Implement SDCH Dictionary domain matching as per RFC 2965

net/base/sdch_dictionary.cc

 // Copyright 2015 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/sdch_dictionary.h"
 
+#include "base/strings/string_util.h"
 #include "base/time/clock.h"
 #include "base/time/default_clock.h"
 #include "base/values.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 
-namespace {
-
-bool DomainMatch(const GURL& gurl, const std::string& restriction) {
-  // TODO(jar): This is not precisely a domain match definition.
-  return gurl.DomainIs(restriction);
-}
-
-}  // namespace
-
 namespace net {
 
 SdchDictionary::SdchDictionary(const std::string& dictionary_text,
                                size_t offset,
                                const std::string& client_hash,
                                const std::string& server_hash,
                                const GURL& gurl,
                                const std::string& domain,
                                const std::string& path,
                                const base::Time& expiration,
@@ skipping 119 matching lines @@
   if (path == restriction)
     return true;
   size_t prefix_length = restriction.size();
   if (prefix_length > path.size())
     return false;  // Can't be a prefix.
   if (0 != path.compare(0, prefix_length, restriction))
     return false;
   return restriction[prefix_length - 1] == '/' || path[prefix_length] == '/';
 }
 
+// static
+bool SdchDictionary::DomainMatch(const GURL& gurl,
+                                 const std::string& restriction) {
+  /* RFC 2965:

[Mike West, 2016/04/14 07:32:49]

1. This RFC has been updated by https://tools.ietf.org/html/rfc6265, so you
probably want to reference https://tools.ietf.org/html/rfc6265#section-5.1.3.

2. This replicates logic from CanonicalCookie::IsDomainMatch; I'd suggest either
copy/pasting from that method, or extracting the algorithm out somewhere usable
by both.

+   * Host A's name domain-matches host B's if
+   *   *  their host name strings string-compare equal; or
+   *   * A is a HDN string and has the form NB, where N is a non-empty
+   *      name string, B has the form .B', and B' is a HDN string.  (So,
+   *      x.y.com domain-matches .Y.com but not Y.com.)
+   *
+   *  In our case |gurl| is B, |restriction| is "A".
+   */
+  if (!gurl.is_valid() || restriction.empty())
+    return false;
+
+  // Avoid useless string allocation by using GURL::host()
+  base::StringPiece host(gurl.possibly_invalid_spec().data() +
+                             gurl.parsed_for_possibly_invalid_spec().host.begin,
+                         gurl.parsed_for_possibly_invalid_spec().host.len);
+  if (host.empty())
+    return false;
+
+  base::StringPiece domain(restriction);
+
+  // Ignore trailing '.'s
+  if (*host.rbegin() == '.')
+    host.remove_suffix(1);
+
+  if (*domain.rbegin() == '.')
+    domain.remove_suffix(1);
+
+  // Skip leading '.' in domain and remember it for future use
+  bool has_leading_dot = domain[0] == '.';
+  if (has_leading_dot) {
+    domain.remove_prefix(1);
+  }
+
+  if (host.length() < domain.length())
+    return false;
+
+  // Advance host to be same length as domain.
+  auto distance = host.length() - domain.length();
+  if (distance > 0) {
+    // Make sure there aren't extra characters in host before the compared part;
+    // if the host name is longer than the input domain name, then the character
+    // immediately before the compared part should be a dot. For example,
+    // www.google.com has domain "google.com", but www.iamnotgoogle.com does
+    // not.
+    if (host[distance - 1] != '.')
+      return false;
+
+    host.remove_prefix(distance);
+  }
+
+  if (!base::LowerCaseEqualsASCII(host, domain))
+    return false;
+
+  // If we compared only part of host with domain check that domain starts with
+  // '.'
+  if (distance > 0)
+    return has_leading_dot;
+
+  return true;
+}
+
 bool SdchDictionary::Expired() const {
   return base::Time::Now() > expiration_;
 }
 
 }  // namespace net