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 [ + - ]: 753 : FUZZ_TARGET(pow, .init = initialize_pow)
27 : : {
28 : 339 : FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
29 : 339 : const Consensus::Params& consensus_params = Params().GetConsensus();
30 : 339 : std::vector<std::unique_ptr<CBlockIndex>> blocks;
31 : 339 : const uint32_t fixed_time = fuzzed_data_provider.ConsumeIntegral<uint32_t>();
32 : 339 : const uint32_t fixed_bits = fuzzed_data_provider.ConsumeIntegral<uint32_t>();
33 [ + + + + ]: 219972 : LIMITED_WHILE(fuzzed_data_provider.remaining_bytes() > 0, 10000) {
34 : 219633 : const std::optional<CBlockHeader> block_header = ConsumeDeserializable<CBlockHeader>(fuzzed_data_provider);
35 [ + + ]: 219633 : if (!block_header) {
36 : 86996 : continue;
37 : : }
38 [ + - ]: 132637 : CBlockIndex& current_block{
39 [ + - + - ]: 132637 : *blocks.emplace_back(std::make_unique<CBlockIndex>(*block_header))};
40 : 132637 : {
41 [ + - + - ]: 132637 : CBlockIndex* previous_block = blocks.empty() ? nullptr : PickValue(fuzzed_data_provider, blocks).get();
42 [ + - + - ]: 132637 : const int current_height = (previous_block != nullptr && previous_block->nHeight != std::numeric_limits<int>::max()) ? previous_block->nHeight + 1 : 0;
43 [ + + ]: 132637 : if (fuzzed_data_provider.ConsumeBool()) {
44 : 77040 : current_block.pprev = previous_block;
45 : : }
46 [ + + ]: 132637 : if (fuzzed_data_provider.ConsumeBool()) {
47 : 77286 : current_block.nHeight = current_height;
48 : : }
49 [ + + ]: 132637 : if (fuzzed_data_provider.ConsumeBool()) {
50 : 76834 : const uint32_t seconds = current_height * consensus_params.nPowTargetSpacing;
51 [ + + ]: 76834 : if (!AdditionOverflow(fixed_time, seconds)) {
52 : 70534 : current_block.nTime = fixed_time + seconds;
53 : : }
54 : : }
55 [ + + ]: 132637 : if (fuzzed_data_provider.ConsumeBool()) {
56 : 76373 : current_block.nBits = fixed_bits;
57 : : }
58 [ + + ]: 132637 : if (fuzzed_data_provider.ConsumeBool()) {
59 [ + - + - : 152266 : current_block.nChainWork = previous_block != nullptr ? previous_block->nChainWork + GetBlockProof(*previous_block) : arith_uint256{0};
+ - ]
60 : : } else {
61 [ + - ]: 56504 : current_block.nChainWork = ConsumeArithUInt256(fuzzed_data_provider);
62 : : }
63 : : }
64 : 132637 : {
65 [ + - ]: 132637 : (void)GetBlockProof(current_block);
66 [ + - ]: 132637 : (void)CalculateNextWorkRequired(¤t_block, fuzzed_data_provider.ConsumeIntegralInRange<int64_t>(0, std::numeric_limits<int64_t>::max()), consensus_params);
67 [ + - - + ]: 132637 : if (current_block.nHeight != std::numeric_limits<int>::max() && current_block.nHeight - (consensus_params.DifficultyAdjustmentInterval() - 1) >= 0) {
68 [ # # ]: 0 : (void)GetNextWorkRequired(¤t_block, &(*block_header), consensus_params);
69 : : }
70 : : }
71 : 132637 : {
72 : 132637 : const auto& to = PickValue(fuzzed_data_provider, blocks);
73 : 132637 : const auto& from = PickValue(fuzzed_data_provider, blocks);
74 : 132637 : const auto& tip = PickValue(fuzzed_data_provider, blocks);
75 : 132637 : try {
76 [ + + ]: 132637 : (void)GetBlockProofEquivalentTime(*to, *from, *tip, consensus_params);
77 [ - + ]: 82749 : } catch (const uint_error&) {
78 [ + - ]: 82749 : }
79 : : }
80 : 132637 : {
81 : 132637 : const std::optional<uint256> hash = ConsumeDeserializable<uint256>(fuzzed_data_provider);
82 [ + + ]: 132637 : if (hash) {
83 [ + - ]: 56825 : (void)CheckProofOfWorkImpl(*hash, fuzzed_data_provider.ConsumeIntegral<unsigned int>(), consensus_params);
84 : : }
85 : : }
86 : : }
87 : 339 : }
88 : :
89 : :
90 [ + - ]: 591 : FUZZ_TARGET(pow_transition, .init = initialize_pow)
91 : : {
92 : 177 : FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
93 : 177 : const Consensus::Params& consensus_params{Params().GetConsensus()};
94 : 177 : std::vector<std::unique_ptr<CBlockIndex>> blocks;
95 : :
96 : 177 : const uint32_t old_time{fuzzed_data_provider.ConsumeIntegral<uint32_t>()};
97 : 177 : const uint32_t new_time{fuzzed_data_provider.ConsumeIntegral<uint32_t>()};
98 : 177 : const int32_t version{fuzzed_data_provider.ConsumeIntegral<int32_t>()};
99 : 177 : uint32_t nbits{fuzzed_data_provider.ConsumeIntegral<uint32_t>()};
100 : :
101 [ + - ]: 177 : const arith_uint256 pow_limit = UintToArith256(consensus_params.powLimit);
102 : 177 : arith_uint256 old_target;
103 [ + - ]: 177 : old_target.SetCompact(nbits);
104 [ + - + + ]: 177 : if (old_target > pow_limit) {
105 [ + - ]: 2 : nbits = pow_limit.GetCompact();
106 : : }
107 : : // Create one difficulty adjustment period worth of headers
108 [ + + ]: 357009 : for (int height = 0; height < consensus_params.DifficultyAdjustmentInterval(); ++height) {
109 : 356832 : CBlockHeader header;
110 : 356832 : header.nVersion = version;
111 : 356832 : header.nTime = old_time;
112 : 356832 : header.nBits = nbits;
113 [ + + ]: 356832 : if (height == consensus_params.DifficultyAdjustmentInterval() - 1) {
114 : 177 : header.nTime = new_time;
115 : : }
116 [ + - ]: 356832 : auto current_block{std::make_unique<CBlockIndex>(header)};
117 [ + + + - ]: 356832 : current_block->pprev = blocks.empty() ? nullptr : blocks.back().get();
118 : 356832 : current_block->nHeight = height;
119 [ + - ]: 356832 : blocks.emplace_back(std::move(current_block));
120 : 356832 : }
121 [ + - ]: 177 : auto last_block{blocks.back().get()};
122 [ + - ]: 177 : unsigned int new_nbits{GetNextWorkRequired(last_block, nullptr, consensus_params)};
123 [ + - + - ]: 177 : Assert(PermittedDifficultyTransition(consensus_params, last_block->nHeight + 1, last_block->nBits, new_nbits));
124 : 177 : }
|
