Move error classification into the ssl_errors component

components/ssl_errors/error_classification.cc

-// Copyright 2014 The Chromium Authors. All rights reserved.
+// 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 "components/ssl_errors/error_classification.h"
+
 #include <vector>
 
-#include "chrome/browser/ssl/ssl_error_classification.h"
-
 #include "base/build_time.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "components/ssl_errors/error_info.h"
 #include "net/base/net_util.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/cert/x509_cert_types.h"
 #include "net/cert/x509_certificate.h"
 #include "url/gurl.h"
 
 #if defined(OS_WIN)
 #include "base/win/win_util.h"
 #include "base/win/windows_version.h"
 #endif
 
 using base::Time;
 using base::TimeTicks;
 using base::TimeDelta;
 
+namespace ssl_errors {
 namespace {
 
 // Events for UMA. Do not reorder or change!
 enum SSLInterstitialCause {
   CLOCK_PAST,
   CLOCK_FUTURE,
   WWW_SUBDOMAIN_MATCH,
   SUBDOMAIN_MATCH,
   SUBDOMAIN_INVERSE_MATCH,
   SUBDOMAIN_OUTSIDE_WILDCARD,
@@ skipping 11 matching lines @@
 void RecordSSLInterstitialCause(bool overridable, SSLInterstitialCause event) {
   if (overridable) {
     UMA_HISTOGRAM_ENUMERATION("interstitial.ssl.cause.overridable", event,
                               UNUSED_INTERSTITIAL_CAUSE_ENTRY);
   } else {
     UMA_HISTOGRAM_ENUMERATION("interstitial.ssl.cause.nonoverridable", event,
                               UNUSED_INTERSTITIAL_CAUSE_ENTRY);
   }
 }
 
-int GetLevensteinDistance(const std::string& str1,
-                          const std::string& str2) {
+int GetLevensteinDistance(const std::string& str1, const std::string& str2) {
   if (str1 == str2)
     return 0;
   if (str1.size() == 0)
     return str2.size();
   if (str2.size() == 0)
     return str1.size();
   std::vector<int> kFirstRow(str2.size() + 1, 0);
   std::vector<int> kSecondRow(str2.size() + 1, 0);
 
   for (size_t i = 0; i < kFirstRow.size(); ++i)
     kFirstRow[i] = i;
   for (size_t i = 0; i < str1.size(); ++i) {
     kSecondRow[0] = i + 1;
     for (size_t j = 0; j < str2.size(); ++j) {
       int cost = str1[i] == str2[j] ? 0 : 1;
-      kSecondRow[j+1] = std::min(std::min(
-          kSecondRow[j] + 1, kFirstRow[j + 1] + 1), kFirstRow[j] + cost);
+      kSecondRow[j + 1] =
+          std::min(std::min(kSecondRow[j] + 1, kFirstRow[j + 1] + 1),
+                   kFirstRow[j] + cost);
     }
     for (size_t j = 0; j < kFirstRow.size(); j++)
       kFirstRow[j] = kSecondRow[j];
   }
   return kSecondRow[str2.size()];
 }
 
+std::vector<UrlTokens> GetTokenizedDNSNames(
+    const std::vector<std::string>& dns_names) {
+  std::vector<std::vector<std::string>> dns_name_tokens;

[estark, 2015/10/02 22:17:21]

std::vector<UrlTokens>

[felt, 2015/10/05 18:23:07]

Done.

+  for (size_t i = 0; i < dns_names.size(); ++i) {

[estark, 2015/10/02 22:17:21]

optional nit: could do `for (const auto& dns_name : dns_names)` here

[felt, 2015/10/05 18:23:07]

Done.

+    std::vector<std::string> dns_name_token_single;

[estark, 2015/10/02 22:17:21]

UrlTokens

[felt, 2015/10/05 18:23:07]

Done.

+    if (dns_names[i].empty() || dns_names[i].find('\0') != std::string::npos ||
+        !(IsHostNameKnownTLD(dns_names[i]))) {
+      dns_name_token_single.push_back(std::string());
+    } else {
+      dns_name_token_single = Tokenize(dns_names[i]);
+    }
+    dns_name_tokens.push_back(dns_name_token_single);
+  }
+  return dns_name_tokens;
+}
+
+size_t FindSubDomainDifference(const UrlTokens& potential_subdomain,

[estark, 2015/10/02 22:17:21]

nit: I think we usually capitalize it as "Subdomain" rather than "Subdomain"

Also even though this is an internal helper function I think it could benefit
from a comment, maybe something like "If |potential_subdomain| is a subdomain of
|parent|, returns the number of labels that are different. Otherwise returns 0."

Though it's also kind of weird that potential_subdomain == parent has the same
return value as when they are completely unrelated. Maybe the signature should
be `bool FindSubdomainDifference(potential_subdomain, parent, size_t*
difference)` and returns false if it's not a subdomain of the parent.

(Sorry, I know this is pre-existing code)

[felt, 2015/10/05 05:26:40]

I'll change the signature in a followup CL.

+                               const UrlTokens& parent) {
+  // A check to ensure that the number of tokens in the tokenized_parent is
+  // less than the tokenized_potential_subdomain.
+  if (parent.size() >= potential_subdomain.size())
+    return 0;
+
+  size_t tokens_match = 0;
+  size_t diff_size = potential_subdomain.size() - parent.size();
+  for (size_t i = 0; i < parent.size(); ++i) {
+    if (parent[i] == potential_subdomain[i + diff_size])
+      tokens_match++;
+  }
+  if (tokens_match == parent.size())
+    return diff_size;
+  return 0;
+}

[estark, 2015/10/02 22:17:21]

I think this could be written more simply as:

for (size_t i = 0; i < parent.size(); i++) {
  if (parent[i] != potential_subdomain[i + diff_size])
    return 0;
}
return potential_subdomain.size() - parent.size();

[felt, 2015/10/05 05:26:40]

Follow-up CL

+
 // The time to use when doing build time operations in browser tests.
 base::Time g_testing_build_time;
 
-} // namespace
+}  // namespace
 
-SSLErrorClassification::SSLErrorClassification(const base::Time& current_time,
-                                               const GURL& url,
-                                               int cert_error,
-                                               const net::X509Certificate& cert)
-    : current_time_(current_time),
-      request_url_(url),
-      cert_error_(cert_error),
-      cert_(cert) {}
-
-SSLErrorClassification::~SSLErrorClassification() { }
-
-void SSLErrorClassification::RecordUMAStatistics(
-    bool overridable) const {
+void RecordUMAStatistics(bool overridable,
+                         const base::Time& current_time,
+                         const GURL& request_url,
+                         int cert_error,
+                         const net::X509Certificate& cert) {
   ssl_errors::ErrorInfo::ErrorType type =
-      ssl_errors::ErrorInfo::NetErrorToErrorType(cert_error_);
+      ssl_errors::ErrorInfo::NetErrorToErrorType(cert_error);
   UMA_HISTOGRAM_ENUMERATION("interstitial.ssl_error_type", type,
                             ssl_errors::ErrorInfo::END_OF_ENUM);
   switch (type) {
     case ssl_errors::ErrorInfo::CERT_DATE_INVALID: {
       if (IsUserClockInThePast(base::Time::NowFromSystemTime())) {
         RecordSSLInterstitialCause(overridable, CLOCK_PAST);
       } else if (IsUserClockInTheFuture(base::Time::NowFromSystemTime())) {
         RecordSSLInterstitialCause(overridable, CLOCK_FUTURE);
-      } else if (cert_.HasExpired() &&
-                 (current_time_ - cert_.valid_expiry()).InDays() < 28) {
+      } else if (cert.HasExpired() &&
+                 (current_time - cert.valid_expiry()).InDays() < 28) {
         RecordSSLInterstitialCause(overridable, EXPIRED_RECENTLY);
       }
       break;
     }
     case ssl_errors::ErrorInfo::CERT_COMMON_NAME_INVALID: {
-      std::string host_name = request_url_.host();
+      std::string host_name = request_url.host();
       if (IsHostNameKnownTLD(host_name)) {
-        Tokens host_name_tokens = Tokenize(host_name);
-        if (IsWWWSubDomainMatch())
+        UrlTokens host_name_tokens = Tokenize(host_name);
+        if (IsWWWSubDomainMatch(request_url, cert))
           RecordSSLInterstitialCause(overridable, WWW_SUBDOMAIN_MATCH);
-        if (IsSubDomainOutsideWildcard(host_name_tokens))
+        if (IsSubDomainOutsideWildcard(request_url, cert))
           RecordSSLInterstitialCause(overridable, SUBDOMAIN_OUTSIDE_WILDCARD);
         std::vector<std::string> dns_names;
-        cert_.GetDNSNames(&dns_names);
-        std::vector<Tokens> dns_name_tokens = GetTokenizedDNSNames(dns_names);
+        cert.GetDNSNames(&dns_names);
+        std::vector<UrlTokens> dns_name_tokens =
+            GetTokenizedDNSNames(dns_names);
         if (NameUnderAnyNames(host_name_tokens, dns_name_tokens))
           RecordSSLInterstitialCause(overridable, SUBDOMAIN_MATCH);
         if (AnyNamesUnderName(dns_name_tokens, host_name_tokens))
           RecordSSLInterstitialCause(overridable, SUBDOMAIN_INVERSE_MATCH);
-        if (IsCertLikelyFromMultiTenantHosting())
+        if (IsCertLikelyFromMultiTenantHosting(request_url, cert))
           RecordSSLInterstitialCause(overridable, LIKELY_MULTI_TENANT_HOSTING);
-        if (IsCertLikelyFromSameDomain())
+        if (IsCertLikelyFromSameDomain(request_url, cert))
           RecordSSLInterstitialCause(overridable, LIKELY_SAME_DOMAIN);
       } else {
-         RecordSSLInterstitialCause(overridable, HOST_NAME_NOT_KNOWN_TLD);
+        RecordSSLInterstitialCause(overridable, HOST_NAME_NOT_KNOWN_TLD);
       }
       break;
     }
     case ssl_errors::ErrorInfo::CERT_AUTHORITY_INVALID: {
-      const std::string& hostname = request_url_.HostNoBrackets();
+      const std::string& hostname = request_url.HostNoBrackets();
       if (net::IsLocalhost(hostname))
         RecordSSLInterstitialCause(overridable, LOCALHOST);
       if (IsHostnameNonUniqueOrDotless(hostname))
         RecordSSLInterstitialCause(overridable, PRIVATE_URL);
-      if (net::X509Certificate::IsSelfSigned(cert_.os_cert_handle()))
+      if (net::X509Certificate::IsSelfSigned(cert.os_cert_handle()))
         RecordSSLInterstitialCause(overridable, SELF_SIGNED);
       break;
     }
     default:
       break;
   }
   UMA_HISTOGRAM_ENUMERATION("interstitial.ssl.connection_type",
                             net::NetworkChangeNotifier::GetConnectionType(),
                             net::NetworkChangeNotifier::CONNECTION_LAST);
 }
 
-bool SSLErrorClassification::IsUserClockInThePast(const base::Time& time_now) {
+bool IsUserClockInThePast(const base::Time& time_now) {
   base::Time build_time;
   if (!g_testing_build_time.is_null()) {
     build_time = g_testing_build_time;
   } else {
 #if defined(DONT_EMBED_BUILD_METADATA) && !defined(OFFICIAL_BUILD)
     return false;
 #else
     build_time = base::GetBuildTime();
 #endif
   }
 
   if (time_now < build_time - base::TimeDelta::FromDays(2))
     return true;
   return false;
 }
 
-bool SSLErrorClassification::IsUserClockInTheFuture(
-    const base::Time& time_now) {
+bool IsUserClockInTheFuture(const base::Time& time_now) {
   base::Time build_time;
   if (!g_testing_build_time.is_null()) {
     build_time = g_testing_build_time;
   } else {
 #if defined(DONT_EMBED_BUILD_METADATA) && !defined(OFFICIAL_BUILD)
     return false;
 #else
     build_time = base::GetBuildTime();
 #endif
   }
 
   if (time_now > build_time + base::TimeDelta::FromDays(365))
     return true;
   return false;
 }
 
-// static
-void SSLErrorClassification::SetBuildTimeForTesting(
-    const base::Time& testing_time) {
+void SetBuildTimeForTesting(const base::Time& testing_time) {
   g_testing_build_time = testing_time;
 }
 
-bool SSLErrorClassification::MaybeWindowsLacksSHA256Support() {
-#if defined(OS_WIN)
-  return !base::win::MaybeHasSHA256Support();
-#else
-  return false;
-#endif
-}
-
-bool SSLErrorClassification::IsHostNameKnownTLD(const std::string& host_name) {
-  size_t tld_length =
-      net::registry_controlled_domains::GetRegistryLength(
-          host_name,
-          net::registry_controlled_domains::EXCLUDE_UNKNOWN_REGISTRIES,
-          net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
+bool IsHostNameKnownTLD(const std::string& host_name) {
+  size_t tld_length = net::registry_controlled_domains::GetRegistryLength(
+      host_name, net::registry_controlled_domains::EXCLUDE_UNKNOWN_REGISTRIES,
+      net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
   if (tld_length == 0 || tld_length == std::string::npos)
     return false;
   return true;
 }
 
-std::vector<SSLErrorClassification::Tokens> SSLErrorClassification::
-GetTokenizedDNSNames(const std::vector<std::string>& dns_names) {
-  std::vector<std::vector<std::string>> dns_name_tokens;
-  for (size_t i = 0; i < dns_names.size(); ++i) {
-    std::vector<std::string> dns_name_token_single;
-    if (dns_names[i].empty() || dns_names[i].find('\0') != std::string::npos
-        || !(IsHostNameKnownTLD(dns_names[i]))) {
-      dns_name_token_single.push_back(std::string());
-    } else {
-      dns_name_token_single = Tokenize(dns_names[i]);
-    }
-    dns_name_tokens.push_back(dns_name_token_single);
-  }
-  return dns_name_tokens;
-}
-
-size_t SSLErrorClassification::FindSubDomainDifference(
-    const Tokens& potential_subdomain, const Tokens& parent) const {
-  // A check to ensure that the number of tokens in the tokenized_parent is
-  // less than the tokenized_potential_subdomain.
-  if (parent.size() >= potential_subdomain.size())
-    return 0;
-
-  size_t tokens_match = 0;
-  size_t diff_size = potential_subdomain.size() - parent.size();
-  for (size_t i = 0; i < parent.size(); ++i) {
-    if (parent[i] == potential_subdomain[i + diff_size])
-      tokens_match++;
-  }
-  if (tokens_match == parent.size())
-    return diff_size;
-  return 0;
-}
-
-SSLErrorClassification::Tokens SSLErrorClassification::
-Tokenize(const std::string& name) {
-  return base::SplitString(
-      name, ".", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
+UrlTokens Tokenize(const std::string& name) {
+  return base::SplitString(name, ".", base::KEEP_WHITESPACE,
+                           base::SPLIT_WANT_ALL);
 }
 
 // We accept the inverse case for www for historical reasons.
-bool SSLErrorClassification::GetWWWSubDomainMatch(
-    const std::string& host_name,
-    const std::vector<std::string>& dns_names,
-    std::string* www_match_host_name) {
+bool IsWWWSubDomainMatch(const GURL& request_url,

[estark, 2015/10/02 22:17:21]

To get this out of the header file, I think you could put this in the anonymous
namespace and test GetWWWSubdomainMatch() in the unit tests instead of this
function. That actually seems like it would better because
GetWWWSubdomainMatch() isn't currently unit-tested and it's the thing that
actually gets used outside this file.

[felt, 2015/10/05 18:23:07]

Follow-up CL

+                         const net::X509Certificate& cert) {
+  std::string www_host;
+  std::vector<std::string> dns_names;
+  cert.GetDNSNames(&dns_names);
+  return (GetWWWSubDomainMatch(request_url, dns_names, &www_host));
+}
+
+bool GetWWWSubDomainMatch(const GURL& request_url,
+                          const std::vector<std::string>& dns_names,
+                          std::string* www_match_host_name) {
+  const std::string& host_name = request_url.host();
+
   if (IsHostNameKnownTLD(host_name)) {
     // Need to account for all possible domains given in the SSL certificate.
     for (size_t i = 0; i < dns_names.size(); ++i) {
       if (dns_names[i].empty() ||
           dns_names[i].find('\0') != std::string::npos ||
           dns_names[i].length() == host_name.length() ||
           !IsHostNameKnownTLD(dns_names[i])) {
         continue;
       } else if (dns_names[i].length() > host_name.length()) {
         if (net::StripWWW(base::ASCIIToUTF16(dns_names[i])) ==
             base::ASCIIToUTF16(host_name)) {
           *www_match_host_name = dns_names[i];
           return true;
         }
       } else {
         if (net::StripWWW(base::ASCIIToUTF16(host_name)) ==
             base::ASCIIToUTF16(dns_names[i])) {
           *www_match_host_name = dns_names[i];
           return true;
         }
       }
     }
   }
   return false;
 }
 
-bool SSLErrorClassification::IsWWWSubDomainMatch() const {
-  const std::string& host_name = request_url_.host();
-  std::vector<std::string> dns_names;
-  cert_.GetDNSNames(&dns_names);
-  std::string www_host;
-  return GetWWWSubDomainMatch(host_name, dns_names, &www_host);
-}
-
-bool SSLErrorClassification::NameUnderAnyNames(
-    const Tokens& child,
-    const std::vector<Tokens>& potential_parents) const {
+bool NameUnderAnyNames(const UrlTokens& child,
+                       const std::vector<UrlTokens>& potential_parents) {
   bool result = false;
   // Need to account for all the possible domains given in the SSL certificate.
   for (size_t i = 0; i < potential_parents.size(); ++i) {
     if (potential_parents[i].empty() ||
         potential_parents[i].size() >= child.size()) {
       result = result || false;
     } else {
-      size_t domain_diff = FindSubDomainDifference(child,
-                                                   potential_parents[i]);
-      if (domain_diff == 1 &&  child[0] != "www")
+      size_t domain_diff = FindSubDomainDifference(child, potential_parents[i]);
+      if (domain_diff == 1 && child[0] != "www")
         result = result || true;

[estark, 2015/10/02 22:17:21]

optional nit: I think this can be simplified a little bit though it's not all
that much simpler:

for (size_t i = 0; i < potential_parents.size(); ++i) {
  if (potential_parents[i].empty() || potential_parents[i].size >= child.size())
    continue;
  size_t domain_diff = ...;
  if (domain_diff == 1 && child[0] != "www") return true;
}
return false;

[felt, 2015/10/05 18:23:07]

Follow-up CL

     }
   }
   return result;
 }
 
-bool SSLErrorClassification::AnyNamesUnderName(
-    const std::vector<Tokens>& potential_children,
-    const Tokens& parent) const {
+bool AnyNamesUnderName(const std::vector<UrlTokens>& potential_children,
+                       const UrlTokens& parent) {
   bool result = false;
   // Need to account for all the possible domains given in the SSL certificate.
   for (size_t i = 0; i < potential_children.size(); ++i) {
     if (potential_children[i].empty() ||
         potential_children[i].size() <= parent.size()) {
       result = result || false;
     } else {
-      size_t domain_diff = FindSubDomainDifference(potential_children[i],
-                                                   parent);
-      if (domain_diff == 1 &&  potential_children[i][0] != "www")
+      size_t domain_diff =
+          FindSubDomainDifference(potential_children[i], parent);
+      if (domain_diff == 1 && potential_children[i][0] != "www")

[estark, 2015/10/02 22:17:21]

same optional minor simplification as above

[felt, 2015/10/05 18:23:07]

Follow-up CL

         result = result || true;
     }
   }
   return result;
 }
 
-bool SSLErrorClassification::IsSubDomainOutsideWildcard(
-    const Tokens& host_name_tokens) const {
-  std::string host_name = request_url_.host();
+bool IsSubDomainOutsideWildcard(const GURL& request_url,
+                                const net::X509Certificate& cert) {
+  std::string host_name = request_url.host();
+  UrlTokens host_name_tokens = Tokenize(host_name);
   std::vector<std::string> dns_names;
-  cert_.GetDNSNames(&dns_names);
+  cert.GetDNSNames(&dns_names);
   bool result = false;
 
   // This method requires that the host name be longer than the dns name on
   // the certificate.
   for (size_t i = 0; i < dns_names.size(); ++i) {
     const std::string& name = dns_names[i];
     if (name.length() < 2 || name.length() >= host_name.length() ||
-        name.find('\0') != std::string::npos ||
-        !IsHostNameKnownTLD(name)
-        || name[0] != '*' || name[1] != '.') {
+        name.find('\0') != std::string::npos || !IsHostNameKnownTLD(name) ||
+        name[0] != '*' || name[1] != '.') {
       continue;
     }
 
     // Move past the "*.".
     std::string extracted_dns_name = name.substr(2);
-    if (FindSubDomainDifference(
-        host_name_tokens, Tokenize(extracted_dns_name)) == 2) {
+    if (FindSubDomainDifference(host_name_tokens,
+                                Tokenize(extracted_dns_name)) == 2) {
       return true;
     }
   }
   return result;
 }
 
-bool SSLErrorClassification::IsCertLikelyFromMultiTenantHosting() const {
-  std::string host_name = request_url_.host();
+bool IsCertLikelyFromMultiTenantHosting(const GURL& request_url,
+                                        const net::X509Certificate& cert) {
+  std::string host_name = request_url.host();
   std::vector<std::string> dns_names;
   std::vector<std::string> dns_names_domain;
-  cert_.GetDNSNames(&dns_names);
+  cert.GetDNSNames(&dns_names);
   size_t dns_names_size = dns_names.size();
 
   // If there is only 1 DNS name then it is definitely not a shared certificate.
   if (dns_names_size == 0 || dns_names_size == 1)
     return false;
 
   // Check to see if all the domains in the SAN field in the SSL certificate are
   // the same or not.
   for (size_t i = 0; i < dns_names_size; ++i) {
     dns_names_domain.push_back(
-        net::registry_controlled_domains::
-        GetDomainAndRegistry(
+        net::registry_controlled_domains::GetDomainAndRegistry(
             dns_names[i],
             net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES));
   }
   for (size_t i = 1; i < dns_names_domain.size(); ++i) {
     if (dns_names_domain[i] != dns_names_domain[0])
       return false;
   }
 
   // If the number of DNS names is more than 5 then assume that it is a shared
   // certificate.
@@ skipping 11 matching lines @@
   for (size_t i = 0; i < dns_names_size; ++i) {
     for (size_t j = i + 1; j < dns_names_size; ++j) {
       int edit_distance = GetLevensteinDistance(dns_names[i], dns_names[j]);
       if (edit_distance < kMinimumEditDsitance)
         return false;
     }
   }
   return true;
 }
 
-bool SSLErrorClassification::IsCertLikelyFromSameDomain() const {
-  std::string host_name = request_url_.host();
+bool IsCertLikelyFromSameDomain(const GURL& request_url,
+                                const net::X509Certificate& cert) {
+  std::string host_name = request_url.host();
   std::vector<std::string> dns_names;
-  cert_.GetDNSNames(&dns_names);
+  cert.GetDNSNames(&dns_names);
 
   dns_names.push_back(host_name);
   std::vector<std::string> dns_names_domain;
 
   for (const std::string& dns_name : dns_names) {
     dns_names_domain.push_back(
         net::registry_controlled_domains::GetDomainAndRegistry(
             dns_name,
             net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES));
   }
 
   DCHECK(!dns_names_domain.empty());
   const std::string& host_name_domain = dns_names_domain.back();
 
   // Last element is the original domain. So, excluding it.
   return std::find(dns_names_domain.begin(), dns_names_domain.end() - 1,
                    host_name_domain) != dns_names_domain.end() - 1;
 }
 
-// static
-bool SSLErrorClassification::IsHostnameNonUniqueOrDotless(
-    const std::string& hostname) {
+bool IsHostnameNonUniqueOrDotless(const std::string& hostname) {
   return net::IsHostnameNonUnique(hostname) ||
          hostname.find('.') == std::string::npos;
 }
+
+}  // namespace ssl_errors