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