hardened_hash.h

#pragma once
 
#include <xrpl/beast/hash/hash_append.h>
#include <xrpl/beast/hash/xxhasher.h>
 
#include <cstdint>
#include <mutex>
#include <random>
#include <utility>
 
namespace xrpl {
 
namespace detail {
 
using seed_pair = std::pair<std::uint64_t, std::uint64_t>;
 
template <bool = true>
seed_pair
makeSeedPair() noexcept
{
    struct StateT
    {
        std::mutex mutex;
        std::random_device rng;
        std::mt19937_64 gen;
        std::uniform_int_distribution<std::uint64_t> dist;
 
        StateT() : gen(rng())
        {
        }
        // state_t(state_t const&) = delete;
        // state_t& operator=(state_t const&) = delete;
    };
    static StateT kState;
    std::scoped_lock const lock(kState.mutex);
    return {kState.dist(kState.gen), kState.dist(kState.gen)};
}
 
}  // namespace detail

 
template <class HashAlgorithm = beast::Xxhasher>
class HardenedHash
{
private:
    detail::seed_pair seeds_{detail::makeSeedPair<>()};
 
public:
    using result_type = HashAlgorithm::result_type;
 
    HardenedHash() = default;
 
    template <class T>
    result_type
    operator()(T const& t) const noexcept
    {
        HashAlgorithm h(seeds_.first, seeds_.second);
        hash_append(h, t);
        return static_cast<result_type>(h);
    }
};
 
}  // namespace xrpl