Branch data Line data Source code
# 1 : : // Copyright (c) 2009-2010 Satoshi Nakamoto
# 2 : : // Copyright (c) 2009-2020 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 <cstdint>
# 7 : : #include <netaddress.h>
# 8 : : #include <hash.h>
# 9 : : #include <util/strencodings.h>
# 10 : : #include <util/asmap.h>
# 11 : : #include <tinyformat.h>
# 12 : :
# 13 : : constexpr size_t CNetAddr::V1_SERIALIZATION_SIZE;
# 14 : :
# 15 : : /**
# 16 : : * Construct an unspecified IPv6 network address (::/128).
# 17 : : *
# 18 : : * @note This address is considered invalid by CNetAddr::IsValid()
# 19 : : */
# 20 : 1175228 : CNetAddr::CNetAddr() {}
# 21 : :
# 22 : : void CNetAddr::SetIP(const CNetAddr& ipIn)
# 23 : 2 : {
# 24 : 2 : m_net = ipIn.m_net;
# 25 : 2 : m_addr = ipIn.m_addr;
# 26 : 2 : }
# 27 : :
# 28 : : void CNetAddr::SetLegacyIPv6(const uint8_t (&ipv6)[ADDR_IPv6_SIZE])
# 29 : 3905 : {
# 30 : 3905 : const uint8_t* ipv6_end = ipv6 + ADDR_IPv6_SIZE;
# 31 : 3905 :
# 32 : 3905 : if (memcmp(ipv6, IPv4_IN_IPv6_PREFIX, sizeof(IPv4_IN_IPv6_PREFIX)) == 0) {
# 33 : 1760 : // IPv4-in-IPv6
# 34 : 1760 : m_net = NET_IPV4;
# 35 : 1760 : m_addr.assign(ipv6 + sizeof(IPv4_IN_IPv6_PREFIX), ipv6_end);
# 36 : 2145 : } else if (memcmp(ipv6, TORv2_IN_IPv6_PREFIX, sizeof(TORv2_IN_IPv6_PREFIX)) == 0) {
# 37 : 8 : // TORv2-in-IPv6
# 38 : 8 : m_net = NET_ONION;
# 39 : 8 : m_addr.assign(ipv6 + sizeof(TORv2_IN_IPv6_PREFIX), ipv6_end);
# 40 : 2137 : } else if (memcmp(ipv6, INTERNAL_IN_IPv6_PREFIX, sizeof(INTERNAL_IN_IPv6_PREFIX)) == 0) {
# 41 : 2 : // Internal-in-IPv6
# 42 : 2 : m_net = NET_INTERNAL;
# 43 : 2 : m_addr.assign(ipv6 + sizeof(INTERNAL_IN_IPv6_PREFIX), ipv6_end);
# 44 : 2135 : } else {
# 45 : 2135 : // IPv6
# 46 : 2135 : m_net = NET_IPV6;
# 47 : 2135 : m_addr.assign(ipv6, ipv6_end);
# 48 : 2135 : }
# 49 : 3905 : }
# 50 : :
# 51 : : /**
# 52 : : * Try to make this a dummy address that maps the specified name into IPv6 like
# 53 : : * so: (0xFD + %sha256("bitcoin")[0:5]) + %sha256(name)[0:10]. Such dummy
# 54 : : * addresses have a prefix of fd6b:88c0:8724::/48 and are guaranteed to not be
# 55 : : * publicly routable as it falls under RFC4193's fc00::/7 subnet allocated to
# 56 : : * unique-local addresses.
# 57 : : *
# 58 : : * CAddrMan uses these fake addresses to keep track of which DNS seeds were
# 59 : : * used.
# 60 : : *
# 61 : : * @returns Whether or not the operation was successful.
# 62 : : *
# 63 : : * @see CNetAddr::IsInternal(), CNetAddr::IsRFC4193()
# 64 : : */
# 65 : : bool CNetAddr::SetInternal(const std::string &name)
# 66 : 433 : {
# 67 : 433 : if (name.empty()) {
# 68 : 0 : return false;
# 69 : 0 : }
# 70 : 433 : m_net = NET_INTERNAL;
# 71 : 433 : unsigned char hash[32] = {};
# 72 : 433 : CSHA256().Write((const unsigned char*)name.data(), name.size()).Finalize(hash);
# 73 : 433 : m_addr.assign(hash, hash + ADDR_INTERNAL_SIZE);
# 74 : 433 : return true;
# 75 : 433 : }
# 76 : :
# 77 : : /**
# 78 : : * Parse a TORv2 address and set this object to it.
# 79 : : *
# 80 : : * @returns Whether or not the operation was successful.
# 81 : : *
# 82 : : * @see CNetAddr::IsTor()
# 83 : : */
# 84 : : bool CNetAddr::SetSpecial(const std::string &strName)
# 85 : 219949 : {
# 86 : 219949 : if (strName.size()>6 && strName.substr(strName.size() - 6, 6) == ".onion") {
# 87 : 11 : std::vector<unsigned char> vchAddr = DecodeBase32(strName.substr(0, strName.size() - 6).c_str());
# 88 : 11 : if (vchAddr.size() != ADDR_TORv2_SIZE)
# 89 : 0 : return false;
# 90 : 11 : m_net = NET_ONION;
# 91 : 11 : m_addr.assign(vchAddr.begin(), vchAddr.end());
# 92 : 11 : return true;
# 93 : 11 : }
# 94 : 219938 : return false;
# 95 : 219938 : }
# 96 : :
# 97 : : CNetAddr::CNetAddr(const struct in_addr& ipv4Addr)
# 98 : 219903 : {
# 99 : 219903 : m_net = NET_IPV4;
# 100 : 219903 : const uint8_t* ptr = reinterpret_cast<const uint8_t*>(&ipv4Addr);
# 101 : 219903 : m_addr.assign(ptr, ptr + ADDR_IPv4_SIZE);
# 102 : 219903 : }
# 103 : :
# 104 : : CNetAddr::CNetAddr(const struct in6_addr& ipv6Addr, const uint32_t scope)
# 105 : 1202 : {
# 106 : 1202 : assert(sizeof(ipv6Addr) == ADDR_IPv6_SIZE);
# 107 : 1202 : SetLegacyIPv6(*reinterpret_cast<const uint8_t (*)[ADDR_IPv6_SIZE]>(&ipv6Addr));
# 108 : 1202 : scopeId = scope;
# 109 : 1202 : }
# 110 : :
# 111 : : bool CNetAddr::IsBindAny() const
# 112 : 1070 : {
# 113 : 1070 : if (!IsIPv4() && !IsIPv6()) {
# 114 : 4 : return false;
# 115 : 4 : }
# 116 : 9022 : for (uint8_t b : m_addr) {
# 117 : 9022 : if (b != 0) {
# 118 : 1062 : return false;
# 119 : 1062 : }
# 120 : 9022 : }
# 121 : 1066 :
# 122 : 1066 : return true;
# 123 : 1066 : }
# 124 : :
# 125 : : bool CNetAddr::IsIPv4() const
# 126 : 2263982 : {
# 127 : 2263982 : if (m_net == NET_IPV4) {
# 128 : 2231074 : assert(m_addr.size() == ADDR_IPv4_SIZE);
# 129 : 2231074 : return true;
# 130 : 2231074 : }
# 131 : 32908 : return false;
# 132 : 32908 : }
# 133 : :
# 134 : : bool CNetAddr::IsIPv6() const
# 135 : 2233188 : {
# 136 : 2233188 : if (m_net == NET_IPV6) {
# 137 : 139679 : assert(m_addr.size() == ADDR_IPv6_SIZE);
# 138 : 139679 : return true;
# 139 : 139679 : }
# 140 : 2093509 : return false;
# 141 : 2093509 : }
# 142 : :
# 143 : : bool CNetAddr::IsRFC1918() const
# 144 : 200616 : {
# 145 : 200616 : return IsIPv4() && (
# 146 : 200492 : m_addr[0] == 10 ||
# 147 : 200492 : (m_addr[0] == 192 && m_addr[1] == 168) ||
# 148 : 200492 : (m_addr[0] == 172 && m_addr[1] >= 16 && m_addr[1] <= 31));
# 149 : 200616 : }
# 150 : :
# 151 : : bool CNetAddr::IsRFC2544() const
# 152 : 200592 : {
# 153 : 200592 : return IsIPv4() && m_addr[0] == 198 && (m_addr[1] == 18 || m_addr[1] == 19);
# 154 : 200592 : }
# 155 : :
# 156 : : bool CNetAddr::IsRFC3927() const
# 157 : 200590 : {
# 158 : 200590 : return IsIPv4() && m_addr[0] == 169 && m_addr[1] == 254;
# 159 : 200590 : }
# 160 : :
# 161 : : bool CNetAddr::IsRFC6598() const
# 162 : 200582 : {
# 163 : 200582 : return IsIPv4() && m_addr[0] == 100 && m_addr[1] >= 64 && m_addr[1] <= 127;
# 164 : 200582 : }
# 165 : :
# 166 : : bool CNetAddr::IsRFC5737() const
# 167 : 200582 : {
# 168 : 200582 : return IsIPv4() && ((m_addr[0] == 192 && m_addr[1] == 0 && m_addr[2] == 2) ||
# 169 : 200458 : (m_addr[0] == 198 && m_addr[1] == 51 && m_addr[2] == 100) ||
# 170 : 200458 : (m_addr[0] == 203 && m_addr[1] == 0 && m_addr[2] == 113));
# 171 : 200582 : }
# 172 : :
# 173 : : bool CNetAddr::IsRFC3849() const
# 174 : 337705 : {
# 175 : 337705 : return IsIPv6() && m_addr[0] == 0x20 && m_addr[1] == 0x01 &&
# 176 : 337705 : m_addr[2] == 0x0D && m_addr[3] == 0xB8;
# 177 : 337705 : }
# 178 : :
# 179 : : bool CNetAddr::IsRFC3964() const
# 180 : 45 : {
# 181 : 45 : return IsIPv6() && m_addr[0] == 0x20 && m_addr[1] == 0x02;
# 182 : 45 : }
# 183 : :
# 184 : : bool CNetAddr::IsRFC6052() const
# 185 : 55 : {
# 186 : 55 : static const unsigned char pchRFC6052[] = {0,0x64,0xFF,0x9B,0,0,0,0,0,0,0,0};
# 187 : 55 : return IsIPv6() && memcmp(m_addr.data(), pchRFC6052, sizeof(pchRFC6052)) == 0;
# 188 : 55 : }
# 189 : :
# 190 : : bool CNetAddr::IsRFC4380() const
# 191 : 37 : {
# 192 : 37 : return IsIPv6() && m_addr[0] == 0x20 && m_addr[1] == 0x01 && m_addr[2] == 0x00 &&
# 193 : 37 : m_addr[3] == 0x00;
# 194 : 37 : }
# 195 : :
# 196 : : bool CNetAddr::IsRFC4862() const
# 197 : 200584 : {
# 198 : 200584 : static const unsigned char pchRFC4862[] = {0xFE,0x80,0,0,0,0,0,0};
# 199 : 200584 : return IsIPv6() && memcmp(m_addr.data(), pchRFC4862, sizeof(pchRFC4862)) == 0;
# 200 : 200584 : }
# 201 : :
# 202 : : bool CNetAddr::IsRFC4193() const
# 203 : 200584 : {
# 204 : 200584 : return IsIPv6() && (m_addr[0] & 0xFE) == 0xFC;
# 205 : 200584 : }
# 206 : :
# 207 : : bool CNetAddr::IsRFC6145() const
# 208 : 57 : {
# 209 : 57 : static const unsigned char pchRFC6145[] = {0,0,0,0,0,0,0,0,0xFF,0xFF,0,0};
# 210 : 57 : return IsIPv6() && memcmp(m_addr.data(), pchRFC6145, sizeof(pchRFC6145)) == 0;
# 211 : 57 : }
# 212 : :
# 213 : : bool CNetAddr::IsRFC4843() const
# 214 : 200584 : {
# 215 : 200584 : return IsIPv6() && m_addr[0] == 0x20 && m_addr[1] == 0x01 &&
# 216 : 200584 : m_addr[2] == 0x00 && (m_addr[3] & 0xF0) == 0x10;
# 217 : 200584 : }
# 218 : :
# 219 : : bool CNetAddr::IsRFC7343() const
# 220 : 200584 : {
# 221 : 200584 : return IsIPv6() && m_addr[0] == 0x20 && m_addr[1] == 0x01 &&
# 222 : 200584 : m_addr[2] == 0x00 && (m_addr[3] & 0xF0) == 0x20;
# 223 : 200584 : }
# 224 : :
# 225 : : bool CNetAddr::IsHeNet() const
# 226 : 4 : {
# 227 : 4 : return IsIPv6() && m_addr[0] == 0x20 && m_addr[1] == 0x01 && m_addr[2] == 0x04 && m_addr[3] == 0x70;
# 228 : 4 : }
# 229 : :
# 230 : : /**
# 231 : : * @returns Whether or not this is a dummy address that maps an onion address
# 232 : : * into IPv6.
# 233 : : *
# 234 : : * @see CNetAddr::SetSpecial(const std::string &)
# 235 : : */
# 236 : 163430 : bool CNetAddr::IsTor() const { return m_net == NET_ONION; }
# 237 : :
# 238 : : bool CNetAddr::IsLocal() const
# 239 : 323177 : {
# 240 : 323177 : // IPv4 loopback (127.0.0.0/8 or 0.0.0.0/8)
# 241 : 323177 : if (IsIPv4() && (m_addr[0] == 127 || m_addr[0] == 0))
# 242 : 17536 : return true;
# 243 : 305641 :
# 244 : 305641 : // IPv6 loopback (::1/128)
# 245 : 305641 : static const unsigned char pchLocal[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1};
# 246 : 305641 : if (IsIPv6() && memcmp(m_addr.data(), pchLocal, sizeof(pchLocal)) == 0)
# 247 : 4 : return true;
# 248 : 305637 :
# 249 : 305637 : return false;
# 250 : 305637 : }
# 251 : :
# 252 : : /**
# 253 : : * @returns Whether or not this network address is a valid address that @a could
# 254 : : * be used to refer to an actual host.
# 255 : : *
# 256 : : * @note A valid address may or may not be publicly routable on the global
# 257 : : * internet. As in, the set of valid addresses is a superset of the set of
# 258 : : * publicly routable addresses.
# 259 : : *
# 260 : : * @see CNetAddr::IsRoutable()
# 261 : : */
# 262 : : bool CNetAddr::IsValid() const
# 263 : 390873 : {
# 264 : 390873 : // Cleanup 3-byte shifted addresses caused by garbage in size field
# 265 : 390873 : // of addr messages from versions before 0.2.9 checksum.
# 266 : 390873 : // Two consecutive addr messages look like this:
# 267 : 390873 : // header20 vectorlen3 addr26 addr26 addr26 header20 vectorlen3 addr26 addr26 addr26...
# 268 : 390873 : // so if the first length field is garbled, it reads the second batch
# 269 : 390873 : // of addr misaligned by 3 bytes.
# 270 : 390873 : if (IsIPv6() && memcmp(m_addr.data(), IPv4_IN_IPv6_PREFIX + 3,
# 271 : 53274 : sizeof(IPv4_IN_IPv6_PREFIX) - 3) == 0)
# 272 : 0 : return false;
# 273 : 390873 :
# 274 : 390873 : // unspecified IPv6 address (::/128)
# 275 : 390873 : unsigned char ipNone6[16] = {};
# 276 : 390873 : if (IsIPv6() && memcmp(m_addr.data(), ipNone6, sizeof(ipNone6)) == 0)
# 277 : 53170 : return false;
# 278 : 337703 :
# 279 : 337703 : // documentation IPv6 address
# 280 : 337703 : if (IsRFC3849())
# 281 : 0 : return false;
# 282 : 337703 :
# 283 : 337703 : if (IsInternal())
# 284 : 2 : return false;
# 285 : 337701 :
# 286 : 337701 : if (IsIPv4()) {
# 287 : 675089 : for (uint32_t a : {(uint32_t)INADDR_ANY, (uint32_t)INADDR_NONE}) {
# 288 : 675089 : if (memcmp(m_addr.data(), &a, sizeof(a)) == 0) {
# 289 : 11 : return false;
# 290 : 11 : }
# 291 : 675089 : }
# 292 : 337549 : }
# 293 : 337701 :
# 294 : 337701 : return true;
# 295 : 337701 : }
# 296 : :
# 297 : : /**
# 298 : : * @returns Whether or not this network address is publicly routable on the
# 299 : : * global internet.
# 300 : : *
# 301 : : * @note A routable address is always valid. As in, the set of routable addresses
# 302 : : * is a subset of the set of valid addresses.
# 303 : : *
# 304 : : * @see CNetAddr::IsValid()
# 305 : : */
# 306 : : bool CNetAddr::IsRoutable() const
# 307 : 229007 : {
# 308 : 229007 : return IsValid() && !(IsRFC1918() || IsRFC2544() || IsRFC3927() || IsRFC4862() || IsRFC6598() || IsRFC5737() || (IsRFC4193() && !IsTor()) || IsRFC4843() || IsRFC7343() || IsLocal() || IsInternal());
# 309 : 229007 : }
# 310 : :
# 311 : : /**
# 312 : : * @returns Whether or not this is a dummy address that represents a name.
# 313 : : *
# 314 : : * @see CNetAddr::SetInternal(const std::string &)
# 315 : : */
# 316 : : bool CNetAddr::IsInternal() const
# 317 : 1034685 : {
# 318 : 1034685 : return m_net == NET_INTERNAL;
# 319 : 1034685 : }
# 320 : :
# 321 : : enum Network CNetAddr::GetNetwork() const
# 322 : 636 : {
# 323 : 636 : if (IsInternal())
# 324 : 2 : return NET_INTERNAL;
# 325 : 634 :
# 326 : 634 : if (!IsRoutable())
# 327 : 246 : return NET_UNROUTABLE;
# 328 : 388 :
# 329 : 388 : return m_net;
# 330 : 388 : }
# 331 : :
# 332 : : std::string CNetAddr::ToStringIP() const
# 333 : 161985 : {
# 334 : 161985 : if (IsTor())
# 335 : 7 : return EncodeBase32(m_addr.data(), m_addr.size()) + ".onion";
# 336 : 161978 : if (IsInternal())
# 337 : 2 : return EncodeBase32(m_addr.data(), m_addr.size()) + ".internal";
# 338 : 161976 : CService serv(*this, 0);
# 339 : 161976 : struct sockaddr_storage sockaddr;
# 340 : 161976 : socklen_t socklen = sizeof(sockaddr);
# 341 : 161976 : if (serv.GetSockAddr((struct sockaddr*)&sockaddr, &socklen)) {
# 342 : 161976 : char name[1025] = "";
# 343 : 161976 : if (!getnameinfo((const struct sockaddr*)&sockaddr, socklen, name, sizeof(name), nullptr, 0, NI_NUMERICHOST))
# 344 : 161976 : return std::string(name);
# 345 : 0 : }
# 346 : 0 : if (IsIPv4())
# 347 : 0 : return strprintf("%u.%u.%u.%u", m_addr[0], m_addr[1], m_addr[2], m_addr[3]);
# 348 : 0 : assert(IsIPv6());
# 349 : 0 : return strprintf("%x:%x:%x:%x:%x:%x:%x:%x",
# 350 : 0 : m_addr[0] << 8 | m_addr[1], m_addr[2] << 8 | m_addr[3],
# 351 : 0 : m_addr[4] << 8 | m_addr[5], m_addr[6] << 8 | m_addr[7],
# 352 : 0 : m_addr[8] << 8 | m_addr[9], m_addr[10] << 8 | m_addr[11],
# 353 : 0 : m_addr[12] << 8 | m_addr[13], m_addr[14] << 8 | m_addr[15]);
# 354 : 0 : }
# 355 : :
# 356 : : std::string CNetAddr::ToString() const
# 357 : 5653 : {
# 358 : 5653 : return ToStringIP();
# 359 : 5653 : }
# 360 : :
# 361 : : bool operator==(const CNetAddr& a, const CNetAddr& b)
# 362 : 10355 : {
# 363 : 10355 : return a.m_net == b.m_net && a.m_addr == b.m_addr;
# 364 : 10355 : }
# 365 : :
# 366 : : bool operator<(const CNetAddr& a, const CNetAddr& b)
# 367 : 151519 : {
# 368 : 151519 : return a.m_net < b.m_net || (a.m_net == b.m_net && a.m_addr < b.m_addr);
# 369 : 151519 : }
# 370 : :
# 371 : : /**
# 372 : : * Try to get our IPv4 address.
# 373 : : *
# 374 : : * @param[out] pipv4Addr The in_addr struct to which to copy.
# 375 : : *
# 376 : : * @returns Whether or not the operation was successful, in particular, whether
# 377 : : * or not our address was an IPv4 address.
# 378 : : *
# 379 : : * @see CNetAddr::IsIPv4()
# 380 : : */
# 381 : : bool CNetAddr::GetInAddr(struct in_addr* pipv4Addr) const
# 382 : 161491 : {
# 383 : 161491 : if (!IsIPv4())
# 384 : 0 : return false;
# 385 : 161491 : memcpy(pipv4Addr, m_addr.data(), m_addr.size());
# 386 : 161491 : return true;
# 387 : 161491 : }
# 388 : :
# 389 : : /**
# 390 : : * Try to get our IPv6 address.
# 391 : : *
# 392 : : * @param[out] pipv6Addr The in6_addr struct to which to copy.
# 393 : : *
# 394 : : * @returns Whether or not the operation was successful, in particular, whether
# 395 : : * or not our address was an IPv6 address.
# 396 : : *
# 397 : : * @see CNetAddr::IsIPv6()
# 398 : : */
# 399 : : bool CNetAddr::GetIn6Addr(struct in6_addr* pipv6Addr) const
# 400 : 1971 : {
# 401 : 1971 : if (!IsIPv6()) {
# 402 : 0 : return false;
# 403 : 0 : }
# 404 : 1971 : memcpy(pipv6Addr, m_addr.data(), m_addr.size());
# 405 : 1971 : return true;
# 406 : 1971 : }
# 407 : :
# 408 : : bool CNetAddr::HasLinkedIPv4() const
# 409 : 99574 : {
# 410 : 99574 : return IsRoutable() && (IsIPv4() || IsRFC6145() || IsRFC6052() || IsRFC3964() || IsRFC4380());
# 411 : 99574 : }
# 412 : :
# 413 : : uint32_t CNetAddr::GetLinkedIPv4() const
# 414 : 31873 : {
# 415 : 31873 : if (IsIPv4()) {
# 416 : 31865 : return ReadBE32(m_addr.data());
# 417 : 31865 : } else if (IsRFC6052() || IsRFC6145()) {
# 418 : 4 : // mapped IPv4, SIIT translated IPv4: the IPv4 address is the last 4 bytes of the address
# 419 : 4 : return ReadBE32(m_addr.data() + m_addr.size() - ADDR_IPv4_SIZE);
# 420 : 4 : } else if (IsRFC3964()) {
# 421 : 2 : // 6to4 tunneled IPv4: the IPv4 address is in bytes 2-6
# 422 : 2 : return ReadBE32(m_addr.data() + 2);
# 423 : 2 : } else if (IsRFC4380()) {
# 424 : 2 : // Teredo tunneled IPv4: the IPv4 address is in the last 4 bytes of the address, but bitflipped
# 425 : 2 : return ~ReadBE32(m_addr.data() + m_addr.size() - ADDR_IPv4_SIZE);
# 426 : 2 : }
# 427 : 0 : assert(false);
# 428 : 0 : }
# 429 : :
# 430 : 93355 : uint32_t CNetAddr::GetNetClass() const {
# 431 : 93355 : uint32_t net_class = NET_IPV6;
# 432 : 93355 : if (IsLocal()) {
# 433 : 7409 : net_class = 255;
# 434 : 7409 : }
# 435 : 93355 : if (IsInternal()) {
# 436 : 4 : net_class = NET_INTERNAL;
# 437 : 93351 : } else if (!IsRoutable()) {
# 438 : 25659 : net_class = NET_UNROUTABLE;
# 439 : 67692 : } else if (HasLinkedIPv4()) {
# 440 : 67674 : net_class = NET_IPV4;
# 441 : 67674 : } else if (IsTor()) {
# 442 : 10 : net_class = NET_ONION;
# 443 : 10 : }
# 444 : 93355 : return net_class;
# 445 : 93355 : }
# 446 : :
# 447 : 56965 : uint32_t CNetAddr::GetMappedAS(const std::vector<bool> &asmap) const {
# 448 : 56965 : uint32_t net_class = GetNetClass();
# 449 : 56965 : if (asmap.size() == 0 || (net_class != NET_IPV4 && net_class != NET_IPV6)) {
# 450 : 44143 : return 0; // Indicates not found, safe because AS0 is reserved per RFC7607.
# 451 : 44143 : }
# 452 : 12822 : std::vector<bool> ip_bits(128);
# 453 : 12822 : if (HasLinkedIPv4()) {
# 454 : 12822 : // For lookup, treat as if it was just an IPv4 address (IPv4_IN_IPv6_PREFIX + IPv4 bits)
# 455 : 166686 : for (int8_t byte_i = 0; byte_i < 12; ++byte_i) {
# 456 : 1384776 : for (uint8_t bit_i = 0; bit_i < 8; ++bit_i) {
# 457 : 1230912 : ip_bits[byte_i * 8 + bit_i] = (IPv4_IN_IPv6_PREFIX[byte_i] >> (7 - bit_i)) & 1;
# 458 : 1230912 : }
# 459 : 153864 : }
# 460 : 12822 : uint32_t ipv4 = GetLinkedIPv4();
# 461 : 423126 : for (int i = 0; i < 32; ++i) {
# 462 : 410304 : ip_bits[96 + i] = (ipv4 >> (31 - i)) & 1;
# 463 : 410304 : }
# 464 : 12822 : } else {
# 465 : 0 : // Use all 128 bits of the IPv6 address otherwise
# 466 : 0 : assert(IsIPv6());
# 467 : 0 : for (int8_t byte_i = 0; byte_i < 16; ++byte_i) {
# 468 : 0 : uint8_t cur_byte = m_addr[byte_i];
# 469 : 0 : for (uint8_t bit_i = 0; bit_i < 8; ++bit_i) {
# 470 : 0 : ip_bits[byte_i * 8 + bit_i] = (cur_byte >> (7 - bit_i)) & 1;
# 471 : 0 : }
# 472 : 0 : }
# 473 : 0 : }
# 474 : 12822 : uint32_t mapped_as = Interpret(asmap, ip_bits);
# 475 : 12822 : return mapped_as;
# 476 : 12822 : }
# 477 : :
# 478 : : /**
# 479 : : * Get the canonical identifier of our network group
# 480 : : *
# 481 : : * The groups are assigned in a way where it should be costly for an attacker to
# 482 : : * obtain addresses with many different group identifiers, even if it is cheap
# 483 : : * to obtain addresses with the same identifier.
# 484 : : *
# 485 : : * @note No two connections will be attempted to addresses with the same network
# 486 : : * group.
# 487 : : */
# 488 : : std::vector<unsigned char> CNetAddr::GetGroup(const std::vector<bool> &asmap) const
# 489 : 36390 : {
# 490 : 36390 : std::vector<unsigned char> vchRet;
# 491 : 36390 : uint32_t net_class = GetNetClass();
# 492 : 36390 : // If non-empty asmap is supplied and the address is IPv4/IPv6,
# 493 : 36390 : // return ASN to be used for bucketing.
# 494 : 36390 : uint32_t asn = GetMappedAS(asmap);
# 495 : 36390 : if (asn != 0) { // Either asmap was empty, or address has non-asmappable net class (e.g. TOR).
# 496 : 7246 : vchRet.push_back(NET_IPV6); // IPv4 and IPv6 with same ASN should be in the same bucket
# 497 : 36230 : for (int i = 0; i < 4; i++) {
# 498 : 28984 : vchRet.push_back((asn >> (8 * i)) & 0xFF);
# 499 : 28984 : }
# 500 : 7246 : return vchRet;
# 501 : 7246 : }
# 502 : 29144 :
# 503 : 29144 : vchRet.push_back(net_class);
# 504 : 29144 : int nBits;
# 505 : 29144 :
# 506 : 29144 : if (IsLocal()) {
# 507 : 957 : // all local addresses belong to the same group
# 508 : 957 : nBits = 0;
# 509 : 28187 : } else if (IsInternal()) {
# 510 : 2 : // all internal-usage addresses get their own group
# 511 : 2 : nBits = ADDR_INTERNAL_SIZE * 8;
# 512 : 28185 : } else if (!IsRoutable()) {
# 513 : 9125 : // all other unroutable addresses belong to the same group
# 514 : 9125 : nBits = 0;
# 515 : 19060 : } else if (HasLinkedIPv4()) {
# 516 : 19051 : // IPv4 addresses (and mapped IPv4 addresses) use /16 groups
# 517 : 19051 : uint32_t ipv4 = GetLinkedIPv4();
# 518 : 19051 : vchRet.push_back((ipv4 >> 24) & 0xFF);
# 519 : 19051 : vchRet.push_back((ipv4 >> 16) & 0xFF);
# 520 : 19051 : return vchRet;
# 521 : 19051 : } else if (IsTor()) {
# 522 : 5 : nBits = 4;
# 523 : 5 : } else if (IsHeNet()) {
# 524 : 2 : // for he.net, use /36 groups
# 525 : 2 : nBits = 36;
# 526 : 2 : } else {
# 527 : 2 : // for the rest of the IPv6 network, use /32 groups
# 528 : 2 : nBits = 32;
# 529 : 2 : }
# 530 : 29144 :
# 531 : 29144 : // push our ip onto vchRet byte by byte...
# 532 : 29144 : size_t i = 0;
# 533 : 10129 : while (nBits >= 8)
# 534 : 36 : {
# 535 : 36 : assert(i < m_addr.size());
# 536 : 36 : vchRet.push_back(m_addr[i]);
# 537 : 36 : i++;
# 538 : 36 : nBits -= 8;
# 539 : 36 : }
# 540 : 10093 : // ...for the last byte, push nBits and for the rest of the byte push 1's
# 541 : 10093 : if (nBits > 0) {
# 542 : 7 : assert(i < m_addr.size());
# 543 : 7 : vchRet.push_back(m_addr[i] | ((1 << (8 - nBits)) - 1));
# 544 : 7 : }
# 545 : 10093 :
# 546 : 10093 : return vchRet;
# 547 : 29144 : }
# 548 : :
# 549 : : std::vector<unsigned char> CNetAddr::GetAddrBytes() const
# 550 : 1256448 : {
# 551 : 1256448 : uint8_t serialized[V1_SERIALIZATION_SIZE];
# 552 : 1256448 : SerializeV1Array(serialized);
# 553 : 1256448 : return {std::begin(serialized), std::end(serialized)};
# 554 : 1256448 : }
# 555 : :
# 556 : : uint64_t CNetAddr::GetHash() const
# 557 : 10 : {
# 558 : 10 : uint256 hash = Hash(m_addr.begin(), m_addr.end());
# 559 : 10 : uint64_t nRet;
# 560 : 10 : memcpy(&nRet, &hash, sizeof(nRet));
# 561 : 10 : return nRet;
# 562 : 10 : }
# 563 : :
# 564 : : // private extensions to enum Network, only returned by GetExtNetwork,
# 565 : : // and only used in GetReachabilityFrom
# 566 : : static const int NET_UNKNOWN = NET_MAX + 0;
# 567 : : static const int NET_TEREDO = NET_MAX + 1;
# 568 : : int static GetExtNetwork(const CNetAddr *addr)
# 569 : 0 : {
# 570 : 0 : if (addr == nullptr)
# 571 : 0 : return NET_UNKNOWN;
# 572 : 0 : if (addr->IsRFC4380())
# 573 : 0 : return NET_TEREDO;
# 574 : 0 : return addr->GetNetwork();
# 575 : 0 : }
# 576 : :
# 577 : : /** Calculates a metric for how reachable (*this) is from a given partner */
# 578 : : int CNetAddr::GetReachabilityFrom(const CNetAddr *paddrPartner) const
# 579 : 2 : {
# 580 : 2 : enum Reachability {
# 581 : 2 : REACH_UNREACHABLE,
# 582 : 2 : REACH_DEFAULT,
# 583 : 2 : REACH_TEREDO,
# 584 : 2 : REACH_IPV6_WEAK,
# 585 : 2 : REACH_IPV4,
# 586 : 2 : REACH_IPV6_STRONG,
# 587 : 2 : REACH_PRIVATE
# 588 : 2 : };
# 589 : 2 :
# 590 : 2 : if (!IsRoutable() || IsInternal())
# 591 : 2 : return REACH_UNREACHABLE;
# 592 : 0 :
# 593 : 0 : int ourNet = GetExtNetwork(this);
# 594 : 0 : int theirNet = GetExtNetwork(paddrPartner);
# 595 : 0 : bool fTunnel = IsRFC3964() || IsRFC6052() || IsRFC6145();
# 596 : 0 :
# 597 : 0 : switch(theirNet) {
# 598 : 0 : case NET_IPV4:
# 599 : 0 : switch(ourNet) {
# 600 : 0 : default: return REACH_DEFAULT;
# 601 : 0 : case NET_IPV4: return REACH_IPV4;
# 602 : 0 : }
# 603 : 0 : case NET_IPV6:
# 604 : 0 : switch(ourNet) {
# 605 : 0 : default: return REACH_DEFAULT;
# 606 : 0 : case NET_TEREDO: return REACH_TEREDO;
# 607 : 0 : case NET_IPV4: return REACH_IPV4;
# 608 : 0 : case NET_IPV6: return fTunnel ? REACH_IPV6_WEAK : REACH_IPV6_STRONG; // only prefer giving our IPv6 address if it's not tunnelled
# 609 : 0 : }
# 610 : 0 : case NET_ONION:
# 611 : 0 : switch(ourNet) {
# 612 : 0 : default: return REACH_DEFAULT;
# 613 : 0 : case NET_IPV4: return REACH_IPV4; // Tor users can connect to IPv4 as well
# 614 : 0 : case NET_ONION: return REACH_PRIVATE;
# 615 : 0 : }
# 616 : 0 : case NET_TEREDO:
# 617 : 0 : switch(ourNet) {
# 618 : 0 : default: return REACH_DEFAULT;
# 619 : 0 : case NET_TEREDO: return REACH_TEREDO;
# 620 : 0 : case NET_IPV6: return REACH_IPV6_WEAK;
# 621 : 0 : case NET_IPV4: return REACH_IPV4;
# 622 : 0 : }
# 623 : 0 : case NET_UNKNOWN:
# 624 : 0 : case NET_UNROUTABLE:
# 625 : 0 : default:
# 626 : 0 : switch(ourNet) {
# 627 : 0 : default: return REACH_DEFAULT;
# 628 : 0 : case NET_TEREDO: return REACH_TEREDO;
# 629 : 0 : case NET_IPV6: return REACH_IPV6_WEAK;
# 630 : 0 : case NET_IPV4: return REACH_IPV4;
# 631 : 0 : case NET_ONION: return REACH_PRIVATE; // either from Tor, or don't care about our address
# 632 : 0 : }
# 633 : 0 : }
# 634 : 0 : }
# 635 : :
# 636 : : CService::CService() : port(0)
# 637 : 675379 : {
# 638 : 675379 : }
# 639 : :
# 640 : : CService::CService(const CNetAddr& cip, uint16_t portIn) : CNetAddr(cip), port(portIn)
# 641 : 367284 : {
# 642 : 367284 : }
# 643 : :
# 644 : : CService::CService(const struct in_addr& ipv4Addr, uint16_t portIn) : CNetAddr(ipv4Addr), port(portIn)
# 645 : 5 : {
# 646 : 5 : }
# 647 : :
# 648 : : CService::CService(const struct in6_addr& ipv6Addr, uint16_t portIn) : CNetAddr(ipv6Addr), port(portIn)
# 649 : 3 : {
# 650 : 3 : }
# 651 : :
# 652 : : CService::CService(const struct sockaddr_in& addr) : CNetAddr(addr.sin_addr), port(ntohs(addr.sin_port))
# 653 : 1152 : {
# 654 : 1152 : assert(addr.sin_family == AF_INET);
# 655 : 1152 : }
# 656 : :
# 657 : : CService::CService(const struct sockaddr_in6 &addr) : CNetAddr(addr.sin6_addr, addr.sin6_scope_id), port(ntohs(addr.sin6_port))
# 658 : 0 : {
# 659 : 0 : assert(addr.sin6_family == AF_INET6);
# 660 : 0 : }
# 661 : :
# 662 : : bool CService::SetSockAddr(const struct sockaddr *paddr)
# 663 : 1152 : {
# 664 : 1152 : switch (paddr->sa_family) {
# 665 : 1152 : case AF_INET:
# 666 : 1152 : *this = CService(*(const struct sockaddr_in*)paddr);
# 667 : 1152 : return true;
# 668 : 0 : case AF_INET6:
# 669 : 0 : *this = CService(*(const struct sockaddr_in6*)paddr);
# 670 : 0 : return true;
# 671 : 0 : default:
# 672 : 0 : return false;
# 673 : 1152 : }
# 674 : 1152 : }
# 675 : :
# 676 : : uint16_t CService::GetPort() const
# 677 : 197 : {
# 678 : 197 : return port;
# 679 : 197 : }
# 680 : :
# 681 : : bool operator==(const CService& a, const CService& b)
# 682 : 994 : {
# 683 : 994 : return static_cast<CNetAddr>(a) == static_cast<CNetAddr>(b) && a.port == b.port;
# 684 : 994 : }
# 685 : :
# 686 : : bool operator<(const CService& a, const CService& b)
# 687 : 4393 : {
# 688 : 4393 : return static_cast<CNetAddr>(a) < static_cast<CNetAddr>(b) || (static_cast<CNetAddr>(a) == static_cast<CNetAddr>(b) && a.port < b.port);
# 689 : 4393 : }
# 690 : :
# 691 : : /**
# 692 : : * Obtain the IPv4/6 socket address this represents.
# 693 : : *
# 694 : : * @param[out] paddr The obtained socket address.
# 695 : : * @param[in,out] addrlen The size, in bytes, of the address structure pointed
# 696 : : * to by paddr. The value that's pointed to by this
# 697 : : * parameter might change after calling this function if
# 698 : : * the size of the corresponding address structure
# 699 : : * changed.
# 700 : : *
# 701 : : * @returns Whether or not the operation was successful.
# 702 : : */
# 703 : : bool CService::GetSockAddr(struct sockaddr* paddr, socklen_t *addrlen) const
# 704 : 163462 : {
# 705 : 163462 : if (IsIPv4()) {
# 706 : 161491 : if (*addrlen < (socklen_t)sizeof(struct sockaddr_in))
# 707 : 0 : return false;
# 708 : 161491 : *addrlen = sizeof(struct sockaddr_in);
# 709 : 161491 : struct sockaddr_in *paddrin = (struct sockaddr_in*)paddr;
# 710 : 161491 : memset(paddrin, 0, *addrlen);
# 711 : 161491 : if (!GetInAddr(&paddrin->sin_addr))
# 712 : 0 : return false;
# 713 : 161491 : paddrin->sin_family = AF_INET;
# 714 : 161491 : paddrin->sin_port = htons(port);
# 715 : 161491 : return true;
# 716 : 161491 : }
# 717 : 1971 : if (IsIPv6()) {
# 718 : 1971 : if (*addrlen < (socklen_t)sizeof(struct sockaddr_in6))
# 719 : 0 : return false;
# 720 : 1971 : *addrlen = sizeof(struct sockaddr_in6);
# 721 : 1971 : struct sockaddr_in6 *paddrin6 = (struct sockaddr_in6*)paddr;
# 722 : 1971 : memset(paddrin6, 0, *addrlen);
# 723 : 1971 : if (!GetIn6Addr(&paddrin6->sin6_addr))
# 724 : 0 : return false;
# 725 : 1971 : paddrin6->sin6_scope_id = scopeId;
# 726 : 1971 : paddrin6->sin6_family = AF_INET6;
# 727 : 1971 : paddrin6->sin6_port = htons(port);
# 728 : 1971 : return true;
# 729 : 1971 : }
# 730 : 0 : return false;
# 731 : 0 : }
# 732 : :
# 733 : : /**
# 734 : : * @returns An identifier unique to this service's address and port number.
# 735 : : */
# 736 : : std::vector<unsigned char> CService::GetKey() const
# 737 : 1255704 : {
# 738 : 1255704 : auto key = GetAddrBytes();
# 739 : 1255704 : key.push_back(port / 0x100); // most significant byte of our port
# 740 : 1255704 : key.push_back(port & 0x0FF); // least significant byte of our port
# 741 : 1255704 : return key;
# 742 : 1255704 : }
# 743 : :
# 744 : : std::string CService::ToStringPort() const
# 745 : 141220 : {
# 746 : 141220 : return strprintf("%u", port);
# 747 : 141220 : }
# 748 : :
# 749 : : std::string CService::ToStringIPPort() const
# 750 : 141220 : {
# 751 : 141220 : if (IsIPv4() || IsTor() || IsInternal()) {
# 752 : 139808 : return ToStringIP() + ":" + ToStringPort();
# 753 : 139808 : } else {
# 754 : 1412 : return "[" + ToStringIP() + "]:" + ToStringPort();
# 755 : 1412 : }
# 756 : 141220 : }
# 757 : :
# 758 : : std::string CService::ToString() const
# 759 : 136272 : {
# 760 : 136272 : return ToStringIPPort();
# 761 : 136272 : }
# 762 : :
# 763 : : CSubNet::CSubNet():
# 764 : : valid(false)
# 765 : 1652 : {
# 766 : 1652 : memset(netmask, 0, sizeof(netmask));
# 767 : 1652 : }
# 768 : :
# 769 : : CSubNet::CSubNet(const CNetAddr& addr, uint8_t mask) : CSubNet()
# 770 : 602 : {
# 771 : 602 : valid = (addr.IsIPv4() && mask <= ADDR_IPv4_SIZE * 8) ||
# 772 : 602 : (addr.IsIPv6() && mask <= ADDR_IPv6_SIZE * 8);
# 773 : 602 : if (!valid) {
# 774 : 5 : return;
# 775 : 5 : }
# 776 : 597 :
# 777 : 597 : assert(mask <= sizeof(netmask) * 8);
# 778 : 597 :
# 779 : 597 : network = addr;
# 780 : 597 :
# 781 : 597 : uint8_t n = mask;
# 782 : 3213 : for (size_t i = 0; i < network.m_addr.size(); ++i) {
# 783 : 2616 : const uint8_t bits = n < 8 ? n : 8;
# 784 : 2616 : netmask[i] = (uint8_t)((uint8_t)0xFF << (8 - bits)); // Set first bits.
# 785 : 2616 : network.m_addr[i] &= netmask[i]; // Normalize network according to netmask.
# 786 : 2616 : n -= bits;
# 787 : 2616 : }
# 788 : 597 : }
# 789 : :
# 790 : : /**
# 791 : : * @returns The number of 1-bits in the prefix of the specified subnet mask. If
# 792 : : * the specified subnet mask is not a valid one, -1.
# 793 : : */
# 794 : : static inline int NetmaskBits(uint8_t x)
# 795 : 9861 : {
# 796 : 9861 : switch(x) {
# 797 : 210 : case 0x00: return 0;
# 798 : 16 : case 0x80: return 1;
# 799 : 16 : case 0xc0: return 2;
# 800 : 19 : case 0xe0: return 3;
# 801 : 16 : case 0xf0: return 4;
# 802 : 16 : case 0xf8: return 5;
# 803 : 20 : case 0xfc: return 6;
# 804 : 18 : case 0xfe: return 7;
# 805 : 9526 : case 0xff: return 8;
# 806 : 4 : default: return -1;
# 807 : 9861 : }
# 808 : 9861 : }
# 809 : :
# 810 : : CSubNet::CSubNet(const CNetAddr& addr, const CNetAddr& mask) : CSubNet()
# 811 : 96 : {
# 812 : 96 : valid = (addr.IsIPv4() || addr.IsIPv6()) && addr.m_net == mask.m_net;
# 813 : 96 : if (!valid) {
# 814 : 6 : return;
# 815 : 6 : }
# 816 : 90 : // Check if `mask` contains 1-bits after 0-bits (which is an invalid netmask).
# 817 : 478 : for (auto b : mask.m_addr) {
# 818 : 478 : if (NetmaskBits(b) == -1) {
# 819 : 4 : valid = false;
# 820 : 4 : return;
# 821 : 4 : }
# 822 : 478 : }
# 823 : 90 :
# 824 : 90 : assert(mask.m_addr.size() <= sizeof(netmask));
# 825 : 86 :
# 826 : 86 : memcpy(netmask, mask.m_addr.data(), mask.m_addr.size());
# 827 : 86 :
# 828 : 86 : network = addr;
# 829 : 86 :
# 830 : 86 : // Normalize network according to netmask
# 831 : 526 : for (size_t x = 0; x < network.m_addr.size(); ++x)
# 832 : 440 : network.m_addr[x] &= netmask[x];
# 833 : 86 : }
# 834 : :
# 835 : : CSubNet::CSubNet(const CNetAddr& addr) : CSubNet()
# 836 : 636 : {
# 837 : 636 : valid = addr.IsIPv4() || addr.IsIPv6();
# 838 : 636 : if (!valid) {
# 839 : 2 : return;
# 840 : 2 : }
# 841 : 634 :
# 842 : 634 : assert(addr.m_addr.size() <= sizeof(netmask));
# 843 : 634 :
# 844 : 634 : memset(netmask, 0xFF, addr.m_addr.size());
# 845 : 634 :
# 846 : 634 : network = addr;
# 847 : 634 : }
# 848 : :
# 849 : : /**
# 850 : : * @returns True if this subnet is valid, the specified address is valid, and
# 851 : : * the specified address belongs in this subnet.
# 852 : : */
# 853 : : bool CSubNet::Match(const CNetAddr &addr) const
# 854 : 63626 : {
# 855 : 63626 : if (!valid || !addr.IsValid() || network.m_net != addr.m_net)
# 856 : 16 : return false;
# 857 : 63610 : assert(network.m_addr.size() == addr.m_addr.size());
# 858 : 318160 : for (size_t x = 0; x < addr.m_addr.size(); ++x)
# 859 : 254564 : if ((addr.m_addr[x] & netmask[x]) != network.m_addr[x])
# 860 : 14 : return false;
# 861 : 63610 : return true;
# 862 : 63610 : }
# 863 : :
# 864 : : std::string CSubNet::ToString() const
# 865 : 1173 : {
# 866 : 1173 : assert(network.m_addr.size() <= sizeof(netmask));
# 867 : 1173 :
# 868 : 1173 : uint8_t cidr = 0;
# 869 : 1173 :
# 870 : 10556 : for (size_t i = 0; i < network.m_addr.size(); ++i) {
# 871 : 9988 : if (netmask[i] == 0x00) {
# 872 : 605 : break;
# 873 : 605 : }
# 874 : 9383 : cidr += NetmaskBits(netmask[i]);
# 875 : 9383 : }
# 876 : 1173 :
# 877 : 1173 : return network.ToString() + "/" + strprintf("%hhu", cidr);
# 878 : 1173 : }
# 879 : :
# 880 : : bool CSubNet::IsValid() const
# 881 : 337 : {
# 882 : 337 : return valid;
# 883 : 337 : }
# 884 : :
# 885 : : bool operator==(const CSubNet& a, const CSubNet& b)
# 886 : 4 : {
# 887 : 4 : const size_t size = a.network.IsIPv4() ? ADDR_IPv4_SIZE : ADDR_IPv6_SIZE;
# 888 : 4 :
# 889 : 4 : return a.valid == b.valid && a.network == b.network &&
# 890 : 4 : memcmp(a.netmask, b.netmask, size) == 0;
# 891 : 4 : }
# 892 : :
# 893 : : bool operator<(const CSubNet& a, const CSubNet& b)
# 894 : 103 : {
# 895 : 103 : const size_t size = a.network.IsIPv4() ? ADDR_IPv4_SIZE : ADDR_IPv6_SIZE;
# 896 : 103 :
# 897 : 103 : return a.network < b.network ||
# 898 : 103 : (a.network == b.network && memcmp(a.netmask, b.netmask, size) < 0);
# 899 : 103 : }
# 900 : :
# 901 : : bool SanityCheckASMap(const std::vector<bool>& asmap)
# 902 : 5 : {
# 903 : 5 : return SanityCheckASMap(asmap, 128); // For IP address lookups, the input is 128 bits
# 904 : 5 : }
|
