5 #include <chainparams.h>
26 #include <boost/test/unit_test.hpp>
34 using namespace std::literals;
45 uint16_t altPort = 12345;
56 ipv4Addr.s_addr = 0xa0b0c001;
61 std::unique_ptr<CNode> pnode1 = std::make_unique<CNode>(
id++,
79 std::unique_ptr<CNode> pnode2 = std::make_unique<CNode>(
id++,
97 std::unique_ptr<CNode> pnode3 = std::make_unique<CNode>(
id++,
115 std::unique_ptr<CNode> pnode4 = std::make_unique<CNode>(
id++,
124 BOOST_CHECK(pnode4->IsFullOutboundConn() ==
false);
140 BOOST_REQUIRE(!addr.
IsValid());
141 BOOST_REQUIRE(addr.
IsIPv4());
148 addr =
LookupHost(
"255.255.255.255",
false).value();
149 BOOST_REQUIRE(!addr.
IsValid());
150 BOOST_REQUIRE(addr.
IsIPv4());
157 addr =
LookupHost(
"12.34.56.78",
false).value();
159 BOOST_REQUIRE(addr.
IsIPv4());
167 BOOST_REQUIRE(!addr.
IsValid());
168 BOOST_REQUIRE(addr.
IsIPv6());
175 addr =
LookupHost(
"1122:3344:5566:7788:9900:aabb:ccdd:eeff",
false).value();
177 BOOST_REQUIRE(addr.
IsIPv6());
188 const std::string link_local{
"fe80::1"};
189 const std::string scoped_addr{link_local +
"%32"};
190 addr =
LookupHost(scoped_addr,
false).value();
192 BOOST_REQUIRE(addr.
IsIPv6());
197 addr =
LookupHost(link_local +
"%0",
false).value();
199 BOOST_REQUIRE(addr.
IsIPv6());
207 const char* torv3_addr =
"pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion";
210 BOOST_REQUIRE(addr.
IsTor());
225 "pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd\0wtf.onion", 66}));
234 const char* i2p_addr =
"UDHDrtrcetjm5sxzskjyr5ztpeszydbh4dpl3pl4utgqqw2v4jna.b32.I2P";
237 BOOST_REQUIRE(addr.
IsI2P());
257 !addr.
SetSpecial(
"pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscsad.b32.i2p"));
264 BOOST_REQUIRE(!addr.
IsValid());
279 const std::map<std::string, std::string> canonical_representations_ipv6{
280 {
"0000:0000:0000:0000:0000:0000:0000:0000",
"::"},
281 {
"000:0000:000:00:0:00:000:0000",
"::"},
282 {
"000:000:000:000:000:000:000:000",
"::"},
283 {
"00:00:00:00:00:00:00:00",
"::"},
284 {
"0:0:0:0:0:0:0:0",
"::"},
285 {
"0:0:0:0:0:0:0:1",
"::1"},
286 {
"2001:0:0:1:0:0:0:1",
"2001:0:0:1::1"},
287 {
"2001:0db8:0:0:1:0:0:1",
"2001:db8::1:0:0:1"},
288 {
"2001:0db8:85a3:0000:0000:8a2e:0370:7334",
"2001:db8:85a3::8a2e:370:7334"},
289 {
"2001:0db8::0001",
"2001:db8::1"},
290 {
"2001:0db8::0001:0000",
"2001:db8::1:0"},
291 {
"2001:0db8::1:0:0:1",
"2001:db8::1:0:0:1"},
292 {
"2001:db8:0000:0:1::1",
"2001:db8::1:0:0:1"},
293 {
"2001:db8:0000:1:1:1:1:1",
"2001:db8:0:1:1:1:1:1"},
294 {
"2001:db8:0:0:0:0:2:1",
"2001:db8::2:1"},
295 {
"2001:db8:0:0:0::1",
"2001:db8::1"},
296 {
"2001:db8:0:0:1:0:0:1",
"2001:db8::1:0:0:1"},
297 {
"2001:db8:0:0:1::1",
"2001:db8::1:0:0:1"},
298 {
"2001:DB8:0:0:1::1",
"2001:db8::1:0:0:1"},
299 {
"2001:db8:0:0::1",
"2001:db8::1"},
300 {
"2001:db8:0:0:aaaa::1",
"2001:db8::aaaa:0:0:1"},
301 {
"2001:db8:0:1:1:1:1:1",
"2001:db8:0:1:1:1:1:1"},
302 {
"2001:db8:0::1",
"2001:db8::1"},
303 {
"2001:db8:85a3:0:0:8a2e:370:7334",
"2001:db8:85a3::8a2e:370:7334"},
304 {
"2001:db8::0:1",
"2001:db8::1"},
305 {
"2001:db8::0:1:0:0:1",
"2001:db8::1:0:0:1"},
306 {
"2001:DB8::1",
"2001:db8::1"},
307 {
"2001:db8::1",
"2001:db8::1"},
308 {
"2001:db8::1:0:0:1",
"2001:db8::1:0:0:1"},
309 {
"2001:db8::1:1:1:1:1",
"2001:db8:0:1:1:1:1:1"},
310 {
"2001:db8::aaaa:0:0:1",
"2001:db8::aaaa:0:0:1"},
311 {
"2001:db8:aaaa:bbbb:cccc:dddd:0:1",
"2001:db8:aaaa:bbbb:cccc:dddd:0:1"},
312 {
"2001:db8:aaaa:bbbb:cccc:dddd::1",
"2001:db8:aaaa:bbbb:cccc:dddd:0:1"},
313 {
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:0001",
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:1"},
314 {
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:001",
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:1"},
315 {
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:01",
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:1"},
316 {
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:1",
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:1"},
317 {
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:aaaa",
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:aaaa"},
318 {
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:AAAA",
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:aaaa"},
319 {
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:AaAa",
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:aaaa"},
321 for (
const auto& [input_address, expected_canonical_representation_output] : canonical_representations_ipv6) {
322 const std::optional<CNetAddr> net_addr{
LookupHost(input_address,
false)};
323 BOOST_REQUIRE(net_addr.value().IsIPv6());
324 BOOST_CHECK_EQUAL(net_addr.value().ToStringAddr(), expected_canonical_representation_output);
334 s << ser_params(addr);
339 s << ser_params(addr);
343 addr =
LookupHost(
"1a1b:2a2b:3a3b:4a4b:5a5b:6a6b:7a7b:8a8b",
false).value();
344 s << ser_params(addr);
351 BOOST_REQUIRE(addr.
SetSpecial(
"pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion"));
352 s << ser_params(addr);
357 s << ser_params(addr);
368 s << ser_params(addr);
373 s << ser_params(addr);
377 addr =
LookupHost(
"1a1b:2a2b:3a3b:4a4b:5a5b:6a6b:7a7b:8a8b",
false).value();
378 s << ser_params(addr);
385 BOOST_REQUIRE(addr.
SetSpecial(
"kpgvmscirrdqpekbqjsvw5teanhatztpp2gl6eee4zkowvwfxwenqaid.onion"));
386 s << ser_params(addr);
391 s << ser_params(addr);
406 s >> ser_params(addr);
411 BOOST_REQUIRE(s.empty());
417 BOOST_CHECK_EXCEPTION(s >> ser_params(addr), std::ios_base::failure,
HasReason(
"end of data"));
418 BOOST_REQUIRE(!s.empty());
425 BOOST_CHECK_EXCEPTION(s >> ser_params(addr), std::ios_base::failure,
426 HasReason(
"BIP155 IPv4 address with length 5 (should be 4)"));
427 BOOST_REQUIRE(!s.empty());
434 BOOST_CHECK_EXCEPTION(s >> ser_params(addr), std::ios_base::failure,
435 HasReason(
"Address too long: 513 > 512"));
436 BOOST_REQUIRE(!s.empty());
442 "0102030405060708090a0b0c0d0e0f10")};
443 s >> ser_params(addr);
448 BOOST_REQUIRE(s.empty());
454 "fd6b88c08724ca978112ca1bbdcafac2")};
456 s >> ser_params(addr);
460 BOOST_REQUIRE(s.empty());
466 BOOST_CHECK_EXCEPTION(s >> ser_params(addr), std::ios_base::failure,
467 HasReason(
"BIP155 IPv6 address with length 4 (should be 16)"));
468 BOOST_REQUIRE(!s.empty());
474 "00000000000000000000ffff01020304")};
475 s >> ser_params(addr);
477 BOOST_REQUIRE(s.empty());
482 "fd87d87eeb430102030405060708090a")};
483 s >> ser_params(addr);
485 BOOST_REQUIRE(s.empty());
490 "f1f2f3f4f5f6f7f8f9fa")};
491 s >> ser_params(addr);
493 BOOST_REQUIRE(s.empty());
498 "79bcc625184b05194975c28b66b66b04"
499 "69f7f6556fb1ac3189a79b40dda32f1f"
501 s >> ser_params(addr);
506 "pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion");
507 BOOST_REQUIRE(s.empty());
514 BOOST_CHECK_EXCEPTION(s >> ser_params(addr), std::ios_base::failure,
515 HasReason(
"BIP155 TORv3 address with length 0 (should be 32)"));
516 BOOST_REQUIRE(!s.empty());
522 "a2894dabaec08c0051a481a6dac88b64"
523 "f98232ae42d4b6fd2fa81952dfe36a87")};
524 s >> ser_params(addr);
529 "ukeu3k5oycgaauneqgtnvselmt4yemvoilkln7jpvamvfx7dnkdq.b32.i2p");
530 BOOST_REQUIRE(s.empty());
537 BOOST_CHECK_EXCEPTION(s >> ser_params(addr), std::ios_base::failure,
538 HasReason(
"BIP155 I2P address with length 3 (should be 32)"));
539 BOOST_REQUIRE(!s.empty());
545 "fc000001000200030004000500060007"
547 s >> ser_params(addr);
552 BOOST_REQUIRE(s.empty());
557 "aa000001000200030004000500060007"
559 s >> ser_params(addr);
562 BOOST_REQUIRE(s.empty());
569 BOOST_CHECK_EXCEPTION(s >> ser_params(addr), std::ios_base::failure,
570 HasReason(
"BIP155 CJDNS address with length 1 (should be 16)"));
571 BOOST_REQUIRE(!s.empty());
579 BOOST_CHECK_EXCEPTION(s >> ser_params(addr), std::ios_base::failure,
580 HasReason(
"Address too long: 33554432 > 512"));
581 BOOST_REQUIRE(!s.empty());
589 s >> ser_params(addr);
591 BOOST_REQUIRE(s.empty());
598 s >> ser_params(addr);
600 BOOST_REQUIRE(s.empty());
610 raw_addr.s_addr = htonl(0x7f000001);
617 mapLocalHost[mapLocalHost_entry] = lsi;
621 in_addr ipv4AddrPeer;
622 ipv4AddrPeer.s_addr = 0xa0b0c001;
624 std::unique_ptr<CNode> pnode = std::make_unique<CNode>(0,
633 pnode->fSuccessfullyConnected.store(
true);
636 in6_addr ipv6AddrLocal;
637 memset(ipv6AddrLocal.s6_addr, 0, 16);
638 ipv6AddrLocal.s6_addr[0] = 0xcc;
640 pnode->SetAddrLocal(addrLocal);
651 mapLocalHost.erase(mapLocalHost_entry);
667 const uint16_t bind_port = 20001;
671 in_addr peer_us_addr;
672 peer_us_addr.s_addr = htonl(0x02030405);
673 const CService peer_us{peer_us_addr, 20002};
676 in_addr peer_out_in_addr;
677 peer_out_in_addr.s_addr = htonl(0x01020304);
687 peer_out.fSuccessfullyConnected =
true;
688 peer_out.SetAddrLocal(peer_us);
692 BOOST_REQUIRE(chosen_local_addr);
693 const CService expected{peer_us_addr, bind_port};
697 in_addr peer_in_in_addr;
698 peer_in_in_addr.s_addr = htonl(0x05060708);
708 peer_in.fSuccessfullyConnected =
true;
709 peer_in.SetAddrLocal(peer_us);
713 BOOST_REQUIRE(chosen_local_addr);
774 unsigned char ip[] = {p1, p2, p3, p4};
776 struct sockaddr_in sa;
777 memset(&sa, 0,
sizeof(sockaddr_in));
778 memcpy(&(sa.sin_addr), &
ip,
sizeof(
ip));
824 const uint16_t bind_port = 20001;
829 in_addr peer_us_addr;
830 peer_us_addr.s_addr = htonl(0x02030405);
831 const CService peer_us{peer_us_addr, 20002};
834 in_addr peer_in_addr;
835 peer_in_addr.s_addr = htonl(0x01020304);
847 const int64_t time{0};
856 std::atomic<bool> interrupt_dummy{
false};
857 std::chrono::microseconds time_received_dummy{0};
859 const auto msg_version =
874 const CService expected{peer_us_addr, bind_port};
879 const std::string& msg_type,
881 bool is_incoming) ->
void {
882 if (!is_incoming && msg_type ==
"addr") {
884 std::vector<CAddress> addresses;
888 for (
const auto& addr : addresses) {
889 if (addr == expected) {
910 auto CreatePeer = [](
const CAddress& addr) {
911 return std::make_unique<CNode>(0,
924 BOOST_REQUIRE(addr_ipv4.IsValid());
925 BOOST_REQUIRE(addr_ipv4.IsIPv4());
928 BOOST_REQUIRE(addr_ipv6.IsValid());
929 BOOST_REQUIRE(addr_ipv6.IsIPv6());
932 BOOST_REQUIRE(addr_ipv6_tunnel.IsValid());
933 BOOST_REQUIRE(addr_ipv6_tunnel.IsIPv6());
934 BOOST_REQUIRE(addr_ipv6_tunnel.IsRFC3964());
937 BOOST_REQUIRE(addr_teredo.IsValid());
938 BOOST_REQUIRE(addr_teredo.IsIPv6());
939 BOOST_REQUIRE(addr_teredo.IsRFC4380());
942 BOOST_REQUIRE(addr_onion.
SetSpecial(
"pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion"));
943 BOOST_REQUIRE(addr_onion.
IsValid());
944 BOOST_REQUIRE(addr_onion.
IsTor());
947 BOOST_REQUIRE(addr_i2p.
SetSpecial(
"udhdrtrcetjm5sxzskjyr5ztpeszydbh4dpl3pl4utgqqw2v4jna.b32.i2p"));
948 BOOST_REQUIRE(addr_i2p.
IsValid());
949 BOOST_REQUIRE(addr_i2p.
IsI2P());
953 BOOST_REQUIRE(addr_cjdns.IsValid());
954 BOOST_REQUIRE(addr_cjdns.IsCJDNS());
956 const auto peer_ipv4{CreatePeer(addr_ipv4)};
957 const auto peer_ipv6{CreatePeer(addr_ipv6)};
958 const auto peer_ipv6_tunnel{CreatePeer(addr_ipv6_tunnel)};
959 const auto peer_teredo{CreatePeer(addr_teredo)};
960 const auto peer_onion{CreatePeer(addr_onion)};
961 const auto peer_i2p{CreatePeer(addr_i2p)};
962 const auto peer_cjdns{CreatePeer(addr_cjdns)};
1014 CKey GenerateRandomTestKey() noexcept
1030 class V2TransportTester
1034 bool m_test_initiator;
1036 std::vector<uint8_t> m_sent_garbage;
1037 std::vector<uint8_t> m_recv_garbage;
1038 std::vector<uint8_t> m_to_send;
1039 std::vector<uint8_t> m_received;
1040 std::deque<CSerializedNetMsg> m_msg_to_send;
1041 bool m_sent_aad{
false};
1045 explicit V2TransportTester(
bool test_initiator)
1046 : m_transport{0, test_initiator},
1048 m_test_initiator(test_initiator) {}
1057 using InteractResult = std::optional<std::vector<std::optional<CNetMessage>>>;
1064 InteractResult Interact()
1066 std::vector<std::optional<CNetMessage>>
ret;
1068 bool progress{
false};
1070 if (!m_to_send.empty()) {
1072 size_t old_len = to_send.
size();
1074 return std::nullopt;
1076 if (old_len != to_send.
size()) {
1078 m_to_send.erase(m_to_send.begin(), m_to_send.begin() + (old_len - to_send.
size()));
1086 ret.emplace_back(std::nullopt);
1088 ret.emplace_back(std::move(
msg));
1095 m_msg_to_send.pop_front();
1100 const auto& [recv_bytes, _more, _msg_type] = m_transport.
GetBytesToSend(!m_msg_to_send.empty());
1103 m_received.insert(m_received.end(), recv_bytes.begin(), recv_bytes.begin() + to_receive);
1107 if (!progress)
break;
1118 m_to_send.insert(m_to_send.end(), data.
begin(), data.
end());
1127 m_to_send.insert(m_to_send.end(),
UCharCast(ser.data()),
UCharCast(ser.data() + ser.size()));
1140 m_sent_garbage.assign(garbage.
begin(), garbage.
end());
1142 Send(m_sent_garbage);
1146 void SendGarbage(
size_t garbage_len)
1159 void AddMessage(std::string m_type, std::vector<uint8_t> payload)
1162 msg.m_type = std::move(m_type);
1163 msg.data = std::move(payload);
1164 m_msg_to_send.push_back(std::move(
msg));
1187 std::vector<std::byte> ciphertext;
1199 void SendGarbageTerm()
1210 if (!m_sent_aad) aad = m_sent_garbage;
1211 SendPacket(version_data, aad, vers_ignore);
1220 std::vector<uint8_t> contents;
1230 contents.resize(size);
1251 void ReceiveGarbage()
1261 m_recv_garbage.assign(m_received.begin(), m_received.begin() + garblen);
1267 void ReceiveVersion()
1269 auto contents = ReceivePacket(
MakeByteSpan(m_recv_garbage));
1280 auto ret = ReceivePacket();
1290 auto ret = ReceivePacket();
1293 for (
unsigned i = 0; i < 12; ++i) {
1294 if (i < m_type.size()) {
1309 std::copy(mtype.begin(), mtype.end(),
reinterpret_cast<char*
>(contents.data() + 1));
1312 SendPacket(contents);
1320 std::vector<uint8_t> contents(1 + payload.
size());
1321 contents[0] = short_id;
1322 std::copy(payload.
begin(), payload.
end(), contents.begin() + 1);
1324 SendPacket(contents);
1328 void CompareSessionIDs()
const
1330 auto info = m_transport.
GetInfo();
1347 for (
int i = 0; i < 10; ++i) {
1348 V2TransportTester tester(
true);
1349 auto ret = tester.Interact();
1350 BOOST_REQUIRE(
ret &&
ret->empty());
1352 tester.SendGarbage();
1353 tester.ReceiveKey();
1354 tester.SendGarbageTerm();
1355 tester.SendVersion();
1356 ret = tester.Interact();
1357 BOOST_REQUIRE(
ret &&
ret->empty());
1358 tester.ReceiveGarbage();
1359 tester.ReceiveVersion();
1360 tester.CompareSessionIDs();
1363 tester.SendMessage(uint8_t(4), msg_data_1);
1364 tester.SendMessage(0, {});
1365 tester.SendMessage(
"tx", msg_data_2);
1366 ret = tester.Interact();
1367 BOOST_REQUIRE(
ret &&
ret->size() == 3);
1375 tester.SendMessage(
"bad", msg_data_1);
1378 ret = tester.Interact();
1383 tester.SendMessage(uint8_t(12), msg_data_3);
1388 for (
int i = 0; i < 10; ++i) {
1389 V2TransportTester tester(
false);
1391 tester.SendGarbage();
1392 auto ret = tester.Interact();
1393 BOOST_REQUIRE(
ret &&
ret->empty());
1394 tester.ReceiveKey();
1395 tester.SendGarbageTerm();
1396 tester.SendVersion();
1397 ret = tester.Interact();
1398 BOOST_REQUIRE(
ret &&
ret->empty());
1399 tester.ReceiveGarbage();
1400 tester.ReceiveVersion();
1401 tester.CompareSessionIDs();
1404 tester.SendMessage(uint8_t(14), msg_data_1);
1405 tester.SendMessage(uint8_t(19), msg_data_2);
1406 ret = tester.Interact();
1407 BOOST_REQUIRE(
ret &&
ret->size() == 2);
1413 tester.SendMessage(uint8_t(11), msg_data_3);
1414 ret = tester.Interact();
1419 for (
int i = 0; i < 50; ++i) {
1432 V2TransportTester tester(initiator);
1433 if (send_immediately) {
1435 tester.SendGarbage(garb_len);
1437 auto ret = tester.Interact();
1438 BOOST_REQUIRE(
ret &&
ret->empty());
1439 if (!send_immediately) {
1441 tester.SendGarbage(garb_len);
1443 tester.ReceiveKey();
1444 tester.SendGarbageTerm();
1445 for (
unsigned v = 0; v < num_ignore_version; ++v) {
1448 tester.SendVersion(ver_ign_data,
true);
1450 tester.SendVersion(ver_data,
false);
1451 ret = tester.Interact();
1452 BOOST_REQUIRE(
ret &&
ret->empty());
1453 tester.ReceiveGarbage();
1454 tester.ReceiveVersion();
1455 tester.CompareSessionIDs();
1456 for (
unsigned d = 0; d < num_decoys_1; ++d) {
1458 tester.SendPacket(decoy_data, {},
true);
1461 tester.SendMessage(uint8_t(28), msg_data_1);
1462 for (
unsigned d = 0; d < num_decoys_2; ++d) {
1464 tester.SendPacket(decoy_data, {},
true);
1467 tester.SendMessage(uint8_t(13), msg_data_2);
1470 tester.SendMessage(
"foobar", {});
1471 tester.AddMessage(
"barfoo", {});
1472 ret = tester.Interact();
1473 BOOST_REQUIRE(
ret &&
ret->size() == 4);
1478 tester.ReceiveMessage(
"barfoo", {});
1483 V2TransportTester tester(
true);
1484 auto ret = tester.Interact();
1485 BOOST_REQUIRE(
ret &&
ret->empty());
1488 tester.ReceiveKey();
1489 tester.SendGarbageTerm();
1490 ret = tester.Interact();
1496 V2TransportTester tester(
false);
1499 auto ret = tester.Interact();
1500 BOOST_REQUIRE(
ret &&
ret->empty());
1501 tester.ReceiveKey();
1502 tester.SendGarbageTerm();
1503 ret = tester.Interact();
1509 V2TransportTester tester(
true);
1510 auto ret = tester.Interact();
1511 BOOST_REQUIRE(
ret &&
ret->empty());
1513 tester.ReceiveKey();
1521 auto garb_term =
MakeUCharSpan(tester.GetCipher().GetSendGarbageTerminator());
1522 std::copy(garb_term.begin(), garb_term.begin() + 16, garbage.
begin() + len_before);
1526 tester.SendGarbage(garbage);
1527 tester.SendGarbageTerm();
1528 tester.SendVersion();
1529 ret = tester.Interact();
1530 BOOST_REQUIRE(
ret &&
ret->empty());
1531 tester.ReceiveGarbage();
1532 tester.ReceiveVersion();
1533 tester.CompareSessionIDs();
1537 tester.SendMessage(uint8_t(2), msg_data_1);
1538 tester.AddMessage(
"blocktxn", msg_data_2);
1539 ret = tester.Interact();
1540 BOOST_REQUIRE(
ret &&
ret->size() == 2);
1543 tester.ReceiveMessage(uint8_t(3), msg_data_2);
1548 V2TransportTester tester(
false);
1549 tester.SendV1Version(
Params().MessageStart());
1550 auto ret = tester.Interact();
1556 V2TransportTester tester(
false);
1558 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.
Span< const std::byte > GetSendGarbageTerminator() const noexcept
Get the Garbage Terminator to send.
Span< const std::byte > GetSessionID() const noexcept
Get the Session ID.
static constexpr unsigned GARBAGE_TERMINATOR_LEN
unsigned DecryptLength(Span< const std::byte > input) noexcept
Decrypt the length of a packet.
const EllSwiftPubKey & GetOurPubKey() const noexcept
Retrieve our public key.
bool Decrypt(Span< const std::byte > input, Span< const std::byte > aad, bool &ignore, Span< std::byte > contents) noexcept
Decrypt a packet.
void Encrypt(Span< const std::byte > contents, Span< const std::byte > aad, bool ignore, Span< std::byte > output) noexcept
Encrypt a packet.
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.
Span< const std::byte > GetReceiveGarbageTerminator() const noexcept
Get the expected Garbage Terminator to receive.
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.
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)
A Span is an object that can refer to a contiguous sequence of objects.
constexpr std::size_t size() const noexcept
constexpr C * end() const noexcept
constexpr C * begin() const noexcept
CONSTEXPR_IF_NOT_DEBUG Span< C > first(std::size_t count) const noexcept
CONSTEXPR_IF_NOT_DEBUG Span< C > subspan(std::size_t offset) const noexcept
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
bool ReceivedBytes(Span< const uint8_t > &msg_bytes) noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex
Feed wire bytes to the transport.
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 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_AUTO_TEST_SUITE_END()
static CService ip(uint32_t i)
std::string HexStr(const 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...
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)
std::optional< CService > GetLocalAddrForPeer(CNode &node)
Returns a local address that we should advertise to this peer.
bool AddLocal(const CService &addr_, int nScore)
CService GetLocalAddress(const CNode &peer)
GlobalMutex g_maplocalhost_mutex
std::function< void(const CAddress &addr, const std::string &msg_type, 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< 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
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.
#define BOOST_CHECK_EQUAL(v1, v2)
#define BOOST_CHECK(expr)
static const int PROTOCOL_VERSION
network protocol versioning
constexpr auto MakeUCharSpan(V &&v) -> decltype(UCharSpanCast(Span{std::forward< V >(v)}))
Like the Span constructor, but for (const) unsigned char member types only.
unsigned char * UCharCast(char *c)
Span< const std::byte > MakeByteSpan(V &&v) noexcept
Span< std::byte > MakeWritableByteSpan(V &&v) noexcept
std::vector< Byte > ParseHex(std::string_view hex_str)
Like TryParseHex, but returns an empty vector on invalid input.
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
FastRandomContext g_insecure_rand_ctx
This global and the helpers that use it are not thread-safe.
static uint64_t InsecureRandRange(uint64_t range)
static uint256 InsecureRand256()
static bool InsecureRandBool()
std::string ToLower(std::string_view str)
Returns the lowercase equivalent of the given string.