Resolve RFC 6761 localhost names to loopback

net/base/net_util_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/base/net_util.h"
 
 #include <string.h>
 
 #include <ostream>
 
 #include "base/files/file_path.h"
 #include "base/format_macros.h"
 #include "base/scoped_native_library.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_byteorder.h"
 #include "base/time/time.h"
+#include "net/base/address_list.h"
 #include "net/base/ip_endpoint.h"
 
 #if !defined(OS_NACL) && !defined(OS_WIN)
 #include <net/if.h>
 #include <netinet/in.h>
 #if defined(OS_MACOSX)
 #include <ifaddrs.h>
 #if !defined(OS_IOS)
 #include <netinet/in_var.h>
 #endif  // !OS_IOS
@@ skipping 17 matching lines @@
 
 namespace net {
 
 namespace {
 
 struct HeaderCase {
   const char* const header_name;
   const char* const expected;
 };
 
+const unsigned char kLocalhostIPv4[] = {127, 0, 0, 1};
+const unsigned char kLocalhostIPv6[] =
+    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
+const uint16_t kLocalhostLookupPort = 80;
+
 // Fills in sockaddr for the given 32-bit address (IPv4.)
 // |bytes| should be an array of length 4.
 void MakeIPv4Address(const uint8_t* bytes, int port, SockaddrStorage* storage) {
   memset(&storage->addr_storage, 0, sizeof(storage->addr_storage));
   storage->addr_len = sizeof(struct sockaddr_in);
   struct sockaddr_in* addr4 = reinterpret_cast<sockaddr_in*>(storage->addr);
   addr4->sin_port = base::HostToNet16(port);
   addr4->sin_family = AF_INET;
   memcpy(&addr4->sin_addr, bytes, 4);
 }
 
 // Fills in sockaddr for the given 128-bit address (IPv6.)
 // |bytes| should be an array of length 16.
 void MakeIPv6Address(const uint8_t* bytes, int port, SockaddrStorage* storage) {
   memset(&storage->addr_storage, 0, sizeof(storage->addr_storage));
   storage->addr_len = sizeof(struct sockaddr_in6);
   struct sockaddr_in6* addr6 = reinterpret_cast<sockaddr_in6*>(storage->addr);
   addr6->sin6_port = base::HostToNet16(port);
   addr6->sin6_family = AF_INET6;
   memcpy(&addr6->sin6_addr, bytes, 16);
 }
 
+bool HasEndpoint(const IPEndPoint& endpoint, const AddressList& addresses) {
+  for (const auto& address : addresses) {
+    if (endpoint == address)
+      return true;
+  }
+  return false;
+}
+
+void TestBothLoopbackIPs(const std::string& host) {
+  IPEndPoint localhost_ipv4(
+      IPAddressNumber(kLocalhostIPv4,
+                      kLocalhostIPv4 + arraysize(kLocalhostIPv4)),
+      kLocalhostLookupPort);
+  IPEndPoint localhost_ipv6(
+      IPAddressNumber(kLocalhostIPv6,
+                      kLocalhostIPv6 + arraysize(kLocalhostIPv6)),
+      kLocalhostLookupPort);
+
+  AddressList addresses;
+  EXPECT_TRUE(ResolveLocalHostname(host, kLocalhostLookupPort, &addresses));
+  EXPECT_EQ(2u, addresses.size());
+  EXPECT_TRUE(HasEndpoint(localhost_ipv4, addresses));
+  EXPECT_TRUE(HasEndpoint(localhost_ipv6, addresses));
+}
+
+void TestIPv6LoopbackOnly(const std::string& host) {
+  IPEndPoint localhost_ipv6(
+      IPAddressNumber(kLocalhostIPv6,
+                      kLocalhostIPv6 + arraysize(kLocalhostIPv6)),
+      kLocalhostLookupPort);
+
+  AddressList addresses;
+  EXPECT_TRUE(ResolveLocalHostname(host, kLocalhostLookupPort, &addresses));
+  EXPECT_EQ(1u, addresses.size());
+  EXPECT_TRUE(HasEndpoint(localhost_ipv6, addresses));
+}
+
 }  // anonymous namespace
 
 TEST(NetUtilTest, GetIdentityFromURL) {
   struct {
     const char* const input_url;
     const char* const expected_username;
     const char* const expected_password;
   } tests[] = {
     {
       "http://username:password@google.com",
@@ skipping 381 matching lines @@
 TEST(NetUtilTest, GetAddressFamily) {
   IPAddressNumber number;
   EXPECT_TRUE(ParseIPLiteralToNumber("192.168.0.1", &number));
   EXPECT_EQ(ADDRESS_FAMILY_IPV4, GetAddressFamily(number));
   EXPECT_TRUE(ParseIPLiteralToNumber("1:abcd::3:4:ff", &number));
   EXPECT_EQ(ADDRESS_FAMILY_IPV6, GetAddressFamily(number));
 }
 
 TEST(NetUtilTest, IsLocalhost) {
   EXPECT_TRUE(IsLocalhost("localhost"));
+  EXPECT_TRUE(IsLocalhost("localhost."));
   EXPECT_TRUE(IsLocalhost("localhost.localdomain"));
+  EXPECT_TRUE(IsLocalhost("localhost.localdomain."));
   EXPECT_TRUE(IsLocalhost("localhost6"));
+  EXPECT_TRUE(IsLocalhost("localhost6."));
   EXPECT_TRUE(IsLocalhost("localhost6.localdomain6"));
+  EXPECT_TRUE(IsLocalhost("localhost6.localdomain6."));
   EXPECT_TRUE(IsLocalhost("127.0.0.1"));
   EXPECT_TRUE(IsLocalhost("127.0.1.0"));
   EXPECT_TRUE(IsLocalhost("127.1.0.0"));
   EXPECT_TRUE(IsLocalhost("127.0.0.255"));
   EXPECT_TRUE(IsLocalhost("127.0.255.0"));
   EXPECT_TRUE(IsLocalhost("127.255.0.0"));
   EXPECT_TRUE(IsLocalhost("::1"));
   EXPECT_TRUE(IsLocalhost("0:0:0:0:0:0:0:1"));
   EXPECT_TRUE(IsLocalhost("foo.localhost"));
+  EXPECT_TRUE(IsLocalhost("foo.localhost."));
 
   EXPECT_FALSE(IsLocalhost("localhostx"));
+  EXPECT_FALSE(IsLocalhost("localhost.x"));
   EXPECT_FALSE(IsLocalhost("foo.localdomain"));
+  EXPECT_FALSE(IsLocalhost("foo.localdomain.x"));
   EXPECT_FALSE(IsLocalhost("localhost6x"));
   EXPECT_FALSE(IsLocalhost("localhost.localdomain6"));
   EXPECT_FALSE(IsLocalhost("localhost6.localdomain"));
   EXPECT_FALSE(IsLocalhost("127.0.0.1.1"));
   EXPECT_FALSE(IsLocalhost(".127.0.0.255"));
   EXPECT_FALSE(IsLocalhost("::2"));
   EXPECT_FALSE(IsLocalhost("::1:1"));
   EXPECT_FALSE(IsLocalhost("0:0:0:0:1:0:0:1"));
   EXPECT_FALSE(IsLocalhost("::1:1"));
   EXPECT_FALSE(IsLocalhost("0:0:0:0:0:0:0:0:1"));
   EXPECT_FALSE(IsLocalhost("foo.localhost.com"));
   EXPECT_FALSE(IsLocalhost("foo.localhoste"));
 }
 
+TEST(NetUtilTest, ResolveLocalHostname) {
+  AddressList addresses;
+
+  TestBothLoopbackIPs("localhost");
+  TestBothLoopbackIPs("localhost.");
+  TestBothLoopbackIPs("localhost.localdomain");
+  TestBothLoopbackIPs("localhost.localdomain.");
+  TestBothLoopbackIPs("foo.localhost");
+  TestBothLoopbackIPs("foo.localhost.");
+
+  TestIPv6LoopbackOnly("localhost6");
+  TestIPv6LoopbackOnly("localhost6.");
+  TestIPv6LoopbackOnly("localhost6.localdomain6");
+  TestIPv6LoopbackOnly("localhost6.localdomain6.");
+
+  EXPECT_FALSE(
+      ResolveLocalHostname("127.0.0.1", kLocalhostLookupPort, &addresses));
+  EXPECT_FALSE(ResolveLocalHostname("::1", kLocalhostLookupPort, &addresses));
+  EXPECT_FALSE(ResolveLocalHostname("0:0:0:0:0:0:0:1", kLocalhostLookupPort,
+                                    &addresses));
+  EXPECT_FALSE(
+      ResolveLocalHostname("localhostx", kLocalhostLookupPort, &addresses));
+  EXPECT_FALSE(
+      ResolveLocalHostname("localhost.x", kLocalhostLookupPort, &addresses));
+  EXPECT_FALSE(ResolveLocalHostname("foo.localdomain", kLocalhostLookupPort,
+                                    &addresses));
+  EXPECT_FALSE(ResolveLocalHostname("foo.localdomain.x", kLocalhostLookupPort,
+                                    &addresses));
+  EXPECT_FALSE(
+      ResolveLocalHostname("localhost6x", kLocalhostLookupPort, &addresses));
+  EXPECT_FALSE(ResolveLocalHostname("localhost.localdomain6",
+                                    kLocalhostLookupPort, &addresses));
+  EXPECT_FALSE(ResolveLocalHostname("localhost6.localdomain",
+                                    kLocalhostLookupPort, &addresses));
+  EXPECT_FALSE(
+      ResolveLocalHostname("127.0.0.1.1", kLocalhostLookupPort, &addresses));
+  EXPECT_FALSE(
+      ResolveLocalHostname(".127.0.0.255", kLocalhostLookupPort, &addresses));
+  EXPECT_FALSE(ResolveLocalHostname("::2", kLocalhostLookupPort, &addresses));
+  EXPECT_FALSE(ResolveLocalHostname("::1:1", kLocalhostLookupPort, &addresses));
+  EXPECT_FALSE(ResolveLocalHostname("0:0:0:0:1:0:0:1", kLocalhostLookupPort,
+                                    &addresses));
+  EXPECT_FALSE(ResolveLocalHostname("::1:1", kLocalhostLookupPort, &addresses));
+  EXPECT_FALSE(ResolveLocalHostname("0:0:0:0:0:0:0:0:1", kLocalhostLookupPort,
+                                    &addresses));
+  EXPECT_FALSE(ResolveLocalHostname("foo.localhost.com", kLocalhostLookupPort,
+                                    &addresses));
+  EXPECT_FALSE(
+      ResolveLocalHostname("foo.localhoste", kLocalhostLookupPort, &addresses));
+}
+
 TEST(NetUtilTest, IsLocalhostTLD) {
   EXPECT_TRUE(IsLocalhostTLD("foo.localhost"));
   EXPECT_TRUE(IsLocalhostTLD("foo.localhost."));
   EXPECT_FALSE(IsLocalhostTLD("foo.localhos"));
   EXPECT_FALSE(IsLocalhostTLD("foo.localhost.com"));
   EXPECT_FALSE(IsLocalhost("foo.localhoste"));
 }
 
 TEST(NetUtilTest, GoogleHost) {
   struct GoogleHostCase {
@@ skipping 105 matching lines @@
 TEST_P(NetUtilNonUniqueNameTest, IsHostnameNonUnique) {
   const NonUniqueNameTestData& test_data = GetParam();
 
   EXPECT_EQ(test_data.is_unique, IsUnique(test_data.hostname));
 }
 
 INSTANTIATE_TEST_CASE_P(, NetUtilNonUniqueNameTest,
                         testing::ValuesIn(kNonUniqueNameTestData));
 
 }  // namespace net