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 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 "crypto/verus_hash.h"
  12 #include "prevector.h"
  13 #include "serialize.h"
  14 #include "uint256.h"
  15 #include "version.h"
  16
  17 #include "sodium.h"
  18
  19 #include <vector>
  20
  21 typedef uint256 ChainCode;
  22
  23 /** A hasher class for Bitcoin's 256-bit hash (double SHA-256). */
  24 class CHash256 {
  25 private:
  26     CSHA256 sha;
  27 public:
  28     static const size_t OUTPUT_SIZE = CSHA256::OUTPUT_SIZE;
  29
  30     void Finalize(unsigned char hash[OUTPUT_SIZE]) {
  31         unsigned char buf[sha.OUTPUT_SIZE];
  32         sha.Finalize(buf);
  33         sha.Reset().Write(buf, sha.OUTPUT_SIZE).Finalize(hash);
  34     }
  35
  36     CHash256& Write(const unsigned char *data, size_t len) {
  37         sha.Write(data, len);
  38         return *this;
  39     }
  40
  41     CHash256& Reset() {
  42         sha.Reset();
  43         return *this;
  44     }
  45 };
  46
  47 /** A hasher class for Bitcoin's 160-bit hash (SHA-256 + RIPEMD-160). */
  48 class CHash160 {
  49 private:
  50     CSHA256 sha;
  51 public:
  52     static const size_t OUTPUT_SIZE = CRIPEMD160::OUTPUT_SIZE;
  53
  54     void Finalize(unsigned char hash[OUTPUT_SIZE]) {
  55         unsigned char buf[sha.OUTPUT_SIZE];
  56         sha.Finalize(buf);
  57         CRIPEMD160().Write(buf, sha.OUTPUT_SIZE).Finalize(hash);
  58     }
  59
  60     CHash160& Write(const unsigned char *data, size_t len) {
  61         sha.Write(data, len);
  62         return *this;
  63     }
  64
  65     CHash160& Reset() {
  66         sha.Reset();
  67         return *this;
  68     }
  69 };
  70
  71 /** Compute the 256-bit hash of an object. */
  72 template<typename T1>
  73 inline uint256 Hash(const T1 pbegin, const T1 pend)
  74 {
  75     static const unsigned char pblank[1] = {};
  76     uint256 result;
  77     CHash256().Write(pbegin == pend ? pblank : (const unsigned char*)&pbegin[0], (pend - pbegin) * sizeof(pbegin[0]))
  78               .Finalize((unsigned char*)&result);
  79     return result;
  80 }
  81
  82 /** Compute the 256-bit hash of the concatenation of two objects. */
  83 template<typename T1, typename T2>
  84 inline uint256 Hash(const T1 p1begin, const T1 p1end,
  85                     const T2 p2begin, const T2 p2end) {
  86     static const unsigned char pblank[1] = {};
  87     uint256 result;
  88     CHash256().Write(p1begin == p1end ? pblank : (const unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0]))
  89               .Write(p2begin == p2end ? pblank : (const unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0]))
  90               .Finalize((unsigned char*)&result);
  91     return result;
  92 }
  93
  94 /** Compute the 256-bit hash of the concatenation of three objects. */
  95 template<typename T1, typename T2, typename T3>
  96 inline uint256 Hash(const T1 p1begin, const T1 p1end,
  97                     const T2 p2begin, const T2 p2end,
  98                     const T3 p3begin, const T3 p3end) {
  99     static const unsigned char pblank[1] = {};
 100     uint256 result;
 101     CHash256().Write(p1begin == p1end ? pblank : (const unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0]))
 102               .Write(p2begin == p2end ? pblank : (const unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0]))
 103               .Write(p3begin == p3end ? pblank : (const unsigned char*)&p3begin[0], (p3end - p3begin) * sizeof(p3begin[0]))
 104               .Finalize((unsigned char*)&result);
 105     return result;
 106 }
 107
 108 /** Compute the 160-bit hash an object. */
 109 template<typename T1>
 110 inline uint160 Hash160(const T1 pbegin, const T1 pend)
 111 {
 112     static unsigned char pblank[1] = {};
 113     uint160 result;
 114     CHash160().Write(pbegin == pend ? pblank : (const unsigned char*)&pbegin[0], (pend - pbegin) * sizeof(pbegin[0]))
 115               .Finalize((unsigned char*)&result);
 116     return result;
 117 }
 118
 119 /** Compute the 160-bit hash of a vector. */
 120 inline uint160 Hash160(const std::vector<unsigned char>& vch)
 121 {
 122     return Hash160(vch.begin(), vch.end());
 123 }
 124
 125 /** Compute the 160-bit hash of a vector. */
 126 template<unsigned int N>
 127 inline uint160 Hash160(const prevector<N, unsigned char>& vch)
 128 {
 129     return Hash160(vch.begin(), vch.end());
 130 }
 131
 132 /** A writer stream (for serialization) that computes a 256-bit hash. */
 133 class CHashWriter
 134 {
 135 private:
 136     CHash256 ctx;
 137
 138     const int nType;
 139     const int nVersion;
 140 public:
 141
 142     CHashWriter(int nTypeIn, int nVersionIn) : nType(nTypeIn), nVersion(nVersionIn) {}
 143
 144     int GetType() const { return nType; }
 145     int GetVersion() const { return nVersion; }
 146
 147     void write(const char *pch, size_t size) {
 148         ctx.Write((const unsigned char*)pch, size);
 149     }
 150
 151     // invalidates the object
 152     uint256 GetHash() {
 153         uint256 result;
 154         ctx.Finalize((unsigned char*)&result);
 155         return result;
 156     }
 157
 158     template<typename T>
 159     CHashWriter& operator<<(const T& obj) {
 160         // Serialize to this stream
 161         ::Serialize(*this, obj);
 162         return (*this);
 163     }
 164 };
 165
 166
 167 /** A writer stream (for serialization) that computes a 256-bit BLAKE2b hash. */
 168 class CBLAKE2bWriter
 169 {
 170 private:
 171     crypto_generichash_blake2b_state state;
 172
 173 public:
 174     int nType;
 175     int nVersion;
 176
 177     CBLAKE2bWriter(int nTypeIn, int nVersionIn, const unsigned char* personal) : nType(nTypeIn), nVersion(nVersionIn) {
 178         assert(crypto_generichash_blake2b_init_salt_personal(
 179             &state,
 180             NULL, 0, // No key.
 181             32,
 182             NULL,    // No salt.
 183             personal) == 0);
 184     }
 185
 186     int GetType() const { return nType; }
 187     int GetVersion() const { return nVersion; }
 188
 189     CBLAKE2bWriter& write(const char *pch, size_t size) {
 190         crypto_generichash_blake2b_update(&state, (const unsigned char*)pch, size);
 191         return (*this);
 192     }
 193
 194     // invalidates the object
 195     uint256 GetHash() {
 196         uint256 result;
 197         crypto_generichash_blake2b_final(&state, (unsigned char*)&result, 32);
 198         return result;
 199     }
 200
 201     template<typename T>
 202     CBLAKE2bWriter& operator<<(const T& obj) {
 203         // Serialize to this stream
 204         ::Serialize(*this, obj);
 205         return (*this);
 206     }
 207 };
 208
 209 /** A writer stream (for serialization) that computes a 256-bit Verus hash. */
 210 class CVerusHashWriter
 211 {
 212 private:
 213     CVerusHash state;
 214
 215 public:
 216     int nType;
 217     int nVersion;
 218
 219     CVerusHashWriter(int nTypeIn, int nVersionIn) : nType(nTypeIn), nVersion(nVersionIn), state() { }
 220     void Reset() { state.Reset(); }
 221
 222     CVerusHashWriter& write(const char *pch, size_t size) {
 223         state.Write((const unsigned char*)pch, size);
 224         return (*this);
 225     }
 226
 227     // invalidates the object for further writing
 228     uint256 GetHash() {
 229         uint256 result;
 230         state.Finalize((unsigned char*)&result);
 231         return result;
 232     }
 233
 234     int64_t *xI64p() { return state.ExtraI64Ptr(); }
 235     CVerusHash &GetState() { return state; }
 236
 237     template<typename T>
 238     CVerusHashWriter& operator<<(const T& obj) {
 239         // Serialize to this stream
 240         ::Serialize(*this, obj);
 241         return (*this);
 242     }
 243 };
 244
 245 /** A writer stream (for serialization) that computes a 256-bit Verus hash with key initialized to Haraka standard. */
 246 class CVerusHashV2Writer
 247 {
 248 private:
 249     CVerusHashV2 state;
 250
 251 public:
 252     int nType;
 253     int nVersion;
 254
 255     CVerusHashV2Writer(int nTypeIn, int nVersionIn) : nType(nTypeIn), nVersion(nVersionIn), state() {}
 256     void Reset() { state.Reset(); }
 257
 258     CVerusHashV2Writer& write(const char *pch, size_t size) {
 259         state.Write((const unsigned char*)pch, size);
 260         return (*this);
 261     }
 262
 263     // invalidates the object for further writing
 264     uint256 GetHash() {
 265         uint256 result;
 266         state.Finalize((unsigned char*)&result);
 267         return result;
 268     }
 269
 270     int64_t *xI64p() { return state.ExtraI64Ptr(); }
 271     CVerusHashV2 &GetState() { return state; }
 272
 273     template<typename T>
 274     CVerusHashV2Writer& operator<<(const T& obj) {
 275         // Serialize to this stream
 276         ::Serialize(*this, obj);
 277         return (*this);
 278     }
 279 };
 280
 281 /** Compute the 256-bit hash of an object's serialization. */
 282 template<typename T>
 283 uint256 SerializeHash(const T& obj, int nType=SER_GETHASH, int nVersion=PROTOCOL_VERSION)
 284 {
 285     CHashWriter ss(nType, nVersion);
 286     ss << obj;
 287     return ss.GetHash();
 288 }
 289
 290 /** Compute the 256-bit Verus hash of an object's serialization. */
 291 template<typename T>
 292 uint256 SerializeVerusHash(const T& obj, int nType=SER_GETHASH, int nVersion=PROTOCOL_VERSION)
 293 {
 294     CVerusHashWriter ss(nType, nVersion);
 295     ss << obj;
 296     return ss.GetHash();
 297 }
 298
 299 /** Compute the 256-bit Verus hash of an object's serialization. */
 300 template<typename T>
 301 uint256 SerializeVerusHashV2(const T& obj, int nType=SER_GETHASH, int nVersion=PROTOCOL_VERSION)
 302 {
 303     CVerusHashV2Writer ss(nType, nVersion);
 304     ss << obj;
 305     return ss.GetHash();
 306 }
 307
 308 unsigned int MurmurHash3(unsigned int nHashSeed, const std::vector<unsigned char>& vDataToHash);
 309
 310 void BIP32Hash(const ChainCode &chainCode, unsigned int nChild, unsigned char header, const unsigned char data[32], unsigned char output[64]);
 311
 312 #endif // BITCOIN_HASH_H