1// Copyright (c) 2009-2010 Satoshi Nakamoto
2// Copyright (c) 2009-present The Bitcoin Core developers
3// Distributed under the MIT software license, see the accompanying
4// file COPYING or http://www.opensource.org/licenses/mit-license.php.
5
6#include <netaddress.h>
7
8#include <crypto/common.h>
9#include <crypto/sha3.h>
10#include <hash.h>
11#include <prevector.h>
12#include <tinyformat.h>
13#include <util/strencodings.h>
14#include <util/string.h>
15
16#include <algorithm>
17#include <array>
18#include <cstdint>
19#include <ios>
20#include <iterator>
21#include <string_view>
22#include <tuple>
23
24using util::ContainsNUL;
25using util::HasPrefix;
26
27CNetAddr::BIP155Network CNetAddr::GetBIP155Network() const
28{
29    switch (m_net) {
30    case NET_IPV4:
31        return BIP155Network::IPV4;
32    case NET_IPV6:
33        return BIP155Network::IPV6;
34    case NET_ONION:
35        return BIP155Network::TORV3;
36    case NET_I2P:
37        return BIP155Network::I2P;
38    case NET_CJDNS:
39        return BIP155Network::CJDNS;
40    case NET_INTERNAL:   // should have been handled before calling this function
41    case NET_UNROUTABLE: // m_net is never and should not be set to NET_UNROUTABLE
42    case NET_MAX:        // m_net is never and should not be set to NET_MAX
43        assert(false);
44    } // no default case, so the compiler can warn about missing cases
45
46    assert(false);
47}
48
49bool CNetAddr::SetNetFromBIP155Network(uint8_t possible_bip155_net, size_t address_size)
50{
51    switch (possible_bip155_net) {
52    case BIP155Network::IPV4:
53        if (address_size == ADDR_IPV4_SIZE) {
54            m_net = NET_IPV4;
55            return true;
56        }
57        throw std::ios_base::failure(
58            strprintf("BIP155 IPv4 address with length %u (should be %u)", address_size,
59                      ADDR_IPV4_SIZE));
60    case BIP155Network::IPV6:
61        if (address_size == ADDR_IPV6_SIZE) {
62            m_net = NET_IPV6;
63            return true;
64        }
65        throw std::ios_base::failure(
66            strprintf("BIP155 IPv6 address with length %u (should be %u)", address_size,
67                      ADDR_IPV6_SIZE));
68    case BIP155Network::TORV3:
69        if (address_size == ADDR_TORV3_SIZE) {
70            m_net = NET_ONION;
71            return true;
72        }
73        throw std::ios_base::failure(
74            strprintf("BIP155 TORv3 address with length %u (should be %u)", address_size,
75                      ADDR_TORV3_SIZE));
76    case BIP155Network::I2P:
77        if (address_size == ADDR_I2P_SIZE) {
78            m_net = NET_I2P;
79            return true;
80        }
81        throw std::ios_base::failure(
82            strprintf("BIP155 I2P address with length %u (should be %u)", address_size,
83                      ADDR_I2P_SIZE));
84    case BIP155Network::CJDNS:
85        if (address_size == ADDR_CJDNS_SIZE) {
86            m_net = NET_CJDNS;
87            return true;
88        }
89        throw std::ios_base::failure(
90            strprintf("BIP155 CJDNS address with length %u (should be %u)", address_size,
91                      ADDR_CJDNS_SIZE));
92    }
93
94    // Don't throw on addresses with unknown network ids (maybe from the future).
95    // Instead silently drop them and have the unserialization code consume
96    // subsequent ones which may be known to us.
97    return false;
98}
99
100/**
101 * Construct an unspecified IPv6 network address (::/128).
102 *
103 * @note This address is considered invalid by CNetAddr::IsValid()
104 */
105CNetAddr::CNetAddr() = default;
106
107void CNetAddr::SetIP(const CNetAddr& ipIn)
108{
109    // Size check.
110    switch (ipIn.m_net) {
111    case NET_IPV4:
112        assert(ipIn.m_addr.size() == ADDR_IPV4_SIZE);
113        break;
114    case NET_IPV6:
115        assert(ipIn.m_addr.size() == ADDR_IPV6_SIZE);
116        break;
117    case NET_ONION:
118        assert(ipIn.m_addr.size() == ADDR_TORV3_SIZE);
119        break;
120    case NET_I2P:
121        assert(ipIn.m_addr.size() == ADDR_I2P_SIZE);
122        break;
123    case NET_CJDNS:
124        assert(ipIn.m_addr.size() == ADDR_CJDNS_SIZE);
125        break;
126    case NET_INTERNAL:
127        assert(ipIn.m_addr.size() == ADDR_INTERNAL_SIZE);
128        break;
129    case NET_UNROUTABLE:
130    case NET_MAX:
131        assert(false);
132    } // no default case, so the compiler can warn about missing cases
133
134    m_net = ipIn.m_net;
135    m_addr = ipIn.m_addr;
136}
137
138void CNetAddr::SetLegacyIPv6(std::span<const uint8_t> ipv6)
139{
140    assert(ipv6.size() == ADDR_IPV6_SIZE);
141
142    size_t skip{0};
143
144    if (HasPrefix(ipv6, IPV4_IN_IPV6_PREFIX)) {
145        // IPv4-in-IPv6
146        m_net = NET_IPV4;
147        skip = sizeof(IPV4_IN_IPV6_PREFIX);
148    } else if (HasPrefix(ipv6, TORV2_IN_IPV6_PREFIX)) {
149        // TORv2-in-IPv6 (unsupported). Unserialize as !IsValid(), thus ignoring them.
150        // Mimic a default-constructed CNetAddr object which is !IsValid() and thus
151        // will not be gossiped, but continue reading next addresses from the stream.
152        m_net = NET_IPV6;
153        m_addr.assign(ADDR_IPV6_SIZE, 0x0);
154        return;
155    } else if (HasPrefix(ipv6, INTERNAL_IN_IPV6_PREFIX)) {
156        // Internal-in-IPv6
157        m_net = NET_INTERNAL;
158        skip = sizeof(INTERNAL_IN_IPV6_PREFIX);
159    } else {
160        // IPv6
161        m_net = NET_IPV6;
162    }
163
164    m_addr.assign(ipv6.begin() + skip, ipv6.end());
165}
166
167/**
168 * Create an "internal" address that represents a name or FQDN. AddrMan uses
169 * these fake addresses to keep track of which DNS seeds were used.
170 * @returns Whether or not the operation was successful.
171 * @see NET_INTERNAL, INTERNAL_IN_IPV6_PREFIX, CNetAddr::IsInternal(), CNetAddr::IsRFC4193()
172 */
173bool CNetAddr::SetInternal(const std::string &name)
174{
175    if (name.empty()) {
176        return false;
177    }
178    m_net = NET_INTERNAL;
179    unsigned char hash[32] = {};
180    CSHA256().Write((const unsigned char*)name.data(), name.size()).Finalize(hash);
181    m_addr.assign(hash, hash + ADDR_INTERNAL_SIZE);
182    return true;
183}
184
185namespace torv3 {
186// https://gitlab.torproject.org/tpo/core/torspec/-/tree/main/spec/rend-spec
187static constexpr size_t CHECKSUM_LEN = 2;
188static const unsigned char VERSION[] = {3};
189static constexpr size_t TOTAL_LEN = ADDR_TORV3_SIZE + CHECKSUM_LEN + sizeof(VERSION);
190
191static void Checksum(std::span<const uint8_t> addr_pubkey, uint8_t (&checksum)[CHECKSUM_LEN])
192{
193    // TORv3 CHECKSUM = H(".onion checksum" | PUBKEY | VERSION)[:2]
194    static const unsigned char prefix[] = ".onion checksum";
195    static constexpr size_t prefix_len = 15;
196
197    SHA3_256 hasher;
198
199    hasher.Write(std::span{prefix}.first(prefix_len));
200    hasher.Write(addr_pubkey);
201    hasher.Write(VERSION);
202
203    uint8_t checksum_full[SHA3_256::OUTPUT_SIZE];
204
205    hasher.Finalize(checksum_full);
206
207    memcpy(checksum, checksum_full, sizeof(checksum));
208}
209
210}; // namespace torv3
211
212bool CNetAddr::SetSpecial(std::string_view addr)
213{
214    if (ContainsNUL(addr)) {
215        return false;
216    }
217
218    if (SetTor(addr)) {
219        return true;
220    }
221
222    if (SetI2P(addr)) {
223        return true;
224    }
225
226    return false;
227}
228
229bool CNetAddr::SetTor(std::string_view addr)
230{
231    if (!addr.ends_with(".onion")) return false;
232    addr.remove_suffix(6);
233    auto input = DecodeBase32(addr);
234
235    if (!input) {
236        return false;
237    }
238
239    if (input->size() == torv3::TOTAL_LEN) {
240        std::span<const uint8_t> input_pubkey{input->data(), ADDR_TORV3_SIZE};
241        std::span<const uint8_t> input_checksum{input->data() + ADDR_TORV3_SIZE, torv3::CHECKSUM_LEN};
242        std::span<const uint8_t> input_version{input->data() + ADDR_TORV3_SIZE + torv3::CHECKSUM_LEN, sizeof(torv3::VERSION)};
243
244        if (!std::ranges::equal(input_version, torv3::VERSION)) {
245            return false;
246        }
247
248        uint8_t calculated_checksum[torv3::CHECKSUM_LEN];
249        torv3::Checksum(input_pubkey, calculated_checksum);
250