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