[Wallet] split the keypool in an internal and external part
[bitcoinplatinum.git] / src / hash.h
blobeacb8f04fef378ab80a1b1df15689525e5d45895
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.
6 #ifndef BITCOIN_HASH_H
7 #define BITCOIN_HASH_H
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"
16 #include <vector>
18 typedef uint256 ChainCode;
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;
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);
33 CHash256& Write(const unsigned char *data, size_t len) {
34 sha.Write(data, len);
35 return *this;
38 CHash256& Reset() {
39 sha.Reset();
40 return *this;
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;
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);
57 CHash160& Write(const unsigned char *data, size_t len) {
58 sha.Write(data, len);
59 return *this;
62 CHash160& Reset() {
63 sha.Reset();
64 return *this;
68 /** Compute the 256-bit hash of an object. */
69 template<typename T1>
70 inline uint256 Hash(const T1 pbegin, const T1 pend)
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;
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;
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;
105 /** Compute the 160-bit hash an object. */
106 template<typename T1>
107 inline uint160 Hash160(const T1 pbegin, const T1 pend)
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;
116 /** Compute the 160-bit hash of a vector. */
117 inline uint160 Hash160(const std::vector<unsigned char>& vch)
119 return Hash160(vch.begin(), vch.end());
122 /** Compute the 160-bit hash of a vector. */
123 template<unsigned int N>
124 inline uint160 Hash160(const prevector<N, unsigned char>& vch)
126 return Hash160(vch.begin(), vch.end());
129 /** A writer stream (for serialization) that computes a 256-bit hash. */
130 class CHashWriter
132 private:
133 CHash256 ctx;
135 const int nType;
136 const int nVersion;
137 public:
139 CHashWriter(int nTypeIn, int nVersionIn) : nType(nTypeIn), nVersion(nVersionIn) {}
141 int GetType() const { return nType; }
142 int GetVersion() const { return nVersion; }
144 void write(const char *pch, size_t size) {
145 ctx.Write((const unsigned char*)pch, size);
148 // invalidates the object
149 uint256 GetHash() {
150 uint256 result;
151 ctx.Finalize((unsigned char*)&result);
152 return result;
155 template<typename T>
156 CHashWriter& operator<<(const T& obj) {
157 // Serialize to this stream
158 ::Serialize(*this, obj);
159 return (*this);
163 /** Compute the 256-bit hash of an object's serialization. */
164 template<typename T>
165 uint256 SerializeHash(const T& obj, int nType=SER_GETHASH, int nVersion=PROTOCOL_VERSION)
167 CHashWriter ss(nType, nVersion);
168 ss << obj;
169 return ss.GetHash();
172 unsigned int MurmurHash3(unsigned int nHashSeed, const std::vector<unsigned char>& vDataToHash);
174 void BIP32Hash(const ChainCode &chainCode, unsigned int nChild, unsigned char header, const unsigned char data[32], unsigned char output[64]);
176 /** SipHash-2-4 */
177 class CSipHasher
179 private:
180 uint64_t v[4];
181 uint64_t tmp;
182 int count;
184 public:
185 /** Construct a SipHash calculator initialized with 128-bit key (k0, k1) */
186 CSipHasher(uint64_t k0, uint64_t k1);
187 /** Hash a 64-bit integer worth of data
188 * It is treated as if this was the little-endian interpretation of 8 bytes.
189 * This function can only be used when a multiple of 8 bytes have been written so far.
191 CSipHasher& Write(uint64_t data);
192 /** Hash arbitrary bytes. */
193 CSipHasher& Write(const unsigned char* data, size_t size);
194 /** Compute the 64-bit SipHash-2-4 of the data written so far. The object remains untouched. */
195 uint64_t Finalize() const;
198 /** Optimized SipHash-2-4 implementation for uint256.
200 * It is identical to:
201 * SipHasher(k0, k1)
202 * .Write(val.GetUint64(0))
203 * .Write(val.GetUint64(1))
204 * .Write(val.GetUint64(2))
205 * .Write(val.GetUint64(3))
206 * .Finalize()
208 uint64_t SipHashUint256(uint64_t k0, uint64_t k1, const uint256& val);
210 #endif // BITCOIN_HASH_H