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

content/child/webcrypto/shared_crypto.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/shared_crypto.h"
 
 #include "base/logging.h"
 #include "content/child/webcrypto/crypto_data.h"
 #include "content/child/webcrypto/jwk.h"
 #include "content/child/webcrypto/platform_crypto.h"
@@ skipping 583 matching lines @@
   if (!ContainsKeyUsages(all_public_key_usages | all_private_key_usages,
                          combined_usage_mask))
     return Status::ErrorCreateKeyBadUsages();
 
   *public_key_usages = combined_usage_mask & all_public_key_usages;
   *private_key_usages = combined_usage_mask & all_private_key_usages;
 
   return Status::Success();
 }
 
+// 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

[Ryan Sleevi, 2014/06/10 23:46:44]

This was answered upstream. Can you please fix this here, as it's a bug.

[eroman, 2014/06/11 01:13:09]

Yup I am aware of that (http://crbug.com/373552).

I am not going to address that here, it requires some changes on Blink side
first.

This is strictly moving a function.

+  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;
+}
+
+
 }  // namespace
 
 void Init() { platform::Init(); }
 
 Status Encrypt(const blink::WebCryptoAlgorithm& algorithm,
                const blink::WebCryptoKey& key,
                const CryptoData& data,
                std::vector<uint8>* buffer) {
   if (!KeyUsageAllows(key, blink::WebCryptoKeyUsageEncrypt))
     return Status::ErrorUnexpected();
@@ skipping 96 matching lines @@
 
   // TODO(padolph): Handle other asymmetric algorithm key generation.
   switch (algorithm.paramsType()) {
     case blink::WebCryptoAlgorithmParamsTypeRsaHashedKeyGenParams: {
       const blink::WebCryptoRsaHashedKeyGenParams* params =
           algorithm.rsaHashedKeyGenParams();
 
       if (!params->modulusLengthBits())
         return Status::ErrorGenerateRsaZeroModulus();
 
-      CryptoData publicExponent(params->publicExponent());
-      if (!publicExponent.byte_length())
+      unsigned long public_exponent = 0;
+      if (!BigIntegerToLong(params->publicExponent().data(),
+                            params->publicExponent().size(),
+                            &public_exponent) ||
+          (public_exponent != 3 && public_exponent != 65537)) {
         return Status::ErrorGenerateKeyPublicExponent();
+      }
 
       return platform::GenerateRsaKeyPair(algorithm,
                                           extractable,
                                           public_key_usage_mask,
                                           private_key_usage_mask,
                                           params->modulusLengthBits(),
-                                          publicExponent,
+                                          public_exponent,
                                           public_key,
                                           private_key);
     }
     default:
       return Status::ErrorUnsupported();
   }
 }
 
 // Note that this function may be called from the target Blink thread.
 Status ImportKey(blink::WebCryptoKeyFormat format,
@@ skipping 245 matching lines @@
   if (!ContainsKeyUsages(GetValidKeyUsagesForKeyType(algorithm, key_type),
                          usages))
     return Status::ErrorCreateKeyBadUsages();
 
   return Status::Success();
 }
 
 }  // namespace webcrypto
 
 }  // namespace content