forked from ak-fortuna/fortuna
113 lines
2.5 KiB
C++
113 lines
2.5 KiB
C++
#ifndef FORTUNA_UTIL_H
|
|
#define FORTUNA_UTIL_H
|
|
|
|
#include <cryptopp/filters.h>
|
|
#include <cryptopp/hex.h>
|
|
#include <cryptopp/sha3.h>
|
|
|
|
#include <array>
|
|
#include <chrono>
|
|
#include <cstddef>
|
|
#include <vector>
|
|
|
|
namespace fortuna {
|
|
|
|
class Util final {
|
|
public:
|
|
static constexpr const std::size_t gen_block_size{32}; // 256 bits
|
|
|
|
static auto de_hex(const std::string& str) -> const std::string {
|
|
std::string s{str};
|
|
std::string dst;
|
|
CryptoPP::HexDecoder decoder;
|
|
|
|
decoder.Put(reinterpret_cast<CryptoPP::byte*>(s.data()), s.size());
|
|
decoder.MessageEnd();
|
|
dst.resize(gen_block_size);
|
|
decoder.Get(reinterpret_cast<CryptoPP::byte*>(&dst[0]), dst.size());
|
|
|
|
return dst;
|
|
}
|
|
|
|
static auto do_sha(const std::string& str_to_hash) -> const std::string {
|
|
// do sha256
|
|
std::string digest;
|
|
|
|
// no reason not to go for Keccak
|
|
CryptoPP::SHA3_256 sha3_256;
|
|
|
|
CryptoPP::StringSource str_src(
|
|
str_to_hash,
|
|
true,
|
|
new CryptoPP::HashFilter(
|
|
sha3_256,
|
|
new CryptoPP::HexEncoder(new CryptoPP::StringSink(digest),
|
|
true))); // unify to uppercase
|
|
|
|
return digest;
|
|
}
|
|
|
|
static auto do_sha(const std::vector<char>& char_vec) -> const std::string {
|
|
std::string output;
|
|
|
|
{
|
|
CryptoPP::SHA3_256 sha3_256;
|
|
CryptoPP::byte digest[CryptoPP::SHA3_256::DIGESTSIZE];
|
|
|
|
{
|
|
sha3_256.CalculateDigest(
|
|
digest,
|
|
reinterpret_cast<const CryptoPP::byte*>(&char_vec[0]),
|
|
char_vec.size());
|
|
}
|
|
|
|
CryptoPP::HexEncoder encoder;
|
|
encoder.Attach(new CryptoPP::StringSink(output));
|
|
encoder.Put(digest, sizeof(digest));
|
|
encoder.MessageEnd();
|
|
}
|
|
|
|
return output;
|
|
}
|
|
|
|
static auto do_sha(std::vector<char>& char_vec) -> const std::string {
|
|
std::string output;
|
|
|
|
{
|
|
CryptoPP::SHA3_256 sha3_256;
|
|
// convert vector to string
|
|
const std::string s{std::string(char_vec.begin(), char_vec.end())};
|
|
|
|
CryptoPP::StringSource src(
|
|
s,
|
|
true,
|
|
new CryptoPP::HashFilter(
|
|
sha3_256,
|
|
new CryptoPP::HexEncoder(new CryptoPP::StringSink(output),
|
|
true)));
|
|
}
|
|
|
|
return output;
|
|
}
|
|
|
|
static auto current_time() -> std::chrono::time_point<
|
|
std::chrono::system_clock,
|
|
std::chrono::duration<long, std::ratio<1, 1000000000>>> {
|
|
return std::chrono::system_clock::now();
|
|
}
|
|
|
|
// returns number of blocks for a given number of bytes
|
|
static constexpr std::size_t b2b(std::size_t bytes) noexcept {
|
|
// returns number of blocks
|
|
return bytes == 0 ? 0 : ((bytes - 1) / gen_block_size) + 1;
|
|
}
|
|
|
|
Util() = delete;
|
|
~Util() noexcept;
|
|
|
|
}; // class Util
|
|
|
|
} // namespace fortuna
|
|
|
|
#endif // FORTUNA_UTIL_H
|