Support for client certs in ssl_server_socket.

net/socket/ssl_server_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.
 
 // This test suite uses SSLClientSocket to test the implementation of
 // SSLServerSocket. In order to establish connections between the sockets
 // we need two additional classes:
 // 1. FakeSocket
 //    Connects SSL socket to FakeDataChannel. This class is just a stub.
 //
 // 2. FakeDataChannel
 //    Implements the actual exchange of data between two FakeSockets.
 //
 // Implementations of these two classes are included in this file.
 
 #include "net/socket/ssl_server_socket.h"
 
+#include <openssl/evp.h>
+
 #include <stdint.h>
 #include <stdlib.h>
 
 #include <queue>
 
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "crypto/nss_util.h"
 #include "crypto/rsa_private_key.h"
+#include "crypto/signature_creator.h"
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_data_directory.h"
 #include "net/cert/cert_status_flags.h"
 #include "net/cert/mock_cert_verifier.h"
+#include "net/cert/mock_client_cert_verifier.h"
 #include "net/cert/x509_certificate.h"
 #include "net/http/transport_security_state.h"
 #include "net/log/net_log.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/socket_test_util.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/stream_socket.h"
+#include "net/ssl/ssl_cert_request_info.h"
 #include "net/ssl/ssl_cipher_suite_names.h"
 #include "net/ssl/ssl_connection_status_flags.h"
 #include "net/ssl/ssl_info.h"
+#include "net/ssl/ssl_private_key.h"
 #include "net/ssl/ssl_server_config.h"
 #include "net/test/cert_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 namespace net {
 
 namespace {
 
+const char kClientCertFileName[] = "client_1.pem";
+const char kClientPrivateKeyFileName[] = "client_1.pk8";
+const char kWrongClientCertFileName[] = "client_2.pem";
+const char kWrongClientPrivateKeyFileName[] = "client_2.pk8";
+const char kClientCertCAFileName[] = "client_1_ca.pem";
+
 class FakeDataChannel {
  public:
   FakeDataChannel()
       : read_buf_len_(0),
         closed_(false),
         write_called_after_close_(false),
         weak_factory_(this) {
   }
 
   int Read(IOBuffer* buf, int buf_len, const CompletionCallback& callback) {
@@ skipping 31 matching lines @@
                               weak_factory_.GetWeakPtr()));
     return buf_len;
   }
 
   // Closes the FakeDataChannel. After Close() is called, Read() returns 0,
   // indicating EOF, and Write() fails with ERR_CONNECTION_RESET. Note that
   // after the FakeDataChannel is closed, the first Write() call completes
   // asynchronously, which is necessary to reproduce bug 127822.
   void Close() {
     closed_ = true;
+    data_.push(
+        new DrainableIOBuffer(new StringIOBuffer(std::string("0", 1)), 1));
+    if (!read_callback_.is_null()) {
+      base::MessageLoop::current()->PostTask(

[Ryan Sleevi, 2015/12/17 03:47:36]

BUG: Use base::ThreadTaskRunnerHandle() over base::MessageLoop::current()

Very little (virtually no) new code should be using base::MessageLoop::current()

[ryanchung, 2015/12/18 00:00:56]

Done.

+          FROM_HERE, base::Bind(&FakeDataChannel::DoReadCallback,
+                                weak_factory_.GetWeakPtr()));
+    }
   }
 
  private:
   void DoReadCallback() {
     if (read_callback_.is_null() || data_.empty())
       return;
-
     int copied = PropagateData(read_buf_, read_buf_len_);
     CompletionCallback callback = read_callback_;
     read_callback_.Reset();
     read_buf_ = NULL;
     read_buf_len_ = 0;
     callback.Run(copied);
   }
 
   void DoWriteCallback() {
     if (write_callback_.is_null())
@@ skipping 118 matching lines @@
   }
 
  private:
   BoundNetLog net_log_;
   FakeDataChannel* incoming_;
   FakeDataChannel* outgoing_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeSocket);
 };
 
+class TestSSLPrivateKey : public SSLPrivateKey {
+ public:
+  TestSSLPrivateKey(crypto::RSAPrivateKey* rsa_private_key)
+      : rsa_private_key_(rsa_private_key) {}
+
+  Type GetType() override { return SSLPrivateKey::Type::RSA; }
+
+  std::vector<SSLPrivateKey::Hash> GetDigestPreferences() override {
+    static const SSLPrivateKey::Hash kHashes[] = {SSLPrivateKey::Hash::SHA256,
+                                                  SSLPrivateKey::Hash::SHA1};
+    return std::vector<SSLPrivateKey::Hash>(kHashes,
+                                            kHashes + arraysize(kHashes));

[Ryan Sleevi, 2015/12/17 03:47:36]

Could do

return std::vector<SSLPrivateKey::Hash>(std::begin(kHashes), std::end(kHashes));

[ryanchung, 2015/12/18 00:00:56]

Done.

+  }
+
+  // NOTE: The following algorithm assumes the answer is a power of 2, which is
+  // true for the test keys in use.
+  size_t GetMaxSignatureLengthInBytes() override {
+#if defined(USE_OPENSSL)
+    return EVP_PKEY_size(rsa_private_key_->key());
+#else
+    NOTIMPLEMENTED();
+    return 0;
+#endif
+  }
+
+  void SignDigest(Hash hash,
+                  const base::StringPiece& input,
+                  const SignCallback& callback) override {
+    std::vector<uint8_t> signature;
+    crypto::SignatureCreator::HashAlgorithm hash_alg;
+    switch (hash) {
+      case Hash::SHA1:
+        hash_alg = crypto::SignatureCreator::SHA1;
+        break;
+
+      case Hash::SHA256:
+        hash_alg = crypto::SignatureCreator::SHA256;
+        break;
+
+      default:
+        FAIL() << "Unsupported hash function";
+    }
+    crypto::SignatureCreator::Sign(
+        rsa_private_key_.get(), hash_alg,
+        reinterpret_cast<const uint8_t*>(input.data()), input.size(),
+        &signature);
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(callback, OK, signature));
+  }
+
+ private:
+  ~TestSSLPrivateKey() override {}
+
+  scoped_ptr<crypto::RSAPrivateKey> rsa_private_key_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestSSLPrivateKey);
+};
+
 }  // namespace
 
 // Verify the correctness of the test helper classes first.
 TEST(FakeSocketTest, DataTransfer) {
   // Establish channels between two sockets.
   FakeDataChannel channel_1;
   FakeDataChannel channel_2;
   FakeSocket client(&channel_1, &channel_2);
   FakeSocket server(&channel_2, &channel_1);
 
@@ skipping 27 matching lines @@
   EXPECT_GT(read, 0);
   EXPECT_LE(read, written);
   EXPECT_EQ(0, memcmp(kTestData, read_buf->data(), read));
 }
 
 class SSLServerSocketTest : public PlatformTest {
  public:
   SSLServerSocketTest()
       : socket_factory_(ClientSocketFactory::GetDefaultFactory()),
         cert_verifier_(new MockCertVerifier()),
+        client_cert_verifier_(new MockClientCertVerifier()),
         transport_security_state_(new TransportSecurityState) {
-    cert_verifier_->set_default_result(CERT_STATUS_AUTHORITY_INVALID);
+    cert_verifier_->set_default_result(ERR_CERT_AUTHORITY_INVALID);
+    client_cert_verifier_->set_default_result(ERR_CERT_AUTHORITY_INVALID);
   }
 
  protected:
   void Initialize() {
     scoped_ptr<ClientSocketHandle> client_connection(new ClientSocketHandle);
     client_connection->SetSocket(
         scoped_ptr<StreamSocket>(new FakeSocket(&channel_1_, &channel_2_)));
     scoped_ptr<StreamSocket> server_socket(
         new FakeSocket(&channel_2_, &channel_1_));
 
-    base::FilePath certs_dir(GetTestCertsDirectory());
-
-    base::FilePath cert_path = certs_dir.AppendASCII("unittest.selfsigned.der");
-    std::string cert_der;
-    ASSERT_TRUE(base::ReadFileToString(cert_path, &cert_der));
-
-    scoped_refptr<X509Certificate> cert =
-        X509Certificate::CreateFromBytes(cert_der.data(), cert_der.size());
-
-    base::FilePath key_path = certs_dir.AppendASCII("unittest.key.bin");
-    std::string key_string;
-    ASSERT_TRUE(base::ReadFileToString(key_path, &key_string));
-    std::vector<uint8> key_vector(
-        reinterpret_cast<const uint8*>(key_string.data()),
-        reinterpret_cast<const uint8*>(key_string.data() +
-                                       key_string.length()));
-
-    scoped_ptr<crypto::RSAPrivateKey> private_key(
-        crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_vector));
+    std::string server_cert_der;
+    scoped_refptr<X509Certificate> server_cert(
+        ReadTestCert("unittest.selfsigned.der", &server_cert_der));
+    scoped_ptr<crypto::RSAPrivateKey> server_private_key(
+        ReadTestKey("unittest.key.bin"));
 
     client_ssl_config_.false_start_enabled = false;
     client_ssl_config_.channel_id_enabled = false;
 
     // Certificate provided by the host doesn't need authority.
     SSLConfig::CertAndStatus cert_and_status;
     cert_and_status.cert_status = CERT_STATUS_AUTHORITY_INVALID;
-    cert_and_status.der_cert = cert_der;
+    cert_and_status.der_cert = server_cert_der;
     client_ssl_config_.allowed_bad_certs.push_back(cert_and_status);
 
     HostPortPair host_and_pair("unittest", 0);
     SSLClientSocketContext context;
     context.cert_verifier = cert_verifier_.get();
     context.transport_security_state = transport_security_state_.get();
+    socket_factory_->ClearSSLSessionCache();
     client_socket_ = socket_factory_->CreateSSLClientSocket(
         client_connection.Pass(), host_and_pair, client_ssl_config_, context);
     server_socket_ =
-        CreateSSLServerSocket(server_socket.Pass(), cert.get(),
-                              private_key.get(), server_ssl_config_);
+        CreateSSLServerSocket(server_socket.Pass(), server_cert.get(),
+                              server_private_key.get(), server_ssl_config_);
+  }
+
+  void ConfigureClientCertsForClient(const char* cert_file_name,
+                                     const char* private_key_file_name) {
+    scoped_refptr<X509Certificate> cert;
+    scoped_refptr<net::SSLPrivateKey> key;
+    if (cert_file_name && private_key_file_name) {
+      cert = ImportCertFromFile(GetTestCertsDirectory(), cert_file_name);
+      key = new TestSSLPrivateKey(ReadTestKey(private_key_file_name));
+    }
+    client_ssl_config_.send_client_cert = true;
+    client_ssl_config_.client_cert = cert;
+    client_ssl_config_.client_private_key = key;
+  }
+
+  void ConfigureClientCertsForServer(bool cert_expected) {
+    if (!cert_expected)
+      return;
+
+    server_ssl_config_.require_client_cert = true;
+
+    scoped_refptr<X509Certificate> expected_client_ca_cert(
+        ImportCertFromFile(GetTestCertsDirectory(), kClientCertCAFileName));
+    CertificateList ca_list;
+    ca_list.push_back(expected_client_ca_cert);
+    server_ssl_config_.client_cert_ca_list = ca_list;
+    scoped_refptr<X509Certificate> expected_client_cert(
+        ImportCertFromFile(GetTestCertsDirectory(), kClientCertFileName));
+    client_cert_verifier_->AddResultForCert(expected_client_cert.get(), OK);
+
+    server_ssl_config_.client_cert_verifier = client_cert_verifier_.get();
+  }
+
+  X509Certificate* ReadTestCert(const base::StringPiece& name,
+                                std::string* cert_der) {
+    base::FilePath certs_dir(GetTestCertsDirectory());
+    base::FilePath cert_path = certs_dir.AppendASCII(name);
+    std::string unused;
+    if (!cert_der)
+      cert_der = &unused;
+    if (!base::ReadFileToString(cert_path, cert_der))
+      return NULL;
+    return X509Certificate::CreateFromBytes(cert_der->data(), cert_der->size());
+  }
+
+  crypto::RSAPrivateKey* ReadTestKey(const base::StringPiece& name) {
+    base::FilePath certs_dir(GetTestCertsDirectory());
+    base::FilePath key_path = certs_dir.AppendASCII(name);
+    std::string key_string;
+    if (!base::ReadFileToString(key_path, &key_string))
+      return NULL;
+    std::vector<uint8_t> key_vector(
+        reinterpret_cast<const uint8_t*>(key_string.data()),
+        reinterpret_cast<const uint8_t*>(key_string.data() +
+                                         key_string.length()));
+    return crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_vector);
   }
 
   FakeDataChannel channel_1_;
   FakeDataChannel channel_2_;
   SSLConfig client_ssl_config_;
   SSLServerConfig server_ssl_config_;
   scoped_ptr<SSLClientSocket> client_socket_;
   scoped_ptr<SSLServerSocket> server_socket_;
   ClientSocketFactory* socket_factory_;
   scoped_ptr<MockCertVerifier> cert_verifier_;
+  scoped_ptr<MockClientCertVerifier> client_cert_verifier_;
   scoped_ptr<TransportSecurityState> transport_security_state_;
+  CertificateList trusted_certs_;
 };
 
 // This test only executes creation of client and server sockets. This is to
 // test that creation of sockets doesn't crash and have minimal code to run
 // under valgrind in order to help debugging memory problems.
 TEST_F(SSLServerSocketTest, Initialize) {
   Initialize();
 }
 
 // This test executes Connect() on SSLClientSocket and Handshake() on
 // SSLServerSocket to make sure handshaking between the two sockets is
 // completed successfully.
 TEST_F(SSLServerSocketTest, Handshake) {
   Initialize();
 
   TestCompletionCallback connect_callback;
   TestCompletionCallback handshake_callback;
 
   int server_ret = server_socket_->Handshake(handshake_callback.callback());
   EXPECT_TRUE(server_ret == OK || server_ret == ERR_IO_PENDING);
 
   int client_ret = client_socket_->Connect(connect_callback.callback());
   EXPECT_TRUE(client_ret == OK || client_ret == ERR_IO_PENDING);
 
   if (client_ret == ERR_IO_PENDING) {
-    EXPECT_EQ(OK, connect_callback.WaitForResult());
+    EXPECT_EQ(OK, connect_callback.GetResult(client_ret));
   }
   if (server_ret == ERR_IO_PENDING) {
-    EXPECT_EQ(OK, handshake_callback.WaitForResult());
+    EXPECT_EQ(OK, handshake_callback.GetResult(server_ret));
   }
 
   // Make sure the cert status is expected.
   SSLInfo ssl_info;
   ASSERT_TRUE(client_socket_->GetSSLInfo(&ssl_info));
   EXPECT_EQ(CERT_STATUS_AUTHORITY_INVALID, ssl_info.cert_status);
 
   // The default cipher suite should be ECDHE and, unless on NSS and the
   // platform doesn't support it, an AEAD.
   uint16_t cipher_suite =
       SSLConnectionStatusToCipherSuite(ssl_info.connection_status);
   const char* key_exchange;
   const char* cipher;
   const char* mac;
   bool is_aead;
   SSLCipherSuiteToStrings(&key_exchange, &cipher, &mac, &is_aead, cipher_suite);
   EXPECT_STREQ("ECDHE_RSA", key_exchange);
   EXPECT_TRUE(is_aead);
 }
 
+// NSS ports don't support client certificates
+#if defined(USE_OPENSSL)
+
+// This test executes Connect() on SSLClientSocket and Handshake() on
+// SSLServerSocket to make sure handshaking between the two sockets is
+// completed successfully, using client certificate.
+TEST_F(SSLServerSocketTest, HandshakeWithClientCert) {
+  scoped_refptr<X509Certificate> client_cert =
+      ImportCertFromFile(GetTestCertsDirectory(), kClientCertFileName);
+  ConfigureClientCertsForClient(kClientCertFileName, kClientPrivateKeyFileName);
+  ConfigureClientCertsForServer(true);
+  Initialize();
+
+  TestCompletionCallback connect_callback;
+  TestCompletionCallback handshake_callback;

[Ryan Sleevi, 2015/12/17 03:47:36]

You should declare your variables where they're used.

TestCompletionCallback handshake_callback;
int server_ret = ..
ASSERT_TRUE(...);

TestCompletionCallback connect_callback;
int client_ret = ...;
ASSERT_TRUE(...);

[ryanchung, 2015/12/18 00:00:56]

Done.

+
+  int server_ret = server_socket_->Handshake(handshake_callback.callback());
+  EXPECT_TRUE(server_ret == OK || server_ret == ERR_IO_PENDING);

[Ryan Sleevi, 2015/12/17 03:47:36]

Should be ASSERT

[ryanchung, 2015/12/18 00:00:55]

Done.

+
+  int client_ret = client_socket_->Connect(connect_callback.callback());
+  EXPECT_TRUE(client_ret == OK || client_ret == ERR_IO_PENDING);

[Ryan Sleevi, 2015/12/17 03:47:36]

Should be ASSERT

[ryanchung, 2015/12/18 00:00:56]

Done.

+
+  if (client_ret == ERR_IO_PENDING) {
+    EXPECT_EQ(OK, connect_callback.GetResult(client_ret));
+  }
+  if (server_ret == ERR_IO_PENDING) {
+    EXPECT_EQ(OK, handshake_callback.GetResult(server_ret));
+  }

[Ryan Sleevi, 2015/12/17 03:47:36]

1) No braces throughout for client certs
2) Just do

client_ret = connect_callback.GetResult(client_ret);
server_ret = handshake_callback.GetResult(server_ret);

ASSERT_EQ(OK, client_ret);
ASSERT_EQ(OK, server_ret);

The changes to assert above are because you're violating the API contract on
line 568 if they failed.

[ryanchung, 2015/12/18 00:00:55]

Done.

+
+  // Make sure the cert status is expected.
+  SSLInfo ssl_info;
+  client_socket_->GetSSLInfo(&ssl_info);
+  EXPECT_EQ(CERT_STATUS_AUTHORITY_INVALID, ssl_info.cert_status);
+  server_socket_->GetSSLInfo(&ssl_info);
+  EXPECT_TRUE(ssl_info.cert.get());
+  EXPECT_TRUE(client_cert->Equals(ssl_info.cert.get()));
+}
+
+TEST_F(SSLServerSocketTest, HandshakeWithClientCertRequiredNotSupplied) {
+  ConfigureClientCertsForServer(true);
+  Initialize();
+  // We use the default setting for the client socket. This causes the client to
+  // get ERR_SSL_CLIENT_AUTH_CERT_NEEDED. This code path allows us to access the
+  // cert_authorities from the CertificateRequest.

[Ryan Sleevi, 2015/12/17 03:47:36]

Don't use pronouns in comments.
https://groups.google.com/a/chromium.org/forum/#!topic/chromium-dev/NH-S6KCkr2M

// Use the default setting for the client socket, which is to not send
// a client certificate. This will cause the client to receive an
// ERR_SSL_CLIENT_AUTH_CERT_NEEDED error, and allow for inspecting the
// requested cert_authorities from the CertificateRequest sent by the
// server.

[ryanchung, 2015/12/18 00:00:55]

Done.

+
+  TestCompletionCallback connect_callback;
+  TestCompletionCallback handshake_callback;

[Ryan Sleevi, 2015/12/17 03:47:36]

Same comments throughout the test.

[ryanchung, 2015/12/18 00:00:55]

Done.

+  int server_ret = server_socket_->Handshake(handshake_callback.callback());
+  EXPECT_EQ(server_ret, ERR_IO_PENDING);

[Ryan Sleevi, 2015/12/17 03:47:36]

ASSERT_EQ

[ryanchung, 2015/12/18 00:00:56]

Done.

+
+  EXPECT_EQ(ERR_SSL_CLIENT_AUTH_CERT_NEEDED,
+            connect_callback.GetResult(
+                client_socket_->Connect(connect_callback.callback())));
+
+  scoped_refptr<SSLCertRequestInfo> request_info = new SSLCertRequestInfo();
+  client_socket_->GetSSLCertRequestInfo(request_info.get());
+
+  // Check that the authority name that arrived in the CertificateRequest
+  // handshake message is as expected.
+  scoped_refptr<X509Certificate> client_cert =
+      ImportCertFromFile(GetTestCertsDirectory(), kClientCertFileName);
+  EXPECT_TRUE(client_cert->IsIssuedByEncoded(request_info->cert_authorities));
+
+  client_socket_->Disconnect();
+
+  if (server_ret == ERR_IO_PENDING) {

[Ryan Sleevi, 2015/12/17 03:47:36]

This conditional isn't necessary with the above ASSERT change; if you leave it
though

server_ret = handshake_callback.GetResult(server_ret);
EXPECT_EQ(ERR_FAILED, server_ret);

[ryanchung, 2015/12/18 00:00:56]

Done.

+    EXPECT_EQ(ERR_FAILED, handshake_callback.GetResult(server_ret));
+  }

[Ryan Sleevi, 2015/12/17 03:47:36]

No braces

[ryanchung, 2015/12/18 00:00:56]

Done.

+}
+
+TEST_F(SSLServerSocketTest, HandshakeWithWrongClientCertSupplied) {
+  scoped_refptr<X509Certificate> client_cert =
+      ImportCertFromFile(GetTestCertsDirectory(), kClientCertFileName);
+  ConfigureClientCertsForClient(kWrongClientCertFileName,
+                                kWrongClientPrivateKeyFileName);
+  ConfigureClientCertsForServer(true);
+  Initialize();
+
+  TestCompletionCallback connect_callback;
+  TestCompletionCallback handshake_callback;

[Ryan Sleevi, 2015/12/17 03:47:36]

Same comments about ordering.

[ryanchung, 2015/12/18 00:00:56]

Done.

+
+  int server_ret = server_socket_->Handshake(handshake_callback.callback());
+  EXPECT_EQ(server_ret, ERR_IO_PENDING);
+
+  int client_ret = client_socket_->Connect(connect_callback.callback());
+
+  EXPECT_EQ(ERR_BAD_SSL_CLIENT_AUTH_CERT,
+            connect_callback.GetResult(client_ret));
+  EXPECT_EQ(ERR_BAD_SSL_CLIENT_AUTH_CERT,
+            handshake_callback.GetResult(server_ret));
+}
+#endif  // defined(USE_OPENSSL)
+
 TEST_F(SSLServerSocketTest, DataTransfer) {
   Initialize();
 
   TestCompletionCallback connect_callback;
   TestCompletionCallback handshake_callback;
 
   // Establish connection.
   int client_ret = client_socket_->Connect(connect_callback.callback());
   ASSERT_TRUE(client_ret == OK || client_ret == ERR_IO_PENDING);
 
@@ skipping 197 matching lines @@
   int server_ret = server_socket_->Handshake(handshake_callback.callback());
 
   client_ret = connect_callback.GetResult(client_ret);
   server_ret = handshake_callback.GetResult(server_ret);
 
   ASSERT_EQ(ERR_SSL_VERSION_OR_CIPHER_MISMATCH, client_ret);
   ASSERT_EQ(ERR_SSL_VERSION_OR_CIPHER_MISMATCH, server_ret);
 }
 
 }  // namespace net