Line data    Source code

       1             : // Copyright (c) 2009-2010 Satoshi Nakamoto
       2             : // Copyright (c) 2009-2018 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 <uint256.h>
      16             : #include <version.h>
      17             : 
      18             : #include <vector>
      19             : 
      20             : typedef uint256 ChainCode;
      21             : 
      22             : /** A hasher class for Bitcoin's 256-bit hash (double SHA-256). */
      23     2318358 : class CHash256 {
      24             : private:
      25             :     CSHA256 sha;
      26             : public:
      27             :     static const size_t OUTPUT_SIZE = CSHA256::OUTPUT_SIZE;
      28             : 
      29     1245288 :     void Finalize(Span<unsigned char> output) {
      30     1245288 :         assert(output.size() == OUTPUT_SIZE);
      31     1245289 :         unsigned char buf[CSHA256::OUTPUT_SIZE];
      32     1245289 :         sha.Finalize(buf);
      33     1245289 :         sha.Reset().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(output.data());
      34     1245289 :     }
      35             : 
      36     2207751 :     CHash256& Write(Span<const unsigned char> input) {
      37     2207751 :         sha.Write(input.data(), input.size());
      38     2207751 :         return *this;
      39             :     }
      40             : 
      41       87568 :     CHash256& Reset() {
      42       87568 :         sha.Reset();
      43       87568 :         return *this;
      44             :     }
      45             : };
      46             : 
      47             : /** A hasher class for Bitcoin's 160-bit hash (SHA-256 + RIPEMD-160). */
      48     6445046 : class CHash160 {
      49             : private:
      50             :     CSHA256 sha;
      51             : public:
      52             :     static const size_t OUTPUT_SIZE = CRIPEMD160::OUTPUT_SIZE;
      53             : 
      54     3222576 :     void Finalize(Span<unsigned char> output) {
      55     3222576 :         assert(output.size() == OUTPUT_SIZE);
      56     3222586 :         unsigned char buf[CSHA256::OUTPUT_SIZE];
      57     3222586 :         sha.Finalize(buf);
      58     3222586 :         CRIPEMD160().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(output.data());
      59     3222586 :     }
      60             : 
      61     3222543 :     CHash160& Write(Span<const unsigned char> input) {
      62     3222543 :         sha.Write(input.data(), input.size());
      63     3222543 :         return *this;
      64             :     }
      65             : 
      66             :     CHash160& Reset() {
      67             :         sha.Reset();
      68             :         return *this;
      69             :     }
      70             : };
      71             : 
      72             : /** Compute the 256-bit hash of an object. */
      73             : template<typename T>
      74      233118 : inline uint256 Hash(const T& in1)
      75             : {
      76      233118 :     uint256 result;
      77      233118 :     CHash256().Write(MakeUCharSpan(in1)).Finalize(result);
      78      233118 :     return result;
      79             : }
      80             : 
      81             : /** Compute the 256-bit hash of the concatenation of two objects. */
      82             : template<typename T1, typename T2>
      83      355552 : inline uint256 Hash(const T1& in1, const T2& in2) {
      84      355552 :     uint256 result;
      85      355552 :     CHash256().Write(MakeUCharSpan(in1)).Write(MakeUCharSpan(in2)).Finalize(result);
      86      355552 :     return result;
      87             : }
      88             : 
      89             : /** Compute the 160-bit hash an object. */
      90             : template<typename T1>
      91     2287518 : inline uint160 Hash160(const T1& in1)
      92             : {
      93     2287518 :     uint160 result;
      94     2287518 :     CHash160().Write(MakeUCharSpan(in1)).Finalize(result);
      95     2287518 :     return result;
      96             : }
      97             : 
      98             : /** A writer stream (for serialization) that computes a 256-bit hash. */
      99             : class CHashWriter
     100             : {
     101             : private:
     102             :     CSHA256 ctx;
     103             : 
     104             :     const int nType;
     105             :     const int nVersion;
     106             : public:
     107             : 
     108    16286470 :     CHashWriter(int nTypeIn, int nVersionIn) : nType(nTypeIn), nVersion(nVersionIn) {}
     109             : 
     110       24885 :     int GetType() const { return nType; }
     111     1182615 :     int GetVersion() const { return nVersion; }
     112             : 
     113   160232088 :     void write(const char *pch, size_t size) {
     114   160232088 :         ctx.Write((const unsigned char*)pch, size);
     115   160232088 :     }
     116             : 
     117             :     /** Compute the double-SHA256 hash of all data written to this object.
     118             :      *
     119             :      * Invalidates this object.
     120             :      */
     121     8008319 :     uint256 GetHash() {
     122     8008319 :         uint256 result;
     123     8008319 :         ctx.Finalize(result.begin());
     124     8008319 :         ctx.Reset().Write(result.begin(), CSHA256::OUTPUT_SIZE).Finalize(result.begin());
     125     8008319 :         return result;
     126             :     }
     127             : 
     128             :     /** Compute the SHA256 hash of all data written to this object.
     129             :      *
     130             :      * Invalidates this object.
     131             :      */
     132      141351 :     uint256 GetSHA256() {
     133      141351 :         uint256 result;
     134      141351 :         ctx.Finalize(result.begin());
     135      141351 :         return result;
     136             :     }
     137             : 
     138             :     /**
     139             :      * Returns the first 64 bits from the resulting hash.
     140             :      */
     141     4965094 :     inline uint64_t GetCheapHash() {
     142     4965094 :         uint256 result = GetHash();
     143     9930188 :         return ReadLE64(result.begin());
     144     4965094 :     }
     145             : 
     146             :     template<typename T>
     147    74644109 :     CHashWriter& operator<<(const T& obj) {
     148             :         // Serialize to this stream
     149    74644109 :         ::Serialize(*this, obj);
     150    74644109 :         return (*this);
     151             :     }
     152             : };
     153             : 
     154             : /** Reads data from an underlying stream, while hashing the read data. */
     155             : template<typename Source>
     156             : class CHashVerifier : public CHashWriter
     157             : {
     158             : private:
     159             :     Source* source;
     160             : 
     161             : public:
     162       23358 :     explicit CHashVerifier(Source* source_) : CHashWriter(source_->GetType(), source_->GetVersion()), source(source_) {}
     163             : 
     164      350418 :     void read(char* pch, size_t nSize)
     165             :     {
     166      350418 :         source->read(pch, nSize);
     167      350418 :         this->write(pch, nSize);
     168      350418 :     }
     169             : 
     170           0 :     void ignore(size_t nSize)
     171             :     {
     172           0 :         char data[1024];
     173           0 :         while (nSize > 0) {
     174           0 :             size_t now = std::min<size_t>(nSize, 1024);
     175           0 :             read(data, now);
     176           0 :             nSize -= now;
     177             :         }
     178           0 :     }
     179             : 
     180             :     template<typename T>
     181      261251 :     CHashVerifier<Source>& operator>>(T&& obj)
     182             :     {
     183             :         // Unserialize from this stream
     184      261251 :         ::Unserialize(*this, obj);
     185      261251 :         return (*this);
     186             :     }
     187             : };
     188             : 
     189             : /** Compute the 256-bit hash of an object's serialization. */
     190             : template<typename T>
     191     2621666 : uint256 SerializeHash(const T& obj, int nType=SER_GETHASH, int nVersion=PROTOCOL_VERSION)
     192             : {
     193     2621666 :     CHashWriter ss(nType, nVersion);
     194     2621666 :     ss << obj;
     195     2621666 :     return ss.GetHash();
     196     2621666 : }
     197             : 
     198             : /** Single-SHA256 a 32-byte input (represented as uint256). */
     199             : NODISCARD uint256 SHA256Uint256(const uint256& input);
     200             : 
     201             : unsigned int MurmurHash3(unsigned int nHashSeed, Span<const unsigned char> vDataToHash);
     202             : 
     203             : void BIP32Hash(const ChainCode &chainCode, unsigned int nChild, unsigned char header, const unsigned char data[32], unsigned char output[64]);
     204             : 
     205             : #endif // BITCOIN_HASH_H