Provide RSA2048 as per RFC

webrtc/base/sslstreamadapter_unittest.cc

 /*
  *  Copyright 2011 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.
  */
 
@@ skipping 143 matching lines @@
   rtc::FifoBuffer *in_;
   rtc::FifoBuffer *out_;
   bool first_packet_;
 };
 
 static const int kFifoBufferSize = 4096;
 
 class SSLStreamAdapterTestBase : public testing::Test,
                                  public sigslot::has_slots<> {
  public:
-  SSLStreamAdapterTestBase(const std::string& client_cert_pem,
-                           const std::string& client_private_key_pem,
-                           bool dtls,
-                           rtc::KeyType client_key_type = rtc::KT_DEFAULT,
-                           rtc::KeyType server_key_type = rtc::KT_DEFAULT)
+  SSLStreamAdapterTestBase(
+      const std::string& client_cert_pem,
+      const std::string& client_private_key_pem,
+      bool dtls,
+      rtc::KeyParams client_key_type = rtc::KeyParams(rtc::KT_DEFAULT),
+      rtc::KeyParams server_key_type = rtc::KeyParams(rtc::KT_DEFAULT))
       : client_buffer_(kFifoBufferSize),
         server_buffer_(kFifoBufferSize),
         client_stream_(
             new SSLDummyStream(this, "c2s", &client_buffer_, &server_buffer_)),
         server_stream_(
             new SSLDummyStream(this, "s2c", &server_buffer_, &client_buffer_)),
         client_ssl_(rtc::SSLStreamAdapter::Create(client_stream_)),
         server_ssl_(rtc::SSLStreamAdapter::Create(server_stream_)),
         client_identity_(NULL),
         server_identity_(NULL),
@@ skipping 37 matching lines @@
         new SSLDummyStream(this, "c2s", &client_buffer_, &server_buffer_);
     server_stream_ =
         new SSLDummyStream(this, "s2c", &server_buffer_, &client_buffer_);
 
     client_ssl_.reset(rtc::SSLStreamAdapter::Create(client_stream_));
     server_ssl_.reset(rtc::SSLStreamAdapter::Create(server_stream_));
 
     client_ssl_->SignalEvent.connect(this, &SSLStreamAdapterTestBase::OnEvent);
     server_ssl_->SignalEvent.connect(this, &SSLStreamAdapterTestBase::OnEvent);
 
-    rtc::SSLIdentityParams client_params;
+    rtc::SSLIdentityParams client_params((rtc::KeyParams(rtc::KT_DEFAULT)));

[juberti, 2015/10/07 06:35:23]

Remove extra parens, here and below

[torbjorng (webrtc), 2015/10/07 13:30:04]

The extra parens are required; these variable declarations
look too much as function declarations to the compiler.

     client_params.common_name = "client";
     client_params.not_before = not_before;
     client_params.not_after = not_after;
-    client_params.key_type = rtc::KT_DEFAULT;
     client_identity_ = rtc::SSLIdentity::GenerateForTest(client_params);
 
-    rtc::SSLIdentityParams server_params;
+    rtc::SSLIdentityParams server_params((rtc::KeyParams(rtc::KT_DEFAULT)));
     server_params.common_name = "server";
     server_params.not_before = not_before;
     server_params.not_after = not_after;
-    server_params.key_type = rtc::KT_DEFAULT;
     server_identity_ = rtc::SSLIdentity::GenerateForTest(server_params);
 
     client_ssl_->SetIdentity(client_identity_);
     server_ssl_->SetIdentity(server_identity_);
   }
 
   virtual void OnEvent(rtc::StreamInterface *stream, int sig, int err) {
     LOG(LS_INFO) << "SSLStreamAdapterTestBase::OnEvent sig=" << sig;
 
     if (sig & rtc::SE_READ) {
@@ skipping 207 matching lines @@
   int loss_;
   bool lose_first_packet_;
   bool damage_;
   bool dtls_;
   int handshake_wait_;
   bool identities_set_;
 };
 
 class SSLStreamAdapterTestTLS
     : public SSLStreamAdapterTestBase,
-      public WithParamInterface<tuple<rtc::KeyType, rtc::KeyType>> {
+      public WithParamInterface<tuple<rtc::KeyParams, rtc::KeyParams>> {
  public:
   SSLStreamAdapterTestTLS()
       : SSLStreamAdapterTestBase("",
                                  "",
                                  false,
                                  ::testing::get<0>(GetParam()),
                                  ::testing::get<1>(GetParam())){};
 
   // Test data transfer for TLS
   virtual void TestTransfer(int size) {
@@ skipping 87 matching lines @@
     }
   }
 
  private:
   rtc::MemoryStream send_stream_;
   rtc::MemoryStream recv_stream_;
 };
 
 class SSLStreamAdapterTestDTLS
     : public SSLStreamAdapterTestBase,
-      public WithParamInterface<tuple<rtc::KeyType, rtc::KeyType>> {
+      public WithParamInterface<tuple<rtc::KeyParams, rtc::KeyParams>> {
  public:
   SSLStreamAdapterTestDTLS()
       : SSLStreamAdapterTestBase("",
                                  "",
                                  true,
                                  ::testing::get<0>(GetParam()),
                                  ::testing::get<1>(GetParam())),
         packet_size_(1000),
         count_(0),
         sent_(0) {}
@@ skipping 387 matching lines @@
   MAYBE_SKIP_TEST(HaveDtls);
   SetupProtocolVersions(rtc::SSL_PROTOCOL_DTLS_10, rtc::SSL_PROTOCOL_DTLS_10);
   TestHandshake();
 
   uint16_t client_cipher;
   ASSERT_TRUE(GetSslCipherSuite(true, &client_cipher));
   uint16_t server_cipher;
   ASSERT_TRUE(GetSslCipherSuite(false, &server_cipher));
 
   ASSERT_EQ(client_cipher, server_cipher);
-  ASSERT_EQ(rtc::SSLStreamAdapter::GetDefaultSslCipherForTest(
-                rtc::SSL_PROTOCOL_DTLS_10, ::testing::get<1>(GetParam())),
-            server_cipher);
+  ASSERT_EQ(
+      rtc::SSLStreamAdapter::GetDefaultSslCipherForTest(
+          rtc::SSL_PROTOCOL_DTLS_10, ::testing::get<1>(GetParam()).type()),
+      server_cipher);
 }
 
 // Test getting the used DTLS 1.2 ciphers.
 // DTLS 1.2 enabled for client and server -> DTLS 1.2 will be used.
 TEST_P(SSLStreamAdapterTestDTLS, TestGetSslCipherSuiteDtls12Both) {
   MAYBE_SKIP_TEST(HaveDtls);
   SetupProtocolVersions(rtc::SSL_PROTOCOL_DTLS_12, rtc::SSL_PROTOCOL_DTLS_12);
   TestHandshake();
 
   uint16_t client_cipher;
   ASSERT_TRUE(GetSslCipherSuite(true, &client_cipher));
   uint16_t server_cipher;
   ASSERT_TRUE(GetSslCipherSuite(false, &server_cipher));
 
   ASSERT_EQ(client_cipher, server_cipher);
-  ASSERT_EQ(rtc::SSLStreamAdapter::GetDefaultSslCipherForTest(
-                rtc::SSL_PROTOCOL_DTLS_12, ::testing::get<1>(GetParam())),
-            server_cipher);
+  ASSERT_EQ(
+      rtc::SSLStreamAdapter::GetDefaultSslCipherForTest(
+          rtc::SSL_PROTOCOL_DTLS_12, ::testing::get<1>(GetParam()).type()),
+      server_cipher);
 }
 
 // DTLS 1.2 enabled for client only -> DTLS 1.0 will be used.
 TEST_P(SSLStreamAdapterTestDTLS, TestGetSslCipherSuiteDtls12Client) {
   MAYBE_SKIP_TEST(HaveDtls);
   SetupProtocolVersions(rtc::SSL_PROTOCOL_DTLS_10, rtc::SSL_PROTOCOL_DTLS_12);
   TestHandshake();
 
   uint16_t client_cipher;
   ASSERT_TRUE(GetSslCipherSuite(true, &client_cipher));
   uint16_t server_cipher;
   ASSERT_TRUE(GetSslCipherSuite(false, &server_cipher));
 
   ASSERT_EQ(client_cipher, server_cipher);
-  ASSERT_EQ(rtc::SSLStreamAdapter::GetDefaultSslCipherForTest(
-                rtc::SSL_PROTOCOL_DTLS_10, ::testing::get<1>(GetParam())),
-            server_cipher);
+  ASSERT_EQ(
+      rtc::SSLStreamAdapter::GetDefaultSslCipherForTest(
+          rtc::SSL_PROTOCOL_DTLS_10, ::testing::get<1>(GetParam()).type()),
+      server_cipher);
 }
 
 // DTLS 1.2 enabled for server only -> DTLS 1.0 will be used.
 TEST_P(SSLStreamAdapterTestDTLS, TestGetSslCipherSuiteDtls12Server) {
   MAYBE_SKIP_TEST(HaveDtls);
   SetupProtocolVersions(rtc::SSL_PROTOCOL_DTLS_12, rtc::SSL_PROTOCOL_DTLS_10);
   TestHandshake();
 
   uint16_t client_cipher;
   ASSERT_TRUE(GetSslCipherSuite(true, &client_cipher));
   uint16_t server_cipher;
   ASSERT_TRUE(GetSslCipherSuite(false, &server_cipher));
 
   ASSERT_EQ(client_cipher, server_cipher);
-  ASSERT_EQ(rtc::SSLStreamAdapter::GetDefaultSslCipherForTest(
-                rtc::SSL_PROTOCOL_DTLS_10, ::testing::get<1>(GetParam())),
-            server_cipher);
+  ASSERT_EQ(
+      rtc::SSLStreamAdapter::GetDefaultSslCipherForTest(
+          rtc::SSL_PROTOCOL_DTLS_10, ::testing::get<1>(GetParam()).type()),
+      server_cipher);
 }
 
-INSTANTIATE_TEST_CASE_P(SSLStreamAdapterTestsTLS,
-                        SSLStreamAdapterTestTLS,
-                        Combine(Values(rtc::KT_RSA, rtc::KT_ECDSA),
-                                Values(rtc::KT_RSA, rtc::KT_ECDSA)));
-INSTANTIATE_TEST_CASE_P(SSLStreamAdapterTestsDTLS,
-                        SSLStreamAdapterTestDTLS,
-                        Combine(Values(rtc::KT_RSA, rtc::KT_ECDSA),
-                                Values(rtc::KT_RSA, rtc::KT_ECDSA)));
+// The RSA keysizes here might look strange, why not include the RFC's size
+// 2048?. The reason is test case slowness; testing two sizes to exercise
+// parametrization is sufficient.
+INSTANTIATE_TEST_CASE_P(
+    SSLStreamAdapterTestsTLS,
+    SSLStreamAdapterTestTLS,
+    Combine(Values(rtc::KeyParams::RSA(1024, 65537),
+                   rtc::KeyParams::RSA(1152, 65537),
+                   rtc::KeyParams::ECDSA(rtc::EC_NIST_P256)),
+            Values(rtc::KeyParams::RSA(1024, 65537),
+                   rtc::KeyParams::RSA(1152, 65537),
+                   rtc::KeyParams::ECDSA(rtc::EC_NIST_P256))));
+INSTANTIATE_TEST_CASE_P(
+    SSLStreamAdapterTestsDTLS,
+    SSLStreamAdapterTestDTLS,
+    Combine(Values(rtc::KeyParams::RSA(1024, 65537),
+                   rtc::KeyParams::RSA(1152, 65537),
+                   rtc::KeyParams::ECDSA(rtc::EC_NIST_P256)),
+            Values(rtc::KeyParams::RSA(1024, 65537),
+                   rtc::KeyParams::RSA(1152, 65537),
+                   rtc::KeyParams::ECDSA(rtc::EC_NIST_P256))));