Inside Bitcoin

501
502BOOST_AUTO_TEST_CASE(getaddr_unfiltered)
503{
504    auto addrman = std::make_unique<AddrMan>(EMPTY_NETGROUPMAN, DETERMINISTIC, GetCheckRatio(m_node));
505
506    // Set time on this addr so isTerrible = false
507    CAddress addr1 = CAddress(ResolveService("250.250.2.1", 8333), NODE_NONE);
508    addr1.nTime = Now<NodeSeconds>();
509    // Not setting time so this addr should be isTerrible = true
510    CAddress addr2 = CAddress(ResolveService("250.251.2.2", 9999), NODE_NONE);
511
512    CNetAddr source = ResolveIP("250.1.2.1");
513    BOOST_CHECK(addrman->Add({addr1, addr2}, source));
514
515    // Set time on this addr so isTerrible = false
516    CAddress addr3 = CAddress(ResolveService("250.251.2.3", 9998), NODE_NONE);
517    addr3.nTime = Now<NodeSeconds>();
518    addrman->Good(addr3, /*time=*/Now<NodeSeconds>());
519    BOOST_CHECK(addrman->Add({addr3}, source));
520    // The time is set, but after ADDRMAN_RETRIES unsuccessful attempts not
521    // retried in the last minute, this addr should be isTerrible = true
522    for (size_t i = 0; i < 3; ++i) {
523        addrman->Attempt(addr3, /*fCountFailure=*/true, /*time=*/Now<NodeSeconds>() - 61s);
524    }
525
526    // Set time more than 10 minutes in the future (flying DeLorean), so this
527    // addr should be isTerrible = true
528    CAddress addr4 = CAddress(ResolveService("250.252.2.4", 9997), NODE_NONE);
529    addr4.nTime = Now<NodeSeconds>() + 11min;
530    BOOST_CHECK(addrman->Add({addr4}, source));
531
532    // GetAddr filtered by quality (i.e. not IsTerrible) should only return addr1
533    BOOST_CHECK_EQUAL(addrman->GetAddr(/*max_addresses=*/0, /*max_pct=*/0, /*network=*/std::nullopt).size(), 1U);
534    // Unfiltered GetAddr should return all addrs
535    BOOST_CHECK_EQUAL(addrman->GetAddr(/*max_addresses=*/0, /*max_pct=*/0, /*network=*/std::nullopt, /*filtered=*/false).size(), 4U);
536}
537
538BOOST_AUTO_TEST_CASE(caddrinfo_get_tried_bucket_legacy)
539{
540    CAddress addr1 = CAddress(ResolveService("250.1.1.1", 8333), NODE_NONE);
541    CAddress addr2 = CAddress(ResolveService("250.1.1.1", 9999), NODE_NONE);
542
543    CNetAddr source1 = ResolveIP("250.1.1.1");
544
545
546    AddrInfo info1 = AddrInfo(addr1, source1);
547
548    uint256 nKey1 = (HashWriter{} << 1).GetHash();
549    uint256 nKey2 = (HashWriter{} << 2).GetHash();
550
551    BOOST_CHECK_EQUAL(info1.GetTriedBucket(nKey1, EMPTY_NETGROUPMAN), 40);
552
553    // Test: Make sure key actually randomizes bucket placement. A fail on
554    //  this test could be a security issue.
555    BOOST_CHECK(info1.GetTriedBucket(nKey1, EMPTY_NETGROUPMAN) != info1.GetTriedBucket(nKey2, EMPTY_NETGROUPMAN));
556
557    // Test: Two addresses with same IP but different ports can map to
558    //  different buckets because they have different keys.
559    AddrInfo info2 = AddrInfo(addr2, source1);
560
561    BOOST_CHECK(info1.GetKey() != info2.GetKey());
562    BOOST_CHECK(info1.GetTriedBucket(nKey1, EMPTY_NETGROUPMAN) != info2.GetTriedBucket(nKey1, EMPTY_NETGROUPMAN));
563
564    std::set<int> buckets;
565    for (int i = 0; i < 255; i++) {
566        AddrInfo infoi = AddrInfo(
567            CAddress(ResolveService("250.1.1." + ToString(i)), NODE_NONE),
568            ResolveIP("250.1.1." + ToString(i)));
569        int bucket = infoi.GetTriedBucket(nKey1, EMPTY_NETGROUPMAN);
570        buckets.insert(bucket);
571    }
572    // Test: IP addresses in the same /16 prefix should
573    // never get more than 8 buckets with legacy grouping
574    BOOST_CHECK_EQUAL(buckets.size(), 8U);
575
576    buckets.clear();
577    for (int j = 0; j < 255; j++) {
578        AddrInfo infoj = AddrInfo(
579            CAddress(ResolveService("250." + ToString(j) + ".1.1"), NODE_NONE),
580            ResolveIP("250." + ToString(j) + ".1.1"));
581        int bucket = infoj.GetTriedBucket(nKey1, EMPTY_NETGROUPMAN);
582        buckets.insert(bucket);
583    }
584    // Test: IP addresses in the different /16 prefix should map to more than
585    // 8 buckets with legacy grouping
586    BOOST_CHECK_EQUAL(buckets.size(), 160U);
587}
588
589BOOST_AUTO_TEST_CASE(caddrinfo_get_new_bucket_legacy)
590{
591    CAddress addr1 = CAddress(ResolveService("250.1.2.1", 8333), NODE_NONE);
592    CAddress addr2 = CAddress(ResolveService("250.1.2.1", 9999), NODE_NONE);
593
594    CNetAddr source1 = ResolveIP("250.1.2.1");
595
596    AddrInfo info1 = AddrInfo(addr1, source1);
597
598    uint256 nKey1 = (HashWriter{} << 1).GetHash();
599    uint256 nKey2 = (HashWriter{} << 2).GetHash();
600
601    // Test: Make sure the buckets are what we expect
602    BOOST_CHECK_EQUAL(info1.GetNewBucket(nKey1, EMPTY_NETGROUPMAN), 786);
603    BOOST_CHECK_EQUAL(info1.GetNewBucket(nKey1, source1, EMPTY_NETGROUPMAN), 786);
604
605    // Test: Make sure key actually randomizes bucket placement. A fail on
606    //  this test could be a security issue.
607    BOOST_CHECK(info1.GetNewBucket(nKey1, EMPTY_NETGROUPMAN) != info1.GetNewBucket(nKey2, EMPTY_NETGROUPMAN));
608
609    // Test: Ports should not affect bucket placement in the addr
610    AddrInfo info2 = AddrInfo(addr2, source1);
611    BOOST_CHECK(info1.GetKey() != info2.GetKey());
612    BOOST_CHECK_EQUAL(info1.GetNewBucket(nKey1, EMPTY_NETGROUPMAN), info2.GetNewBucket(nKey1, EMPTY_NETGROUPMAN));
613
614    std::set<int> buckets;
615    for (int i = 0; i < 255; i++) {
616        AddrInfo infoi = AddrInfo(
617            CAddress(ResolveService("250.1.1." + ToString(i)), NODE_NONE),
618            ResolveIP("250.1.1." + ToString(i)));
619        int bucket = infoi.GetNewBucket(nKey1, EMPTY_NETGROUPMAN);
620        buckets.insert(bucket);
621    }
622    // Test: IP addresses in the same group (\16 prefix for IPv4) should
623    //  always map to the same bucket.
624    BOOST_CHECK_EQUAL(buckets.size(), 1U);
625
626    buckets.clear();
627    for (int j = 0; j < 4 * 255; j++) {
628        AddrInfo infoj = AddrInfo(CAddress(
629                                        ResolveService(
630                                            ToString(250 + (j / 255)) + "." + ToString(j % 256) + ".1.1"), NODE_NONE),
631            ResolveIP("251.4.1.1"));
632        int bucket = infoj.GetNewBucket(nKey1, EMPTY_NETGROUPMAN);
633        buckets.insert(bucket);
634    }
635    // Test: IP addresses in the same source groups should map to NO MORE
636    //  than 64 buckets.
637    BOOST_CHECK(buckets.size() <= 64);
638
639    buckets.clear();
640    for (int p = 0; p < 255; p++) {
641        AddrInfo infoj = AddrInfo(
642            CAddress(ResolveService("250.1.1.1"), NODE_NONE),
643            ResolveIP("250." + ToString(p) + ".1.1"));
644        int bucket = infoj.GetNewBucket(nKey1, EMPTY_NETGROUPMAN);
645        buckets.insert(bucket);
646    }
647    // Test: IP addresses in the different source groups should map to MORE
648    //  than 64 buckets.
649    BOOST_CHECK(buckets.size() > 64);
650}
651
652// The following three test cases use asmap.raw
653// We use an artificial minimal mock mapping
654// 250.0.0.0/8 AS1000
655// 101.1.0.0/16 AS1
656// 101.2.0.0/16 AS2
657// 101.3.0.0/16 AS3
658// 101.4.0.0/16 AS4
659// 101.5.0.0/16 AS5
660// 101.6.0.0/16 AS6
661// 101.7.0.0/16 AS7
662// 101.8.0.0/16 AS8
663BOOST_AUTO_TEST_CASE(caddrinfo_get_tried_bucket)
664{
665    auto ngm_asmap{NetGroupManager::WithEmbeddedAsmap(test::data::asmap)};
666
667    CAddress addr1 = CAddress(ResolveService("250.1.1.1", 8333), NODE_NONE);
668    CAddress addr2 = CAddress(ResolveService("250.1.1.1", 9999), NODE_NONE);
669
670    CNetAddr source1 = ResolveIP("250.1.1.1");
671
672
673    AddrInfo info1 = AddrInfo(addr1, source1);
674
675    uint256 nKey1 = (HashWriter{} << 1).GetHash();
676    uint256 nKey2 = (HashWriter{} << 2).GetHash();
677
678    BOOST_CHECK_EQUAL(info1.GetTriedBucket(nKey1, ngm_asmap), 236);
679
680    // Test: Make sure key actually randomizes bucket placement. A fail on
681    //  this test could be a security issue.
682    BOOST_CHECK(info1.GetTriedBucket(nKey1, ngm_asmap) != info1.GetTriedBucket(nKey2, ngm_asmap));
683
684    // Test: Two addresses with same IP but different ports can map to
685    //  different buckets because they have different keys.
686    AddrInfo info2 = AddrInfo(addr2, source1);
687
688    BOOST_CHECK(info1.GetKey() != info2.GetKey());
689    BOOST_CHECK(info1.GetTriedBucket(nKey1, ngm_asmap) != info2.GetTriedBucket(nKey1, ngm_asmap));
690
691    std::set<int> buckets;
692    for (int j = 0; j < 255; j++) {
693        AddrInfo infoj = AddrInfo(
694            CAddress(ResolveService("101." + ToString(j) + ".1.1"), NODE_NONE),
695            ResolveIP("101." + ToString(j) + ".1.1"));
696        int bucket = infoj.GetTriedBucket(nKey1, ngm_asmap);
697        buckets.insert(bucket);
698    }
699    // Test: IP addresses in the different /16 prefix MAY map to more than
700    // 8 buckets.
701    BOOST_CHECK(buckets.size() > 8);
702
703    buckets.clear();
704    for (int j = 0; j < 255; j++) {
705        AddrInfo infoj = AddrInfo(
706            CAddress(ResolveService("250." + ToString(j) + ".1.1"), NODE_NONE),
707            ResolveIP("250." + ToString(j) + ".1.1"));
708        int bucket = infoj.GetTriedBucket(nKey1, ngm_asmap);
709        buckets.insert(bucket);
710    }
711    // Test: IP addresses in the different /16 prefix MAY NOT map to more than
712    // 8 buckets.
713    BOOST_CHECK(buckets.size() == 8);
714}
715
716BOOST_AUTO_TEST_CASE(caddrinfo_get_new_bucket)
717{
718    auto ngm_asmap{NetGroupManager::WithEmbeddedAsmap(test::data::asmap)};
719
720    CAddress addr1 = CAddress(ResolveService("250.1.2.1", 8333), NODE_NONE);
721    CAddress addr2 = CAddress(ResolveService("250.1.2.1", 9999), NODE_NONE);
722
723    CNetAddr source1 = ResolveIP("250.1.2.1");
724
725    AddrInfo info1 = AddrInfo(addr1, source1);
726
727    uint256 nKey1 = (HashWriter{} << 1).GetHash();
728    uint256 nKey2 = (HashWriter{} << 2).GetHash();
729
730    // Test: Make sure the buckets are what we expect
731    BOOST_CHECK_EQUAL(info1.GetNewBucket(nKey1, ngm_asmap), 795);
732    BOOST_CHECK_EQUAL(info1.GetNewBucket(nKey1, source1, ngm_asmap), 795);
733
734    // Test: Make sure key actually randomizes bucket placement. A fail on
735    //  this test could be a security issue.
736    BOOST_CHECK(info1.GetNewBucket(nKey1, ngm_asmap) != info1.GetNewBucket(nKey2, ngm_asmap));
737
738    // Test: Ports should not affect bucket placement in the addr
739    AddrInfo info2 = AddrInfo(addr2, source1);
740    BOOST_CHECK(info1.GetKey() != info2.GetKey());
741    BOOST_CHECK_EQUAL(info1.GetNewBucket(nKey1, ngm_asmap), info2.GetNewBucket(nKey1, ngm_asmap));
742
743    std::set<int> buckets;
744    for (int i = 0; i < 255; i++) {
745        AddrInfo infoi = AddrInfo(
746            CAddress(ResolveService("250.1.1." + ToString(i)), NODE_NONE),
747            ResolveIP("250.1.1." + ToString(i)));
748        int bucket = infoi.GetNewBucket(nKey1, ngm_asmap);
749        buckets.insert(bucket);
750    }