Branch data     Line data    Source code

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