Branch data Line data Source code
1 : : // Copyright (c) 2021-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 <netgroup.h>
6 : :
7 : : #include <hash.h>
8 : : #include <logging.h>
9 : : #include <uint256.h>
10 : : #include <util/asmap.h>
11 : :
12 : : #include <cstddef>
13 : :
14 : 2132 : uint256 NetGroupManager::GetAsmapVersion() const
15 : : {
16 : 2132 : return AsmapVersion(m_asmap);
17 : : }
18 : :
19 : 86807 : std::vector<unsigned char> NetGroupManager::GetGroup(const CNetAddr& address) const
20 : : {
21 : 86807 : std::vector<unsigned char> vchRet;
22 : : // If non-empty asmap is supplied and the address is IPv4/IPv6,
23 : : // return ASN to be used for bucketing.
24 [ + - ]: 86807 : uint32_t asn = GetMappedAS(address);
25 [ + + ]: 86807 : if (asn != 0) { // Either asmap was empty, or address has non-asmappable net class (e.g. TOR).
26 [ + - ]: 3690 : vchRet.push_back(NET_IPV6); // IPv4 and IPv6 with same ASN should be in the same bucket
27 [ + + ]: 18450 : for (int i = 0; i < 4; i++) {
28 [ + - ]: 14760 : vchRet.push_back((asn >> (8 * i)) & 0xFF);
29 : : }
30 : : return vchRet;
31 : : }
32 : :
33 [ + - + - ]: 83117 : vchRet.push_back(address.GetNetClass());
34 : 83117 : int nStartByte{0};
35 : 83117 : int nBits{0};
36 : :
37 [ + - + + ]: 83117 : if (address.IsLocal()) {
38 : : // all local addresses belong to the same group
39 [ + - + + ]: 80220 : } else if (address.IsInternal()) {
40 : : // All internal-usage addresses get their own group.
41 : : // Skip over the INTERNAL_IN_IPV6_PREFIX returned by CAddress::GetAddrBytes().
42 : : nStartByte = INTERNAL_IN_IPV6_PREFIX.size();
43 : : nBits = ADDR_INTERNAL_SIZE * 8;
44 [ + - + + ]: 80219 : } else if (!address.IsRoutable()) {
45 : : // all other unroutable addresses belong to the same group
46 [ + - + + ]: 80085 : } else if (address.HasLinkedIPv4()) {
47 : : // IPv4 addresses (and mapped IPv4 addresses) use /16 groups
48 [ + - ]: 79576 : uint32_t ipv4 = address.GetLinkedIPv4();
49 [ + - ]: 79576 : vchRet.push_back((ipv4 >> 24) & 0xFF);
50 [ + - ]: 86807 : vchRet.push_back((ipv4 >> 16) & 0xFF);
51 : : return vchRet;
52 [ + + + + ]: 509 : } else if (address.IsTor() || address.IsI2P()) {
53 : : nBits = 4;
54 [ + + ]: 350 : } else if (address.IsCJDNS()) {
55 : : // Treat in the same way as Tor and I2P because the address in all of
56 : : // them is "random" bytes (derived from a public key). However in CJDNS
57 : : // the first byte is a constant (see CJDNS_PREFIX), so the random bytes
58 : : // come after it. Thus skip the constant 8 bits at the start.
59 : : nBits = 12;
60 [ + - + + ]: 293 : } else if (address.IsHeNet()) {
61 : : // for he.net, use /36 groups
62 : : nBits = 36;
63 : : } else {
64 : : // for the rest of the IPv6 network, use /32 groups
65 : 292 : nBits = 32;
66 : : }
67 : :
68 : : // Push our address onto vchRet.
69 [ + - ]: 3541 : auto addr_bytes = address.GetAddrBytes();
70 : 3541 : const size_t num_bytes = nBits / 8;
71 [ + - ]: 3541 : vchRet.insert(vchRet.end(), addr_bytes.begin() + nStartByte, addr_bytes.begin() + nStartByte + num_bytes);
72 : 3541 : nBits %= 8;
73 : : // ...for the last byte, push nBits and for the rest of the byte push 1's
74 [ + + ]: 3541 : if (nBits > 0) {
75 [ - + - + ]: 217 : assert(num_bytes < addr_bytes.size());
76 [ + - ]: 217 : vchRet.push_back(addr_bytes[num_bytes + nStartByte] | ((1 << (8 - nBits)) - 1));
77 : : }
78 : :
79 : 3541 : return vchRet;
80 : 3541 : }
81 : :
82 : 135385 : uint32_t NetGroupManager::GetMappedAS(const CNetAddr& address) const
83 : : {
84 : 135385 : uint32_t net_class = address.GetNetClass();
85 [ + + + + ]: 135385 : if (m_asmap.empty() || (net_class != NET_IPV4 && net_class != NET_IPV6)) {
86 : : return 0; // Indicates not found, safe because AS0 is reserved per RFC7607.
87 : : }
88 : 4210 : std::vector<std::byte> ip_bytes(16);
89 [ + - + + ]: 4210 : if (address.HasLinkedIPv4()) {
90 : : // For lookup, treat as if it was just an IPv4 address (IPV4_IN_IPV6_PREFIX + IPv4 bits)
91 : 4191 : std::copy_n(std::as_bytes(std::span{IPV4_IN_IPV6_PREFIX}).begin(),
92 : : IPV4_IN_IPV6_PREFIX.size(), ip_bytes.begin());
93 [ + - ]: 4191 : uint32_t ipv4 = address.GetLinkedIPv4();
94 [ + + ]: 20955 : for (int i = 0; i < 4; ++i) {
95 : 16764 : ip_bytes[12 + i] = std::byte((ipv4 >> (24 - i * 8)) & 0xFF);
96 : : }
97 : : } else {
98 : : // Use all 128 bits of the IPv6 address otherwise
99 [ - + ]: 19 : assert(address.IsIPv6());
100 [ + - ]: 19 : auto addr_bytes = address.GetAddrBytes();
101 [ - + - + : 19 : assert(addr_bytes.size() == ip_bytes.size());
- + ]
102 : 19 : std::copy_n(std::as_bytes(std::span{addr_bytes}).begin(),
103 : : addr_bytes.size(), ip_bytes.begin());
104 : 19 : }
105 [ - + + - ]: 4210 : uint32_t mapped_as = Interpret(m_asmap, ip_bytes);
106 : 4210 : return mapped_as;
107 : 4210 : }
108 : :
109 : 5 : void NetGroupManager::ASMapHealthCheck(const std::vector<CNetAddr>& clearnet_addrs) const {
110 : 5 : std::set<uint32_t> clearnet_asns{};
111 : 5 : int unmapped_count{0};
112 : :
113 [ + + ]: 13 : for (const auto& addr : clearnet_addrs) {
114 [ + - ]: 8 : uint32_t asn = GetMappedAS(addr);
115 [ - + ]: 8 : if (asn == 0) {
116 : 0 : ++unmapped_count;
117 : 0 : continue;
118 : : }
119 [ + - ]: 8 : clearnet_asns.insert(asn);
120 : : }
121 : :
122 [ - + + - ]: 5 : LogInfo("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);
123 : 5 : }
124 : :
125 : 1022 : bool NetGroupManager::UsingASMap() const {
126 : 1022 : return m_asmap.size() > 0;
127 : : }
|
