Modernize and clean up hashing infrastructure:

The hardened hash implementation carried dead weight: SipHash
compatibility code that never saw use, plus template indirection
now superseded by inline variables.

Separately, base_uint_hasher in RWDBFactory had a bug: it would
instantiate a new hardened hasher per operation. Since nothing
used this type anyway, it's been removed entirely.

Author: a-noni-mousse

Builds/CMake/RippledCore.cmake

@@ -812,7 +812,6 @@ if (tests)
     src/test/basics/base_uint_test.cpp
     src/test/basics/contract_test.cpp
     src/test/basics/FeeUnits_test.cpp
-    src/test/basics/hardened_hash_test.cpp
     src/test/basics/join_test.cpp
     src/test/basics/mulDiv_test.cpp
     src/test/basics/tagged_integer_test.cpp

src/ripple/basics/hardened_hash.h

@@ -22,43 +22,25 @@
 
 #include <ripple/beast/hash/hash_append.h>
 #include <ripple/beast/hash/xxhasher.h>
+#include <ripple/beast/xor_shift_engine.h>
 
-#include <cstdint>
-#include <functional>
-#include <mutex>
+#include <atomic>
 #include <random>
-#include <type_traits>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
 
 namespace ripple {
 
 namespace detail {
 
-using seed_pair = std::pair<std::uint64_t, std::uint64_t>;
+inline std::atomic hardened_hash_seed = []() {
+    std::uint64_t seed = 0x726661627563794;
 
-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)};
-}
+    std::random_device rd;
+
+    for (int i = 0; i < 16; ++i)
+        seed ^= (seed << 6) + rd();
+
+    return seed;
+}();
 
 }  // namespace detail
 
@@ -95,21 +77,25 @@ make_seed_pair() noexcept
 template <class HashAlgorithm = beast::xxhasher>
 class hardened_hash
 {
-private:
-    detail::seed_pair m_seeds;
+    std::uint64_t seed_;
 
 public:
-    using result_type = typename HashAlgorithm::result_type;
-
-    hardened_hash() : m_seeds(detail::make_seed_pair<>())
+    using result_type = HashAlgorithm::result_type;
+
+    hardened_hash() noexcept
+        : seed_(
+              beast::fmix64(
+                  detail::hardened_hash_seed.fetch_add(
+                      1,
+                      std::memory_order_relaxed)))
     {
     }
 
     template <class T>
-    result_type
+    [[nodiscard]] result_type
     operator()(T const& t) const noexcept
     {
-        HashAlgorithm h(m_seeds.first, m_seeds.second);
+        HashAlgorithm h(seed_);
         hash_append(h, t);
         return static_cast<result_type>(h);
     }

src/ripple/beast/hash/xxhasher.h

@@ -22,41 +22,29 @@
 
 #include <ripple/beast/hash/impl/xxhash.h>
 #include <boost/endian/conversion.hpp>
+#include <concepts>
 #include <cstddef>
-#include <type_traits>
 
 namespace beast {
 
 class xxhasher
 {
-private:
     // requires 64-bit std::size_t
-    static_assert(sizeof(std::size_t) == 8, "");
+    static_assert(sizeof(std::size_t) == 8);
 
     detail::XXH64_state_t state_;
 
 public:
     using result_type = std::size_t;
 
-    static constexpr auto const endian = boost::endian::order::native;
+    static constexpr auto endian = boost::endian::order::native;
 
     xxhasher() noexcept
     {
         detail::XXH64_reset(&state_, 1);
     }
 
-    template <
-        class Seed,
-        std::enable_if_t<std::is_unsigned<Seed>::value>* = nullptr>
-    explicit xxhasher(Seed seed)
-    {
-        detail::XXH64_reset(&state_, seed);
-    }
-
-    template <
-        class Seed,
-        std::enable_if_t<std::is_unsigned<Seed>::value>* = nullptr>
-    xxhasher(Seed seed, Seed)
+    explicit xxhasher(std::unsigned_integral auto seed) noexcept
     {
         detail::XXH64_reset(&state_, seed);
     }
@@ -67,7 +55,8 @@ class xxhasher
         detail::XXH64_update(&state_, key, len);
     }
 
-    explicit operator std::size_t() noexcept
+    [[nodiscard]] explicit
+    operator std::size_t() noexcept
     {
         return detail::XXH64_digest(&state_);
     }

src/ripple/beast/xor_shift_engine.h

@@ -20,15 +20,40 @@
 #ifndef BEAST_RANDOM_XOR_SHIFT_ENGINE_H_INCLUDED
 #define BEAST_RANDOM_XOR_SHIFT_ENGINE_H_INCLUDED
 
+#include <array>
 #include <cstdint>
 #include <limits>
-#include <stdexcept>
 
 namespace beast {
 
-namespace detail {
+/** MurmurHash3 64-bit finalizer (fmix64).
 
-template <class = void>
+    A bijective mixing function with strong avalanche behavior: every input
+    bit affects every output bit with probability ~0.5.
+
+    Commonly used for:
+    - Integer hashing
+    - Seed expansion for PRNGs
+    - Converting sequential values to uncorrelated values
+
+    @param x The input value to mix.
+    @return The mixed output value.
+*/
+[[nodiscard]] constexpr std::uint64_t
+fmix64(std::uint64_t x) noexcept
+{
+    x = 0xff51afd7ed558ccd * (x ^ (x >> 33));
+    x = 0xc4ceb9fe1a85ec53 * (x ^ (x >> 33));
+    return x ^ (x >> 33);
+}
+
+/** XOR-shift Generator.
+
+    Meets the requirements of UniformRandomNumberGenerator.
+
+    Simple and fast RNG based on:
+    http://xorshift.di.unimi.it/xorshift128plus.c
+*/
 class xor_shift_engine
 {
 public:
@@ -38,81 +63,37 @@ class xor_shift_engine
     xor_shift_engine&
     operator=(xor_shift_engine const&) = default;
 
-    explicit xor_shift_engine(result_type val = 1977u);
-
-    void
-    seed(result_type seed);
+    explicit constexpr xor_shift_engine(result_type val = 1977u) noexcept
+        : s_{(val * val) + 1, fmix64(val)}
+    {
+    }
 
-    result_type
-    operator()();
+    [[nodiscard]] constexpr result_type
+    operator()() noexcept
+    {
+        result_type s1 = s_[0];
+        result_type const s0 = s_[1];
+        s_[0] = s0;
+        s1 ^= s1 << 23;
+        return (s_[1] = (s1 ^ s0 ^ (s1 >> 17) ^ (s0 >> 26))) + s0;
+    }
 
-    static result_type constexpr min()
+    static constexpr result_type
+    min() noexcept
     {
         return std::numeric_limits<result_type>::min();
     }
 
-    static result_type constexpr max()
+    static constexpr result_type
+    max() noexcept
     {
         return std::numeric_limits<result_type>::max();
     }
 
 private:
-    result_type s_[2];
-
-    static result_type
-    murmurhash3(result_type x);
+    std::array<result_type, 2> s_;
 };
 
-template <class _>
-xor_shift_engine<_>::xor_shift_engine(result_type val)
-{
-    seed(val);
-}
-
-template <class _>
-void
-xor_shift_engine<_>::seed(result_type seed)
-{
-    if (seed == 0)
-        throw std::domain_error("invalid seed");
-    s_[0] = murmurhash3(seed);
-    s_[1] = murmurhash3(s_[0]);
-}
-
-template <class _>
-auto
-xor_shift_engine<_>::operator()() -> result_type
-{
-    result_type s1 = s_[0];
-    result_type const s0 = s_[1];
-    s_[0] = s0;
-    s1 ^= s1 << 23;
-    return (s_[1] = (s1 ^ s0 ^ (s1 >> 17) ^ (s0 >> 26))) + s0;
-}
-
-template <class _>
-auto
-xor_shift_engine<_>::murmurhash3(result_type x) -> result_type
-{
-    x ^= x >> 33;
-    x *= 0xff51afd7ed558ccdULL;
-    x ^= x >> 33;
-    x *= 0xc4ceb9fe1a85ec53ULL;
-    return x ^= x >> 33;
-}
-
-}  // namespace detail
-
-/** XOR-shift Generator.
-
-    Meets the requirements of UniformRandomNumberGenerator.
-
-    Simple and fast RNG based on:
-    http://xorshift.di.unimi.it/xorshift128plus.c
-    does not accept seed==0
-*/
-using xor_shift_engine = detail::xor_shift_engine<>;
-
 }  // namespace beast
 
 #endif

src/ripple/nodestore/backend/RWDBFactory.cpp

@@ -20,17 +20,6 @@ class RWDBBackend : public Backend
     beast::Journal journal_;
     bool isOpen_{false};
 
-    struct base_uint_hasher
-    {
-        using result_type = std::size_t;
-
-        result_type
-        operator()(base_uint<256> const& value) const
-        {
-            return hardened_hash<>{}(value);
-        }
-    };
-
     using DataStore =
         std::map<uint256, std::vector<std::uint8_t>>;  // Store compressed blob
                                                        // data