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 <chain.h>
       6                 :             : #include <chainparams.h>
       7                 :             : #include <pow.h>
       8                 :             : #include <primitives/block.h>
       9                 :             : #include <test/fuzz/FuzzedDataProvider.h>
      10                 :             : #include <test/fuzz/fuzz.h>
      11                 :             : #include <test/fuzz/util.h>
      12                 :             : #include <util/chaintype.h>
      13                 :             : #include <util/check.h>
      14                 :             : #include <util/overflow.h>
      15                 :             : 
      16                 :             : #include <cstdint>
      17                 :             : #include <optional>
      18                 :             : #include <string>
      19                 :             : #include <vector>
      20                 :             : 
      21                 :           2 : void initialize_pow()
      22                 :             : {
      23                 :           2 :     SelectParams(ChainType::MAIN);
      24                 :           2 : }
      25                 :             : 
      26         [ +  - ]:         703 : FUZZ_TARGET(pow, .init = initialize_pow)
      27                 :             : {
      28                 :         291 :     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
      29                 :         291 :     const Consensus::Params& consensus_params = Params().GetConsensus();
      30                 :         291 :     std::vector<std::unique_ptr<CBlockIndex>> blocks;
      31                 :         291 :     const uint32_t fixed_time = fuzzed_data_provider.ConsumeIntegral<uint32_t>();
      32                 :         291 :     const uint32_t fixed_bits = fuzzed_data_provider.ConsumeIntegral<uint32_t>();
      33   [ +  +  +  + ]:      179213 :     LIMITED_WHILE(fuzzed_data_provider.remaining_bytes() > 0, 10000) {
      34                 :      178922 :         const std::optional<CBlockHeader> block_header = ConsumeDeserializable<CBlockHeader>(fuzzed_data_provider);
      35         [ +  + ]:      178922 :         if (!block_header) {
      36                 :       74960 :             continue;
      37                 :             :         }
      38         [ +  - ]:      103962 :         CBlockIndex& current_block{
      39   [ +  -  +  - ]:      103962 :             *blocks.emplace_back(std::make_unique<CBlockIndex>(*block_header))};
      40                 :      103962 :         {
      41   [ +  -  +  - ]:      103962 :             CBlockIndex* previous_block = blocks.empty() ? nullptr : PickValue(fuzzed_data_provider, blocks).get();
      42   [ +  -  +  - ]:      103962 :             const int current_height = (previous_block != nullptr && previous_block->nHeight != std::numeric_limits<int>::max()) ? previous_block->nHeight + 1 : 0;
      43         [ +  + ]:      103962 :             if (fuzzed_data_provider.ConsumeBool()) {
      44                 :       59057 :                 current_block.pprev = previous_block;
      45                 :             :             }
      46         [ +  + ]:      103962 :             if (fuzzed_data_provider.ConsumeBool()) {
      47                 :       59383 :                 current_block.nHeight = current_height;
      48                 :             :             }
      49         [ +  + ]:      103962 :             if (fuzzed_data_provider.ConsumeBool()) {
      50                 :       58957 :                 const uint32_t seconds = current_height * consensus_params.nPowTargetSpacing;
      51         [ +  + ]:       58957 :                 if (!AdditionOverflow(fixed_time, seconds)) {
      52                 :       55619 :                     current_block.nTime = fixed_time + seconds;
      53                 :             :                 }
      54                 :             :             }
      55         [ +  + ]:      103962 :             if (fuzzed_data_provider.ConsumeBool()) {
      56                 :       58733 :                 current_block.nBits = fixed_bits;
      57                 :             :             }
      58         [ +  + ]:      103962 :             if (fuzzed_data_provider.ConsumeBool()) {
      59   [ +  -  +  -  :      117060 :                 current_block.nChainWork = previous_block != nullptr ? previous_block->nChainWork + GetBlockProof(*previous_block) : arith_uint256{0};
                   +  - ]
      60                 :             :             } else {
      61         [ +  - ]:       45432 :                 current_block.nChainWork = ConsumeArithUInt256(fuzzed_data_provider);
      62                 :             :             }
      63                 :             :         }
      64                 :      103962 :         {
      65         [ +  - ]:      103962 :             (void)GetBlockProof(current_block);
      66         [ +  - ]:      103962 :             (void)CalculateNextWorkRequired(&current_block, fuzzed_data_provider.ConsumeIntegralInRange<int64_t>(0, std::numeric_limits<int64_t>::max()), consensus_params);
      67   [ +  -  -  + ]:      103962 :             if (current_block.nHeight != std::numeric_limits<int>::max() && current_block.nHeight - (consensus_params.DifficultyAdjustmentInterval() - 1) >= 0) {
      68         [ #  # ]:           0 :                 (void)GetNextWorkRequired(&current_block, &(*block_header), consensus_params);
      69                 :             :             }
      70                 :             :         }
      71                 :      103962 :         {
      72                 :      103962 :             const auto& to = PickValue(fuzzed_data_provider, blocks);
      73                 :      103962 :             const auto& from = PickValue(fuzzed_data_provider, blocks);
      74                 :      103962 :             const auto& tip = PickValue(fuzzed_data_provider, blocks);
      75                 :      103962 :             try {
      76         [ +  + ]:      103962 :                 (void)GetBlockProofEquivalentTime(*to, *from, *tip, consensus_params);
      77         [ -  + ]:       60453 :             } catch (const uint_error&) {
      78         [ +  - ]:       60453 :             }
      79                 :             :         }
      80                 :      103962 :         {
      81                 :      103962 :             const std::optional<uint256> hash = ConsumeDeserializable<uint256>(fuzzed_data_provider);
      82         [ +  + ]:      103962 :             if (hash) {
      83         [ +  - ]:       45434 :                 (void)CheckProofOfWorkImpl(*hash, fuzzed_data_provider.ConsumeIntegral<unsigned int>(), consensus_params);
      84                 :             :             }
      85                 :             :         }
      86                 :             :     }
      87                 :         291 : }
      88                 :             : 
      89                 :             : 
      90         [ +  - ]:         570 : FUZZ_TARGET(pow_transition, .init = initialize_pow)
      91                 :             : {
      92                 :         158 :     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
      93                 :         158 :     const Consensus::Params& consensus_params{Params().GetConsensus()};
      94                 :         158 :     std::vector<std::unique_ptr<CBlockIndex>> blocks;
      95                 :             : 
      96                 :         158 :     const uint32_t old_time{fuzzed_data_provider.ConsumeIntegral<uint32_t>()};
      97                 :         158 :     const uint32_t new_time{fuzzed_data_provider.ConsumeIntegral<uint32_t>()};
      98                 :         158 :     const int32_t version{fuzzed_data_provider.ConsumeIntegral<int32_t>()};
      99                 :         158 :     uint32_t nbits{fuzzed_data_provider.ConsumeIntegral<uint32_t>()};
     100                 :             : 
     101         [ +  - ]:         158 :     const arith_uint256 pow_limit = UintToArith256(consensus_params.powLimit);
     102                 :         158 :     arith_uint256 old_target;
     103         [ +  - ]:         158 :     old_target.SetCompact(nbits);
     104   [ +  -  +  + ]:         158 :     if (old_target > pow_limit) {
     105         [ +  - ]:           2 :         nbits = pow_limit.GetCompact();
     106                 :             :     }
     107                 :             :     // Create one difficulty adjustment period worth of headers
     108         [ +  + ]:      318686 :     for (int height = 0; height < consensus_params.DifficultyAdjustmentInterval(); ++height) {
     109                 :      318528 :         CBlockHeader header;
     110                 :      318528 :         header.nVersion = version;
     111                 :      318528 :         header.nTime = old_time;
     112                 :      318528 :         header.nBits = nbits;
     113         [ +  + ]:      318528 :         if (height == consensus_params.DifficultyAdjustmentInterval() - 1) {
     114                 :         158 :             header.nTime = new_time;
     115                 :             :         }
     116         [ +  - ]:      318528 :         auto current_block{std::make_unique<CBlockIndex>(header)};
     117   [ +  +  +  - ]:      318528 :         current_block->pprev = blocks.empty() ? nullptr : blocks.back().get();
     118                 :      318528 :         current_block->nHeight = height;
     119         [ +  - ]:      318528 :         blocks.emplace_back(std::move(current_block));
     120                 :      318528 :     }
     121         [ +  - ]:         158 :     auto last_block{blocks.back().get()};
     122         [ +  - ]:         158 :     unsigned int new_nbits{GetNextWorkRequired(last_block, nullptr, consensus_params)};
     123   [ +  -  +  - ]:         158 :     Assert(PermittedDifficultyTransition(consensus_params, last_block->nHeight + 1, last_block->nBits, new_nbits));
     124                 :         158 : }