Branch data Line data Source code
1 : : // Copyright (c) 2020-present The Bitcoin Core developers
2 : : // Distributed under the MIT software license, see the accompanying
3 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 : :
5 : : #include <coins.h>
6 : : #include <consensus/amount.h>
7 : : #include <consensus/tx_check.h>
8 : : #include <consensus/tx_verify.h>
9 : : #include <consensus/validation.h>
10 : : #include <policy/policy.h>
11 : : #include <primitives/transaction.h>
12 : : #include <script/interpreter.h>
13 : : #include <test/fuzz/FuzzedDataProvider.h>
14 : : #include <test/fuzz/fuzz.h>
15 : : #include <test/fuzz/util.h>
16 : : #include <test/util/setup_common.h>
17 : : #include <txdb.h>
18 : : #include <util/hasher.h>
19 : :
20 : : #include <cassert>
21 : : #include <cstdint>
22 : : #include <limits>
23 : : #include <memory>
24 : : #include <optional>
25 : : #include <stdexcept>
26 : : #include <string>
27 : : #include <utility>
28 : : #include <vector>
29 : :
30 : : namespace {
31 : : const Coin EMPTY_COIN{};
32 : :
33 : 11980 : bool operator==(const Coin& a, const Coin& b)
34 : : {
35 [ + + - + ]: 11980 : if (a.IsSpent() && b.IsSpent()) return true;
36 [ + + + + : 10024 : return a.fCoinBase == b.fCoinBase && a.nHeight == b.nHeight && a.out == b.out;
+ + ]
37 : : }
38 : : } // namespace
39 : :
40 : 2 : void initialize_coins_view()
41 : : {
42 [ + - + - : 2 : static const auto testing_setup = MakeNoLogFileContext<>();
+ - ]
43 : 2 : }
44 : :
45 : 6968 : void TestCoinsView(FuzzedDataProvider& fuzzed_data_provider, CCoinsView& backend_coins_view, bool is_db)
46 : : {
47 : 6968 : bool good_data{true};
48 : :
49 : 6968 : CCoinsViewCache coins_view_cache{&backend_coins_view, /*deterministic=*/true};
50 [ + + + - ]: 6968 : if (is_db) coins_view_cache.SetBestBlock(uint256::ONE);
51 : 6968 : COutPoint random_out_point;
52 : 6968 : Coin random_coin;
53 [ + - ]: 6968 : CMutableTransaction random_mutable_transaction;
54 [ + + + + : 7352863 : LIMITED_WHILE(good_data && fuzzed_data_provider.ConsumeBool(), 10'000)
+ + ]
55 : : {
56 [ + - ]: 3669896 : CallOneOf(
57 : : fuzzed_data_provider,
58 : 551381 : [&] {
59 [ + + ]: 551381 : if (random_coin.IsSpent()) {
60 : : return;
61 : : }
62 : 499237 : Coin coin = random_coin;
63 : 499237 : bool expected_code_path = false;
64 : 499237 : const bool possible_overwrite = fuzzed_data_provider.ConsumeBool();
65 : 499237 : try {
66 [ + + ]: 499237 : coins_view_cache.AddCoin(random_out_point, std::move(coin), possible_overwrite);
67 : : expected_code_path = true;
68 [ - + ]: 17161 : } catch (const std::logic_error& e) {
69 [ + - + - ]: 17161 : if (e.what() == std::string{"Attempted to overwrite an unspent coin (when possible_overwrite is false)"}) {
70 [ - + ]: 17161 : assert(!possible_overwrite);
71 : 17161 : expected_code_path = true;
72 : : // AddCoin() decreases cachedCoinsUsage by the memory usage of the old coin at the beginning and
73 : : // increases it by the value of the new coin at the end. If it throws in the process, the value
74 : : // of cachedCoinsUsage would have been incorrectly decreased, leading to an underflow later on.
75 : : // To avoid this, use Flush() to reset the value of cachedCoinsUsage in sync with the cacheCoins
76 : : // mapping.
77 [ + - ]: 17161 : (void)coins_view_cache.Flush();
78 : : }
79 : 0 : }
80 : 17161 : assert(expected_code_path);
81 : 499237 : },
82 : 770906 : [&] {
83 : 770906 : (void)coins_view_cache.Flush();
84 : 770906 : },
85 : 1813503 : [&] {
86 : 1813503 : (void)coins_view_cache.Sync();
87 : 1813503 : },
88 : 12044 : [&] {
89 : 12044 : uint256 best_block{ConsumeUInt256(fuzzed_data_provider)};
90 : : // Set best block hash to non-null to satisfy the assertion in CCoinsViewDB::BatchWrite().
91 [ + + + + ]: 18576 : if (is_db && best_block.IsNull()) best_block = uint256::ONE;
92 : 12044 : coins_view_cache.SetBestBlock(best_block);
93 : 12044 : },
94 : 384604 : [&] {
95 : 384604 : Coin move_to;
96 [ + + + - ]: 399847 : (void)coins_view_cache.SpendCoin(random_out_point, fuzzed_data_provider.ConsumeBool() ? &move_to : nullptr);
97 : 384604 : },
98 : 30149 : [&] {
99 : 30149 : coins_view_cache.Uncache(random_out_point);
100 : 30149 : },
101 : 16385 : [&] {
102 [ + + ]: 16385 : if (fuzzed_data_provider.ConsumeBool()) {
103 : 15096 : backend_coins_view = CCoinsView{};
104 : : }
105 : 16385 : coins_view_cache.SetBackend(backend_coins_view);
106 : 16385 : },
107 : 8580 : [&] {
108 : 8580 : const std::optional<COutPoint> opt_out_point = ConsumeDeserializable<COutPoint>(fuzzed_data_provider);
109 [ + + ]: 8580 : if (!opt_out_point) {
110 : 79 : good_data = false;
111 : 79 : return;
112 : : }
113 : 8501 : random_out_point = *opt_out_point;
114 : : },
115 : 23030 : [&] {
116 : 23030 : const std::optional<Coin> opt_coin = ConsumeDeserializable<Coin>(fuzzed_data_provider);
117 [ + + ]: 23030 : if (!opt_coin) {
118 : 222 : good_data = false;
119 : 222 : return;
120 : : }
121 : 22808 : random_coin = *opt_coin;
122 : 23030 : },
123 : 20435 : [&] {
124 : 20435 : const std::optional<CMutableTransaction> opt_mutable_transaction = ConsumeDeserializable<CMutableTransaction>(fuzzed_data_provider, TX_WITH_WITNESS);
125 [ + + ]: 20435 : if (!opt_mutable_transaction) {
126 : 478 : good_data = false;
127 [ - + ]: 478 : return;
128 : : }
129 [ + - ]: 19957 : random_mutable_transaction = *opt_mutable_transaction;
130 : 20435 : },
131 : 38879 : [&] {
132 : 38879 : CoinsCachePair sentinel{};
133 : 38879 : sentinel.second.SelfRef(sentinel);
134 : 38879 : size_t usage{0};
135 [ + - ]: 38879 : CCoinsMapMemoryResource resource;
136 [ + - + - ]: 38879 : CCoinsMap coins_map{0, SaltedOutpointHasher{/*deterministic=*/true}, CCoinsMap::key_equal{}, &resource};
137 [ + - + + : 837647 : LIMITED_WHILE(good_data && fuzzed_data_provider.ConsumeBool(), 10'000)
+ + ]
138 : : {
139 : 798854 : CCoinsCacheEntry coins_cache_entry;
140 : 798854 : const auto dirty{fuzzed_data_provider.ConsumeBool()};
141 : 798854 : const auto fresh{fuzzed_data_provider.ConsumeBool()};
142 [ + + ]: 798854 : if (fuzzed_data_provider.ConsumeBool()) {
143 : 787552 : coins_cache_entry.coin = random_coin;
144 : : } else {
145 : 11302 : const std::optional<Coin> opt_coin = ConsumeDeserializable<Coin>(fuzzed_data_provider);
146 [ + + ]: 11302 : if (!opt_coin) {
147 : 86 : good_data = false;
148 : 86 : return;
149 : : }
150 : 11216 : coins_cache_entry.coin = *opt_coin;
151 : 11216 : }
152 [ + - ]: 798768 : auto it{coins_map.emplace(random_out_point, std::move(coins_cache_entry)).first};
153 [ + + ]: 798768 : if (dirty) CCoinsCacheEntry::SetDirty(*it, sentinel);
154 [ + + ]: 798768 : if (fresh) CCoinsCacheEntry::SetFresh(*it, sentinel);
155 [ + + ]: 798768 : usage += it->second.coin.DynamicMemoryUsage();
156 : 798854 : }
157 : 38793 : bool expected_code_path = false;
158 : 38793 : try {
159 [ + - ]: 38793 : auto cursor{CoinsViewCacheCursor(usage, sentinel, coins_map, /*will_erase=*/true)};
160 [ + - ]: 38793 : uint256 best_block{coins_view_cache.GetBestBlock()};
161 [ + + ]: 38793 : if (fuzzed_data_provider.ConsumeBool()) best_block = ConsumeUInt256(fuzzed_data_provider);
162 : : // Set best block hash to non-null to satisfy the assertion in CCoinsViewDB::BatchWrite().
163 [ + + + + ]: 53015 : if (is_db && best_block.IsNull()) best_block = uint256::ONE;
164 [ + + ]: 38793 : coins_view_cache.BatchWrite(cursor, best_block);
165 : : expected_code_path = true;
166 [ - + ]: 6306 : } catch (const std::logic_error& e) {
167 [ + - + - ]: 6306 : if (e.what() == std::string{"FRESH flag misapplied to coin that exists in parent cache"}) {
168 : 6306 : expected_code_path = true;
169 : : }
170 : 0 : }
171 : 6306 : assert(expected_code_path);
172 : 38879 : });
173 : : }
174 : :
175 : 6968 : {
176 [ + - ]: 6968 : const Coin& coin_using_access_coin = coins_view_cache.AccessCoin(random_out_point);
177 : 6968 : const bool exists_using_access_coin = !(coin_using_access_coin == EMPTY_COIN);
178 [ + - ]: 6968 : const bool exists_using_have_coin = coins_view_cache.HaveCoin(random_out_point);
179 [ + - ]: 6968 : const bool exists_using_have_coin_in_cache = coins_view_cache.HaveCoinInCache(random_out_point);
180 [ + - + + ]: 6968 : if (auto coin{coins_view_cache.GetCoin(random_out_point)}) {
181 [ - + ]: 5012 : assert(*coin == coin_using_access_coin);
182 [ + - - + ]: 5012 : assert(exists_using_access_coin && exists_using_have_coin_in_cache && exists_using_have_coin);
183 : : } else {
184 [ + - - + ]: 1956 : assert(!exists_using_access_coin && !exists_using_have_coin_in_cache && !exists_using_have_coin);
185 : 6968 : }
186 : : // If HaveCoin on the backend is true, it must also be on the cache if the coin wasn't spent.
187 [ + - ]: 6968 : const bool exists_using_have_coin_in_backend = backend_coins_view.HaveCoin(random_out_point);
188 [ + + + + ]: 6968 : if (!coin_using_access_coin.IsSpent() && exists_using_have_coin_in_backend) {
189 [ - + ]: 1809 : assert(exists_using_have_coin);
190 : : }
191 [ + - + + ]: 6968 : if (auto coin{backend_coins_view.GetCoin(random_out_point)}) {
192 [ - + ]: 1857 : assert(exists_using_have_coin_in_backend);
193 : : // Note we can't assert that `coin_using_get_coin == *coin` because the coin in
194 : : // the cache may have been modified but not yet flushed.
195 : : } else {
196 [ - + ]: 5111 : assert(!exists_using_have_coin_in_backend);
197 : 6968 : }
198 : : }
199 : :
200 : 6968 : {
201 : 6968 : bool expected_code_path = false;
202 : 6968 : try {
203 : 6968 : (void)coins_view_cache.Cursor();
204 [ - + ]: 6968 : } catch (const std::logic_error&) {
205 : 6968 : expected_code_path = true;
206 : 6968 : }
207 : 6968 : assert(expected_code_path);
208 [ + - ]: 6968 : (void)coins_view_cache.DynamicMemoryUsage();
209 [ + - ]: 6968 : (void)coins_view_cache.EstimateSize();
210 [ + - ]: 6968 : (void)coins_view_cache.GetBestBlock();
211 [ + - ]: 6968 : (void)coins_view_cache.GetCacheSize();
212 [ + - ]: 6968 : (void)coins_view_cache.GetHeadBlocks();
213 [ + - + - ]: 6968 : (void)coins_view_cache.HaveInputs(CTransaction{random_mutable_transaction});
214 : : }
215 : :
216 : 6968 : {
217 [ + - ]: 6968 : std::unique_ptr<CCoinsViewCursor> coins_view_cursor = backend_coins_view.Cursor();
218 [ - + ]: 6968 : assert(is_db == !!coins_view_cursor);
219 [ + - ]: 6968 : (void)backend_coins_view.EstimateSize();
220 [ + - ]: 6968 : (void)backend_coins_view.GetBestBlock();
221 [ + - ]: 6968 : (void)backend_coins_view.GetHeadBlocks();
222 : 6968 : }
223 : :
224 [ + + ]: 6968 : if (fuzzed_data_provider.ConsumeBool()) {
225 [ + - ]: 5293 : CallOneOf(
226 : : fuzzed_data_provider,
227 : 404 : [&] {
228 : 404 : const CTransaction transaction{random_mutable_transaction};
229 : 404 : bool is_spent = false;
230 [ + + ]: 2234294 : for (const CTxOut& tx_out : transaction.vout) {
231 [ + + ]: 2233890 : if (Coin{tx_out, 0, transaction.IsCoinBase()}.IsSpent()) {
232 : 35 : is_spent = true;
233 : : }
234 : : }
235 [ + + ]: 404 : if (is_spent) {
236 : : // Avoid:
237 : : // coins.cpp:69: void CCoinsViewCache::AddCoin(const COutPoint &, Coin &&, bool): Assertion `!coin.IsSpent()' failed.
238 : 16 : return;
239 : : }
240 : 388 : bool expected_code_path = false;
241 : 388 : const int height{int(fuzzed_data_provider.ConsumeIntegral<uint32_t>() >> 1)};
242 : 388 : const bool possible_overwrite = fuzzed_data_provider.ConsumeBool();
243 : 388 : try {
244 [ + + ]: 388 : AddCoins(coins_view_cache, transaction, height, possible_overwrite);
245 : : expected_code_path = true;
246 [ - + ]: 4 : } catch (const std::logic_error& e) {
247 [ + - + - ]: 4 : if (e.what() == std::string{"Attempted to overwrite an unspent coin (when possible_overwrite is false)"}) {
248 [ - + ]: 4 : assert(!possible_overwrite);
249 : : expected_code_path = true;
250 : : }
251 : 0 : }
252 : 4 : assert(expected_code_path);
253 : 404 : },
254 : 3092 : [&] {
255 [ + - ]: 3092 : (void)AreInputsStandard(CTransaction{random_mutable_transaction}, coins_view_cache);
256 : 3092 : },
257 : 258 : [&] {
258 [ + - ]: 258 : TxValidationState state;
259 : 258 : CAmount tx_fee_out;
260 [ + - ]: 258 : const CTransaction transaction{random_mutable_transaction};
261 [ + + ]: 258 : if (ContainsSpentInput(transaction, coins_view_cache)) {
262 : : // Avoid:
263 : : // consensus/tx_verify.cpp:171: bool Consensus::CheckTxInputs(const CTransaction &, TxValidationState &, const CCoinsViewCache &, int, CAmount &): Assertion `!coin.IsSpent()' failed.
264 : : return;
265 : : }
266 [ + - ]: 240 : TxValidationState dummy;
267 [ + - + + ]: 240 : if (!CheckTransaction(transaction, dummy)) {
268 : : // It is not allowed to call CheckTxInputs if CheckTransaction failed
269 : 148 : return;
270 : : }
271 [ + - + + ]: 92 : if (Consensus::CheckTxInputs(transaction, state, coins_view_cache, fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()), tx_fee_out)) {
272 [ - + ]: 6 : assert(MoneyRange(tx_fee_out));
273 : : }
274 : 756 : },
275 : 267 : [&] {
276 : 267 : const CTransaction transaction{random_mutable_transaction};
277 [ + + ]: 267 : if (ContainsSpentInput(transaction, coins_view_cache)) {
278 : : // Avoid:
279 : : // consensus/tx_verify.cpp:130: unsigned int GetP2SHSigOpCount(const CTransaction &, const CCoinsViewCache &): Assertion `!coin.IsSpent()' failed.
280 : 74 : return;
281 : : }
282 [ + - ]: 193 : (void)GetP2SHSigOpCount(transaction, coins_view_cache);
283 : 267 : },
284 : 704 : [&] {
285 : 704 : const CTransaction transaction{random_mutable_transaction};
286 [ + + ]: 704 : if (ContainsSpentInput(transaction, coins_view_cache)) {
287 : : // Avoid:
288 : : // consensus/tx_verify.cpp:130: unsigned int GetP2SHSigOpCount(const CTransaction &, const CCoinsViewCache &): Assertion `!coin.IsSpent()' failed.
289 : : return;
290 : : }
291 : 689 : const auto flags{fuzzed_data_provider.ConsumeIntegral<uint32_t>()};
292 [ + + + + : 689 : if (!transaction.vin.empty() && (flags & SCRIPT_VERIFY_WITNESS) != 0 && (flags & SCRIPT_VERIFY_P2SH) == 0) {
+ + ]
293 : : // Avoid:
294 : : // script/interpreter.cpp:1705: size_t CountWitnessSigOps(const CScript &, const CScript &, const CScriptWitness *, unsigned int): Assertion `(flags & SCRIPT_VERIFY_P2SH) != 0' failed.
295 : : return;
296 : : }
297 [ + - ]: 687 : (void)GetTransactionSigOpCost(transaction, coins_view_cache, flags);
298 : 704 : },
299 : 568 : [&] {
300 [ + - ]: 568 : (void)IsWitnessStandard(CTransaction{random_mutable_transaction}, coins_view_cache);
301 : 568 : });
302 : : }
303 : 6968 : }
304 : :
305 [ + - ]: 3998 : FUZZ_TARGET(coins_view, .init = initialize_coins_view)
306 : : {
307 [ + - ]: 3542 : FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
308 : 3542 : CCoinsView backend_coins_view;
309 [ + - ]: 3542 : TestCoinsView(fuzzed_data_provider, backend_coins_view, /*is_db=*/false);
310 : 3542 : }
311 : :
312 [ + - ]: 3882 : FUZZ_TARGET(coins_view_db, .init = initialize_coins_view)
313 : : {
314 : 3426 : FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
315 : 3426 : auto db_params = DBParams{
316 : : .path = "",
317 : : .cache_bytes = 1_MiB,
318 : : .memory_only = true,
319 : 3426 : };
320 [ + - ]: 3426 : CCoinsViewDB coins_db{std::move(db_params), CoinsViewOptions{}};
321 [ + - ]: 3426 : TestCoinsView(fuzzed_data_provider, coins_db, /*is_db=*/true);
322 : 6852 : }
|
