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/generator.cpp
surtur 01238c805a
All checks were successful
continuous-integration/drone/push Build is passing
generator: change exit(1) -> throw
2022-01-30 00:00:20 +01:00

241 lines
5.8 KiB
C++

#ifndef FORTUNA_GENERATOR_CPP
#define FORTUNA_GENERATOR_CPP
#include "generator.h"
#include "util.h"
#include <cryptopp/filters.h>
#include <cryptopp/hex.h>
#include <cryptopp/secblock.h>
#include <fmt/core.h>
#include <algorithm>
#include <atomic>
#include <cassert>
#include <chrono>
#include <cmath>
#include <cstdint>
#include <mutex>
#include <stdexcept>
namespace fortuna {
namespace generator {
Generator::Generator() /*noexcept*/ {
try {
initialize_generator();
}
catch (CryptoPP::Exception& e) {
fmt::print(stderr, "{}\n", e.what());
throw;
}
}
Generator::~Generator() noexcept {}
void Generator::initialize_generator() {
std::lock_guard<std::recursive_mutex> lg(mtx);
try {
std::memset(G.k, 0x00, G.k.size());
G.ctr = 0;
fmt::print("Generator initialized\n");
}
catch (CryptoPP::Exception& e) {
fmt::print(stderr, "{}\n", e.what());
throw;
}
}
auto Generator::get_state() const -> G_state {
std::lock_guard<std::recursive_mutex> lg(mtx);
return G;
}
auto Generator::time_to_reseed(
const uint64_t& pool0_len,
const unsigned int& min_p_size,
const std::chrono::duration<int64_t, std::ratio<1, 1000>>& time_elapsed,
const std::chrono::milliseconds& gen_reseed_interval) const -> bool {
std::lock_guard<std::recursive_mutex> lg(mtx);
return (pool0_len >= min_p_size && time_elapsed > gen_reseed_interval);
}
auto Generator::reseed(const std::string& s) -> void {
std::lock_guard<std::recursive_mutex> lg(mtx);
std::unique_lock<std::mutex> ul(reseed_mtx);
// ref: https://www.cryptopp.com/wiki/SecBlock
std::string da_key(reinterpret_cast<const char*>(&G.k[0]),
G.k.SizeInBytes() * 8); // we need the size in bits
try {
std::string a{fortuna::Util::do_sha(da_key + s)};
std::memmove(G.k, a.c_str(), G.k_length);
++G.ctr;
fmt::print("[i] generator: reseeded\n");
}
catch (std::exception& e) {
fmt::print("{}", e.what());
throw;
}
}
auto Generator::do_crypto() -> std::string {
/* this function calls the block cipher
* returns a string of k*(16 bytes);
* do whatever atm */
std::lock_guard<std::recursive_mutex> lg(mtx);
// for the moment loosely based on
// https://www.cryptopp.com/wiki/CTR_Mode
// William Shakespeare, Romeo and Juliet
const std::string plain{"Oh, I am fortune's fool!"};
std::string cipher, encoded_c;
std::unique_lock<std::mutex> ul(crypt_mtx);
// in case we need to convert counter to string
const std::string str_ctr{reinterpret_cast<const char*>(&G.ctr)};
// 16 bytes --> 128bit
static constexpr const std::size_t ctr_length{16};
CryptoPP::FixedSizeSecBlock<CryptoPP::byte, ctr_length> ctr;
std::memmove(ctr, str_ctr.c_str(), ctr_length);
try {
this->enc.SetKeyWithIV(G.k, G.k.size(), ctr);
// The StreamTransformationFilter adds padding as required. ECB and
// CBC Mode must be padded to the block size of the cipher. CTR
// mode not.
// the "true" param - pump all of the data immediately to its
// attached transformation
CryptoPP::StringSource str_src1(
plain,
true,
new CryptoPP::StreamTransformationFilter(
this->enc,
new CryptoPP::StringSink(cipher)) // StreamTransformationFilter
); // StringSource
}
catch (CryptoPP::Exception& e) {
fmt::print(stderr, "{}\n", e.what());
throw;
}
// Pretty print cipher text
CryptoPP::StringSource str_src2(
cipher,
true,
new CryptoPP::HexEncoder(
new CryptoPP::StringSink(encoded_c)) // HexEncoder
); // StringSource
return encoded_c;
}
auto Generator::generate_blocks(unsigned int k_blocks) -> std::string {
std::lock_guard<std::recursive_mutex> lg(mtx);
assert((G.ctr != 0) && "Counter is not 0, generator has been seeded");
if (!this->is_seeded()) {
throw std::logic_error("G.ctr == 0, generator has not been seeded!");
}
std::string r{""};
while (k_blocks--) {
r += Generator::do_crypto();
++G.ctr;
}
return r;
}
auto Generator::generate_random_data(const unsigned int& n) -> std::string {
std::lock_guard<std::recursive_mutex> lg(mtx);
if (n == 0) {
// do not do this..?
const std::string msg{"zero bytes requested, bailing\n"};
fmt::print("[*] g: error: {}", msg);
// throw std::invalid_argument(msg);
// TODO(me): throw or not?
// perhaps just return prematurely
return "";
}
// pre-computed 2^20
if (n > 1048576) {
const std::string msg{"n cannot be > 2^20\n"};
fmt::print("[*] error: {}", msg);
throw std::invalid_argument(msg);
}
std::string r;
try {
/* do magic to compute r
* r ← first-n-bytes(GenerateBlocks(G, ceil(n/16) )) */
unsigned int how_many(
static_cast<unsigned int>(std::ceil(static_cast<double>(n) / 16)));
std::string rr{generate_blocks(how_many)};
fmt::print("rr (output from generate_blocks): {}\n", rr);
// since we're truncating hex, we need to get twice more characters
r = rr.substr(0, n * 0x02ul);
rr.clear();
}
catch (std::exception& e) {
fmt::print("{}", e.what());
}
/* re-key */
try {
std::string nu_G_k{generate_blocks(2)};
// fmt::print("nu_G_k: {}\n", nu_G_k); // debugging
std::string dst;
CryptoPP::HexDecoder decoder;
decoder.Put(reinterpret_cast<CryptoPP::byte*>(nu_G_k.data()),
nu_G_k.size());
decoder.MessageEnd();
dst.resize(G.k_length);
decoder.Get(reinterpret_cast<CryptoPP::byte*>(&dst[0]), dst.size());
nu_G_k.clear();
/* clear out the old key and set a new one */
std::memset(G.k, 0x00, G.k_length);
std::memmove(G.k, dst.c_str(), G.k_length);
}
catch (std::exception& e) {
fmt::print("{}", e.what());
}
return r;
}
auto Generator::ctr_inc() -> void {
// increment the least-significant-byte-first ctr
std::atomic<uint8_t> i{0};
while (true) {
this->G.counter.at(i) = static_cast<std::byte>(
static_cast<uint8_t>(this->G.counter.at(i)) + 0x01);
if (this->G.counter.at(i) == static_cast<std::byte>(0x00) &&
++i < this->G.counter.size()) {
continue;
}
break;
}
}
} // namespace generator
} // namespace fortuna
#endif