Bitcoin Core 29.99.0
P2P Digital Currency
process_message.cpp
Go to the documentation of this file.
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
6#include <net.h>
7#include <net_processing.h>
8#include <node/warnings.h>
10#include <protocol.h>
11#include <script/script.h>
12#include <sync.h>
14#include <test/fuzz/fuzz.h>
15#include <test/fuzz/util.h>
16#include <test/fuzz/util/net.h>
17#include <test/util/mining.h>
18#include <test/util/net.h>
21#include <util/check.h>
22#include <util/time.h>
23#include <validationinterface.h>
24
25#include <cstdlib>
26#include <iostream>
27#include <memory>
28#include <string>
29#include <string_view>
30#include <vector>
31
32namespace {
33TestingSetup* g_setup;
34std::string_view LIMIT_TO_MESSAGE_TYPE{};
35
36void ResetChainman(TestingSetup& setup)
37{
38 SetMockTime(setup.m_node.chainman->GetParams().GenesisBlock().Time());
39 setup.m_node.chainman.reset();
40 setup.m_make_chainman();
42 for (int i = 0; i < 2 * COINBASE_MATURITY; i++) {
43 MineBlock(setup.m_node, {});
44 }
45 setup.m_node.validation_signals->SyncWithValidationInterfaceQueue();
46}
47} // namespace
48
50{
51 if (const auto val{std::getenv("LIMIT_TO_MESSAGE_TYPE")}) {
52 LIMIT_TO_MESSAGE_TYPE = val;
53 Assert(std::count(ALL_NET_MESSAGE_TYPES.begin(), ALL_NET_MESSAGE_TYPES.end(), LIMIT_TO_MESSAGE_TYPE)); // Unknown message type passed
54 }
55
56 static const auto testing_setup{
57 MakeNoLogFileContext<TestingSetup>(
58 /*chain_type=*/ChainType::REGTEST,
59 {}),
60 };
61 g_setup = testing_setup.get();
62 ResetChainman(*g_setup);
63}
64
66{
68 FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
69
70 auto& connman = static_cast<ConnmanTestMsg&>(*g_setup->m_node.connman);
71 connman.ResetAddrCache();
72 connman.ResetMaxOutboundCycle();
73 auto& chainman = static_cast<TestChainstateManager&>(*g_setup->m_node.chainman);
74 const auto block_index_size{WITH_LOCK(chainman.GetMutex(), return chainman.BlockIndex().size())};
75 SetMockTime(1610000000); // any time to successfully reset ibd
76 chainman.ResetIbd();
77 chainman.DisableNextWrite();
78
79 node::Warnings warnings{};
80 NetGroupManager netgroupman{{}};
81 AddrMan addrman{netgroupman, /*deterministic=*/true, /*consistency_check_ratio=*/0};
82 auto peerman = PeerManager::make(connman, addrman,
83 /*banman=*/nullptr, chainman,
84 *g_setup->m_node.mempool, warnings,
86 .reconcile_txs = true,
87 .deterministic_rng = true,
88 });
89
90 connman.SetMsgProc(peerman.get());
92
93 const std::string random_message_type{fuzzed_data_provider.ConsumeBytesAsString(CMessageHeader::MESSAGE_TYPE_SIZE).c_str()};
94 if (!LIMIT_TO_MESSAGE_TYPE.empty() && random_message_type != LIMIT_TO_MESSAGE_TYPE) {
95 return;
96 }
97 CNode& p2p_node = *ConsumeNodeAsUniquePtr(fuzzed_data_provider).release();
98
99 connman.AddTestNode(p2p_node);
100 FillNode(fuzzed_data_provider, connman, p2p_node);
101
102 const auto mock_time = ConsumeTime(fuzzed_data_provider);
103 SetMockTime(mock_time);
104
105 CSerializedNetMsg net_msg;
106 net_msg.m_type = random_message_type;
107 net_msg.data = ConsumeRandomLengthByteVector(fuzzed_data_provider, MAX_PROTOCOL_MESSAGE_LENGTH);
108
109 connman.FlushSendBuffer(p2p_node);
110 (void)connman.ReceiveMsgFrom(p2p_node, std::move(net_msg));
111
112 bool more_work{true};
113 while (more_work) {
114 p2p_node.fPauseSend = false;
115 try {
116 more_work = connman.ProcessMessagesOnce(p2p_node);
117 } catch (const std::ios_base::failure&) {
118 }
119 g_setup->m_node.peerman->SendMessages(&p2p_node);
120 }
121 g_setup->m_node.validation_signals->SyncWithValidationInterfaceQueue();
122 g_setup->m_node.connman->StopNodes();
123 if (block_index_size != WITH_LOCK(chainman.GetMutex(), return chainman.BlockIndex().size())) {
124 // Reuse the global chainman, but reset it when it is dirty
125 ResetChainman(*g_setup);
126 }
127}
#define Assert(val)
Identity function.
Definition: check.h:106
Stochastic address manager.
Definition: addrman.h:89
static constexpr size_t MESSAGE_TYPE_SIZE
Definition: protocol.h:31
Information about a peer.
Definition: net.h:675
std::atomic_bool fPauseSend
Definition: net.h:739
std::string ConsumeBytesAsString(size_t num_bytes)
static Mutex g_msgproc_mutex
Mutex for anything that is only accessed via the msg processing thread.
Definition: net.h:1013
Netgroup manager.
Definition: netgroup.h:16
static std::unique_ptr< PeerManager > make(CConnman &connman, AddrMan &addrman, BanMan *banman, ChainstateManager &chainman, CTxMemPool &pool, node::Warnings &warnings, Options opts)
Manages warning messages within a node.
Definition: warnings.h:40
static const int COINBASE_MATURITY
Coinbase transaction outputs can only be spent after this number of new blocks (network rule)
Definition: consensus.h:19
static const unsigned int MAX_PROTOCOL_MESSAGE_LENGTH
Maximum length of incoming protocol messages (no message over 4 MB is currently acceptable).
Definition: net.h:64
FUZZ_TARGET(process_message,.init=initialize_process_message)
void initialize_process_message()
const std::array ALL_NET_MESSAGE_TYPES
All known message types (see above).
Definition: protocol.h:270
node::NodeContext m_node
Definition: setup_common.h:66
std::string m_type
Definition: net.h:132
std::vector< unsigned char > data
Definition: net.h:131
std::function< void()> m_make_chainman
Definition: setup_common.h:110
void LoadVerifyActivateChainstate()
void ResetAddrCache()
Definition: net.cpp:74
Testing setup that configures a complete environment.
Definition: setup_common.h:121
std::unique_ptr< ValidationSignals > validation_signals
Issues calls about blocks and transactions.
Definition: context.h:88
std::unique_ptr< CConnman > connman
Definition: context.h:67
std::unique_ptr< CTxMemPool > mempool
Definition: context.h:68
std::unique_ptr< ChainstateManager > chainman
Definition: context.h:72
std::unique_ptr< PeerManager > peerman
Definition: context.h:71
#define LOCK(cs)
Definition: sync.h:259
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
Definition: sync.h:290
void FillNode(FuzzedDataProvider &fuzzed_data_provider, ConnmanTestMsg &connman, CNode &node) noexcept
Definition: net.cpp:429
std::unique_ptr< CNode > ConsumeNodeAsUniquePtr(FuzzedDataProvider &fdp, const std::optional< NodeId > &node_id_in=std::nullopt)
Definition: net.h:267
int64_t ConsumeTime(FuzzedDataProvider &fuzzed_data_provider, const std::optional< int64_t > &min, const std::optional< int64_t > &max) noexcept
Definition: util.cpp:34
std::vector< B > ConsumeRandomLengthByteVector(FuzzedDataProvider &fuzzed_data_provider, const std::optional< size_t > &max_length=std::nullopt) noexcept
Definition: util.h:57
COutPoint MineBlock(const NodeContext &node, const node::BlockAssembler::Options &assembler_options)
Returns the generated coin.
Definition: mining.cpp:70
void SeedRandomStateForTest(SeedRand seedtype)
Seed the global RNG state for testing and log the seed value.
Definition: random.cpp:19
@ ZEROS
Seed with a compile time constant of zeros.
static int count
void SetMockTime(int64_t nMockTimeIn)
DEPRECATED Use SetMockTime with chrono type.
Definition: time.cpp:40