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,

[Ryan Sleevi, 2016/07/18 20:08:08]

Document

[dadrian, 2016/07/18 22:23:32]

Done.

+                                   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,

[Ryan Sleevi, 2016/07/18 20:08:08]

Document

[dadrian, 2016/07/18 22:23:32]

Done.

+               CertVerifyResult* verify_result) {

[Ryan Sleevi, 2016/07/18 20:08:08]

Is CertVerifyResult really the right dependency? It looks like you're using it
to smuggle two parameters - the output OCSP response, and the cert under
inspection.

I'd suggest making those inputs explicit (that is, rather than taking the
CertVerifyResult directly)

[dadrian, 2016/07/18 22:23:31]

Done.

+  verify_result->ocsp.Reset();

[Ryan Sleevi, 2016/07/18 20:08:08]

Do we need an explicit reset? Can't you just do a by-val assignment? Is this
just cargo-culted from CertVerifyResult?

[dadrian, 2016/07/18 22:23:32]

Done.

+
+  if (raw_response.empty()) {
+    verify_result->ocsp.response_status = OCSPVerifyResult::MISSING;
+    return;
+  }
+  der::Input response_der(&raw_response);

[Ryan Sleevi, 2016/07/18 20:08:08]

move the newline from 204 to 203 :)

[dadrian, 2016/07/18 22:23:31]

Done.

+
+  OCSPResponse response;
+  if (!ParseOCSPResponse(response_der, &response)) {
+    verify_result->ocsp.response_status = OCSPVerifyResult::PARSE_RESPONSE;

[Ryan Sleevi, 2016/07/18 20:08:07]

Is PARSE_RESPONSE a good name for the enum? How does it distinguish from
BAD_RESPONSE?

Should it be PARSE_ERROR?

[dadrian, 2016/07/18 22:23:32]

I changed it to PARSE_RESPONSE_ERROR and PARSE_RESPONSE_DATA_ERROR, to
distinguish the two cases, while still making it clear it's a parsing error.

+    return;
+  }
+
+  // If the OCSP response isn't status SUCCESSFUL, don't parse the rest of the
+  // data.

[Ryan Sleevi, 2016/07/18 20:08:07]

Could you explain the "why" more? Why is this a 'bad' response?

[dadrian, 2016/07/18 22:23:32]

Done.

+  if (response.status != OCSPResponse::ResponseStatus::SUCCESSFUL) {
+    verify_result->ocsp.response_status = OCSPVerifyResult::BAD_RESPONSE;
+    return;
+  }
+
+  OCSPResponseData response_data;
+  if (!ParseOCSPResponseData(response.data, &response_data)) {

[Ryan Sleevi, 2016/07/18 20:08:07]

This could benefit from documentation, because ParseOCSPResponse and
ParseOCSPResponseData aren't immediately clear about the distinction between
these two. For example, citing spec text (as you can see in the other RFC 5280
validation code) is useful to help refresh readers' context about what's
happening.

[dadrian, 2016/07/18 22:23:32]

Done.

+    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)) {

[Ryan Sleevi, 2016/07/18 20:08:08]

Just to make sure I understand: We parse the certificate validity, and then
re-encode the certificate validity?

[dadrian, 2016/07/18 22:23:32]

Aren't computers great? :) 

The other option would be to implement der::EncodeGeneralizedTimeToTime(), but
based on previous experience, this would literally take months.

+    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.

[Ryan Sleevi, 2016/07/18 20:08:08]

Is there a Bug #?

[dadrian, 2016/07/18 22:23:32]

There is now. https://crbug.com/629249

+  base::Time verify_time = base::Time::Now();
+  base::TimeDelta max_age = base::TimeDelta::FromDays(7);

[Ryan Sleevi, 2016/07/18 20:08:08]

Should this be a function-level static constant so it's clearly documented the
magic age?

[dadrian, 2016/07/18 22:23:31]

Sure? Not sure what the rules are here, but this is buried pretty deep. I'll try
to draw it out.

+  verify_result->ocsp.response_status = OCSPVerifyResult::NO_MATCHING_RESPONSE;
+  for (const auto& single_response_der : response_data.responses) {

[Ryan Sleevi, 2016/07/18 20:08:07]

You could do with some high-level documentation about the logic for matching,
and why it's incomplete here.

For example

for (const auto& single_response_der : response_data.responses) {
  // Although in most cases there should only be a single response (for the
certificate requested), it's
  // possible the OCSP responder provided statuses for multiple certificates.
Look through all the
  // responses to see if there's a response that matches the
|verify_result->verified_cert|'s certificate.
  // This matching is ...

}

etc

[dadrian, 2016/07/18 22:23:32]

Done.

+    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)

[Ryan Sleevi, 2016/07/18 20:08:07]

This could benefit from documentation

[dadrian, 2016/07/18 22:23:32]

Done.

+        verify_result->ocsp.response_status = OCSPVerifyResult::INVALID_DATE;
+      continue;
+    }
+    verify_result->ocsp.response_status = OCSPVerifyResult::PROVIDED;
+
+    OCSPRevocationStatus current_status =
+        verify_result->ocsp.revocation_status.value_or(
+            OCSPRevocationStatus::GOOD);
+    // In the case that we receive multiple responses, we keep only the

[Ryan Sleevi, 2016/07/18 20:08:08]

Avoid "we" in comments, especially new code.

// In the event multiple responses are received, keep the strictest status
(REVOKED > UNKNOWN > GOOD)

[dadrian, 2016/07/18 22:23:32]

Done.

+    // strictest status (REVOKED > UNKNOWN > GOOD).
+    if (current_status == OCSPRevocationStatus::GOOD ||
+        single_response.cert_status.status == OCSPRevocationStatus::REVOKED) {
+      verify_result->ocsp.revocation_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);
   }
 
+  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