Inside Bitcoin

251
252    // I2P, malicious
253    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    BOOST_CHECK(
258        !addr.SetSpecial("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscsad.b32.i2p"));
259
260    // I2P, invalid base32
261    BOOST_CHECK(!addr.SetSpecial(std::string{"tp*szydbh4dp.b32.i2p"}));
262
263    // Internal
264    addr.SetInternal("esffpp");
265    BOOST_REQUIRE(!addr.IsValid()); // "internal" is considered invalid
266    BOOST_REQUIRE(addr.IsInternal());
267
268    BOOST_CHECK(!addr.IsBindAny());
269    BOOST_CHECK(addr.IsAddrV1Compatible());
270    BOOST_CHECK_EQUAL(addr.ToStringAddr(), "esffpvrt3wpeaygy.internal");
271
272    // Totally bogus
273    BOOST_CHECK(!addr.SetSpecial("totally bogus"));
274}
275
276BOOST_AUTO_TEST_CASE(cnetaddr_tostring_canonical_ipv6)
277{
278    // Test that CNetAddr::ToString formats IPv6 addresses with zero compression as described in
279    // RFC 5952 ("A Recommendation for IPv6 Address Text Representation").
280    const std::map<std::string, std::string> canonical_representations_ipv6{
281        {"0000:0000:0000:0000:0000:0000:0000:0000", "::"},
282        {"000:0000:000:00:0:00:000:0000", "::"},
283        {"000:000:000:000:000:000:000:000", "::"},
284        {"00:00:00:00:00:00:00:00", "::"},
285        {"0:0:0:0:0:0:0:0", "::"},
286        {"0:0:0:0:0:0:0:1", "::1"},
287        {"2001:0:0:1:0:0:0:1", "2001:0:0:1::1"},
288        {"2001:0db8:0:0:1:0:0:1", "2001:db8::1:0:0:1"},
289        {"2001:0db8:85a3:0000:0000:8a2e:0370:7334", "2001:db8:85a3::8a2e:370:7334"},
290        {"2001:0db8::0001", "2001:db8::1"},
291        {"2001:0db8::0001:0000", "2001:db8::1:0"},
292        {"2001:0db8::1:0:0:1", "2001:db8::1:0:0:1"},
293        {"2001:db8:0000:0:1::1", "2001:db8::1:0:0:1"},
294        {"2001:db8:0000:1:1:1:1:1", "2001:db8:0:1:1:1:1:1"},
295        {"2001:db8:0:0:0:0:2:1", "2001:db8::2:1"},
296        {"2001:db8:0:0:0::1", "2001:db8::1"},
297        {"2001:db8:0:0:1:0:0:1", "2001:db8::1:0:0:1"},
298        {"2001:db8:0:0:1::1", "2001:db8::1:0:0:1"},
299        {"2001:DB8:0:0:1::1", "2001:db8::1:0:0:1"},
300        {"2001:db8:0:0::1", "2001:db8::1"},
301        {"2001:db8:0:0:aaaa::1", "2001:db8::aaaa:0:0:1"},
302        {"2001:db8:0:1:1:1:1:1", "2001:db8:0:1:1:1:1:1"},
303        {"2001:db8:0::1", "2001:db8::1"},
304        {"2001:db8:85a3:0:0:8a2e:370:7334", "2001:db8:85a3::8a2e:370:7334"},
305        {"2001:db8::0:1", "2001:db8::1"},
306        {"2001:db8::0:1:0:0:1", "2001:db8::1:0:0:1"},
307        {"2001:DB8::1", "2001:db8::1"},
308        {"2001:db8::1", "2001:db8::1"},
309        {"2001:db8::1:0:0:1", "2001:db8::1:0:0:1"},
310        {"2001:db8::1:1:1:1:1", "2001:db8:0:1:1:1:1:1"},
311        {"2001:db8::aaaa:0:0:1", "2001:db8::aaaa:0:0:1"},
312        {"2001:db8:aaaa:bbbb:cccc:dddd:0:1", "2001:db8:aaaa:bbbb:cccc:dddd:0:1"},
313        {"2001:db8:aaaa:bbbb:cccc:dddd::1", "2001:db8:aaaa:bbbb:cccc:dddd:0:1"},
314        {"2001:db8:aaaa:bbbb:cccc:dddd:eeee:0001", "2001:db8:aaaa:bbbb:cccc:dddd:eeee:1"},
315        {"2001:db8:aaaa:bbbb:cccc:dddd:eeee:001", "2001:db8:aaaa:bbbb:cccc:dddd:eeee:1"},
316        {"2001:db8:aaaa:bbbb:cccc:dddd:eeee:01", "2001:db8:aaaa:bbbb:cccc:dddd:eeee:1"},
317        {"2001:db8:aaaa:bbbb:cccc:dddd:eeee:1", "2001:db8:aaaa:bbbb:cccc:dddd:eeee:1"},
318        {"2001:db8:aaaa:bbbb:cccc:dddd:eeee:aaaa", "2001:db8:aaaa:bbbb:cccc:dddd:eeee:aaaa"},
319        {"2001:db8:aaaa:bbbb:cccc:dddd:eeee:AAAA", "2001:db8:aaaa:bbbb:cccc:dddd:eeee:aaaa"},
320        {"2001:db8:aaaa:bbbb:cccc:dddd:eeee:AaAa", "2001:db8:aaaa:bbbb:cccc:dddd:eeee:aaaa"},
321    };
322    for (const auto& [input_address, expected_canonical_representation_output] : canonical_representations_ipv6) {
323        const std::optional<CNetAddr> net_addr{LookupHost(input_address, false)};
324        BOOST_REQUIRE(net_addr.value().IsIPv6());
325        BOOST_CHECK_EQUAL(net_addr.value().ToStringAddr(), expected_canonical_representation_output);
326    }
327}
328
329BOOST_AUTO_TEST_CASE(cnetaddr_serialize_v1)
330{
331    CNetAddr addr;
332    DataStream s{};
333    const auto ser_params{CAddress::V1_NETWORK};
334
335    s << ser_params(addr);
336    BOOST_CHECK_EQUAL(HexStr(s), "00000000000000000000000000000000");
337    s.clear();
338
339    addr = LookupHost("1.2.3.4", false).value();
340    s << ser_params(addr);
341    BOOST_CHECK_EQUAL(HexStr(s), "00000000000000000000ffff01020304");
342    s.clear();
343
344    addr = LookupHost("1a1b:2a2b:3a3b:4a4b:5a5b:6a6b:7a7b:8a8b", false).value();
345    s << ser_params(addr);
346    BOOST_CHECK_EQUAL(HexStr(s), "1a1b2a2b3a3b4a4b5a5b6a6b7a7b8a8b");
347    s.clear();
348
349    // TORv2, no longer supported
350    BOOST_CHECK(!addr.SetSpecial("6hzph5hv6337r6p2.onion"));
351
352    BOOST_REQUIRE(addr.SetSpecial("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion"));
353    s << ser_params(addr);
354    BOOST_CHECK_EQUAL(HexStr(s), "00000000000000000000000000000000");
355    s.clear();
356
357    addr.SetInternal("a");
358    s << ser_params(addr);
359    BOOST_CHECK_EQUAL(HexStr(s), "fd6b88c08724ca978112ca1bbdcafac2");
360    s.clear();
361}
362
363BOOST_AUTO_TEST_CASE(cnetaddr_serialize_v2)
364{
365    CNetAddr addr;
366    DataStream s{};
367    const auto ser_params{CAddress::V2_NETWORK};
368
369    s << ser_params(addr);
370    BOOST_CHECK_EQUAL(HexStr(s), "021000000000000000000000000000000000");
371    s.clear();
372
373    addr = LookupHost("1.2.3.4", false).value();
374    s << ser_params(addr);
375    BOOST_CHECK_EQUAL(HexStr(s), "010401020304");
376    s.clear();
377
378    addr = LookupHost("1a1b:2a2b:3a3b:4a4b:5a5b:6a6b:7a7b:8a8b", false).value();
379    s << ser_params(addr);
380    BOOST_CHECK_EQUAL(HexStr(s), "02101a1b2a2b3a3b4a4b5a5b6a6b7a7b8a8b");
381    s.clear();
382
383    // TORv2, no longer supported
384    BOOST_CHECK(!addr.SetSpecial("6hzph5hv6337r6p2.onion"));
385
386    BOOST_REQUIRE(addr.SetSpecial("kpgvmscirrdqpekbqjsvw5teanhatztpp2gl6eee4zkowvwfxwenqaid.onion"));
387    s << ser_params(addr);
388    BOOST_CHECK_EQUAL(HexStr(s), "042053cd5648488c4707914182655b7664034e09e66f7e8cbf1084e654eb56c5bd88");
389    s.clear();
390
391    BOOST_REQUIRE(addr.SetInternal("a"));
392    s << ser_params(addr);
393    BOOST_CHECK_EQUAL(HexStr(s), "0210fd6b88c08724ca978112ca1bbdcafac2");
394    s.clear();
395}
396
397BOOST_AUTO_TEST_CASE(cnetaddr_unserialize_v2)
398{
399    CNetAddr addr;
400    DataStream s{};
401    const auto ser_params{CAddress::V2_NETWORK};
402
403    // Valid IPv4.
404    s << "01"            // network type (IPv4)
405         "04"            // address length
406         "01020304"_hex; // address
407    s >> ser_params(addr);
408    BOOST_CHECK(addr.IsValid());
409    BOOST_CHECK(addr.IsIPv4());
410    BOOST_CHECK(addr.IsAddrV1Compatible());
411    BOOST_CHECK_EQUAL(addr.ToStringAddr(), "1.2.3.4");
412    BOOST_REQUIRE(s.empty());
413
414    // Invalid IPv4, valid length but address itself is shorter.
415    s << "01"        // network type (IPv4)
416         "04"        // address length
417         "0102"_hex; // address
418    BOOST_CHECK_EXCEPTION(s >> ser_params(addr), std::ios_base::failure, HasReason("end of data"));
419    BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input.
420    s.clear();
421
422    // Invalid IPv4, with bogus length.
423    s << "01"            // network type (IPv4)
424         "05"            // address length
425         "01020304"_hex; // address
426    BOOST_CHECK_EXCEPTION(s >> ser_params(addr), std::ios_base::failure,
427                          HasReason("BIP155 IPv4 address with length 5 (should be 4)"));
428    BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input.
429    s.clear();
430
431    // Invalid IPv4, with extreme length.
432    s << "01"            // network type (IPv4)
433         "fd0102"        // address length (513 as CompactSize)
434         "01020304"_hex; // address
435    BOOST_CHECK_EXCEPTION(s >> ser_params(addr), std::ios_base::failure,
436                          HasReason("Address too long: 513 > 512"));
437    BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input.
438    s.clear();
439
440    // Valid IPv6.
441    s << "02"                                    // network type (IPv6)
442         "10"                                    // address length
443         "0102030405060708090a0b0c0d0e0f10"_hex; // address
444    s >> ser_params(addr);
445    BOOST_CHECK(addr.IsValid());
446    BOOST_CHECK(addr.IsIPv6());
447    BOOST_CHECK(addr.IsAddrV1Compatible());
448    BOOST_CHECK_EQUAL(addr.ToStringAddr(), "102:304:506:708:90a:b0c:d0e:f10");
449    BOOST_REQUIRE(s.empty());
450
451    // Valid IPv6, contains embedded "internal".
452    s << "02"                                    // network type (IPv6)
453         "10"                                    // address length
454         "fd6b88c08724ca978112ca1bbdcafac2"_hex; // address: 0xfd + sha256("bitcoin")[0:5] +
455                                                 // sha256(name)[0:10]
456    s >> ser_params(addr);
457    BOOST_CHECK(addr.IsInternal());
458    BOOST_CHECK(addr.IsAddrV1Compatible());
459    BOOST_CHECK_EQUAL(addr.ToStringAddr(), "zklycewkdo64v6wc.internal");
460    BOOST_REQUIRE(s.empty());
461
462    // Invalid IPv6, with bogus length.
463    s << "02"      // network type (IPv6)
464         "04"      // address length
465         "00"_hex; // address
466    BOOST_CHECK_EXCEPTION(s >> ser_params(addr), std::ios_base::failure,
467                          HasReason("BIP155 IPv6 address with length 4 (should be 16)"));
468    BOOST_REQUIRE(!s.empty()); // The stream is not consumed on invalid input.
469    s.clear();
470
471    // Invalid IPv6, contains embedded IPv4.
472    s << "02"                                    // network type (IPv6)
473         "10"                                    // address length
474         "00000000000000000000ffff01020304"_hex; // address
475    s >> ser_params(addr);
476    BOOST_CHECK(!addr.IsValid());
477    BOOST_REQUIRE(s.empty());
478
479    // Invalid IPv6, contains embedded TORv2.
480    s << "02"                                    // network type (IPv6)
481         "10"                                    // address length
482         "fd87d87eeb430102030405060708090a"_hex; // address
483    s >> ser_params(addr);
484    BOOST_CHECK(!addr.IsValid());
485    BOOST_REQUIRE(s.empty());
486
487    // TORv2, no longer supported.
488    s << "03"                        // network type (TORv2)
489         "0a"                        // address length
490         "f1f2f3f4f5f6f7f8f9fa"_hex; // address
491    s >> ser_params(addr);
492    BOOST_CHECK(!addr.IsValid());
493    BOOST_REQUIRE(s.empty());
494
495    // Valid TORv3.
496    s << "04"                               // network type (TORv3)
497         "20"                               // address length
498         "79bcc625184b05194975c28b66b66b04" // address
499         "69f7f6556fb1ac3189a79b40dda32f1f"_hex;
500    s >> ser_params(addr);