Provide RSA2048 as per RFC

webrtc/base/opensslidentity.cc

 /*
  *  Copyright 2004 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 15 matching lines @@
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/openssl.h"
 #include "webrtc/base/openssldigest.h"
 
 namespace rtc {
 
 // We could have exposed a myriad of parameters for the crypto stuff,
 // but keeping it simple seems best.
 
-// Strength of generated keys. Those are RSA.
-static const int KEY_LENGTH = 1024;
-
 // Random bits for certificate serial number
 static const int SERIAL_RAND_BITS = 64;
 
 // Certificate validity lifetime
 static const int CERTIFICATE_LIFETIME = 60*60*24*30;  // 30 days, arbitrarily
 // Certificate validity window.
 // This is to compensate for slightly incorrect system clocks.
 static const int CERTIFICATE_WINDOW = -60*60*24;
 
 // Generate a key pair. Caller is responsible for freeing the returned object.
-static EVP_PKEY* MakeKey(KeyType key_type) {
+static EVP_PKEY* MakeKey(KeyTypeFull key_type) {

[hbos, 2015/09/29 13:53:18]

DCHECK that the parameters are in valid ranges etc.
Or perhaps return NULL and LOG(LS_ERROR) is more appropriate given that this is
what is done if the key type is not understood?

See my other comment about validating parameters @ KeyTypeFull.

[hbos, 2015/10/01 14:42:43]

Did you forget to address this or are you letting OpenSSL decide the validity
separately from our own IsValid()?

[torbjorng (webrtc), 2015/10/05 12:03:05]

I let boringssl decide at this abstraction level. The isValid method of
KeyParams) is an indication of what our code implements at a given time. It is a
good indication of what will work for Generate(), but it is possible that
boringssl at some point decides that e.g., 1024-bit keys in RSA are too weak to
be supported (IIRC they recently stopped allowing <= 1023 bit keys).

Calling isValid should be done at a higher level, if at all.

   LOG(LS_INFO) << "Making key pair";
   EVP_PKEY* pkey = EVP_PKEY_new();
-  if (key_type == KT_RSA) {
+  if (key_type.type() == KT_RSA) {
+    int key_length = key_type.rsa_params().mod_size;
     BIGNUM* exponent = BN_new();
     RSA* rsa = RSA_new();
     if (!pkey || !exponent || !rsa ||
-        !BN_set_word(exponent, 0x10001) ||  // 65537 RSA exponent
-        !RSA_generate_key_ex(rsa, KEY_LENGTH, exponent, NULL) ||
+        !BN_set_word(exponent, key_type.rsa_params().pub_exp) ||
+        !RSA_generate_key_ex(rsa, key_length, exponent, NULL) ||
         !EVP_PKEY_assign_RSA(pkey, rsa)) {
       EVP_PKEY_free(pkey);
       BN_free(exponent);
       RSA_free(rsa);
       LOG(LS_ERROR) << "Failed to make RSA key pair";
       return NULL;
     }
     // ownership of rsa struct was assigned, don't free it.
     BN_free(exponent);
-  } else if (key_type == KT_ECDSA) {
+  } else if (key_type.type() == KT_ECDSA &&
+             key_type.ec_params() == EC_NIST_P256) {
     EC_KEY* ec_key = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
     if (!pkey || !ec_key || !EC_KEY_generate_key(ec_key) ||
         !EVP_PKEY_assign_EC_KEY(pkey, ec_key)) {
       EVP_PKEY_free(pkey);
       EC_KEY_free(ec_key);
       LOG(LS_ERROR) << "Failed to make EC key pair";
       return NULL;
     }
     // ownership of ec_key struct was assigned, don't free it.
   } else {
@@ skipping 70 matching lines @@
 static void LogSSLErrors(const std::string& prefix) {
   char error_buf[200];
   unsigned long err;
 
   while ((err = ERR_get_error()) != 0) {
     ERR_error_string_n(err, error_buf, sizeof(error_buf));
     LOG(LS_ERROR) << prefix << ": " << error_buf << "\n";
   }
 }
 
-OpenSSLKeyPair* OpenSSLKeyPair::Generate(KeyType key_type) {
+OpenSSLKeyPair* OpenSSLKeyPair::Generate(KeyTypeFull key_type) {
   EVP_PKEY* pkey = MakeKey(key_type);
   if (!pkey) {
     LogSSLErrors("Generating key pair");
     return NULL;
   }
   return new OpenSSLKeyPair(pkey);
 }
 
 OpenSSLKeyPair::~OpenSSLKeyPair() {
   EVP_PKEY_free(pkey_);
@@ skipping 216 matching lines @@
         OpenSSLCertificate::Generate(key_pair, params);
     if (certificate)
       return new OpenSSLIdentity(key_pair, certificate);
     delete key_pair;
   }
   LOG(LS_INFO) << "Identity generation failed";
   return NULL;
 }
 
 OpenSSLIdentity* OpenSSLIdentity::Generate(const std::string& common_name,
-                                           KeyType key_type) {
+                                           KeyTypeFull key_type) {
   SSLIdentityParams params;
   params.common_name = common_name;
   params.not_before = CERTIFICATE_WINDOW;
   params.not_after = CERTIFICATE_LIFETIME;
   params.key_type = key_type;
   return GenerateInternal(params);
 }
 
 OpenSSLIdentity* OpenSSLIdentity::GenerateForTest(
     const SSLIdentityParams& params) {
@@ skipping 44 matching lines @@
      SSL_CTX_use_PrivateKey(ctx, key_pair_->pkey()) != 1) {
     LogSSLErrors("Configuring key and certificate");
     return false;
   }
   return true;
 }
 
 }  // namespace rtc
 
 #endif  // HAVE_OPENSSL_SSL_H