Bitcoin Core Fuzz Coverage Report

Coverage Report

Created: 2026-03-24 13:57

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/root/bitcoin/src/netgroup.cpp
Line
Count
Source
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
uint256 NetGroupManager::GetAsmapVersion() const
15
0
{
16
0
    return AsmapVersion(m_asmap);
17
0
}
18
19
std::vector<unsigned char> NetGroupManager::GetGroup(const CNetAddr& address) const
20
0
{
21
0
    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
0
    uint32_t asn = GetMappedAS(address);
25
0
    if (asn != 0) { // Either asmap was empty, or address has non-asmappable net class (e.g. TOR).
26
0
        vchRet.push_back(NET_IPV6); // IPv4 and IPv6 with same ASN should be in the same bucket
27
0
        for (int i = 0; i < 4; i++) {
28
0
            vchRet.push_back((asn >> (8 * i)) & 0xFF);
29
0
        }
30
0
        return vchRet;
31
0
    }
32
33
0
    vchRet.push_back(address.GetNetClass());
34
0
    int nStartByte{0};
35
0
    int nBits{0};
36
37
0
    if (address.IsLocal()) {
38
        // all local addresses belong to the same group
39
0
    } 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
0
        nStartByte = INTERNAL_IN_IPV6_PREFIX.size();
43
0
        nBits = ADDR_INTERNAL_SIZE * 8;
44
0
    } else if (!address.IsRoutable()) {
45
        // all other unroutable addresses belong to the same group
46
0
    } else if (address.HasLinkedIPv4()) {
47
        // IPv4 addresses (and mapped IPv4 addresses) use /16 groups
48
0
        uint32_t ipv4 = address.GetLinkedIPv4();
49
0
        vchRet.push_back((ipv4 >> 24) & 0xFF);
50
0
        vchRet.push_back((ipv4 >> 16) & 0xFF);
51
0
        return vchRet;
52
0
    } else if (address.IsTor() || address.IsI2P()) {
53
0
        nBits = 4;
54
0
    } 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
0
        nBits = 12;
60
0
    } else if (address.IsHeNet()) {
61
        // for he.net, use /36 groups
62
0
        nBits = 36;
63
0
    } else {
64
        // for the rest of the IPv6 network, use /32 groups
65
0
        nBits = 32;
66
0
    }
67
68
    // Push our address onto vchRet.
69
0
    auto addr_bytes = address.GetAddrBytes();
70
0
    const size_t num_bytes = nBits / 8;
71
0
    vchRet.insert(vchRet.end(), addr_bytes.begin() + nStartByte, addr_bytes.begin() + nStartByte + num_bytes);
72
0
    nBits %= 8;
73
    // ...for the last byte, push nBits and for the rest of the byte push 1's
74
0
    if (nBits > 0) {
75
0
        assert(num_bytes < addr_bytes.size());
76
0
        vchRet.push_back(addr_bytes[num_bytes + nStartByte] | ((1 << (8 - nBits)) - 1));
77
0
    }
78
79
0
    return vchRet;
80
0
}
81
82
uint32_t NetGroupManager::GetMappedAS(const CNetAddr& address) const
83
0
{
84
0
    uint32_t net_class = address.GetNetClass();
85
0
    if (m_asmap.empty() || (net_class != NET_IPV4 && net_class != NET_IPV6)) {
86
0
        return 0; // Indicates not found, safe because AS0 is reserved per RFC7607.
87
0
    }
88
0
    std::vector<std::byte> ip_bytes(16);
89
0
    if (address.HasLinkedIPv4()) {
90
        // For lookup, treat as if it was just an IPv4 address (IPV4_IN_IPV6_PREFIX + IPv4 bits)
91
0
        std::copy_n(std::as_bytes(std::span{IPV4_IN_IPV6_PREFIX}).begin(),
92
0
                    IPV4_IN_IPV6_PREFIX.size(), ip_bytes.begin());
93
0
        uint32_t ipv4 = address.GetLinkedIPv4();
94
0
        for (int i = 0; i < 4; ++i) {
95
0
            ip_bytes[12 + i] = std::byte((ipv4 >> (24 - i * 8)) & 0xFF);
96
0
        }
97
0
    } else {
98
        // Use all 128 bits of the IPv6 address otherwise
99
0
        assert(address.IsIPv6());
100
0
        auto addr_bytes = address.GetAddrBytes();
101
0
        assert(addr_bytes.size() == ip_bytes.size());
102
0
        std::copy_n(std::as_bytes(std::span{addr_bytes}).begin(),
103
0
                    addr_bytes.size(), ip_bytes.begin());
104
0
    }
105
0
    uint32_t mapped_as = Interpret(m_asmap, ip_bytes);
106
0
    return mapped_as;
107
0
}
108
109
0
void NetGroupManager::ASMapHealthCheck(const std::vector<CNetAddr>& clearnet_addrs) const {
110
0
    std::set<uint32_t> clearnet_asns{};
111
0
    int unmapped_count{0};
112
113
0
    for (const auto& addr : clearnet_addrs) {
114
0
        uint32_t asn = GetMappedAS(addr);
115
0
        if (asn == 0) {
116
0
            ++unmapped_count;
117
0
            continue;
118
0
        }
119
0
        clearnet_asns.insert(asn);
120
0
    }
121
122
0
    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);
Line
Count
Source
95
0
#define LogInfo(...) LogPrintLevel_(BCLog::LogFlags::ALL, BCLog::Level::Info, /*should_ratelimit=*/true, __VA_ARGS__)
Line
Count
Source
89
0
#define LogPrintLevel_(category, level, should_ratelimit, ...) LogPrintFormatInternal(SourceLocation{__func__}, category, level, should_ratelimit, __VA_ARGS__)
123
0
}
124
125
0
bool NetGroupManager::UsingASMap() const {
126
0
    return m_asmap.size() > 0;
127
0
}