ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2025-11-19 18:45:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove per-process hash seeding for gcc.

Browse Source 
* gcc now seeds hardened_hash per instance.

* Other platforms were already doing this.
This commit is contained in:
Howard Hinnant
2019-10-28 14:55:28 -04:00
committed by Nik Bougalis
parent 5c1dd87fab
commit 14075630d4
1 changed files with 30 additions and 84 deletions
Download Patch File Download Diff File Expand all files Collapse all files

114
src/ripple/basics/hardened_hash.h
View File

@@ -32,17 +32,6 @@
#include <unordered_map>
#include <unordered_set>
// When set to 1, makes the seed per-process instead
// of per default-constructed instance of hardened_hash
//
#ifndef RIPPLE_NO_HARDENED_HASH_INSTANCE_SEED
# ifdef __GLIBCXX__
# define RIPPLE_NO_HARDENED_HASH_INSTANCE_SEED 1
# else
# define RIPPLE_NO_HARDENED_HASH_INSTANCE_SEED 0
# endif
#endif
namespace ripple {
namespace detail {
@@ -71,45 +60,38 @@ make_seed_pair() noexcept
}
template <class HashAlgorithm, bool ProcessSeeded>
class basic_hardened_hash;
/**
* Seed functor once per process
*/
template <class HashAlgorithm>
class basic_hardened_hash <HashAlgorithm, true>
{
private:
static
detail::seed_pair const&
init_seed_pair()
{
static detail::seed_pair const p = detail::make_seed_pair<>();
return p;
}
public:
explicit basic_hardened_hash() = default;
using result_type = typename HashAlgorithm::result_type;
template <class T>
result_type
operator()(T const& t) const noexcept
{
auto const [seed0, seed1] = init_seed_pair();
HashAlgorithm h(seed0, seed1);
hash_append(h, t);
return static_cast<result_type>(h);
}
};
/**
* Seed functor once per construction
A std compatible hash adapter that resists adversarial inputs.
For this to work, T must implement in its own namespace:
@code
template <class Hasher>
void
hash_append (Hasher& h, T const& t) noexcept
{
// hash_append each base and member that should
// participate in forming the hash
using beast::hash_append;
hash_append (h, static_cast<T::base1 const&>(t));
hash_append (h, static_cast<T::base2 const&>(t));
// ...
hash_append (h, t.member1);
hash_append (h, t.member2);
// ...
}
@endcode
Do not use any version of Murmur or CityHash for the Hasher
template parameter (the hashing algorithm). For details
see https://131002.net/siphash/#at
*/
template <class HashAlgorithm>
class basic_hardened_hash<HashAlgorithm, false>
template <class HashAlgorithm = beast::xxhasher>
class hardened_hash
{
private:
detail::seed_pair m_seeds;
@@ -117,7 +99,7 @@ private:
public:
using result_type = typename HashAlgorithm::result_type;
basic_hardened_hash()
hardened_hash()
: m_seeds (detail::make_seed_pair<>())
{}
@@ -131,42 +113,6 @@ public:
}
};
//------------------------------------------------------------------------------
/** A std compatible hash adapter that resists adversarial inputs.
For this to work, T must implement in its own namespace:
@code
template <class Hasher>
void
hash_append (Hasher& h, T const& t) noexcept
{
// hash_append each base and member that should
// participate in forming the hash
using beast::hash_append;
hash_append (h, static_cast<T::base1 const&>(t));
hash_append (h, static_cast<T::base2 const&>(t));
// ...
hash_append (h, t.member1);
hash_append (h, t.member2);
// ...
}
@endcode
Do not use any version of Murmur or CityHash for the Hasher
template parameter (the hashing algorithm). For details
see https://131002.net/siphash/#at
*/
#if RIPPLE_NO_HARDENED_HASH_INSTANCE_SEED
template <class HashAlgorithm = beast::xxhasher>
using hardened_hash = basic_hardened_hash<HashAlgorithm, true>;
#else
template <class HashAlgorithm = beast::xxhasher>
using hardened_hash = basic_hardened_hash<HashAlgorithm, false>;
#endif
} // ripple
#endif