src/hash.h

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2016 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 "crypto/ripemd160.h"
  10 #include "crypto/sha256.h"
  11 #include "prevector.h"
  12 #include "serialize.h"
  13 #include "uint256.h"
  14 #include "version.h"
  15
  16 #include <vector>
  17
  18 typedef uint256 ChainCode;
  19
  20 /** A hasher class for Bitcoin's 256-bit hash (double SHA-256). */
  21 class CHash256 {
  22 private:
  23     CSHA256 sha;
  24 public:
  25     static const size_t OUTPUT_SIZE = CSHA256::OUTPUT_SIZE;
  26
  27     void Finalize(unsigned char hash[OUTPUT_SIZE]) {
  28         unsigned char buf[CSHA256::OUTPUT_SIZE];
  29         sha.Finalize(buf);
  30         sha.Reset().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(hash);
  31     }
  32
  33     CHash256& Write(const unsigned char *data, size_t len) {
  34         sha.Write(data, len);
  35         return *this;
  36     }
  37
  38     CHash256& Reset() {
  39         sha.Reset();
  40         return *this;
  41     }
  42 };
  43
  44 /** A hasher class for Bitcoin's 160-bit hash (SHA-256 + RIPEMD-160). */
  45 class CHash160 {
  46 private:
  47     CSHA256 sha;
  48 public:
  49     static const size_t OUTPUT_SIZE = CRIPEMD160::OUTPUT_SIZE;
  50
  51     void Finalize(unsigned char hash[OUTPUT_SIZE]) {
  52         unsigned char buf[CSHA256::OUTPUT_SIZE];
  53         sha.Finalize(buf);
  54         CRIPEMD160().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(hash);
  55     }
  56
  57     CHash160& Write(const unsigned char *data, size_t len) {
  58         sha.Write(data, len);
  59         return *this;
  60     }
  61
  62     CHash160& Reset() {
  63         sha.Reset();
  64         return *this;
  65     }
  66 };
  67
  68 /** Compute the 256-bit hash of an object. */
  69 template<typename T1>
  70 inline uint256 Hash(const T1 pbegin, const T1 pend)
  71 {
  72     static const unsigned char pblank[1] = {};
  73     uint256 result;
  74     CHash256().Write(pbegin == pend ? pblank : (const unsigned char*)&pbegin[0], (pend - pbegin) * sizeof(pbegin[0]))
  75               .Finalize((unsigned char*)&result);
  76     return result;
  77 }
  78
  79 /** Compute the 256-bit hash of the concatenation of two objects. */
  80 template<typename T1, typename T2>
  81 inline uint256 Hash(const T1 p1begin, const T1 p1end,
  82                     const T2 p2begin, const T2 p2end) {
  83     static const unsigned char pblank[1] = {};
  84     uint256 result;
  85     CHash256().Write(p1begin == p1end ? pblank : (const unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0]))
  86               .Write(p2begin == p2end ? pblank : (const unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0]))
  87               .Finalize((unsigned char*)&result);
  88     return result;
  89 }
  90
  91 /** Compute the 256-bit hash of the concatenation of three objects. */
  92 template<typename T1, typename T2, typename T3>
  93 inline uint256 Hash(const T1 p1begin, const T1 p1end,
  94                     const T2 p2begin, const T2 p2end,
  95                     const T3 p3begin, const T3 p3end) {
  96     static const unsigned char pblank[1] = {};
  97     uint256 result;
  98     CHash256().Write(p1begin == p1end ? pblank : (const unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0]))
  99               .Write(p2begin == p2end ? pblank : (const unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0]))
 100               .Write(p3begin == p3end ? pblank : (const unsigned char*)&p3begin[0], (p3end - p3begin) * sizeof(p3begin[0]))
 101               .Finalize((unsigned char*)&result);
 102     return result;
 103 }
 104
 105 /** Compute the 160-bit hash an object. */
 106 template<typename T1>
 107 inline uint160 Hash160(const T1 pbegin, const T1 pend)
 108 {
 109     static unsigned char pblank[1] = {};
 110     uint160 result;
 111     CHash160().Write(pbegin == pend ? pblank : (const unsigned char*)&pbegin[0], (pend - pbegin) * sizeof(pbegin[0]))
 112               .Finalize((unsigned char*)&result);
 113     return result;
 114 }
 115
 116 /** Compute the 160-bit hash of a vector. */
 117 inline uint160 Hash160(const std::vector<unsigned char>& vch)
 118 {
 119     return Hash160(vch.begin(), vch.end());
 120 }
 121
 122 /** Compute the 160-bit hash of a vector. */
 123 template<unsigned int N>
 124 inline uint160 Hash160(const prevector<N, unsigned char>& vch)
 125 {
 126     return Hash160(vch.begin(), vch.end());
 127 }
 128
 129 /** A writer stream (for serialization) that computes a 256-bit hash. */
 130 class CHashWriter
 131 {
 132 private:
 133     CHash256 ctx;
 134
 135     const int nType;
 136     const int nVersion;
 137 public:
 138
 139     CHashWriter(int nTypeIn, int nVersionIn) : nType(nTypeIn), nVersion(nVersionIn) {}
 140
 141     int GetType() const { return nType; }
 142     int GetVersion() const { return nVersion; }
 143
 144     void write(const char *pch, size_t size) {
 145         ctx.Write((const unsigned char*)pch, size);
 146     }
 147
 148     // invalidates the object
 149     uint256 GetHash() {
 150         uint256 result;
 151         ctx.Finalize((unsigned char*)&result);
 152         return result;
 153     }
 154
 155     template<typename T>
 156     CHashWriter& operator<<(const T& obj) {
 157         // Serialize to this stream
 158         ::Serialize(*this, obj);
 159         return (*this);
 160     }
 161 };
 162
 163 /** Reads data from an underlying stream, while hashing the read data. */
 164 template<typename Source>
 165 class CHashVerifier : public CHashWriter
 166 {
 167 private:
 168     Source* source;
 169
 170 public:
 171     CHashVerifier(Source* source_) : CHashWriter(source_->GetType(), source_->GetVersion()), source(source_) {}
 172
 173     void read(char* pch, size_t nSize)
 174     {
 175         source->read(pch, nSize);
 176         this->write(pch, nSize);
 177     }
 178
 179     void ignore(size_t nSize)
 180     {
 181         char data[1024];
 182         while (nSize > 0) {
 183             size_t now = std::min<size_t>(nSize, 1024);
 184             read(data, now);
 185             nSize -= now;
 186         }
 187     }
 188
 189     template<typename T>
 190     CHashVerifier<Source>& operator>>(T& obj)
 191     {
 192         // Unserialize from this stream
 193         ::Unserialize(*this, obj);
 194         return (*this);
 195     }
 196 };
 197
 198 /** Compute the 256-bit hash of an object's serialization. */
 199 template<typename T>
 200 uint256 SerializeHash(const T& obj, int nType=SER_GETHASH, int nVersion=PROTOCOL_VERSION)
 201 {
 202     CHashWriter ss(nType, nVersion);
 203     ss << obj;
 204     return ss.GetHash();
 205 }
 206
 207 unsigned int MurmurHash3(unsigned int nHashSeed, const std::vector<unsigned char>& vDataToHash);
 208
 209 void BIP32Hash(const ChainCode &chainCode, unsigned int nChild, unsigned char header, const unsigned char data[32], unsigned char output[64]);
 210
 211 /** SipHash-2-4 */
 212 class CSipHasher
 213 {
 214 private:
 215     uint64_t v[4];
 216     uint64_t tmp;
 217     int count;
 218
 219 public:
 220     /** Construct a SipHash calculator initialized with 128-bit key (k0, k1) */
 221     CSipHasher(uint64_t k0, uint64_t k1);
 222     /** Hash a 64-bit integer worth of data
 223      *  It is treated as if this was the little-endian interpretation of 8 bytes.
 224      *  This function can only be used when a multiple of 8 bytes have been written so far.
 225      */
 226     CSipHasher& Write(uint64_t data);
 227     /** Hash arbitrary bytes. */
 228     CSipHasher& Write(const unsigned char* data, size_t size);
 229     /** Compute the 64-bit SipHash-2-4 of the data written so far. The object remains untouched. */
 230     uint64_t Finalize() const;
 231 };
 232
 233 /** Optimized SipHash-2-4 implementation for uint256.
 234  *
 235  *  It is identical to:
 236  *    SipHasher(k0, k1)
 237  *      .Write(val.GetUint64(0))
 238  *      .Write(val.GetUint64(1))
 239  *      .Write(val.GetUint64(2))
 240  *      .Write(val.GetUint64(3))
 241  *      .Finalize()
 242  */
 243 uint64_t SipHashUint256(uint64_t k0, uint64_t k1, const uint256& val);
 244 uint64_t SipHashUint256Extra(uint64_t k0, uint64_t k1, const uint256& val, uint32_t extra);
 245
 246 #endif // BITCOIN_HASH_H