251        if (!std::ranges::equal(input_checksum, calculated_checksum)) {
252            return false;
253        }
254
255        m_net = NET_ONION;
256        m_addr.assign(input_pubkey.begin(), input_pubkey.end());
257        return true;
258    }
259
260    return false;
261}
262
263bool CNetAddr::SetI2P(std::string_view addr)
264{
265    // I2P addresses that we support consist of 52 base32 characters + ".b32.i2p".
266    static constexpr size_t b32_len{52};
267    static const char* suffix{".b32.i2p"};
268    static constexpr size_t suffix_len{8};
269
270    if (addr.size() != b32_len + suffix_len || ToLower(addr.substr(b32_len)) != suffix) {
271        return false;
272    }
273
274    // Remove the ".b32.i2p" suffix and pad to a multiple of 8 chars, so DecodeBase32()
275    // can decode it.
276    const std::string b32_padded{tfm::format("%s====", addr.substr(0, b32_len))};
277
278    auto address_bytes = DecodeBase32(b32_padded);
279
280    if (!address_bytes || address_bytes->size() != ADDR_I2P_SIZE) {
281        return false;
282    }
283
284    m_net = NET_I2P;
285    m_addr.assign(address_bytes->begin(), address_bytes->end());
286
287    return true;
288}
289
290CNetAddr::CNetAddr(const struct in_addr& ipv4Addr)
291{
292    m_net = NET_IPV4;
293    const uint8_t* ptr = reinterpret_cast<const uint8_t*>(&ipv4Addr);
294    m_addr.assign(ptr, ptr + ADDR_IPV4_SIZE);
295}
296
297CNetAddr::CNetAddr(const struct in6_addr& ipv6Addr, const uint32_t scope)
298{
299    SetLegacyIPv6({reinterpret_cast<const uint8_t*>(&ipv6Addr), sizeof(ipv6Addr)});
300    m_scope_id = scope;
301}
302
303bool CNetAddr::IsBindAny() const
304{
305    if (!IsIPv4() && !IsIPv6()) {
306        return false;
307    }
308    return std::all_of(m_addr.begin(), m_addr.end(), [](uint8_t b) { return b == 0; });
309}
310
311bool CNetAddr::IsRFC1918() const
312{
313    return IsIPv4() && (
314        m_addr[0] == 10 ||
315        (m_addr[0] == 192 && m_addr[1] == 168) ||
316        (m_addr[0] == 172 && m_addr[1] >= 16 && m_addr[1] <= 31));
317}
318
319bool CNetAddr::IsRFC2544() const
320{
321    return IsIPv4() && m_addr[0] == 198 && (m_addr[1] == 18 || m_addr[1] == 19);
322}
323
324bool CNetAddr::IsRFC3927() const
325{
326    return IsIPv4() && HasPrefix(m_addr, std::array<uint8_t, 2>{169, 254});
327}
328
329bool CNetAddr::IsRFC6598() const
330{
331    return IsIPv4() && m_addr[0] == 100 && m_addr[1] >= 64 && m_addr[1] <= 127;
332}
333
334bool CNetAddr::IsRFC5737() const
335{
336    return IsIPv4() && (HasPrefix(m_addr, std::array<uint8_t, 3>{192, 0, 2}) ||
337                        HasPrefix(m_addr, std::array<uint8_t, 3>{198, 51, 100}) ||
338                        HasPrefix(m_addr, std::array<uint8_t, 3>{203, 0, 113}));
339}
340
341bool CNetAddr::IsRFC3849() const
342{
343    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 4>{0x20, 0x01, 0x0D, 0xB8});
344}
345
346bool CNetAddr::IsRFC9637() const
347{
348    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 2>{0x3F, 0xFF}) &&
349           (m_addr[2] & 0xF0) == 0x00;
350}
351
352bool CNetAddr::IsRFC3964() const
353{
354    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 2>{0x20, 0x02});
355}
356
357bool CNetAddr::IsRFC6052() const
358{
359    return IsIPv6() &&
360           HasPrefix(m_addr, std::array<uint8_t, 12>{0x00, 0x64, 0xFF, 0x9B, 0x00, 0x00,
361                                                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00});
362}
363
364bool CNetAddr::IsRFC4380() const
365{
366    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 4>{0x20, 0x01, 0x00, 0x00});
367}
368
369bool CNetAddr::IsRFC4862() const
370{
371    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 8>{0xFE, 0x80, 0x00, 0x00,
372                                                                0x00, 0x00, 0x00, 0x00});
373}
374
375bool CNetAddr::IsRFC4193() const
376{
377    return IsIPv6() && (m_addr[0] & 0xFE) == 0xFC;
378}
379
380bool CNetAddr::IsRFC6145() const
381{
382    return IsIPv6() &&
383           HasPrefix(m_addr, std::array<uint8_t, 12>{0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
384                                                     0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00});
385}
386
387bool CNetAddr::IsRFC4843() const
388{
389    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 3>{0x20, 0x01, 0x00}) &&
390           (m_addr[3] & 0xF0) == 0x10;
391}
392
393bool CNetAddr::IsRFC7343() const
394{
395    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 3>{0x20, 0x01, 0x00}) &&
396           (m_addr[3] & 0xF0) == 0x20;
397}
398
399bool CNetAddr::IsHeNet() const
400{
401    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 4>{0x20, 0x01, 0x04, 0x70});
402}
403
404bool CNetAddr::IsLocal() const
405{
406    // IPv4 loopback (127.0.0.0/8 or 0.0.0.0/8)
407    if (IsIPv4() && (m_addr[0] == 127 || m_addr[0] == 0)) {
408        return true;
409    }
410
411    // IPv6 loopback (::1/128)
412    static const unsigned char pchLocal[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1};
413    if (IsIPv6() && memcmp(m_addr.data(), pchLocal, sizeof(pchLocal)) == 0) {
414        return true;
415    }
416
417    return false;
418}
419
420/**
421 * @returns Whether or not this network address is a valid address that @a could
422 *          be used to refer to an actual host.
423 *
424 * @note A valid address may or may not be publicly routable on the global
425 *       internet. As in, the set of valid addresses is a superset of the set of
426 *       publicly routable addresses.
427 *
428 * @see CNetAddr::IsRoutable()
429 */
430bool CNetAddr::IsValid() const
431{
432    // unspecified IPv6 address (::/128)
433    unsigned char ipNone6[16] = {};
434    if (IsIPv6() && memcmp(m_addr.data(), ipNone6, sizeof(ipNone6)) == 0) {
435        return false;
436    }
437
438    if (IsCJDNS() && !HasCJDNSPrefix()) {
439        return false;
440    }
441
442    // documentation IPv6 address
443    if (IsRFC3849() || IsRFC9637())
444        return false;
445
446    if (IsInternal())
447        return false;
448
449    if (IsIPv4()) {
450        const uint32_t addr = ReadBE32(m_addr.data());
451        if (addr == INADDR_ANY || addr == INADDR_NONE) {
452            return false;
453        }
454    }
455
456    return true;
457}
458
459/**
460 * @returns Whether or not this network address is publicly routable on the
461 *          global internet.
462 *
463 * @note A routable address is always valid. As in, the set of routable addresses
464 *       is a subset of the set of valid addresses.
465 *
466 * @see CNetAddr::IsValid()
467 */
468bool CNetAddr::IsRoutable() const
469{
470    return IsValid() && !(IsRFC1918() || IsRFC2544() || IsRFC3927() || IsRFC4862() || IsRFC6598() || IsRFC5737() || IsRFC4193() || IsRFC4843() || IsRFC7343() || IsLocal() || IsInternal());
471}
472
473/**
474 * @returns Whether or not this is a dummy address that represents a name.
475 *
476 * @see CNetAddr::SetInternal(const std::string &)
477 */
478bool CNetAddr::IsInternal() const
479{
480   return m_net == NET_INTERNAL;
481}
482
483bool CNetAddr::IsAddrV1Compatible() const
484{
485    switch (m_net) {
486    case NET_IPV4:
487    case NET_IPV6:
488    case NET_INTERNAL:
489        return true;
490    case NET_ONION:
491    case NET_I2P:
492    case NET_CJDNS:
493        return false;
494    case NET_UNROUTABLE: // m_net is never and should not be set to NET_UNROUTABLE
495    case NET_MAX:        // m_net is never and should not be set to NET_MAX
496        assert(false);
497    } // no default case, so the compiler can warn about missing cases
498
499    assert(false);
500}