New SSL metric added: Likely From Same Domain

chrome/browser/ssl/ssl_error_classification.cc

 // Copyright 2014 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 <vector>
 
 #include "chrome/browser/ssl/ssl_error_classification.h"
 
 #include "base/build_time.h"
 #include "base/metrics/field_trial.h"
@@ skipping 37 matching lines @@
   SUBDOMAIN_MATCH,
   SUBDOMAIN_INVERSE_MATCH,
   SUBDOMAIN_OUTSIDE_WILDCARD,
   HOST_NAME_NOT_KNOWN_TLD,
   LIKELY_MULTI_TENANT_HOSTING,
   LOCALHOST,
   PRIVATE_URL,
   AUTHORITY_ERROR_CAPTIVE_PORTAL,
   SELF_SIGNED,
   EXPIRED_RECENTLY,
+  LIKELY_SAME_DOMAIN,
   UNUSED_INTERSTITIAL_CAUSE_ENTRY,
 };
 
 // Events for UMA. Do not reorder or change!
 enum SSLInterstitialCauseCaptivePortal {
   CAPTIVE_PORTAL_ALL,
   CAPTIVE_PORTAL_DETECTION_ENABLED,
   CAPTIVE_PORTAL_DETECTION_ENABLED_OVERRIDABLE,
   CAPTIVE_PORTAL_PROBE_COMPLETED,
   CAPTIVE_PORTAL_PROBE_COMPLETED_OVERRIDABLE,
@@ skipping 133 matching lines @@
           RecordSSLInterstitialCause(overridable, SUBDOMAIN_OUTSIDE_WILDCARD);
         std::vector<std::string> dns_names;
         cert_.GetDNSNames(&dns_names);
         std::vector<Tokens> 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())
           RecordSSLInterstitialCause(overridable, LIKELY_MULTI_TENANT_HOSTING);
+        if (IsCertLikelyFromSameDomain())
+          RecordSSLInterstitialCause(overridable, LIKELY_SAME_DOMAIN);
       } else {
          RecordSSLInterstitialCause(overridable, HOST_NAME_NOT_KNOWN_TLD);
       }
       break;
     }
     case SSLErrorInfo::CERT_AUTHORITY_INVALID: {
       const std::string& hostname = request_url_.HostNoBrackets();
       if (net::IsLocalhost(hostname))
         RecordSSLInterstitialCause(overridable, LOCALHOST);
       if (IsHostnameNonUniqueOrDotless(hostname))
@@ skipping 235 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();
+  std::vector<std::string> 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());
+  std::string host_name_domain = dns_names_domain[dns_names_domain.size() - 1];

[palmer, 2015/07/16 19:08:21]

const std::string& host_name_domain = dns_names_domain.back();

Take a const & for efficiency and const-correctness, and |back| is more concise.

[Bhanu Dev, 2015/07/20 21:59:41]

Done.

+
+  // Last element is the original domain. So, excluding it.
+  return std::find(dns_names_domain.begin(), dns_names_domain.end() - 1,

[palmer, 2015/07/16 19:08:21]

I'm not sure if that kind of pointer arithmetic is valid on iterators? It
probably is, but... ask someone who knows C++ STL better than I do. :)

[Bhanu Dev, 2015/07/20 21:59:41]

http://www.cplusplus.com/reference/iterator/ says that iterator supports
arithmetic operators. Similar iterator arithmetic is used previously, an example
at
https://code.google.com/p/chromium/codesearch#chromium/src/net/http/http_resp....
Thanks

+                   host_name_domain) != dns_names_domain.end() - 1;
+}
+
 // static
 bool SSLErrorClassification::IsHostnameNonUniqueOrDotless(
     const std::string& hostname) {
   return net::IsHostnameNonUnique(hostname) ||
          hostname.find('.') == std::string::npos;
 }
 
 void SSLErrorClassification::Observe(
     int type,
     const content::NotificationSource& source,
@@ skipping 17 matching lines @@
     // sure we don't clear the captive protal flag, since the interstitial was
     // potentially caused by the captive portal.
     captive_portal_detected_ = captive_portal_detected_ ||
         (results->result == captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL);
     // Also keep track of non-HTTP portals and error cases.
     captive_portal_no_response_ = captive_portal_no_response_ ||
         (results->result == captive_portal::RESULT_NO_RESPONSE);
   }
 #endif
 }