/workdir/bitcoin/src/hash.h
Line | Count | Source (jump to first uncovered line) |
1 | | // Copyright (c) 2009-2010 Satoshi Nakamoto |
2 | | // Copyright (c) 2009-2022 The Bitcoin Core developers |
3 | | // Distributed under the MIT software license, see the accompanying |
4 | | // file COPYING or http://www.opensource.org/licenses/mit-license.php. |
5 | | |
6 | | #ifndef BITCOIN_HASH_H |
7 | | #define BITCOIN_HASH_H |
8 | | |
9 | | #include <attributes.h> |
10 | | #include <crypto/common.h> |
11 | | #include <crypto/ripemd160.h> |
12 | | #include <crypto/sha256.h> |
13 | | #include <prevector.h> |
14 | | #include <serialize.h> |
15 | | #include <span.h> |
16 | | #include <uint256.h> |
17 | | |
18 | | #include <string> |
19 | | #include <vector> |
20 | | |
21 | | typedef uint256 ChainCode; |
22 | | |
23 | | /** A hasher class for Bitcoin's 256-bit hash (double SHA-256). */ |
24 | | class CHash256 { |
25 | | private: |
26 | | CSHA256 sha; |
27 | | public: |
28 | | static const size_t OUTPUT_SIZE = CSHA256::OUTPUT_SIZE; |
29 | | |
30 | 30.9k | void Finalize(Span<unsigned char> output) { |
31 | 30.9k | assert(output.size() == OUTPUT_SIZE); |
32 | 30.9k | unsigned char buf[CSHA256::OUTPUT_SIZE]; |
33 | 30.9k | sha.Finalize(buf); |
34 | 30.9k | sha.Reset().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(output.data()); |
35 | 30.9k | } |
36 | | |
37 | 30.1k | CHash256& Write(Span<const unsigned char> input) { |
38 | 30.1k | sha.Write(input.data(), input.size()); |
39 | 30.1k | return *this; |
40 | 30.1k | } |
41 | | |
42 | 14.4k | CHash256& Reset() { |
43 | 14.4k | sha.Reset(); |
44 | 14.4k | return *this; |
45 | 14.4k | } |
46 | | }; |
47 | | |
48 | | /** A hasher class for Bitcoin's 160-bit hash (SHA-256 + RIPEMD-160). */ |
49 | | class CHash160 { |
50 | | private: |
51 | | CSHA256 sha; |
52 | | public: |
53 | | static const size_t OUTPUT_SIZE = CRIPEMD160::OUTPUT_SIZE; |
54 | | |
55 | 0 | void Finalize(Span<unsigned char> output) { |
56 | 0 | assert(output.size() == OUTPUT_SIZE); |
57 | 0 | unsigned char buf[CSHA256::OUTPUT_SIZE]; |
58 | 0 | sha.Finalize(buf); |
59 | 0 | CRIPEMD160().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(output.data()); |
60 | 0 | } |
61 | | |
62 | 0 | CHash160& Write(Span<const unsigned char> input) { |
63 | 0 | sha.Write(input.data(), input.size()); |
64 | 0 | return *this; |
65 | 0 | } |
66 | | |
67 | 0 | CHash160& Reset() { |
68 | 0 | sha.Reset(); |
69 | 0 | return *this; |
70 | 0 | } |
71 | | }; |
72 | | |
73 | | /** Compute the 256-bit hash of an object. */ |
74 | | template<typename T> |
75 | | inline uint256 Hash(const T& in1) |
76 | 17.4k | { |
77 | 17.4k | uint256 result; |
78 | 17.4k | CHash256().Write(MakeUCharSpan(in1)).Finalize(result); |
79 | 17.4k | return result; |
80 | 17.4k | } Unexecuted instantiation: uint256 Hash<Span<unsigned char const> >(Span<unsigned char const> const&) uint256 Hash<std::vector<unsigned char, std::allocator<unsigned char> > >(std::vector<unsigned char, std::allocator<unsigned char> > const&) Line | Count | Source | 76 | 17.4k | { | 77 | 17.4k | uint256 result; | 78 | 17.4k | CHash256().Write(MakeUCharSpan(in1)).Finalize(result); | 79 | 17.4k | return result; | 80 | 17.4k | } |
Unexecuted instantiation: uint256 Hash<std::span<unsigned char const, 18446744073709551615ul> >(std::span<unsigned char const, 18446744073709551615ul> const&) Unexecuted instantiation: uint256 Hash<Span<unsigned char> >(Span<unsigned char> const&) |
81 | | |
82 | | /** Compute the 256-bit hash of the concatenation of two objects. */ |
83 | | template<typename T1, typename T2> |
84 | 0 | inline uint256 Hash(const T1& in1, const T2& in2) { |
85 | 0 | uint256 result; |
86 | 0 | CHash256().Write(MakeUCharSpan(in1)).Write(MakeUCharSpan(in2)).Finalize(result); |
87 | 0 | return result; |
88 | 0 | } Unexecuted instantiation: uint256 Hash<uint256, uint256>(uint256 const&, uint256 const&) Unexecuted instantiation: uint256 Hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned char [8]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, unsigned char const (&) [8]) |
89 | | |
90 | | /** Compute the 160-bit hash an object. */ |
91 | | template<typename T1> |
92 | | inline uint160 Hash160(const T1& in1) |
93 | 0 | { |
94 | 0 | uint160 result; |
95 | 0 | CHash160().Write(MakeUCharSpan(in1)).Finalize(result); |
96 | 0 | return result; |
97 | 0 | } Unexecuted instantiation: uint160 Hash160<Span<unsigned char const> >(Span<unsigned char const> const&) Unexecuted instantiation: uint160 Hash160<std::vector<unsigned char, std::allocator<unsigned char> > >(std::vector<unsigned char, std::allocator<unsigned char> > const&) Unexecuted instantiation: uint160 Hash160<XOnlyPubKey>(XOnlyPubKey const&) Unexecuted instantiation: uint160 Hash160<CPubKey>(CPubKey const&) Unexecuted instantiation: uint160 Hash160<CScript>(CScript const&) |
98 | | |
99 | | /** A writer stream (for serialization) that computes a 256-bit hash. */ |
100 | | class HashWriter |
101 | | { |
102 | | private: |
103 | | CSHA256 ctx; |
104 | | |
105 | | public: |
106 | | void write(Span<const std::byte> src) |
107 | 2.19M | { |
108 | 2.19M | ctx.Write(UCharCast(src.data()), src.size()); |
109 | 2.19M | } |
110 | | |
111 | | /** Compute the double-SHA256 hash of all data written to this object. |
112 | | * |
113 | | * Invalidates this object. |
114 | | */ |
115 | 352k | uint256 GetHash() { |
116 | 352k | uint256 result; |
117 | 352k | ctx.Finalize(result.begin()); |
118 | 352k | ctx.Reset().Write(result.begin(), CSHA256::OUTPUT_SIZE).Finalize(result.begin()); |
119 | 352k | return result; |
120 | 352k | } |
121 | | |
122 | | /** Compute the SHA256 hash of all data written to this object. |
123 | | * |
124 | | * Invalidates this object. |
125 | | */ |
126 | 0 | uint256 GetSHA256() { |
127 | 0 | uint256 result; |
128 | 0 | ctx.Finalize(result.begin()); |
129 | 0 | return result; |
130 | 0 | } |
131 | | |
132 | | /** |
133 | | * Returns the first 64 bits from the resulting hash. |
134 | | */ |
135 | 0 | inline uint64_t GetCheapHash() { |
136 | 0 | uint256 result = GetHash(); |
137 | 0 | return ReadLE64(result.begin()); |
138 | 0 | } |
139 | | |
140 | | template <typename T> |
141 | | HashWriter& operator<<(const T& obj) |
142 | 1.02M | { |
143 | 1.02M | ::Serialize(*this, obj); |
144 | 1.02M | return *this; |
145 | 1.02M | } Unexecuted instantiation: HashWriter& HashWriter::operator<< <uint256>(uint256 const&) HashWriter& HashWriter::operator<< <Span<unsigned char const> >(Span<unsigned char const> const&) Line | Count | Source | 142 | 670k | { | 143 | 670k | ::Serialize(*this, obj); | 144 | 670k | return *this; | 145 | 670k | } |
Unexecuted instantiation: HashWriter& HashWriter::operator<< <std::vector<unsigned char, std::allocator<unsigned char> > >(std::vector<unsigned char, std::allocator<unsigned char> > const&) Unexecuted instantiation: HashWriter& HashWriter::operator<< <unsigned long>(unsigned long const&) Unexecuted instantiation: HashWriter& HashWriter::operator<< <unsigned char>(unsigned char const&) Unexecuted instantiation: HashWriter& HashWriter::operator<< <int>(int const&) Unexecuted instantiation: HashWriter& HashWriter::operator<< <std::vector<bool, std::allocator<bool> > >(std::vector<bool, std::allocator<bool> > const&) Unexecuted instantiation: HashWriter& HashWriter::operator<< <COutPoint>(COutPoint const&) Unexecuted instantiation: HashWriter& HashWriter::operator<< <unsigned int>(unsigned int const&) Unexecuted instantiation: HashWriter& HashWriter::operator<< <CTxOut>(CTxOut const&) Unexecuted instantiation: HashWriter& HashWriter::operator<< <CBlockUndo>(CBlockUndo const&) Unexecuted instantiation: HashWriter& HashWriter::operator<< <Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&> >(Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&> const&) Unexecuted instantiation: HashWriter& HashWriter::operator<< <Span<unsigned char> >(Span<unsigned char> const&) Unexecuted instantiation: HashWriter& HashWriter::operator<< <Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&> >(Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&> const&) Unexecuted instantiation: HashWriter& HashWriter::operator<< <transaction_identifier<true> >(transaction_identifier<true> const&) Unexecuted instantiation: HashWriter& HashWriter::operator<< <Span<char> >(Span<char> const&) Unexecuted instantiation: HashWriter& HashWriter::operator<< <std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) HashWriter& HashWriter::operator<< <CBlockHeader>(CBlockHeader const&) Line | Count | Source | 142 | 335k | { | 143 | 335k | ::Serialize(*this, obj); | 144 | 335k | return *this; | 145 | 335k | } |
Unexecuted instantiation: HashWriter& HashWriter::operator<< <ParamsWrapper<TransactionSerParams, CMutableTransaction const> >(ParamsWrapper<TransactionSerParams, CMutableTransaction const> const&) HashWriter& HashWriter::operator<< <ParamsWrapper<TransactionSerParams, CTransaction const> >(ParamsWrapper<TransactionSerParams, CTransaction const> const&) Line | Count | Source | 142 | 17.0k | { | 143 | 17.0k | ::Serialize(*this, obj); | 144 | 17.0k | return *this; | 145 | 17.0k | } |
Unexecuted instantiation: HashWriter& HashWriter::operator<< <long>(long const&) Unexecuted instantiation: HashWriter& HashWriter::operator<< <CScript>(CScript const&) Unexecuted instantiation: interpreter.cpp:HashWriter& HashWriter::operator<< <(anonymous namespace)::CTransactionSignatureSerializer<CTransaction> >((anonymous namespace)::CTransactionSignatureSerializer<CTransaction> const&) Unexecuted instantiation: interpreter.cpp:HashWriter& HashWriter::operator<< <(anonymous namespace)::CTransactionSignatureSerializer<CMutableTransaction> >((anonymous namespace)::CTransactionSignatureSerializer<CMutableTransaction> const&) Unexecuted instantiation: HashWriter& HashWriter::operator<< <CompactSizeWriter>(CompactSizeWriter const&) Unexecuted instantiation: HashWriter& HashWriter::operator<< <unsigned char [384]>(unsigned char const (&) [384]) |
146 | | }; |
147 | | |
148 | | /** Reads data from an underlying stream, while hashing the read data. */ |
149 | | template <typename Source> |
150 | | class HashVerifier : public HashWriter |
151 | | { |
152 | | private: |
153 | | Source& m_source; |
154 | | |
155 | | public: |
156 | 0 | explicit HashVerifier(Source& source LIFETIMEBOUND) : m_source{source} {} Unexecuted instantiation: HashVerifier<DataStream>::HashVerifier(DataStream&) Unexecuted instantiation: HashVerifier<AutoFile>::HashVerifier(AutoFile&) |
157 | | |
158 | | void read(Span<std::byte> dst) |
159 | 0 | { |
160 | 0 | m_source.read(dst); |
161 | 0 | this->write(dst); |
162 | 0 | } Unexecuted instantiation: HashVerifier<DataStream>::read(Span<std::byte>) Unexecuted instantiation: HashVerifier<AutoFile>::read(Span<std::byte>) |
163 | | |
164 | | void ignore(size_t num_bytes) |
165 | 0 | { |
166 | 0 | std::byte data[1024]; |
167 | 0 | while (num_bytes > 0) { Branch (167:16): [True: 0, False: 0]
Branch (167:16): [True: 0, False: 0]
|
168 | 0 | size_t now = std::min<size_t>(num_bytes, 1024); |
169 | 0 | read({data, now}); |
170 | 0 | num_bytes -= now; |
171 | 0 | } |
172 | 0 | } Unexecuted instantiation: HashVerifier<AutoFile>::ignore(unsigned long) Unexecuted instantiation: HashVerifier<DataStream>::ignore(unsigned long) |
173 | | |
174 | | template <typename T> |
175 | | HashVerifier<Source>& operator>>(T&& obj) |
176 | 0 | { |
177 | 0 | ::Unserialize(*this, obj); |
178 | 0 | return *this; |
179 | 0 | } Unexecuted instantiation: HashVerifier<DataStream>& HashVerifier<DataStream>::operator>><std::array<unsigned char, 4ul>&>(std::array<unsigned char, 4ul>&) Unexecuted instantiation: HashVerifier<DataStream>& HashVerifier<DataStream>::operator>><AddrMan&>(AddrMan&) Unexecuted instantiation: HashVerifier<AutoFile>& HashVerifier<AutoFile>::operator>><std::array<unsigned char, 4ul>&>(std::array<unsigned char, 4ul>&) Unexecuted instantiation: HashVerifier<AutoFile>& HashVerifier<AutoFile>::operator>><AddrMan&>(AddrMan&) Unexecuted instantiation: HashVerifier<AutoFile>& HashVerifier<AutoFile>::operator>><ParamsWrapper<CAddress::SerParams, std::vector<CAddress, std::allocator<CAddress> > >&>(ParamsWrapper<CAddress::SerParams, std::vector<CAddress, std::allocator<CAddress> > >&) Unexecuted instantiation: HashVerifier<AutoFile>& HashVerifier<AutoFile>::operator>><Wrapper<CustomUintFormatter<1, false>, AddrManImpl::Format&> >(Wrapper<CustomUintFormatter<1, false>, AddrManImpl::Format&>&&) Unexecuted instantiation: HashVerifier<DataStream>& HashVerifier<DataStream>::operator>><Wrapper<CustomUintFormatter<1, false>, AddrManImpl::Format&> >(Wrapper<CustomUintFormatter<1, false>, AddrManImpl::Format&>&&) Unexecuted instantiation: HashVerifier<AutoFile>& HashVerifier<AutoFile>::operator>><CBlockUndo&>(CBlockUndo&) Unexecuted instantiation: HashVerifier<AutoFile>& HashVerifier<AutoFile>::operator>><Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&> >(Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>&&) Unexecuted instantiation: HashVerifier<AutoFile>& HashVerifier<AutoFile>::operator>><Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&> >(Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&&) Unexecuted instantiation: HashVerifier<AutoFile>& HashVerifier<AutoFile>::operator>><Span<unsigned char> >(Span<unsigned char>&&) |
180 | | }; |
181 | | |
182 | | /** Writes data to an underlying source stream, while hashing the written data. */ |
183 | | template <typename Source> |
184 | | class HashedSourceWriter : public HashWriter |
185 | | { |
186 | | private: |
187 | | Source& m_source; |
188 | | |
189 | | public: |
190 | 0 | explicit HashedSourceWriter(Source& source LIFETIMEBOUND) : HashWriter{}, m_source{source} {} |
191 | | |
192 | | void write(Span<const std::byte> src) |
193 | 0 | { |
194 | 0 | m_source.write(src); |
195 | 0 | HashWriter::write(src); |
196 | 0 | } |
197 | | |
198 | | template <typename T> |
199 | | HashedSourceWriter& operator<<(const T& obj) |
200 | 0 | { |
201 | 0 | ::Serialize(*this, obj); |
202 | 0 | return *this; |
203 | 0 | } Unexecuted instantiation: HashedSourceWriter<AutoFile>& HashedSourceWriter<AutoFile>::operator<< <std::array<unsigned char, 4ul> >(std::array<unsigned char, 4ul> const&) Unexecuted instantiation: HashedSourceWriter<AutoFile>& HashedSourceWriter<AutoFile>::operator<< <AddrMan>(AddrMan const&) Unexecuted instantiation: HashedSourceWriter<AutoFile>& HashedSourceWriter<AutoFile>::operator<< <ParamsWrapper<CAddress::SerParams, std::vector<CAddress, std::allocator<CAddress> > const> >(ParamsWrapper<CAddress::SerParams, std::vector<CAddress, std::allocator<CAddress> > const> const&) |
204 | | }; |
205 | | |
206 | | /** Single-SHA256 a 32-byte input (represented as uint256). */ |
207 | | [[nodiscard]] uint256 SHA256Uint256(const uint256& input); |
208 | | |
209 | | unsigned int MurmurHash3(unsigned int nHashSeed, Span<const unsigned char> vDataToHash); |
210 | | |
211 | | void BIP32Hash(const ChainCode &chainCode, unsigned int nChild, unsigned char header, const unsigned char data[32], unsigned char output[64]); |
212 | | |
213 | | /** Return a HashWriter primed for tagged hashes (as specified in BIP 340). |
214 | | * |
215 | | * The returned object will have SHA256(tag) written to it twice (= 64 bytes). |
216 | | * A tagged hash can be computed by feeding the message into this object, and |
217 | | * then calling HashWriter::GetSHA256(). |
218 | | */ |
219 | | HashWriter TaggedHash(const std::string& tag); |
220 | | |
221 | | /** Compute the 160-bit RIPEMD-160 hash of an array. */ |
222 | | inline uint160 RIPEMD160(Span<const unsigned char> data) |
223 | 0 | { |
224 | 0 | uint160 result; |
225 | 0 | CRIPEMD160().Write(data.data(), data.size()).Finalize(result.begin()); |
226 | 0 | return result; |
227 | 0 | } |
228 | | |
229 | | #endif // BITCOIN_HASH_H |