1 // Copyright (c) 2009-2010 Satoshi Nakamoto
2 // Copyright (c) 2009-2020 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 #include <merkleblock.h>
7
8 #include <hash.h>
9 #include <consensus/consensus.h>
10
11
BitsToBytes(const std::vector<bool> & bits)12 std::vector<unsigned char> BitsToBytes(const std::vector<bool>& bits)
13 {
14 std::vector<unsigned char> ret((bits.size() + 7) / 8);
15 for (unsigned int p = 0; p < bits.size(); p++) {
16 ret[p / 8] |= bits[p] << (p % 8);
17 }
18 return ret;
19 }
20
BytesToBits(const std::vector<unsigned char> & bytes)21 std::vector<bool> BytesToBits(const std::vector<unsigned char>& bytes)
22 {
23 std::vector<bool> ret(bytes.size() * 8);
24 for (unsigned int p = 0; p < ret.size(); p++) {
25 ret[p] = (bytes[p / 8] & (1 << (p % 8))) != 0;
26 }
27 return ret;
28 }
29
CMerkleBlock(const CBlock & block,CBloomFilter * filter,const std::set<uint256> * txids)30 CMerkleBlock::CMerkleBlock(const CBlock& block, CBloomFilter* filter, const std::set<uint256>* txids)
31 {
32 header = block.GetBlockHeader();
33
34 std::vector<bool> vMatch;
35 std::vector<uint256> vHashes;
36
37 vMatch.reserve(block.vtx.size());
38 vHashes.reserve(block.vtx.size());
39
40 for (unsigned int i = 0; i < block.vtx.size(); i++)
41 {
42 const uint256& hash = block.vtx[i]->GetHash();
43 if (txids && txids->count(hash)) {
44 vMatch.push_back(true);
45 } else if (filter && filter->IsRelevantAndUpdate(*block.vtx[i])) {
46 vMatch.push_back(true);
47 vMatchedTxn.emplace_back(i, hash);
48 } else {
49 vMatch.push_back(false);
50 }
51 vHashes.push_back(hash);
52 }
53
54 txn = CPartialMerkleTree(vHashes, vMatch);
55 }
56
CalcHash(int height,unsigned int pos,const std::vector<uint256> & vTxid)57 uint256 CPartialMerkleTree::CalcHash(int height, unsigned int pos, const std::vector<uint256> &vTxid) {
58 //we can never have zero txs in a merkle block, we always need the coinbase tx
59 //if we do not have this assert, we can hit a memory access violation when indexing into vTxid
60 assert(vTxid.size() != 0);
61 if (height == 0) {
62 // hash at height 0 is the txids themselves
63 return vTxid[pos];
64 } else {
65 // calculate left hash
66 uint256 left = CalcHash(height-1, pos*2, vTxid), right;
67 // calculate right hash if not beyond the end of the array - copy left hash otherwise
68 if (pos*2+1 < CalcTreeWidth(height-1))
69 right = CalcHash(height-1, pos*2+1, vTxid);
70 else
71 right = left;
72 // combine subhashes
73 return Hash(left, right);
74 }
75 }
76
TraverseAndBuild(int height,unsigned int pos,const std::vector<uint256> & vTxid,const std::vector<bool> & vMatch)77 void CPartialMerkleTree::TraverseAndBuild(int height, unsigned int pos, const std::vector<uint256> &vTxid, const std::vector<bool> &vMatch) {
78 // determine whether this node is the parent of at least one matched txid
79 bool fParentOfMatch = false;
80 for (unsigned int p = pos << height; p < (pos+1) << height && p < nTransactions; p++)
81 fParentOfMatch |= vMatch[p];
82 // store as flag bit
83 vBits.push_back(fParentOfMatch);
84 if (height==0 || !fParentOfMatch) {
85 // if at height 0, or nothing interesting below, store hash and stop
86 vHash.push_back(CalcHash(height, pos, vTxid));
87 } else {
88 // otherwise, don't store any hash, but descend into the subtrees
89 TraverseAndBuild(height-1, pos*2, vTxid, vMatch);
90 if (pos*2+1 < CalcTreeWidth(height-1))
91 TraverseAndBuild(height-1, pos*2+1, vTxid, vMatch);
92 }
93 }
94
TraverseAndExtract(int height,unsigned int pos,unsigned int & nBitsUsed,unsigned int & nHashUsed,std::vector<uint256> & vMatch,std::vector<unsigned int> & vnIndex)95 uint256 CPartialMerkleTree::TraverseAndExtract(int height, unsigned int pos, unsigned int &nBitsUsed, unsigned int &nHashUsed, std::vector<uint256> &vMatch, std::vector<unsigned int> &vnIndex) {
96 if (nBitsUsed >= vBits.size()) {
97 // overflowed the bits array - failure
98 fBad = true;
99 return uint256();
100 }
101 bool fParentOfMatch = vBits[nBitsUsed++];
102 if (height==0 || !fParentOfMatch) {
103 // if at height 0, or nothing interesting below, use stored hash and do not descend
104 if (nHashUsed >= vHash.size()) {
105 // overflowed the hash array - failure
106 fBad = true;
107 return uint256();
108 }
109 const uint256 &hash = vHash[nHashUsed++];
110 if (height==0 && fParentOfMatch) { // in case of height 0, we have a matched txid
111 vMatch.push_back(hash);
112 vnIndex.push_back(pos);
113 }
114 return hash;
115 } else {
116 // otherwise, descend into the subtrees to extract matched txids and hashes
117 uint256 left = TraverseAndExtract(height-1, pos*2, nBitsUsed, nHashUsed, vMatch, vnIndex), right;
118 if (pos*2+1 < CalcTreeWidth(height-1)) {
119 right = TraverseAndExtract(height-1, pos*2+1, nBitsUsed, nHashUsed, vMatch, vnIndex);
120 if (right == left) {
121 // The left and right branches should never be identical, as the transaction
122 // hashes covered by them must each be unique.
123 fBad = true;
124 }
125 } else {
126 right = left;
127 }
128 // and combine them before returning
129 return Hash(left, right);
130 }
131 }
132
CPartialMerkleTree(const std::vector<uint256> & vTxid,const std::vector<bool> & vMatch)133 CPartialMerkleTree::CPartialMerkleTree(const std::vector<uint256> &vTxid, const std::vector<bool> &vMatch) : nTransactions(vTxid.size()), fBad(false) {
134 // reset state
135 vBits.clear();
136 vHash.clear();
137
138 // calculate height of tree
139 int nHeight = 0;
140 while (CalcTreeWidth(nHeight) > 1)
141 nHeight++;
142
143 // traverse the partial tree
144 TraverseAndBuild(nHeight, 0, vTxid, vMatch);
145 }
146
CPartialMerkleTree()147 CPartialMerkleTree::CPartialMerkleTree() : nTransactions(0), fBad(true) {}
148
ExtractMatches(std::vector<uint256> & vMatch,std::vector<unsigned int> & vnIndex)149 uint256 CPartialMerkleTree::ExtractMatches(std::vector<uint256> &vMatch, std::vector<unsigned int> &vnIndex) {
150 vMatch.clear();
151 // An empty set will not work
152 if (nTransactions == 0)
153 return uint256();
154 // check for excessively high numbers of transactions
155 if (nTransactions > MAX_BLOCK_WEIGHT / MIN_TRANSACTION_WEIGHT)
156 return uint256();
157 // there can never be more hashes provided than one for every txid
158 if (vHash.size() > nTransactions)
159 return uint256();
160 // there must be at least one bit per node in the partial tree, and at least one node per hash
161 if (vBits.size() < vHash.size())
162 return uint256();
163 // calculate height of tree
164 int nHeight = 0;
165 while (CalcTreeWidth(nHeight) > 1)
166 nHeight++;
167 // traverse the partial tree
168 unsigned int nBitsUsed = 0, nHashUsed = 0;
169 uint256 hashMerkleRoot = TraverseAndExtract(nHeight, 0, nBitsUsed, nHashUsed, vMatch, vnIndex);
170 // verify that no problems occurred during the tree traversal
171 if (fBad)
172 return uint256();
173 // verify that all bits were consumed (except for the padding caused by serializing it as a byte sequence)
174 if ((nBitsUsed+7)/8 != (vBits.size()+7)/8)
175 return uint256();
176 // verify that all hashes were consumed
177 if (nHashUsed != vHash.size())
178 return uint256();
179 return hashMerkleRoot;
180 }
181