Branch data Line data Source code
1 : : // Copyright (c) 2020-2022 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 <chainparams.h>
6 : : #include <coins.h>
7 : : #include <consensus/amount.h>
8 : : #include <consensus/tx_check.h>
9 : : #include <consensus/tx_verify.h>
10 : : #include <consensus/validation.h>
11 : : #include <key.h>
12 : : #include <policy/policy.h>
13 : : #include <primitives/transaction.h>
14 : : #include <pubkey.h>
15 : : #include <test/fuzz/FuzzedDataProvider.h>
16 : : #include <test/fuzz/fuzz.h>
17 [ + - ]: 173 : #include <test/fuzz/util.h>
18 [ + - ]: 173 : #include <test/util/setup_common.h>
19 : : #include <validation.h>
20 : :
21 : : #include <cstdint>
22 : : #include <limits>
23 : : #include <optional>
24 : : #include <string>
25 : : #include <vector>
26 : :
27 : : namespace {
28 : : const TestingSetup* g_setup;
29 : 173 : const Coin EMPTY_COIN{};
30 : :
31 : 2386 : bool operator==(const Coin& a, const Coin& b)
32 : : {
33 [ + + - + ]: 2386 : if (a.IsSpent() && b.IsSpent()) return true;
34 [ + + + + ]: 1956 : return a.fCoinBase == b.fCoinBase && a.nHeight == b.nHeight && a.out == b.out;
35 : 2386 : }
36 : : } // namespace
37 : :
38 : 1 : void initialize_coins_view()
39 : : {
40 [ + - - + : 1 : static const auto testing_setup = MakeNoLogFileContext<const TestingSetup>();
+ - ]
41 : 1 : g_setup = testing_setup.get();
42 : 1 : }
43 : :
44 [ + - - + ]: 1754 : FUZZ_TARGET(coins_view, .init = initialize_coins_view)
45 : : {
46 : 1408 : FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
47 : 1408 : CCoinsView backend_coins_view;
48 [ + - ]: 1408 : CCoinsViewCache coins_view_cache{&backend_coins_view, /*deterministic=*/true};
49 [ + - ]: 1408 : COutPoint random_out_point;
50 [ + - ]: 1408 : Coin random_coin;
51 [ + - ]: 1408 : CMutableTransaction random_mutable_transaction;
52 [ + - + + : 392833 : LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 10000) {
+ + ]
53 [ + - ]: 391425 : CallOneOf(
54 : : fuzzed_data_provider,
55 : 418015 : [&] {
56 [ + + ]: 26590 : if (random_coin.IsSpent()) {
57 : 1469 : return;
58 : : }
59 : 25121 : Coin coin = random_coin;
60 : 25121 : bool expected_code_path = false;
61 [ + - ]: 25121 : const bool possible_overwrite = fuzzed_data_provider.ConsumeBool();
62 : : try {
63 [ + + ]: 25121 : coins_view_cache.AddCoin(random_out_point, std::move(coin), possible_overwrite);
64 : 24394 : expected_code_path = true;
65 [ - + ]: 25121 : } catch (const std::logic_error& e) {
66 [ + - + - : 727 : if (e.what() == std::string{"Attempted to overwrite an unspent coin (when possible_overwrite is false)"}) {
- + ]
67 [ + - ]: 727 : assert(!possible_overwrite);
68 : 727 : expected_code_path = true;
69 : 727 : }
70 [ # # + - ]: 727 : }
71 [ + - ]: 25121 : assert(expected_code_path);
72 : 27317 : },
73 : 437746 : [&] {
74 : 46494 : (void)coins_view_cache.Flush();
75 : 46321 : },
76 : 450085 : [&] {
77 : 58660 : (void)coins_view_cache.Sync();
78 : 58660 : },
79 : 396251 : [&] {
80 : 4826 : coins_view_cache.SetBestBlock(ConsumeUInt256(fuzzed_data_provider));
81 : 4826 : },
82 : 406950 : [&] {
83 : 15525 : Coin move_to;
84 [ + - + + : 15525 : (void)coins_view_cache.SpendCoin(random_out_point, fuzzed_data_provider.ConsumeBool() ? &move_to : nullptr);
+ - ]
85 : 15525 : },
86 : 421787 : [&] {
87 : 30362 : coins_view_cache.Uncache(random_out_point);
88 : 30362 : },
89 : 404559 : [&] {
90 [ + + ]: 13134 : if (fuzzed_data_provider.ConsumeBool()) {
91 : 7548 : backend_coins_view = CCoinsView{};
92 : 7548 : }
93 : 13134 : coins_view_cache.SetBackend(backend_coins_view);
94 : 13134 : },
95 : 416100 : [&] {
96 : 24675 : const std::optional<COutPoint> opt_out_point = ConsumeDeserializable<COutPoint>(fuzzed_data_provider);
97 [ + + ]: 24675 : if (!opt_out_point) {
98 : 8905 : return;
99 : : }
100 : 15770 : random_out_point = *opt_out_point;
101 : 24675 : },
102 : 410690 : [&] {
103 : 19265 : const std::optional<Coin> opt_coin = ConsumeDeserializable<Coin>(fuzzed_data_provider);
104 [ + + ]: 19265 : if (!opt_coin) {
105 : 10716 : return;
106 : : }
107 [ + - + - ]: 8549 : random_coin = *opt_coin;
108 [ - + ]: 19265 : },
109 : 491256 : [&] {
110 : 99831 : const std::optional<CMutableTransaction> opt_mutable_transaction = ConsumeDeserializable<CMutableTransaction>(fuzzed_data_provider);
111 [ + + ]: 99831 : if (!opt_mutable_transaction) {
112 : 87470 : return;
113 : : }
114 [ + - + - ]: 12361 : random_mutable_transaction = *opt_mutable_transaction;
115 [ - + ]: 99831 : },
116 : 454785 : [&] {
117 : 63360 : CCoinsMapMemoryResource resource;
118 [ + + + + ]: 63360 : CCoinsMap coins_map{0, SaltedOutpointHasher{/*deterministic=*/true}, CCoinsMap::key_equal{}, &resource};
119 [ + + + + ]: 324118 : LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 10000) {
120 [ + + ]: 241894 : CCoinsCacheEntry coins_cache_entry;
121 [ + - ]: 283006 : coins_cache_entry.flags = fuzzed_data_provider.ConsumeIntegral<unsigned char>();
122 [ + - + + ]: 283006 : if (fuzzed_data_provider.ConsumeBool()) {
123 [ + - ]: 264100 : coins_cache_entry.coin = random_coin;
124 : 264100 : } else {
125 : 18906 : const std::optional<Coin> opt_coin = ConsumeDeserializable<Coin>(fuzzed_data_provider);
126 [ + + ]: 18906 : if (!opt_coin) {
127 : 11124 : return;
128 : : }
129 [ + - ]: 7782 : coins_cache_entry.coin = *opt_coin;
130 [ + + ]: 18906 : }
131 [ + - ]: 271882 : coins_map.emplace(random_out_point, std::move(coins_cache_entry));
132 : 283006 : }
133 : 41112 : bool expected_code_path = false;
134 : : try {
135 [ + - + + : 41112 : coins_view_cache.BatchWrite(coins_map, fuzzed_data_provider.ConsumeBool() ? ConsumeUInt256(fuzzed_data_provider) : coins_view_cache.GetBestBlock());
+ - + + ]
136 : 22149 : expected_code_path = true;
137 [ - + ]: 41112 : } catch (const std::logic_error& e) {
138 [ + - - + ]: 18963 : if (e.what() == std::string{"FRESH flag misapplied to coin that exists in parent cache"}) {
139 : 18963 : expected_code_path = true;
140 : 18963 : }
141 [ # # + - ]: 18963 : }
142 [ + - ]: 41112 : assert(expected_code_path);
143 [ - + ]: 164547 : });
144 : 391425 : }
145 : :
146 : : {
147 [ + - ]: 1408 : const Coin& coin_using_access_coin = coins_view_cache.AccessCoin(random_out_point);
148 [ + - ]: 1408 : const bool exists_using_access_coin = !(coin_using_access_coin == EMPTY_COIN);
149 [ + - ]: 1408 : const bool exists_using_have_coin = coins_view_cache.HaveCoin(random_out_point);
150 [ + - ]: 1408 : const bool exists_using_have_coin_in_cache = coins_view_cache.HaveCoinInCache(random_out_point);
151 [ + - ]: 1408 : Coin coin_using_get_coin;
152 [ + - ]: 1408 : const bool exists_using_get_coin = coins_view_cache.GetCoin(random_out_point, coin_using_get_coin);
153 [ + + ]: 1408 : if (exists_using_get_coin) {
154 [ + - + - ]: 978 : assert(coin_using_get_coin == coin_using_access_coin);
155 : 978 : }
156 [ + + + - : 1408 : assert((exists_using_access_coin && exists_using_have_coin_in_cache && exists_using_have_coin && exists_using_get_coin) ||
+ - + - +
- + - - +
+ - ]
157 : : (!exists_using_access_coin && !exists_using_have_coin_in_cache && !exists_using_have_coin && !exists_using_get_coin));
158 : : // If HaveCoin on the backend is true, it must also be on the cache if the coin wasn't spent.
159 [ + - ]: 1408 : const bool exists_using_have_coin_in_backend = backend_coins_view.HaveCoin(random_out_point);
160 [ + - + + : 1408 : if (!coin_using_access_coin.IsSpent() && exists_using_have_coin_in_backend) {
+ - ]
161 [ # # ]: 0 : assert(exists_using_have_coin);
162 : 0 : }
163 [ + - ]: 1408 : Coin coin_using_backend_get_coin;
164 [ + - - + ]: 1408 : if (backend_coins_view.GetCoin(random_out_point, coin_using_backend_get_coin)) {
165 [ # # ]: 0 : assert(exists_using_have_coin_in_backend);
166 : : // Note we can't assert that `coin_using_get_coin == coin_using_backend_get_coin` because the coin in
167 : : // the cache may have been modified but not yet flushed.
168 : 0 : } else {
169 [ + - ]: 1408 : assert(!exists_using_have_coin_in_backend);
170 : : }
171 : 1408 : }
172 : :
173 : : {
174 : 1408 : bool expected_code_path = false;
175 : : try {
176 [ - + ]: 1408 : (void)coins_view_cache.Cursor();
177 [ + - ]: 1408 : } catch (const std::logic_error&) {
178 : 1408 : expected_code_path = true;
179 [ + - ]: 1408 : }
180 [ + - ]: 1408 : assert(expected_code_path);
181 [ + - ]: 1408 : (void)coins_view_cache.DynamicMemoryUsage();
182 [ + - ]: 1408 : (void)coins_view_cache.EstimateSize();
183 [ + - ]: 1408 : (void)coins_view_cache.GetBestBlock();
184 [ + - ]: 1408 : (void)coins_view_cache.GetCacheSize();
185 [ + - ]: 1408 : (void)coins_view_cache.GetHeadBlocks();
186 [ + - + - ]: 1408 : (void)coins_view_cache.HaveInputs(CTransaction{random_mutable_transaction});
187 : : }
188 : :
189 : : {
190 [ + - ]: 1408 : std::unique_ptr<CCoinsViewCursor> coins_view_cursor = backend_coins_view.Cursor();
191 [ + - ]: 1408 : assert(!coins_view_cursor);
192 [ + - ]: 1408 : (void)backend_coins_view.EstimateSize();
193 [ + - ]: 1408 : (void)backend_coins_view.GetBestBlock();
194 [ + - ]: 1408 : (void)backend_coins_view.GetHeadBlocks();
195 : 1408 : }
196 : :
197 [ + - + + ]: 1408 : if (fuzzed_data_provider.ConsumeBool()) {
198 [ + - ]: 1046 : CallOneOf(
199 : : fuzzed_data_provider,
200 : 179223 : [&] {
201 : 178177 : const CTransaction transaction{random_mutable_transaction};
202 : 178177 : bool is_spent = false;
203 [ + + ]: 178187 : for (const CTxOut& tx_out : transaction.vout) {
204 [ + + + + : 178108 : if (Coin{tx_out, 0, transaction.IsCoinBase()}.IsSpent()) {
- + ]
205 : 10 : is_spent = true;
206 : 10 : }
207 : : }
208 [ + + ]: 79 : if (is_spent) {
209 : : // Avoid:
210 : : // coins.cpp:69: void CCoinsViewCache::AddCoin(const COutPoint &, Coin &&, bool): Assertion `!coin.IsSpent()' failed.
211 : 4 : return;
212 : : }
213 : 75 : bool expected_code_path = false;
214 [ + - ]: 75 : const int height{int(fuzzed_data_provider.ConsumeIntegral<uint32_t>() >> 1)};
215 [ + - ]: 75 : const bool possible_overwrite = fuzzed_data_provider.ConsumeBool();
216 : : try {
217 [ + + ]: 75 : AddCoins(coins_view_cache, transaction, height, possible_overwrite);
218 : 73 : expected_code_path = true;
219 [ - + ]: 75 : } catch (const std::logic_error& e) {
220 [ + - - + ]: 2 : if (e.what() == std::string{"Attempted to overwrite an unspent coin (when possible_overwrite is false)"}) {
221 [ + - ]: 2 : assert(!possible_overwrite);
222 : 2 : expected_code_path = true;
223 : 2 : }
224 [ # # + - ]: 2 : }
225 [ + - ]: 75 : assert(expected_code_path);
226 [ - + ]: 178179 : },
227 : 1690 : [&] {
228 [ + - ]: 644 : (void)AreInputsStandard(CTransaction{random_mutable_transaction}, coins_view_cache);
229 : 644 : },
230 : 1109 : [&] {
231 : 63 : TxValidationState state;
232 : : CAmount tx_fee_out;
233 [ + - ]: 63 : const CTransaction transaction{random_mutable_transaction};
234 [ + + ]: 63 : if (ContainsSpentInput(transaction, coins_view_cache)) {
235 : : // Avoid:
236 : : // consensus/tx_verify.cpp:171: bool Consensus::CheckTxInputs(const CTransaction &, TxValidationState &, const CCoinsViewCache &, int, CAmount &): Assertion `!coin.IsSpent()' failed.
237 : 12 : return;
238 : : }
239 : 51 : TxValidationState dummy;
240 [ + - + + ]: 51 : if (!CheckTransaction(transaction, dummy)) {
241 : : // It is not allowed to call CheckTxInputs if CheckTransaction failed
242 : 36 : return;
243 : : }
244 [ + - + - : 15 : if (Consensus::CheckTxInputs(transaction, state, coins_view_cache, fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()), tx_fee_out)) {
+ + ]
245 [ + - + - ]: 4 : assert(MoneyRange(tx_fee_out));
246 : 4 : }
247 [ - + ]: 63 : },
248 : 1083 : [&] {
249 : 37 : const CTransaction transaction{random_mutable_transaction};
250 [ + + ]: 37 : if (ContainsSpentInput(transaction, coins_view_cache)) {
251 : : // Avoid:
252 : : // consensus/tx_verify.cpp:130: unsigned int GetP2SHSigOpCount(const CTransaction &, const CCoinsViewCache &): Assertion `!coin.IsSpent()' failed.
253 : 22 : return;
254 : : }
255 [ + - ]: 15 : (void)GetP2SHSigOpCount(transaction, coins_view_cache);
256 [ - + ]: 37 : },
257 : 1187 : [&] {
258 : 141 : const CTransaction transaction{random_mutable_transaction};
259 [ + + ]: 141 : if (ContainsSpentInput(transaction, coins_view_cache)) {
260 : : // Avoid:
261 : : // consensus/tx_verify.cpp:130: unsigned int GetP2SHSigOpCount(const CTransaction &, const CCoinsViewCache &): Assertion `!coin.IsSpent()' failed.
262 : 13 : return;
263 : : }
264 [ + - ]: 128 : const auto flags{fuzzed_data_provider.ConsumeIntegral<uint32_t>()};
265 [ + + + + : 128 : if (!transaction.vin.empty() && (flags & SCRIPT_VERIFY_WITNESS) != 0 && (flags & SCRIPT_VERIFY_P2SH) == 0) {
+ + ]
266 : : // Avoid:
267 : : // script/interpreter.cpp:1705: size_t CountWitnessSigOps(const CScript &, const CScript &, const CScriptWitness *, unsigned int): Assertion `(flags & SCRIPT_VERIFY_P2SH) != 0' failed.
268 : 1 : return;
269 : : }
270 [ + - ]: 127 : (void)GetTransactionSigOpCost(transaction, coins_view_cache, flags);
271 [ - + ]: 141 : },
272 : 1128 : [&] {
273 [ + - ]: 82 : (void)IsWitnessStandard(CTransaction{random_mutable_transaction}, coins_view_cache);
274 : 82 : });
275 : 1046 : }
276 : 2816 : }
|
