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