1// Copyright (c) 2009-2010 Satoshi Nakamoto
2// Copyright (c) 2009-present 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 <support/cleanse.h>
17#include <uint256.h>
18
19#include <string>
20#include <vector>
21
22/** A BIP32 chain code. Cleansed on destruction. */
23class ChainCode : public base_blob<256> {
24public:
25    constexpr ChainCode() = default;
26    constexpr explicit ChainCode(std::span<const unsigned char> vch) : base_blob<256>(vch) {}
27    constexpr explicit ChainCode(const base_blob<256>& b) : base_blob<256>(b) {}
28    ~ChainCode() { memory_cleanse(data(), size()); }
29};
30
31/** A hasher class for Bitcoin's 256-bit hash (double SHA-256). */
32class CHash256 {
33private:
34    CSHA256 sha;
35public:
36    static constexpr size_t OUTPUT_SIZE{CSHA256::OUTPUT_SIZE};
37
38    void Finalize(std::span<unsigned char> output) {
39        assert(output.size() == OUTPUT_SIZE);
40        unsigned char buf[CSHA256::OUTPUT_SIZE];
41        sha.Finalize(buf);
42        sha.Reset().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(output.data());
43    }
44
45    CHash256& Write(std::span<const unsigned char> input) {
46        sha.Write(input.data(), input.size());
47        return *this;
48    }
49
50    CHash256& Reset() {
51        sha.Reset();
52        return *this;
53    }
54};
55
56/** A hasher class for Bitcoin's 160-bit hash (SHA-256 + RIPEMD-160). */
57class CHash160 {
58private:
59    CSHA256 sha;
60public:
61    static constexpr size_t OUTPUT_SIZE{CRIPEMD160::OUTPUT_SIZE};
62
63    void Finalize(std::span<unsigned char> output) {
64        assert(output.size() == OUTPUT_SIZE);
65        unsigned char buf[CSHA256::OUTPUT_SIZE];
66        sha.Finalize(buf);
67        CRIPEMD160().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(output.data());
68    }
69
70    CHash160& Write(std::span<const unsigned char> input) {
71        sha.Write(input.data(), input.size());
72        return *this;
73    }
74
75    CHash160& Reset() {
76        sha.Reset();
77        return *this;
78    }
79};
80
81/** Compute the 256-bit hash of an object. */
82template<typename T>
83inline uint256 Hash(const T& in1)
84{
85    uint256 result;
86    CHash256().Write(MakeUCharSpan(in1)).Finalize(result);
87    return result;
88}
89
90/** Compute the 256-bit hash of the concatenation of two objects. */
91template<typename T1, typename T2>
92inline uint256 Hash(const T1& in1, const T2& in2) {
93    uint256 result;
94    CHash256().Write(MakeUCharSpan(in1)).Write(MakeUCharSpan(in2)).Finalize(result);
95    return result;
96}
97
98/** Compute the 160-bit hash an object. */
99template<typename T1>
100inline uint160 Hash160(const T1& in1)
101{
102    uint160 result;
103    CHash160().Write(MakeUCharSpan(in1)).Finalize(result);
104    return result;
105}
106
107/** A writer stream (for serialization) that computes a 256-bit hash. */
108class HashWriter
109{
110private:
111    CSHA256 ctx;
112
113public:
114    void write(std::span<const std::byte> src)
115    {
116        ctx.Write(UCharCast(src.data()), src.size());
117    }
118
119    /** Compute the double-SHA256 hash of all data written to this object.
120     *
121     * Invalidates this object.
122     */
123    uint256 GetHash() {
124        uint256 result;
125        ctx.Finalize(result.begin());
126        ctx.Reset().Write(result.begin(), CSHA256::OUTPUT_SIZE).Finalize(result.begin());
127        return result;
128    }
129
130    /** Compute the SHA256 hash of all data written to this object.
131     *
132     * Invalidates this object.
133     */
134    uint256 GetSHA256() {
135        uint256 result;
136        ctx.Finalize(result.begin());
137        return result;
138    }
139
140    /**
141     * Returns the first 64 bits from the resulting hash.
142     */
143    inline uint64_t GetCheapHash() {
144        uint256 result = GetHash();
145        return ReadLE64(result.begin());
146    }
147
148    template <typename T>
149    HashWriter& operator<<(const T& obj)
150    {
151        ::Serialize(*this, obj);
152        return *this;
153    }
154};
155
156/** Reads data from an underlying stream, while hashing the read data. */
157template <typename Source>
158class HashVerifier : public HashWriter
159{
160private:
161    Source& m_source;
162
163public:
164    explicit HashVerifier(Source& source LIFETIMEBOUND) : m_source{source} {}
165
166    void read(std::span<std::byte> dst)
167    {
168        m_source.read(dst);
169        this->write(dst);
170    }
171
172    void ignore(size_t num_bytes)
173    {
174        std::byte data[1024];
175        while (num_bytes > 0) {
176            size_t now = std::min<size_t>(num_bytes, 1024);
177            read({data, now});
178            num_bytes -= now;
179        }
180    }
181
182    template <typename T>
183    HashVerifier<Source>& operator>>(T&& obj)
184    {
185        ::Unserialize(*this, obj);
186        return *this;
187    }
188};
189
190/** Writes data to an underlying source stream, while hashing the written data. */
191template <typename Source>
192class HashedSourceWriter : public HashWriter
193{
194private:
195    Source& m_source;
196
197public:
198    explicit HashedSourceWriter(Source& source LIFETIMEBOUND) : HashWriter{}, m_source{source} {}
199
200    void write(std::span<const std::byte> src)
201    {
202        m_source.write(src);
203        HashWriter::write(src);
204    }
205
206    template <typename T>
207    HashedSourceWriter& operator<<(const T& obj)
208    {
209        ::Serialize(*this, obj);
210        return *this;
211    }
212};
213
214/** Single-SHA256 a 32-byte input (represented as uint256). */
215[[nodiscard]] uint256 SHA256Uint256(const uint256& input);
216
217unsigned int MurmurHash3(unsigned int nHashSeed, std::span<const unsigned char> vDataToHash);
218
219void BIP32Hash(const ChainCode &chainCode, unsigned int nChild, unsigned char header, const unsigned char data[32], unsigned char output[64]);
220
221/** Return a HashWriter primed for tagged hashes (as specified in BIP 340).
222 *
223 * The returned object will have SHA256(tag) written to it twice (= 64 bytes).
224 * A tagged hash can be computed by feeding the message into this object, and
225 * then calling HashWriter::GetSHA256().
226 */
227HashWriter TaggedHash(const std::string& tag);
228
229/** Compute the 160-bit RIPEMD-160 hash of an array. */
230inline uint160 RIPEMD160(std::span<const unsigned char> data)
231{
232    uint160 result;
233    CRIPEMD160().Write(data.data(), data.size()).Finalize(result.begin());
234    return result;
235}
236
237#endif // BITCOIN_HASH_H
238