Hook up Chrome Cast sender to Cast CRL.

extensions/browser/api/cast_channel/cast_auth_util.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 "extensions/browser/api/cast_channel/cast_auth_util.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "components/cast_certificate/cast_cert_validator.h"
+#include "components/cast_certificate/cast_crl.h"
 #include "extensions/browser/api/cast_channel/cast_message_util.h"
 #include "extensions/common/api/cast_channel/cast_channel.pb.h"
 #include "net/cert/x509_certificate.h"
 #include "net/der/parse_values.h"
 
 namespace extensions {
 namespace api {
 namespace cast_channel {
 namespace {
 
 const char* const kParseErrorPrefix = "Failed to parse auth message: ";
 
 // The maximum number of days a cert can live for.
 const int kMaxSelfSignedCertLifetimeInDays = 4;
 
+// Enforce certificate revocation when set to true.
+// If set to false, then any revocation failures are ignored.
+//
+// This flag tracks the changes necessary to fully enforce revocation.
+// Flip this flag to true when the Cast certificate revocation feature
+// is rolled out.

[mark a. foltz, 2016/10/08 04:44:33]

Instead of a hard coded constant you'll probably want to convert this to a flag
plus a Finch experiment.  That way you can test with this feature enabled and
disabled, and roll it out across the user population at a specific time (instead
of by release milestone).

[ryanchung, 2016/10/11 17:15:16]

Sounds good. I've added a feature flag here.

I will write up a plan for a Finch experiment. We can't really run the
experiment until all the Cast devices have been updated to support this.

+const bool kEnforceRevocationCheck = false;
+
 namespace cast_crypto = ::cast_certificate;
 
 // Extracts an embedded DeviceAuthMessage payload from an auth challenge reply
 // message.
 AuthResult ParseAuthMessage(const CastMessage& challenge_reply,
                             DeviceAuthMessage* auth_message) {
   if (challenge_reply.payload_type() != CastMessage_PayloadType_BINARY) {
     return AuthResult::CreateWithParseError(
         "Wrong payload type in challenge reply",
         AuthResult::ERROR_WRONG_PAYLOAD_TYPE);
@@ skipping 84 matching lines @@
   }
 
   const AuthResponse& response = auth_message.response();
   return VerifyCredentials(response, peer_cert_der);
 }
 
 // This function does the following
 //
 // * Verifies that the certificate chain |response.client_auth_certificate| +
 //   |response.intermediate_certificate| is valid and chains to a trusted
-//   Cast root.
+//   Cast root. The list of trusted Cast roots can be overrided by providing a
+//   non-nullptr |cast_trust_store|. The certificate is verified at
+//   |verification_time|.
+//
+// * Verifies that none of the certificates in the chain are revoked based on
+//   the CRL provided in the response |response.crl|. The CRL is verified to be
+//   valid and its issuer certificate chains to a trusted Cast CRL root. The
+//   list of trusted Cast CRL roots can be overrided by providing a non-nullptr
+//   |crl_trust_store|. If |crl_policy| is CRL_OPTIONAL then the result of
+//   revocation checking is ignored. The CRL is verified at
+//   |verification_time|.
 //
 // * Verifies that |response.signature| matches the signature
 //   of |signature_input| by |response.client_auth_certificate|'s public
 //   key.
-AuthResult VerifyCredentials(const AuthResponse& response,
-                             const std::string& signature_input) {
+AuthResult VerifyCredentialsImpl(const AuthResponse& response,
+                                 const std::string& signature_input,
+                                 const cast_crypto::CRLPolicy& crl_policy,
+                                 net::TrustStore* cast_trust_store,
+                                 net::TrustStore* crl_trust_store,
+                                 const base::Time& verification_time) {
   // Verify the certificate
   std::unique_ptr<cast_crypto::CertVerificationContext> verification_context;
 
   // Build a single vector containing the certificate chain.
   std::vector<std::string> cert_chain;
   cert_chain.push_back(response.client_auth_certificate());
   cert_chain.insert(cert_chain.end(),
                     response.intermediate_certificate().begin(),
                     response.intermediate_certificate().end());
 
-  // Use the current time when checking certificate validity.
-  base::Time now = base::Time::Now();
-
-  // CRL should not be enforced until it is served.
-  cast_crypto::CastDeviceCertPolicy device_policy;
-  if (!cast_crypto::VerifyDeviceCert(
-          cert_chain, now, &verification_context, &device_policy, nullptr,
-          cast_certificate::CRLPolicy::CRL_OPTIONAL)) {
-    // TODO(eroman): The error information was lost; this error is ambiguous.
-    return AuthResult("Failed verifying cast device certificate",
-                      AuthResult::ERROR_CERT_NOT_SIGNED_BY_TRUSTED_CA);
+  // Parse the CRL.
+  std::unique_ptr<cast_crypto::CastCRL> crl =
+      cast_crypto::ParseAndVerifyCRLUsingCustomTrustStore(
+          response.crl(), verification_time, crl_trust_store);
+  if (!crl && crl_policy == cast_crypto::CRLPolicy::CRL_REQUIRED) {
+    // CRL is invalid.
+    return AuthResult("Failed verifying Cast CRL.",
+                      AuthResult::ERROR_CRL_INVALID);
   }
 
+  cast_crypto::CastDeviceCertPolicy device_policy;
+  bool verification_success =
+      cast_crypto::VerifyDeviceCertUsingCustomTrustStore(
+          cert_chain, verification_time, &verification_context, &device_policy,
+          crl.get(), crl_policy, cast_trust_store);
+  if (!verification_success) {
+    // TODO(ryanchung): Once this feature is completely rolled-out, remove the
+    // reverification step and use error reporting to get verification errors
+    // for metrics.
+    bool verification_no_crl_success =
+        cast_crypto::VerifyDeviceCertUsingCustomTrustStore(
+            cert_chain, verification_time, &verification_context,
+            &device_policy, nullptr, cast_crypto::CRLPolicy::CRL_OPTIONAL,
+            cast_trust_store);
+    if (!verification_no_crl_success) {
+      // TODO(eroman): The error information was lost; this error is ambiguous.
+      return AuthResult("Failed verifying cast device certificate",
+                        AuthResult::ERROR_CERT_NOT_SIGNED_BY_TRUSTED_CA);
+    }
+    if (crl_policy == cast_crypto::CRLPolicy::CRL_REQUIRED) {
+      // Device is revoked.
+      return AuthResult("Failed certificate revocation check.",
+                        AuthResult::ERROR_CERT_REVOKED);
+    }
+  }
   if (!verification_context->VerifySignatureOverData(response.signature(),
                                                      signature_input)) {
     return AuthResult("Failed verifying signature over data",
                       AuthResult::ERROR_SIGNED_BLOBS_MISMATCH);
   }
 
   AuthResult success;
 
   // Set the policy into the result.
   switch (device_policy) {
     case cast_crypto::CastDeviceCertPolicy::AUDIO_ONLY:
       success.channel_policies = AuthResult::POLICY_AUDIO_ONLY;
       break;
     case cast_crypto::CastDeviceCertPolicy::NONE:
       success.channel_policies = AuthResult::POLICY_NONE;
       break;
   }
 
   return success;
 }
 
+AuthResult VerifyCredentials(const AuthResponse& response,
+                             const std::string& signature_input) {
+  base::Time now = base::Time::Now();
+  cast_crypto::CRLPolicy policy = cast_crypto::CRLPolicy::CRL_REQUIRED;
+  if (!kEnforceRevocationCheck) {
+    policy = cast_crypto::CRLPolicy::CRL_OPTIONAL;
+  }
+  return VerifyCredentialsImpl(response, signature_input, policy, nullptr,
+                               nullptr, now);
+}
+
+AuthResult VerifyCredentialsForTest(const AuthResponse& response,
+                                    const std::string& signature_input,
+                                    const cast_crypto::CRLPolicy& crl_policy,
+                                    net::TrustStore* cast_trust_store,
+                                    net::TrustStore* crl_trust_store,
+                                    const base::Time& verification_time) {
+  return VerifyCredentialsImpl(response, signature_input, crl_policy,
+                               cast_trust_store, crl_trust_store,
+                               verification_time);
+}
+
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions