Add Expect CT policy that gets checked on all certs

net/socket/ssl_client_socket_unittest.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/socket/ssl_client_socket.h"
 
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/location.h"
@@ skipping 666 matching lines @@
                            const std::string&,
                            const std::string&,
                            ct::CTVerifyResult*,
                            const BoundNetLog&));
   MOCK_METHOD1(SetObserver, void(CTVerifier::Observer*));
 };
 
 // A mock CTPolicyEnforcer that returns a custom verification result.
 class MockCTPolicyEnforcer : public CTPolicyEnforcer {
  public:
-  MOCK_METHOD4(DoesConformToCTEVPolicy,
+  MOCK_METHOD4(DoesConformToCTPolicy,
                bool(X509Certificate* cert,
                     const ct::EVCertsWhitelist*,
                     const ct::CTVerifyResult&,
                     const BoundNetLog&));
 };
 
 class SSLClientSocketTest : public PlatformTest {
  public:
   SSLClientSocketTest()
       : socket_factory_(ClientSocketFactory::GetDefaultFactory()),
@@ skipping 1629 matching lines @@
 
   // To activate the CT/EV policy enforcement non-null CTVerifier and
   // CTPolicyEnforcer are needed.
   MockCTVerifier ct_verifier;
   SetCTVerifier(&ct_verifier);
   EXPECT_CALL(ct_verifier, Verify(_, "", "", _, _)).WillRepeatedly(Return(OK));
 
   // Emulate compliance of the certificate to the policy.
   MockCTPolicyEnforcer policy_enforcer;
   SetCTPolicyEnforcer(&policy_enforcer);
-  EXPECT_CALL(policy_enforcer, DoesConformToCTEVPolicy(_, _, _, _))
+  EXPECT_CALL(policy_enforcer, DoesConformToCTPolicy(_, _, _, _))
       .WillRepeatedly(Return(true));
 
   int rv;
   ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
   EXPECT_EQ(OK, rv);
 
   SSLInfo result;
   ASSERT_TRUE(sock_->GetSSLInfo(&result));
 
   EXPECT_TRUE(result.cert_status & CERT_STATUS_IS_EV);
@@ skipping 11 matching lines @@
 
   // To activate the CT/EV policy enforcement non-null CTVerifier and
   // CTPolicyEnforcer are needed.
   MockCTVerifier ct_verifier;
   SetCTVerifier(&ct_verifier);
   EXPECT_CALL(ct_verifier, Verify(_, "", "", _, _)).WillRepeatedly(Return(OK));
 
   // Emulate non-compliance of the certificate to the policy.
   MockCTPolicyEnforcer policy_enforcer;
   SetCTPolicyEnforcer(&policy_enforcer);
-  EXPECT_CALL(policy_enforcer, DoesConformToCTEVPolicy(_, _, _, _))
+  EXPECT_CALL(policy_enforcer, DoesConformToCTPolicy(_, _, _, _))
       .WillRepeatedly(Return(false));
 
   int rv;
   ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
   EXPECT_EQ(OK, rv);
 
   SSLInfo result;
   ASSERT_TRUE(sock_->GetSSLInfo(&result));
 
   EXPECT_FALSE(result.cert_status & CERT_STATUS_IS_EV);
   EXPECT_TRUE(result.cert_status & CERT_STATUS_CT_COMPLIANCE_FAILED);
 }
 
+// Test that when a CT verifier and a CTPolicyEnforcer are defined, but
+// the non-EV certificate used does not conform to the CT/EV policy, the
+// correct cert status flag is set.
+TEST_F(SSLClientSocketTest, CertStatusSetForNonCompliantNonEVCert) {
+  SpawnedTestServer::SSLOptions ssl_options;
+  ASSERT_TRUE(StartTestServer(ssl_options));
+
+  SSLConfig ssl_config;
+
+  // To activate the CT/EV policy enforcement non-null CTVerifier and
+  // CTPolicyEnforcer are needed.
+  MockCTVerifier ct_verifier;
+  SetCTVerifier(&ct_verifier);
+  EXPECT_CALL(ct_verifier, Verify(_, "", "", _, _)).WillRepeatedly(Return(OK));
+
+  // Emulate non-compliance of the certificate to the policy.
+  MockCTPolicyEnforcer policy_enforcer;
+  SetCTPolicyEnforcer(&policy_enforcer);
+  EXPECT_CALL(policy_enforcer, DoesConformToCTPolicy(_, _, _, _))
+      .WillRepeatedly(Return(false));
+
+  int rv;
+  ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
+  EXPECT_EQ(OK, rv);
+
+  SSLInfo result;
+  ASSERT_TRUE(sock_->GetSSLInfo(&result));
+
+  EXPECT_TRUE(result.cert_status & CERT_STATUS_CT_COMPLIANCE_FAILED);
+}
+
 namespace {
 
 bool IsValidOCSPResponse(const base::StringPiece& input) {
   der::Parser parser(der::Input(reinterpret_cast<const uint8_t*>(input.data()),
                                 input.length()));
   der::Parser sequence;
   return parser.ReadSequence(&sequence) && !parser.HasMore() &&
          sequence.SkipTag(der::kEnumerated) &&
          sequence.SkipTag(der::kTagContextSpecific | der::kTagConstructed |
                           0) &&
@@ skipping 842 matching lines @@
   int rv;
   ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
   EXPECT_EQ(OK, rv);
 
   std::string proto;
   EXPECT_EQ(SSLClientSocket::kNextProtoUnsupported,
             sock_->GetNextProto(&proto));
 }
 
 }  // namespace net