forked from ak-fortuna/fortuna
surtur
d404681889
general
* make greater use of "this"
Fortuna
* declare da_pools as a proper std::array of 32 Pool objects
* declare da_pools as const
* use std::shared_ptr _p_pools to access da_pools and share access to
it
* reflect change of pools[] -> std::array in how the array elements
are accessed, which is a) via _p_pools pointer and b) using ".at(i)"
function
* pass _p_pools shared_ptr to Accumulator
* refactor member function names and variable names
* add member function attribute [[optimize_for_synchronized]]
* secure conversions with static_cast-s
Accumulator
* make use of _p_pools
* add _p_pools-related member functions
* add a static constexpr variable NUM_OF_POOLS
UrandomEntropySrc
* implement event adding logic using _p_pools
* make std::vector<char> non-static in urandom_entropy_src
* implement proper urandom entropy source event "sourcing" (from
/dev/urandom), event adding, clear bytes array at the end
* properly convert using reinterpret_cast
* protect access to the main function with std::lock_guard
* receive EventAdderImpl as a ref
* use return value from "add_entropy()" member function and create
sanity guard checking the return code "int ret"
EventAdder
* pass event (std::vector<char>) by const&
EventAdderImpl
* make use of _p_pools shared_ptr
* implement proper pool-rotating event-adding logic
Pool
* delete all copy constructors and assignment operator, the objects
will not be copied or assigned to
* receive parameters by const& where possible/sensible
* handle concurrency:
* declare std:string s as mutable
* declare a rw std::mutex intended for writing and mutable
std::recursive_mutex for read-only operations in const member
functions
ref: https://herbsutter.com/2013/05/24/gotw-6a-const-correctness-part-1-3/
ref: https://arne-mertz.de/2017/10/mutable/
* use std::lock_guard and std::unique_lock
* refactor "add_entropy()" member function
* get rid of intermediate "event_str" and directly use the "event"
std::vector<char> for all operations
* add a lock guard to prevent multiple threads (should that route be
taken) from modifying pool resources simultaneously
* add all_ok bool for basic sanity checking
* add print statements (at least for now)
* rename "get_s_length()" member function to "get_s_byte_count()" and
repurpose it to return byte count of the stored entropy std::string s
53 lines
1.1 KiB
C++
53 lines
1.1 KiB
C++
#ifndef FORTUNA_POOL_H
|
|
#define FORTUNA_POOL_H
|
|
|
|
#include "util.h"
|
|
|
|
#include <mutex>
|
|
|
|
namespace fortuna {
|
|
namespace accumulator {
|
|
|
|
class Pool {
|
|
public:
|
|
static constexpr const uint8_t NUM_OF_POOLS{32};
|
|
|
|
Pool() noexcept {};
|
|
Pool(const Pool&) = delete; // no copy
|
|
Pool(Pool&) = delete;
|
|
Pool& operator=(const Pool&) = delete;
|
|
~Pool() noexcept = default;
|
|
|
|
auto set_id(const unsigned int& id) noexcept -> void;
|
|
|
|
auto get_id() const noexcept -> unsigned int;
|
|
|
|
auto initialize_pool(const unsigned int& id) -> void;
|
|
|
|
// add entropy contained in a random event of 1 to 32 bytes
|
|
auto add_entropy(const unsigned int& source, const std::vector<char>& event)
|
|
-> int;
|
|
|
|
auto get_s_byte_count() const -> uint64_t;
|
|
|
|
auto get_s() const -> std::string;
|
|
|
|
auto clear_pool() -> void;
|
|
|
|
protected:
|
|
auto append_s(const std::string& entropy_s) -> void;
|
|
|
|
private:
|
|
unsigned int pool_id{0};
|
|
mutable std::string s{""};
|
|
uint64_t size{0};
|
|
std::mutex mtx; // mutex for write locks
|
|
mutable std::recursive_mutex ro_mtx_s; // mtx for readers of s
|
|
|
|
}; // class Pool
|
|
|
|
} // namespace accumulator
|
|
} // namespace fortuna
|
|
|
|
#endif // FORTUNA_POOL_H
|