Restrict the set of WoSign/StartCom certs to the Alexa Top 1M

net/cert/cert_verify_proc_whitelist.cc

 // Copyright (c) 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/cert/cert_verify_proc_whitelist.h"
 
 #include <cstdlib>
 
+#include "net/base/lookup_string_in_fixed_set.h"
 #include "net/cert/x509_certificate.h"
 
 namespace net {
 
 namespace {
 
 // clang-format off
 // SHA-256 hashes of the subjectPublicKeyInfos of root certificates owned
 // or operated by WoSign, including that of StartCom. For the certificates,
 // see //net/data/ssl/wosign.
@@ skipping 29 matching lines @@
 };
 // clang-format on
 
 // Comparator to compare a (SHA-256) HashValue with a uint8_t array containing
 // a raw SHA-256 hash. Return value follows memcmp semantics.
 int CompareHashValueToRawHash(const void* key, const void* element) {
   const HashValue* search_key = reinterpret_cast<const HashValue*>(key);
   return memcmp(search_key->data(), element, search_key->size());
 }
 
+namespace wosign {
+#include "net/data/ssl/wosign/wosign_domains-inc.cc"
+}  // namespace
+
 }  // namespace
 
 bool IsNonWhitelistedCertificate(const X509Certificate& cert,
-                                 const HashValueVector& public_key_hashes) {
-  // 2016-10-21 00:00:00 UTC
-  const base::Time last_wosign_cert =
-      base::Time::UnixEpoch() + base::TimeDelta::FromSeconds(1477008000);
-
+                                 const HashValueVector& public_key_hashes,
+                                 base::StringPiece hostname) {
   for (const auto& hash : public_key_hashes) {
     if (hash.tag != HASH_VALUE_SHA256)
       continue;
 
     // Check for WoSign/StartCom certificates.
     if (bsearch(&hash, kWosignKeys, arraysize(kWosignKeys),
-                crypto::kSHA256Length, CompareHashValueToRawHash) != nullptr &&
-        (cert.valid_start().is_null() || cert.valid_start().is_max() ||
-         cert.valid_start() > last_wosign_cert)) {
-      return true;
+                crypto::kSHA256Length, CompareHashValueToRawHash) != nullptr) {
+      // 2016-10-21 00:00:00 UTC
+      const base::Time last_wosign_cert =
+          base::Time::UnixEpoch() + base::TimeDelta::FromSeconds(1477008000);
+
+      // Don't allow new certificates.
+      if (cert.valid_start().is_null() || cert.valid_start().is_max() ||
+          cert.valid_start() > last_wosign_cert) {
+        return true;
+      }
+
+      // Don't allow certificates from non-whitelisted hosts.
+      return !IsWhitelistedHost(wosign::kDafsa, arraysize(wosign::kDafsa),
+                                hostname);
     }
   }
   return false;
 }
 
+bool IsWhitelistedHost(const unsigned char* graph,
+                       size_t graph_length,
+                       base::StringPiece host) {
+  if (host.empty())
+    return false;
+
+  size_t end = host.length();
+
+  // Skip trailing '.', if any.
+  if (host[end - 1] == '.') {
+    --end;
+  }
+
+  // Reverse through each of the domain components, trying to see if the
+  // domain is on the whitelist. For example, the string
+  // "www.domain.example.com" would be processed by first searching
+  // for "com", then "example.com", then "domain.example.com". The
+  // loop will terminate when there are no more distinct label separators,
+  // and thus the final check for "www.domain.example.com".
+  size_t start = end;
+  while (start != 0 &&
+         (start = host.rfind('.', start - 1)) != base::StringPiece::npos) {
+    const char* domain_str = host.data() + start + 1;
+    size_t domain_length = end - start - 1;
+    if (domain_length == 0)
+      return false;
+    if (LookupStringInFixedSet(graph, graph_length, domain_str,
+                               domain_length) != kDafsaNotFound) {
+      return true;
+    }
+  }
+
+  return LookupStringInFixedSet(graph, graph_length, host.data(), end) !=
+         kDafsaNotFound;
+}
+
 }  // namespace net