Support generation of EC keys using P256 curve and support ECDSA certs.

webrtc/base/ssladapter_unittest.cc

 /*
  *  Copyright 2014 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <string>
 
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/ipaddress.h"
 #include "webrtc/base/socketstream.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/sslstreamadapter.h"
+#include "webrtc/base/sslidentity.h"
 #include "webrtc/base/stream.h"
 #include "webrtc/base/virtualsocketserver.h"
 
 static const int kTimeout = 5000;
 
 static rtc::AsyncSocket* CreateSocket(const rtc::SSLMode& ssl_mode) {
   rtc::SocketAddress address(rtc::IPAddress(INADDR_ANY), 0);
 
   rtc::AsyncSocket* socket = rtc::Thread::Current()->
       socketserver()->CreateAsyncSocket(
@@ skipping 94 matching lines @@
  private:
   const rtc::SSLMode ssl_mode_;
 
   rtc::scoped_ptr<rtc::SSLAdapter> ssl_adapter_;
 
   std::string data_;
 };
 
 class SSLAdapterTestDummyServer : public sigslot::has_slots<> {
  public:
-  explicit SSLAdapterTestDummyServer(const rtc::SSLMode& ssl_mode)
+  explicit SSLAdapterTestDummyServer(const rtc::SSLMode& ssl_mode,
+                                     const rtc::KeyType key_type)
       : ssl_mode_(ssl_mode) {
     // Generate a key pair and a certificate for this host.
-    ssl_identity_.reset(rtc::SSLIdentity::Generate(GetHostname()));
+    ssl_identity_.reset(rtc::SSLIdentity::Generate(GetHostname(), key_type));
 
     server_socket_.reset(CreateSocket(ssl_mode_));
 
     if (ssl_mode_ == rtc::SSL_MODE_TLS) {
       server_socket_->SignalReadEvent.connect(this,
           &SSLAdapterTestDummyServer::OnServerSocketReadEvent);
 
       server_socket_->Listen(1);
     }
 
@@ skipping 115 matching lines @@
   rtc::scoped_ptr<rtc::SSLStreamAdapter> ssl_stream_adapter_;
 
   rtc::scoped_ptr<rtc::SSLIdentity> ssl_identity_;
 
   std::string data_;
 };
 
 class SSLAdapterTestBase : public testing::Test,
                            public sigslot::has_slots<> {
  public:
-  explicit SSLAdapterTestBase(const rtc::SSLMode& ssl_mode)
+  explicit SSLAdapterTestBase(const rtc::SSLMode& ssl_mode,
+                              const rtc::KeyType key_type)
       : ssl_mode_(ssl_mode),
         ss_scope_(new rtc::VirtualSocketServer(NULL)),
-        server_(new SSLAdapterTestDummyServer(ssl_mode_)),
+        server_(new SSLAdapterTestDummyServer(ssl_mode_, key_type)),
         client_(new SSLAdapterTestDummyClient(ssl_mode_)),
-        handshake_wait_(kTimeout) {
-  }
+        handshake_wait_(kTimeout) {}
 
   void SetHandshakeWait(int wait) {
     handshake_wait_ = wait;
   }
 
   void TestHandshake(bool expect_success) {
     int rv;
 
     // The initial state is CS_CLOSED
     ASSERT_EQ(rtc::AsyncSocket::CS_CLOSED, client_->GetState());
@@ skipping 48 matching lines @@
   const rtc::SSLMode ssl_mode_;
 
   const rtc::SocketServerScope ss_scope_;
 
   rtc::scoped_ptr<SSLAdapterTestDummyServer> server_;
   rtc::scoped_ptr<SSLAdapterTestDummyClient> client_;
 
   int handshake_wait_;
 };
 
-class SSLAdapterTestTLS : public SSLAdapterTestBase {
+class SSLAdapterTestTLS_RSA : public SSLAdapterTestBase {
  public:
-  SSLAdapterTestTLS() : SSLAdapterTestBase(rtc::SSL_MODE_TLS) {}
+  SSLAdapterTestTLS_RSA()
+      : SSLAdapterTestBase(rtc::SSL_MODE_TLS, rtc::KT_RSA) {}
 };
 
-class SSLAdapterTestDTLS : public SSLAdapterTestBase {
+class SSLAdapterTestTLS_ECDSA : public SSLAdapterTestBase {
  public:
-  SSLAdapterTestDTLS() : SSLAdapterTestBase(rtc::SSL_MODE_DTLS) {}
+  SSLAdapterTestTLS_ECDSA()
+      : SSLAdapterTestBase(rtc::SSL_MODE_TLS, rtc::KT_ECDSA) {}
+};
+
+class SSLAdapterTestDTLS_RSA : public SSLAdapterTestBase {
+ public:
+  SSLAdapterTestDTLS_RSA()
+      : SSLAdapterTestBase(rtc::SSL_MODE_DTLS, rtc::KT_RSA) {}
+};
+
+class SSLAdapterTestDTLS_ECDSA : public SSLAdapterTestBase {
+ public:
+  SSLAdapterTestDTLS_ECDSA()
+      : SSLAdapterTestBase(rtc::SSL_MODE_DTLS, rtc::KT_ECDSA) {}
 };
 
 #if SSL_USE_OPENSSL
 
 // Basic tests: TLS
 
-// Test that handshake works
-TEST_F(SSLAdapterTestTLS, TestTLSConnect) {
+// Test that handshake works, using RSA
+TEST_F(SSLAdapterTestTLS_RSA, TestTLSConnect) {
   TestHandshake(true);
 }
 
-// Test transfer between client and server
-TEST_F(SSLAdapterTestTLS, TestTLSTransfer) {
+// Test that handshake works, using ECDSA
+TEST_F(SSLAdapterTestTLS_ECDSA, TestTLSConnect) {
+  TestHandshake(true);
+}
+
+// Test transfer between client and server, using RSA
+TEST_F(SSLAdapterTestTLS_RSA, TestTLSTransfer) {
+  TestHandshake(true);
+  TestTransfer("Hello, world!");
+}
+
+// Test transfer between client and server, using ECDSA
+TEST_F(SSLAdapterTestTLS_ECDSA, TestTLSTransfer) {
   TestHandshake(true);
   TestTransfer("Hello, world!");
 }
 
 // Basic tests: DTLS
 
-// Test that handshake works
-TEST_F(SSLAdapterTestDTLS, TestDTLSConnect) {
+// Test that handshake works, using RSA
+TEST_F(SSLAdapterTestDTLS_RSA, TestDTLSConnect) {
   TestHandshake(true);
 }
 
-// Test transfer between client and server
-TEST_F(SSLAdapterTestDTLS, TestDTLSTransfer) {
+// Test that handshake works, using ECDSA
+TEST_F(SSLAdapterTestDTLS_ECDSA, TestDTLSConnect) {
+  TestHandshake(true);
+}
+
+// Test transfer between client and server, using RSA
+TEST_F(SSLAdapterTestDTLS_RSA, TestDTLSTransfer) {
+  TestHandshake(true);
+  TestTransfer("Hello, world!");
+}
+
+// Test transfer between client and server, using ECDSA
+TEST_F(SSLAdapterTestDTLS_ECDSA, TestDTLSTransfer) {
   TestHandshake(true);
   TestTransfer("Hello, world!");
 }
 
 #endif  // SSL_USE_OPENSSL
-