5 #include <chainparams.h>
25 void initialize_p2p_transport_serialization()
29 std::sort(g_all_messages.begin(), g_all_messages.end());
34 FUZZ_TARGET(p2p_transport_serialization, .
init = initialize_p2p_transport_serialization)
42 auto checksum_assist = fuzzed_data_provider.
ConsumeBool();
43 auto magic_bytes_assist = fuzzed_data_provider.ConsumeBool();
44 std::vector<uint8_t> mutable_msg_bytes;
47 if (magic_bytes_assist) {
50 mutable_msg_bytes.push_back(msg_start[i]);
55 if (checksum_assist) {
59 auto header_random_bytes = fuzzed_data_provider.ConsumeBytes<uint8_t>(header_bytes_remaining);
60 mutable_msg_bytes.insert(mutable_msg_bytes.end(), header_random_bytes.begin(), header_random_bytes.end());
61 auto payload_bytes = fuzzed_data_provider.ConsumeRemainingBytes<uint8_t>();
65 unsigned char hsh[32];
66 hasher.
Write(payload_bytes);
69 mutable_msg_bytes.push_back(hsh[i]);
73 mutable_msg_bytes.insert(mutable_msg_bytes.end(), payload_bytes.begin(), payload_bytes.end());
75 while (msg_bytes.size() > 0) {
76 if (!recv_transport.ReceivedBytes(msg_bytes)) {
79 if (recv_transport.ReceivedMessageComplete()) {
80 const std::chrono::microseconds m_time{std::numeric_limits<int64_t>::max()};
81 bool reject_message{
false};
82 CNetMessage msg = recv_transport.GetReceivedMessage(m_time, reject_message);
84 assert(
msg.m_raw_message_size <= mutable_msg_bytes.size());
88 std::vector<unsigned char> header;
90 bool queued = send_transport.SetMessageToSend(msg2);
92 std::optional<bool> known_more;
94 const auto& [to_send, more, _msg_type] = send_transport.GetBytesToSend(
false);
95 if (known_more)
assert(!to_send.empty() == *known_more);
96 if (to_send.empty())
break;
97 send_transport.MarkBytesSent(to_send.size());
106 template<RandomNumberGenerator R>
115 const std::array<Transport*, 2> transports = {&initiator, &responder};
118 std::array<std::vector<uint8_t>, 2> in_flight;
121 std::array<std::deque<CSerializedNetMsg>, 2> expected;
124 std::array<std::vector<uint8_t>, 2> to_send;
128 std::array<std::optional<bool>, 2> last_more, last_more_next;
132 std::array<std::optional<bool>, 2> expect_more, expect_more_next;
135 auto msg_type_fn = [&]() {
145 if (c < ' ' || c > 0x7E)
break;
151 return g_all_messages[v % g_all_messages.size()];
156 auto make_msg_fn = [&](
bool first) {
160 msg.m_type =
"version";
162 msg.m_type = msg_type_fn();
167 msg.data = rng.randbytes(size);
173 std::array<CSerializedNetMsg, 2> next_msg = {
183 const auto& [bytes, more_nonext, msg_type] = transports[side]->GetBytesToSend(
false);
184 const auto& [bytes_next, more_next, msg_type_next] = transports[side]->GetBytesToSend(
true);
186 if (expect_more[side].has_value())
assert(!bytes.empty() == *expect_more[side]);
188 assert(bytes == bytes_next);
189 assert(msg_type == msg_type_next);
190 if (more_nonext)
assert(more_next);
192 assert(to_send[side].size() <= bytes.size());
194 to_send[side].resize(bytes.size());
195 std::copy(bytes.begin(), bytes.end(), to_send[side].begin());
197 last_more[side] = {more_nonext};
198 last_more_next[side] = {more_next};
200 return {bytes, more_nonext, msg_type};
204 auto new_msg_fn = [&](
int side) {
206 if (expected[side].size() >= 16)
return;
209 bool queued = transports[side]->SetMessageToSend(
msg);
211 expect_more[side] = expect_more_next[side];
212 expect_more_next[side] = std::nullopt;
214 bytes_to_send_fn(side);
217 expected[side].emplace_back(std::move(next_msg[side]));
219 next_msg[side] = make_msg_fn(
false);
224 auto send_fn = [&](
int side,
bool everything =
false) {
225 const auto& [bytes, more, msg_type] = bytes_to_send_fn(side);
227 if (bytes.empty())
return false;
229 if (send_now == 0)
return false;
231 in_flight[side].insert(in_flight[side].end(), bytes.begin(), bytes.begin() + send_now);
232 transports[side]->MarkBytesSent(send_now);
234 if (send_now == bytes.size()) {
235 expect_more[side] = last_more[side];
236 expect_more_next[side] = last_more_next[side];
239 assert(to_send[side].size() >= send_now);
240 to_send[side].erase(to_send[side].begin(), to_send[side].begin() + send_now);
242 bytes_to_send_fn(side);
248 auto recv_fn = [&](
int side,
bool everything =
false) {
250 if (in_flight[side].empty())
return false;
252 size_t to_recv_len = in_flight[side].size();
256 while (!to_recv.empty()) {
257 size_t old_len = to_recv.size();
258 bool ret = transports[!side]->ReceivedBytes(to_recv);
264 if (expect_more[!side] ==
false) expect_more[!side] = std::nullopt;
265 if (expect_more_next[!side] ==
false) expect_more_next[!side] = std::nullopt;
267 bytes_to_send_fn(!side);
268 bool progress = to_recv.size() < old_len;
269 if (transports[!side]->ReceivedMessageComplete()) {
271 auto received = transports[!side]->GetReceivedMessage({}, reject);
275 assert(!expected[side].empty());
277 assert(received.m_message_size == received.m_recv.size());
279 assert(received.m_type == expected[side].front().m_type);
282 expected[side].pop_front();
290 in_flight[side].erase(in_flight[side].begin(), in_flight[side].begin() + to_recv_len);
292 return to_recv_len > 0;
299 [&] { new_msg_fn(0); },
300 [&] { new_msg_fn(1); },
314 if (send_fn(0,
true)) any =
true;
315 if (send_fn(1,
true)) any =
true;
316 if (recv_fn(0,
true)) any =
true;
317 if (recv_fn(1,
true)) any =
true;
322 assert(in_flight[0].empty());
323 assert(in_flight[1].empty());
326 assert(expected[0].empty());
327 assert(expected[1].empty());
333 std::unique_ptr<Transport> MakeV1Transport(
NodeId nodeid) noexcept
335 return std::make_unique<V1Transport>(nodeid);
338 template<RandomNumberGenerator RNG>
343 if (!key.IsValid())
return {};
346 std::vector<uint8_t> garb;
347 if (garb_len <= 64) {
350 garb.resize(garb_len);
354 garb = rng.randbytes(garb_len);
366 .
Write(garb.data(), garb.size())
369 return std::make_unique<V2Transport>(nodeid, initiator, key, ent, std::move(garb));
374 FUZZ_TARGET(p2p_transport_bidirectional, .
init = initialize_p2p_transport_serialization)
379 auto t1 = MakeV1Transport(
NodeId{0});
380 auto t2 = MakeV1Transport(
NodeId{1});
381 if (!t1 || !t2)
return;
385 FUZZ_TARGET(p2p_transport_bidirectional_v2, .
init = initialize_p2p_transport_serialization)
390 auto t1 = MakeV2Transport(
NodeId{0},
true, rng, provider);
391 auto t2 = MakeV2Transport(
NodeId{1},
false, rng, provider);
392 if (!t1 || !t2)
return;
396 FUZZ_TARGET(p2p_transport_bidirectional_v1v2, .
init = initialize_p2p_transport_serialization)
401 auto t1 = MakeV1Transport(
NodeId{0});
402 auto t2 = MakeV2Transport(
NodeId{1},
false, rng, provider);
403 if (!t1 || !t2)
return;
const CChainParams & Params()
Return the currently selected parameters.
void SelectParams(const ChainType chain)
Sets the params returned by Params() to those for the given chain type.
const MessageStartChars & MessageStart() const
A hasher class for Bitcoin's 256-bit hash (double SHA-256).
CHash256 & Write(Span< const unsigned char > input)
void Finalize(Span< unsigned char > output)
Transport protocol agnostic message container.
A hasher class for SHA-256.
void Finalize(unsigned char hash[OUTPUT_SIZE])
CSHA256 & Write(const unsigned char *data, size_t len)
RAII class initializing and deinitializing global state for elliptic curve support.
std::vector< T > ConsumeBytes(size_t num_bytes)
T ConsumeIntegralInRange(T min, T max)
A Span is an object that can refer to a contiguous sequence of objects.
CONSTEXPR_IF_NOT_DEBUG Span< C > first(std::size_t count) const noexcept
The Transport converts one connection's sent messages to wire bytes, and received bytes back.
std::tuple< Span< const uint8_t >, bool, const std::string & > BytesToSend
Return type for GetBytesToSend, consisting of:
static constexpr uint32_t MAX_GARBAGE_LEN
void SimulationTest(CCoinsView *base, bool fake_best_block)
#define LIMITED_WHILE(condition, limit)
Can be used to limit a theoretically unbounded loop.
CSerializedNetMsg Make(std::string msg_type, Args &&... args)
FUZZ_TARGET(p2p_transport_serialization,.init=initialize_p2p_transport_serialization)
const std::array ALL_NET_MESSAGE_TYPES
All known message types (see above).
unsigned char * UCharCast(char *c)
Span< const std::byte > MakeByteSpan(V &&v) noexcept
CKey ConsumePrivateKey(FuzzedDataProvider &fuzzed_data_provider, std::optional< bool > compressed) noexcept
size_t CallOneOf(FuzzedDataProvider &fuzzed_data_provider, Callables... callables)
static TxMempoolInfo GetInfo(CTxMemPool::indexed_transaction_set::const_iterator it)