diff options
Diffstat (limited to 'src')
32 files changed, 674 insertions, 848 deletions
diff --git a/src/entropy/beos_stats/es_beos.cpp b/src/entropy/beos_stats/es_beos.cpp index b5a5e7fee..02a751e6a 100644 --- a/src/entropy/beos_stats/es_beos.cpp +++ b/src/entropy/beos_stats/es_beos.cpp @@ -4,7 +4,6 @@ */ #include <botan/es_beos.h> -#include <botan/xor_buf.h> #include <kernel/OS.h> #include <kernel/image.h> @@ -13,69 +12,52 @@ namespace Botan { /** -* BeOS Fast Poll +* BeOS entropy poll */ -u32bit BeOS_EntropySource::fast_poll(byte buf[], u32bit length) +void BeOS_EntropySource::poll(Entropy_Accumulator& accum) { - if(length == 0) - return 0; - length = std::min<u32bit>(length, 32); - - u32bit buf_i = 0; - system_info info_sys; get_system_info(&info_sys); - buf_i = xor_into_buf(buf, buf_i, length, info_sys); + accum.add(info_sys, 2); - key_info info_key; + key_info info_key; // current state of the keyboard get_key_info(&info_key); - buf_i = xor_into_buf(buf, buf_i, length, key_info); - - buf_i = xor_into_buf(buf, buf_i, length, idle_time()); - - return length; - } + accum.add(info_key, 0); -/** -* BeOS slow poll -*/ -u32bit BeOS_EntropySource::slow_poll(byte buf[], u32bit length) - { - if(length == 0) - return 0; + accum.add(idle_time(), 0); - u32bit buf_i = 0; team_info info_team; int32 cookie_team = 0; while(get_next_team_info(&cookie_team, &info_team) == B_OK) { - buf_i = xor_into_buf(buf, buf_i, length, info_team); + accum.add(info_team, 2); team_id id = info_team.team; int32 cookie = 0; thread_info info_thr; while(get_next_thread_info(id, &cookie, &info_thr) == B_OK) - buf_i = xor_into_buf(buf, buf_i, length, info_thr); + accum.add(info_thr, 1); cookie = 0; image_info info_img; while(get_next_image_info(id, &cookie, &info_img) == B_OK) - buf_i = xor_into_buf(buf, buf_i, length, info_img); + accum.add(info_img, 1); cookie = 0; sem_info info_sem; while(get_next_sem_info(id, &cookie, &info_sem) == B_OK) - buf_i = xor_into_buf(buf, buf_i, length, info_sem); + accum.add(info_sem, 1); cookie = 0; area_info info_area; while(get_next_area_info(id, &cookie, &info_area) == B_OK) - buf_i = xor_into_buf(buf, buf_i, length, info_area); - } + accum.add(info_area, 2); - return length; + if(accum.polling_goal_achieved()) + break; + } } } diff --git a/src/entropy/beos_stats/es_beos.h b/src/entropy/beos_stats/es_beos.h index 686ac5c38..0ae670e94 100644 --- a/src/entropy/beos_stats/es_beos.h +++ b/src/entropy/beos_stats/es_beos.h @@ -18,8 +18,7 @@ class BOTAN_DLL BeOS_EntropySource : public EntropySource private: std::string name() const { return "BeOS Statistics"; } - u32bit fast_poll(byte buf[], u32bit length); - u32bit slow_poll(byte buf[], u32bit length); + void poll(Entropy_Accumulator& accum); }; } diff --git a/src/entropy/cryptoapi_rng/es_capi.cpp b/src/entropy/cryptoapi_rng/es_capi.cpp index ca0e1b95e..7cc4d015b 100644 --- a/src/entropy/cryptoapi_rng/es_capi.cpp +++ b/src/entropy/cryptoapi_rng/es_capi.cpp @@ -1,7 +1,7 @@ -/************************************************* -* Win32 CryptoAPI EntropySource Source File * -* (C) 1999-2007 Jack Lloyd * -*************************************************/ +/* +* Win32 CryptoAPI EntropySource +* (C) 1999-2009 Jack Lloyd +*/ #include <botan/es_capi.h> #include <botan/parsing.h> @@ -10,71 +10,68 @@ namespace Botan { -/** -* Gather Entropy from Win32 CAPI -*/ -u32bit Win32_CAPI_EntropySource::slow_poll(byte output[], u32bit length) +namespace { + +class CSP_Handle { - return fast_poll(output, length); - } + public: + CSP_Handle(u64bit capi_provider) + { + valid = false; + DWORD prov_type = (DWORD)capi_provider; + + if(CryptAcquireContext(&handle, 0, 0, + prov_type, CRYPT_VERIFYCONTEXT)) + valid = true; + } + + ~CSP_Handle() + { + if(is_valid()) + CryptReleaseContext(handle, 0); + } + + u32bit gen_random(byte out[], u32bit n) const + { + if(is_valid() && CryptGenRandom(handle, n, out)) + return n; + return 0; + } + + bool is_valid() const { return valid; } + + HCRYPTPROV get_handle() const { return handle; } + private: + HCRYPTPROV handle; + bool valid; + }; + +} /** * Gather Entropy from Win32 CAPI */ -u32bit Win32_CAPI_EntropySource::fast_poll(byte output[], u32bit length) +void Win32_CAPI_EntropySource::poll(Entropy_Accumulator& accum) { - class CSP_Handle - { - public: - CSP_Handle(u64bit capi_provider) - { - valid = false; - DWORD prov_type = (DWORD)capi_provider; - - if(CryptAcquireContext(&handle, 0, 0, - prov_type, CRYPT_VERIFYCONTEXT)) - valid = true; - } - - ~CSP_Handle() - { - if(is_valid()) - CryptReleaseContext(handle, 0); - } - - void gen_random(byte out[], u32bit n) const - { - if(is_valid()) - CryptGenRandom(handle, n, out); - } - - bool is_valid() const { return valid; } - - HCRYPTPROV get_handle() const { return handle; } - private: - HCRYPTPROV handle; - bool valid; - }; - - - if(length > 64) - length = 64; + MemoryRegion<byte>& io_buffer = accum.get_io_buffer(32); for(u32bit j = 0; j != prov_types.size(); ++j) { CSP_Handle csp(prov_types[j]); - if(!csp.is_valid()) - continue; - csp.gen_random(output, length); - break; + u32bit got = csp.gen_random(io_buffer.begin(), io_buffer.length()); + + if(got) + { + accum.add(io_buffer.begin(), io_buffer.length(), 8); + break; + } } - return length; } -/************************************************* -* Gather Entropy from Win32 CAPI * -*************************************************/ +/** +* Win32_Capi_Entropysource Constructor +*/ Win32_CAPI_EntropySource::Win32_CAPI_EntropySource(const std::string& provs) { std::vector<std::string> capi_provs = split_on(provs, ':'); diff --git a/src/entropy/cryptoapi_rng/es_capi.h b/src/entropy/cryptoapi_rng/es_capi.h index b8bbb7507..d727de5dd 100644 --- a/src/entropy/cryptoapi_rng/es_capi.h +++ b/src/entropy/cryptoapi_rng/es_capi.h @@ -11,16 +11,15 @@ namespace Botan { -/************************************************* -* Win32 CAPI Entropy Source * -*************************************************/ +/** +* Win32 CAPI Entropy Source +*/ class BOTAN_DLL Win32_CAPI_EntropySource : public EntropySource { public: std::string name() const { return "Win32 CryptoGenRandom"; } - u32bit fast_poll(byte[], u32bit); - u32bit slow_poll(byte[], u32bit); + void poll(Entropy_Accumulator& accum); Win32_CAPI_EntropySource(const std::string& = ""); private: diff --git a/src/entropy/dev_random/es_dev.cpp b/src/entropy/dev_random/es_dev.cpp index 7b936dbaa..89f981373 100644 --- a/src/entropy/dev_random/es_dev.cpp +++ b/src/entropy/dev_random/es_dev.cpp @@ -1,7 +1,7 @@ -/************************************************* -* Device EntropySource Source File * -* (C) 1999-2008 Jack Lloyd * -*************************************************/ +/* +* /dev/random EntropySource +* (C) 1999-2009 Jack Lloyd +*/ #include <botan/es_dev.h> @@ -51,12 +51,7 @@ u32bit Device_EntropySource::Device_Reader::get(byte out[], u32bit length, if(got <= 0) return 0; - const u32bit ret = static_cast<u32bit>(got); - - if(ret > length) - return 0; - - return ret; + return static_cast<u32bit>(got); } /** @@ -79,6 +74,7 @@ Device_EntropySource::Device_Reader::open(const std::string& pathname) /** Device_EntropySource constructor +Open a file descriptor to each (available) device in fsnames */ Device_EntropySource::Device_EntropySource( const std::vector<std::string>& fsnames) @@ -92,41 +88,36 @@ Device_EntropySource::Device_EntropySource( } /** -* Gather entropy from a RNG device +Device_EntropySource destructor: close all open devices */ -u32bit Device_EntropySource::slow_poll(byte output[], u32bit length) +Device_EntropySource::~Device_EntropySource() { for(size_t i = 0; i != devices.size(); ++i) - { - const u32bit got = devices[i].get(output, length, 20); - - if(got) - return got; - } - - return 0; + devices[i].close(); } /** -* Fast poll: try limit to 10 ms wait +* Gather entropy from a RNG device */ -u32bit Device_EntropySource::fast_poll(byte output[], u32bit length) +void Device_EntropySource::poll(Entropy_Accumulator& accum) { + u32bit go_get = std::min<u32bit>(accum.desired_remaining_bits() / 8, 16); + + u32bit read_wait_ms = go_get / 16; + + MemoryRegion<byte>& io_buffer = accum.get_io_buffer(go_get); + for(size_t i = 0; i != devices.size(); ++i) { - const u32bit got = devices[i].get(output, length, 5); + u32bit got = devices[i].get(io_buffer.begin(), io_buffer.size(), + read_wait_ms); if(got) - return got; + { + accum.add(io_buffer.begin(), got, 8); + break; + } } - - return 0; - } - -Device_EntropySource::~Device_EntropySource() - { - for(size_t i = 0; i != devices.size(); ++i) - devices[i].close(); } } diff --git a/src/entropy/dev_random/es_dev.h b/src/entropy/dev_random/es_dev.h index db64b75fa..139f8ec52 100644 --- a/src/entropy/dev_random/es_dev.h +++ b/src/entropy/dev_random/es_dev.h @@ -1,7 +1,7 @@ -/************************************************* -* Device EntropySource Header File * -* (C) 1999-2007 Jack Lloyd * -*************************************************/ +/* +* /dev/random EntropySource +* (C) 1999-2009 Jack Lloyd +*/ #ifndef BOTAN_ENTROPY_SRC_DEVICE_H__ #define BOTAN_ENTROPY_SRC_DEVICE_H__ @@ -12,19 +12,15 @@ namespace Botan { -/************************************************* -* Device Based Entropy Source * -*************************************************/ class BOTAN_DLL Device_EntropySource : public EntropySource { public: std::string name() const { return "RNG Device Reader"; } + void poll(Entropy_Accumulator& accum); + Device_EntropySource(const std::vector<std::string>& fsnames); ~Device_EntropySource(); - - u32bit slow_poll(byte[], u32bit); - u32bit fast_poll(byte[], u32bit); private: /** diff --git a/src/entropy/egd/es_egd.cpp b/src/entropy/egd/es_egd.cpp index 84773c215..17e366f2b 100644 --- a/src/entropy/egd/es_egd.cpp +++ b/src/entropy/egd/es_egd.cpp @@ -1,6 +1,6 @@ -/** +/* * EGD EntropySource Source File -* (C) 1999-2008 Jack Lloyd +* (C) 1999-2009 Jack Lloyd */ #include <botan/es_egd.h> @@ -8,6 +8,7 @@ #include <botan/parsing.h> #include <botan/exceptn.h> #include <cstring> +#include <stdexcept> #include <sys/types.h> #include <sys/stat.h> @@ -23,28 +24,86 @@ namespace Botan { -EGD_EntropySource::EGD_Socket::EGD_Socket(const std::string& path) +EGD_EntropySource::EGD_Socket::EGD_Socket(const std::string& path) : + socket_path(path), m_fd(-1) { - m_fd = ::socket(PF_LOCAL, SOCK_STREAM, 0); + } - if(m_fd > 0) +/** +* Attempt a connection to an EGD/PRNGD socket +*/ +int EGD_EntropySource::EGD_Socket::open_socket(const std::string& path) + { + int fd = ::socket(PF_LOCAL, SOCK_STREAM, 0); + + if(fd >= 0) { sockaddr_un addr; std::memset(&addr, 0, sizeof(addr)); addr.sun_family = PF_LOCAL; if(sizeof(addr.sun_path) < path.length() + 1) - throw Exception("EGD_EntropySource: Socket path is too long"); + throw std::invalid_argument("EGD socket path is too long"); + std::strcpy(addr.sun_path, path.c_str()); int len = sizeof(addr.sun_family) + std::strlen(addr.sun_path) + 1; - if(::connect(m_fd, reinterpret_cast<struct ::sockaddr*>(&addr), len) < 0) + if(::connect(fd, reinterpret_cast<struct ::sockaddr*>(&addr), len) < 0) { - ::close(m_fd); - m_fd = -1; + ::close(fd); + fd = -1; } } + + return fd; + } + +/** +* Attempt to read entropy from EGD +*/ +u32bit EGD_EntropySource::EGD_Socket::read(byte outbuf[], u32bit length) + { + if(length == 0) + return 0; + + if(m_fd < 0) + { + m_fd = open_socket(socket_path); + if(m_fd < 0) + return 0; + } + + try + { + // 1 == EGD command for non-blocking read + byte egd_read_command[2] = { + 1, static_cast<byte>(std::min<u32bit>(length, 255)) }; + + if(::write(m_fd, egd_read_command, 2) != 2) + throw std::runtime_error("Writing entropy read command to EGD failed"); + + byte out_len = 0; + if(::read(m_fd, &out_len, 1) != 1) + throw std::runtime_error("Reading response length from EGD failed"); + + if(out_len > egd_read_command[1]) + throw std::runtime_error("Bogus length field recieved from EGD"); + + ssize_t count = ::read(m_fd, outbuf, out_len); + + if(count != out_len) + throw std::runtime_error("Reading entropy result from EGD failed"); + + return static_cast<u32bit>(count); + } + catch(std::exception& e) + { + this->close(); + // Will attempt to reopen next poll + } + + return 0; } void EGD_EntropySource::EGD_Socket::close() @@ -62,12 +121,7 @@ void EGD_EntropySource::EGD_Socket::close() EGD_EntropySource::EGD_EntropySource(const std::vector<std::string>& paths) { for(size_t i = 0; i != paths.size(); ++i) - { - EGD_Socket sock(paths[i]); - - if(sock.fd() != -1) - sockets.push_back(sock); - } + sockets.push_back(EGD_Socket(paths[i])); } EGD_EntropySource::~EGD_EntropySource() @@ -80,46 +134,22 @@ EGD_EntropySource::~EGD_EntropySource() /** * Gather Entropy from EGD */ -u32bit EGD_EntropySource::slow_poll(byte output[], u32bit length) +void EGD_EntropySource::poll(Entropy_Accumulator& accum) { - if(length > 128) - length = 128; + u32bit go_get = std::min<u32bit>(accum.desired_remaining_bits() / 8, 32); + + MemoryRegion<byte>& io_buffer = accum.get_io_buffer(go_get); for(size_t i = 0; i != sockets.size(); ++i) { - EGD_Socket& socket = sockets[i]; + u32bit got = sockets[i].read(io_buffer.begin(), io_buffer.size()); - byte buffer[2]; - buffer[0] = 1; - buffer[1] = static_cast<byte>(length); - - if(::write(socket.fd(), buffer, 2) != 2) - return 0; - - byte out_len = 0; - if(::read(socket.fd(), &out_len, 1) != 1) - return 0; - - if(out_len > length) - return 0; - - ssize_t count = ::read(socket.fd(), output, out_len); - - if(count < 0) - return 0; - - return static_cast<u32bit>(count); + if(got) + { + accum.add(io_buffer.begin(), got, 8); + break; + } } - - return 0; - } - -/** -* Gather Entropy from EGD, limiting to 64 bytes -*/ -u32bit EGD_EntropySource::fast_poll(byte output[], u32bit length) - { - return slow_poll(output, std::min<u32bit>(length, 64)); } } diff --git a/src/entropy/egd/es_egd.h b/src/entropy/egd/es_egd.h index de80374cc..5fb09fc57 100644 --- a/src/entropy/egd/es_egd.h +++ b/src/entropy/egd/es_egd.h @@ -20,8 +20,7 @@ class BOTAN_DLL EGD_EntropySource : public EntropySource public: std::string name() const { return "EGD/PRNGD"; } - u32bit fast_poll(byte[], u32bit); - u32bit slow_poll(byte[], u32bit); + void poll(Entropy_Accumulator& accum); EGD_EntropySource(const std::vector<std::string>&); ~EGD_EntropySource(); @@ -32,9 +31,12 @@ class BOTAN_DLL EGD_EntropySource : public EntropySource EGD_Socket(const std::string& path); void close(); - int fd() const { return m_fd; } + u32bit read(byte outbuf[], u32bit length); private: - int m_fd; + static int open_socket(const std::string& path); + + std::string socket_path; + int m_fd; // cached fd }; std::vector<EGD_Socket> sockets; diff --git a/src/entropy/entropy_src.h b/src/entropy/entropy_src.h index 0891e393f..3fd5c443e 100644 --- a/src/entropy/entropy_src.h +++ b/src/entropy/entropy_src.h @@ -1,26 +1,90 @@ -/************************************************* -* EntropySource Header File * -* (C) 2008 Jack Lloyd * -*************************************************/ +/** +* EntropySource Header File +* (C) 2008-2009 Jack Lloyd +*/ #ifndef BOTAN_ENTROPY_SOURCE_BASE_H__ #define BOTAN_ENTROPY_SOURCE_BASE_H__ -#include <botan/types.h> +#include <botan/buf_comp.h> #include <string> +#include <utility> namespace Botan { /** +* Class used to accumulate the poll results of EntropySources +*/ +class Entropy_Accumulator + { + public: + Entropy_Accumulator(u32bit goal) : + entropy_goal(goal), collected_bits(0) {} + + virtual ~Entropy_Accumulator() {} + + /** + @return cached I/O buffer for repeated polls + */ + MemoryRegion<byte>& get_io_buffer(u32bit size) + { io_buffer.create(size); return io_buffer; } + + u32bit bits_collected() const + { return static_cast<u32bit>(collected_bits); } + + bool polling_goal_achieved() const + { return (collected_bits >= entropy_goal); } + + u32bit desired_remaining_bits() const + { + if(collected_bits >= entropy_goal) + return 0; + return (entropy_goal - collected_bits); + } + + void add(const void* bytes, u32bit length, double entropy_bits_per_byte) + { + add_bytes(bytes, length); + collected_bits += entropy_bits_per_byte * length; + } + + template<typename T> + void add(const T& v, double entropy_bits_per_byte) + { + add(&v, sizeof(T), entropy_bits_per_byte); + } + private: + virtual void add_bytes(const void* bytes, u32bit length) = 0; + + SecureVector<byte> io_buffer; + u32bit entropy_goal; + double collected_bits; + }; + +class Entropy_Accumulator_BufferedComputation : public Entropy_Accumulator + { + public: + Entropy_Accumulator_BufferedComputation(BufferedComputation& sink, + u32bit goal) : + Entropy_Accumulator(goal), entropy_sink(sink) {} + + private: + virtual void add_bytes(const void* bytes, u32bit length) + { + entropy_sink.update(reinterpret_cast<const byte*>(bytes), length); + } + + BufferedComputation& entropy_sink; + }; + +/** * Abstract interface to a source of (hopefully unpredictable) system entropy */ class BOTAN_DLL EntropySource { public: virtual std::string name() const = 0; - - virtual u32bit slow_poll(byte buf[], u32bit len) = 0; - virtual u32bit fast_poll(byte buf[], u32bit len) = 0; + virtual void poll(Entropy_Accumulator& accum) = 0; virtual ~EntropySource() {} }; diff --git a/src/entropy/proc_walk/es_ftw.cpp b/src/entropy/proc_walk/es_ftw.cpp index 1ad6c56b6..55f26fa73 100644 --- a/src/entropy/proc_walk/es_ftw.cpp +++ b/src/entropy/proc_walk/es_ftw.cpp @@ -5,7 +5,6 @@ #include <botan/es_ftw.h> #include <botan/secmem.h> -#include <botan/xor_buf.h> #include <cstring> #include <deque> @@ -110,49 +109,36 @@ FTW_EntropySource::~FTW_EntropySource() delete dir; } -u32bit FTW_EntropySource::slow_poll(byte buf[], u32bit length) +void FTW_EntropySource::poll(Entropy_Accumulator& accum) { + const u32bit MAX_FILES_READ_PER_POLL = 1024; + if(!dir) dir = new Directory_Walker(path); - SecureVector<byte> read_buf(4096); - - u32bit bytes_read = 0; - u32bit buf_i = 0; + MemoryRegion<byte>& io_buffer = accum.get_io_buffer(2048); - while(bytes_read < length * 32) + for(u32bit i = 0; i != MAX_FILES_READ_PER_POLL; ++i) { int fd = dir->next_fd(); - if(fd == -1) // re-walk + // If we've exhaused this walk of the directory, halt the poll + if(fd == -1) { delete dir; - dir = new Directory_Walker(path); - fd = dir->next_fd(); - - if(fd == -1) // still fails (directory not mounted, etc) -> fail - return 0; + dir = 0; + break; } - ssize_t got = ::read(fd, read_buf.begin(), read_buf.size()); + ssize_t got = ::read(fd, io_buffer.begin(), io_buffer.size()); + ::close(fd); if(got > 0) - { - buf_i = xor_into_buf(buf, buf_i, length, read_buf, got); - - // never count any one file for more than 128 bytes - bytes_read += std::min<u32bit>(got, 128); - } + accum.add(io_buffer.begin(), got, .01); - ::close(fd); + if(accum.polling_goal_achieved()) + break; } - - return length; - } - -u32bit FTW_EntropySource::fast_poll(byte[], u32bit) - { - return 0; // no op } } diff --git a/src/entropy/proc_walk/es_ftw.h b/src/entropy/proc_walk/es_ftw.h index 5b127943f..a764462c6 100644 --- a/src/entropy/proc_walk/es_ftw.h +++ b/src/entropy/proc_walk/es_ftw.h @@ -10,16 +10,15 @@ namespace Botan { -/************************************************* -* File Tree Walking Entropy Source * -*************************************************/ +/** +* File Tree Walking Entropy Source +*/ class BOTAN_DLL FTW_EntropySource : public EntropySource { public: std::string name() const { return "Proc Walker"; } - u32bit slow_poll(byte buf[], u32bit len); - u32bit fast_poll(byte buf[], u32bit len); + void poll(Entropy_Accumulator& accum); FTW_EntropySource(const std::string& root_dir); ~FTW_EntropySource(); diff --git a/src/entropy/unix_procs/es_unix.cpp b/src/entropy/unix_procs/es_unix.cpp index 124a08da7..3ac8cd8d3 100644 --- a/src/entropy/unix_procs/es_unix.cpp +++ b/src/entropy/unix_procs/es_unix.cpp @@ -1,12 +1,11 @@ -/************************************************* -* Unix EntropySource Source File * -* (C) 1999-2008 Jack Lloyd * -*************************************************/ +/* +* Unix EntropySource Source File +* (C) 1999-2009 Jack Lloyd +*/ #include <botan/es_unix.h> #include <botan/unix_cmd.h> #include <botan/parsing.h> -#include <botan/xor_buf.h> #include <algorithm> #include <sys/time.h> #include <sys/stat.h> @@ -17,43 +16,40 @@ namespace Botan { namespace { -/************************************************* -* Sort ordering by priority * -*************************************************/ +/** +* Sort ordering by priority +*/ bool Unix_Program_Cmp(const Unix_Program& a, const Unix_Program& b) { return (a.priority < b.priority); } } -/************************************************* -* Unix_EntropySource Constructor * -*************************************************/ +/** +* Unix_EntropySource Constructor +*/ Unix_EntropySource::Unix_EntropySource(const std::vector<std::string>& path) : PATH(path) { add_default_sources(sources); } -/************************************************* -* Add sources to the list * -*************************************************/ +/** +* Add sources to the list +*/ void Unix_EntropySource::add_sources(const Unix_Program srcs[], u32bit count) { sources.insert(sources.end(), srcs, srcs + count); std::sort(sources.begin(), sources.end(), Unix_Program_Cmp); } -/************************************************* -* Unix Fast Poll * -*************************************************/ -u32bit Unix_EntropySource::fast_poll(byte buf[], u32bit length) +/** +* Poll for entropy on a generic Unix system, first by grabbing various +* statistics (stat on common files, getrusage, etc), and then, if more +* is required, by exec'ing various programs like uname and rpcinfo and +* reading the output. +*/ +void Unix_EntropySource::poll(Entropy_Accumulator& accum) { - if(length == 0) - return 0; - length = std::min<u32bit>(length, 32); - - u32bit buf_i = 0; - const char* stat_targets[] = { "/", "/tmp", @@ -70,67 +66,50 @@ u32bit Unix_EntropySource::fast_poll(byte buf[], u32bit length) struct stat statbuf; clear_mem(&statbuf, 1); ::stat(stat_targets[j], &statbuf); - buf_i = xor_into_buf(buf, buf_i, length, statbuf); + accum.add(&statbuf, sizeof(statbuf), .05); } - u32bit ids[] = { - ::getpid(), - ::getppid(), - ::getuid(), - ::geteuid(), - ::getegid(), - ::getpgrp(), - ::getsid(0) - }; - - for(u32bit i = 0; i != sizeof(ids) / sizeof(ids[0]); ++i) - buf_i = xor_into_buf(buf, buf_i, length, ids[i]); + accum.add(::getpid(), 0); + accum.add(::getppid(), 0); + accum.add(::getuid(), 0); + accum.add(::geteuid(), 0); + accum.add(::getegid(), 0); + accum.add(::getpgrp(), 0); + accum.add(::getsid(0), 0); struct ::rusage usage; ::getrusage(RUSAGE_SELF, &usage); - buf_i = xor_into_buf(buf, buf_i, length, usage); + accum.add(usage, .05); ::getrusage(RUSAGE_CHILDREN, &usage); - buf_i = xor_into_buf(buf, buf_i, length, usage); - - return length; - } + accum.add(usage, .05); -/************************************************* -* Unix Slow Poll * -*************************************************/ -u32bit Unix_EntropySource::slow_poll(byte buf[], u32bit length) - { - if(length == 0) - return 0; + if(accum.desired_remaining_bits() < 128) + return; - const u32bit MINIMAL_WORKING = 32; + const u32bit MINIMAL_WORKING = 16; - u32bit total_got = 0; - u32bit buf_i = 0; + MemoryRegion<byte>& io_buffer = accum.get_io_buffer(DEFAULT_BUFFERSIZE); for(u32bit j = 0; j != sources.size(); j++) { DataSource_Command pipe(sources[j].name_and_args, PATH); - SecureVector<byte> buffer(DEFAULT_BUFFERSIZE); u32bit got_from_src = 0; while(!pipe.end_of_data()) { - u32bit this_loop = pipe.read(buffer, buffer.size()); - buf_i = xor_into_buf(buf, buf_i, length, buffer, this_loop); - got_from_src += this_loop; + u32bit got_this_loop = pipe.read(io_buffer, io_buffer.size()); + got_from_src += got_this_loop; + + accum.add(io_buffer.begin(), got_this_loop, .005); } sources[j].working = (got_from_src >= MINIMAL_WORKING) ? true : false; - total_got += got_from_src; - if(total_got >= 128*length) + if(accum.polling_goal_achieved()) break; } - - return length; } } diff --git a/src/entropy/unix_procs/es_unix.h b/src/entropy/unix_procs/es_unix.h index f4af255ca..ba3fd51c2 100644 --- a/src/entropy/unix_procs/es_unix.h +++ b/src/entropy/unix_procs/es_unix.h @@ -1,7 +1,7 @@ -/************************************************* -* Unix EntropySource Header File * -* (C) 1999-2007 Jack Lloyd * -*************************************************/ +/* +* Unix EntropySource Header File +* (C) 1999-2009 Jack Lloyd +*/ #ifndef BOTAN_ENTROPY_SRC_UNIX_H__ #define BOTAN_ENTROPY_SRC_UNIX_H__ @@ -12,21 +12,21 @@ namespace Botan { -/************************************************* -* Unix Entropy Source * -*************************************************/ +/** +* Unix Entropy Source +*/ class BOTAN_DLL Unix_EntropySource : public EntropySource { public: std::string name() const { return "Unix Entropy Source"; } + void poll(Entropy_Accumulator& accum); + void add_sources(const Unix_Program[], u32bit); Unix_EntropySource(const std::vector<std::string>& path); private: static void add_default_sources(std::vector<Unix_Program>&); - - u32bit fast_poll(byte buf[], u32bit length); - u32bit slow_poll(byte buf[], u32bit length); + void fast_poll(Entropy_Accumulator& accum); const std::vector<std::string> PATH; std::vector<Unix_Program> sources; diff --git a/src/entropy/unix_procs/unix_cmd.cpp b/src/entropy/unix_procs/unix_cmd.cpp index 4c7f674db..b9558b35c 100644 --- a/src/entropy/unix_procs/unix_cmd.cpp +++ b/src/entropy/unix_procs/unix_cmd.cpp @@ -1,7 +1,7 @@ -/************************************************* -* Unix Command Execution Source File * -* (C) 1999-2007 Jack Lloyd * -*************************************************/ +/* +* Unix Command Execution Source File +* (C) 1999-2007 Jack Lloyd +*/ #include <botan/unix_cmd.h> #include <botan/parsing.h> @@ -18,9 +18,9 @@ namespace Botan { namespace { -/************************************************* -* Attempt to execute the command * -************************************************/ +/** +* Attempt to execute the command +*/ void do_exec(const std::vector<std::string>& arg_list, const std::vector<std::string>& paths) { @@ -41,9 +41,9 @@ void do_exec(const std::vector<std::string>& arg_list, } -/************************************************* -* Local information about the pipe * -*************************************************/ +/** +* Local information about the pipe +*/ struct pipe_wrapper { int fd; @@ -51,9 +51,9 @@ struct pipe_wrapper pipe_wrapper() { fd = -1; pid = 0; } }; -/************************************************* -* Read from the pipe * -*************************************************/ +/** +* Read from the pipe +*/ u32bit DataSource_Command::read(byte buf[], u32bit length) { if(end_of_data()) @@ -83,9 +83,9 @@ u32bit DataSource_Command::read(byte buf[], u32bit length) return static_cast<u32bit>(got); } -/************************************************* -* Peek at the pipe contents * -*************************************************/ +/** +* Peek at the pipe contents +*/ u32bit DataSource_Command::peek(byte[], u32bit, u32bit) const { if(end_of_data()) @@ -93,17 +93,17 @@ u32bit DataSource_Command::peek(byte[], u32bit, u32bit) const throw Stream_IO_Error("Cannot peek/seek on a command pipe"); } -/************************************************* -* Check if we reached EOF * -*************************************************/ +/** +* Check if we reached EOF +*/ bool DataSource_Command::end_of_data() const { return (pipe) ? false : true; } -/************************************************* -* Return the Unix file descriptor of the pipe * -*************************************************/ +/** +* Return the Unix file descriptor of the pipe +*/ int DataSource_Command::fd() const { if(!pipe) @@ -111,17 +111,17 @@ int DataSource_Command::fd() const return pipe->fd; } -/************************************************* -* Return a human-readable ID for this stream * -*************************************************/ +/** +* Return a human-readable ID for this stream +*/ std::string DataSource_Command::id() const { return "Unix command: " + arg_list[0]; } -/************************************************* -* Create the pipe * -*************************************************/ +/** +* Create the pipe +*/ void DataSource_Command::create_pipe(const std::vector<std::string>& paths) { bool found_something = false; @@ -169,9 +169,9 @@ void DataSource_Command::create_pipe(const std::vector<std::string>& paths) } } -/************************************************* -* Shutdown the pipe * -*************************************************/ +/** +* Shutdown the pipe +*/ void DataSource_Command::shutdown_pipe() { if(pipe) @@ -204,9 +204,9 @@ void DataSource_Command::shutdown_pipe() } } -/************************************************* -* DataSource_Command Constructor * -*************************************************/ +/** +* DataSource_Command Constructor +*/ DataSource_Command::DataSource_Command(const std::string& prog_and_args, const std::vector<std::string>& paths) : MAX_BLOCK_USECS(100000), KILL_WAIT(10000) @@ -222,9 +222,9 @@ DataSource_Command::DataSource_Command(const std::string& prog_and_args, create_pipe(paths); } -/************************************************* -* DataSource_Command Destructor * -*************************************************/ +/** +* DataSource_Command Destructor +*/ DataSource_Command::~DataSource_Command() { if(!end_of_data()) diff --git a/src/entropy/unix_procs/unix_cmd.h b/src/entropy/unix_procs/unix_cmd.h index 8544e7879..66122ea49 100644 --- a/src/entropy/unix_procs/unix_cmd.h +++ b/src/entropy/unix_procs/unix_cmd.h @@ -1,7 +1,7 @@ -/************************************************* -* Unix Command Execution Header File * -* (C) 1999-2007 Jack Lloyd * -*************************************************/ +/** +* Unix Command Execution Header File +* (C) 1999-2007 Jack Lloyd +*/ #ifndef BOTAN_UNIX_CMD_H__ #define BOTAN_UNIX_CMD_H__ @@ -13,9 +13,9 @@ namespace Botan { -/************************************************* -* Unix Program Info * -*************************************************/ +/** +* Unix Program Info +*/ struct Unix_Program { Unix_Program(const char* n, u32bit p) @@ -26,9 +26,9 @@ struct Unix_Program bool working; }; -/************************************************* -* Command Output DataSource * -*************************************************/ +/** +* Command Output DataSource +*/ class BOTAN_DLL DataSource_Command : public DataSource { public: diff --git a/src/entropy/unix_procs/unix_src.cpp b/src/entropy/unix_procs/unix_src.cpp index 9d44dbf4f..5e48ba41d 100644 --- a/src/entropy/unix_procs/unix_src.cpp +++ b/src/entropy/unix_procs/unix_src.cpp @@ -1,15 +1,15 @@ -/************************************************* -* Program List for Unix_EntropySource * -* (C) 1999-2007 Jack Lloyd * -*************************************************/ +/* +* Program List for Unix_EntropySource +* (C) 1999-2007 Jack Lloyd +*/ #include <botan/es_unix.h> namespace Botan { -/************************************************* -* Default Commands for Entropy Gathering * -*************************************************/ +/** +* Default Commands for Entropy Gathering +*/ void Unix_EntropySource::add_default_sources(std::vector<Unix_Program>& srcs) { srcs.push_back(Unix_Program("vmstat", 1)); diff --git a/src/entropy/win32_stats/es_win32.cpp b/src/entropy/win32_stats/es_win32.cpp index a529ccc1a..0c17f7b02 100644 --- a/src/entropy/win32_stats/es_win32.cpp +++ b/src/entropy/win32_stats/es_win32.cpp @@ -1,43 +1,69 @@ /** * Win32 EntropySource Source File -* (C) 1999-2008 Jack Lloyd +* (C) 1999-2009 Jack Lloyd */ #include <botan/es_win32.h> -#include <botan/xor_buf.h> #include <windows.h> #include <tlhelp32.h> namespace Botan { /** -* Win32 slow poll using Tooltip32 +* Win32 poll using stats functions including Tooltip32 */ -u32bit Win32_EntropySource::slow_poll(byte buf[], u32bit length) +void Win32_EntropySource::poll(Entropy_Accumulator& accum) { - if(length == 0) - return 0; + /* + First query a bunch of basic statistical stuff, though + don't count it for much in terms of contributed entropy. + */ + accum.add(GetTickCount(), 0); + accum.add(GetMessagePos(), 0); + accum.add(GetMessageTime(), 0); + accum.add(GetInputState(), 0); + accum.add(GetCurrentProcessId(), 0); + accum.add(GetCurrentThreadId() 0); - const u32bit MAX_ITEMS = length / 4; + SYSTEM_INFO sys_info; + GetSystemInfo(&sys_info); + accum.add(sys_info, 1); + + MEMORYSTATUS mem_info; + GlobalMemoryStatus(&mem_info); + accum.add(mem_info, 1); + + POINT point; + GetCursorPos(&point); + accum.add(point, 1); + + GetCaretPos(&point); + accum.add(point, 1); + + LARGE_INTEGER perf_counter; + QueryPerformanceCounter(&perf_counter); + accum.add(perf_count, 0); - u32bit buf_i = 0; + /* + Now use the Tooltip library to iterate throug various objects on + the system, including processes, threads, and heap objects. + */ HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPALL, 0); #define TOOLHELP32_ITER(DATA_TYPE, FUNC_FIRST, FUNC_NEXT) \ - { \ - u32bit items = 0; \ - DATA_TYPE info; \ - info.dwSize = sizeof(DATA_TYPE); \ - if(FUNC_FIRST(snapshot, &info)) \ + if(!accum.polling_goal_achieved()) \ { \ - do \ + DATA_TYPE info; \ + info.dwSize = sizeof(DATA_TYPE); \ + if(FUNC_FIRST(snapshot, &info)) \ { \ - if(items++ > MAX_ITEMS) break; \ - buf_i = xor_into_buf(buf, buf_i, length, info); \ - } while(FUNC_NEXT(snapshot, &info)); \ - } \ - } + do \ + { \ + accum.add(info, 1); \ + } while(FUNC_NEXT(snapshot, &info)); \ + } \ + } TOOLHELP32_ITER(MODULEENTRY32, Module32First, Module32Next); TOOLHELP32_ITER(PROCESSENTRY32, Process32First, Process32Next); @@ -45,85 +71,46 @@ u32bit Win32_EntropySource::slow_poll(byte buf[], u32bit length) #undef TOOLHELP32_ITER - u32bit heap_lists_found = 0; - HEAPLIST32 heap_list; - heap_list.dwSize = sizeof(HEAPLIST32); - - const u32bit HEAP_LISTS_MAX = 32; - const u32bit HEAP_OBJS_PER_LIST = 128; - if(Heap32ListFirst(snapshot, &heap_list)) + if(!accum.polling_goal_achieved()) { - do - { - buf_i = xor_into_buf(buf, buf_i, length, heap_list); + u32bit heap_lists_found = 0; + HEAPLIST32 heap_list; + heap_list.dwSize = sizeof(HEAPLIST32); - if(heap_lists_found++ > HEAP_LISTS_MAX) - break; + const u32bit HEAP_LISTS_MAX = 32; + const u32bit HEAP_OBJS_PER_LIST = 128; - u32bit heap_objs_found = 0; - HEAPENTRY32 heap_entry; - heap_entry.dwSize = sizeof(HEAPENTRY32); - if(Heap32First(&heap_entry, heap_list.th32ProcessID, - heap_list.th32HeapID)) + if(Heap32ListFirst(snapshot, &heap_list)) + { + do { - do + accum.add(heap_list, 1); + + if(++heap_lists_found > HEAP_LISTS_MAX) + break; + + u32bit heap_objs_found = 0; + HEAPENTRY32 heap_entry; + heap_entry.dwSize = sizeof(HEAPENTRY32); + if(Heap32First(&heap_entry, heap_list.th32ProcessID, + heap_list.th32HeapID)) { - if(heap_objs_found++ > HEAP_OBJS_PER_LIST) - break; - buf_i = xor_into_buf(buf, buf_i, length, heap_entry); - } while(Heap32Next(&heap_entry)); - } - } while(Heap32ListNext(snapshot, &heap_list)); + do + { + if(heap_objs_found++ > HEAP_OBJS_PER_LIST) + break; + accum.add(heap_entry, 1); + } while(Heap32Next(&heap_entry)); + } + + if(accum.polling_goal_achieved()) + break; + + } while(Heap32ListNext(snapshot, &heap_list)); + } } CloseHandle(snapshot); - - return length; - } - -/** -* Win32 fast poll -*/ -u32bit Win32_EntropySource::fast_poll(byte buf[], u32bit length) - { - if(length == 0) - return 0; - length = std::min<u32bit>(length, 32); - - u32bit buf_i = 0; - - u32bit stats[] = { - GetTickCount(), - GetMessagePos(), - GetMessageTime(), - GetInputState(), - GetCurrentProcessId(), - GetCurrentThreadId() - }; - - for(u32bit i = 0; i != sizeof(stats) / sizeof(stats[0]); ++i) - buf_i = xor_into_buf(buf, buf_i, length, stats[i]); - - SYSTEM_INFO sys_info; - GetSystemInfo(&sys_info); - buf_i = xor_into_buf(buf, buf_i, length, sys_info); - - MEMORYSTATUS mem_info; - GlobalMemoryStatus(&mem_info); - buf_i = xor_into_buf(buf, buf_i, length, mem_info); - - POINT point; - GetCursorPos(&point); - buf_i = xor_into_buf(buf, buf_i, length, point); - - GetCaretPos(&point); - buf_i = xor_into_buf(buf, buf_i, length, point); - - LARGE_INTEGER perf_counter; - QueryPerformanceCounter(&perf_counter); - buf_i = xor_into_buf(buf, buf_i, length, perf_counter); - - return length; } } diff --git a/src/entropy/win32_stats/es_win32.h b/src/entropy/win32_stats/es_win32.h index 3124bd414..06e3b88cc 100644 --- a/src/entropy/win32_stats/es_win32.h +++ b/src/entropy/win32_stats/es_win32.h @@ -1,6 +1,6 @@ /** * Win32 EntropySource Header File -* (C) 1999-2008 Jack Lloyd +* (C) 1999-2009 Jack Lloyd */ #ifndef BOTAN_ENTROPY_SRC_WIN32_H__ @@ -17,9 +17,7 @@ class BOTAN_DLL Win32_EntropySource : public EntropySource { public: std::string name() const { return "Win32 Statistics"; } - - u32bit fast_poll(byte buf[], u32bit length); - u32bit slow_poll(byte buf[], u32bit length); + void poll(Entropy_Accumulator& accum); }; } diff --git a/src/rng/auto_rng/auto_rng.cpp b/src/rng/auto_rng/auto_rng.cpp index 845d958e2..620cc1f61 100644 --- a/src/rng/auto_rng/auto_rng.cpp +++ b/src/rng/auto_rng/auto_rng.cpp @@ -76,19 +76,15 @@ namespace { */ void add_entropy_sources(RandomNumberGenerator* rng) { + + // Add a high resolution timer, if available #if defined(BOTAN_HAS_TIMER_HARDWARE) rng->add_entropy_source(new Hardware_Timer); -#endif - -#if defined(BOTAN_HAS_TIMER_POSIX) +#elif defined(BOTAN_HAS_TIMER_POSIX) rng->add_entropy_source(new POSIX_Timer); -#endif - -#if defined(BOTAN_HAS_TIMER_UNIX) +#elif defined(BOTAN_HAS_TIMER_UNIX) rng->add_entropy_source(new Unix_Timer); -#endif - -#if defined(BOTAN_HAS_TIMER_WIN32) +#elif defined(BOTAN_HAS_TIMER_WIN32) rng->add_entropy_source(new Win32_Timer); #endif @@ -114,7 +110,6 @@ void add_entropy_sources(RandomNumberGenerator* rng) rng->add_entropy_source(new FTW_EntropySource("/proc")); #endif - #if defined(BOTAN_HAS_ENTROPY_SRC_WIN32) rng->add_entropy_source(new Win32_EntropySource); #endif @@ -132,7 +127,7 @@ void add_entropy_sources(RandomNumberGenerator* rng) } -AutoSeeded_RNG::AutoSeeded_RNG() +AutoSeeded_RNG::AutoSeeded_RNG(u32bit poll_bits) { rng = 0; @@ -152,7 +147,7 @@ AutoSeeded_RNG::AutoSeeded_RNG() add_entropy_sources(rng); - rng->reseed(); + rng->reseed(poll_bits); } } diff --git a/src/rng/auto_rng/auto_rng.h b/src/rng/auto_rng/auto_rng.h index dea735470..5536f2b8e 100644 --- a/src/rng/auto_rng/auto_rng.h +++ b/src/rng/auto_rng/auto_rng.h @@ -25,13 +25,13 @@ class BOTAN_DLL AutoSeeded_RNG : public RandomNumberGenerator std::string name() const { return "AutoSeeded(" + rng->name() + ")"; } - void reseed() { rng->reseed(); } + void reseed(u32bit poll_bits) { rng->reseed(poll_bits); } void add_entropy_source(EntropySource* es) { rng->add_entropy_source(es); } void add_entropy(const byte in[], u32bit len) { rng->add_entropy(in, len); } - AutoSeeded_RNG(); + AutoSeeded_RNG(u32bit poll_bits = 256); ~AutoSeeded_RNG() { delete rng; } private: RandomNumberGenerator* rng; diff --git a/src/rng/hmac_rng/hmac_rng.cpp b/src/rng/hmac_rng/hmac_rng.cpp index 188c32689..458118e11 100644 --- a/src/rng/hmac_rng/hmac_rng.cpp +++ b/src/rng/hmac_rng/hmac_rng.cpp @@ -1,7 +1,7 @@ -/************************************************* -* HMAC_RNG Source File * -* (C) 2008 Jack Lloyd * -*************************************************/ +/* +* HMAC_RNG +* (C) 2008-2009 Jack Lloyd +*/ #include <botan/hmac_rng.h> #include <botan/loadstor.h> @@ -16,9 +16,9 @@ namespace Botan { namespace { void hmac_prf(MessageAuthenticationCode* prf, - MemoryRegion<byte>& K, - u32bit& counter, - const std::string& label) + MemoryRegion<byte>& K, + u32bit& counter, + const std::string& label) { prf->update(K, K.size()); prf->update(label); @@ -31,24 +31,13 @@ void hmac_prf(MessageAuthenticationCode* prf, } -/************************************************* -* Generate a buffer of random bytes * -*************************************************/ +/** +* Generate a buffer of random bytes +*/ void HMAC_RNG::randomize(byte out[], u32bit length) { - /* Attempt to seed if we are currently not seeded, or if the - counter is greater than 2^20 - - If HMAC_RNG is wrapped in an X9.31/AES PRNG (the default), this - means a reseed will be kicked off every 16 MiB of RNG output. - */ - if(!is_seeded() || counter >= 0x100000) - { - reseed(); - - if(!is_seeded()) - throw PRNG_Unseeded(name() + " seeding attempt failed"); - } + if(!is_seeded()) + throw PRNG_Unseeded(name()); /* HMAC KDF as described in E-t-E, using a CTXinfo of "rng" @@ -63,94 +52,43 @@ void HMAC_RNG::randomize(byte out[], u32bit length) out += copied; length -= copied; } - - /* Every once in a while do a fast poll of a entropy source */ - if(entropy_sources.size() && (counter % 65536 == 0)) - { - u32bit got = entropy_sources.at(source_index)-> - fast_poll(io_buffer, io_buffer.size()); - - source_index = (source_index + 1) % entropy_sources.size(); - extractor->update(io_buffer, got); - io_buffer.clear(); - } } /** * Reseed the internal state, also accepting user input to include */ -void HMAC_RNG::reseed_with_input(const byte input[], u32bit input_length) +void HMAC_RNG::reseed_with_input(u32bit poll_bits, + const byte input[], u32bit input_length) { - if(entropy_sources.size()) + /** + Using the terminology of E-t-E, XTR is the MAC function (normally + HMAC) seeded with XTS (below) and we form SKM, the key material, by + fast polling each source, and then slow polling as many as we think + we need (in the following loop), and feeding all of the poll + results, along with any optional user input, along with, finally, + feedback of the current PRK value, into the extractor function. + */ + + Entropy_Accumulator_BufferedComputation accum(*extractor, poll_bits); + + for(u32bit i = 0; i < entropy_sources.size(); ++i) { - /** - Using the terminology of E-t-E, XTR is the MAC function (normally - HMAC) seeded with XTS (below) and we form SKM, the key material, by - fast polling each source, and then slow polling as many as we think - we need (in the following loop), and feeding all of the poll - results, along with any optional user input, along with, finally, - feedback of the current PRK value, into the extractor function. - */ - - /* - Previously this function did entropy estimation. However the paper - - "Boaz Barak, Shai Halevi: A model and architecture for - pseudo-random generation with applications to /dev/random. ACM - Conference on Computer and Communications Security 2005." - - provides a pretty strong case to not even try, since what we are - really interested in is the *conditional* entropy from the point - of view of an unknown attacker, which is impossible to - calculate. They recommend, if an entropy estimate of some kind - is needed, to use a low static estimate instead. We use here an - estimate of 1 bit per byte. - - One thing I had been concerned about initially was that people - without any randomness source enabled (much more likely in the - days when you had to enable them manually) would find the RNG - was unseeded and then pull the manuever some OpenSSL users did - and seed the RNG with a constant string. However, upon further - thought, I've decided that people who do that deserve to lose - anyway. - */ - - for(u32bit j = 0; j < entropy_sources.size(); ++j) - { - const u32bit got = - entropy_sources[j]->fast_poll(io_buffer, io_buffer.size()); - - entropy += got; - extractor->update(io_buffer, got); - io_buffer.clear(); - } - - for(u32bit j = 0; j != entropy_sources.size(); ++j) - { - const u32bit got = - entropy_sources[j]->slow_poll(io_buffer, io_buffer.size()); - - entropy += got; - extractor->update(io_buffer, got); - io_buffer.clear(); - } + if(accum.polling_goal_achieved()) + break; + + entropy_sources[i]->poll(accum); } - /* - And now add the user-provided input, if any - */ + // And now add the user-provided input, if any if(input_length) - { - extractor->update(input, input_length); - entropy += input_length; - } + accum.add(input, input_length, 1); /* - It is necessary to feed forward poll data. Otherwise, a good - poll (collecting a large amount of conditional entropy) followed - by a bad one (collecting little) would be unsafe. Do this by - generating new PRF outputs using the previous key and feeding them - into the extractor function. + It is necessary to feed forward poll data. Otherwise, a good poll + (collecting a large amount of conditional entropy) followed by a + bad one (collecting little) would be unsafe. Do this by generating + new PRF outputs using the previous key and feeding them into the + extractor function. Cycle the RNG once (CTXinfo="rng"), then generate a new PRF output using the CTXinfo "reseed". Provide these values as input to the @@ -174,77 +112,66 @@ void HMAC_RNG::reseed_with_input(const byte input[], u32bit input_length) K.clear(); counter = 0; - // Upper bound entropy estimate at the extractor output size - entropy = std::min<u32bit>(entropy, 8 * extractor->OUTPUT_LENGTH); + if(input_length || accum.bits_collected() >= poll_bits) + seeded = true; } /** * Reseed the internal state */ -void HMAC_RNG::reseed() +void HMAC_RNG::reseed(u32bit poll_bits) { - reseed_with_input(0, 0); + reseed_with_input(poll_bits, 0, 0); } /** -Add user-supplied entropy by reseeding and including this -input among the poll data +* Add user-supplied entropy by reseeding and including this +* input among the poll data */ void HMAC_RNG::add_entropy(const byte input[], u32bit length) { - reseed_with_input(input, length); + reseed_with_input(0, input, length); } -/************************************************* -* Add another entropy source to the list * -*************************************************/ +/** +* Add another entropy source to the list +*/ void HMAC_RNG::add_entropy_source(EntropySource* src) { entropy_sources.push_back(src); } -/************************************************* -* Check if the the pool is seeded * -*************************************************/ -bool HMAC_RNG::is_seeded() const - { - return (entropy >= 8 * prf->OUTPUT_LENGTH); - } - - /************************************************* -* Clear memory of sensitive data * -*************************************************/ +/* +* Clear memory of sensitive data +*/ void HMAC_RNG::clear() throw() { extractor->clear(); prf->clear(); K.clear(); - entropy = 0; counter = 0; - source_index = 0; + seeded = false; } -/************************************************* -* Return the name of this type * -*************************************************/ +/** +* Return the name of this type +*/ std::string HMAC_RNG::name() const { return "HMAC_RNG(" + extractor->name() + "," + prf->name() + ")"; } -/************************************************* -* HMAC_RNG Constructor * -*************************************************/ +/** +* HMAC_RNG Constructor +*/ HMAC_RNG::HMAC_RNG(MessageAuthenticationCode* extractor_mac, MessageAuthenticationCode* prf_mac) : - extractor(extractor_mac), prf(prf_mac), io_buffer(96) + extractor(extractor_mac), prf(prf_mac) { - entropy = 0; - // First PRF inputs are all zero, as specified in section 2 K.create(prf->OUTPUT_LENGTH); counter = 0; - source_index = 0; + seeded = false; /* Normally we want to feedback PRF output into the input to the @@ -275,9 +202,9 @@ HMAC_RNG::HMAC_RNG(MessageAuthenticationCode* extractor_mac, xts.length()); } -/************************************************* -* HMAC_RNG Destructor * -*************************************************/ +/** +* HMAC_RNG Destructor +*/ HMAC_RNG::~HMAC_RNG() { delete extractor; @@ -286,7 +213,6 @@ HMAC_RNG::~HMAC_RNG() std::for_each(entropy_sources.begin(), entropy_sources.end(), del_fun<EntropySource>()); - entropy = 0; counter = 0; } diff --git a/src/rng/hmac_rng/hmac_rng.h b/src/rng/hmac_rng/hmac_rng.h index b9ea064c3..16adddd60 100644 --- a/src/rng/hmac_rng/hmac_rng.h +++ b/src/rng/hmac_rng/hmac_rng.h @@ -1,7 +1,7 @@ -/************************************************* -* HMAC RNG * -* (C) 2008 Jack Lloyd * -*************************************************/ +/* +* HMAC RNG +* (C) 2008 Jack Lloyd +*/ #ifndef BOTAN_HMAC_RNG_H__ #define BOTAN_HMAC_RNG_H__ @@ -26,11 +26,11 @@ class BOTAN_DLL HMAC_RNG : public RandomNumberGenerator { public: void randomize(byte buf[], u32bit len); - bool is_seeded() const; + bool is_seeded() const { return seeded; } void clear() throw(); std::string name() const; - void reseed(); + void reseed(u32bit poll_bits); void add_entropy_source(EntropySource* es); void add_entropy(const byte[], u32bit); @@ -39,13 +39,14 @@ class BOTAN_DLL HMAC_RNG : public RandomNumberGenerator ~HMAC_RNG(); private: - void reseed_with_input(const byte input[], u32bit length); + void reseed_with_input(u32bit poll_bits, + const byte input[], u32bit length); MessageAuthenticationCode* extractor; MessageAuthenticationCode* prf; std::vector<EntropySource*> entropy_sources; - u32bit entropy; + bool seeded; SecureVector<byte> K, io_buffer; u32bit counter, source_index; diff --git a/src/rng/randpool/randpool.cpp b/src/rng/randpool/randpool.cpp index e35ee22ca..af36c335f 100644 --- a/src/rng/randpool/randpool.cpp +++ b/src/rng/randpool/randpool.cpp @@ -1,7 +1,7 @@ -/************************************************* -* Randpool Source File * -* (C) 1999-2008 Jack Lloyd * -*************************************************/ +/* +* Randpool Source File +* (C) 1999-2009 Jack Lloyd +*/ #include <botan/randpool.h> #include <botan/loadstor.h> @@ -14,9 +14,9 @@ namespace Botan { namespace { -/************************************************* -* PRF based on a MAC * -*************************************************/ +/** +* PRF based on a MAC +*/ enum RANDPOOL_PRF_TAG { CIPHER_KEY = 0, MAC_KEY = 1, @@ -25,18 +25,13 @@ enum RANDPOOL_PRF_TAG { } -/************************************************* -* Generate a buffer of random bytes * -*************************************************/ +/** +* Generate a buffer of random bytes +*/ void Randpool::randomize(byte out[], u32bit length) { if(!is_seeded()) - { - reseed(); - - if(!is_seeded()) - throw PRNG_Unseeded(name()); - } + throw PRNG_Unseeded(name()); update_buffer(); while(length) @@ -49,15 +44,15 @@ void Randpool::randomize(byte out[], u32bit length) } } -/************************************************* -* Refill the output buffer * -*************************************************/ +/** +* Refill the output buffer +*/ void Randpool::update_buffer() { const u64bit timestamp = system_time(); - for(u32bit j = 0; j != counter.size(); ++j) - if(++counter[j]) + for(u32bit i = 0; i != counter.size(); ++i) + if(++counter[i]) break; store_be(timestamp, counter + 4); @@ -65,17 +60,17 @@ void Randpool::update_buffer() mac->update(counter, counter.size()); SecureVector<byte> mac_val = mac->final(); - for(u32bit j = 0; j != mac_val.size(); ++j) - buffer[j % buffer.size()] ^= mac_val[j]; + for(u32bit i = 0; i != mac_val.size(); ++i) + buffer[i % buffer.size()] ^= mac_val[i]; cipher->encrypt(buffer); if(counter[0] % ITERATIONS_BEFORE_RESEED == 0) mix_pool(); } -/************************************************* -* Mix the entropy pool * -*************************************************/ +/** +* Mix the entropy pool +*/ void Randpool::mix_pool() { const u32bit BLOCK_SIZE = cipher->BLOCK_SIZE; @@ -90,10 +85,10 @@ void Randpool::mix_pool() xor_buf(pool, buffer, BLOCK_SIZE); cipher->encrypt(pool); - for(u32bit j = 1; j != POOL_BLOCKS; ++j) + for(u32bit i = 1; i != POOL_BLOCKS; ++i) { - const byte* previous_block = pool + BLOCK_SIZE*(j-1); - byte* this_block = pool + BLOCK_SIZE*j; + const byte* previous_block = pool + BLOCK_SIZE*(i-1); + byte* this_block = pool + BLOCK_SIZE*i; xor_buf(this_block, previous_block, BLOCK_SIZE); cipher->encrypt(this_block); } @@ -101,48 +96,19 @@ void Randpool::mix_pool() update_buffer(); } -/************************************************* -* Reseed the internal state * -*************************************************/ -void Randpool::reseed() +/** +* Reseed the internal state +*/ +void Randpool::reseed(u32bit poll_bits) { - SecureVector<byte> buffer(128); - - u32bit entropy_est = 0; + Entropy_Accumulator_BufferedComputation accum(*mac, poll_bits); - /* - When we reseed, assume we get 1 bit per byte sampled. - - This class used to perform entropy estimation, but what we really - want to measure is the conditional entropy of the data with respect - to an unknown attacker with unknown capabilities. For this reason - making any sort of sane estimate is impossible. See also - "Boaz Barak, Shai Halevi: A model and architecture for - pseudo-random generation with applications to /dev/random. ACM - Conference on Computer and Communications Security 2005." - */ - - // First do a fast poll of all sources (no matter what) - for(u32bit j = 0; j != entropy_sources.size(); ++j) + for(u32bit i = 0; i != entropy_sources.size(); ++i) { - u32bit got = entropy_sources[j]->fast_poll(buffer, buffer.size()); - - mac->update(buffer, got); - entropy_est += got; - buffer.clear(); - } + entropy_sources[i]->poll(accum); - // Then do a slow poll, until we think we have got enough entropy - for(u32bit j = 0; j != entropy_sources.size(); ++j) - { - u32bit got = entropy_sources[j]->slow_poll(buffer, buffer.size()); - - mac->update(buffer, got); - entropy_est += got; - - if(entropy_est > 512) + if(accum.polling_goal_achieved()) break; - buffer.clear(); } SecureVector<byte> mac_val = mac->final(); @@ -150,41 +116,34 @@ void Randpool::reseed() xor_buf(pool, mac_val, mac_val.size()); mix_pool(); - entropy = std::min<u32bit>(entropy + entropy_est, 8 * mac_val.size()); + if(accum.bits_collected() >= poll_bits) + seeded = true; } -/************************************************* -* Add user-supplied entropy * -*************************************************/ +/** +* Add user-supplied entropy +*/ void Randpool::add_entropy(const byte input[], u32bit length) { SecureVector<byte> mac_val = mac->process(input, length); xor_buf(pool, mac_val, mac_val.size()); mix_pool(); - // Assume 1 bit conditional entropy per byte of input - entropy = std::min<u32bit>(entropy + length, 8 * mac_val.size()); + if(length) + seeded = true; } -/************************************************* -* Add another entropy source to the list * -*************************************************/ +/** +* Add another entropy source to the list +*/ void Randpool::add_entropy_source(EntropySource* src) { entropy_sources.push_back(src); } -/************************************************* -* Check if the the pool is seeded * -*************************************************/ -bool Randpool::is_seeded() const - { - return (entropy >= 7 * mac->OUTPUT_LENGTH); - } - -/************************************************* -* Clear memory of sensitive data * -*************************************************/ +/** +* Clear memory of sensitive data +*/ void Randpool::clear() throw() { cipher->clear(); @@ -192,20 +151,20 @@ void Randpool::clear() throw() pool.clear(); buffer.clear(); counter.clear(); - entropy = 0; + seeded = false; } -/************************************************* -* Return the name of this type * -*************************************************/ +/** +* Return the name of this type +*/ std::string Randpool::name() const { return "Randpool(" + cipher->name() + "," + mac->name() + ")"; } -/************************************************* -* Randpool Constructor * -*************************************************/ +/** +* Randpool Constructor +*/ Randpool::Randpool(BlockCipher* cipher_in, MessageAuthenticationCode* mac_in, u32bit pool_blocks, @@ -231,12 +190,12 @@ Randpool::Randpool(BlockCipher* cipher_in, buffer.create(BLOCK_SIZE); pool.create(POOL_BLOCKS * BLOCK_SIZE); counter.create(12); - entropy = 0; + seeded = false; } -/************************************************* -* Randpool Destructor * -*************************************************/ +/** +* Randpool Destructor +*/ Randpool::~Randpool() { delete cipher; @@ -244,8 +203,6 @@ Randpool::~Randpool() std::for_each(entropy_sources.begin(), entropy_sources.end(), del_fun<EntropySource>()); - - entropy = 0; } } diff --git a/src/rng/randpool/randpool.h b/src/rng/randpool/randpool.h index f6bae9d52..f44527609 100644 --- a/src/rng/randpool/randpool.h +++ b/src/rng/randpool/randpool.h @@ -1,7 +1,7 @@ -/************************************************* -* Randpool Header File * -* (C) 1999-2008 Jack Lloyd * -*************************************************/ +/* +* Randpool Header File +* (C) 1999-2008 Jack Lloyd +*/ #ifndef BOTAN_RANDPOOL_H__ #define BOTAN_RANDPOOL_H__ @@ -13,22 +13,22 @@ namespace Botan { -/************************************************* -* Randpool * -*************************************************/ +/** +* Randpool +*/ class BOTAN_DLL Randpool : public RandomNumberGenerator { public: void randomize(byte[], u32bit); - bool is_seeded() const; + bool is_seeded() const { return seeded; } void clear() throw(); std::string name() const; - void reseed(); - void add_entropy_source(EntropySource*); - void add_entropy(const byte[], u32bit); + void reseed(u32bit bits_to_collect); + void add_entropy_source(EntropySource* es); + void add_entropy(const byte input[], u32bit length); - Randpool(BlockCipher*, MessageAuthenticationCode*, + Randpool(BlockCipher* cipher, MessageAuthenticationCode* mac, u32bit pool_blocks = 32, u32bit iterations_before_reseed = 128); @@ -43,7 +43,7 @@ class BOTAN_DLL Randpool : public RandomNumberGenerator std::vector<EntropySource*> entropy_sources; SecureVector<byte> pool, buffer, counter; - u32bit entropy; + bool seeded; }; } diff --git a/src/rng/rng.h b/src/rng/rng.h index fb92bb3c5..7fc6ee439 100644 --- a/src/rng/rng.h +++ b/src/rng/rng.h @@ -1,7 +1,7 @@ -/************************************************* -* RandomNumberGenerator Header File * -* (C) 1999-2008 Jack Lloyd * -*************************************************/ +/* +* RandomNumberGenerator Header File +* (C) 1999-2009 Jack Lloyd +*/ #ifndef BOTAN_RANDOM_NUMBER_GENERATOR_H__ #define BOTAN_RANDOM_NUMBER_GENERATOR_H__ @@ -54,8 +54,10 @@ class BOTAN_DLL RandomNumberGenerator /** * Seed this RNG using the entropy sources it contains. + * @param bits_to_collect is the number of bits of entropy to + attempt to gather from the entropy sources */ - virtual void reseed() {} + virtual void reseed(u32bit bits_to_collect) = 0; /** * Add this entropy source to the RNG object @@ -88,6 +90,7 @@ class BOTAN_DLL Null_RNG : public RandomNumberGenerator void clear() throw() {} std::string name() const { return "Null_RNG"; } + void reseed(u32bit) {} bool is_seeded() const { return false; } void add_entropy(const byte[], u32bit) {} void add_entropy_source(EntropySource* es) { delete es; } diff --git a/src/rng/x931_rng/x931_rng.cpp b/src/rng/x931_rng/x931_rng.cpp index 619c37e57..e77f04ae4 100644 --- a/src/rng/x931_rng/x931_rng.cpp +++ b/src/rng/x931_rng/x931_rng.cpp @@ -1,7 +1,7 @@ -/************************************************* -* ANSI X9.31 RNG Source File * -* (C) 1999-2008 Jack Lloyd * -*************************************************/ +/* +* ANSI X9.31 RNG Source File +* (C) 1999-2009 Jack Lloyd +*/ #include <botan/x931_rng.h> #include <botan/xor_buf.h> @@ -9,13 +9,13 @@ namespace Botan { -/************************************************* -* Generate a buffer of random bytes * -*************************************************/ +/** +* Generate a buffer of random bytes +*/ void ANSI_X931_RNG::randomize(byte out[], u32bit length) { if(!is_seeded()) - reseed(); + throw PRNG_Unseeded(name()); while(length) { @@ -31,9 +31,9 @@ void ANSI_X931_RNG::randomize(byte out[], u32bit length) } } -/************************************************* -* Refill the internal state * -*************************************************/ +/** +* Refill the internal state +*/ void ANSI_X931_RNG::update_buffer() { SecureVector<byte> DT(cipher->BLOCK_SIZE); @@ -50,13 +50,11 @@ void ANSI_X931_RNG::update_buffer() position = 0; } -/************************************************* -* Reseed the internal state * -*************************************************/ -void ANSI_X931_RNG::reseed() +/** +* Reset V and the cipher key with new values +*/ +void ANSI_X931_RNG::rekey() { - prng->reseed(); - if(prng->is_seeded()) { SecureVector<byte> key(cipher->MAXIMUM_KEYLENGTH); @@ -71,33 +69,43 @@ void ANSI_X931_RNG::reseed() } } -/************************************************* -* Add a entropy source to the underlying PRNG * -*************************************************/ +/** +* Reseed the internal state +*/ +void ANSI_X931_RNG::reseed(u32bit poll_bits) + { + prng->reseed(poll_bits); + rekey(); + } + +/** +* Add a entropy source to the underlying PRNG +*/ void ANSI_X931_RNG::add_entropy_source(EntropySource* src) { prng->add_entropy_source(src); } -/************************************************* -* Add some entropy to the underlying PRNG * -*************************************************/ +/** +* Add some entropy to the underlying PRNG +*/ void ANSI_X931_RNG::add_entropy(const byte input[], u32bit length) { prng->add_entropy(input, length); + rekey(); } -/************************************************* -* Check if the the PRNG is seeded * -*************************************************/ +/** +* Check if the the PRNG is seeded +*/ bool ANSI_X931_RNG::is_seeded() const { return V.has_items(); } -/************************************************* -* Clear memory of sensitive data * -*************************************************/ +/** +* Clear memory of sensitive data +*/ void ANSI_X931_RNG::clear() throw() { cipher->clear(); @@ -108,17 +116,17 @@ void ANSI_X931_RNG::clear() throw() position = 0; } -/************************************************* -* Return the name of this type * -*************************************************/ +/** +* Return the name of this type +*/ std::string ANSI_X931_RNG::name() const { return "X9.31(" + cipher->name() + ")"; } -/************************************************* -* ANSI X931 RNG Constructor * -*************************************************/ +/** +* ANSI X931 RNG Constructor +*/ ANSI_X931_RNG::ANSI_X931_RNG(BlockCipher* cipher_in, RandomNumberGenerator* prng_in) { @@ -132,9 +140,9 @@ ANSI_X931_RNG::ANSI_X931_RNG(BlockCipher* cipher_in, position = 0; } -/************************************************* -* ANSI X931 RNG Destructor * -*************************************************/ +/** +* ANSI X931 RNG Destructor +*/ ANSI_X931_RNG::~ANSI_X931_RNG() { delete cipher; diff --git a/src/rng/x931_rng/x931_rng.h b/src/rng/x931_rng/x931_rng.h index e1d090c3c..b1cef8df3 100644 --- a/src/rng/x931_rng/x931_rng.h +++ b/src/rng/x931_rng/x931_rng.h @@ -1,7 +1,7 @@ -/************************************************* -* ANSI X9.31 RNG Header File * -* (C) 1999-2008 Jack Lloyd * -*************************************************/ +/* +* ANSI X9.31 RNG Header File +* (C) 1999-2009 Jack Lloyd +*/ #ifndef BOTAN_ANSI_X931_RNG_H__ #define BOTAN_ANSI_X931_RNG_H__ @@ -11,9 +11,9 @@ namespace Botan { -/************************************************* -* ANSI X9.31 RNG * -*************************************************/ +/** +* ANSI X9.31 RNG +*/ class BOTAN_DLL ANSI_X931_RNG : public RandomNumberGenerator { public: @@ -22,13 +22,14 @@ class BOTAN_DLL ANSI_X931_RNG : public RandomNumberGenerator void clear() throw(); std::string name() const; - void reseed(); + void reseed(u32bit poll_bits); void add_entropy_source(EntropySource*); void add_entropy(const byte[], u32bit); ANSI_X931_RNG(BlockCipher*, RandomNumberGenerator*); ~ANSI_X931_RNG(); private: + void rekey(); void update_buffer(); BlockCipher* cipher; diff --git a/src/timer/timer.cpp b/src/timer/timer.cpp index 8758aad21..a801761cf 100644 --- a/src/timer/timer.cpp +++ b/src/timer/timer.cpp @@ -1,6 +1,6 @@ /** * Timestamp Functions Source File -* (C) 1999-2008 Jack Lloyd +* (C) 1999-2009 Jack Lloyd */ #include <botan/timer.h> @@ -21,19 +21,10 @@ u64bit system_time() /** * Read the clock and return the output */ -u32bit Timer::fast_poll(byte out[], u32bit length) +void Timer::poll(Entropy_Accumulator& accum) { const u64bit clock_value = this->clock(); - - for(u32bit j = 0; j != sizeof(clock_value); ++j) - out[j % length] ^= get_byte(j, clock_value); - - return (length < 8) ? length : 8; - } - -u32bit Timer::slow_poll(byte out[], u32bit length) - { - return fast_poll(out, length); + accum.add(clock_value, 0); } /** @@ -56,5 +47,4 @@ u64bit ANSI_Clock_Timer::clock() const return combine_timers(std::time(0), std::clock(), CLOCKS_PER_SEC); } - } diff --git a/src/timer/timer.h b/src/timer/timer.h index af2c58dcb..0e0dcc62e 100644 --- a/src/timer/timer.h +++ b/src/timer/timer.h @@ -1,6 +1,6 @@ /** * Timestamp Functions Header File -* (C) 1999-2008 Jack Lloyd +* (C) 1999-2009 Jack Lloyd */ #ifndef BOTAN_TIMERS_H__ @@ -21,8 +21,7 @@ class BOTAN_DLL Timer : public EntropySource */ virtual u64bit clock() const = 0; - u32bit slow_poll(byte[], u32bit); - u32bit fast_poll(byte[], u32bit); + void poll(Entropy_Accumulator& accum); virtual ~Timer() {} protected: diff --git a/src/utils/info.txt b/src/utils/info.txt index 915ce50b0..ffc19c852 100644 --- a/src/utils/info.txt +++ b/src/utils/info.txt @@ -42,6 +42,5 @@ util.cpp util.h version.cpp version.h -xor_buf.cpp xor_buf.h </add> diff --git a/src/utils/xor_buf.cpp b/src/utils/xor_buf.cpp deleted file mode 100644 index 779be81c3..000000000 --- a/src/utils/xor_buf.cpp +++ /dev/null @@ -1,44 +0,0 @@ -/** -* XOR operations -* (C) 1999-2008 Jack Lloyd -*/ - -#include <botan/xor_buf.h> -#include <botan/loadstor.h> - -namespace Botan { - -/** -* Xor values into buffer -*/ -u32bit xor_into_buf(byte buf[], u32bit buf_i, u32bit length, - const void* in_void, u32bit in_len) - { - const byte* in = static_cast<const byte*>(in_void); - - byte last = 0; - byte count = 0; - - for(u32bit i = 0; i != in_len; ++i) - { - if(in[i] != last) - { - buf[buf_i] ^= last; - buf_i = (buf_i + 1) % length; - - buf[buf_i] ^= count; - buf_i = (buf_i + 1) % length; - - last = in[i]; - count = 1; - } - else - ++count; - } - - // final values of last, count are thrown away - - return buf_i; - } - -} diff --git a/src/utils/xor_buf.h b/src/utils/xor_buf.h index 076877e02..2bf6ced59 100644 --- a/src/utils/xor_buf.h +++ b/src/utils/xor_buf.h @@ -67,24 +67,6 @@ inline void xor_buf(byte out[], out[j] = in[j] ^ in2[j]; } -/** -* XOR values into buffer. Uses RLE compression -* Intended for use in entropy sources to gather collected -* data into a buffer to pass to an RNG. -*/ -u32bit xor_into_buf(byte buf[], u32bit buf_i, u32bit length, - const void* in_void, u32bit in_len); - -/** -* XOR integer value (or something else, I guess) into buffer -*/ -template<typename T> -u32bit xor_into_buf(byte buf[], u32bit buf_i, - u32bit length, const T& in) - { - return xor_into_buf(buf, buf_i, length, &in, sizeof(in)); - } - } #endif |