LCOV - code coverage report
Current view: top level - src/test/fuzz - coins_view.cpp (source / functions) Coverage Total Hit
Test: fuzz_coverage.info Lines: 98.6 % 211 208
Test Date: 2025-06-16 04:13:27 Functions: 100.0 % 21 21
Branches: 68.8 % 234 161

             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                 :        7297 : bool operator==(const Coin& a, const Coin& b)
      34                 :             : {
      35   [ +  +  -  + ]:        7297 :     if (a.IsSpent() && b.IsSpent()) return true;
      36   [ +  +  +  +  :        5958 :     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   [ +  -  +  - ]:           4 :     static const auto testing_setup = MakeNoLogFileContext<>();
      43         [ +  - ]:           4 : }
      44                 :             : 
      45                 :        4318 : void TestCoinsView(FuzzedDataProvider& fuzzed_data_provider, CCoinsView& backend_coins_view, bool is_db)
      46                 :             : {
      47                 :        4318 :     bool good_data{true};
      48                 :             : 
      49                 :        4318 :     CCoinsViewCache coins_view_cache{&backend_coins_view, /*deterministic=*/true};
      50   [ +  +  +  - ]:        4318 :     if (is_db) coins_view_cache.SetBestBlock(uint256::ONE);
      51                 :        4318 :     COutPoint random_out_point;
      52                 :        4318 :     Coin random_coin;
      53         [ +  - ]:        4318 :     CMutableTransaction random_mutable_transaction;
      54   [ +  +  +  +  :     4198138 :     LIMITED_WHILE(good_data && fuzzed_data_provider.ConsumeBool(), 10'000)
                   +  + ]
      55                 :             :     {
      56         [ +  - ]:     2095017 :         CallOneOf(
      57                 :             :             fuzzed_data_provider,
      58                 :      293891 :             [&] {
      59         [ +  + ]:      293891 :                 if (random_coin.IsSpent()) {
      60                 :             :                     return;
      61                 :             :                 }
      62                 :      259865 :                 Coin coin = random_coin;
      63                 :      259865 :                 bool expected_code_path = false;
      64                 :      259865 :                 const bool possible_overwrite = fuzzed_data_provider.ConsumeBool();
      65                 :      259865 :                 try {
      66         [ +  + ]:      259865 :                     coins_view_cache.AddCoin(random_out_point, std::move(coin), possible_overwrite);
      67                 :             :                     expected_code_path = true;
      68         [ -  + ]:       12959 :                 } catch (const std::logic_error& e) {
      69   [ +  -  +  - ]:       12959 :                     if (e.what() == std::string{"Attempted to overwrite an unspent coin (when possible_overwrite is false)"}) {
      70         [ -  + ]:       12959 :                         assert(!possible_overwrite);
      71                 :       12959 :                         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         [ +  - ]:       12959 :                         (void)coins_view_cache.Flush();
      78                 :             :                     }
      79                 :           0 :                 }
      80                 :       12959 :                 assert(expected_code_path);
      81                 :      259865 :             },
      82                 :      446110 :             [&] {
      83                 :      446110 :                 (void)coins_view_cache.Flush();
      84                 :      446110 :             },
      85                 :     1072421 :             [&] {
      86                 :     1072421 :                 (void)coins_view_cache.Sync();
      87                 :     1072421 :             },
      88                 :        6583 :             [&] {
      89                 :        6583 :                 uint256 best_block{ConsumeUInt256(fuzzed_data_provider)};
      90                 :             :                 // Set best block hash to non-null to satisfy the assertion in CCoinsViewDB::BatchWrite().
      91   [ +  +  +  + ]:        6583 :                 if (is_db && best_block.IsNull()) best_block = uint256::ONE;
      92                 :        6583 :                 coins_view_cache.SetBestBlock(best_block);
      93                 :        6583 :             },
      94                 :      200378 :             [&] {
      95                 :      200378 :                 Coin move_to;
      96   [ +  +  +  - ]:      209387 :                 (void)coins_view_cache.SpendCoin(random_out_point, fuzzed_data_provider.ConsumeBool() ? &move_to : nullptr);
      97                 :      200378 :             },
      98                 :       15884 :             [&] {
      99                 :       15884 :                 coins_view_cache.Uncache(random_out_point);
     100                 :       15884 :             },
     101                 :       10679 :             [&] {
     102         [ +  + ]:       10679 :                 if (fuzzed_data_provider.ConsumeBool()) {
     103                 :        9839 :                     backend_coins_view = CCoinsView{};
     104                 :             :                 }
     105                 :       10679 :                 coins_view_cache.SetBackend(backend_coins_view);
     106                 :       10679 :             },
     107                 :        4785 :             [&] {
     108                 :        4785 :                 const std::optional<COutPoint> opt_out_point = ConsumeDeserializable<COutPoint>(fuzzed_data_provider);
     109         [ +  + ]:        4785 :                 if (!opt_out_point) {
     110                 :          54 :                     good_data = false;
     111                 :          54 :                     return;
     112                 :             :                 }
     113                 :        4731 :                 random_out_point = *opt_out_point;
     114                 :             :             },
     115                 :       14156 :             [&] {
     116                 :       14156 :                 const std::optional<Coin> opt_coin = ConsumeDeserializable<Coin>(fuzzed_data_provider);
     117         [ +  + ]:       14156 :                 if (!opt_coin) {
     118                 :         145 :                     good_data = false;
     119                 :         145 :                     return;
     120                 :             :                 }
     121                 :       14011 :                 random_coin = *opt_coin;
     122                 :       14156 :             },
     123                 :       11827 :             [&] {
     124                 :       11827 :                 const std::optional<CMutableTransaction> opt_mutable_transaction = ConsumeDeserializable<CMutableTransaction>(fuzzed_data_provider, TX_WITH_WITNESS);
     125         [ +  + ]:       11827 :                 if (!opt_mutable_transaction) {
     126                 :         284 :                     good_data = false;
     127         [ -  + ]:         284 :                     return;
     128                 :             :                 }
     129         [ +  - ]:       11543 :                 random_mutable_transaction = *opt_mutable_transaction;
     130                 :       11827 :             },
     131                 :       18303 :             [&] {
     132                 :       18303 :                 CoinsCachePair sentinel{};
     133                 :       18303 :                 sentinel.second.SelfRef(sentinel);
     134                 :       18303 :                 size_t usage{0};
     135         [ +  - ]:       18303 :                 CCoinsMapMemoryResource resource;
     136   [ +  -  +  - ]:       18303 :                 CCoinsMap coins_map{0, SaltedOutpointHasher{/*deterministic=*/true}, CCoinsMap::key_equal{}, &resource};
     137   [ +  -  +  +  :      396083 :                 LIMITED_WHILE(good_data && fuzzed_data_provider.ConsumeBool(), 10'000)
                   +  + ]
     138                 :             :                 {
     139                 :      377829 :                     CCoinsCacheEntry coins_cache_entry;
     140                 :      377829 :                     const auto dirty{fuzzed_data_provider.ConsumeBool()};
     141                 :      377829 :                     const auto fresh{fuzzed_data_provider.ConsumeBool()};
     142         [ +  + ]:      377829 :                     if (fuzzed_data_provider.ConsumeBool()) {
     143                 :      373283 :                         coins_cache_entry.coin = random_coin;
     144                 :             :                     } else {
     145                 :        4546 :                         const std::optional<Coin> opt_coin = ConsumeDeserializable<Coin>(fuzzed_data_provider);
     146         [ +  + ]:        4546 :                         if (!opt_coin) {
     147                 :          49 :                             good_data = false;
     148                 :          49 :                             return;
     149                 :             :                         }
     150                 :        4497 :                         coins_cache_entry.coin = *opt_coin;
     151                 :        4497 :                     }
     152         [ +  - ]:      377780 :                     auto it{coins_map.emplace(random_out_point, std::move(coins_cache_entry)).first};
     153         [ +  + ]:      377780 :                     if (dirty) CCoinsCacheEntry::SetDirty(*it, sentinel);
     154         [ +  + ]:      377780 :                     if (fresh) CCoinsCacheEntry::SetFresh(*it, sentinel);
     155         [ +  + ]:      377780 :                     usage += it->second.coin.DynamicMemoryUsage();
     156                 :      377829 :                 }
     157                 :       18254 :                 bool expected_code_path = false;
     158                 :       18254 :                 try {
     159         [ +  - ]:       18254 :                     auto cursor{CoinsViewCacheCursor(usage, sentinel, coins_map, /*will_erase=*/true)};
     160         [ +  - ]:       18254 :                     uint256 best_block{coins_view_cache.GetBestBlock()};
     161         [ +  + ]:       18254 :                     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   [ +  +  +  + ]:       18254 :                     if (is_db && best_block.IsNull()) best_block = uint256::ONE;
     164         [ +  + ]:       18254 :                     coins_view_cache.BatchWrite(cursor, best_block);
     165                 :             :                     expected_code_path = true;
     166         [ -  + ]:        2788 :                 } catch (const std::logic_error& e) {
     167   [ +  -  +  - ]:        2788 :                     if (e.what() == std::string{"FRESH flag misapplied to coin that exists in parent cache"}) {
     168                 :        2788 :                         expected_code_path = true;
     169                 :             :                     }
     170                 :           0 :                 }
     171                 :        2788 :                 assert(expected_code_path);
     172                 :       18303 :             });
     173                 :             :     }
     174                 :             : 
     175                 :        4318 :     {
     176         [ +  - ]:        4318 :         const Coin& coin_using_access_coin = coins_view_cache.AccessCoin(random_out_point);
     177                 :        4318 :         const bool exists_using_access_coin = !(coin_using_access_coin == EMPTY_COIN);
     178         [ +  - ]:        4318 :         const bool exists_using_have_coin = coins_view_cache.HaveCoin(random_out_point);
     179         [ +  - ]:        4318 :         const bool exists_using_have_coin_in_cache = coins_view_cache.HaveCoinInCache(random_out_point);
     180   [ +  -  +  + ]:        4318 :         if (auto coin{coins_view_cache.GetCoin(random_out_point)}) {
     181         [ -  + ]:        2979 :             assert(*coin == coin_using_access_coin);
     182   [ +  -  -  + ]:        2979 :             assert(exists_using_access_coin && exists_using_have_coin_in_cache && exists_using_have_coin);
     183                 :             :         } else {
     184   [ +  -  -  + ]:        1339 :             assert(!exists_using_access_coin && !exists_using_have_coin_in_cache && !exists_using_have_coin);
     185                 :        4318 :         }
     186                 :             :         // If HaveCoin on the backend is true, it must also be on the cache if the coin wasn't spent.
     187         [ +  - ]:        4318 :         const bool exists_using_have_coin_in_backend = backend_coins_view.HaveCoin(random_out_point);
     188   [ +  +  +  + ]:        4318 :         if (!coin_using_access_coin.IsSpent() && exists_using_have_coin_in_backend) {
     189         [ -  + ]:        1103 :             assert(exists_using_have_coin);
     190                 :             :         }
     191   [ +  -  +  + ]:        4318 :         if (auto coin{backend_coins_view.GetCoin(random_out_point)}) {
     192         [ -  + ]:        1131 :             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         [ -  + ]:        3187 :             assert(!exists_using_have_coin_in_backend);
     197                 :        4318 :         }
     198                 :             :     }
     199                 :             : 
     200                 :        4318 :     {
     201                 :        4318 :         bool expected_code_path = false;
     202                 :        4318 :         try {
     203                 :        4318 :             (void)coins_view_cache.Cursor();
     204         [ -  + ]:        4318 :         } catch (const std::logic_error&) {
     205                 :        4318 :             expected_code_path = true;
     206                 :        4318 :         }
     207                 :        4318 :         assert(expected_code_path);
     208         [ +  - ]:        4318 :         (void)coins_view_cache.DynamicMemoryUsage();
     209         [ +  - ]:        4318 :         (void)coins_view_cache.EstimateSize();
     210         [ +  - ]:        4318 :         (void)coins_view_cache.GetBestBlock();
     211         [ +  - ]:        4318 :         (void)coins_view_cache.GetCacheSize();
     212         [ +  - ]:        4318 :         (void)coins_view_cache.GetHeadBlocks();
     213   [ +  -  +  - ]:        4318 :         (void)coins_view_cache.HaveInputs(CTransaction{random_mutable_transaction});
     214                 :             :     }
     215                 :             : 
     216                 :        4318 :     {
     217         [ +  - ]:        4318 :         std::unique_ptr<CCoinsViewCursor> coins_view_cursor = backend_coins_view.Cursor();
     218         [ -  + ]:        4318 :         assert(is_db == !!coins_view_cursor);
     219         [ +  - ]:        4318 :         (void)backend_coins_view.EstimateSize();
     220         [ +  - ]:        4318 :         (void)backend_coins_view.GetBestBlock();
     221         [ +  - ]:        4318 :         (void)backend_coins_view.GetHeadBlocks();
     222                 :        4318 :     }
     223                 :             : 
     224         [ +  + ]:        4318 :     if (fuzzed_data_provider.ConsumeBool()) {
     225         [ +  - ]:        3219 :         CallOneOf(
     226                 :             :             fuzzed_data_provider,
     227                 :         259 :             [&] {
     228                 :         259 :                 const CTransaction transaction{random_mutable_transaction};
     229                 :         259 :                 bool is_spent = false;
     230         [ +  + ]:     1649852 :                 for (const CTxOut& tx_out : transaction.vout) {
     231         [ +  + ]:     1649593 :                     if (Coin{tx_out, 0, transaction.IsCoinBase()}.IsSpent()) {
     232                 :          21 :                         is_spent = true;
     233                 :             :                     }
     234                 :             :                 }
     235         [ +  + ]:         259 :                 if (is_spent) {
     236                 :             :                     // Avoid:
     237                 :             :                     // coins.cpp:69: void CCoinsViewCache::AddCoin(const COutPoint &, Coin &&, bool): Assertion `!coin.IsSpent()' failed.
     238                 :           9 :                     return;
     239                 :             :                 }
     240                 :         250 :                 bool expected_code_path = false;
     241                 :         250 :                 const int height{int(fuzzed_data_provider.ConsumeIntegral<uint32_t>() >> 1)};
     242                 :         250 :                 const bool possible_overwrite = fuzzed_data_provider.ConsumeBool();
     243                 :         250 :                 try {
     244         [ +  + ]:         250 :                     AddCoins(coins_view_cache, transaction, height, possible_overwrite);
     245                 :             :                     expected_code_path = true;
     246         [ -  + ]:           2 :                 } catch (const std::logic_error& e) {
     247   [ +  -  +  - ]:           2 :                     if (e.what() == std::string{"Attempted to overwrite an unspent coin (when possible_overwrite is false)"}) {
     248         [ -  + ]:           2 :                         assert(!possible_overwrite);
     249                 :             :                         expected_code_path = true;
     250                 :             :                     }
     251                 :           0 :                 }
     252                 :           2 :                 assert(expected_code_path);
     253                 :         259 :             },
     254                 :        1903 :             [&] {
     255         [ +  - ]:        1903 :                 (void)AreInputsStandard(CTransaction{random_mutable_transaction}, coins_view_cache);
     256                 :        1903 :             },
     257                 :         164 :             [&] {
     258         [ +  - ]:         164 :                 TxValidationState state;
     259                 :         164 :                 CAmount tx_fee_out;
     260         [ +  - ]:         164 :                 const CTransaction transaction{random_mutable_transaction};
     261         [ +  + ]:         164 :                 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         [ +  - ]:         149 :                 TxValidationState dummy;
     267   [ +  -  +  + ]:         149 :                 if (!CheckTransaction(transaction, dummy)) {
     268                 :             :                     // It is not allowed to call CheckTxInputs if CheckTransaction failed
     269                 :          99 :                     return;
     270                 :             :                 }
     271   [ +  -  +  + ]:          50 :                 if (Consensus::CheckTxInputs(transaction, state, coins_view_cache, fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()), tx_fee_out)) {
     272         [ -  + ]:           3 :                     assert(MoneyRange(tx_fee_out));
     273                 :             :                 }
     274                 :         477 :             },
     275                 :         164 :             [&] {
     276                 :         164 :                 const CTransaction transaction{random_mutable_transaction};
     277         [ +  + ]:         164 :                 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                 :          48 :                     return;
     281                 :             :                 }
     282         [ +  - ]:         116 :                 (void)GetP2SHSigOpCount(transaction, coins_view_cache);
     283                 :         164 :             },
     284                 :         396 :             [&] {
     285                 :         396 :                 const CTransaction transaction{random_mutable_transaction};
     286         [ +  + ]:         396 :                 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                 :         386 :                 const auto flags{fuzzed_data_provider.ConsumeIntegral<uint32_t>()};
     292   [ +  +  +  + ]:         386 :                 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         [ +  - ]:         384 :                 (void)GetTransactionSigOpCost(transaction, coins_view_cache, flags);
     298                 :         396 :             },
     299                 :         333 :             [&] {
     300         [ +  - ]:         333 :                 (void)IsWitnessStandard(CTransaction{random_mutable_transaction}, coins_view_cache);
     301                 :         333 :             });
     302                 :             :     }
     303                 :        4318 : }
     304                 :             : 
     305         [ +  - ]:        2578 : FUZZ_TARGET(coins_view, .init = initialize_coins_view)
     306                 :             : {
     307         [ +  - ]:        2134 :     FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
     308                 :        2134 :     CCoinsView backend_coins_view;
     309         [ +  - ]:        2134 :     TestCoinsView(fuzzed_data_provider, backend_coins_view, /*is_db=*/false);
     310                 :        2134 : }
     311                 :             : 
     312         [ +  - ]:        2628 : FUZZ_TARGET(coins_view_db, .init = initialize_coins_view)
     313                 :             : {
     314                 :        2184 :     FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
     315                 :        2184 :     auto db_params = DBParams{
     316                 :             :         .path = "",
     317                 :             :         .cache_bytes = 1_MiB,
     318                 :             :         .memory_only = true,
     319                 :        2184 :     };
     320         [ +  - ]:        2184 :     CCoinsViewDB coins_db{std::move(db_params), CoinsViewOptions{}};
     321         [ +  - ]:        2184 :     TestCoinsView(fuzzed_data_provider, coins_db, /*is_db=*/true);
     322                 :        4368 : }
        

Generated by: LCOV version 2.0-1