[webcrypto] Restrict public exponent for RSA key generation to 3 or 65537.

content/child/webcrypto/platform_crypto_nss.cc

 // Copyright 2014 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 "content/child/webcrypto/platform_crypto.h"
 
 #include <cryptohi.h>
 #include <pk11pub.h>
 #include <secerr.h>
 #include <sechash.h>
@@ skipping 513 matching lines @@
     case blink::WebCryptoAlgorithmIdAesGcm:
     case blink::WebCryptoAlgorithmIdAesKw:
       return CKM_AES_KEY_GEN;
     case blink::WebCryptoAlgorithmIdHmac:
       return WebCryptoHashToHMACMechanism(algorithm.hmacKeyGenParams()->hash());
     default:
       return CKM_INVALID_MECHANISM;
   }
 }
 
-// Converts a (big-endian) WebCrypto BigInteger, with or without leading zeros,
-// to unsigned long.
-bool BigIntegerToLong(const uint8* data,
-                      unsigned int data_size,
-                      unsigned long* result) {
-  // TODO(padolph): Is it correct to say that empty data is an error, or does it
-  // mean value 0? See https://www.w3.org/Bugs/Public/show_bug.cgi?id=23655
-  if (data_size == 0)
-    return false;
-
-  *result = 0;
-  for (size_t i = 0; i < data_size; ++i) {
-    size_t reverse_i = data_size - i - 1;
-
-    if (reverse_i >= sizeof(unsigned long) && data[i])
-      return false;  // Too large for a long.
-
-    *result |= data[i] << 8 * reverse_i;
-  }
-  return true;
-}
-
 bool CreatePublicKeyAlgorithm(const blink::WebCryptoAlgorithm& algorithm,
                               SECKEYPublicKey* key,
                               blink::WebCryptoKeyAlgorithm* key_algorithm) {
   // TODO(eroman): What about other key types rsaPss, rsaOaep.
   if (!key || key->keyType != rsaKey)
     return false;
 
   unsigned int modulus_length_bits = SECKEY_PublicKeyStrength(key) * 8;
   CryptoData public_exponent(key->u.rsa.publicExponent.data,
                              key->u.rsa.publicExponent.len);
@@ skipping 870 matching lines @@
 
 // -----------------------------------
 // Key generation
 // -----------------------------------
 
 Status GenerateRsaKeyPair(const blink::WebCryptoAlgorithm& algorithm,
                           bool extractable,
                           blink::WebCryptoKeyUsageMask public_key_usage_mask,
                           blink::WebCryptoKeyUsageMask private_key_usage_mask,
                           unsigned int modulus_length_bits,
-                          const CryptoData& public_exponent,
+                          unsigned long public_exponent,
                           blink::WebCryptoKey* public_key,
                           blink::WebCryptoKey* private_key) {
   if (algorithm.id() == blink::WebCryptoAlgorithmIdRsaOaep &&
       !g_nss_runtime_support.Get().IsRsaOaepSupported()) {
     return Status::ErrorUnsupported();
   }
 
   crypto::ScopedPK11Slot slot(PK11_GetInternalKeySlot());
   if (!slot)
     return Status::OperationError();
 
-  unsigned long public_exponent_long;
-  if (!BigIntegerToLong(public_exponent.bytes(),
-                        public_exponent.byte_length(),
-                        &public_exponent_long) ||
-      !public_exponent_long) {
-    return Status::ErrorGenerateKeyPublicExponent();
-  }
-
   PK11RSAGenParams rsa_gen_params;
   rsa_gen_params.keySizeInBits = modulus_length_bits;
-  rsa_gen_params.pe = public_exponent_long;
+  rsa_gen_params.pe = public_exponent;
 
   // Flags are verified at the Blink layer; here the flags are set to all
   // possible operations for the given key type.
   CK_FLAGS operation_flags;
   switch (algorithm.id()) {
     case blink::WebCryptoAlgorithmIdRsaOaep:
       operation_flags = CKF_ENCRYPT | CKF_DECRYPT | CKF_WRAP | CKF_UNWRAP;
       break;
     case blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5:
       operation_flags = CKF_SIGN | CKF_VERIFY;
@@ skipping 413 matching lines @@
   buffer->assign(key_data->data, key_data->data + key_data->len);
 
   return Status::Success();
 }
 
 }  // namespace platform
 
 }  // namespace webcrypto
 
 }  // namespace content