Reduce buggy usage of the registry controlled domain service.

net/base/registry_controlled_domains/registry_controlled_domain_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/registry_controlled_domains/registry_controlled_domain.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
 namespace {
@@ skipping 38 matching lines @@
 }
 
 size_t GetRegistryLengthFromURLIncludingPrivate(
     const std::string& url,
     UnknownRegistryFilter unknown_filter) {
   return GetRegistryLength(GURL(url),
                            unknown_filter,
                            INCLUDE_PRIVATE_REGISTRIES);
 }
 
-size_t GetRegistryLengthFromHost(
+size_t GetRegistryLengthForCanonicalHost(const std::string& host,
+                                         UnknownRegistryFilter unknown_filter) {
+  return GetRegistryLengthForCanonicalHost(host, unknown_filter,
+                                           EXCLUDE_PRIVATE_REGISTRIES);
+}
+
+size_t GetRegistryLengthForCanonicalHostIncludingPrivate(
     const std::string& host,
     UnknownRegistryFilter unknown_filter) {
-  return GetRegistryLength(host, unknown_filter, EXCLUDE_PRIVATE_REGISTRIES);
-}
-
-size_t GetRegistryLengthFromHostIncludingPrivate(
-    const std::string& host,
-    UnknownRegistryFilter unknown_filter) {
-  return GetRegistryLength(host, unknown_filter, INCLUDE_PRIVATE_REGISTRIES);
+  return GetRegistryLengthForCanonicalHost(host, unknown_filter,
+                                           INCLUDE_PRIVATE_REGISTRIES);
 }
 
 }  // namespace
 
 class RegistryControlledDomainTest : public testing::Test {
  protected:
   template <typename Graph>
   void UseDomainData(const Graph& graph) {
     SetFindDomainGraph(graph, sizeof(Graph));
   }
@@ skipping 130 matching lines @@
   EXPECT_EQ(0U, GetRegistryLengthFromURL("http://localhost.",
                                          EXCLUDE_UNKNOWN_REGISTRIES));
   EXPECT_EQ(0U, GetRegistryLengthFromURL("http://localhost.",
                                          INCLUDE_UNKNOWN_REGISTRIES));
   EXPECT_EQ(0U, GetRegistryLengthFromURL("http:////Comment",
                                          EXCLUDE_UNKNOWN_REGISTRIES));
 
   // Test std::string version of GetRegistryLength().  Uses the same
   // underpinnings as the GURL version, so this is really more of a check of
   // CanonicalizeHost().
-  EXPECT_EQ(2U, GetRegistryLengthFromHost("a.baz.jp",
-                                          EXCLUDE_UNKNOWN_REGISTRIES));  // 1
-  EXPECT_EQ(3U, GetRegistryLengthFromHost("a.baz.jp.",
-                                          EXCLUDE_UNKNOWN_REGISTRIES));  // 1
-  EXPECT_EQ(0U, GetRegistryLengthFromHost("ac.jp",
-                                          EXCLUDE_UNKNOWN_REGISTRIES));  // 2
-  EXPECT_EQ(0U, GetRegistryLengthFromHost("a.bar.jp",
-                                          EXCLUDE_UNKNOWN_REGISTRIES));  // 3
-  EXPECT_EQ(0U, GetRegistryLengthFromHost("bar.jp",
-                                          EXCLUDE_UNKNOWN_REGISTRIES));  // 3
-  EXPECT_EQ(0U, GetRegistryLengthFromHost("baz.bar.jp",
-                                          EXCLUDE_UNKNOWN_REGISTRIES));  // 3 4
-  EXPECT_EQ(12U, GetRegistryLengthFromHost("a.b.baz.bar.jp",
-                                           EXCLUDE_UNKNOWN_REGISTRIES)); // 4
-  EXPECT_EQ(6U, GetRegistryLengthFromHost("baz.pref.bar.jp",
-                                          EXCLUDE_UNKNOWN_REGISTRIES));  // 5
-  EXPECT_EQ(11U, GetRegistryLengthFromHost("a.b.bar.baz.com",
-                                           EXCLUDE_UNKNOWN_REGISTRIES)); // 6
-  EXPECT_EQ(3U, GetRegistryLengthFromHost("a.d.c",
-                                          EXCLUDE_UNKNOWN_REGISTRIES));  // 7
-  EXPECT_EQ(3U, GetRegistryLengthFromHost(".a.d.c",
-                                          EXCLUDE_UNKNOWN_REGISTRIES));  // 7
-  EXPECT_EQ(3U, GetRegistryLengthFromHost("..a.d.c",
-                                          EXCLUDE_UNKNOWN_REGISTRIES));  // 7
-  EXPECT_EQ(1U, GetRegistryLengthFromHost("a.b.c",
-                                          EXCLUDE_UNKNOWN_REGISTRIES));  // 7 8
-  EXPECT_EQ(0U, GetRegistryLengthFromHost("baz.com",
-                                          EXCLUDE_UNKNOWN_REGISTRIES));  // none
-  EXPECT_EQ(0U, GetRegistryLengthFromHost("baz.com.",
-                                          EXCLUDE_UNKNOWN_REGISTRIES));  // none
-  EXPECT_EQ(3U, GetRegistryLengthFromHost("baz.com",
-                                          INCLUDE_UNKNOWN_REGISTRIES));  // none
-  EXPECT_EQ(4U, GetRegistryLengthFromHost("baz.com.",
-                                          INCLUDE_UNKNOWN_REGISTRIES));  // none
+  EXPECT_EQ(2U, GetRegistryLengthForCanonicalHost(
+                    "a.baz.jp", EXCLUDE_UNKNOWN_REGISTRIES));  // 1
+  EXPECT_EQ(3U, GetRegistryLengthForCanonicalHost(
+                    "a.baz.jp.", EXCLUDE_UNKNOWN_REGISTRIES));  // 1
+  EXPECT_EQ(0U, GetRegistryLengthForCanonicalHost(
+                    "ac.jp", EXCLUDE_UNKNOWN_REGISTRIES));  // 2
+  EXPECT_EQ(0U, GetRegistryLengthForCanonicalHost(
+                    "a.bar.jp", EXCLUDE_UNKNOWN_REGISTRIES));  // 3
+  EXPECT_EQ(0U, GetRegistryLengthForCanonicalHost(
+                    "bar.jp", EXCLUDE_UNKNOWN_REGISTRIES));  // 3
+  EXPECT_EQ(0U, GetRegistryLengthForCanonicalHost(
+                    "baz.bar.jp", EXCLUDE_UNKNOWN_REGISTRIES));  // 3 4
+  EXPECT_EQ(12U, GetRegistryLengthForCanonicalHost(
+                     "a.b.baz.bar.jp", EXCLUDE_UNKNOWN_REGISTRIES));  // 4
+  EXPECT_EQ(6U, GetRegistryLengthForCanonicalHost(
+                    "baz.pref.bar.jp", EXCLUDE_UNKNOWN_REGISTRIES));  // 5
+  EXPECT_EQ(11U, GetRegistryLengthForCanonicalHost(
+                     "a.b.bar.baz.com", EXCLUDE_UNKNOWN_REGISTRIES));  // 6
+  EXPECT_EQ(3U, GetRegistryLengthForCanonicalHost(
+                    "a.d.c", EXCLUDE_UNKNOWN_REGISTRIES));  // 7
+  EXPECT_EQ(3U, GetRegistryLengthForCanonicalHost(
+                    ".a.d.c", EXCLUDE_UNKNOWN_REGISTRIES));  // 7
+  EXPECT_EQ(3U, GetRegistryLengthForCanonicalHost(
+                    "..a.d.c", EXCLUDE_UNKNOWN_REGISTRIES));  // 7
+  EXPECT_EQ(1U, GetRegistryLengthForCanonicalHost(
+                    "a.b.c", EXCLUDE_UNKNOWN_REGISTRIES));  // 7 8
+  EXPECT_EQ(0U, GetRegistryLengthForCanonicalHost(
+                    "baz.com", EXCLUDE_UNKNOWN_REGISTRIES));  // none
+  EXPECT_EQ(0U, GetRegistryLengthForCanonicalHost(
+                    "baz.com.", EXCLUDE_UNKNOWN_REGISTRIES));  // none
+  EXPECT_EQ(3U, GetRegistryLengthForCanonicalHost(
+                    "baz.com", INCLUDE_UNKNOWN_REGISTRIES));  // none
+  EXPECT_EQ(4U, GetRegistryLengthForCanonicalHost(
+                    "baz.com.", INCLUDE_UNKNOWN_REGISTRIES));  // none
 
-  EXPECT_EQ(std::string::npos,
-      GetRegistryLengthFromHost(std::string(), EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U, GetRegistryLengthFromHost("foo.com..",
-                                          EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U, GetRegistryLengthFromHost("..",
-                                          EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U, GetRegistryLengthFromHost("192.168.0.1",
-                                          EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U, GetRegistryLengthFromHost("localhost",
-                                          EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U, GetRegistryLengthFromHost("localhost",
-                                          INCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U, GetRegistryLengthFromHost("localhost.",
-                                          EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U, GetRegistryLengthFromHost("localhost.",
-                                          INCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(std::string::npos, GetRegistryLengthForCanonicalHost(
+                                   std::string(), EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(0U, GetRegistryLengthForCanonicalHost("foo.com..",
+                                                  EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(
+      0U, GetRegistryLengthForCanonicalHost("..", EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(0U, GetRegistryLengthForCanonicalHost("192.168.0.1",
+                                                  EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(0U, GetRegistryLengthForCanonicalHost("localhost",
+                                                  EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(0U, GetRegistryLengthForCanonicalHost("localhost",
+                                                  INCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(0U, GetRegistryLengthForCanonicalHost("localhost.",
+                                                  EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(0U, GetRegistryLengthForCanonicalHost("localhost.",
+                                                  INCLUDE_UNKNOWN_REGISTRIES));
+
+  // IDN case. This domain is:
+  //   Unicode: U+4E2D, U+56FD
+  //   UTF8: E4, B8, AD, E5, 9B, BD
+  //   IDN: xn--fiqs8s
+  EXPECT_EQ(10U, GetRegistryLengthForCanonicalHost("foo.xn--fiqs8s",
+                                                   EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(10U, BuggyGetHostRegistryLength("foo.xn--fiqs8s",

[brettw, 2016/10/19 20:17:43]

This has a bug but I'm not uploading the fixed version yet to avoid clobbering
the comments I added.

+                                            EXCLUDE_UNKNOWN_REGISTRIES));
+  // These illustrate the "buggy" version on non-canonical URLs. They both
+  // return 10 which is the length of the canonical version, which if the
+  // calling code starts to use as offsets in the string will lead to
+  // corruption.
+  // EXPECT_EQ(18U, BuggyGetHostRegistryLength("foo.%E4%B8%AD%E5%9B%BD",
+  //                                          EXCLUDE_UNKNOWN_REGISTRIES));
+  // EXPECT_EQ(6U, BuggyGetHostRegistryLength("foo.\xE4\xB8\xAD\xE5\x9B\xBD",
+  //                                         EXCLUDE_UNKNOWN_REGISTRIES));
 }
 
 TEST_F(RegistryControlledDomainTest, TestSameDomainOrHost) {
   UseDomainData(test2::kDafsa);
 
   EXPECT_TRUE(CompareDomains("http://a.b.bar.jp/file.html",
                              "http://a.b.bar.jp/file.html"));  // b.bar.jp
   EXPECT_TRUE(CompareDomains("http://a.b.bar.jp/file.html",
                              "http://b.b.bar.jp/file.html"));  // b.bar.jp
   EXPECT_FALSE(CompareDomains("http://a.foo.jp/file.html",     // foo.jp
@@ skipping 101 matching lines @@
   const char key0[] =
       "a.b.6____________________________________________________"
       "________________________________________________6";
   const char key1[] =
       "a.b.7____________________________________________________"
       "________________________________________________7";
   const char key2[] =
       "a.b.a____________________________________________________"
       "________________________________________________8";
 
-  EXPECT_EQ(102U, GetRegistryLengthFromHost(key0, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U, GetRegistryLengthFromHost(key1, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(102U,
-            GetRegistryLengthFromHostIncludingPrivate(
-                key1, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U, GetRegistryLengthFromHost(key2, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(102U, GetRegistryLengthForCanonicalHost(
+                      key0, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(
+      0U, GetRegistryLengthForCanonicalHost(key1, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(102U, GetRegistryLengthForCanonicalHostIncludingPrivate(
+                      key1, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(
+      0U, GetRegistryLengthForCanonicalHost(key2, EXCLUDE_UNKNOWN_REGISTRIES));
 }
 
 TEST_F(RegistryControlledDomainTest, TestDafsaThreeByteOffsets) {
   UseDomainData(test4::kDafsa);
 
   // Testing to lookup keys in a DAFSA with three byte offsets.
   // This DAFSA is constructed so that labels begin and end with unique
   // characters, which makes it impossible to merge labels. The byte array
   // has a size of ~54k. A two byte offset can add at most add 8k to the
   // previous offset. Since we can skip only forward in memory, the nodes
   // representing the return values must be located near the end of the byte
   // array. The probability that we can reach from an arbitrary inner node to
   // a return value without using a three byte offset is small (but not zero).
   // The test is repeated with some different keys and with a reasonable
   // probability at least one of the tested paths has go over a three byte
   // offset.
 
   const char key0[] =
       "a.b.Z6___________________________________________________"
       "_________________________________________________Z6";
   const char key1[] =
       "a.b.Z7___________________________________________________"
       "_________________________________________________Z7";
   const char key2[] =
       "a.b.Za___________________________________________________"
       "_________________________________________________Z8";
 
-  EXPECT_EQ(104U, GetRegistryLengthFromHost(key0, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U, GetRegistryLengthFromHost(key1, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(104U,
-            GetRegistryLengthFromHostIncludingPrivate(
-                key1, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U, GetRegistryLengthFromHost(key2, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(104U, GetRegistryLengthForCanonicalHost(
+                      key0, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(
+      0U, GetRegistryLengthForCanonicalHost(key1, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(104U, GetRegistryLengthForCanonicalHostIncludingPrivate(
+                      key1, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(
+      0U, GetRegistryLengthForCanonicalHost(key2, EXCLUDE_UNKNOWN_REGISTRIES));
 }
 
 TEST_F(RegistryControlledDomainTest, TestDafsaJoinedPrefixes) {
   UseDomainData(test5::kDafsa);
 
   // Testing to lookup keys in a DAFSA with compressed prefixes.
   // This DAFSA is constructed from words with similar prefixes but distinct
   // suffixes. The DAFSA will then form a trie with the implicit source node
   // as root.
 
   const char key0[] = "a.b.ai";
   const char key1[] = "a.b.bj";
   const char key2[] = "a.b.aak";
   const char key3[] = "a.b.bbl";
   const char key4[] = "a.b.aaa";
   const char key5[] = "a.b.bbb";
   const char key6[] = "a.b.aaaam";
   const char key7[] = "a.b.bbbbn";
 
-  EXPECT_EQ(2U, GetRegistryLengthFromHost(key0, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U, GetRegistryLengthFromHost(key1, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(2U,
-            GetRegistryLengthFromHostIncludingPrivate(
-                key1, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(3U, GetRegistryLengthFromHost(key2, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U, GetRegistryLengthFromHost(key3, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(3U,
-            GetRegistryLengthFromHostIncludingPrivate(
-                key3, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U,
-            GetRegistryLengthFromHostIncludingPrivate(
-                key4, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U,
-            GetRegistryLengthFromHostIncludingPrivate(
-                key5, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(5U, GetRegistryLengthFromHost(key6, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(5U, GetRegistryLengthFromHost(key7, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(
+      2U, GetRegistryLengthForCanonicalHost(key0, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(
+      0U, GetRegistryLengthForCanonicalHost(key1, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(2U, GetRegistryLengthForCanonicalHostIncludingPrivate(
+                    key1, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(
+      3U, GetRegistryLengthForCanonicalHost(key2, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(
+      0U, GetRegistryLengthForCanonicalHost(key3, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(3U, GetRegistryLengthForCanonicalHostIncludingPrivate(
+                    key3, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(0U, GetRegistryLengthForCanonicalHostIncludingPrivate(
+                    key4, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(0U, GetRegistryLengthForCanonicalHostIncludingPrivate(
+                    key5, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(
+      5U, GetRegistryLengthForCanonicalHost(key6, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(
+      5U, GetRegistryLengthForCanonicalHost(key7, EXCLUDE_UNKNOWN_REGISTRIES));
 }
 
 TEST_F(RegistryControlledDomainTest, TestDafsaJoinedSuffixes) {
   UseDomainData(test6::kDafsa);
 
   // Testing to lookup keys in a DAFSA with compressed suffixes.
   // This DAFSA is constructed from words with similar suffixes but distinct
   // prefixes. The DAFSA will then form a trie with the implicit sink node as
   // root.
 
   const char key0[] = "a.b.ia";
   const char key1[] = "a.b.jb";
   const char key2[] = "a.b.kaa";
   const char key3[] = "a.b.lbb";
   const char key4[] = "a.b.aaa";
   const char key5[] = "a.b.bbb";
   const char key6[] = "a.b.maaaa";
   const char key7[] = "a.b.nbbbb";
 
-  EXPECT_EQ(2U, GetRegistryLengthFromHost(key0, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U, GetRegistryLengthFromHost(key1, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(2U,
-            GetRegistryLengthFromHostIncludingPrivate(
-                key1, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(3U, GetRegistryLengthFromHost(key2, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U, GetRegistryLengthFromHost(key3, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(3U,
-            GetRegistryLengthFromHostIncludingPrivate(
-                key3, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U,
-            GetRegistryLengthFromHostIncludingPrivate(
-                key4, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(0U,
-            GetRegistryLengthFromHostIncludingPrivate(
-                key5, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(5U, GetRegistryLengthFromHost(key6, EXCLUDE_UNKNOWN_REGISTRIES));
-  EXPECT_EQ(5U, GetRegistryLengthFromHost(key7, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(
+      2U, GetRegistryLengthForCanonicalHost(key0, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(
+      0U, GetRegistryLengthForCanonicalHost(key1, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(2U, GetRegistryLengthForCanonicalHostIncludingPrivate(
+                    key1, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(
+      3U, GetRegistryLengthForCanonicalHost(key2, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(
+      0U, GetRegistryLengthForCanonicalHost(key3, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(3U, GetRegistryLengthForCanonicalHostIncludingPrivate(
+                    key3, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(0U, GetRegistryLengthForCanonicalHostIncludingPrivate(
+                    key4, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(0U, GetRegistryLengthForCanonicalHostIncludingPrivate(
+                    key5, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(
+      5U, GetRegistryLengthForCanonicalHost(key6, EXCLUDE_UNKNOWN_REGISTRIES));
+  EXPECT_EQ(
+      5U, GetRegistryLengthForCanonicalHost(key7, EXCLUDE_UNKNOWN_REGISTRIES));
 }
 }  // namespace registry_controlled_domains
 }  // namespace net