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