5 #include <chainparams.h>
24 std::vector<std::string> g_all_messages;
26 void initialize_p2p_transport_serialization()
31 std::sort(g_all_messages.begin(), g_all_messages.end());
36 FUZZ_TARGET(p2p_transport_serialization, .
init = initialize_p2p_transport_serialization)
44 auto checksum_assist = fuzzed_data_provider.
ConsumeBool();
45 auto magic_bytes_assist = fuzzed_data_provider.ConsumeBool();
46 std::vector<uint8_t> mutable_msg_bytes;
49 if (magic_bytes_assist) {
52 mutable_msg_bytes.push_back(msg_start[i]);
57 if (checksum_assist) {
61 auto header_random_bytes = fuzzed_data_provider.ConsumeBytes<uint8_t>(header_bytes_remaining);
62 mutable_msg_bytes.insert(mutable_msg_bytes.end(), header_random_bytes.begin(), header_random_bytes.end());
63 auto payload_bytes = fuzzed_data_provider.ConsumeRemainingBytes<uint8_t>();
67 unsigned char hsh[32];
68 hasher.
Write(payload_bytes);
71 mutable_msg_bytes.push_back(hsh[i]);
75 mutable_msg_bytes.insert(mutable_msg_bytes.end(), payload_bytes.begin(), payload_bytes.end());
77 while (msg_bytes.size() > 0) {
78 if (!recv_transport.ReceivedBytes(msg_bytes)) {
81 if (recv_transport.ReceivedMessageComplete()) {
82 const std::chrono::microseconds m_time{std::numeric_limits<int64_t>::max()};
83 bool reject_message{
false};
84 CNetMessage msg = recv_transport.GetReceivedMessage(m_time, reject_message);
86 assert(
msg.m_raw_message_size <= mutable_msg_bytes.size());
90 std::vector<unsigned char> header;
92 bool queued = send_transport.SetMessageToSend(msg2);
94 std::optional<bool> known_more;
96 const auto& [to_send, more, _msg_type] = send_transport.GetBytesToSend(
false);
97 if (known_more)
assert(!to_send.empty() == *known_more);
98 if (to_send.empty())
break;
99 send_transport.MarkBytesSent(to_send.size());
117 const std::array<Transport*, 2> transports = {&initiator, &responder};
120 std::array<std::vector<uint8_t>, 2> in_flight;
123 std::array<std::deque<CSerializedNetMsg>, 2> expected;
126 std::array<std::vector<uint8_t>, 2> to_send;
130 std::array<std::optional<bool>, 2> last_more, last_more_next;
134 std::array<std::optional<bool>, 2> expect_more, expect_more_next;
137 auto msg_type_fn = [&]() {
147 if (c < ' ' || c > 0x7E)
break;
153 return g_all_messages[v % g_all_messages.size()];
158 auto make_msg_fn = [&](
bool first) {
162 msg.m_type =
"version";
164 msg.m_type = msg_type_fn();
169 msg.data.resize(size);
170 for (
auto& v :
msg.data) v = uint8_t(rng());
176 std::array<CSerializedNetMsg, 2> next_msg = {
186 const auto& [bytes, more_nonext, msg_type] = transports[side]->GetBytesToSend(
false);
187 const auto& [bytes_next, more_next, msg_type_next] = transports[side]->GetBytesToSend(
true);
189 if (expect_more[side].has_value())
assert(!bytes.empty() == *expect_more[side]);
191 assert(bytes == bytes_next);
192 assert(msg_type == msg_type_next);
193 if (more_nonext)
assert(more_next);
195 assert(to_send[side].size() <= bytes.size());
197 to_send[side].resize(bytes.size());
198 std::copy(bytes.begin(), bytes.end(), to_send[side].begin());
200 last_more[side] = {more_nonext};
201 last_more_next[side] = {more_next};
203 return {bytes, more_nonext, msg_type};
207 auto new_msg_fn = [&](
int side) {
209 if (expected[side].size() >= 16)
return;
212 bool queued = transports[side]->SetMessageToSend(
msg);
214 expect_more[side] = expect_more_next[side];
215 expect_more_next[side] = std::nullopt;
217 bytes_to_send_fn(side);
220 expected[side].emplace_back(std::move(next_msg[side]));
222 next_msg[side] = make_msg_fn(
false);
227 auto send_fn = [&](
int side,
bool everything =
false) {
228 const auto& [bytes, more, msg_type] = bytes_to_send_fn(side);
230 if (bytes.empty())
return false;
232 if (send_now == 0)
return false;
234 in_flight[side].insert(in_flight[side].end(), bytes.begin(), bytes.begin() + send_now);
235 transports[side]->MarkBytesSent(send_now);
237 if (send_now == bytes.size()) {
238 expect_more[side] = last_more[side];
239 expect_more_next[side] = last_more_next[side];
242 assert(to_send[side].size() >= send_now);
243 to_send[side].erase(to_send[side].begin(), to_send[side].begin() + send_now);
245 bytes_to_send_fn(side);
251 auto recv_fn = [&](
int side,
bool everything =
false) {
253 if (in_flight[side].empty())
return false;
255 size_t to_recv_len = in_flight[side].size();
259 while (!to_recv.empty()) {
260 size_t old_len = to_recv.size();
261 bool ret = transports[!side]->ReceivedBytes(to_recv);
267 if (expect_more[!side] ==
false) expect_more[!side] = std::nullopt;
268 if (expect_more_next[!side] ==
false) expect_more_next[!side] = std::nullopt;
270 bytes_to_send_fn(!side);
271 bool progress = to_recv.size() < old_len;
272 if (transports[!side]->ReceivedMessageComplete()) {
274 auto received = transports[!side]->GetReceivedMessage({}, reject);
278 assert(!expected[side].empty());
280 assert(received.m_message_size == received.m_recv.size());
282 assert(received.m_type == expected[side].front().m_type);
285 expected[side].pop_front();
293 in_flight[side].erase(in_flight[side].begin(), in_flight[side].begin() + to_recv_len);
295 return to_recv_len > 0;
302 [&] { new_msg_fn(0); },
303 [&] { new_msg_fn(1); },
317 if (send_fn(0,
true)) any =
true;
318 if (send_fn(1,
true)) any =
true;
319 if (recv_fn(0,
true)) any =
true;
320 if (recv_fn(1,
true)) any =
true;
325 assert(in_flight[0].empty());
326 assert(in_flight[1].empty());
329 assert(expected[0].empty());
330 assert(expected[1].empty());
336 std::unique_ptr<Transport> MakeV1Transport(
NodeId nodeid) noexcept
338 return std::make_unique<V1Transport>(nodeid);
341 template<
typename RNG>
346 if (!key.IsValid())
return {};
349 std::vector<uint8_t> garb;
350 if (garb_len <= 64) {
353 garb.resize(garb_len);
357 garb.resize(garb_len);
358 for (
auto& v : garb) v = uint8_t(rng());
370 .
Write(garb.data(), garb.size())
373 return std::make_unique<V2Transport>(nodeid, initiator, key, ent, std::move(garb));
378 FUZZ_TARGET(p2p_transport_bidirectional, .
init = initialize_p2p_transport_serialization)
383 auto t1 = MakeV1Transport(
NodeId{0});
384 auto t2 = MakeV1Transport(
NodeId{1});
385 if (!t1 || !t2)
return;
389 FUZZ_TARGET(p2p_transport_bidirectional_v2, .
init = initialize_p2p_transport_serialization)
394 auto t1 = MakeV2Transport(
NodeId{0},
true, rng, provider);
395 auto t2 = MakeV2Transport(
NodeId{1},
false, rng, provider);
396 if (!t1 || !t2)
return;
400 FUZZ_TARGET(p2p_transport_bidirectional_v1v2, .
init = initialize_p2p_transport_serialization)
405 auto t1 = MakeV1Transport(
NodeId{0});
406 auto t2 = MakeV2Transport(
NodeId{1},
false, rng, provider);
407 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)
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::vector< std::string > & getAllNetMessageTypes()
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)