Line data    Source code

       1             : // Copyright (c) 2021 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 <netgroup.h>
       6             : 
       7             : #include <hash.h>
       8             : #include <logging.h>
       9             : #include <util/asmap.h>
      10             : 
      11        7040 : uint256 NetGroupManager::GetAsmapChecksum() const
      12             : {
      13        7040 :     if (!m_asmap.size()) return {};
      14             : 
      15          33 :     return (HashWriter{} << m_asmap).GetHash();
      16        7040 : }
      17             : 
      18      234965 : std::vector<unsigned char> NetGroupManager::GetGroup(const CNetAddr& address) const
      19             : {
      20      234965 :     std::vector<unsigned char> vchRet;
      21             :     // If non-empty asmap is supplied and the address is IPv4/IPv6,
      22             :     // return ASN to be used for bucketing.
      23      234965 :     uint32_t asn = GetMappedAS(address);
      24      234963 :     if (asn != 0) { // Either asmap was empty, or address has non-asmappable net class (e.g. TOR).
      25        3682 :         vchRet.push_back(NET_IPV6); // IPv4 and IPv6 with same ASN should be in the same bucket
      26       18410 :         for (int i = 0; i < 4; i++) {
      27       14728 :             vchRet.push_back((asn >> (8 * i)) & 0xFF);
      28       14728 :         }
      29        3682 :         return vchRet;
      30             :     }
      31             : 
      32      231281 :     vchRet.push_back(address.GetNetClass());
      33      231280 :     int nStartByte{0};
      34      231280 :     int nBits{0};
      35             : 
      36      231280 :     if (address.IsLocal()) {
      37             :         // all local addresses belong to the same group
      38      231280 :     } else if (address.IsInternal()) {
      39             :         // All internal-usage addresses get their own group.
      40             :         // Skip over the INTERNAL_IN_IPV6_PREFIX returned by CAddress::GetAddrBytes().
      41           1 :         nStartByte = INTERNAL_IN_IPV6_PREFIX.size();
      42           1 :         nBits = ADDR_INTERNAL_SIZE * 8;
      43      218836 :     } else if (!address.IsRoutable()) {
      44             :         // all other unroutable addresses belong to the same group
      45      218835 :     } else if (address.HasLinkedIPv4()) {
      46             :         // IPv4 addresses (and mapped IPv4 addresses) use /16 groups
      47      141121 :         uint32_t ipv4 = address.GetLinkedIPv4();
      48      141121 :         vchRet.push_back((ipv4 >> 24) & 0xFF);
      49      141121 :         vchRet.push_back((ipv4 >> 16) & 0xFF);
      50      141121 :         return vchRet;
      51         486 :     } else if (address.IsTor() || address.IsI2P()) {
      52          24 :         nBits = 4;
      53         486 :     } else if (address.IsCJDNS()) {
      54             :         // Treat in the same way as Tor and I2P because the address in all of
      55             :         // them is "random" bytes (derived from a public key). However in CJDNS
      56             :         // the first byte is a constant (see CJDNS_PREFIX), so the random bytes
      57             :         // come after it. Thus skip the constant 8 bits at the start.
      58           2 :         nBits = 12;
      59         462 :     } else if (address.IsHeNet()) {
      60             :         // for he.net, use /36 groups
      61           1 :         nBits = 36;
      62           1 :     } else {
      63             :         // for the rest of the IPv6 network, use /32 groups
      64         459 :         nBits = 32;
      65             :     }
      66             : 
      67             :     // Push our address onto vchRet.
      68       90159 :     auto addr_bytes = address.GetAddrBytes();
      69       90160 :     const size_t num_bytes = nBits / 8;
      70       90160 :     vchRet.insert(vchRet.end(), addr_bytes.begin() + nStartByte, addr_bytes.begin() + nStartByte + num_bytes);
      71       90160 :     nBits %= 8;
      72             :     // ...for the last byte, push nBits and for the rest of the byte push 1's
      73       90160 :     if (nBits > 0) {
      74          27 :         assert(num_bytes < addr_bytes.size());
      75          27 :         vchRet.push_back(addr_bytes[num_bytes + nStartByte] | ((1 << (8 - nBits)) - 1));
      76          27 :     }
      77             : 
      78       90160 :     return vchRet;
      79      234967 : }
      80             : 
      81      400099 : uint32_t NetGroupManager::GetMappedAS(const CNetAddr& address) const
      82             : {
      83      400099 :     uint32_t net_class = address.GetNetClass();
      84      400099 :     if (m_asmap.size() == 0 || (net_class != NET_IPV4 && net_class != NET_IPV6)) {
      85      395926 :         return 0; // Indicates not found, safe because AS0 is reserved per RFC7607.
      86             :     }
      87        4173 :     std::vector<bool> ip_bits(128);
      88        4173 :     if (address.HasLinkedIPv4()) {
      89             :         // For lookup, treat as if it was just an IPv4 address (IPV4_IN_IPV6_PREFIX + IPv4 bits)
      90       54249 :         for (int8_t byte_i = 0; byte_i < 12; ++byte_i) {
      91      450684 :             for (uint8_t bit_i = 0; bit_i < 8; ++bit_i) {
      92      400608 :                 ip_bits[byte_i * 8 + bit_i] = (IPV4_IN_IPV6_PREFIX[byte_i] >> (7 - bit_i)) & 1;
      93      400608 :             }
      94       50076 :         }
      95        4173 :         uint32_t ipv4 = address.GetLinkedIPv4();
      96      137709 :         for (int i = 0; i < 32; ++i) {
      97      133536 :             ip_bits[96 + i] = (ipv4 >> (31 - i)) & 1;
      98      133536 :         }
      99        4173 :     } else {
     100             :         // Use all 128 bits of the IPv6 address otherwise
     101           0 :         assert(address.IsIPv6());
     102           0 :         auto addr_bytes = address.GetAddrBytes();
     103           0 :         for (int8_t byte_i = 0; byte_i < 16; ++byte_i) {
     104           0 :             uint8_t cur_byte = addr_bytes[byte_i];
     105           0 :             for (uint8_t bit_i = 0; bit_i < 8; ++bit_i) {
     106           0 :                 ip_bits[byte_i * 8 + bit_i] = (cur_byte >> (7 - bit_i)) & 1;
     107           0 :             }
     108           0 :         }
     109           0 :     }
     110        4173 :     uint32_t mapped_as = Interpret(m_asmap, ip_bits);
     111        4173 :     return mapped_as;
     112      400099 : }
     113             : 
     114          14 : void NetGroupManager::ASMapHealthCheck(const std::vector<CNetAddr>& clearnet_addrs) const {
     115          14 :     std::set<uint32_t> clearnet_asns{};
     116          14 :     int unmapped_count{0};
     117             : 
     118          22 :     for (const auto& addr : clearnet_addrs) {
     119           8 :         uint32_t asn = GetMappedAS(addr);
     120           8 :         if (asn == 0) {
     121           0 :             ++unmapped_count;
     122           0 :             continue;
     123             :         }
     124           8 :         clearnet_asns.insert(asn);
     125             :     }
     126             : 
     127          14 :     LogPrintf("ASMap Health Check: %i clearnet peers are mapped to %i ASNs with %i peers being unmapped\n", clearnet_addrs.size(), clearnet_asns.size(), unmapped_count);
     128          14 : }
     129             : 
     130        2821 : bool NetGroupManager::UsingASMap() const {
     131        2821 :     return m_asmap.size() > 0;
     132             : }