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.
 //
@@ skipping 23 matching lines @@
 #include "net/base/net_log.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/x509_certificate.h"
 #include "net/http/transport_security_state.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_config_service.h"
 #include "net/ssl/ssl_info.h"
 #include "net/test/cert_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 namespace net {
 
 namespace {
 
@@ skipping 10 matching lines @@
     DCHECK(read_callback_.is_null());
     DCHECK(!read_buf_.get());
     if (closed_)
       return 0;
     if (data_.empty()) {
       read_callback_ = callback;
       read_buf_ = buf;
       read_buf_len_ = buf_len;
       return ERR_IO_PENDING;
     }
-    return PropogateData(buf, buf_len);
+    return PropagateData(buf, buf_len);
   }
 
   int Write(IOBuffer* buf, int buf_len, const CompletionCallback& callback) {
     DCHECK(write_callback_.is_null());
     if (closed_) {
       if (write_called_after_close_)
         return ERR_CONNECTION_RESET;
       write_called_after_close_ = true;
       write_callback_ = callback;
       base::MessageLoop::current()->PostTask(
@@ skipping 10 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;
+    if (!read_callback_.is_null()) {
+      base::MessageLoop::current()->PostTask(
+          FROM_HERE, base::Bind(&FakeDataChannel::DoReadCallback,
+                                weak_factory_.GetWeakPtr()));
+    }
   }
 
  private:
   void DoReadCallback() {
-    if (read_callback_.is_null() || data_.empty())
+    if (read_callback_.is_null())
       return;
-
-    int copied = PropogateData(read_buf_, read_buf_len_);
+    int copied = PropagateData(read_buf_, read_buf_len_);
+    if (!copied && !closed_)
+      return;
     CompletionCallback callback = read_callback_;
     read_callback_.Reset();
     read_buf_ = NULL;
     read_buf_len_ = 0;
     callback.Run(copied);
   }
 
   void DoWriteCallback() {
     if (write_callback_.is_null())
       return;
 
     CompletionCallback callback = write_callback_;
     write_callback_.Reset();
     callback.Run(ERR_CONNECTION_RESET);
   }
 
-  int PropogateData(scoped_refptr<IOBuffer> read_buf, int read_buf_len) {
+  int PropagateData(scoped_refptr<IOBuffer> read_buf, int read_buf_len) {
+    if (data_.empty())
+      return 0;
     scoped_refptr<DrainableIOBuffer> buf = data_.front();
     int copied = std::min(buf->BytesRemaining(), read_buf_len);
     memcpy(read_buf->data(), buf->data(), copied);
     buf->DidConsume(copied);
 
     if (!buf->BytesRemaining())
       data_.pop();
     return copied;
   }
 
@@ skipping 131 matching lines @@
   EXPECT_LE(written, kTestDataSize);
 
   read = callback.WaitForResult();
   EXPECT_GT(read, 0);
   EXPECT_LE(read, written);
   EXPECT_EQ(0, memcmp(kTestData, read_buf->data(), read));
 }
 
 class SSLServerSocketTest : public PlatformTest {
  public:
+  enum ClientCertSupply {
+    kNoneSupplied = 0,
+    kCorrectCertSupplied = 1,
+    kWrongCertSupplied = 2
+  };
+
+  enum ClientCertExpect {
+    kNoneExpected = 0,
+    kCertAllowed = 1,
+    kCertRequired = 2
+  };
+
   SSLServerSocketTest()
       : socket_factory_(ClientSocketFactory::GetDefaultFactory()),
         cert_verifier_(new MockCertVerifier()),
+        client_cert_verifier_(new MockCertVerifier()),
         transport_security_state_(new TransportSecurityState) {
     cert_verifier_->set_default_result(CERT_STATUS_AUTHORITY_INVALID);
+    client_cert_verifier_->set_default_result(CERT_STATUS_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_));
 
+    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"));
+
+    SSLConfig ssl_client_config;
+    ssl_client_config.false_start_enabled = false;
+    ssl_client_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 = server_cert_der;
+    ssl_client_config.allowed_bad_certs.push_back(cert_and_status);
+
+    SSLConfig ssl_server_config;
+    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, ssl_client_config, context);
+
+    server_socket_ =
+        CreateSSLServerSocket(server_socket.Pass(), server_cert.get(),
+                              server_private_key.get(), ssl_server_config);
+  }
+
+  void InitializeClientCertsForClient(ClientCertSupply supply) {
+    scoped_refptr<X509Certificate> cert;
+    scoped_ptr<crypto::RSAPrivateKey> key;
+    if (supply != kNoneSupplied) {
+      const char* cert_file_name = supply == kCorrectCertSupplied
+                                       ? kClientCertFileName
+                                       : kWrongClientCertFileName;
+      const char* private_key_file_name = supply == kCorrectCertSupplied
+                                              ? kClientPrivateKeyFileName
+                                              : kWrongClientPrivateKeyFileName;
+      cert = ImportCertFromFile(GetTestCertsDirectory(), cert_file_name);
+      key.reset(ReadTestKey(private_key_file_name));
+    }
+    client_socket_->ForceClientCertificateAndKeyForTest(cert, key.Pass());
+  }
+
+  void InitializeClientCertsForServer(ClientCertExpect expect) {
+    if (expect == kNoneExpected)
+      return;
+
+    server_socket_->SetAllowClientCert(true);
+
+    if (expect == kCertRequired) {
+      scoped_refptr<X509Certificate> expected_client_ca_cert(
+          ImportCertFromFile(GetTestCertsDirectory(), kClientCertCAFileName));
+      CertificateList ca_list;
+      ca_list.push_back(expected_client_ca_cert);
+      server_socket_->SetClientCertCAList(ca_list);
+      scoped_refptr<X509Certificate> expected_client_cert(
+          ImportCertFromFile(GetTestCertsDirectory(), kClientCertFileName));
+      CertVerifyResult ignored;
+      ignored.verified_cert = expected_client_cert;
+      ignored.cert_status = 0;
+      client_cert_verifier_->AddResultForCert(expected_client_cert.get(),
+                                              ignored, OK);
+      server_socket_->SetClientCertVerifier(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 unneeded;
+    if (!cert_der) {
+      cert_der = &unneeded;
+    }

[Ryan Sleevi, 2015/03/19 04:38:25]

no braces

+    if (!base::ReadFileToString(cert_path, cert_der))
+      return NULL;
+    return X509Certificate::CreateFromBytes(cert_der->data(), cert_der->size());
+  }
 
-    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");
+  crypto::RSAPrivateKey* ReadTestKey(const base::StringPiece& name) {
+    base::FilePath certs_dir(GetTestCertsDirectory());
+    base::FilePath key_path = certs_dir.AppendASCII(name);
     std::string key_string;
-    ASSERT_TRUE(base::ReadFileToString(key_path, &key_string));
+    if (!base::ReadFileToString(key_path, &key_string))
+      return NULL;
     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));
-
-    SSLConfig ssl_config;
-    ssl_config.false_start_enabled = false;
-    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;
-    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();
-    client_socket_ =
-        socket_factory_->CreateSSLClientSocket(
-            client_connection.Pass(), host_and_pair, ssl_config, context);
-    server_socket_ = CreateSSLServerSocket(
-        server_socket.Pass(),
-        cert.get(), private_key.get(), SSLConfig());
+    return crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_vector);
   }
 
   FakeDataChannel channel_1_;
   FakeDataChannel channel_2_;
   scoped_ptr<SSLClientSocket> client_socket_;
   scoped_ptr<SSLServerSocket> server_socket_;
   ClientSocketFactory* socket_factory_;
   scoped_ptr<MockCertVerifier> cert_verifier_;
+  scoped_ptr<MockCertVerifier> client_cert_verifier_;
   scoped_ptr<TransportSecurityState> transport_security_state_;
+  CertificateList trusted_certs_;
+
+  const char* kClientCertFileName = "client_1.pem";

[Ryan Sleevi, 2015/03/19 04:38:25]

STYLE:

const char kClientCertFilename[] =


But really, move these out of the class and into the unnamed namespace.

+  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";
 };
 
 // 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
@@ skipping 17 matching lines @@
   if (server_ret == ERR_IO_PENDING) {
     EXPECT_EQ(OK, handshake_callback.WaitForResult());
   }
 
   // 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);
 }
 
+// TODO(dougsteed). The following tests using client certificates cannot
+// be performed if NSS with platform-based client auth is in use. That's because
+// the tests use SSLClientSocket to make requests against the server, and on
+// those builds, that class does not support supplying of a test key and cert.
+// An alternative approach that would broaden the applicability of these tests
+// would be to build and use the openssl flavor of SSLClientSocket, even
+// on NSS platforms.
+#if !defined(USE_NSS) || !defined(NSS_PLATFORM_CLIENT_AUTH)
+
+// 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);
+  Initialize();
+  InitializeClientCertsForServer(kCertAllowed);
+  InitializeClientCertsForClient(kCorrectCertSupplied);
+
+  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());
+  }
+  if (server_ret == ERR_IO_PENDING) {
+    EXPECT_EQ(OK, handshake_callback.WaitForResult());
+  }
+
+  // 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.client_cert_sent);
+  EXPECT_TRUE(ssl_info.client_cert_sent);
+  EXPECT_TRUE(ssl_info.cert.get());
+  EXPECT_TRUE(client_cert->Equals(ssl_info.cert.get()));
+}
+
+TEST_F(SSLServerSocketTest, HandshakeWithClientCertAllowedNotSupplied) {
+  scoped_refptr<X509Certificate> client_cert =
+      ImportCertFromFile(GetTestCertsDirectory(), kClientCertFileName);
+  Initialize();
+  InitializeClientCertsForServer(kCertAllowed);
+  InitializeClientCertsForClient(kNoneSupplied);
+
+  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());
+  }
+  if (server_ret == ERR_IO_PENDING) {
+    EXPECT_EQ(OK, handshake_callback.WaitForResult());
+  }
+}
+
+TEST_F(SSLServerSocketTest, HandshakeWithClientCertRequiredNotSupplied) {
+  Initialize();
+  InitializeClientCertsForServer(kCertRequired);
+  // We use the default setting for the client socket. This causes the client to
+  // get SSL_CLIENT_AUTH_CERT_NEEDED. This code path allows us to access the
+  // cert_authorities from the CertificateRequest.
+
+  TestCompletionCallback connect_callback;
+  TestCompletionCallback handshake_callback;
+
+  int server_ret = server_socket_->Handshake(handshake_callback.callback());
+  EXPECT_TRUE(server_ret == ERR_IO_PENDING);
+
+  int client_ret = client_socket_->Connect(connect_callback.callback());
+  EXPECT_TRUE(client_ret == ERR_SSL_CLIENT_AUTH_CERT_NEEDED ||
+              client_ret == ERR_IO_PENDING);
+
+  if (client_ret == ERR_IO_PENDING) {
+    EXPECT_EQ(ERR_SSL_CLIENT_AUTH_CERT_NEEDED,
+              connect_callback.WaitForResult());
+  }
+
+  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) {
+    server_ret = handshake_callback.WaitForResult();
+    EXPECT_TRUE(server_ret == ERR_CONNECTION_CLOSED ||
+                server_ret == ERR_FAILED);
+  }
+}
+
+TEST_F(SSLServerSocketTest, HandshakeWithWrongClientCertSupplied) {
+  scoped_refptr<X509Certificate> client_cert =
+      ImportCertFromFile(GetTestCertsDirectory(), kClientCertFileName);
+  Initialize();
+  InitializeClientCertsForServer(kCertRequired);
+  InitializeClientCertsForClient(kWrongCertSupplied);
+
+  TestCompletionCallback connect_callback;
+  TestCompletionCallback handshake_callback;
+
+  int server_ret = server_socket_->Handshake(handshake_callback.callback());
+  EXPECT_TRUE(server_ret == ERR_IO_PENDING);
+
+  int client_ret = client_socket_->Connect(connect_callback.callback());
+  EXPECT_TRUE(client_ret == ERR_BAD_SSL_CLIENT_AUTH_CERT ||
+              client_ret == ERR_IO_PENDING);
+
+  if (client_ret == ERR_IO_PENDING) {
+    EXPECT_EQ(ERR_BAD_SSL_CLIENT_AUTH_CERT, connect_callback.WaitForResult());
+  }
+
+  server_ret = handshake_callback.WaitForResult();
+  // We get a different result on NSS and OpenSSL. That's because an error
+  // mapping with OpenSSL makes an assumption that is true for SSLClientSocket
+  // but not SSLServerSocket (namely that peer cert rejection only occurs due to
+  // a cert change during renego).
+  EXPECT_TRUE(server_ret == ERR_BAD_SSL_CLIENT_AUTH_CERT ||
+              server_ret == ERR_SSL_SERVER_CERT_CHANGED);
+}
+#endif  //!defined(USE_NSS) || !defined(NSS_PLATFORM_CLIENT_AUTH)
+
 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 161 matching lines @@
   const char kKeyingLabelBad[] = "EXPERIMENTAL-server-socket-test-bad";
   unsigned char client_bad[kKeyingMaterialSize];
   rv = client_socket_->ExportKeyingMaterial(kKeyingLabelBad,
                                             false, kKeyingContext,
                                             client_bad, sizeof(client_bad));
   ASSERT_EQ(rv, OK);
   EXPECT_NE(0, memcmp(server_out, client_bad, sizeof(server_out)));
 }
 
 }  // namespace net