This repository has been archived on 2022-02-10. You can view files and clone it, but cannot push or open issues or pull requests.
fortuna/pool.cpp
surtur 5d1d25ecb4
All checks were successful
continuous-integration/drone/push Build is passing
pool: rm unused strsource, using vect<char> anyway
2022-02-07 03:25:21 +01:00

160 lines
4.0 KiB
C++

#ifndef FORTUNA_POOL_CPP
#define FORTUNA_POOL_CPP
#include "pool.h"
#include <fmt/core.h>
#include <fmt/ranges.h>
#include <atomic>
#include <climits>
#include <cstddef>
#include <mutex>
#include <stdexcept>
#include <utility>
namespace fortuna {
namespace accumulator {
auto Pool::set_id(const unsigned int& id) noexcept -> void {
std::lock_guard<std::mutex> lg(mtx);
this->pool_id = id;
}
auto Pool::get_id() const noexcept -> unsigned int {
return this->pool_id;
}
auto Pool::initialize_pool(const unsigned int& id) -> void {
// ref: https://stackoverflow.com/a/23204682
std::call_once(init, [this, id] { this->set_id(id); });
}
auto Pool::add_entropy(const unsigned int& source,
const std::vector<char>& event) -> int {
std::unique_lock<std::recursive_mutex> ul(ro_mtx_s);
const size_t event_size{sizeof(char) * event.size()};
const size_t max_event_size{32};
std::string event_str;
std::atomic<bool> all_ok{false};
fmt::print(stderr, "\tevent_size (bytes): {}\n", event_size);
try {
if (source > 255) {
throw std::invalid_argument(
"source number outside of interval <0,255>\n");
}
fmt::print(stderr, "\tsource_id: {}\n", source);
if (event_size < 1 || event_size > max_event_size) {
const std::string msg{
"[!] add_entropy: the length of the event needs to "
"be from the interval <1,32>"};
fmt::print(stderr,
"\tsource: {}\n{}\nevent size: {}\n\tpool_id: {}",
source,
msg,
event_size,
this->pool_id);
throw std::invalid_argument(msg);
}
else {
all_ok = true;
}
}
catch (const std::exception& e) {
fmt::print(stderr, "{}\n", e.what());
throw;
}
if (all_ok) {
try {
{
// FIXME: check for overflow - std::string size bounding?
// event_str.assign(event.begin(), event.end());
// as per Cryptography Engineering, p. 148 (180/385)
std::vector<char> fullevent{static_cast<char>(source)};
fullevent.push_back(static_cast<char>(event_size));
fullevent.insert(
std::end(fullevent), std::begin(event), std::end(event));
fmt::print(
stderr, "\t[i] add_entropy(fullevent): {}\n", fullevent);
// FIXME: check size for overflow
// also, atm this counts event size but actually what gets
// appended are digests of 64 characters (hex-encoded 32 bytes)
size += event_size;
{
const std::string digest(fortuna::Util::do_sha(fullevent));
fmt::print(
stderr, "\t[i] add_entropy(digest): {}\n", digest);
append_s(digest);
}
}
fmt::print(stderr,
"\t[i] s.length() (simple char count): {}\n"
"\t[i] get_s_byte_count() (byte count): {}\n"
"\t[i] pool_id: {}\n"
"\t[i] s: {}\n",
this->s.length(),
this->get_s_byte_count(),
this->pool_id,
// "");
this->s);
}
catch (const std::exception& e) {
fmt::print(stderr, "[!] pool(add_entropy): {}\n", e.what());
// FIXME: handle this (as all the other unhandled exceptions)
throw;
}
return 0;
}
else {
// everything not ok
return 1;
}
} // add_entropy
auto Pool::get_s_byte_count() const -> uint64_t {
// returns total byte count of (hex-encoded) entropy string contained in
// the pool. since the string is hex-encoded, we divide its char count by 2
// to get proper byte count. we need this since we actually don't care about
// the length of the hex string as it is, rather we care about what it came
// from (the raw entropy event)
std::lock_guard<std::recursive_mutex> lg(ro_mtx_s);
return this->s.length() / 2;
}
auto Pool::get_s() const -> std::string {
std::lock_guard<std::recursive_mutex> lg(ro_mtx_s);
return this->s;
}
auto Pool::clear_pool() -> void {
std::lock_guard<std::mutex> lg(mtx);
this->s.clear();
}
auto Pool::append_s(const std::string& entropy_s) -> void {
std::lock_guard<std::mutex> lg(mtx);
try {
this->s.append(entropy_s);
}
catch (const std::exception& e) {
fmt::print(stderr, "{}\n", e.what());
}
}
} // namespace accumulator
} // namespace fortuna
#endif // FORTUNA_POOL_CPP