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
make_seed_pair() noexcept
{
    struct state_t
    {
        std::mutex mutex;
        std::random_device rng;
        std::mt19937_64 gen;
        std::uniform_int_distribution<std::uint64_t> dist;
 
        state_t() : gen(rng())
        {
        }
        // state_t(state_t const&) = delete;
        // state_t& operator=(state_t const&) = delete;
    };
    static state_t state;
    std::lock_guard lock(state.mutex);
    return {state.dist(state.gen), state.dist(state.gen)};
}
 
}  // namespace detail
 
template <class HashAlgorithm = beast::xxhasher>
class hardened_hash
{
private:
    detail::seed_pair m_seeds;
 
public:
    using result_type = typename HashAlgorithm::result_type;
 
    hardened_hash() : m_seeds(detail::make_seed_pair<>())
    {
    }
 
    template <class T>
    result_type
    operator()(T const& t) const noexcept
    {
        HashAlgorithm h(m_seeds.first, m_seeds.second);
        hash_append(h, t);
        return static_cast<result_type>(h);
    }
};
 
}  // namespace xrpl