Record UMA metrics for Must-Staple certificates on private roots

net/cert/cert_verify_proc.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.
 
 #include "net/cert/cert_verify_proc.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/sha1.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "net/base/net_errors.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/base/url_util.h"
+#include "net/cert/asn1_util.h"
 #include "net/cert/cert_status_flags.h"
 #include "net/cert/cert_verifier.h"
 #include "net/cert/cert_verify_proc_whitelist.h"
 #include "net/cert/cert_verify_result.h"
 #include "net/cert/crl_set.h"
 #include "net/cert/internal/parse_ocsp.h"
 #include "net/cert/ocsp_revocation_status.h"
 #include "net/cert/x509_certificate.h"
 #include "net/der/encode_values.h"
 #include "url/url_canon.h"
@@ skipping 271 matching lines @@
       current_status = ocsp_result->revocation_status;
     }
     if (current_status == OCSPRevocationStatus::GOOD ||
         single_response.cert_status.status == OCSPRevocationStatus::REVOKED) {
       ocsp_result->revocation_status = single_response.cert_status.status;
     }
     ocsp_result->response_status = OCSPVerifyResult::PROVIDED;
   }
 }
 
+// Records histograms indicating whether the certificate |cert|, which
+// is assumed to have been validated chaining to a private root,
+// contains the TLS Feature Extension (https://tools.ietf.org/html/rfc7633) and
+// has valid OCSP information stapled.
+void RecordTLSFeatureExtensionWithPrivateRoot(
+    X509Certificate* cert,
+    const OCSPVerifyResult& ocsp_result) {
+  std::string cert_der;
+  if (!X509Certificate::GetDEREncoded(cert->os_cert_handle(), &cert_der))
+    return;
+
+  bool has_tls_feature_extension;
+  if (!asn1::HasTLSFeatureExtension(cert_der, &has_tls_feature_extension))

[eroman, 2016/10/21 01:49:23]

Should we be checking more specifically for the presence of status_request  (and
status_request_2) in the feature list?

The assumption here is that if it has a TLS feature extension, that extension
includes status_request.
Which might be a reasonable assumption to make. Can the feature list also be
empty? Or are there values other than status_request that might be in there?

[estark, 2016/10/21 02:11:29]

My understanding is that the extension is only used for status_request or
status_request2 in practice (and either of those are interesting for my
purposes), and would only appear when a Must-Staple certificate is explicitly
requested (and thus wouldn't be empty). The RFC is pretty OCSP-focused too. So I
think this is a reasonable assumption to make. I'll add a comment explaining it
though.

+    return;
+
+  UMA_HISTOGRAM_BOOLEAN("Net.Certificate.TLSFeatureExtensionWithPrivateRoot",
+                        has_tls_feature_extension);
+  if (!has_tls_feature_extension)
+    return;
+
+  UMA_HISTOGRAM_BOOLEAN(
+      "Net.Certificate.TLSFeatureExtensionWithPrivateRootHasOCSP",
+      (ocsp_result.response_status != OCSPVerifyResult::MISSING));
+}
+
 // Comparison functor used for binary searching whether a given HashValue,
 // which MUST be a SHA-256 hash, is contained with an array of SHA-256
 // hashes.
 struct HashToArrayComparator {
   template <size_t N>
   bool operator()(const uint8_t(&lhs)[N], const HashValue& rhs) const {
     static_assert(N == crypto::kSHA256Length,
                   "Only SHA-256 hashes are supported");
     return memcmp(lhs, rhs.data(), crypto::kSHA256Length) < 0;
   }
@@ skipping 143 matching lines @@
     // now treat it as a warning and do not map it to an error return value.
   }
 
   // Flag certificates using too long validity periods.
   if (verify_result->is_issued_by_known_root && HasTooLongValidity(*cert)) {
     verify_result->cert_status |= CERT_STATUS_VALIDITY_TOO_LONG;
     if (rv == OK)
       rv = MapCertStatusToNetError(verify_result->cert_status);
   }
 
+  // Record a histogram for the presence of the TLS feature extension in
+  // a certificate chaining to a private root.
+  if (rv == OK && !verify_result->is_issued_by_known_root)
+    RecordTLSFeatureExtensionWithPrivateRoot(cert, verify_result->ocsp_result);
+
   return rv;
 }
 
 // static
 bool CertVerifyProc::IsBlacklisted(X509Certificate* cert) {
   // CloudFlare revoked all certificates issued prior to April 2nd, 2014. Thus
   // all certificates where the CN ends with ".cloudflare.com" with a prior
   // issuance date are rejected.
   //
   // The old certs had a lifetime of five years, so this can be removed April
@@ skipping 224 matching lines @@
     return true;
 
   // For certificates issued after 1 April 2015: 39 months.
   if (start >= time_2015_04_01 && month_diff > 39)
     return true;
 
   return false;
 }
 
 }  // namespace net