Botan::Device_EntropySource Class Reference

#include <dev_random.h>

Inheritance diagram for Botan::Device_EntropySource:

Public Member Functions
	Device_EntropySource (const std::vector< std::string > &fsnames)
std::string	name () const override
size_t	poll (RandomNumberGenerator &rng) override
	~Device_EntropySource ()

Static Public Member Functions
static std::unique_ptr< Entropy_Source >	create (const std::string &type)

Detailed Description

Entropy source reading from kernel devices like /dev/random

Definition at line 20 of file dev_random.h.

Constructor & Destructor Documentation

Device_EntropySource()

Botan::Device_EntropySource::Device_EntropySource ( const std::vector< std::string > &  fsnames )

explicit

Device_EntropySource constructor Open a file descriptor to each (available) device in fsnames

Definition at line 24 of file dev_random.cpp.

References Botan::PKCS11::flags(), O_NOCTTY, O_NONBLOCK, and Botan::ASN1::to_string().

   {
#ifndef O_NONBLOCK
  #define O_NONBLOCK 0
#endif

#ifndef O_NOCTTY
  #define O_NOCTTY 0
#endif

   const int flags = O_RDONLY | O_NONBLOCK | O_NOCTTY;

   m_max_fd = 0;

   for(auto fsname : fsnames)
      {
      int fd = ::open(fsname.c_str(), flags);

      if(fd < 0)
         {
         /*
         ENOENT or EACCES is normal as some of the named devices may not exist
         on this system. But any other errno value probably indicates
         either a bug in the application or file descriptor exhaustion.
         */
         if(errno != ENOENT && errno != EACCES)
            throw Exception("Opening OS RNG device failed with errno " +
                            std::to_string(errno));
         }
      else
         {
         if(fd > FD_SETSIZE)
            {
            ::close(fd);
            throw Exception("Open of OS RNG succeeded but fd is too large for fd_set");
            }

         m_dev_fds.push_back(fd);
         m_max_fd = std::max(m_max_fd, fd);
         }
      }
   }

~Device_EntropySource()

Botan::Device_EntropySource::~Device_EntropySource

(

)

Device_EntropySource destructor: close all open devices

Definition at line 70 of file dev_random.cpp.

   {
   for(int fd : m_dev_fds)
      {
      // ignoring return value here, can't throw in destructor anyway
      ::close(fd);
      }
   }

Member Function Documentation

create()

std::unique_ptr< Entropy_Source > Botan::Entropy_Source::create ( const std::string &  type )

staticinherited

Return a new entropy source of a particular type, or null Each entropy source may require substantial resources (eg, a file handle or socket instance), so try to share them among multiple RNGs, or just use the preconfigured global list accessed by Entropy_Sources::global_sources()

Definition at line 66 of file entropy_srcs.cpp.

References BOTAN_UNUSED, and Botan::Entropy_Source::name().

Referenced by Botan::Entropy_Sources::Entropy_Sources().

   {
#if defined(BOTAN_HAS_SYSTEM_RNG)
   if(name == "system_rng" || name == "win32_cryptoapi")
      {
      return std::unique_ptr<Entropy_Source>(new System_RNG_EntropySource);
      }
#endif

#if defined(BOTAN_HAS_ENTROPY_SRC_RDRAND)
   if(name == "rdrand")
      {
      return std::unique_ptr<Entropy_Source>(new Intel_Rdrand);
      }
#endif

#if defined(BOTAN_HAS_ENTROPY_SRC_RDSEED)
   if(name == "rdseed")
      {
      return std::unique_ptr<Entropy_Source>(new Intel_Rdseed);
      }
#endif

#if defined(BOTAN_HAS_ENTROPY_SRC_DARWIN_SECRANDOM)
   if(name == "darwin_secrandom")
      {
      return std::unique_ptr<Entropy_Source>(new Darwin_SecRandom);
      }
#endif

#if defined(BOTAN_HAS_ENTROPY_SRC_GETENTROPY)
   if(name == "getentropy")
      {
      return std::unique_ptr<Entropy_Source>(new Getentropy);
      }
#endif

#if defined(BOTAN_HAS_ENTROPY_SRC_DEV_RANDOM)
   if(name == "dev_random")
      {
      return std::unique_ptr<Entropy_Source>(new Device_EntropySource(BOTAN_SYSTEM_RNG_POLL_DEVICES));
      }
#endif

#if defined(BOTAN_HAS_ENTROPY_SRC_PROC_WALKER)
   if(name == "proc_walk")
      {
      const std::string root_dir = BOTAN_ENTROPY_PROC_FS_PATH;
      if(!root_dir.empty())
         return std::unique_ptr<Entropy_Source>(new ProcWalking_EntropySource(root_dir));
      }
#endif

#if defined(BOTAN_HAS_ENTROPY_SRC_WIN32)
   if(name == "system_stats")
      {
      return std::unique_ptr<Entropy_Source>(new Win32_EntropySource);
      }
#endif

   BOTAN_UNUSED(name);
   return std::unique_ptr<Entropy_Source>();
   }

name()

std::string Botan::Device_EntropySource::name ( ) const

inlineoverridevirtual

Returns

name identifying this entropy source

Implements Botan::Entropy_Source.

Definition at line 23 of file dev_random.h.

{ return "dev_random"; }

poll()

size_t Botan::Device_EntropySource::poll ( RandomNumberGenerator &  rng )

overridevirtual

Gather entropy from a RNG device

Implements Botan::Entropy_Source.

Definition at line 82 of file dev_random.cpp.

References Botan::RandomNumberGenerator::add_entropy(), and Botan::CT::select().

   {
   size_t bits = 0;

   if(m_dev_fds.size() > 0)
      {
      fd_set read_set;
      FD_ZERO(&read_set);

      for(int dev_fd : m_dev_fds)
         {
         FD_SET(dev_fd, &read_set);
         }

      secure_vector<uint8_t> io_buf(BOTAN_SYSTEM_RNG_POLL_REQUEST);

      struct ::timeval timeout;
      timeout.tv_sec = (BOTAN_SYSTEM_RNG_POLL_TIMEOUT_MS / 1000);
      timeout.tv_usec = (BOTAN_SYSTEM_RNG_POLL_TIMEOUT_MS % 1000) * 1000;

      if(::select(m_max_fd + 1, &read_set, nullptr, nullptr, &timeout) > 0)
         {
         for(int dev_fd : m_dev_fds)
            {
            if(FD_ISSET(dev_fd, &read_set))
               {
               const ssize_t got = ::read(dev_fd, io_buf.data(), io_buf.size());

               if(got > 0)
                  {
                  rng.add_entropy(io_buf.data(), static_cast<size_t>(got));
                  bits += got * 8;
                  }
               }
            }
         }
      }

   return bits;
   }

---

The documentation for this class was generated from the following files:

• src/lib/entropy/dev_random/dev_random.h
• src/lib/entropy/dev_random/dev_random.cpp