src/hash.h

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2013 The Bitcoin developers
   3 // Distributed under the MIT/X11 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/sha2.h"
  10 #include "crypto/ripemd160.h"
  11 #include "serialize.h"
  12 #include "uint256.h"
  13 #include "version.h"
  14
  15 #include <vector>
  16
  17 /** A hasher class for Bitcoin's 256-bit hash (double SHA-256). */
  18 class CHash256 {
  19 private:
  20     CSHA256 sha;
  21 public:
  22     static const size_t OUTPUT_SIZE = CSHA256::OUTPUT_SIZE;
  23
  24     void Finalize(unsigned char hash[OUTPUT_SIZE]) {
  25         unsigned char buf[sha.OUTPUT_SIZE];
  26         sha.Finalize(buf);
  27         sha.Reset().Write(buf, sha.OUTPUT_SIZE).Finalize(hash);
  28     }
  29
  30     CHash256& Write(const unsigned char *data, size_t len) {
  31         sha.Write(data, len);
  32         return *this;
  33     }
  34
  35     CHash256& Reset() {
  36         sha.Reset();
  37         return *this;
  38     }
  39 };
  40
  41 /** A hasher class for Bitcoin's 160-bit hash (SHA-256 + RIPEMD-160). */
  42 class CHash160 {
  43 private:
  44     CSHA256 sha;
  45 public:
  46     static const size_t OUTPUT_SIZE = CRIPEMD160::OUTPUT_SIZE;
  47
  48     void Finalize(unsigned char hash[OUTPUT_SIZE]) {
  49         unsigned char buf[sha.OUTPUT_SIZE];
  50         sha.Finalize(buf);
  51         CRIPEMD160().Write(buf, sha.OUTPUT_SIZE).Finalize(hash);
  52     }
  53
  54     CHash160& Write(const unsigned char *data, size_t len) {
  55         sha.Write(data, len);
  56         return *this;
  57     }
  58
  59     CHash160& Reset() {
  60         sha.Reset();
  61         return *this;
  62     }
  63 };
  64
  65 /** Compute the 256-bit hash of an object. */
  66 template<typename T1>
  67 inline uint256 Hash(const T1 pbegin, const T1 pend)
  68 {
  69     static const unsigned char pblank[1] = {};
  70     uint256 result;
  71     CHash256().Write(pbegin == pend ? pblank : (const unsigned char*)&pbegin[0], (pend - pbegin) * sizeof(pbegin[0]))
  72               .Finalize((unsigned char*)&result);
  73     return result;
  74 }
  75
  76 /** Compute the 256-bit hash of the concatenation of two objects. */
  77 template<typename T1, typename T2>
  78 inline uint256 Hash(const T1 p1begin, const T1 p1end,
  79                     const T2 p2begin, const T2 p2end) {
  80     static const unsigned char pblank[1] = {};
  81     uint256 result;
  82     CHash256().Write(p1begin == p1end ? pblank : (const unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0]))
  83               .Write(p2begin == p2end ? pblank : (const unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0]))
  84               .Finalize((unsigned char*)&result);
  85     return result;
  86 }
  87
  88 /** Compute the 256-bit hash of the concatenation of three objects. */
  89 template<typename T1, typename T2, typename T3>
  90 inline uint256 Hash(const T1 p1begin, const T1 p1end,
  91                     const T2 p2begin, const T2 p2end,
  92                     const T3 p3begin, const T3 p3end) {
  93     static const unsigned char pblank[1] = {};
  94     uint256 result;
  95     CHash256().Write(p1begin == p1end ? pblank : (const unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0]))
  96               .Write(p2begin == p2end ? pblank : (const unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0]))
  97               .Write(p3begin == p3end ? pblank : (const unsigned char*)&p3begin[0], (p3end - p3begin) * sizeof(p3begin[0]))
  98               .Finalize((unsigned char*)&result);
  99     return result;
 100 }
 101
 102 /** Compute the 160-bit hash an object. */
 103 template<typename T1>
 104 inline uint160 Hash160(const T1 pbegin, const T1 pend)
 105 {
 106     static unsigned char pblank[1] = {};
 107     uint160 result;
 108     CHash160().Write(pbegin == pend ? pblank : (const unsigned char*)&pbegin[0], (pend - pbegin) * sizeof(pbegin[0]))
 109               .Finalize((unsigned char*)&result);
 110     return result;
 111 }
 112
 113 /** Compute the 160-bit hash of a vector. */
 114 inline uint160 Hash160(const std::vector<unsigned char>& vch)
 115 {
 116     return Hash160(vch.begin(), vch.end());
 117 }
 118
 119 /** A writer stream (for serialization) that computes a 256-bit hash. */
 120 class CHashWriter
 121 {
 122 private:
 123     CHash256 ctx;
 124
 125 public:
 126     int nType;
 127     int nVersion;
 128
 129     CHashWriter(int nTypeIn, int nVersionIn) : nType(nTypeIn), nVersion(nVersionIn) {}
 130
 131     CHashWriter& write(const char *pch, size_t size) {
 132         ctx.Write((const unsigned char*)pch, size);
 133         return (*this);
 134     }
 135
 136     // invalidates the object
 137     uint256 GetHash() {
 138         uint256 result;
 139         ctx.Finalize((unsigned char*)&result);
 140         return result;
 141     }
 142
 143     template<typename T>
 144     CHashWriter& operator<<(const T& obj) {
 145         // Serialize to this stream
 146         ::Serialize(*this, obj, nType, nVersion);
 147         return (*this);
 148     }
 149 };
 150
 151 /** Compute the 256-bit hash of an object's serialization. */
 152 template<typename T>
 153 uint256 SerializeHash(const T& obj, int nType=SER_GETHASH, int nVersion=PROTOCOL_VERSION)
 154 {
 155     CHashWriter ss(nType, nVersion);
 156     ss << obj;
 157     return ss.GetHash();
 158 }
 159
 160 unsigned int MurmurHash3(unsigned int nHashSeed, const std::vector<unsigned char>& vDataToHash);
 161
 162 #endif // BITCOIN_HASH_H