5#include <chainparams.h>
26#include <boost/test/unit_test.hpp>
34using namespace std::literals;
46 uint16_t altPort = 12345;
57 ipv4Addr.s_addr = 0xa0b0c001;
62 std::unique_ptr<CNode> pnode1 = std::make_unique<CNode>(
id++,
81 std::unique_ptr<CNode> pnode2 = std::make_unique<CNode>(
id++,
100 std::unique_ptr<CNode> pnode3 = std::make_unique<CNode>(
id++,
119 std::unique_ptr<CNode> pnode4 = std::make_unique<CNode>(
id++,
129 BOOST_CHECK(pnode4->IsFullOutboundConn() ==
false);
145 BOOST_REQUIRE(!addr.
IsValid());
146 BOOST_REQUIRE(addr.
IsIPv4());
153 addr =
LookupHost(
"255.255.255.255",
false).value();
154 BOOST_REQUIRE(!addr.
IsValid());
155 BOOST_REQUIRE(addr.
IsIPv4());
162 addr =
LookupHost(
"12.34.56.78",
false).value();
164 BOOST_REQUIRE(addr.
IsIPv4());
172 BOOST_REQUIRE(!addr.
IsValid());
173 BOOST_REQUIRE(addr.
IsIPv6());
180 addr =
LookupHost(
"1122:3344:5566:7788:9900:aabb:ccdd:eeff",
false).value();
182 BOOST_REQUIRE(addr.
IsIPv6());
193 const std::string link_local{
"fe80::1"};
194 const std::string scoped_addr{link_local +
"%32"};
195 addr =
LookupHost(scoped_addr,
false).value();
197 BOOST_REQUIRE(addr.
IsIPv6());
205 const char* torv3_addr =
"pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion";
208 BOOST_REQUIRE(addr.
IsTor());
223 "pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd\0wtf.onion", 66}));
232 const char* i2p_addr =
"UDHDrtrcetjm5sxzskjyr5ztpeszydbh4dpl3pl4utgqqw2v4jna.b32.I2P";
235 BOOST_REQUIRE(addr.
IsI2P());
255 !addr.
SetSpecial(
"pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscsad.b32.i2p"));
262 BOOST_REQUIRE(!addr.
IsValid());
277 const std::map<std::string, std::string> canonical_representations_ipv6{
278 {
"0000:0000:0000:0000:0000:0000:0000:0000",
"::"},
279 {
"000:0000:000:00:0:00:000:0000",
"::"},
280 {
"000:000:000:000:000:000:000:000",
"::"},
281 {
"00:00:00:00:00:00:00:00",
"::"},
282 {
"0:0:0:0:0:0:0:0",
"::"},
283 {
"0:0:0:0:0:0:0:1",
"::1"},
284 {
"2001:0:0:1:0:0:0:1",
"2001:0:0:1::1"},
285 {
"2001:0db8:0:0:1:0:0:1",
"2001:db8::1:0:0:1"},
286 {
"2001:0db8:85a3:0000:0000:8a2e:0370:7334",
"2001:db8:85a3::8a2e:370:7334"},
287 {
"2001:0db8::0001",
"2001:db8::1"},
288 {
"2001:0db8::0001:0000",
"2001:db8::1:0"},
289 {
"2001:0db8::1:0:0:1",
"2001:db8::1:0:0:1"},
290 {
"2001:db8:0000:0:1::1",
"2001:db8::1:0:0:1"},
291 {
"2001:db8:0000:1:1:1:1:1",
"2001:db8:0:1:1:1:1:1"},
292 {
"2001:db8:0:0:0:0:2:1",
"2001:db8::2:1"},
293 {
"2001:db8:0:0:0::1",
"2001:db8::1"},
294 {
"2001:db8:0:0:1:0:0:1",
"2001:db8::1:0:0:1"},
295 {
"2001:db8:0:0:1::1",
"2001:db8::1:0:0:1"},
296 {
"2001:DB8:0:0:1::1",
"2001:db8::1:0:0:1"},
297 {
"2001:db8:0:0::1",
"2001:db8::1"},
298 {
"2001:db8:0:0:aaaa::1",
"2001:db8::aaaa:0:0:1"},
299 {
"2001:db8:0:1:1:1:1:1",
"2001:db8:0:1:1:1:1:1"},
300 {
"2001:db8:0::1",
"2001:db8::1"},
301 {
"2001:db8:85a3:0:0:8a2e:370:7334",
"2001:db8:85a3::8a2e:370:7334"},
302 {
"2001:db8::0:1",
"2001:db8::1"},
303 {
"2001:db8::0:1:0:0:1",
"2001:db8::1:0:0:1"},
304 {
"2001:DB8::1",
"2001:db8::1"},
305 {
"2001:db8::1",
"2001:db8::1"},
306 {
"2001:db8::1:0:0:1",
"2001:db8::1:0:0:1"},
307 {
"2001:db8::1:1:1:1:1",
"2001:db8:0:1:1:1:1:1"},
308 {
"2001:db8::aaaa:0:0:1",
"2001:db8::aaaa:0:0:1"},
309 {
"2001:db8:aaaa:bbbb:cccc:dddd:0:1",
"2001:db8:aaaa:bbbb:cccc:dddd:0:1"},
310 {
"2001:db8:aaaa:bbbb:cccc:dddd::1",
"2001:db8:aaaa:bbbb:cccc:dddd:0:1"},
311 {
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:0001",
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:1"},
312 {
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:001",
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:1"},
313 {
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:01",
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:1"},
314 {
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:1",
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:1"},
315 {
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:aaaa",
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:aaaa"},
316 {
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:AAAA",
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:aaaa"},
317 {
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:AaAa",
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:aaaa"},
319 for (
const auto& [input_address, expected_canonical_representation_output] : canonical_representations_ipv6) {
320 const std::optional<CNetAddr> net_addr{
LookupHost(input_address,
false)};
321 BOOST_REQUIRE(net_addr.value().IsIPv6());
322 BOOST_CHECK_EQUAL(net_addr.value().ToStringAddr(), expected_canonical_representation_output);
332 s << ser_params(addr);
337 s << ser_params(addr);
341 addr =
LookupHost(
"1a1b:2a2b:3a3b:4a4b:5a5b:6a6b:7a7b:8a8b",
false).value();
342 s << ser_params(addr);
349 BOOST_REQUIRE(addr.
SetSpecial(
"pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion"));
350 s << ser_params(addr);
355 s << ser_params(addr);
366 s << ser_params(addr);
371 s << ser_params(addr);
375 addr =
LookupHost(
"1a1b:2a2b:3a3b:4a4b:5a5b:6a6b:7a7b:8a8b",
false).value();
376 s << ser_params(addr);
383 BOOST_REQUIRE(addr.
SetSpecial(
"kpgvmscirrdqpekbqjsvw5teanhatztpp2gl6eee4zkowvwfxwenqaid.onion"));
384 s << ser_params(addr);
389 s << ser_params(addr);
404 s >> ser_params(addr);
409 BOOST_REQUIRE(
s.empty());
415 BOOST_CHECK_EXCEPTION(
s >> ser_params(addr), std::ios_base::failure,
HasReason(
"end of data"));
416 BOOST_REQUIRE(!
s.empty());
423 BOOST_CHECK_EXCEPTION(
s >> ser_params(addr), std::ios_base::failure,
424 HasReason(
"BIP155 IPv4 address with length 5 (should be 4)"));
425 BOOST_REQUIRE(!
s.empty());
432 BOOST_CHECK_EXCEPTION(
s >> ser_params(addr), std::ios_base::failure,
433 HasReason(
"Address too long: 513 > 512"));
434 BOOST_REQUIRE(!
s.empty());
440 "0102030405060708090a0b0c0d0e0f10"_hex;
441 s >> ser_params(addr);
446 BOOST_REQUIRE(
s.empty());
451 "fd6b88c08724ca978112ca1bbdcafac2"_hex;
453 s >> ser_params(addr);
457 BOOST_REQUIRE(
s.empty());
463 BOOST_CHECK_EXCEPTION(
s >> ser_params(addr), std::ios_base::failure,
464 HasReason(
"BIP155 IPv6 address with length 4 (should be 16)"));
465 BOOST_REQUIRE(!
s.empty());
471 "00000000000000000000ffff01020304"_hex;
472 s >> ser_params(addr);
474 BOOST_REQUIRE(
s.empty());
479 "fd87d87eeb430102030405060708090a"_hex;
480 s >> ser_params(addr);
482 BOOST_REQUIRE(
s.empty());
487 "f1f2f3f4f5f6f7f8f9fa"_hex;
488 s >> ser_params(addr);
490 BOOST_REQUIRE(
s.empty());
495 "79bcc625184b05194975c28b66b66b04"
496 "69f7f6556fb1ac3189a79b40dda32f1f"_hex;
497 s >> ser_params(addr);
502 "pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion");
503 BOOST_REQUIRE(
s.empty());
509 BOOST_CHECK_EXCEPTION(
s >> ser_params(addr), std::ios_base::failure,
510 HasReason(
"BIP155 TORv3 address with length 0 (should be 32)"));
511 BOOST_REQUIRE(!
s.empty());
517 "a2894dabaec08c0051a481a6dac88b64"
518 "f98232ae42d4b6fd2fa81952dfe36a87"_hex;
519 s >> ser_params(addr);
524 "ukeu3k5oycgaauneqgtnvselmt4yemvoilkln7jpvamvfx7dnkdq.b32.i2p");
525 BOOST_REQUIRE(
s.empty());
531 BOOST_CHECK_EXCEPTION(
s >> ser_params(addr), std::ios_base::failure,
532 HasReason(
"BIP155 I2P address with length 3 (should be 32)"));
533 BOOST_REQUIRE(!
s.empty());
539 "fc000001000200030004000500060007"_hex;
540 s >> ser_params(addr);
545 BOOST_REQUIRE(
s.empty());
550 "aa000001000200030004000500060007"_hex;
551 s >> ser_params(addr);
554 BOOST_REQUIRE(
s.empty());
560 BOOST_CHECK_EXCEPTION(
s >> ser_params(addr), std::ios_base::failure,
561 HasReason(
"BIP155 CJDNS address with length 1 (should be 16)"));
562 BOOST_REQUIRE(!
s.empty());
568 "01020304050607"_hex;
569 BOOST_CHECK_EXCEPTION(
s >> ser_params(addr), std::ios_base::failure,
570 HasReason(
"Address too long: 33554432 > 512"));
571 BOOST_REQUIRE(!
s.empty());
578 s >> ser_params(addr);
580 BOOST_REQUIRE(
s.empty());
586 s >> ser_params(addr);
588 BOOST_REQUIRE(
s.empty());
598 raw_addr.s_addr = htonl(0x7f000001);
605 mapLocalHost[mapLocalHost_entry] = lsi;
609 in_addr ipv4AddrPeer;
610 ipv4AddrPeer.s_addr = 0xa0b0c001;
612 std::unique_ptr<CNode> pnode = std::make_unique<CNode>(0,
622 pnode->fSuccessfullyConnected.store(
true);
625 in6_addr ipv6AddrLocal;
626 memset(ipv6AddrLocal.s6_addr, 0, 16);
627 ipv6AddrLocal.s6_addr[0] = 0xcc;
629 pnode->SetAddrLocal(addrLocal);
640 mapLocalHost.erase(mapLocalHost_entry);
656 const uint16_t bind_port = 20001;
660 in_addr peer_us_addr;
661 peer_us_addr.s_addr = htonl(0x02030405);
662 const CService peer_us{peer_us_addr, 20002};
665 in_addr peer_out_in_addr;
666 peer_out_in_addr.s_addr = htonl(0x01020304);
677 peer_out.fSuccessfullyConnected =
true;
678 peer_out.SetAddrLocal(peer_us);
682 BOOST_REQUIRE(chosen_local_addr);
683 const CService expected{peer_us_addr, bind_port};
687 in_addr peer_in_in_addr;
688 peer_in_in_addr.s_addr = htonl(0x05060708);
699 peer_in.fSuccessfullyConnected =
true;
700 peer_in.SetAddrLocal(peer_us);
704 BOOST_REQUIRE(chosen_local_addr);
765 unsigned char ip[] = {p1, p2, p3, p4};
767 struct sockaddr_in sa;
768 memset(&sa, 0,
sizeof(sockaddr_in));
769 memcpy(&(sa.sin_addr), &
ip,
sizeof(
ip));
815 const uint16_t bind_port = 20001;
820 in_addr peer_us_addr;
821 peer_us_addr.s_addr = htonl(0x02030405);
822 const CService peer_us{peer_us_addr, 20002};
825 in_addr peer_in_addr;
826 peer_in_addr.s_addr = htonl(0x01020304);
839 const int64_t time{0};
848 std::atomic<bool> interrupt_dummy{
false};
849 std::chrono::microseconds time_received_dummy{0};
851 const auto msg_version =
866 const CService expected{peer_us_addr, bind_port};
871 const std::string& msg_type,
872 std::span<const unsigned char>
data,
873 bool is_incoming) ->
void {
874 if (!is_incoming && msg_type ==
"addr") {
876 std::vector<CAddress> addresses;
880 for (
const auto& addr : addresses) {
881 if (addr == expected) {
902 auto CreatePeer = [](
const CAddress& addr) {
903 return std::make_unique<CNode>(0,
917 BOOST_REQUIRE(addr_ipv4.IsValid());
918 BOOST_REQUIRE(addr_ipv4.IsIPv4());
921 BOOST_REQUIRE(addr_ipv6.IsValid());
922 BOOST_REQUIRE(addr_ipv6.IsIPv6());
925 BOOST_REQUIRE(addr_ipv6_tunnel.IsValid());
926 BOOST_REQUIRE(addr_ipv6_tunnel.IsIPv6());
927 BOOST_REQUIRE(addr_ipv6_tunnel.IsRFC3964());
930 BOOST_REQUIRE(addr_teredo.IsValid());
931 BOOST_REQUIRE(addr_teredo.IsIPv6());
932 BOOST_REQUIRE(addr_teredo.IsRFC4380());
935 BOOST_REQUIRE(addr_onion.
SetSpecial(
"pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion"));
936 BOOST_REQUIRE(addr_onion.
IsValid());
937 BOOST_REQUIRE(addr_onion.
IsTor());
940 BOOST_REQUIRE(addr_i2p.
SetSpecial(
"udhdrtrcetjm5sxzskjyr5ztpeszydbh4dpl3pl4utgqqw2v4jna.b32.i2p"));
941 BOOST_REQUIRE(addr_i2p.
IsValid());
942 BOOST_REQUIRE(addr_i2p.
IsI2P());
946 BOOST_REQUIRE(addr_cjdns.IsValid());
947 BOOST_REQUIRE(addr_cjdns.IsCJDNS());
949 const auto peer_ipv4{CreatePeer(addr_ipv4)};
950 const auto peer_ipv6{CreatePeer(addr_ipv6)};
951 const auto peer_ipv6_tunnel{CreatePeer(addr_ipv6_tunnel)};
952 const auto peer_teredo{CreatePeer(addr_teredo)};
953 const auto peer_onion{CreatePeer(addr_onion)};
954 const auto peer_i2p{CreatePeer(addr_i2p)};
955 const auto peer_cjdns{CreatePeer(addr_cjdns)};
1010 uint256 key_data = rng.rand256();
1023class V2TransportTester
1028 bool m_test_initiator;
1030 std::vector<uint8_t> m_sent_garbage;
1031 std::vector<uint8_t> m_recv_garbage;
1032 std::vector<uint8_t> m_to_send;
1033 std::vector<uint8_t> m_received;
1034 std::deque<CSerializedNetMsg> m_msg_to_send;
1035 bool m_sent_aad{
false};
1041 m_transport{0, test_initiator},
1042 m_cipher{GenerateRandomTestKey(m_rng),
MakeByteSpan(m_rng.rand256())},
1043 m_test_initiator(test_initiator) {}
1052 using InteractResult = std::optional<std::vector<std::optional<CNetMessage>>>;
1059 InteractResult Interact()
1061 std::vector<std::optional<CNetMessage>>
ret;
1063 bool progress{
false};
1065 if (!m_to_send.empty()) {
1066 std::span<const uint8_t> to_send = std::span{m_to_send}.first(1 + m_rng.
randrange(m_to_send.size()));
1067 size_t old_len = to_send.size();
1069 return std::nullopt;
1071 if (old_len != to_send.size()) {
1073 m_to_send.erase(m_to_send.begin(), m_to_send.begin() + (old_len - to_send.size()));
1081 ret.emplace_back(std::nullopt);
1083 ret.emplace_back(std::move(
msg));
1088 if (!m_msg_to_send.empty() && (!progress || m_rng.
randbool())) {
1090 m_msg_to_send.pop_front();
1095 const auto& [recv_bytes, _more, _msg_type] = m_transport.
GetBytesToSend(!m_msg_to_send.empty());
1096 if (!recv_bytes.empty() && (!progress || m_rng.
randbool())) {
1097 size_t to_receive = 1 + m_rng.
randrange(recv_bytes.size());
1098 m_received.insert(m_received.end(), recv_bytes.begin(), recv_bytes.begin() + to_receive);
1102 if (!progress)
break;
1111 void Send(std::span<const uint8_t>
data)
1113 m_to_send.insert(m_to_send.end(),
data.begin(),
data.end());
1122 m_to_send.insert(m_to_send.end(),
UCharCast(ser.data()),
UCharCast(ser.data() + ser.size()));
1132 void SendGarbage(std::span<const uint8_t> garbage)
1135 m_sent_garbage.assign(garbage.begin(), garbage.end());
1137 Send(m_sent_garbage);
1141 void SendGarbage(
size_t garbage_len)
1144 SendGarbage(m_rng.
randbytes<uint8_t>(garbage_len));
1154 void AddMessage(std::string m_type, std::vector<uint8_t> payload)
1157 msg.m_type = std::move(m_type);
1158 msg.data = std::move(payload);
1159 m_msg_to_send.push_back(std::move(
msg));
1179 void SendPacket(std::span<const uint8_t> content, std::span<const uint8_t> aad = {},
bool ignore =
false)
1182 std::vector<std::byte> ciphertext;
1194 void SendGarbageTerm()
1201 void SendVersion(std::span<const uint8_t> version_data = {},
bool vers_ignore =
false)
1203 std::span<const std::uint8_t> aad;
1205 if (!m_sent_aad) aad = m_sent_garbage;
1206 SendPacket(version_data, aad, vers_ignore);
1213 std::vector<uint8_t> ReceivePacket(std::span<const std::byte> aad = {})
1215 std::vector<uint8_t> contents;
1225 contents.resize(size);
1246 void ReceiveGarbage()
1256 m_recv_garbage.assign(m_received.begin(), m_received.begin() + garblen);
1262 void ReceiveVersion()
1264 auto contents = ReceivePacket(
MakeByteSpan(m_recv_garbage));
1273 void ReceiveMessage(uint8_t short_id, std::span<const uint8_t> payload)
1275 auto ret = ReceivePacket();
1278 BOOST_CHECK(std::ranges::equal(std::span{
ret}.subspan(1), payload));
1283 void ReceiveMessage(
const std::string& m_type, std::span<const uint8_t> payload)
1285 auto ret = ReceivePacket();
1288 for (
unsigned i = 0; i < 12; ++i) {
1289 if (i < m_type.size()) {
1300 void SendMessage(std::string mtype, std::span<const uint8_t> payload)
1304 std::copy(mtype.begin(), mtype.end(),
reinterpret_cast<char*
>(contents.data() + 1));
1307 SendPacket(contents);
1312 void SendMessage(uint8_t short_id, std::span<const uint8_t> payload)
1315 std::vector<uint8_t> contents(1 + payload.size());
1316 contents[0] = short_id;
1317 std::copy(payload.begin(), payload.end(), contents.begin() + 1);
1319 SendPacket(contents);
1323 void CompareSessionIDs()
const
1325 auto info = m_transport.
GetInfo();
1342 for (
int i = 0; i < 10; ++i) {
1343 V2TransportTester tester(m_rng,
true);
1344 auto ret = tester.Interact();
1345 BOOST_REQUIRE(
ret &&
ret->empty());
1347 tester.SendGarbage();
1348 tester.ReceiveKey();
1349 tester.SendGarbageTerm();
1350 tester.SendVersion();
1351 ret = tester.Interact();
1352 BOOST_REQUIRE(
ret &&
ret->empty());
1353 tester.ReceiveGarbage();
1354 tester.ReceiveVersion();
1355 tester.CompareSessionIDs();
1358 tester.SendMessage(uint8_t(4), msg_data_1);
1359 tester.SendMessage(0, {});
1360 tester.SendMessage(
"tx", msg_data_2);
1361 ret = tester.Interact();
1362 BOOST_REQUIRE(
ret &&
ret->size() == 3);
1370 tester.SendMessage(
"bad", msg_data_1);
1373 ret = tester.Interact();
1378 tester.SendMessage(uint8_t(12), msg_data_3);
1383 for (
int i = 0; i < 10; ++i) {
1384 V2TransportTester tester(m_rng,
false);
1386 tester.SendGarbage();
1387 auto ret = tester.Interact();
1388 BOOST_REQUIRE(
ret &&
ret->empty());
1389 tester.ReceiveKey();
1390 tester.SendGarbageTerm();
1391 tester.SendVersion();
1392 ret = tester.Interact();
1393 BOOST_REQUIRE(
ret &&
ret->empty());
1394 tester.ReceiveGarbage();
1395 tester.ReceiveVersion();
1396 tester.CompareSessionIDs();
1399 tester.SendMessage(uint8_t(14), msg_data_1);
1400 tester.SendMessage(uint8_t(19), msg_data_2);
1401 ret = tester.Interact();
1402 BOOST_REQUIRE(
ret &&
ret->size() == 2);
1407 auto msg_data_3 = m_rng.
randbytes<uint8_t>(4005000);
1408 tester.SendMessage(uint8_t(11), msg_data_3);
1409 ret = tester.Interact();
1414 for (
int i = 0; i < 50; ++i) {
1420 unsigned num_ignore_version = m_rng.
randrange(10);
1424 bool send_immediately = !initiator || m_rng.
randbool();
1427 V2TransportTester tester(m_rng, initiator);
1428 if (send_immediately) {
1430 tester.SendGarbage(garb_len);
1432 auto ret = tester.Interact();
1433 BOOST_REQUIRE(
ret &&
ret->empty());
1434 if (!send_immediately) {
1436 tester.SendGarbage(garb_len);
1438 tester.ReceiveKey();
1439 tester.SendGarbageTerm();
1440 for (
unsigned v = 0; v < num_ignore_version; ++v) {
1442 auto ver_ign_data = m_rng.
randbytes<uint8_t>(ver_ign_data_len);
1443 tester.SendVersion(ver_ign_data,
true);
1445 tester.SendVersion(ver_data,
false);
1446 ret = tester.Interact();
1447 BOOST_REQUIRE(
ret &&
ret->empty());
1448 tester.ReceiveGarbage();
1449 tester.ReceiveVersion();
1450 tester.CompareSessionIDs();
1451 for (
unsigned d = 0; d < num_decoys_1; ++d) {
1453 tester.SendPacket(decoy_data, {},
true);
1456 tester.SendMessage(uint8_t(28), msg_data_1);
1457 for (
unsigned d = 0; d < num_decoys_2; ++d) {
1459 tester.SendPacket(decoy_data, {},
true);
1462 tester.SendMessage(uint8_t(13), msg_data_2);
1465 tester.SendMessage(
"foobar", {});
1466 tester.AddMessage(
"barfoo", {});
1467 ret = tester.Interact();
1468 BOOST_REQUIRE(
ret &&
ret->size() == 4);
1473 tester.ReceiveMessage(
"barfoo", {});
1478 V2TransportTester tester(m_rng,
true);
1479 auto ret = tester.Interact();
1480 BOOST_REQUIRE(
ret &&
ret->empty());
1483 tester.ReceiveKey();
1484 tester.SendGarbageTerm();
1485 ret = tester.Interact();
1491 V2TransportTester tester(m_rng,
false);
1494 auto ret = tester.Interact();
1495 BOOST_REQUIRE(
ret &&
ret->empty());
1496 tester.ReceiveKey();
1497 tester.SendGarbageTerm();
1498 ret = tester.Interact();
1504 V2TransportTester tester(m_rng,
true);
1505 auto ret = tester.Interact();
1506 BOOST_REQUIRE(
ret &&
ret->empty());
1508 tester.ReceiveKey();
1514 auto garbage = m_rng.
randbytes<uint8_t>(len_before + 16 + len_after);
1516 auto garb_term =
MakeUCharSpan(tester.GetCipher().GetSendGarbageTerminator());
1517 std::copy(garb_term.begin(), garb_term.begin() + 16, garbage.begin() + len_before);
1520 garbage[len_before + 15] ^= (uint8_t(1) << m_rng.
randrange(8));
1521 tester.SendGarbage(garbage);
1522 tester.SendGarbageTerm();
1523 tester.SendVersion();
1524 ret = tester.Interact();
1525 BOOST_REQUIRE(
ret &&
ret->empty());
1526 tester.ReceiveGarbage();
1527 tester.ReceiveVersion();
1528 tester.CompareSessionIDs();
1529 auto msg_data_1 = m_rng.
randbytes<uint8_t>(4000000);
1530 auto msg_data_2 = m_rng.
randbytes<uint8_t>(4000000);
1531 tester.SendMessage(uint8_t(m_rng.
randrange(223) + 33), {});
1532 tester.SendMessage(uint8_t(2), msg_data_1);
1533 tester.AddMessage(
"blocktxn", msg_data_2);
1534 ret = tester.Interact();
1535 BOOST_REQUIRE(
ret &&
ret->size() == 2);
1538 tester.ReceiveMessage(uint8_t(3), msg_data_2);
1543 V2TransportTester tester(m_rng,
false);
1544 tester.SendV1Version(
Params().MessageStart());
1545 auto ret = tester.Interact();
1551 V2TransportTester tester(m_rng,
false);
1553 auto ret = tester.Interact();
const CChainParams & Params()
Return the currently selected parameters.
void ForceSetArg(const std::string &strArg, const std::string &strValue)
bool SoftSetArg(const std::string &strArg, const std::string &strValue)
Set an argument if it doesn't already have a value.
The BIP324 packet cipher, encapsulating its key derivation, stream cipher, and AEAD.
bool Decrypt(std::span< const std::byte > input, std::span< const std::byte > aad, bool &ignore, std::span< std::byte > contents) noexcept
Decrypt a packet.
std::span< const std::byte > GetSendGarbageTerminator() const noexcept
Get the Garbage Terminator to send.
static constexpr unsigned GARBAGE_TERMINATOR_LEN
unsigned DecryptLength(std::span< const std::byte > input) noexcept
Decrypt the length of a packet.
std::span< const std::byte > GetSessionID() const noexcept
Get the Session ID.
const EllSwiftPubKey & GetOurPubKey() const noexcept
Retrieve our public key.
std::span< const std::byte > GetReceiveGarbageTerminator() const noexcept
Get the expected Garbage Terminator to receive.
static constexpr unsigned LENGTH_LEN
static constexpr unsigned EXPANSION
void Initialize(const EllSwiftPubKey &their_pubkey, bool initiator, bool self_decrypt=false) noexcept
Initialize when the other side's public key is received.
void Encrypt(std::span< const std::byte > contents, std::span< const std::byte > aad, bool ignore, std::span< std::byte > output) noexcept
Encrypt a packet.
A CService with information about it as peer.
static constexpr SerParams V1_NETWORK
static constexpr SerParams V2_NETWORK
static std::unique_ptr< const CChainParams > Main()
An encapsulated private key.
void Set(const T pbegin, const T pend, bool fCompressedIn)
Initialize using begin and end iterators to byte data.
std::string ToStringAddr() const
bool SetSpecial(const std::string &addr)
Parse a Tor or I2P address and set this object to it.
bool SetInternal(const std::string &name)
Create an "internal" address that represents a name or FQDN.
bool IsAddrV1Compatible() const
Check if the current object can be serialized in pre-ADDRv2/BIP155 format.
Information about a peer.
A combination of a network address (CNetAddr) and a (TCP) port.
Double ended buffer combining vector and stream-like interfaces.
BOOST_CHECK_EXCEPTION predicates to check the specific validation error.
static Mutex g_msgproc_mutex
Mutex for anything that is only accessed via the msg processing thread.
I randrange(I range) noexcept
Generate a random integer in the range [0..range), with range > 0.
bool randbool() noexcept
Generate a random boolean.
std::vector< B > randbytes(size_t len) noexcept
Generate random bytes.
void Add(Network net) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
bool Contains(Network net) const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
void Remove(Network net) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
void RemoveAll() EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
void MarkBytesSent(size_t bytes_sent) noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex)
Report how many bytes returned by the last GetBytesToSend() have been sent.
static constexpr uint32_t MAX_GARBAGE_LEN
Info GetInfo() const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex)
Retrieve information about this transport.
BytesToSend GetBytesToSend(bool have_next_message) const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex)
Get bytes to send on the wire, if any, along with other information about it.
bool ReceivedMessageComplete() const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex)
Returns true if the current message is complete (so GetReceivedMessage can be called).
CNetMessage GetReceivedMessage(std::chrono::microseconds time, bool &reject_message) noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex)
Retrieve a completed message from transport.
bool ReceivedBytes(std::span< const uint8_t > &msg_bytes) noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex
Feed wire bytes to the transport.
bool SetMessageToSend(CSerializedNetMsg &msg) noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex)
Set the next message to send.
constexpr unsigned char * end()
constexpr unsigned char * begin()
@ OUTBOUND_FULL_RELAY
These are the default connections that we use to connect with the network.
@ INBOUND
Inbound connections are those initiated by a peer.
BOOST_FIXTURE_TEST_SUITE(cuckoocache_tests, BasicTestingSetup)
Test Suite for CuckooCache.
BOOST_AUTO_TEST_SUITE_END()
static CService ip(uint32_t i)
std::string HexStr(const std::span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
std::array< uint8_t, 4 > MessageStartChars
CSerializedNetMsg Make(std::string msg_type, Args &&... args)
constexpr const char * VERACK
The verack message acknowledges a previously-received version message, informing the connecting node ...
constexpr const char * VERSION
The version message provides information about the transmitting node to the receiving node at the beg...
""_hex is a compile-time user-defined literal returning a std::array<std::byte>, equivalent to ParseH...
std::string ToString(const T &t)
Locale-independent version of std::to_string.
bool IsLocal(const CService &addr)
check whether a given address is potentially local
void RemoveLocal(const CService &addr)
bool AddLocal(const CService &addr_, int nScore)
std::optional< CService > GetLocalAddrForPeer(CNode &node)
Returns a local address that we should advertise to this peer.
CService GetLocalAddress(const CNode &peer)
GlobalMutex g_maplocalhost_mutex
std::function< void(const CAddress &addr, const std::string &msg_type, std::span< const unsigned char > data, bool is_incoming)> CaptureMessage
Defaults to CaptureMessageToFile(), but can be overridden by unit tests.
BOOST_AUTO_TEST_CASE(cnode_listen_port)
CNetAddr UtilBuildAddress(unsigned char p1, unsigned char p2, unsigned char p3, unsigned char p4)
@ NET_ONION
TOR (v2 or v3)
@ NET_UNROUTABLE
Addresses from these networks are not publicly routable on the global Internet.
@ NET_INTERNAL
A set of addresses that represent the hash of a string or FQDN.
std::vector< CNetAddr > LookupHost(const std::string &name, unsigned int nMaxSolutions, bool fAllowLookup, DNSLookupFn dns_lookup_function)
Resolve a host string to its corresponding network addresses.
std::vector< CService > Lookup(const std::string &name, uint16_t portDefault, bool fAllowLookup, unsigned int nMaxSolutions, DNSLookupFn dns_lookup_function)
Resolve a service string to its corresponding service.
CService MaybeFlipIPv6toCJDNS(const CService &service)
If an IPv6 address belongs to the address range used by the CJDNS network and the CJDNS network is re...
ReachableNets g_reachable_nets
#define BOOST_CHECK_EQUAL(v1, v2)
#define BOOST_CHECK(expr)
static const int PROTOCOL_VERSION
network protocol versioning
auto MakeByteSpan(const V &v) noexcept
constexpr auto MakeUCharSpan(const V &v) -> decltype(UCharSpanCast(std::span{v}))
Like the std::span constructor, but for (const) unsigned char member types only.
auto MakeWritableByteSpan(V &&v) noexcept
unsigned char * UCharCast(char *c)
static constexpr size_t size()
Identical to TestingSetup, but chain set to regtest.
void JumpOutOfIbd()
Toggle IsInitialBlockDownload from true to false.
std::unique_ptr< ChainstateManager > chainman
std::unique_ptr< PeerManager > peerman
std::string ToLower(std::string_view str)
Returns the lowercase equivalent of the given string.