net_tests.cpp
1 // Copyright (c) 2012-present The Bitcoin Core developers 2 // Distributed under the MIT software license, see the accompanying 3 // file COPYING or http://www.opensource.org/licenses/mit-license.php. 4 5 #include <addrman.h> 6 #include <chainparams.h> 7 #include <clientversion.h> 8 #include <common/args.h> 9 #include <compat/compat.h> 10 #include <net.h> 11 #include <net_processing.h> 12 #include <netaddress.h> 13 #include <netbase.h> 14 #include <netmessagemaker.h> 15 #include <node/protocol_version.h> 16 #include <serialize.h> 17 #include <span.h> 18 #include <streams.h> 19 #include <test/util/common.h> 20 #include <test/util/net.h> 21 #include <test/util/random.h> 22 #include <test/util/setup_common.h> 23 #include <test/util/validation.h> 24 #include <util/strencodings.h> 25 #include <util/string.h> 26 #include <validation.h> 27 28 #include <boost/test/unit_test.hpp> 29 30 #include <algorithm> 31 #include <cstdint> 32 #include <ios> 33 #include <memory> 34 #include <optional> 35 #include <string> 36 37 using namespace std::literals; 38 using namespace util::hex_literals; 39 using util::ToString; 40 41 BOOST_FIXTURE_TEST_SUITE(net_tests, RegTestingSetup) 42 43 BOOST_AUTO_TEST_CASE(cnode_listen_port) 44 { 45 // test default 46 uint16_t port{GetListenPort()}; 47 BOOST_CHECK(port == Params().GetDefaultPort()); 48 // test set port 49 uint16_t altPort = 12345; 50 BOOST_CHECK(gArgs.SoftSetArg("-port", ToString(altPort))); 51 port = GetListenPort(); 52 BOOST_CHECK(port == altPort); 53 } 54 55 BOOST_AUTO_TEST_CASE(cnode_simple_test) 56 { 57 NodeId id = 0; 58 59 in_addr ipv4Addr; 60 ipv4Addr.s_addr = 0xa0b0c001; 61 62 CAddress addr = CAddress(CService(ipv4Addr, 7777), NODE_NETWORK); 63 std::string pszDest; 64 65 std::unique_ptr<CNode> pnode1 = std::make_unique<CNode>(id++, 66 /*sock=*/nullptr, 67 addr, 68 /*nKeyedNetGroupIn=*/0, 69 /*nLocalHostNonceIn=*/0, 70 CAddress(), 71 pszDest, 72 ConnectionType::OUTBOUND_FULL_RELAY, 73 /*inbound_onion=*/false, 74 /*network_key=*/0); 75 BOOST_CHECK(pnode1->IsFullOutboundConn() == true); 76 BOOST_CHECK(pnode1->IsManualConn() == false); 77 BOOST_CHECK(pnode1->IsBlockOnlyConn() == false); 78 BOOST_CHECK(pnode1->IsFeelerConn() == false); 79 BOOST_CHECK(pnode1->IsAddrFetchConn() == false); 80 BOOST_CHECK(pnode1->IsInboundConn() == false); 81 BOOST_CHECK(pnode1->m_inbound_onion == false); 82 BOOST_CHECK_EQUAL(pnode1->ConnectedThroughNetwork(), Network::NET_IPV4); 83 84 std::unique_ptr<CNode> pnode2 = std::make_unique<CNode>(id++, 85 /*sock=*/nullptr, 86 addr, 87 /*nKeyedNetGroupIn=*/1, 88 /*nLocalHostNonceIn=*/1, 89 CAddress(), 90 pszDest, 91 ConnectionType::INBOUND, 92 /*inbound_onion=*/false, 93 /*network_key=*/1); 94 BOOST_CHECK(pnode2->IsFullOutboundConn() == false); 95 BOOST_CHECK(pnode2->IsManualConn() == false); 96 BOOST_CHECK(pnode2->IsBlockOnlyConn() == false); 97 BOOST_CHECK(pnode2->IsFeelerConn() == false); 98 BOOST_CHECK(pnode2->IsAddrFetchConn() == false); 99 BOOST_CHECK(pnode2->IsInboundConn() == true); 100 BOOST_CHECK(pnode2->m_inbound_onion == false); 101 BOOST_CHECK_EQUAL(pnode2->ConnectedThroughNetwork(), Network::NET_IPV4); 102 103 std::unique_ptr<CNode> pnode3 = std::make_unique<CNode>(id++, 104 /*sock=*/nullptr, 105 addr, 106 /*nKeyedNetGroupIn=*/0, 107 /*nLocalHostNonceIn=*/0, 108 CAddress(), 109 pszDest, 110 ConnectionType::OUTBOUND_FULL_RELAY, 111 /*inbound_onion=*/false, 112 /*network_key=*/2); 113 BOOST_CHECK(pnode3->IsFullOutboundConn() == true); 114 BOOST_CHECK(pnode3->IsManualConn() == false); 115 BOOST_CHECK(pnode3->IsBlockOnlyConn() == false); 116 BOOST_CHECK(pnode3->IsFeelerConn() == false); 117 BOOST_CHECK(pnode3->IsAddrFetchConn() == false); 118 BOOST_CHECK(pnode3->IsInboundConn() == false); 119 BOOST_CHECK(pnode3->m_inbound_onion == false); 120 BOOST_CHECK_EQUAL(pnode3->ConnectedThroughNetwork(), Network::NET_IPV4); 121 122 std::unique_ptr<CNode> pnode4 = std::make_unique<CNode>(id++, 123 /*sock=*/nullptr, 124 addr, 125 /*nKeyedNetGroupIn=*/1, 126 /*nLocalHostNonceIn=*/1, 127 CAddress(), 128 pszDest, 129 ConnectionType::INBOUND, 130 /*inbound_onion=*/true, 131 /*network_key=*/3); 132 BOOST_CHECK(pnode4->IsFullOutboundConn() == false); 133 BOOST_CHECK(pnode4->IsManualConn() == false); 134 BOOST_CHECK(pnode4->IsBlockOnlyConn() == false); 135 BOOST_CHECK(pnode4->IsFeelerConn() == false); 136 BOOST_CHECK(pnode4->IsAddrFetchConn() == false); 137 BOOST_CHECK(pnode4->IsInboundConn() == true); 138 BOOST_CHECK(pnode4->m_inbound_onion == true); 139 BOOST_CHECK_EQUAL(pnode4->ConnectedThroughNetwork(), Network::NET_ONION); 140 } 141 142 BOOST_AUTO_TEST_CASE(cnetaddr_basic) 143 { 144 CNetAddr addr; 145 146 // IPv4, INADDR_ANY 147 addr = LookupHost("0.0.0.0", false).value(); 148 BOOST_REQUIRE(!addr.IsValid()); 149 BOOST_REQUIRE(addr.IsIPv4()); 150 151 BOOST_CHECK(addr.IsBindAny()); 152 BOOST_CHECK(addr.IsAddrV1Compatible()); 153 BOOST_CHECK_EQUAL(addr.ToStringAddr(), "0.0.0.0"); 154 155 // IPv4, INADDR_NONE 156 addr = LookupHost("255.255.255.255", false).value(); 157 BOOST_REQUIRE(!addr.IsValid()); 158 BOOST_REQUIRE(addr.IsIPv4()); 159 160 BOOST_CHECK(!addr.IsBindAny()); 161 BOOST_CHECK(addr.IsAddrV1Compatible()); 162 BOOST_CHECK_EQUAL(addr.ToStringAddr(), "255.255.255.255"); 163 164 // IPv4, casual 165 addr = LookupHost("12.34.56.78", false).value(); 166 BOOST_REQUIRE(addr.IsValid()); 167 BOOST_REQUIRE(addr.IsIPv4()); 168 169 BOOST_CHECK(!addr.IsBindAny()); 170 BOOST_CHECK(addr.IsAddrV1Compatible()); 171 BOOST_CHECK_EQUAL(addr.ToStringAddr(), "12.34.56.78"); 172 173 // IPv6, in6addr_any 174 addr = LookupHost("::", false).value(); 175 BOOST_REQUIRE(!addr.IsValid()); 176 BOOST_REQUIRE(addr.IsIPv6()); 177 178 BOOST_CHECK(addr.IsBindAny()); 179 BOOST_CHECK(addr.IsAddrV1Compatible()); 180 BOOST_CHECK_EQUAL(addr.ToStringAddr(), "::"); 181 182 // IPv6, casual 183 addr = LookupHost("1122:3344:5566:7788:9900:aabb:ccdd:eeff", false).value(); 184 BOOST_REQUIRE(addr.IsValid()); 185 BOOST_REQUIRE(addr.IsIPv6()); 186 187 BOOST_CHECK(!addr.IsBindAny()); 188 BOOST_CHECK(addr.IsAddrV1Compatible()); 189 BOOST_CHECK_EQUAL(addr.ToStringAddr(), "1122:3344:5566:7788:9900:aabb:ccdd:eeff"); 190 191 // IPv6, scoped/link-local. See https://tools.ietf.org/html/rfc4007 192 // We support non-negative decimal integers (uint32_t) as zone id indices. 193 // Normal link-local scoped address functionality is to append "%" plus the 194 // zone id, for example, given a link-local address of "fe80::1" and a zone 195 // id of "32", return the address as "fe80::1%32". 196 const std::string link_local{"fe80::1"}; 197 const std::string scoped_addr{link_local + "%32"}; 198 addr = LookupHost(scoped_addr, false).value(); 199 BOOST_REQUIRE(addr.IsValid()); 200 BOOST_REQUIRE(addr.IsIPv6()); 201 BOOST_CHECK(!addr.IsBindAny()); 202 BOOST_CHECK_EQUAL(addr.ToStringAddr(), scoped_addr); 203 204 // TORv2, no longer supported 205 BOOST_CHECK(!addr.SetSpecial("6hzph5hv6337r6p2.onion")); 206 207 // TORv3 208 const char* torv3_addr = "pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion"; 209 BOOST_REQUIRE(addr.SetSpecial(torv3_addr)); 210 BOOST_REQUIRE(addr.IsValid()); 211 BOOST_REQUIRE(addr.IsTor()); 212 213 BOOST_CHECK(!addr.IsI2P()); 214 BOOST_CHECK(!addr.IsBindAny()); 215 BOOST_CHECK(!addr.IsAddrV1Compatible()); 216 BOOST_CHECK_EQUAL(addr.ToStringAddr(), torv3_addr); 217 218 // TORv3, broken, with wrong checksum 219 BOOST_CHECK(!addr.SetSpecial("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscsad.onion")); 220 221 // TORv3, broken, with wrong version 222 BOOST_CHECK(!addr.SetSpecial("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscrye.onion")); 223 224 // TORv3, malicious 225 BOOST_CHECK(!addr.SetSpecial(std::string{ 226 "pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd\0wtf.onion", 66})); 227 228 // TOR, bogus length 229 BOOST_CHECK(!addr.SetSpecial(std::string{"mfrggzak.onion"})); 230 231 // TOR, invalid base32 232 BOOST_CHECK(!addr.SetSpecial(std::string{"mf*g zak.onion"})); 233 234 // I2P 235 const char* i2p_addr = "UDHDrtrcetjm5sxzskjyr5ztpeszydbh4dpl3pl4utgqqw2v4jna.b32.I2P"; 236 BOOST_REQUIRE(addr.SetSpecial(i2p_addr)); 237 BOOST_REQUIRE(addr.IsValid()); 238 BOOST_REQUIRE(addr.IsI2P()); 239 240 BOOST_CHECK(!addr.IsTor()); 241 BOOST_CHECK(!addr.IsBindAny()); 242 BOOST_CHECK(!addr.IsAddrV1Compatible()); 243 BOOST_CHECK_EQUAL(addr.ToStringAddr(), ToLower(i2p_addr)); 244 245 // I2P, correct length, but decodes to less than the expected number of bytes. 246 BOOST_CHECK(!addr.SetSpecial("udhdrtrcetjm5sxzskjyr5ztpeszydbh4dpl3pl4utgqqw2v4jn=.b32.i2p")); 247 248 // I2P, extra unnecessary padding 249 BOOST_CHECK(!addr.SetSpecial("udhdrtrcetjm5sxzskjyr5ztpeszydbh4dpl3pl4utgqqw2v4jna=.b32.i2p")); 250 251 // I2P, malicious 252 BOOST_CHECK(!addr.SetSpecial("udhdrtrcetjm5sxzskjyr5ztpeszydbh4dpl3pl4utgqqw2v\0wtf.b32.i2p"s)); 253 254 // I2P, valid but unsupported (56 Base32 characters) 255 // See "Encrypted LS with Base 32 Addresses" in 256 // https://geti2p.net/spec/encryptedleaseset.txt 257 BOOST_CHECK( 258 !addr.SetSpecial("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscsad.b32.i2p")); 259 260 // I2P, invalid base32 261 BOOST_CHECK(!addr.SetSpecial(std::string{"tp*szydbh4dp.b32.i2p"})); 262 263 // Internal 264 addr.SetInternal("esffpp"); 265 BOOST_REQUIRE(!addr.IsValid()); // "internal" is considered invalid 266 BOOST_REQUIRE(addr.IsInternal()); 267 268 BOOST_CHECK(!addr.IsBindAny()); 269 BOOST_CHECK(addr.IsAddrV1Compatible()); 270 BOOST_CHECK_EQUAL(addr.ToStringAddr(), "esffpvrt3wpeaygy.internal"); 271 272 // Totally bogus 273 BOOST_CHECK(!addr.SetSpecial("totally bogus")); 274 } 275 276 BOOST_AUTO_TEST_CASE(cnetaddr_tostring_canonical_ipv6) 277 { 278 // Test that CNetAddr::ToString formats IPv6 addresses with zero compression as described in 279 // RFC 5952 ("A Recommendation for IPv6 Address Text Representation"). 280 const std::map<std::string, std::string> canonical_representations_ipv6{ 281 {"0000:0000:0000:0000:0000:0000:0000:0000", "::"}, 282 {"000:0000:000:00:0:00:000:0000", "::"}, 283 {"000:000:000:000:000:000:000:000", "::"}, 284 {"00:00:00:00:00:00:00:00", "::"}, 285 {"0:0:0:0:0:0:0:0", "::"}, 286 {"0:0:0:0:0:0:0:1", "::1"}, 287 {"2001:0:0:1:0:0:0:1", "2001:0:0:1::1"}, 288 {"2001:0db8:0:0:1:0:0:1", "2001:db8::1:0:0:1"}, 289 {"2001:0db8:85a3:0000:0000:8a2e:0370:7334", "2001:db8:85a3::8a2e:370:7334"}, 290 {"2001:0db8::0001", "2001:db8::1"}, 291 {"2001:0db8::0001:0000", "2001:db8::1:0"}, 292 {"2001:0db8::1:0:0:1", "2001:db8::1:0:0:1"}, 293 {"2001:db8:0000:0:1::1", "2001:db8::1:0:0:1"}, 294 {"2001:db8:0000:1:1:1:1:1", "2001:db8:0:1:1:1:1:1"}, 295 {"2001:db8:0:0:0:0:2:1", "2001:db8::2:1"}, 296 {"2001:db8:0:0:0::1", "2001:db8::1"}, 297 {"2001:db8:0:0:1:0:0: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::1", "2001:db8::1:0:0:1"}, 300 {"2001:db8:0:0::1", "2001:db8::1"}, 301 {"2001:db8:0:0:aaaa::1", "2001:db8::aaaa:0:0:1"}, 302 {"2001:db8:0:1:1:1:1:1", "2001:db8:0:1:1:1:1:1"}, 303 {"2001:db8:0::1", "2001:db8::1"}, 304 {"2001:db8:85a3:0:0:8a2e:370:7334", "2001:db8:85a3::8a2e:370:7334"}, 305 {"2001:db8::0:1", "2001:db8::1"}, 306 {"2001:db8::0:1:0:0:1", "2001:db8::1:0:0:1"}, 307 {"2001:DB8::1", "2001:db8::1"}, 308 {"2001:db8::1", "2001:db8::1"}, 309 {"2001:db8::1:0:0:1", "2001:db8::1:0:0:1"}, 310 {"2001:db8::1:1:1:1:1", "2001:db8:0:1:1:1:1:1"}, 311 {"2001:db8::aaaa:0:0:1", "2001:db8::aaaa:0:0:1"}, 312 {"2001:db8:aaaa:bbbb:cccc:dddd:0:1", "2001:db8:aaaa:bbbb:cccc:dddd:0:1"}, 313 {"2001:db8:aaaa:bbbb:cccc:dddd::1", "2001:db8:aaaa:bbbb:cccc:dddd:0:1"}, 314 {"2001:db8:aaaa:bbbb:cccc:dddd:eeee:0001", "2001:db8:aaaa:bbbb:cccc:dddd:eeee:1"}, 315 {"2001:db8:aaaa:bbbb:cccc:dddd:eeee:001", "2001:db8:aaaa:bbbb:cccc:dddd:eeee:1"}, 316 {"2001:db8:aaaa:bbbb:cccc:dddd:eeee:01", "2001:db8:aaaa:bbbb:cccc:dddd:eeee:1"}, 317 {"2001:db8:aaaa:bbbb:cccc:dddd:eeee:1", "2001:db8:aaaa:bbbb:cccc:dddd:eeee:1"}, 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"}, 320 {"2001:db8:aaaa:bbbb:cccc:dddd:eeee:AaAa", "2001:db8:aaaa:bbbb:cccc:dddd:eeee:aaaa"}, 321 }; 322 for (const auto& [input_address, expected_canonical_representation_output] : canonical_representations_ipv6) { 323 const std::optional<CNetAddr> net_addr{LookupHost(input_address, false)}; 324 BOOST_REQUIRE(net_addr.value().IsIPv6()); 325 BOOST_CHECK_EQUAL(net_addr.value().ToStringAddr(), expected_canonical_representation_output); 326 } 327 } 328 329 BOOST_AUTO_TEST_CASE(cnetaddr_serialize_v1) 330 { 331 CNetAddr addr; 332 DataStream s{}; 333 const auto ser_params{CAddress::V1_NETWORK}; 334 335 s << ser_params(addr); 336 BOOST_CHECK_EQUAL(HexStr(s), "00000000000000000000000000000000"); 337 s.clear(); 338 339 addr = LookupHost("1.2.3.4", false).value(); 340 s << ser_params(addr); 341 BOOST_CHECK_EQUAL(HexStr(s), "00000000000000000000ffff01020304"); 342 s.clear(); 343 344 addr = LookupHost("1a1b:2a2b:3a3b:4a4b:5a5b:6a6b:7a7b:8a8b", false).value(); 345 s << ser_params(addr); 346 BOOST_CHECK_EQUAL(HexStr(s), "1a1b2a2b3a3b4a4b5a5b6a6b7a7b8a8b"); 347 s.clear(); 348 349 // TORv2, no longer supported 350 BOOST_CHECK(!addr.SetSpecial("6hzph5hv6337r6p2.onion")); 351 352 BOOST_REQUIRE(addr.SetSpecial("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion")); 353 s << ser_params(addr); 354 BOOST_CHECK_EQUAL(HexStr(s), "00000000000000000000000000000000"); 355 s.clear(); 356 357 addr.SetInternal("a"); 358 s << ser_params(addr); 359 BOOST_CHECK_EQUAL(HexStr(s), "fd6b88c08724ca978112ca1bbdcafac2"); 360 s.clear(); 361 } 362 363 BOOST_AUTO_TEST_CASE(cnetaddr_serialize_v2) 364 { 365 CNetAddr addr; 366 DataStream s{}; 367 const auto ser_params{CAddress::V2_NETWORK}; 368 369 s << ser_params(addr); 370 BOOST_CHECK_EQUAL(HexStr(s), "021000000000000000000000000000000000"); 371 s.clear(); 372 373 addr = LookupHost("1.2.3.4", false).value(); 374 s << ser_params(addr); 375 BOOST_CHECK_EQUAL(HexStr(s), "010401020304"); 376 s.clear(); 377 378 addr = LookupHost("1a1b:2a2b:3a3b:4a4b:5a5b:6a6b:7a7b:8a8b", false).value(); 379 s << ser_params(addr); 380 BOOST_CHECK_EQUAL(HexStr(s), "02101a1b2a2b3a3b4a4b5a5b6a6b7a7b8a8b"); 381 s.clear(); 382 383 // TORv2, no longer supported 384 BOOST_CHECK(!addr.SetSpecial("6hzph5hv6337r6p2.onion")); 385 386 BOOST_REQUIRE(addr.SetSpecial("kpgvmscirrdqpekbqjsvw5teanhatztpp2gl6eee4zkowvwfxwenqaid.onion")); 387 s << ser_params(addr); 388 BOOST_CHECK_EQUAL(HexStr(s), "042053cd5648488c4707914182655b7664034e09e66f7e8cbf1084e654eb56c5bd88"); 389 s.clear(); 390 391 BOOST_REQUIRE(addr.SetInternal("a")); 392 s << ser_params(addr); 393 BOOST_CHECK_EQUAL(HexStr(s), "0210fd6b88c08724ca978112ca1bbdcafac2"); 394 s.clear(); 395 } 396 397 BOOST_AUTO_TEST_CASE(cnetaddr_unserialize_v2) 398 { 399 CNetAddr addr; 400 DataStream s{}; 401 const auto ser_params{CAddress::V2_NETWORK}; 402 403 // Valid IPv4. 404 s << "01" // network type (IPv4) 405 "04" // address length 406 "01020304"_hex; // address 407 s >> ser_params(addr); 408 BOOST_CHECK(addr.IsValid()); 409 BOOST_CHECK(addr.IsIPv4()); 410 BOOST_CHECK(addr.IsAddrV1Compatible()); 411 BOOST_CHECK_EQUAL(addr.ToStringAddr(), "1.2.3.4"); 412 BOOST_REQUIRE(s.empty()); 413 414 // Invalid IPv4, valid length but address itself is shorter. 415 s << "01" // network type (IPv4) 416 "04" // address length 417 "0102"_hex; // address 418 BOOST_CHECK_EXCEPTION(s >> ser_params(addr), std::ios_base::failure, HasReason("end of data")); 419 BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input. 420 s.clear(); 421 422 // Invalid IPv4, with bogus length. 423 s << "01" // network type (IPv4) 424 "05" // address length 425 "01020304"_hex; // address 426 BOOST_CHECK_EXCEPTION(s >> ser_params(addr), std::ios_base::failure, 427 HasReason("BIP155 IPv4 address with length 5 (should be 4)")); 428 BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input. 429 s.clear(); 430 431 // Invalid IPv4, with extreme length. 432 s << "01" // network type (IPv4) 433 "fd0102" // address length (513 as CompactSize) 434 "01020304"_hex; // address 435 BOOST_CHECK_EXCEPTION(s >> ser_params(addr), std::ios_base::failure, 436 HasReason("Address too long: 513 > 512")); 437 BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input. 438 s.clear(); 439 440 // Valid IPv6. 441 s << "02" // network type (IPv6) 442 "10" // address length 443 "0102030405060708090a0b0c0d0e0f10"_hex; // address 444 s >> ser_params(addr); 445 BOOST_CHECK(addr.IsValid()); 446 BOOST_CHECK(addr.IsIPv6()); 447 BOOST_CHECK(addr.IsAddrV1Compatible()); 448 BOOST_CHECK_EQUAL(addr.ToStringAddr(), "102:304:506:708:90a:b0c:d0e:f10"); 449 BOOST_REQUIRE(s.empty()); 450 451 // Valid IPv6, contains embedded "internal". 452 s << "02" // network type (IPv6) 453 "10" // address length 454 "fd6b88c08724ca978112ca1bbdcafac2"_hex; // address: 0xfd + sha256("bitcoin")[0:5] + 455 // sha256(name)[0:10] 456 s >> ser_params(addr); 457 BOOST_CHECK(addr.IsInternal()); 458 BOOST_CHECK(addr.IsAddrV1Compatible()); 459 BOOST_CHECK_EQUAL(addr.ToStringAddr(), "zklycewkdo64v6wc.internal"); 460 BOOST_REQUIRE(s.empty()); 461 462 // Invalid IPv6, with bogus length. 463 s << "02" // network type (IPv6) 464 "04" // address length 465 "00"_hex; // address 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()); // The stream is not consumed on invalid input. 469 s.clear(); 470 471 // Invalid IPv6, contains embedded IPv4. 472 s << "02" // network type (IPv6) 473 "10" // address length 474 "00000000000000000000ffff01020304"_hex; // address 475 s >> ser_params(addr); 476 BOOST_CHECK(!addr.IsValid()); 477 BOOST_REQUIRE(s.empty()); 478 479 // Invalid IPv6, contains embedded TORv2. 480 s << "02" // network type (IPv6) 481 "10" // address length 482 "fd87d87eeb430102030405060708090a"_hex; // address 483 s >> ser_params(addr); 484 BOOST_CHECK(!addr.IsValid()); 485 BOOST_REQUIRE(s.empty()); 486 487 // TORv2, no longer supported. 488 s << "03" // network type (TORv2) 489 "0a" // address length 490 "f1f2f3f4f5f6f7f8f9fa"_hex; // address 491 s >> ser_params(addr); 492 BOOST_CHECK(!addr.IsValid()); 493 BOOST_REQUIRE(s.empty()); 494 495 // Valid TORv3. 496 s << "04" // network type (TORv3) 497 "20" // address length 498 "79bcc625184b05194975c28b66b66b04" // address 499 "69f7f6556fb1ac3189a79b40dda32f1f"_hex; 500 s >> ser_params(addr); 501 BOOST_CHECK(addr.IsValid()); 502 BOOST_CHECK(addr.IsTor()); 503 BOOST_CHECK(!addr.IsAddrV1Compatible()); 504 BOOST_CHECK_EQUAL(addr.ToStringAddr(), 505 "pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion"); 506 BOOST_REQUIRE(s.empty()); 507 508 // Invalid TORv3, with bogus length. 509 s << "04" // network type (TORv3) 510 "00" // address length 511 "00"_hex; // address 512 BOOST_CHECK_EXCEPTION(s >> ser_params(addr), std::ios_base::failure, 513 HasReason("BIP155 TORv3 address with length 0 (should be 32)")); 514 BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input. 515 s.clear(); 516 517 // Valid I2P. 518 s << "05" // network type (I2P) 519 "20" // address length 520 "a2894dabaec08c0051a481a6dac88b64" // address 521 "f98232ae42d4b6fd2fa81952dfe36a87"_hex; 522 s >> ser_params(addr); 523 BOOST_CHECK(addr.IsValid()); 524 BOOST_CHECK(addr.IsI2P()); 525 BOOST_CHECK(!addr.IsAddrV1Compatible()); 526 BOOST_CHECK_EQUAL(addr.ToStringAddr(), 527 "ukeu3k5oycgaauneqgtnvselmt4yemvoilkln7jpvamvfx7dnkdq.b32.i2p"); 528 BOOST_REQUIRE(s.empty()); 529 530 // Invalid I2P, with bogus length. 531 s << "05" // network type (I2P) 532 "03" // address length 533 "00"_hex; // address 534 BOOST_CHECK_EXCEPTION(s >> ser_params(addr), std::ios_base::failure, 535 HasReason("BIP155 I2P address with length 3 (should be 32)")); 536 BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input. 537 s.clear(); 538 539 // Valid CJDNS. 540 s << "06" // network type (CJDNS) 541 "10" // address length 542 "fc000001000200030004000500060007"_hex; // address 543 s >> ser_params(addr); 544 BOOST_CHECK(addr.IsValid()); 545 BOOST_CHECK(addr.IsCJDNS()); 546 BOOST_CHECK(!addr.IsAddrV1Compatible()); 547 BOOST_CHECK_EQUAL(addr.ToStringAddr(), "fc00:1:2:3:4:5:6:7"); 548 BOOST_REQUIRE(s.empty()); 549 550 // Invalid CJDNS, wrong prefix. 551 s << "06" // network type (CJDNS) 552 "10" // address length 553 "aa000001000200030004000500060007"_hex; // address 554 s >> ser_params(addr); 555 BOOST_CHECK(addr.IsCJDNS()); 556 BOOST_CHECK(!addr.IsValid()); 557 BOOST_REQUIRE(s.empty()); 558 559 // Invalid CJDNS, with bogus length. 560 s << "06" // network type (CJDNS) 561 "01" // address length 562 "00"_hex; // address 563 BOOST_CHECK_EXCEPTION(s >> ser_params(addr), std::ios_base::failure, 564 HasReason("BIP155 CJDNS address with length 1 (should be 16)")); 565 BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input. 566 s.clear(); 567 568 // Unknown, with extreme length. 569 s << "aa" // network type (unknown) 570 "fe00000002" // address length (CompactSize's MAX_SIZE) 571 "01020304050607"_hex; // address 572 BOOST_CHECK_EXCEPTION(s >> ser_params(addr), std::ios_base::failure, 573 HasReason("Address too long: 33554432 > 512")); 574 BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input. 575 s.clear(); 576 577 // Unknown, with reasonable length. 578 s << "aa" // network type (unknown) 579 "04" // address length 580 "01020304"_hex; // address 581 s >> ser_params(addr); 582 BOOST_CHECK(!addr.IsValid()); 583 BOOST_REQUIRE(s.empty()); 584 585 // Unknown, with zero length. 586 s << "aa" // network type (unknown) 587 "00" // address length 588 ""_hex; // address 589 s >> ser_params(addr); 590 BOOST_CHECK(!addr.IsValid()); 591 BOOST_REQUIRE(s.empty()); 592 } 593 594 // prior to PR #14728, this test triggers an undefined behavior 595 BOOST_AUTO_TEST_CASE(ipv4_peer_with_ipv6_addrMe_test) 596 { 597 // set up local addresses; all that's necessary to reproduce the bug is 598 // that a normal IPv4 address is among the entries, but if this address is 599 // !IsRoutable the undefined behavior is easier to trigger deterministically 600 in_addr raw_addr; 601 raw_addr.s_addr = htonl(0x7f000001); 602 const CNetAddr mapLocalHost_entry = CNetAddr(raw_addr); 603 { 604 LOCK(g_maplocalhost_mutex); 605 LocalServiceInfo lsi; 606 lsi.nScore = 23; 607 lsi.nPort = 42; 608 mapLocalHost[mapLocalHost_entry] = lsi; 609 } 610 611 // create a peer with an IPv4 address 612 in_addr ipv4AddrPeer; 613 ipv4AddrPeer.s_addr = 0xa0b0c001; 614 CAddress addr = CAddress(CService(ipv4AddrPeer, 7777), NODE_NETWORK); 615 std::unique_ptr<CNode> pnode = std::make_unique<CNode>(/*id=*/0, 616 /*sock=*/nullptr, 617 addr, 618 /*nKeyedNetGroupIn=*/0, 619 /*nLocalHostNonceIn=*/0, 620 CAddress{}, 621 /*pszDest=*/std::string{}, 622 ConnectionType::OUTBOUND_FULL_RELAY, 623 /*inbound_onion=*/false, 624 /*network_key=*/0); 625 pnode->fSuccessfullyConnected.store(true); 626 627 // the peer claims to be reaching us via IPv6 628 in6_addr ipv6AddrLocal; 629 memset(ipv6AddrLocal.s6_addr, 0, 16); 630 ipv6AddrLocal.s6_addr[0] = 0xcc; 631 CAddress addrLocal = CAddress(CService(ipv6AddrLocal, 7777), NODE_NETWORK); 632 pnode->SetAddrLocal(addrLocal); 633 634 // before patch, this causes undefined behavior detectable with clang's -fsanitize=memory 635 GetLocalAddrForPeer(*pnode); 636 637 // suppress no-checks-run warning; if this test fails, it's by triggering a sanitizer 638 BOOST_CHECK(1); 639 640 // Cleanup, so that we don't confuse other tests. 641 { 642 LOCK(g_maplocalhost_mutex); 643 mapLocalHost.erase(mapLocalHost_entry); 644 } 645 } 646 647 BOOST_AUTO_TEST_CASE(get_local_addr_for_peer_port) 648 { 649 // Test that GetLocalAddrForPeer() properly selects the address to self-advertise: 650 // 651 // 1. GetLocalAddrForPeer() calls GetLocalAddress() which returns an address that is 652 // not routable. 653 // 2. GetLocalAddrForPeer() overrides the address with whatever the peer has told us 654 // he sees us as. 655 // 2.1. For inbound connections we must override both the address and the port. 656 // 2.2. For outbound connections we must override only the address. 657 658 // Pretend that we bound to this port. 659 const uint16_t bind_port = 20001; 660 m_node.args->ForceSetArg("-bind", strprintf("3.4.5.6:%u", bind_port)); 661 662 // Our address:port as seen from the peer, completely different from the above. 663 in_addr peer_us_addr; 664 peer_us_addr.s_addr = htonl(0x02030405); 665 const CService peer_us{peer_us_addr, 20002}; 666 667 // Create a peer with a routable IPv4 address (outbound). 668 in_addr peer_out_in_addr; 669 peer_out_in_addr.s_addr = htonl(0x01020304); 670 CNode peer_out{/*id=*/0, 671 /*sock=*/nullptr, 672 /*addrIn=*/CAddress{CService{peer_out_in_addr, 8333}, NODE_NETWORK}, 673 /*nKeyedNetGroupIn=*/0, 674 /*nLocalHostNonceIn=*/0, 675 /*addrBindIn=*/CService{}, 676 /*addrNameIn=*/std::string{}, 677 /*conn_type_in=*/ConnectionType::OUTBOUND_FULL_RELAY, 678 /*inbound_onion=*/false, 679 /*network_key=*/0}; 680 peer_out.fSuccessfullyConnected = true; 681 peer_out.SetAddrLocal(peer_us); 682 683 // Without the fix peer_us:8333 is chosen instead of the proper peer_us:bind_port. 684 auto chosen_local_addr = GetLocalAddrForPeer(peer_out); 685 BOOST_REQUIRE(chosen_local_addr); 686 const CService expected{peer_us_addr, bind_port}; 687 BOOST_CHECK(*chosen_local_addr == expected); 688 689 // Create a peer with a routable IPv4 address (inbound). 690 in_addr peer_in_in_addr; 691 peer_in_in_addr.s_addr = htonl(0x05060708); 692 CNode peer_in{/*id=*/0, 693 /*sock=*/nullptr, 694 /*addrIn=*/CAddress{CService{peer_in_in_addr, 8333}, NODE_NETWORK}, 695 /*nKeyedNetGroupIn=*/0, 696 /*nLocalHostNonceIn=*/0, 697 /*addrBindIn=*/CService{}, 698 /*addrNameIn=*/std::string{}, 699 /*conn_type_in=*/ConnectionType::INBOUND, 700 /*inbound_onion=*/false, 701 /*network_key=*/1}; 702 peer_in.fSuccessfullyConnected = true; 703 peer_in.SetAddrLocal(peer_us); 704 705 // Without the fix peer_us:8333 is chosen instead of the proper peer_us:peer_us.GetPort(). 706 chosen_local_addr = GetLocalAddrForPeer(peer_in); 707 BOOST_REQUIRE(chosen_local_addr); 708 BOOST_CHECK(*chosen_local_addr == peer_us); 709 710 m_node.args->ForceSetArg("-bind", ""); 711 } 712 713 BOOST_AUTO_TEST_CASE(LimitedAndReachable_Network) 714 { 715 BOOST_CHECK(g_reachable_nets.Contains(NET_IPV4)); 716 BOOST_CHECK(g_reachable_nets.Contains(NET_IPV6)); 717 BOOST_CHECK(g_reachable_nets.Contains(NET_ONION)); 718 BOOST_CHECK(g_reachable_nets.Contains(NET_I2P)); 719 BOOST_CHECK(g_reachable_nets.Contains(NET_CJDNS)); 720 721 g_reachable_nets.Remove(NET_IPV4); 722 g_reachable_nets.Remove(NET_IPV6); 723 g_reachable_nets.Remove(NET_ONION); 724 g_reachable_nets.Remove(NET_I2P); 725 g_reachable_nets.Remove(NET_CJDNS); 726 727 BOOST_CHECK(!g_reachable_nets.Contains(NET_IPV4)); 728 BOOST_CHECK(!g_reachable_nets.Contains(NET_IPV6)); 729 BOOST_CHECK(!g_reachable_nets.Contains(NET_ONION)); 730 BOOST_CHECK(!g_reachable_nets.Contains(NET_I2P)); 731 BOOST_CHECK(!g_reachable_nets.Contains(NET_CJDNS)); 732 733 g_reachable_nets.Add(NET_IPV4); 734 g_reachable_nets.Add(NET_IPV6); 735 g_reachable_nets.Add(NET_ONION); 736 g_reachable_nets.Add(NET_I2P); 737 g_reachable_nets.Add(NET_CJDNS); 738 739 BOOST_CHECK(g_reachable_nets.Contains(NET_IPV4)); 740 BOOST_CHECK(g_reachable_nets.Contains(NET_IPV6)); 741 BOOST_CHECK(g_reachable_nets.Contains(NET_ONION)); 742 BOOST_CHECK(g_reachable_nets.Contains(NET_I2P)); 743 BOOST_CHECK(g_reachable_nets.Contains(NET_CJDNS)); 744 } 745 746 BOOST_AUTO_TEST_CASE(LimitedAndReachable_NetworkCaseUnroutableAndInternal) 747 { 748 // Should be reachable by default. 749 BOOST_CHECK(g_reachable_nets.Contains(NET_UNROUTABLE)); 750 BOOST_CHECK(g_reachable_nets.Contains(NET_INTERNAL)); 751 752 g_reachable_nets.RemoveAll(); 753 754 BOOST_CHECK(!g_reachable_nets.Contains(NET_UNROUTABLE)); 755 BOOST_CHECK(!g_reachable_nets.Contains(NET_INTERNAL)); 756 757 g_reachable_nets.Add(NET_IPV4); 758 g_reachable_nets.Add(NET_IPV6); 759 g_reachable_nets.Add(NET_ONION); 760 g_reachable_nets.Add(NET_I2P); 761 g_reachable_nets.Add(NET_CJDNS); 762 g_reachable_nets.Add(NET_UNROUTABLE); 763 g_reachable_nets.Add(NET_INTERNAL); 764 } 765 766 CNetAddr UtilBuildAddress(unsigned char p1, unsigned char p2, unsigned char p3, unsigned char p4) 767 { 768 unsigned char ip[] = {p1, p2, p3, p4}; 769 770 struct sockaddr_in sa; 771 memset(&sa, 0, sizeof(sockaddr_in)); // initialize the memory block 772 memcpy(&(sa.sin_addr), &ip, sizeof(ip)); 773 return CNetAddr(sa.sin_addr); 774 } 775 776 777 BOOST_AUTO_TEST_CASE(LimitedAndReachable_CNetAddr) 778 { 779 CNetAddr addr = UtilBuildAddress(0x001, 0x001, 0x001, 0x001); // 1.1.1.1 780 781 g_reachable_nets.Add(NET_IPV4); 782 BOOST_CHECK(g_reachable_nets.Contains(addr)); 783 784 g_reachable_nets.Remove(NET_IPV4); 785 BOOST_CHECK(!g_reachable_nets.Contains(addr)); 786 787 g_reachable_nets.Add(NET_IPV4); // have to reset this, because this is stateful. 788 } 789 790 791 BOOST_AUTO_TEST_CASE(LocalAddress_BasicLifecycle) 792 { 793 CService addr = CService(UtilBuildAddress(0x002, 0x001, 0x001, 0x001), 1000); // 2.1.1.1:1000 794 795 g_reachable_nets.Add(NET_IPV4); 796 797 BOOST_CHECK(!IsLocal(addr)); 798 BOOST_CHECK(AddLocal(addr, 1000)); 799 BOOST_CHECK(IsLocal(addr)); 800 801 RemoveLocal(addr); 802 BOOST_CHECK(!IsLocal(addr)); 803 } 804 805 BOOST_AUTO_TEST_CASE(initial_advertise_from_version_message) 806 { 807 LOCK(NetEventsInterface::g_msgproc_mutex); 808 auto& connman{static_cast<ConnmanTestMsg&>(*m_node.connman)}; 809 810 // Tests the following scenario: 811 // * -bind=3.4.5.6:20001 is specified 812 // * we make an outbound connection to a peer 813 // * the peer reports he sees us as 2.3.4.5:20002 in the version message 814 // (20002 is a random port assigned by our OS for the outgoing TCP connection, 815 // we cannot accept connections to it) 816 // * we should self-advertise to that peer as 2.3.4.5:20001 817 818 // Pretend that we bound to this port. 819 const uint16_t bind_port = 20001; 820 m_node.args->ForceSetArg("-bind", strprintf("3.4.5.6:%u", bind_port)); 821 m_node.connman->SetCaptureMessages(true); 822 823 // Our address:port as seen from the peer - 2.3.4.5:20002 (different from the above). 824 in_addr peer_us_addr; 825 peer_us_addr.s_addr = htonl(0x02030405); 826 const CService peer_us{peer_us_addr, 20002}; 827 828 // Create a peer with a routable IPv4 address. 829 in_addr peer_in_addr; 830 peer_in_addr.s_addr = htonl(0x01020304); 831 CNode peer{/*id=*/0, 832 /*sock=*/nullptr, 833 /*addrIn=*/CAddress{CService{peer_in_addr, 8333}, NODE_NETWORK}, 834 /*nKeyedNetGroupIn=*/0, 835 /*nLocalHostNonceIn=*/0, 836 /*addrBindIn=*/CService{}, 837 /*addrNameIn=*/std::string{}, 838 /*conn_type_in=*/ConnectionType::OUTBOUND_FULL_RELAY, 839 /*inbound_onion=*/false, 840 /*network_key=*/2}; 841 842 const uint64_t services{NODE_NETWORK | NODE_WITNESS}; 843 const int64_t time{0}; 844 845 // Force ChainstateManager::IsInitialBlockDownload() to return false. 846 // Otherwise PushAddress() isn't called by PeerManager::ProcessMessage(). 847 auto& chainman = static_cast<TestChainstateManager&>(*m_node.chainman); 848 chainman.JumpOutOfIbd(); 849 850 m_node.peerman->InitializeNode(peer, NODE_NETWORK); 851 852 m_node.peerman->SendMessages(peer); 853 connman.FlushSendBuffer(peer); // Drop sent version message 854 855 auto msg_version_receive = 856 NetMsg::Make(NetMsgType::VERSION, PROTOCOL_VERSION, services, time, services, CAddress::V1_NETWORK(peer_us)); 857 Assert(connman.ReceiveMsgFrom(peer, std::move(msg_version_receive))); 858 peer.fPauseSend = false; 859 bool more_work{connman.ProcessMessagesOnce(peer)}; 860 Assert(!more_work); 861 862 m_node.peerman->SendMessages(peer); 863 connman.FlushSendBuffer(peer); // Drop sent verack message 864 865 Assert(connman.ReceiveMsgFrom(peer, NetMsg::Make(NetMsgType::VERACK))); 866 peer.fPauseSend = false; 867 // Will set peer.fSuccessfullyConnected to true (necessary in SendMessages()). 868 more_work = connman.ProcessMessagesOnce(peer); 869 Assert(!more_work); 870 871 // Ensure that peer_us_addr:bind_port is sent to the peer. 872 const CService expected{peer_us_addr, bind_port}; 873 bool sent{false}; 874 875 const auto CaptureMessageOrig = CaptureMessage; 876 CaptureMessage = [&sent, &expected](const CAddress& addr, 877 const std::string& msg_type, 878 std::span<const unsigned char> data, 879 bool is_incoming) -> void { 880 if (!is_incoming && msg_type == "addr") { 881 std::vector<CAddress> addresses; 882 883 SpanReader{data} >> CAddress::V1_NETWORK(addresses); 884 885 for (const auto& addr : addresses) { 886 if (addr == expected) { 887 sent = true; 888 return; 889 } 890 } 891 } 892 }; 893 894 m_node.peerman->SendMessages(peer); 895 896 BOOST_CHECK(sent); 897 898 CaptureMessage = CaptureMessageOrig; 899 chainman.ResetIbd(); 900 m_node.connman->SetCaptureMessages(false); 901 m_node.args->ForceSetArg("-bind", ""); 902 } 903 904 905 BOOST_AUTO_TEST_CASE(advertise_local_address) 906 { 907 auto CreatePeer = [](const CAddress& addr) { 908 return std::make_unique<CNode>(/*id=*/0, 909 /*sock=*/nullptr, 910 addr, 911 /*nKeyedNetGroupIn=*/0, 912 /*nLocalHostNonceIn=*/0, 913 CAddress{}, 914 /*pszDest=*/std::string{}, 915 ConnectionType::OUTBOUND_FULL_RELAY, 916 /*inbound_onion=*/false, 917 /*network_key=*/0); 918 }; 919 g_reachable_nets.Add(NET_CJDNS); 920 921 CAddress addr_ipv4{Lookup("1.2.3.4", 8333, false).value(), NODE_NONE}; 922 BOOST_REQUIRE(addr_ipv4.IsValid()); 923 BOOST_REQUIRE(addr_ipv4.IsIPv4()); 924 925 CAddress addr_ipv6{Lookup("1122:3344:5566:7788:9900:aabb:ccdd:eeff", 8333, false).value(), NODE_NONE}; 926 BOOST_REQUIRE(addr_ipv6.IsValid()); 927 BOOST_REQUIRE(addr_ipv6.IsIPv6()); 928 929 CAddress addr_ipv6_tunnel{Lookup("2002:3344:5566:7788:9900:aabb:ccdd:eeff", 8333, false).value(), NODE_NONE}; 930 BOOST_REQUIRE(addr_ipv6_tunnel.IsValid()); 931 BOOST_REQUIRE(addr_ipv6_tunnel.IsIPv6()); 932 BOOST_REQUIRE(addr_ipv6_tunnel.IsRFC3964()); 933 934 CAddress addr_teredo{Lookup("2001:0000:5566:7788:9900:aabb:ccdd:eeff", 8333, false).value(), NODE_NONE}; 935 BOOST_REQUIRE(addr_teredo.IsValid()); 936 BOOST_REQUIRE(addr_teredo.IsIPv6()); 937 BOOST_REQUIRE(addr_teredo.IsRFC4380()); 938 939 CAddress addr_onion; 940 BOOST_REQUIRE(addr_onion.SetSpecial("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion")); 941 BOOST_REQUIRE(addr_onion.IsValid()); 942 BOOST_REQUIRE(addr_onion.IsTor()); 943 944 CAddress addr_i2p; 945 BOOST_REQUIRE(addr_i2p.SetSpecial("udhdrtrcetjm5sxzskjyr5ztpeszydbh4dpl3pl4utgqqw2v4jna.b32.i2p")); 946 BOOST_REQUIRE(addr_i2p.IsValid()); 947 BOOST_REQUIRE(addr_i2p.IsI2P()); 948 949 CService service_cjdns{Lookup("fc00:3344:5566:7788:9900:aabb:ccdd:eeff", 8333, false).value(), NODE_NONE}; 950 CAddress addr_cjdns{MaybeFlipIPv6toCJDNS(service_cjdns), NODE_NONE}; 951 BOOST_REQUIRE(addr_cjdns.IsValid()); 952 BOOST_REQUIRE(addr_cjdns.IsCJDNS()); 953 954 const auto peer_ipv4{CreatePeer(addr_ipv4)}; 955 const auto peer_ipv6{CreatePeer(addr_ipv6)}; 956 const auto peer_ipv6_tunnel{CreatePeer(addr_ipv6_tunnel)}; 957 const auto peer_teredo{CreatePeer(addr_teredo)}; 958 const auto peer_onion{CreatePeer(addr_onion)}; 959 const auto peer_i2p{CreatePeer(addr_i2p)}; 960 const auto peer_cjdns{CreatePeer(addr_cjdns)}; 961 962 // one local clearnet address - advertise to all but privacy peers 963 AddLocal(addr_ipv4); 964 BOOST_CHECK(GetLocalAddress(*peer_ipv4) == addr_ipv4); 965 BOOST_CHECK(GetLocalAddress(*peer_ipv6) == addr_ipv4); 966 BOOST_CHECK(GetLocalAddress(*peer_ipv6_tunnel) == addr_ipv4); 967 BOOST_CHECK(GetLocalAddress(*peer_teredo) == addr_ipv4); 968 BOOST_CHECK(GetLocalAddress(*peer_cjdns) == addr_ipv4); 969 BOOST_CHECK(!GetLocalAddress(*peer_onion).IsValid()); 970 BOOST_CHECK(!GetLocalAddress(*peer_i2p).IsValid()); 971 RemoveLocal(addr_ipv4); 972 973 // local privacy addresses - don't advertise to clearnet peers 974 AddLocal(addr_onion); 975 AddLocal(addr_i2p); 976 BOOST_CHECK(!GetLocalAddress(*peer_ipv4).IsValid()); 977 BOOST_CHECK(!GetLocalAddress(*peer_ipv6).IsValid()); 978 BOOST_CHECK(!GetLocalAddress(*peer_ipv6_tunnel).IsValid()); 979 BOOST_CHECK(!GetLocalAddress(*peer_teredo).IsValid()); 980 BOOST_CHECK(!GetLocalAddress(*peer_cjdns).IsValid()); 981 BOOST_CHECK(GetLocalAddress(*peer_onion) == addr_onion); 982 BOOST_CHECK(GetLocalAddress(*peer_i2p) == addr_i2p); 983 RemoveLocal(addr_onion); 984 RemoveLocal(addr_i2p); 985 986 // local addresses from all networks 987 AddLocal(addr_ipv4); 988 AddLocal(addr_ipv6); 989 AddLocal(addr_ipv6_tunnel); 990 AddLocal(addr_teredo); 991 AddLocal(addr_onion); 992 AddLocal(addr_i2p); 993 AddLocal(addr_cjdns); 994 BOOST_CHECK(GetLocalAddress(*peer_ipv4) == addr_ipv4); 995 BOOST_CHECK(GetLocalAddress(*peer_ipv6) == addr_ipv6); 996 BOOST_CHECK(GetLocalAddress(*peer_ipv6_tunnel) == addr_ipv6); 997 BOOST_CHECK(GetLocalAddress(*peer_teredo) == addr_ipv4); 998 BOOST_CHECK(GetLocalAddress(*peer_onion) == addr_onion); 999 BOOST_CHECK(GetLocalAddress(*peer_i2p) == addr_i2p); 1000 BOOST_CHECK(GetLocalAddress(*peer_cjdns) == addr_cjdns); 1001 RemoveLocal(addr_ipv4); 1002 RemoveLocal(addr_ipv6); 1003 RemoveLocal(addr_ipv6_tunnel); 1004 RemoveLocal(addr_teredo); 1005 RemoveLocal(addr_onion); 1006 RemoveLocal(addr_i2p); 1007 RemoveLocal(addr_cjdns); 1008 } 1009 1010 namespace { 1011 1012 CKey GenerateRandomTestKey(FastRandomContext& rng) noexcept 1013 { 1014 CKey key; 1015 uint256 key_data = rng.rand256(); 1016 key.Set(key_data.begin(), key_data.end(), true); 1017 return key; 1018 } 1019 1020 /** A class for scenario-based tests of V2Transport 1021 * 1022 * Each V2TransportTester encapsulates a V2Transport (the one being tested), and can be told to 1023 * interact with it. To do so, it also encapsulates a BIP324Cipher to act as the other side. A 1024 * second V2Transport is not used, as doing so would not permit scenarios that involve sending 1025 * invalid data, or ones using BIP324 features that are not implemented on the sending 1026 * side (like decoy packets). 1027 */ 1028 class V2TransportTester 1029 { 1030 FastRandomContext& m_rng; 1031 V2Transport m_transport; //!< V2Transport being tested 1032 BIP324Cipher m_cipher; //!< Cipher to help with the other side 1033 bool m_test_initiator; //!< Whether m_transport is the initiator (true) or responder (false) 1034 1035 std::vector<uint8_t> m_sent_garbage; //!< The garbage we've sent to m_transport. 1036 std::vector<uint8_t> m_recv_garbage; //!< The garbage we've received from m_transport. 1037 std::vector<uint8_t> m_to_send; //!< Bytes we have queued up to send to m_transport. 1038 std::vector<uint8_t> m_received; //!< Bytes we have received from m_transport. 1039 std::deque<CSerializedNetMsg> m_msg_to_send; //!< Messages to be sent *by* m_transport to us. 1040 bool m_sent_aad{false}; 1041 1042 public: 1043 /** Construct a tester object. test_initiator: whether the tested transport is initiator. */ 1044 explicit V2TransportTester(FastRandomContext& rng, bool test_initiator) 1045 : m_rng{rng}, 1046 m_transport{0, test_initiator}, 1047 m_cipher{GenerateRandomTestKey(m_rng), MakeByteSpan(m_rng.rand256())}, 1048 m_test_initiator(test_initiator) {} 1049 1050 /** Data type returned by Interact: 1051 * 1052 * - std::nullopt: transport error occurred 1053 * - otherwise: a vector of 1054 * - std::nullopt: invalid message received 1055 * - otherwise: a CNetMessage retrieved 1056 */ 1057 using InteractResult = std::optional<std::vector<std::optional<CNetMessage>>>; 1058 1059 /** Send/receive scheduled/available bytes and messages. 1060 * 1061 * This is the only function that interacts with the transport being tested; everything else is 1062 * scheduling things done by Interact(), or processing things learned by it. 1063 */ 1064 InteractResult Interact() 1065 { 1066 std::vector<std::optional<CNetMessage>> ret; 1067 while (true) { 1068 bool progress{false}; 1069 // Send bytes from m_to_send to the transport. 1070 if (!m_to_send.empty()) { 1071 std::span<const uint8_t> to_send = std::span{m_to_send}.first(1 + m_rng.randrange(m_to_send.size())); 1072 size_t old_len = to_send.size(); 1073 if (!m_transport.ReceivedBytes(to_send)) { 1074 return std::nullopt; // transport error occurred 1075 } 1076 if (old_len != to_send.size()) { 1077 progress = true; 1078 m_to_send.erase(m_to_send.begin(), m_to_send.begin() + (old_len - to_send.size())); 1079 } 1080 } 1081 // Retrieve messages received by the transport. 1082 if (m_transport.ReceivedMessageComplete() && (!progress || m_rng.randbool())) { 1083 bool reject{false}; 1084 auto msg = m_transport.GetReceivedMessage({}, reject); 1085 if (reject) { 1086 ret.emplace_back(std::nullopt); 1087 } else { 1088 ret.emplace_back(std::move(msg)); 1089 } 1090 progress = true; 1091 } 1092 // Enqueue a message to be sent by the transport to us. 1093 if (!m_msg_to_send.empty() && (!progress || m_rng.randbool())) { 1094 if (m_transport.SetMessageToSend(m_msg_to_send.front())) { 1095 m_msg_to_send.pop_front(); 1096 progress = true; 1097 } 1098 } 1099 // Receive bytes from the transport. 1100 const auto& [recv_bytes, _more, _msg_type] = m_transport.GetBytesToSend(!m_msg_to_send.empty()); 1101 if (!recv_bytes.empty() && (!progress || m_rng.randbool())) { 1102 size_t to_receive = 1 + m_rng.randrange(recv_bytes.size()); 1103 m_received.insert(m_received.end(), recv_bytes.begin(), recv_bytes.begin() + to_receive); 1104 progress = true; 1105 m_transport.MarkBytesSent(to_receive); 1106 } 1107 if (!progress) break; 1108 } 1109 return ret; 1110 } 1111 1112 /** Expose the cipher. */ 1113 BIP324Cipher& GetCipher() { return m_cipher; } 1114 1115 /** Schedule bytes to be sent to the transport. */ 1116 void Send(std::span<const uint8_t> data) 1117 { 1118 m_to_send.insert(m_to_send.end(), data.begin(), data.end()); 1119 } 1120 1121 /** Send V1 version message header to the transport. */ 1122 void SendV1Version(const MessageStartChars& magic) 1123 { 1124 CMessageHeader hdr(magic, "version", 126 + m_rng.randrange(11)); 1125 DataStream ser{}; 1126 ser << hdr; 1127 m_to_send.insert(m_to_send.end(), UCharCast(ser.data()), UCharCast(ser.data() + ser.size())); 1128 } 1129 1130 /** Schedule bytes to be sent to the transport. */ 1131 void Send(std::span<const std::byte> data) { Send(MakeUCharSpan(data)); } 1132 1133 /** Schedule our ellswift key to be sent to the transport. */ 1134 void SendKey() { Send(m_cipher.GetOurPubKey()); } 1135 1136 /** Schedule specified garbage to be sent to the transport. */ 1137 void SendGarbage(std::span<const uint8_t> garbage) 1138 { 1139 // Remember the specified garbage (so we can use it as AAD). 1140 m_sent_garbage.assign(garbage.begin(), garbage.end()); 1141 // Schedule it for sending. 1142 Send(m_sent_garbage); 1143 } 1144 1145 /** Schedule garbage (of specified length) to be sent to the transport. */ 1146 void SendGarbage(size_t garbage_len) 1147 { 1148 // Generate random garbage and send it. 1149 SendGarbage(m_rng.randbytes<uint8_t>(garbage_len)); 1150 } 1151 1152 /** Schedule garbage (with valid random length) to be sent to the transport. */ 1153 void SendGarbage() 1154 { 1155 SendGarbage(m_rng.randrange(V2Transport::MAX_GARBAGE_LEN + 1)); 1156 } 1157 1158 /** Schedule a message to be sent to us by the transport. */ 1159 void AddMessage(std::string m_type, std::vector<uint8_t> payload) 1160 { 1161 CSerializedNetMsg msg; 1162 msg.m_type = std::move(m_type); 1163 msg.data = std::move(payload); 1164 m_msg_to_send.push_back(std::move(msg)); 1165 } 1166 1167 /** Expect ellswift key to have been received from transport and process it. 1168 * 1169 * Many other V2TransportTester functions cannot be called until after ReceiveKey() has been 1170 * called, as no encryption keys are set up before that point. 1171 */ 1172 void ReceiveKey() 1173 { 1174 // When processing a key, enough bytes need to have been received already. 1175 BOOST_REQUIRE(m_received.size() >= EllSwiftPubKey::size()); 1176 // Initialize the cipher using it (acting as the opposite side of the tested transport). 1177 m_cipher.Initialize(MakeByteSpan(m_received).first(EllSwiftPubKey::size()), !m_test_initiator); 1178 // Strip the processed bytes off the front of the receive buffer. 1179 m_received.erase(m_received.begin(), m_received.begin() + EllSwiftPubKey::size()); 1180 } 1181 1182 /** Schedule an encrypted packet with specified content/aad/ignore to be sent to transport 1183 * (only after ReceiveKey). */ 1184 void SendPacket(std::span<const uint8_t> content, std::span<const uint8_t> aad = {}, bool ignore = false) 1185 { 1186 // Use cipher to construct ciphertext. 1187 std::vector<std::byte> ciphertext; 1188 ciphertext.resize(content.size() + BIP324Cipher::EXPANSION); 1189 m_cipher.Encrypt( 1190 /*contents=*/MakeByteSpan(content), 1191 /*aad=*/MakeByteSpan(aad), 1192 /*ignore=*/ignore, 1193 /*output=*/ciphertext); 1194 // Schedule it for sending. 1195 Send(ciphertext); 1196 } 1197 1198 /** Schedule garbage terminator to be sent to the transport (only after ReceiveKey). */ 1199 void SendGarbageTerm() 1200 { 1201 // Schedule the garbage terminator to be sent. 1202 Send(m_cipher.GetSendGarbageTerminator()); 1203 } 1204 1205 /** Schedule version packet to be sent to the transport (only after ReceiveKey). */ 1206 void SendVersion(std::span<const uint8_t> version_data = {}, bool vers_ignore = false) 1207 { 1208 std::span<const std::uint8_t> aad; 1209 // Set AAD to garbage only for first packet. 1210 if (!m_sent_aad) aad = m_sent_garbage; 1211 SendPacket(/*content=*/version_data, /*aad=*/aad, /*ignore=*/vers_ignore); 1212 m_sent_aad = true; 1213 } 1214 1215 /** Expect a packet to have been received from transport, process it, and return its contents 1216 * (only after ReceiveKey). Decoys are skipped. Optional associated authenticated data (AAD) is 1217 * expected in the first received packet, no matter if that is a decoy or not. */ 1218 std::vector<uint8_t> ReceivePacket(std::span<const std::byte> aad = {}) 1219 { 1220 std::vector<uint8_t> contents; 1221 // Loop as long as there are ignored packets that are to be skipped. 1222 while (true) { 1223 // When processing a packet, at least enough bytes for its length descriptor must be received. 1224 BOOST_REQUIRE(m_received.size() >= BIP324Cipher::LENGTH_LEN); 1225 // Decrypt the content length. 1226 size_t size = m_cipher.DecryptLength(MakeByteSpan(std::span{m_received}.first(BIP324Cipher::LENGTH_LEN))); 1227 // Check that the full packet is in the receive buffer. 1228 BOOST_REQUIRE(m_received.size() >= size + BIP324Cipher::EXPANSION); 1229 // Decrypt the packet contents. 1230 contents.resize(size); 1231 bool ignore{false}; 1232 bool ret = m_cipher.Decrypt( 1233 /*input=*/MakeByteSpan( 1234 std::span{m_received}.first(size + BIP324Cipher::EXPANSION).subspan(BIP324Cipher::LENGTH_LEN)), 1235 /*aad=*/aad, 1236 /*ignore=*/ignore, 1237 /*contents=*/MakeWritableByteSpan(contents)); 1238 BOOST_CHECK(ret); 1239 // Don't expect AAD in further packets. 1240 aad = {}; 1241 // Strip the processed packet's bytes off the front of the receive buffer. 1242 m_received.erase(m_received.begin(), m_received.begin() + size + BIP324Cipher::EXPANSION); 1243 // Stop if the ignore bit is not set on this packet. 1244 if (!ignore) break; 1245 } 1246 return contents; 1247 } 1248 1249 /** Expect garbage and garbage terminator to have been received, and process them (only after 1250 * ReceiveKey). */ 1251 void ReceiveGarbage() 1252 { 1253 // Figure out the garbage length. 1254 size_t garblen; 1255 for (garblen = 0; garblen <= V2Transport::MAX_GARBAGE_LEN; ++garblen) { 1256 BOOST_REQUIRE(m_received.size() >= garblen + BIP324Cipher::GARBAGE_TERMINATOR_LEN); 1257 auto term_span = MakeByteSpan(std::span{m_received}.subspan(garblen, BIP324Cipher::GARBAGE_TERMINATOR_LEN)); 1258 if (std::ranges::equal(term_span, m_cipher.GetReceiveGarbageTerminator())) break; 1259 } 1260 // Copy the garbage to a buffer. 1261 m_recv_garbage.assign(m_received.begin(), m_received.begin() + garblen); 1262 // Strip garbage + garbage terminator off the front of the receive buffer. 1263 m_received.erase(m_received.begin(), m_received.begin() + garblen + BIP324Cipher::GARBAGE_TERMINATOR_LEN); 1264 } 1265 1266 /** Expect version packet to have been received, and process it (only after ReceiveKey). */ 1267 void ReceiveVersion() 1268 { 1269 auto contents = ReceivePacket(/*aad=*/MakeByteSpan(m_recv_garbage)); 1270 // Version packets from real BIP324 peers are expected to be empty, despite the fact that 1271 // this class supports *sending* non-empty version packets (to test that BIP324 peers 1272 // correctly ignore version packet contents). 1273 BOOST_CHECK(contents.empty()); 1274 } 1275 1276 /** Expect application packet to have been received, with specified short id and payload. 1277 * (only after ReceiveKey). */ 1278 void ReceiveMessage(uint8_t short_id, std::span<const uint8_t> payload) 1279 { 1280 auto ret = ReceivePacket(); 1281 BOOST_CHECK(ret.size() == payload.size() + 1); 1282 BOOST_CHECK(ret[0] == short_id); 1283 BOOST_CHECK(std::ranges::equal(std::span{ret}.subspan(1), payload)); 1284 } 1285 1286 /** Expect application packet to have been received, with specified 12-char message type and 1287 * payload (only after ReceiveKey). */ 1288 void ReceiveMessage(const std::string& m_type, std::span<const uint8_t> payload) 1289 { 1290 auto ret = ReceivePacket(); 1291 BOOST_REQUIRE(ret.size() == payload.size() + 1 + CMessageHeader::MESSAGE_TYPE_SIZE); 1292 BOOST_CHECK(ret[0] == 0); 1293 for (unsigned i = 0; i < 12; ++i) { 1294 if (i < m_type.size()) { 1295 BOOST_CHECK(ret[1 + i] == m_type[i]); 1296 } else { 1297 BOOST_CHECK(ret[1 + i] == 0); 1298 } 1299 } 1300 BOOST_CHECK(std::ranges::equal(std::span{ret}.subspan(1 + CMessageHeader::MESSAGE_TYPE_SIZE), payload)); 1301 } 1302 1303 /** Schedule an encrypted packet with specified message type and payload to be sent to 1304 * transport (only after ReceiveKey). */ 1305 void SendMessage(std::string mtype, std::span<const uint8_t> payload) 1306 { 1307 // Construct contents consisting of 0x00 + 12-byte message type + payload. 1308 std::vector<uint8_t> contents(1 + CMessageHeader::MESSAGE_TYPE_SIZE + payload.size()); 1309 std::copy(mtype.begin(), mtype.end(), contents.begin() + 1); 1310 std::copy(payload.begin(), payload.end(), contents.begin() + 1 + CMessageHeader::MESSAGE_TYPE_SIZE); 1311 // Send a packet with that as contents. 1312 SendPacket(contents); 1313 } 1314 1315 /** Schedule an encrypted packet with specified short message id and payload to be sent to 1316 * transport (only after ReceiveKey). */ 1317 void SendMessage(uint8_t short_id, std::span<const uint8_t> payload) 1318 { 1319 // Construct contents consisting of short_id + payload. 1320 std::vector<uint8_t> contents(1 + payload.size()); 1321 contents[0] = short_id; 1322 std::copy(payload.begin(), payload.end(), contents.begin() + 1); 1323 // Send a packet with that as contents. 1324 SendPacket(contents); 1325 } 1326 1327 /** Test whether the transport's session ID matches the session ID we expect. */ 1328 void CompareSessionIDs() const 1329 { 1330 auto info = m_transport.GetInfo(); 1331 BOOST_CHECK(info.session_id); 1332 BOOST_CHECK(uint256(MakeUCharSpan(m_cipher.GetSessionID())) == *info.session_id); 1333 } 1334 1335 /** Introduce a bit error in the data scheduled to be sent. */ 1336 void Damage() 1337 { 1338 m_to_send[m_rng.randrange(m_to_send.size())] ^= (uint8_t{1} << m_rng.randrange(8)); 1339 } 1340 }; 1341 1342 } // namespace 1343 1344 BOOST_AUTO_TEST_CASE(v2transport_test) 1345 { 1346 // A mostly normal scenario, testing a transport in initiator mode. 1347 for (int i = 0; i < 10; ++i) { 1348 V2TransportTester tester(m_rng, true); 1349 auto ret = tester.Interact(); 1350 BOOST_REQUIRE(ret && ret->empty()); 1351 tester.SendKey(); 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(); 1361 auto msg_data_1 = m_rng.randbytes<uint8_t>(m_rng.randrange(100000)); 1362 auto msg_data_2 = m_rng.randbytes<uint8_t>(m_rng.randrange(1000)); 1363 tester.SendMessage(uint8_t(4), msg_data_1); // cmpctblock short id 1364 tester.SendMessage(0, {}); // Invalidly encoded message 1365 tester.SendMessage("tx", msg_data_2); // 12-character encoded message type 1366 ret = tester.Interact(); 1367 BOOST_REQUIRE(ret && ret->size() == 3); 1368 BOOST_CHECK((*ret)[0] && (*ret)[0]->m_type == "cmpctblock" && std::ranges::equal((*ret)[0]->m_recv, MakeByteSpan(msg_data_1))); 1369 BOOST_CHECK(!(*ret)[1]); 1370 BOOST_CHECK((*ret)[2] && (*ret)[2]->m_type == "tx" && std::ranges::equal((*ret)[2]->m_recv, MakeByteSpan(msg_data_2))); 1371 1372 // Then send a message with a bit error, expecting failure. It's possible this failure does 1373 // not occur immediately (when the length descriptor was modified), but it should come 1374 // eventually, and no messages can be delivered anymore. 1375 tester.SendMessage("bad", msg_data_1); 1376 tester.Damage(); 1377 while (true) { 1378 ret = tester.Interact(); 1379 if (!ret) break; // failure 1380 BOOST_CHECK(ret->size() == 0); // no message can be delivered 1381 // Send another message. 1382 auto msg_data_3 = m_rng.randbytes<uint8_t>(m_rng.randrange(10000)); 1383 tester.SendMessage(uint8_t(12), msg_data_3); // getheaders short id 1384 } 1385 } 1386 1387 // Normal scenario, with a transport in responder node. 1388 for (int i = 0; i < 10; ++i) { 1389 V2TransportTester tester(m_rng, false); 1390 tester.SendKey(); 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(); 1402 auto msg_data_1 = m_rng.randbytes<uint8_t>(m_rng.randrange(100000)); 1403 auto msg_data_2 = m_rng.randbytes<uint8_t>(m_rng.randrange(1000)); 1404 tester.SendMessage(uint8_t(14), msg_data_1); // inv short id 1405 tester.SendMessage(uint8_t(19), msg_data_2); // pong short id 1406 ret = tester.Interact(); 1407 BOOST_REQUIRE(ret && ret->size() == 2); 1408 BOOST_CHECK((*ret)[0] && (*ret)[0]->m_type == "inv" && std::ranges::equal((*ret)[0]->m_recv, MakeByteSpan(msg_data_1))); 1409 BOOST_CHECK((*ret)[1] && (*ret)[1]->m_type == "pong" && std::ranges::equal((*ret)[1]->m_recv, MakeByteSpan(msg_data_2))); 1410 1411 // Then send a too-large message. 1412 auto msg_data_3 = m_rng.randbytes<uint8_t>(4005000); 1413 tester.SendMessage(uint8_t(11), msg_data_3); // getdata short id 1414 ret = tester.Interact(); 1415 BOOST_CHECK(!ret); 1416 } 1417 1418 // Various valid but unusual scenarios. 1419 for (int i = 0; i < 50; ++i) { 1420 /** Whether an initiator or responder is being tested. */ 1421 bool initiator = m_rng.randbool(); 1422 /** Use either 0 bytes or the maximum possible (4095 bytes) garbage length. */ 1423 size_t garb_len = m_rng.randbool() ? 0 : V2Transport::MAX_GARBAGE_LEN; 1424 /** How many decoy packets to send before the version packet. */ 1425 unsigned num_ignore_version = m_rng.randrange(10); 1426 /** What data to send in the version packet (ignored by BIP324 peers, but reserved for future extensions). */ 1427 auto ver_data = m_rng.randbytes<uint8_t>(m_rng.randbool() ? 0 : m_rng.randrange(1000)); 1428 /** Whether to immediately send key and garbage out (required for responders, optional otherwise). */ 1429 bool send_immediately = !initiator || m_rng.randbool(); 1430 /** How many decoy packets to send before the first and second real message. */ 1431 unsigned num_decoys_1 = m_rng.randrange(1000), num_decoys_2 = m_rng.randrange(1000); 1432 V2TransportTester tester(m_rng, initiator); 1433 if (send_immediately) { 1434 tester.SendKey(); 1435 tester.SendGarbage(garb_len); 1436 } 1437 auto ret = tester.Interact(); 1438 BOOST_REQUIRE(ret && ret->empty()); 1439 if (!send_immediately) { 1440 tester.SendKey(); 1441 tester.SendGarbage(garb_len); 1442 } 1443 tester.ReceiveKey(); 1444 tester.SendGarbageTerm(); 1445 for (unsigned v = 0; v < num_ignore_version; ++v) { 1446 size_t ver_ign_data_len = m_rng.randbool() ? 0 : m_rng.randrange(1000); 1447 auto ver_ign_data = m_rng.randbytes<uint8_t>(ver_ign_data_len); 1448 tester.SendVersion(ver_ign_data, true); 1449 } 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) { 1457 auto decoy_data = m_rng.randbytes<uint8_t>(m_rng.randrange(1000)); 1458 tester.SendPacket(/*content=*/decoy_data, /*aad=*/{}, /*ignore=*/true); 1459 } 1460 auto msg_data_1 = m_rng.randbytes<uint8_t>(m_rng.randrange(4000000)); 1461 tester.SendMessage(uint8_t(28), msg_data_1); 1462 for (unsigned d = 0; d < num_decoys_2; ++d) { 1463 auto decoy_data = m_rng.randbytes<uint8_t>(m_rng.randrange(1000)); 1464 tester.SendPacket(/*content=*/decoy_data, /*aad=*/{}, /*ignore=*/true); 1465 } 1466 auto msg_data_2 = m_rng.randbytes<uint8_t>(m_rng.randrange(1000)); 1467 tester.SendMessage(uint8_t(13), msg_data_2); // headers short id 1468 // Send invalidly-encoded message 1469 tester.SendMessage(std::string("blocktxn\x00\x00\x00a", CMessageHeader::MESSAGE_TYPE_SIZE), {}); 1470 tester.SendMessage("foobar", {}); // test receiving unknown message type 1471 tester.AddMessage("barfoo", {}); // test sending unknown message type 1472 ret = tester.Interact(); 1473 BOOST_REQUIRE(ret && ret->size() == 4); 1474 BOOST_CHECK((*ret)[0] && (*ret)[0]->m_type == "addrv2" && std::ranges::equal((*ret)[0]->m_recv, MakeByteSpan(msg_data_1))); 1475 BOOST_CHECK((*ret)[1] && (*ret)[1]->m_type == "headers" && std::ranges::equal((*ret)[1]->m_recv, MakeByteSpan(msg_data_2))); 1476 BOOST_CHECK(!(*ret)[2]); 1477 BOOST_CHECK((*ret)[3] && (*ret)[3]->m_type == "foobar" && (*ret)[3]->m_recv.empty()); 1478 tester.ReceiveMessage("barfoo", {}); 1479 } 1480 1481 // Too long garbage (initiator). 1482 { 1483 V2TransportTester tester(m_rng, true); 1484 auto ret = tester.Interact(); 1485 BOOST_REQUIRE(ret && ret->empty()); 1486 tester.SendKey(); 1487 tester.SendGarbage(V2Transport::MAX_GARBAGE_LEN + 1); 1488 tester.ReceiveKey(); 1489 tester.SendGarbageTerm(); 1490 ret = tester.Interact(); 1491 BOOST_CHECK(!ret); 1492 } 1493 1494 // Too long garbage (responder). 1495 { 1496 V2TransportTester tester(m_rng, false); 1497 tester.SendKey(); 1498 tester.SendGarbage(V2Transport::MAX_GARBAGE_LEN + 1); 1499 auto ret = tester.Interact(); 1500 BOOST_REQUIRE(ret && ret->empty()); 1501 tester.ReceiveKey(); 1502 tester.SendGarbageTerm(); 1503 ret = tester.Interact(); 1504 BOOST_CHECK(!ret); 1505 } 1506 1507 // Send garbage that includes the first 15 garbage terminator bytes somewhere. 1508 { 1509 V2TransportTester tester(m_rng, true); 1510 auto ret = tester.Interact(); 1511 BOOST_REQUIRE(ret && ret->empty()); 1512 tester.SendKey(); 1513 tester.ReceiveKey(); 1514 /** The number of random garbage bytes before the included first 15 bytes of terminator. */ 1515 size_t len_before = m_rng.randrange(V2Transport::MAX_GARBAGE_LEN - 16 + 1); 1516 /** The number of random garbage bytes after it. */ 1517 size_t len_after = m_rng.randrange(V2Transport::MAX_GARBAGE_LEN - 16 - len_before + 1); 1518 // Construct len_before + 16 + len_after random bytes. 1519 auto garbage = m_rng.randbytes<uint8_t>(len_before + 16 + len_after); 1520 // Replace the designed 16 bytes in the middle with the to-be-sent garbage terminator. 1521 auto garb_term = MakeUCharSpan(tester.GetCipher().GetSendGarbageTerminator()); 1522 std::copy(garb_term.begin(), garb_term.begin() + 16, garbage.begin() + len_before); 1523 // Introduce a bit error in the last byte of that copied garbage terminator, making only 1524 // the first 15 of them match. 1525 garbage[len_before + 15] ^= (uint8_t(1) << m_rng.randrange(8)); 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(); 1534 auto msg_data_1 = m_rng.randbytes<uint8_t>(4000000); // test that receiving 4M payload works 1535 auto msg_data_2 = m_rng.randbytes<uint8_t>(4000000); // test that sending 4M payload works 1536 tester.SendMessage(uint8_t(m_rng.randrange(223) + 33), {}); // unknown short id 1537 tester.SendMessage(uint8_t(2), msg_data_1); // "block" short id 1538 tester.AddMessage("blocktxn", msg_data_2); // schedule blocktxn to be sent to us 1539 ret = tester.Interact(); 1540 BOOST_REQUIRE(ret && ret->size() == 2); 1541 BOOST_CHECK(!(*ret)[0]); 1542 BOOST_CHECK((*ret)[1] && (*ret)[1]->m_type == "block" && std::ranges::equal((*ret)[1]->m_recv, MakeByteSpan(msg_data_1))); 1543 tester.ReceiveMessage(uint8_t(3), msg_data_2); // "blocktxn" short id 1544 } 1545 1546 // Send correct network's V1 header 1547 { 1548 V2TransportTester tester(m_rng, false); 1549 tester.SendV1Version(Params().MessageStart()); 1550 auto ret = tester.Interact(); 1551 BOOST_CHECK(ret); 1552 } 1553 1554 // Send wrong network's V1 header 1555 { 1556 V2TransportTester tester(m_rng, false); 1557 tester.SendV1Version(CChainParams::Main()->MessageStart()); 1558 auto ret = tester.Interact(); 1559 BOOST_CHECK(!ret); 1560 } 1561 } 1562 1563 BOOST_AUTO_TEST_CASE(private_broadcast_version_does_not_update_addrman_services) 1564 { 1565 LOCK(NetEventsInterface::g_msgproc_mutex); 1566 1567 const CNetAddr source{LookupHost("2.3.4.5", /*fAllowLookup=*/false).value()}; 1568 const CAddress addr{Lookup("1.2.3.4", 8333, /*fAllowLookup=*/false).value(), NODE_NONE}; 1569 BOOST_REQUIRE(m_node.addrman->Add({addr}, source)); 1570 CNode node{/*id=*/0, 1571 /*sock=*/nullptr, 1572 /*addrIn=*/addr, 1573 /*nKeyedNetGroupIn=*/0, 1574 /*nLocalHostNonceIn=*/0, 1575 /*addrBindIn=*/CService{}, 1576 /*addrNameIn=*/"", 1577 /*conn_type_in=*/ConnectionType::PRIVATE_BROADCAST, 1578 /*inbound_onion=*/false, 1579 /*network_key=*/0}; 1580 1581 auto& connman = static_cast<ConnmanTestMsg&>(*m_node.connman); 1582 connman.Handshake(node, 1583 /*successfully_connected=*/false, 1584 /*remote_services=*/NODE_NETWORK, 1585 /*local_services=*/NODE_NONE, 1586 /*version=*/PROTOCOL_VERSION, 1587 /*relay_txs=*/true); 1588 1589 BOOST_CHECK_EQUAL(m_node.addrman->Select().first.nServices, NODE_NONE); 1590 m_node.peerman->FinalizeNode(node); 1591 } 1592 1593 BOOST_AUTO_TEST_SUITE_END()