/root/bitcoin/src/util/hasher.h

Source (jump to first uncovered line)
// Copyright (c) 2019-2022 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#ifndef BITCOIN_UTIL_HASHER_H
#define BITCOIN_UTIL_HASHER_H

#include <crypto/common.h>
#include <crypto/siphash.h>
#include <primitives/transaction.h>
#include <uint256.h>

#include <cstdint>
#include <cstring>

template <typename C> class Span;

class SaltedTxidHasher
{
private:
    /** Salt */
    const uint64_t k0, k1;

public:
    SaltedTxidHasher();

    size_t operator()(const uint256& txid) const {
        return SipHashUint256(k0, k1, txid);
    }
};

class SaltedOutpointHasher
{
private:
    /** Salt */
    const uint64_t k0, k1;

public:
    SaltedOutpointHasher(bool deterministic = false);

    /**
     * Having the hash noexcept allows libstdc++'s unordered_map to recalculate
     * the hash during rehash, so it does not have to cache the value. This
     * reduces node's memory by sizeof(size_t). The required recalculation has
     * a slight performance penalty (around 1.6%), but this is compensated by
     * memory savings of about 9% which allow for a larger dbcache setting.
     *
     * @see https://gcc.gnu.org/onlinedocs/gcc-13.2.0/libstdc++/manual/manual/unordered_associative.html
     */
    size_t operator()(const COutPoint& id) const noexcept {
        return SipHashUint256Extra(k0, k1, id.hash, id.n);
    }
};

struct FilterHeaderHasher
{
    size_t operator()(const uint256& hash) const { return ReadLE64(hash.begin()); }
};

/**
 * We're hashing a nonce into the entries themselves, so we don't need extra
 * blinding in the set hash computation.
 *
 * This may exhibit platform endian dependent behavior but because these are
 * nonced hashes (random) and this state is only ever used locally it is safe.
 * All that matters is local consistency.
 */
class SignatureCacheHasher
{
public:
    template <uint8_t hash_select>
    uint32_t operator()(const uint256& key) const
    {
        static_assert(hash_select <8, "SignatureCacheHasher only has 8 hashes available.");
        uint32_t u;
        std::memcpy(&u, key.begin()+4*hash_select, 4);
        return u;
    }
};

struct BlockHasher
{
    // this used to call `GetCheapHash()` in uint256, which was later moved; the
    // cheap hash function simply calls ReadLE64() however, so the end result is
    // identical
    size_t operator()(const uint256& hash) const { return ReadLE64(hash.begin()); }
};

class SaltedSipHasher
{
private:
    /** Salt */
    const uint64_t m_k0, m_k1;

public:
    SaltedSipHasher();

    size_t operator()(const Span<const unsigned char>& script) const;
};

#endif // BITCOIN_UTIL_HASHER_H

Line	Count	Source (jump to first uncovered line)
1		// Copyright (c) 2019-2022 The Bitcoin Core developers
2		// Distributed under the MIT software license, see the accompanying
3		// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5		#ifndef BITCOIN_UTIL_HASHER_H
6		#define BITCOIN_UTIL_HASHER_H
7
8		#include <crypto/common.h>
9		#include <crypto/siphash.h>
10		#include <primitives/transaction.h>
11		#include <uint256.h>
12
13		#include <cstdint>
14		#include <cstring>
15
16		template <typename C> class Span;
17
18		class SaltedTxidHasher
19		{
20		private:
21		/** Salt */
22		const uint64_t k0, k1;
23
24		public:
25		SaltedTxidHasher();
26
27	123k	size_t operator()(const uint256& txid) const {
28	123k	return SipHashUint256(k0, k1, txid);
29	123k	}
30		};
31
32		class SaltedOutpointHasher
33		{
34		private:
35		/** Salt */
36		const uint64_t k0, k1;
37
38		public:
39		SaltedOutpointHasher(bool deterministic = false);
40
41		/**
42		* Having the hash noexcept allows libstdc++'s unordered_map to recalculate
43		* the hash during rehash, so it does not have to cache the value. This
44		* reduces node's memory by sizeof(size_t). The required recalculation has
45		* a slight performance penalty (around 1.6%), but this is compensated by
46		* memory savings of about 9% which allow for a larger dbcache setting.
47		*
48		* @see https://gcc.gnu.org/onlinedocs/gcc-13.2.0/libstdc++/manual/manual/unordered_associative.html
49		*/
50	0	size_t operator()(const COutPoint& id) const noexcept {
51	0	return SipHashUint256Extra(k0, k1, id.hash, id.n);
52	0	}
53		};
54
55		struct FilterHeaderHasher
56		{
57	0	size_t operator()(const uint256& hash) const { return ReadLE64(hash.begin()); }
58		};
59
60		/**
61		* We're hashing a nonce into the entries themselves, so we don't need extra
62		* blinding in the set hash computation.
63		*
64		* This may exhibit platform endian dependent behavior but because these are
65		* nonced hashes (random) and this state is only ever used locally it is safe.
66		* All that matters is local consistency.
67		*/
68		class SignatureCacheHasher
69		{
70		public:
71		template <uint8_t hash_select>
72		uint32_t operator()(const uint256& key) const
73	0	{
74	0	static_assert(hash_select <8, "SignatureCacheHasher only has 8 hashes available.");
75	0	uint32_t u;
76	0	std::memcpy(&u, key.begin()+4*hash_select, 4);
77	0	return u;
78	0	} Unexecuted instantiation: _ZNK20SignatureCacheHasherclILh0EEEjRK7uint256 Unexecuted instantiation: _ZNK20SignatureCacheHasherclILh1EEEjRK7uint256 Unexecuted instantiation: _ZNK20SignatureCacheHasherclILh2EEEjRK7uint256 Unexecuted instantiation: _ZNK20SignatureCacheHasherclILh3EEEjRK7uint256 Unexecuted instantiation: _ZNK20SignatureCacheHasherclILh4EEEjRK7uint256 Unexecuted instantiation: _ZNK20SignatureCacheHasherclILh5EEEjRK7uint256 Unexecuted instantiation: _ZNK20SignatureCacheHasherclILh6EEEjRK7uint256 Unexecuted instantiation: _ZNK20SignatureCacheHasherclILh7EEEjRK7uint256
79		};
80
81		struct BlockHasher
82		{
83		// this used to call `GetCheapHash()` in uint256, which was later moved; the
84		// cheap hash function simply calls ReadLE64() however, so the end result is
85		// identical
86	0	size_t operator()(const uint256& hash) const { return ReadLE64(hash.begin()); }
87		};
88
89		class SaltedSipHasher
90		{
91		private:
92		/** Salt */
93		const uint64_t m_k0, m_k1;
94
95		public:
96		SaltedSipHasher();
97
98		size_t operator()(const Span<const unsigned char>& script) const;
99		};
100
101		#endif // BITCOIN_UTIL_HASHER_H

Coverage Report

Created: 2024-10-29 12:10