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