Add OCSPVerifyResult for tracking stapled OCSP responses cross-platform.

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/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"
 
 #if defined(USE_NSS_CERTS)
 #include "net/cert/cert_verify_proc_nss.h"
 #elif defined(USE_OPENSSL_CERTS) && !defined(OS_ANDROID)
 #include "net/cert/cert_verify_proc_openssl.h"
 #elif defined(OS_ANDROID)
 #include "net/cert/cert_verify_proc_android.h"
 #elif defined(OS_IOS)
 #include "net/cert/cert_verify_proc_ios.h"
@@ skipping 138 matching lines @@
 bool IsPastSHA1DeprecationDate(const X509Certificate& cert) {
   const base::Time& start = cert.valid_start();
   if (start.is_max() || start.is_null())
     return true;
   // 2016-01-01 00:00:00 UTC.
   const base::Time kSHA1DeprecationDate =
       base::Time::FromInternalValue(INT64_C(13096080000000000));
   return start >= kSHA1DeprecationDate;
 }
 
+bool CheckCertIDMatchesCertificate(const OCSPCertID& cert_id,
+                                   const X509Certificate& certificate) {
+  // TODO(dadrian): Verify name and key hashes. https://crbug.com/620005
+  der::Input serial(&certificate.serial_number());
+  return cert_id.serial_number == serial;
+}
+
+void CheckOCSP(const std::string& raw_response,
+               CertVerifyResult* verify_result) {
+  verify_result->ocsp.Reset();
+
+  if (raw_response.empty()) {
+    verify_result->ocsp.response_status = OCSPVerifyResult::MISSING;
+    return;
+  }
+  der::Input response_der(&raw_response);
+
+  OCSPResponse response;
+  if (!ParseOCSPResponse(response_der, &response)) {
+    verify_result->ocsp.response_status = OCSPVerifyResult::PARSE_RESPONSE;
+    return;
+  }
+
+  // If the OCSP response isn't status SUCCESSFUL, don't parse the rest of the
+  // data.
+  if (response.status != OCSPResponse::ResponseStatus::SUCCESSFUL) {
+    verify_result->ocsp.response_status = OCSPVerifyResult::BAD_RESPONSE;
+    return;
+  }
+
+  OCSPResponseData response_data;
+  if (!ParseOCSPResponseData(response.data, &response_data)) {
+    verify_result->ocsp.response_status = OCSPVerifyResult::PARSE_RESPONSE_DATA;
+    return;
+  }
+
+  // If producedAt is outside of the certificate validity period, reject the
+  // response.
+  der::GeneralizedTime not_before, not_after;
+  if (!der::EncodeTimeAsGeneralizedTime(
+          verify_result->verified_cert->valid_start(), &not_before) ||
+      !der::EncodeTimeAsGeneralizedTime(
+          verify_result->verified_cert->valid_expiry(), &not_after)) {
+    verify_result->ocsp.response_status = OCSPVerifyResult::BAD_PRODUCED_AT;
+    return;
+  }
+  if (response_data.produced_at < not_before ||
+      response_data.produced_at > not_after) {
+    verify_result->ocsp.response_status = OCSPVerifyResult::BAD_PRODUCED_AT;
+    return;
+  }
+
+  // TODO(svaldez): Unify with GetOCSPCertStatus.
+  base::Time verify_time = base::Time::Now();
+  base::TimeDelta max_age = base::TimeDelta::FromDays(7);
+  verify_result->ocsp.response_status = OCSPVerifyResult::NO_MATCHING_RESPONSE;
+  for (const auto& single_response_der : response_data.responses) {
+    OCSPSingleResponse single_response;
+    if (!ParseOCSPSingleResponse(single_response_der, &single_response))
+      continue;
+    OCSPCertID cert_id;
+    if (!ParseOCSPCertID(single_response.cert_id_tlv, &cert_id))
+      continue;
+    if (!CheckCertIDMatchesCertificate(cert_id, *verify_result->verified_cert))
+      continue;
+    if (!CheckOCSPDateValid(single_response, verify_time, max_age)) {
+      if (verify_result->ocsp.response_status != OCSPVerifyResult::PROVIDED)
+        verify_result->ocsp.response_status = OCSPVerifyResult::INVALID_DATE;
+      continue;
+    }
+    verify_result->ocsp.response_status = OCSPVerifyResult::PROVIDED;
+
+    OCSPRevocationStatus current_status =
+        verify_result->ocsp.cert_status.value_or(OCSPRevocationStatus::GOOD);
+    // In the case that we receive multiple responses, we keep only the
+    // strictest status (REVOKED > UNKNOWN > GOOD).
+    if (current_status == OCSPRevocationStatus::GOOD ||
+        single_response.cert_status.status == OCSPRevocationStatus::REVOKED) {
+      verify_result->ocsp.cert_status = single_response.cert_status.status;
+    }
+  }
+}
+
 // 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 56 matching lines @@
   int rv = VerifyInternal(cert, hostname, ocsp_response, flags, crl_set,
                           additional_trust_anchors, verify_result);
 
   UMA_HISTOGRAM_BOOLEAN("Net.CertCommonNameFallback",
                         verify_result->common_name_fallback_used);
   if (!verify_result->is_issued_by_known_root) {
     UMA_HISTOGRAM_BOOLEAN("Net.CertCommonNameFallbackPrivateCA",
                           verify_result->common_name_fallback_used);
   }
 
+  // Check OCSP information

[estark, 2016/07/14 21:14:58]

nit: non-useful comment, I think you could just delete it.

question: I'm wondering if it's correct that we don't call CheckOCSP() in the
event of a blacklisted cert (line 327). I suppose that won't end up mattering
because we plan to only send Expect-Staple reports for certificates that
validate without errors, is that correct? Still, I would lean towards
consistency (either always have verify_result.ocsp populated, or never populate
it in the event of a validation error).

[dadrian, 2016/07/15 01:00:50]

Done.
Hmmm. I'm a fan of consistency, but we also don't do any of the other error
checking when a certificate is blacklisted (e.g. weak keys, name constraints). I
could see almost any approach being rational. /shrug

+  CheckOCSP(ocsp_response, verify_result);
+
   // This check is done after VerifyInternal so that VerifyInternal can fill
   // in the list of public key hashes.
   if (IsPublicKeyBlacklisted(verify_result->public_key_hashes)) {
     verify_result->cert_status |= CERT_STATUS_REVOKED;
     rv = MapCertStatusToNetError(verify_result->cert_status);
   }
 
   std::vector<std::string> dns_names, ip_addrs;
   cert->GetSubjectAltName(&dns_names, &ip_addrs);
   if (HasNameConstraintsViolation(verify_result->public_key_hashes,
@@ skipping 305 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