Reduce buggy usage of the registry controlled domain service.

net/base/registry_controlled_domains/registry_controlled_domain.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.
 
 // NB: Modelled after Mozilla's code (originally written by Pamela Greene,
 // later modified by others), but almost entirely rewritten for Chrome.
 //   (netwerk/dns/src/nsEffectiveTLDService.cpp)
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
@@ skipping 48 matching lines @@
 namespace registry_controlled_domains {
 
 namespace {
 #include "net/base/registry_controlled_domains/effective_tld_names-inc.cc"
 
 // See make_dafsa.py for documentation of the generated dafsa byte array.
 
 const unsigned char* g_graph = kDafsa;
 size_t g_graph_length = sizeof(kDafsa);
 
+struct MappedHostComponent {
+  size_t original_begin;
+  size_t original_end;
+
+  size_t canonical_begin;
+  size_t canonical_end;
+};
+
 size_t GetRegistryLengthImpl(base::StringPiece host,
                              UnknownRegistryFilter unknown_filter,
                              PrivateRegistryFilter private_filter) {
-  DCHECK(!host.empty());
+  if (host.empty())
+    return std::string::npos;
 
   // Skip leading dots.
   const size_t host_check_begin = host.find_first_not_of('.');
   if (host_check_begin == std::string::npos)
     return 0;  // Host is only dots.
 
   // A single trailing dot isn't relevant in this determination, but does need
   // to be included in the final returned length.
   size_t host_check_len = host.length();
   if (host[host_check_len - 1] == '.') {
@@ skipping 99 matching lines @@
 // interface type for all the APIs.
 base::StringPiece GetDomainAndRegistryAsStringPiece(
     const GURL& gurl,
     PrivateRegistryFilter filter) {
   base::StringPiece host = gurl.host_piece();
   if (host.empty() || gurl.HostIsIPAddress())
     return base::StringPiece();
   return GetDomainAndRegistryImpl(host, filter);
 }
 
+// These two functions append the given string as-is to the given output,
+// converting to UTF-8 if necessary.
+void AppendInvalidString(base::StringPiece str, url::CanonOutput* output) {
+  output->Append(str.data(), static_cast<int>(str.length()));
+}
+void AppendInvalidString(base::StringPiece16 str, url::CanonOutput* output) {
+  std::string utf8 = base::UTF16ToUTF8(str);
+  output->Append(utf8.data(), static_cast<int>(utf8.length()));
+}
+
+// Backend for PermissiveGetHostRegistryLength that handles both UTF-8 and
+// UTF-16 input. The template type is the std::string type to use (it makes the
+// typedefs easier than using the character type).
+template <typename Str>
+size_t DoPermissiveGetHostRegistryLength(base::BasicStringPiece<Str> host,
+                                         UnknownRegistryFilter unknown_filter,
+                                         PrivateRegistryFilter private_filter) {
+  std::string canonical_host;  // Do not modify outside of canon_output.
+  canonical_host.reserve(host.length());
+  url::StdStringCanonOutput canon_output(&canonical_host);
+
+  std::vector<MappedHostComponent> components;
+
+  for (size_t current = 0; current < host.length(); current++) {
+    size_t begin = current;
+
+    // Advance to next "." or end.
+    current = host.find('.', begin);
+    if (current == std::string::npos)
+      current = host.length();
+
+    MappedHostComponent mapping;
+    mapping.original_begin = begin;
+    mapping.original_end = current;
+    mapping.canonical_begin = static_cast<size_t>(canon_output.length());
+
+    // Try to append the canonicalized version of this component.
+    int current_len = static_cast<int>(current - begin);
+    if (!url::CanonicalizeHostSubstring(
+            host.data(), url::Component(static_cast<int>(begin), current_len),
+            &canon_output)) {
+      // Failed to canonicalize this component; append as-is.
+      AppendInvalidString(host.substr(begin, current_len), &canon_output);
+    }
+
+    mapping.canonical_end = static_cast<size_t>(canon_output.length());
+    components.push_back(mapping);
+
+    if (current < host.length())
+      canon_output.push_back('.');
+  }
+  canon_output.Complete();
+
+  size_t canonical_rcd_len =
+      GetRegistryLengthImpl(canonical_host, unknown_filter, private_filter);
+  if (canonical_rcd_len == 0 || canonical_rcd_len == std::string::npos)
+    return canonical_rcd_len;  // Error or no registry controlled domain.
+
+  // Find which host component the result started in.
+  size_t canonical_rcd_begin = canonical_host.length() - canonical_rcd_len;
+  for (const auto& mapping : components) {
+    // In the common case, GetRegistryLengthImpl will identify the beginning
+    // of a component and we can just return where that component was in the
+    // original string.
+    if (canonical_rcd_begin == mapping.canonical_begin)
+      return host.length() - mapping.original_begin;
+
+    if (canonical_rcd_begin >= mapping.canonical_end)
+      continue;
+
+    // The registry controlled domain begin was identified as being in the
+    // middle of this dot-separated domain component in the non-canonical
+    // input. This indicates some form of escaped dot, or a non-ASCII
+    // character that was canonicalized to a dot.
+    //
+    // Brute-force search from the end by repeatedly canonicalizing longer
+    // substrings until we get a match for the canonicalized version. This
+    // can't be done with binary search because canonicalization might increase
+    // or decrease the length of the produced string depending on where it's
+    // split. This depends on the canonicalization process not changing the
+    // order of the characters. Punycode can change the order of characters,
+    // but it doesn't work across dots so this is safe.
+
+    // Expected canonical registry controlled domain.
+    base::StringPiece canonical_rcd(&canonical_host[canonical_rcd_begin],
+                                    canonical_rcd_len);
+
+    for (int current_try = static_cast<int>(mapping.original_end) - 1;
+         current_try >= static_cast<int>(mapping.original_begin);
+         current_try--) {
+      std::string try_string;
+      url::StdStringCanonOutput try_output(&try_string);
+
+      if (!url::CanonicalizeHostSubstring(
+              host.data(),
+              url::Component(
+                  current_try,
+                  static_cast<int>(mapping.original_end) - current_try),
+              &try_output))
+        continue;  // Invalid substring, skip.
+
+      try_output.Complete();
+      if (try_string == canonical_rcd)
+        return host.length() - current_try;
+    }
+  }
+
+  NOTREACHED();
+  return canonical_rcd_len;
+}
+
 }  // namespace
 
 std::string GetDomainAndRegistry(const GURL& gurl,
                                  PrivateRegistryFilter filter) {
   return GetDomainAndRegistryAsStringPiece(gurl, filter).as_string();
 }
 
 std::string GetDomainAndRegistry(base::StringPiece host,
                                  PrivateRegistryFilter filter) {
   url::CanonHostInfo host_info;
@@ skipping 29 matching lines @@
 bool SameDomainOrHost(const url::Origin& origin1,
                       const url::Origin& origin2,
                       PrivateRegistryFilter filter) {
   return SameDomainOrHost(origin1.GetURL(), origin2.GetURL(), filter);
 }
 
 size_t GetRegistryLength(
     const GURL& gurl,
     UnknownRegistryFilter unknown_filter,
     PrivateRegistryFilter private_filter) {
-  base::StringPiece host = gurl.host_piece();
-  if (host.empty())
-    return std::string::npos;
-  if (gurl.HostIsIPAddress())
-    return 0;
-  return GetRegistryLengthImpl(host, unknown_filter, private_filter);
+  return GetRegistryLengthImpl(gurl.host_piece(), unknown_filter,
+                               private_filter);
 }
 
-size_t GetRegistryLength(base::StringPiece host,
-                         UnknownRegistryFilter unknown_filter,
-                         PrivateRegistryFilter private_filter) {
+bool HostHasRegistryControlledDomain(base::StringPiece host,
+                                     UnknownRegistryFilter unknown_filter,
+                                     PrivateRegistryFilter private_filter) {
   url::CanonHostInfo host_info;
   const std::string canon_host(CanonicalizeHost(host, &host_info));
-  if (canon_host.empty())
-    return std::string::npos;
-  if (host_info.IsIPAddress())
-    return 0;
+
+  size_t rcd_length;
+  switch (host_info.family) {
+    case url::CanonHostInfo::IPV4:
+    case url::CanonHostInfo::IPV6:
+      // IP addresses don't have R.C.D.'s.
+      return false;
+    case url::CanonHostInfo::BROKEN:
+      // Host is not canonicalizable. Fall back to the slower "permissive"
+      // version.
+      rcd_length =
+          PermissiveGetHostRegistryLength(host, unknown_filter, private_filter);
+      break;
+    case url::CanonHostInfo::NEUTRAL:
+      rcd_length =
+          GetRegistryLengthImpl(canon_host, unknown_filter, private_filter);
+      break;
+    default:
+      NOTREACHED();
+      return false;
+  }
+  return (rcd_length != 0) && (rcd_length != std::string::npos);
+}
+
+size_t GetCanonicalHostRegistryLength(base::StringPiece canon_host,
+                                      UnknownRegistryFilter unknown_filter,
+                                      PrivateRegistryFilter private_filter) {
+#ifndef NDEBUG
+  // Ensure passed-in host name is canonical.
+  url::CanonHostInfo host_info;
+  DCHECK_EQ(net::CanonicalizeHost(canon_host, &host_info), canon_host);
+#endif
+
   return GetRegistryLengthImpl(canon_host, unknown_filter, private_filter);
 }
 
+size_t PermissiveGetHostRegistryLength(base::StringPiece host,
+                                       UnknownRegistryFilter unknown_filter,
+                                       PrivateRegistryFilter private_filter) {
+  return DoPermissiveGetHostRegistryLength<std::string>(host, unknown_filter,
+                                                        private_filter);
+}
+
+size_t PermissiveGetHostRegistryLength(base::StringPiece16 host,
+                                       UnknownRegistryFilter unknown_filter,
+                                       PrivateRegistryFilter private_filter) {
+  return DoPermissiveGetHostRegistryLength<base::string16>(host, unknown_filter,
+                                                           private_filter);
+}
+
 void SetFindDomainGraph() {
   g_graph = kDafsa;
   g_graph_length = sizeof(kDafsa);
 }
 
 void SetFindDomainGraph(const unsigned char* domains, size_t length) {
   CHECK(domains);
   CHECK_NE(length, 0u);
   g_graph = domains;
   g_graph_length = length;
 }
 
 }  // namespace registry_controlled_domains
 }  // namespace net