src/hash.h

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2013 The Bitcoin Core developers
   3 // Distributed under the MIT software license, see the accompanying
   4 // file COPYING or https://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 "sodium.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 class CHash256 {
  24 private:
  25     CSHA256 sha;
  26 public:
  27     static const size_t OUTPUT_SIZE = CSHA256::OUTPUT_SIZE;
  28
  29     void Finalize(unsigned char hash[OUTPUT_SIZE]) {
  30         unsigned char buf[sha.OUTPUT_SIZE];
  31         sha.Finalize(buf);
  32         sha.Reset().Write(buf, sha.OUTPUT_SIZE).Finalize(hash);
  33     }
  34
  35     CHash256& Write(const unsigned char *data, size_t len) {
  36         sha.Write(data, len);
  37         return *this;
  38     }
  39
  40     CHash256& Reset() {
  41         sha.Reset();
  42         return *this;
  43     }
  44 };
  45
  46 /** A hasher class for Bitcoin's 160-bit hash (SHA-256 + RIPEMD-160). */
  47 class CHash160 {
  48 private:
  49     CSHA256 sha;
  50 public:
  51     static const size_t OUTPUT_SIZE = CRIPEMD160::OUTPUT_SIZE;
  52
  53     void Finalize(unsigned char hash[OUTPUT_SIZE]) {
  54         unsigned char buf[sha.OUTPUT_SIZE];
  55         sha.Finalize(buf);
  56         CRIPEMD160().Write(buf, sha.OUTPUT_SIZE).Finalize(hash);
  57     }
  58
  59     CHash160& Write(const unsigned char *data, size_t len) {
  60         sha.Write(data, len);
  61         return *this;
  62     }
  63
  64     CHash160& Reset() {
  65         sha.Reset();
  66         return *this;
  67     }
  68 };
  69
  70 /** Compute the 256-bit hash of an object. */
  71 template<typename T1>
  72 inline uint256 Hash(const T1 pbegin, const T1 pend)
  73 {
  74     static const unsigned char pblank[1] = {};
  75     uint256 result;
  76     CHash256().Write(pbegin == pend ? pblank : (const unsigned char*)&pbegin[0], (pend - pbegin) * sizeof(pbegin[0]))
  77               .Finalize((unsigned char*)&result);
  78     return result;
  79 }
  80
  81 /** Compute the 256-bit hash of the concatenation of two objects. */
  82 template<typename T1, typename T2>
  83 inline uint256 Hash(const T1 p1begin, const T1 p1end,
  84                     const T2 p2begin, const T2 p2end) {
  85     static const unsigned char pblank[1] = {};
  86     uint256 result;
  87     CHash256().Write(p1begin == p1end ? pblank : (const unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0]))
  88               .Write(p2begin == p2end ? pblank : (const unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0]))
  89               .Finalize((unsigned char*)&result);
  90     return result;
  91 }
  92
  93 /** Compute the 256-bit hash of the concatenation of three objects. */
  94 template<typename T1, typename T2, typename T3>
  95 inline uint256 Hash(const T1 p1begin, const T1 p1end,
  96                     const T2 p2begin, const T2 p2end,
  97                     const T3 p3begin, const T3 p3end) {
  98     static const unsigned char pblank[1] = {};
  99     uint256 result;
 100     CHash256().Write(p1begin == p1end ? pblank : (const unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0]))
 101               .Write(p2begin == p2end ? pblank : (const unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0]))
 102               .Write(p3begin == p3end ? pblank : (const unsigned char*)&p3begin[0], (p3end - p3begin) * sizeof(p3begin[0]))
 103               .Finalize((unsigned char*)&result);
 104     return result;
 105 }
 106
 107 /** Compute the 160-bit hash an object. */
 108 template<typename T1>
 109 inline uint160 Hash160(const T1 pbegin, const T1 pend)
 110 {
 111     static unsigned char pblank[1] = {};
 112     uint160 result;
 113     CHash160().Write(pbegin == pend ? pblank : (const unsigned char*)&pbegin[0], (pend - pbegin) * sizeof(pbegin[0]))
 114               .Finalize((unsigned char*)&result);
 115     return result;
 116 }
 117
 118 /** Compute the 160-bit hash of a vector. */
 119 inline uint160 Hash160(const std::vector<unsigned char>& vch)
 120 {
 121     return Hash160(vch.begin(), vch.end());
 122 }
 123
 124 /** Compute the 160-bit hash of a vector. */
 125 template<unsigned int N>
 126 inline uint160 Hash160(const prevector<N, unsigned char>& vch)
 127 {
 128     return Hash160(vch.begin(), vch.end());
 129 }
 130
 131 /** A writer stream (for serialization) that computes a 256-bit hash. */
 132 class CHashWriter
 133 {
 134 private:
 135     CHash256 ctx;
 136
 137     const int nType;
 138     const int nVersion;
 139 public:
 140
 141     CHashWriter(int nTypeIn, int nVersionIn) : nType(nTypeIn), nVersion(nVersionIn) {}
 142
 143     int GetType() const { return nType; }
 144     int GetVersion() const { return nVersion; }
 145
 146     void write(const char *pch, size_t size) {
 147         ctx.Write((const unsigned char*)pch, size);
 148     }
 149
 150     // invalidates the object
 151     uint256 GetHash() {
 152         uint256 result;
 153         ctx.Finalize((unsigned char*)&result);
 154         return result;
 155     }
 156
 157     template<typename T>
 158     CHashWriter& operator<<(const T& obj) {
 159         // Serialize to this stream
 160         ::Serialize(*this, obj);
 161         return (*this);
 162     }
 163 };
 164
 165
 166 /** A writer stream (for serialization) that computes a 256-bit BLAKE2b hash. */
 167 class CBLAKE2bWriter
 168 {
 169 private:
 170     crypto_generichash_blake2b_state state;
 171
 172 public:
 173     int nType;
 174     int nVersion;
 175
 176     CBLAKE2bWriter(int nTypeIn, int nVersionIn, const unsigned char* personal) : nType(nTypeIn), nVersion(nVersionIn) {
 177         assert(crypto_generichash_blake2b_init_salt_personal(
 178             &state,
 179             NULL, 0, // No key.
 180             32,
 181             NULL,    // No salt.
 182             personal) == 0);
 183     }
 184
 185     int GetType() const { return nType; }
 186     int GetVersion() const { return nVersion; }
 187
 188     CBLAKE2bWriter& write(const char *pch, size_t size) {
 189         crypto_generichash_blake2b_update(&state, (const unsigned char*)pch, size);
 190         return (*this);
 191     }
 192
 193     // invalidates the object
 194     uint256 GetHash() {
 195         uint256 result;
 196         crypto_generichash_blake2b_final(&state, (unsigned char*)&result, 32);
 197         return result;
 198     }
 199
 200     template<typename T>
 201     CBLAKE2bWriter& operator<<(const T& obj) {
 202         // Serialize to this stream
 203         ::Serialize(*this, obj);
 204         return (*this);
 205     }
 206 };
 207
 208
 209 /** Compute the 256-bit hash of an object's serialization. */
 210 template<typename T>
 211 uint256 SerializeHash(const T& obj, int nType=SER_GETHASH, int nVersion=PROTOCOL_VERSION)
 212 {
 213     CHashWriter ss(nType, nVersion);
 214     ss << obj;
 215     return ss.GetHash();
 216 }
 217
 218 unsigned int MurmurHash3(unsigned int nHashSeed, const std::vector<unsigned char>& vDataToHash);
 219
 220 void BIP32Hash(const ChainCode &chainCode, unsigned int nChild, unsigned char header, const unsigned char data[32], unsigned char output[64]);
 221
 222 #endif // BITCOIN_HASH_H