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