OpenSSL: Disable ECDSA cipher suites on Windows XP.

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 "base/callback_helpers.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
@@ skipping 14 matching lines @@
 #include "net/socket/tcp_client_socket.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/default_channel_id_store.h"
 #include "net/ssl/ssl_cert_request_info.h"
 #include "net/ssl/ssl_config_service.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
+#if defined(OS_WIN)
+#include "base/win/windows_version.h"
+#endif
+
 //-----------------------------------------------------------------------------
 
 namespace net {
 
 namespace {
 
 const SSLConfig kDefaultSSLConfig;
 
 // WrappedStreamSocket is a base class that wraps an existing StreamSocket,
 // forwarding the Socket and StreamSocket interfaces to the underlying
@@ skipping 514 matching lines @@
   }
 
   int read_count() const { return read_count_; }
   int write_count() const { return write_count_; }
 
  private:
   int read_count_;
   int write_count_;
 };
 
+// WriteCapturingSocket is a fake StreamSocket that captures all writes and
+// fails any reads. It is intended to capture the ClientHello.
+class WriteCapturingSocket : public StreamSocket {
+ public:
+  WriteCapturingSocket(net::NetLog* net_log)
+      : net_log_(BoundNetLog::Make(net_log, net::NetLog::SOURCE_SOCKET)) {}
+
+  const std::vector<uint8_t>& bytes_written() const { return bytes_written_; }
+
+  // StreamSocket implementation:
+  virtual int Connect(const CompletionCallback& callback) OVERRIDE {
+    return OK;
+  }
+  virtual void Disconnect() OVERRIDE { }
+  virtual bool IsConnected() const OVERRIDE {
+    return true;
+  }
+  virtual bool IsConnectedAndIdle() const OVERRIDE {
+    return true;
+  }
+  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE {
+    // NSS requires this method be functional.
+    IPAddressNumber number;
+    CHECK(ParseIPLiteralToNumber("127.0.0.1", &number));
+    *address = IPEndPoint(number, 443);
+    return OK;
+  }
+  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE {
+    NOTIMPLEMENTED();
+    return ERR_FAILED;
+  }
+  virtual const BoundNetLog& NetLog() const OVERRIDE {
+    return net_log_;
+  }
+  virtual void SetSubresourceSpeculation() OVERRIDE {
+    NOTIMPLEMENTED();
+  }
+  virtual void SetOmniboxSpeculation() OVERRIDE {
+    NOTIMPLEMENTED();
+  }
+  virtual bool WasEverUsed() const OVERRIDE {
+    NOTIMPLEMENTED();
+    return false;
+  }
+  virtual bool UsingTCPFastOpen() const OVERRIDE {
+    return false;
+  }
+  virtual bool WasNpnNegotiated() const OVERRIDE {
+    return false;
+  }
+  virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
+    return kProtoUnknown;
+  }
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE {
+    return false;
+  }
+
+  // Socket implementation:
+  virtual int Read(IOBuffer* buf,
+                   int buf_len,
+                   const CompletionCallback& callback) OVERRIDE {
+    // Fail the read to stop the handshake at ClientHello.
+    return ERR_FAILED;
+  }
+  virtual int Write(IOBuffer* buf,
+                    int buf_len,
+                    const CompletionCallback& callback) OVERRIDE {
+    for (int i = 0; i < buf_len; i++) {
+      bytes_written_.push_back(buf->data()[i]);
+    }
+    return buf_len;
+  }
+  virtual int SetReceiveBufferSize(int32 size) OVERRIDE {
+    return 0;
+  }
+  virtual int SetSendBufferSize(int32 size) OVERRIDE {
+    return 0;
+  }
+
+ private:
+  BoundNetLog net_log_;
+  std::vector<uint8_t> bytes_written_;
+};
+
 // CompletionCallback that will delete the associated StreamSocket when
 // the callback is invoked.
 class DeleteSocketCallback : public TestCompletionCallbackBase {
  public:
   explicit DeleteSocketCallback(StreamSocket* socket)
       : socket_(socket),
         callback_(base::Bind(&DeleteSocketCallback::OnComplete,
                              base::Unretained(this))) {}
   virtual ~DeleteSocketCallback() {}
 
@@ skipping 2098 matching lines @@
   EXPECT_TRUE(sock->WasEverUsed());
 
   // TODO(davidben): Read one byte to ensure the test server has responded and
   // then assert IsConnectedAndIdle is false. This currently doesn't work
   // because neither SSLClientSocketNSS nor SSLClientSocketOpenSSL check their
   // SSL implementation's internal buffers. Either call PR_Available and
   // SSL_pending, although the former isn't actually implemented or perhaps
   // attempt to read one byte extra.
 }
 
+#if defined(OS_WIN)
+
+bool IsECDSACipherSuite(uint16_t cipher_suite) {
+  // RFC 4492.
+  if (0xc001 <= cipher_suite && cipher_suite <= 0xc00a)
+    return true;
+  // RFC 5289.
+  if (0xc023 <= cipher_suite && cipher_suite <= 0xc026)
+    return true;
+  if (0xc02b <= cipher_suite && cipher_suite <= 0xc02e)
+    return true;
+  return false;

[Ryan Sleevi, 2014/09/02 23:45:01]

SSLCipherSuiteToStrings(&key_exchange, ..., cipher_suite);
return std::string(key_exchange).find("ECDSA") != std::string::npos;

[davidben, 2014/09/03 17:10:41]

Done.

+}
+
+// Test that ECDSA is disabled on Windows XP, where ECDSA certificates cannot be
+// verified.
+TEST_F(SSLClientSocketTest, DisableECDSAOnXP) {
+  if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
+    LOG(INFO) << "Skipping test on this version.";
+    return;
+  }
+
+  scoped_ptr<WriteCapturingSocket> transport(new WriteCapturingSocket(&log_));
+  WriteCapturingSocket* raw_transport = transport.get();
+
+  // Handshake up to trying to read the ServerHello.
+  scoped_ptr<SSLClientSocket> sock(CreateSSLClientSocket(
+      transport.PassAs<StreamSocket>(),
+      HostPortPair("example.com", 443), kDefaultSSLConfig));
+  TestCompletionCallback callback;
+  EXPECT_EQ(ERR_FAILED, callback.GetResult(sock->Connect(callback.callback())));
+  base::RunLoop().RunUntilIdle();
+
+  // Parse out the cipher list. This will require that the ClientHello is not
+  // fragmented before the cipher list because that would be an exceedingly long
+  // cipher list.
+  std::vector<uint8_t> client_hello = raw_transport->bytes_written();
+
+  // TLSPlaintext header:
+  ASSERT_GE(client_hello.size(), 5u);
+  EXPECT_EQ(22, client_hello[0]);  // type
+  // Next two bytes are the version.
+  uint16_t record_length = (client_hello[3] << 8) | client_hello[4];
+  // Grab the record body.
+  ASSERT_GE(client_hello.size(), 5u + record_length);
+  std::vector<uint8_t> record_body(client_hello.begin() + 5,
+                                   client_hello.begin() + 5 + record_length);
+
+  // Handshake header:
+  ASSERT_GE(record_body.size(), 4u);
+  EXPECT_EQ(1, record_body[0]);  // msg_type
+  uint32_t length =
+      (record_body[1] << 16) | (record_body[2] << 8) | record_body[3];
+  std::vector<uint8_t> message(record_body.begin() + 4, record_body.end());
+  // There cannot be a handshake message after ClientHello, though the
+  // ClientHello could conceivably be fragmented across two records.
+  ASSERT_LE(message.size(), length);
+
+  // ClientHello:
+
+  // Skip past the client_version and random.
+  ASSERT_GE(message.size(), 2u + 32u);
+  message.erase(message.begin(), message.begin() + 2 + 32);
+
+  // Skip past the session id.
+  ASSERT_GE(message.size(), 1u);
+  uint8_t session_id_length = message[0];
+  ASSERT_GE(message.size(), 1u + session_id_length);
+  message.erase(message.begin(), message.begin() + 1 + session_id_length);
+
+  // Get the cipher suite list.
+  ASSERT_GE(message.size(), 2u);
+  uint16_t cipher_suites_length = (message[0] << 8) | message[1];
+  EXPECT_EQ(0, cipher_suites_length % 2);
+  ASSERT_GE(message.size(), 2u + cipher_suites_length);
+  std::vector<uint8_t> cipher_suites(
+      message.begin() + 2, message.begin() + 2 + cipher_suites_length);
+
+  // Finally, ensure there are no ECDSA cipher suites in there.
+  for (size_t i = 0; i+1 < cipher_suites.size(); i+=2) {
+    uint16_t cipher_suite = (cipher_suites[i] << 8) | cipher_suites[i+1];
+    EXPECT_FALSE(IsECDSACipherSuite(cipher_suite))
+        << "ClientHello advertised " << std::hex << cipher_suite;
+  }
+}
+
+#endif  // OS_WIN
+
 #if defined(USE_OPENSSL)
 
 TEST_F(SSLClientSocketTest, HandshakeCallbackIsRun_WithFailure) {
   SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTPS,
                                 SpawnedTestServer::kLocalhost,
                                 base::FilePath());
   ASSERT_TRUE(test_server.Start());
 
   AddressList addr;
   ASSERT_TRUE(test_server.GetAddressList(&addr));
@@ skipping 293 matching lines @@
   ssl_config.channel_id_enabled = true;
 
   int rv;
   ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
 
   EXPECT_EQ(ERR_UNEXPECTED, rv);
   EXPECT_FALSE(sock_->IsConnected());
 }
 
 }  // namespace net