aboutsummaryrefslogtreecommitdiff
path: root/src/test/fuzz/pow.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/test/fuzz/pow.cpp')
-rw-r--r--src/test/fuzz/pow.cpp81
1 files changed, 81 insertions, 0 deletions
diff --git a/src/test/fuzz/pow.cpp b/src/test/fuzz/pow.cpp
new file mode 100644
index 0000000000..0343d33401
--- /dev/null
+++ b/src/test/fuzz/pow.cpp
@@ -0,0 +1,81 @@
+// Copyright (c) 2020 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <chain.h>
+#include <chainparams.h>
+#include <optional.h>
+#include <pow.h>
+#include <primitives/block.h>
+#include <test/fuzz/FuzzedDataProvider.h>
+#include <test/fuzz/fuzz.h>
+#include <test/fuzz/util.h>
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+void initialize()
+{
+ SelectParams(CBaseChainParams::MAIN);
+}
+
+void test_one_input(const std::vector<uint8_t>& buffer)
+{
+ FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
+ const Consensus::Params& consensus_params = Params().GetConsensus();
+ std::vector<CBlockIndex> blocks;
+ const uint32_t fixed_time = fuzzed_data_provider.ConsumeIntegral<uint32_t>();
+ const uint32_t fixed_bits = fuzzed_data_provider.ConsumeIntegral<uint32_t>();
+ while (fuzzed_data_provider.remaining_bytes() > 0) {
+ const Optional<CBlockHeader> block_header = ConsumeDeserializable<CBlockHeader>(fuzzed_data_provider);
+ if (!block_header) {
+ continue;
+ }
+ CBlockIndex current_block{*block_header};
+ {
+ CBlockIndex* previous_block = !blocks.empty() ? &blocks[fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, blocks.size() - 1)] : nullptr;
+ const int current_height = (previous_block != nullptr && previous_block->nHeight != std::numeric_limits<int>::max()) ? previous_block->nHeight + 1 : 0;
+ if (fuzzed_data_provider.ConsumeBool()) {
+ current_block.pprev = previous_block;
+ }
+ if (fuzzed_data_provider.ConsumeBool()) {
+ current_block.nHeight = current_height;
+ }
+ if (fuzzed_data_provider.ConsumeBool()) {
+ current_block.nTime = fixed_time + current_height * consensus_params.nPowTargetSpacing;
+ }
+ if (fuzzed_data_provider.ConsumeBool()) {
+ current_block.nBits = fixed_bits;
+ }
+ if (fuzzed_data_provider.ConsumeBool()) {
+ current_block.nChainWork = previous_block != nullptr ? previous_block->nChainWork + GetBlockProof(*previous_block) : arith_uint256{0};
+ } else {
+ current_block.nChainWork = ConsumeArithUInt256(fuzzed_data_provider);
+ }
+ blocks.push_back(current_block);
+ }
+ {
+ (void)GetBlockProof(current_block);
+ (void)CalculateNextWorkRequired(&current_block, fuzzed_data_provider.ConsumeIntegralInRange<int64_t>(0, std::numeric_limits<int64_t>::max()), consensus_params);
+ if (current_block.nHeight != std::numeric_limits<int>::max() && current_block.nHeight - (consensus_params.DifficultyAdjustmentInterval() - 1) >= 0) {
+ (void)GetNextWorkRequired(&current_block, &(*block_header), consensus_params);
+ }
+ }
+ {
+ const CBlockIndex* to = &blocks[fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, blocks.size() - 1)];
+ const CBlockIndex* from = &blocks[fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, blocks.size() - 1)];
+ const CBlockIndex* tip = &blocks[fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, blocks.size() - 1)];
+ try {
+ (void)GetBlockProofEquivalentTime(*to, *from, *tip, consensus_params);
+ } catch (const uint_error&) {
+ }
+ }
+ {
+ const Optional<uint256> hash = ConsumeDeserializable<uint256>(fuzzed_data_provider);
+ if (hash) {
+ (void)CheckProofOfWork(*hash, fuzzed_data_provider.ConsumeIntegral<unsigned int>(), consensus_params);
+ }
+ }
+ }
+}