5 #include <chainparams.h>
26 #include <boost/test/unit_test.hpp>
34 using namespace std::literals;
44 uint16_t altPort = 12345;
55 ipv4Addr.s_addr = 0xa0b0c001;
60 std::unique_ptr<CNode> pnode1 = std::make_unique<CNode>(
id++,
78 std::unique_ptr<CNode> pnode2 = std::make_unique<CNode>(
id++,
96 std::unique_ptr<CNode> pnode3 = std::make_unique<CNode>(
id++,
114 std::unique_ptr<CNode> pnode4 = std::make_unique<CNode>(
id++,
123 BOOST_CHECK(pnode4->IsFullOutboundConn() ==
false);
139 BOOST_REQUIRE(!addr.
IsValid());
140 BOOST_REQUIRE(addr.
IsIPv4());
147 addr =
LookupHost(
"255.255.255.255",
false).value();
148 BOOST_REQUIRE(!addr.
IsValid());
149 BOOST_REQUIRE(addr.
IsIPv4());
156 addr =
LookupHost(
"12.34.56.78",
false).value();
158 BOOST_REQUIRE(addr.
IsIPv4());
166 BOOST_REQUIRE(!addr.
IsValid());
167 BOOST_REQUIRE(addr.
IsIPv6());
174 addr =
LookupHost(
"1122:3344:5566:7788:9900:aabb:ccdd:eeff",
false).value();
176 BOOST_REQUIRE(addr.
IsIPv6());
187 const std::string link_local{
"fe80::1"};
188 const std::string scoped_addr{link_local +
"%32"};
189 addr =
LookupHost(scoped_addr,
false).value();
191 BOOST_REQUIRE(addr.
IsIPv6());
196 addr =
LookupHost(link_local +
"%0",
false).value();
198 BOOST_REQUIRE(addr.
IsIPv6());
206 const char* torv3_addr =
"pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion";
209 BOOST_REQUIRE(addr.
IsTor());
224 "pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd\0wtf.onion", 66}));
233 const char* i2p_addr =
"UDHDrtrcetjm5sxzskjyr5ztpeszydbh4dpl3pl4utgqqw2v4jna.b32.I2P";
236 BOOST_REQUIRE(addr.
IsI2P());
256 !addr.
SetSpecial(
"pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscsad.b32.i2p"));
263 BOOST_REQUIRE(!addr.
IsValid());
278 const std::map<std::string, std::string> canonical_representations_ipv6{
279 {
"0000:0000:0000:0000:0000:0000:0000:0000",
"::"},
280 {
"000:0000:000:00:0:00:000:0000",
"::"},
281 {
"000:000:000:000:000:000:000:000",
"::"},
282 {
"00:00:00:00:00:00:00:00",
"::"},
283 {
"0:0:0:0:0:0:0:0",
"::"},
284 {
"0:0:0:0:0:0:0:1",
"::1"},
285 {
"2001:0:0:1:0:0:0:1",
"2001:0:0:1::1"},
286 {
"2001:0db8:0:0:1:0:0:1",
"2001:db8::1:0:0:1"},
287 {
"2001:0db8:85a3:0000:0000:8a2e:0370:7334",
"2001:db8:85a3::8a2e:370:7334"},
288 {
"2001:0db8::0001",
"2001:db8::1"},
289 {
"2001:0db8::0001:0000",
"2001:db8::1:0"},
290 {
"2001:0db8::1:0:0:1",
"2001:db8::1:0:0:1"},
291 {
"2001:db8:0000:0:1::1",
"2001:db8::1:0:0:1"},
292 {
"2001:db8:0000:1:1:1:1:1",
"2001:db8:0:1:1:1:1:1"},
293 {
"2001:db8:0:0:0:0:2:1",
"2001:db8::2:1"},
294 {
"2001:db8:0:0:0::1",
"2001:db8::1"},
295 {
"2001:db8:0:0:1:0:0: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::1",
"2001:db8::1:0:0:1"},
298 {
"2001:db8:0:0::1",
"2001:db8::1"},
299 {
"2001:db8:0:0:aaaa::1",
"2001:db8::aaaa:0:0:1"},
300 {
"2001:db8:0:1:1:1:1:1",
"2001:db8:0:1:1:1:1:1"},
301 {
"2001:db8:0::1",
"2001:db8::1"},
302 {
"2001:db8:85a3:0:0:8a2e:370:7334",
"2001:db8:85a3::8a2e:370:7334"},
303 {
"2001:db8::0:1",
"2001:db8::1"},
304 {
"2001:db8::0:1:0:0:1",
"2001:db8::1:0:0:1"},
305 {
"2001:DB8::1",
"2001:db8::1"},
306 {
"2001:db8::1",
"2001:db8::1"},
307 {
"2001:db8::1:0:0:1",
"2001:db8::1:0:0:1"},
308 {
"2001:db8::1:1:1:1:1",
"2001:db8:0:1:1:1:1:1"},
309 {
"2001:db8::aaaa:0:0:1",
"2001:db8::aaaa:0:0:1"},
310 {
"2001:db8:aaaa:bbbb:cccc:dddd:0:1",
"2001:db8:aaaa:bbbb:cccc:dddd:0:1"},
311 {
"2001:db8:aaaa:bbbb:cccc:dddd::1",
"2001:db8:aaaa:bbbb:cccc:dddd:0:1"},
312 {
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:0001",
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:1"},
313 {
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:001",
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:1"},
314 {
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:01",
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:1"},
315 {
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:1",
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:1"},
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"},
318 {
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:AaAa",
"2001:db8:aaaa:bbbb:cccc:dddd:eeee:aaaa"},
320 for (
const auto& [input_address, expected_canonical_representation_output] : canonical_representations_ipv6) {
321 const std::optional<CNetAddr> net_addr{
LookupHost(input_address,
false)};
322 BOOST_REQUIRE(net_addr.value().IsIPv6());
323 BOOST_CHECK_EQUAL(net_addr.value().ToStringAddr(), expected_canonical_representation_output);
333 s << ser_params(addr);
338 s << ser_params(addr);
342 addr =
LookupHost(
"1a1b:2a2b:3a3b:4a4b:5a5b:6a6b:7a7b:8a8b",
false).value();
343 s << ser_params(addr);
350 BOOST_REQUIRE(addr.
SetSpecial(
"pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion"));
351 s << ser_params(addr);
356 s << ser_params(addr);
367 s << ser_params(addr);
372 s << ser_params(addr);
376 addr =
LookupHost(
"1a1b:2a2b:3a3b:4a4b:5a5b:6a6b:7a7b:8a8b",
false).value();
377 s << ser_params(addr);
384 BOOST_REQUIRE(addr.
SetSpecial(
"kpgvmscirrdqpekbqjsvw5teanhatztpp2gl6eee4zkowvwfxwenqaid.onion"));
385 s << ser_params(addr);
390 s << ser_params(addr);
405 s >> ser_params(addr);
410 BOOST_REQUIRE(s.empty());
416 BOOST_CHECK_EXCEPTION(s >> ser_params(addr), std::ios_base::failure,
HasReason(
"end of data"));
417 BOOST_REQUIRE(!s.empty());
424 BOOST_CHECK_EXCEPTION(s >> ser_params(addr), std::ios_base::failure,
425 HasReason(
"BIP155 IPv4 address with length 5 (should be 4)"));
426 BOOST_REQUIRE(!s.empty());
433 BOOST_CHECK_EXCEPTION(s >> ser_params(addr), std::ios_base::failure,
434 HasReason(
"Address too long: 513 > 512"));
435 BOOST_REQUIRE(!s.empty());
441 "0102030405060708090a0b0c0d0e0f10")};
442 s >> ser_params(addr);
447 BOOST_REQUIRE(s.empty());
453 "fd6b88c08724ca978112ca1bbdcafac2")};
455 s >> ser_params(addr);
459 BOOST_REQUIRE(s.empty());
465 BOOST_CHECK_EXCEPTION(s >> ser_params(addr), std::ios_base::failure,
466 HasReason(
"BIP155 IPv6 address with length 4 (should be 16)"));
467 BOOST_REQUIRE(!s.empty());
473 "00000000000000000000ffff01020304")};
474 s >> ser_params(addr);
476 BOOST_REQUIRE(s.empty());
481 "fd87d87eeb430102030405060708090a")};
482 s >> ser_params(addr);
484 BOOST_REQUIRE(s.empty());
489 "f1f2f3f4f5f6f7f8f9fa")};
490 s >> ser_params(addr);
492 BOOST_REQUIRE(s.empty());
497 "79bcc625184b05194975c28b66b66b04"
498 "69f7f6556fb1ac3189a79b40dda32f1f"
500 s >> ser_params(addr);
505 "pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion");
506 BOOST_REQUIRE(s.empty());
513 BOOST_CHECK_EXCEPTION(s >> ser_params(addr), std::ios_base::failure,
514 HasReason(
"BIP155 TORv3 address with length 0 (should be 32)"));
515 BOOST_REQUIRE(!s.empty());
521 "a2894dabaec08c0051a481a6dac88b64"
522 "f98232ae42d4b6fd2fa81952dfe36a87")};
523 s >> ser_params(addr);
528 "ukeu3k5oycgaauneqgtnvselmt4yemvoilkln7jpvamvfx7dnkdq.b32.i2p");
529 BOOST_REQUIRE(s.empty());
536 BOOST_CHECK_EXCEPTION(s >> ser_params(addr), std::ios_base::failure,
537 HasReason(
"BIP155 I2P address with length 3 (should be 32)"));
538 BOOST_REQUIRE(!s.empty());
544 "fc000001000200030004000500060007"
546 s >> ser_params(addr);
551 BOOST_REQUIRE(s.empty());
556 "aa000001000200030004000500060007"
558 s >> ser_params(addr);
561 BOOST_REQUIRE(s.empty());
568 BOOST_CHECK_EXCEPTION(s >> ser_params(addr), std::ios_base::failure,
569 HasReason(
"BIP155 CJDNS address with length 1 (should be 16)"));
570 BOOST_REQUIRE(!s.empty());
578 BOOST_CHECK_EXCEPTION(s >> ser_params(addr), std::ios_base::failure,
579 HasReason(
"Address too long: 33554432 > 512"));
580 BOOST_REQUIRE(!s.empty());
588 s >> ser_params(addr);
590 BOOST_REQUIRE(s.empty());
597 s >> ser_params(addr);
599 BOOST_REQUIRE(s.empty());
609 raw_addr.s_addr = htonl(0x7f000001);
616 mapLocalHost[mapLocalHost_entry] = lsi;
620 in_addr ipv4AddrPeer;
621 ipv4AddrPeer.s_addr = 0xa0b0c001;
623 std::unique_ptr<CNode> pnode = std::make_unique<CNode>(0,
632 pnode->fSuccessfullyConnected.store(
true);
635 in6_addr ipv6AddrLocal;
636 memset(ipv6AddrLocal.s6_addr, 0, 16);
637 ipv6AddrLocal.s6_addr[0] = 0xcc;
639 pnode->SetAddrLocal(addrLocal);
650 mapLocalHost.erase(mapLocalHost_entry);
666 const uint16_t bind_port = 20001;
670 in_addr peer_us_addr;
671 peer_us_addr.s_addr = htonl(0x02030405);
672 const CService peer_us{peer_us_addr, 20002};
675 in_addr peer_out_in_addr;
676 peer_out_in_addr.s_addr = htonl(0x01020304);
686 peer_out.fSuccessfullyConnected =
true;
687 peer_out.SetAddrLocal(peer_us);
691 BOOST_REQUIRE(chosen_local_addr);
692 const CService expected{peer_us_addr, bind_port};
696 in_addr peer_in_in_addr;
697 peer_in_in_addr.s_addr = htonl(0x05060708);
707 peer_in.fSuccessfullyConnected =
true;
708 peer_in.SetAddrLocal(peer_us);
712 BOOST_REQUIRE(chosen_local_addr);
773 unsigned char ip[] = {p1, p2, p3, p4};
775 struct sockaddr_in sa;
776 memset(&sa, 0,
sizeof(sockaddr_in));
777 memcpy(&(sa.sin_addr), &
ip,
sizeof(
ip));
823 const uint16_t bind_port = 20001;
828 in_addr peer_us_addr;
829 peer_us_addr.s_addr = htonl(0x02030405);
830 const CService peer_us{peer_us_addr, 20002};
833 in_addr peer_in_addr;
834 peer_in_addr.s_addr = htonl(0x01020304);
846 const int64_t time{0};
855 std::atomic<bool> interrupt_dummy{
false};
856 std::chrono::microseconds time_received_dummy{0};
858 const auto msg_version =
873 const CService expected{peer_us_addr, bind_port};
878 const std::string& msg_type,
880 bool is_incoming) ->
void {
881 if (!is_incoming && msg_type ==
"addr") {
883 std::vector<CAddress> addresses;
887 for (
const auto& addr : addresses) {
888 if (addr == expected) {
909 auto CreatePeer = [](
const CAddress& addr) {
910 return std::make_unique<CNode>(0,
923 BOOST_REQUIRE(addr_ipv4.IsValid());
924 BOOST_REQUIRE(addr_ipv4.IsIPv4());
927 BOOST_REQUIRE(addr_ipv6.IsValid());
928 BOOST_REQUIRE(addr_ipv6.IsIPv6());
931 BOOST_REQUIRE(addr_ipv6_tunnel.IsValid());
932 BOOST_REQUIRE(addr_ipv6_tunnel.IsIPv6());
933 BOOST_REQUIRE(addr_ipv6_tunnel.IsRFC3964());
936 BOOST_REQUIRE(addr_teredo.IsValid());
937 BOOST_REQUIRE(addr_teredo.IsIPv6());
938 BOOST_REQUIRE(addr_teredo.IsRFC4380());
941 BOOST_REQUIRE(addr_onion.
SetSpecial(
"pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion"));
942 BOOST_REQUIRE(addr_onion.
IsValid());
943 BOOST_REQUIRE(addr_onion.
IsTor());
946 BOOST_REQUIRE(addr_i2p.
SetSpecial(
"udhdrtrcetjm5sxzskjyr5ztpeszydbh4dpl3pl4utgqqw2v4jna.b32.i2p"));
947 BOOST_REQUIRE(addr_i2p.
IsValid());
948 BOOST_REQUIRE(addr_i2p.
IsI2P());
952 BOOST_REQUIRE(addr_cjdns.IsValid());
953 BOOST_REQUIRE(addr_cjdns.IsCJDNS());
955 const auto peer_ipv4{CreatePeer(addr_ipv4)};
956 const auto peer_ipv6{CreatePeer(addr_ipv6)};
957 const auto peer_ipv6_tunnel{CreatePeer(addr_ipv6_tunnel)};
958 const auto peer_teredo{CreatePeer(addr_teredo)};
959 const auto peer_onion{CreatePeer(addr_onion)};
960 const auto peer_i2p{CreatePeer(addr_i2p)};
961 const auto peer_cjdns{CreatePeer(addr_cjdns)};
1013 CKey GenerateRandomTestKey() noexcept
1029 class V2TransportTester
1033 bool m_test_initiator;
1035 std::vector<uint8_t> m_sent_garbage;
1036 std::vector<uint8_t> m_recv_garbage;
1037 std::vector<uint8_t> m_to_send;
1038 std::vector<uint8_t> m_received;
1039 std::deque<CSerializedNetMsg> m_msg_to_send;
1040 bool m_sent_aad{
false};
1044 explicit V2TransportTester(
bool test_initiator)
1045 : m_transport{0, test_initiator},
1047 m_test_initiator(test_initiator) {}
1056 using InteractResult = std::optional<std::vector<std::optional<CNetMessage>>>;
1063 InteractResult Interact()
1065 std::vector<std::optional<CNetMessage>>
ret;
1067 bool progress{
false};
1069 if (!m_to_send.empty()) {
1071 size_t old_len = to_send.
size();
1073 return std::nullopt;
1075 if (old_len != to_send.
size()) {
1077 m_to_send.erase(m_to_send.begin(), m_to_send.begin() + (old_len - to_send.
size()));
1085 ret.emplace_back(std::nullopt);
1087 ret.emplace_back(std::move(
msg));
1094 m_msg_to_send.pop_front();
1099 const auto& [recv_bytes, _more, _msg_type] = m_transport.
GetBytesToSend(!m_msg_to_send.empty());
1102 m_received.insert(m_received.end(), recv_bytes.begin(), recv_bytes.begin() + to_receive);
1106 if (!progress)
break;
1117 m_to_send.insert(m_to_send.end(), data.
begin(), data.
end());
1126 m_to_send.insert(m_to_send.end(),
UCharCast(ser.data()),
UCharCast(ser.data() + ser.size()));
1139 m_sent_garbage.assign(garbage.
begin(), garbage.
end());
1141 Send(m_sent_garbage);
1145 void SendGarbage(
size_t garbage_len)
1158 void AddMessage(std::string m_type, std::vector<uint8_t> payload)
1161 msg.m_type = std::move(m_type);
1162 msg.data = std::move(payload);
1163 m_msg_to_send.push_back(std::move(
msg));
1186 std::vector<std::byte> ciphertext;
1198 void SendGarbageTerm()
1209 if (!m_sent_aad) aad = m_sent_garbage;
1210 SendPacket(version_data, aad, vers_ignore);
1219 std::vector<uint8_t> contents;
1229 contents.resize(size);
1250 void ReceiveGarbage()
1260 m_recv_garbage.assign(m_received.begin(), m_received.begin() + garblen);
1266 void ReceiveVersion()
1268 auto contents = ReceivePacket(
MakeByteSpan(m_recv_garbage));
1279 auto ret = ReceivePacket();
1289 auto ret = ReceivePacket();
1292 for (
unsigned i = 0; i < 12; ++i) {
1293 if (i < m_type.size()) {
1308 std::copy(mtype.begin(), mtype.end(),
reinterpret_cast<char*
>(contents.data() + 1));
1311 SendPacket(contents);
1319 std::vector<uint8_t> contents(1 + payload.
size());
1320 contents[0] = short_id;
1321 std::copy(payload.
begin(), payload.
end(), contents.begin() + 1);
1323 SendPacket(contents);
1327 void CompareSessionIDs()
const
1329 auto info = m_transport.
GetInfo();
1346 for (
int i = 0; i < 10; ++i) {
1347 V2TransportTester tester(
true);
1348 auto ret = tester.Interact();
1349 BOOST_REQUIRE(
ret &&
ret->empty());
1351 tester.SendGarbage();
1352 tester.ReceiveKey();
1353 tester.SendGarbageTerm();
1354 tester.SendVersion();
1355 ret = tester.Interact();
1356 BOOST_REQUIRE(
ret &&
ret->empty());
1357 tester.ReceiveGarbage();
1358 tester.ReceiveVersion();
1359 tester.CompareSessionIDs();
1362 tester.SendMessage(uint8_t(4), msg_data_1);
1363 tester.SendMessage(0, {});
1364 tester.SendMessage(
"tx", msg_data_2);
1365 ret = tester.Interact();
1366 BOOST_REQUIRE(
ret &&
ret->size() == 3);
1374 tester.SendMessage(
"bad", msg_data_1);
1377 ret = tester.Interact();
1382 tester.SendMessage(uint8_t(12), msg_data_3);
1387 for (
int i = 0; i < 10; ++i) {
1388 V2TransportTester tester(
false);
1390 tester.SendGarbage();
1391 auto ret = tester.Interact();
1392 BOOST_REQUIRE(
ret &&
ret->empty());
1393 tester.ReceiveKey();
1394 tester.SendGarbageTerm();
1395 tester.SendVersion();
1396 ret = tester.Interact();
1397 BOOST_REQUIRE(
ret &&
ret->empty());
1398 tester.ReceiveGarbage();
1399 tester.ReceiveVersion();
1400 tester.CompareSessionIDs();
1403 tester.SendMessage(uint8_t(14), msg_data_1);
1404 tester.SendMessage(uint8_t(19), msg_data_2);
1405 ret = tester.Interact();
1406 BOOST_REQUIRE(
ret &&
ret->size() == 2);
1412 tester.SendMessage(uint8_t(11), msg_data_3);
1413 ret = tester.Interact();
1418 for (
int i = 0; i < 50; ++i) {
1431 V2TransportTester tester(initiator);
1432 if (send_immediately) {
1434 tester.SendGarbage(garb_len);
1436 auto ret = tester.Interact();
1437 BOOST_REQUIRE(
ret &&
ret->empty());
1438 if (!send_immediately) {
1440 tester.SendGarbage(garb_len);
1442 tester.ReceiveKey();
1443 tester.SendGarbageTerm();
1444 for (
unsigned v = 0; v < num_ignore_version; ++v) {
1447 tester.SendVersion(ver_ign_data,
true);
1449 tester.SendVersion(ver_data,
false);
1450 ret = tester.Interact();
1451 BOOST_REQUIRE(
ret &&
ret->empty());
1452 tester.ReceiveGarbage();
1453 tester.ReceiveVersion();
1454 tester.CompareSessionIDs();
1455 for (
unsigned d = 0; d < num_decoys_1; ++d) {
1457 tester.SendPacket(decoy_data, {},
true);
1460 tester.SendMessage(uint8_t(28), msg_data_1);
1461 for (
unsigned d = 0; d < num_decoys_2; ++d) {
1463 tester.SendPacket(decoy_data, {},
true);
1466 tester.SendMessage(uint8_t(13), msg_data_2);
1469 tester.SendMessage(
"foobar", {});
1470 tester.AddMessage(
"barfoo", {});
1471 ret = tester.Interact();
1472 BOOST_REQUIRE(
ret &&
ret->size() == 4);
1477 tester.ReceiveMessage(
"barfoo", {});
1482 V2TransportTester tester(
true);
1483 auto ret = tester.Interact();
1484 BOOST_REQUIRE(
ret &&
ret->empty());
1487 tester.ReceiveKey();
1488 tester.SendGarbageTerm();
1489 ret = tester.Interact();
1495 V2TransportTester tester(
false);
1498 auto ret = tester.Interact();
1499 BOOST_REQUIRE(
ret &&
ret->empty());
1500 tester.ReceiveKey();
1501 tester.SendGarbageTerm();
1502 ret = tester.Interact();
1508 V2TransportTester tester(
true);
1509 auto ret = tester.Interact();
1510 BOOST_REQUIRE(
ret &&
ret->empty());
1512 tester.ReceiveKey();
1520 auto garb_term =
MakeUCharSpan(tester.GetCipher().GetSendGarbageTerminator());
1521 std::copy(garb_term.begin(), garb_term.begin() + 16, garbage.
begin() + len_before);
1525 tester.SendGarbage(garbage);
1526 tester.SendGarbageTerm();
1527 tester.SendVersion();
1528 ret = tester.Interact();
1529 BOOST_REQUIRE(
ret &&
ret->empty());
1530 tester.ReceiveGarbage();
1531 tester.ReceiveVersion();
1532 tester.CompareSessionIDs();
1536 tester.SendMessage(uint8_t(2), msg_data_1);
1537 tester.AddMessage(
"blocktxn", msg_data_2);
1538 ret = tester.Interact();
1539 BOOST_REQUIRE(
ret &&
ret->size() == 2);
1542 tester.ReceiveMessage(uint8_t(3), msg_data_2);
1547 V2TransportTester tester(
false);
1548 tester.SendV1Version(
Params().MessageStart());
1549 auto ret = tester.Interact();
1555 V2TransportTester tester(
false);
1557 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.
std::vector< B > randbytes(size_t len)
Generate random bytes.
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.
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::array< uint8_t, 4 > MessageStartChars
CSerializedNetMsg Make(std::string msg_type, Args &&... args)
const char * VERSION
The version message provides information about the transmitting node to the receiving node at the beg...
const char * VERACK
The verack message acknowledges a previously-received version message, informing the connecting node ...
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.
std::string ToString(const T &t)
Locale-independent version of std::to_string.
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 HexStr(const Span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
std::string ToLower(std::string_view str)
Returns the lowercase equivalent of the given string.