Branch data Line data Source code
1 : : // Copyright (c) 2021-2022 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 : 5980 : uint256 NetGroupManager::GetAsmapChecksum() const 12 : : { 13 [ + + ]: 5980 : if (!m_asmap.size()) return {}; 14 : : 15 : 2180 : return (HashWriter{} << m_asmap).GetHash(); 16 : 5980 : } 17 : : 18 : 46948394 : std::vector<unsigned char> NetGroupManager::GetGroup(const CNetAddr& address) const 19 : : { 20 : 46948394 : 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 [ + - ]: 46948394 : uint32_t asn = GetMappedAS(address); 24 [ + + ]: 46948394 : if (asn != 0) { // Either asmap was empty, or address has non-asmappable net class (e.g. TOR). 25 [ + - ]: 6189798 : vchRet.push_back(NET_IPV6); // IPv4 and IPv6 with same ASN should be in the same bucket 26 [ + + ]: 30948990 : for (int i = 0; i < 4; i++) { 27 [ + - ]: 24759192 : vchRet.push_back((asn >> (8 * i)) & 0xFF); 28 : 24759192 : } 29 : 6189798 : return vchRet; 30 : : } 31 : : 32 [ + - + - ]: 40758596 : vchRet.push_back(address.GetNetClass()); 33 : 40758596 : int nStartByte{0}; 34 : 40758596 : int nBits{0}; 35 : : 36 [ + - + + ]: 40758596 : if (address.IsLocal()) { 37 : : // all local addresses belong to the same group 38 [ + - + + ]: 40758596 : } 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 : 258700 : nStartByte = INTERNAL_IN_IPV6_PREFIX.size(); 42 : 258700 : nBits = ADDR_INTERNAL_SIZE * 8; 43 [ + - + + ]: 40605419 : } else if (!address.IsRoutable()) { 44 : : // all other unroutable addresses belong to the same group 45 [ + - + + ]: 40346719 : } else if (address.HasLinkedIPv4()) { 46 : : // IPv4 addresses (and mapped IPv4 addresses) use /16 groups 47 [ + - ]: 5265507 : uint32_t ipv4 = address.GetLinkedIPv4(); 48 [ + - ]: 5265507 : vchRet.push_back((ipv4 >> 24) & 0xFF); 49 [ - + ]: 5265507 : vchRet.push_back((ipv4 >> 16) & 0xFF); 50 : 5265507 : return vchRet; 51 [ + - + + : 39932452 : } else if (address.IsTor() || address.IsI2P()) { + - + + ] 52 : 17923467 : nBits = 4; 53 [ + - + + ]: 34666945 : } 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 : 7572180 : nBits = 12; 59 [ + - + + ]: 16743478 : } else if (address.IsHeNet()) { 60 : : // for he.net, use /36 groups 61 : 6079 : nBits = 36; 62 : 6079 : } else { 63 : : // for the rest of the IPv6 network, use /32 groups 64 : 9165219 : nBits = 32; 65 : : } 66 : : 67 : : // Push our address onto vchRet. 68 [ + - ]: 35493089 : auto addr_bytes = address.GetAddrBytes(); 69 : 35493089 : const size_t num_bytes = nBits / 8; 70 [ + - ]: 35493089 : vchRet.insert(vchRet.end(), addr_bytes.begin() + nStartByte, addr_bytes.begin() + nStartByte + num_bytes); 71 : 35493089 : nBits %= 8; 72 : : // ...for the last byte, push nBits and for the rest of the byte push 1's 73 [ + + ]: 35493089 : if (nBits > 0) { 74 [ + - ]: 25501727 : assert(num_bytes < addr_bytes.size()); 75 [ + - ]: 25501726 : vchRet.push_back(addr_bytes[num_bytes + nStartByte] | ((1 << (8 - nBits)) - 1)); 76 : 25501726 : } 77 : : 78 : 35493089 : return vchRet; 79 [ + - ]: 46948394 : } 80 : : 81 : 61119530 : uint32_t NetGroupManager::GetMappedAS(const CNetAddr& address) const 82 : : { 83 : 61119530 : uint32_t net_class = address.GetNetClass(); 84 [ + + + + : 61119530 : if (m_asmap.size() == 0 || (net_class != NET_IPV4 && net_class != NET_IPV6)) { + + ] 85 : 50571334 : return 0; // Indicates not found, safe because AS0 is reserved per RFC7607. 86 : : } 87 [ + - ]: 10548196 : std::vector<bool> ip_bits(128); 88 [ + - + + ]: 10548196 : if (address.HasLinkedIPv4()) { 89 : : // For lookup, treat as if it was just an IPv4 address (IPV4_IN_IPV6_PREFIX + IPv4 bits) 90 [ + + ]: 45151002 : for (int8_t byte_i = 0; byte_i < 12; ++byte_i) { 91 [ + + ]: 375100632 : for (uint8_t bit_i = 0; bit_i < 8; ++bit_i) { 92 [ + - ]: 333422784 : ip_bits[byte_i * 8 + bit_i] = (IPV4_IN_IPV6_PREFIX[byte_i] >> (7 - bit_i)) & 1; 93 : 333422784 : } 94 : 41677848 : } 95 [ - + ]: 3473154 : uint32_t ipv4 = address.GetLinkedIPv4(); 96 [ + + ]: 114614082 : for (int i = 0; i < 32; ++i) { 97 [ + - ]: 111140928 : ip_bits[96 + i] = (ipv4 >> (31 - i)) & 1; 98 : 111140928 : } 99 : 3473154 : } else { 100 : : // Use all 128 bits of the IPv6 address otherwise 101 [ + - + - ]: 7075042 : assert(address.IsIPv6()); 102 [ + - ]: 7075042 : auto addr_bytes = address.GetAddrBytes(); 103 [ + + ]: 120275714 : for (int8_t byte_i = 0; byte_i < 16; ++byte_i) { 104 : 113200672 : uint8_t cur_byte = addr_bytes[byte_i]; 105 [ + + ]: 1018806048 : for (uint8_t bit_i = 0; bit_i < 8; ++bit_i) { 106 [ + - ]: 905605376 : ip_bits[byte_i * 8 + bit_i] = (cur_byte >> (7 - bit_i)) & 1; 107 : 905605376 : } 108 : 113200672 : } 109 : 7075042 : } 110 [ + - ]: 10548196 : uint32_t mapped_as = Interpret(m_asmap, ip_bits); 111 : 10548196 : return mapped_as; 112 : 61119530 : } 113 : : 114 : 0 : void NetGroupManager::ASMapHealthCheck(const std::vector<CNetAddr>& clearnet_addrs) const { 115 : 0 : std::set<uint32_t> clearnet_asns{}; 116 : 0 : int unmapped_count{0}; 117 : : 118 [ # # ]: 0 : for (const auto& addr : clearnet_addrs) { 119 [ # # ]: 0 : uint32_t asn = GetMappedAS(addr); 120 [ # # ]: 0 : if (asn == 0) { 121 : 0 : ++unmapped_count; 122 : 0 : continue; 123 : : } 124 [ # # ]: 0 : clearnet_asns.insert(asn); 125 [ # # # # : 0 : } # ] 126 : : 127 [ # # # # : 0 : 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 : 0 : } 129 : : 130 : 0 : bool NetGroupManager::UsingASMap() const { 131 : 0 : return m_asmap.size() > 0; 132 : : }