RTCPeerConnection.generateCertificate taking AlgorithmIdentifier and using WebCrypto

components/webcrypto/algorithms/rsa.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 "components/webcrypto/algorithms/rsa.h"
 
 #include <openssl/evp.h>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "components/webcrypto/algorithms/asymmetric_key_util.h"
 #include "components/webcrypto/algorithms/util.h"
 #include "components/webcrypto/blink_key_handle.h"
 #include "components/webcrypto/crypto_data.h"
 #include "components/webcrypto/generate_key_result.h"
 #include "components/webcrypto/jwk.h"
 #include "components/webcrypto/status.h"
 #include "crypto/openssl_util.h"
 #include "crypto/scoped_openssl_types.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
 #include "third_party/WebKit/public/platform/WebCryptoKeyAlgorithm.h"
+#include "third_party/WebKit/public/platform/WebCryptoUtil.h"
 
 namespace webcrypto {
 
 namespace {
 
 // Describes the RSA components for a parsed key. The names of the properties
 // correspond with those from the JWK spec. Note that Chromium's WebCrypto
 // implementation does not support multi-primes, so there is no parsed field
 // for "oth".
 struct JwkRsaInfo {
@@ skipping 65 matching lines @@
   if (status.IsError())
     return status;
 
   status = jwk.GetBigInteger("qi", &result->qi);
   if (status.IsError())
     return status;
 
   return Status::Success();
 }
 
-// Converts a (big-endian) WebCrypto BigInteger, with or without leading zeros,
-// to unsigned int.
-bool BigIntegerToUint(const uint8_t* data,
-                      size_t data_size,
-                      unsigned int* result) {
-  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(*result) && data[i])
-      return false;  // Too large for a uint.
-
-    *result |= data[i] << 8 * reverse_i;
-  }
-  return true;
-}
-
 // Creates a blink::WebCryptoAlgorithm having the modulus length and public
 // exponent  of |key|.
 Status CreateRsaHashedKeyAlgorithm(
     blink::WebCryptoAlgorithmId rsa_algorithm,
     blink::WebCryptoAlgorithmId hash_algorithm,
     EVP_PKEY* key,
     blink::WebCryptoKeyAlgorithm* key_algorithm) {
   DCHECK_EQ(EVP_PKEY_RSA, EVP_PKEY_id(key));
 
   crypto::ScopedRSA rsa(EVP_PKEY_get1_RSA(key));
@@ skipping 154 matching lines @@
   //
   // These correspond with limitations at the time there was an NSS WebCrypto
   // implementation. However in practice the upper bound is also helpful
   // because generating large RSA keys is very slow.
   if (modulus_length_bits < 256 || modulus_length_bits > 16384 ||
       (modulus_length_bits % 8) != 0) {
     return Status::ErrorGenerateRsaUnsupportedModulus();
   }
 
   unsigned int public_exponent = 0;
-  if (!BigIntegerToUint(params->publicExponent().data(),
-                        params->publicExponent().size(), &public_exponent)) {
+  if (!blink::bigIntegerToUint(params->publicExponent(), public_exponent))
     return Status::ErrorGenerateKeyPublicExponent();
-  }
 
   // OpenSSL hangs when given bad public exponents. Use a whitelist.
   if (public_exponent != 3 && public_exponent != 65537)
     return Status::ErrorGenerateKeyPublicExponent();
 
   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
 
   // Generate an RSA key pair.
   crypto::ScopedRSA rsa_private_key(RSA_new());
   crypto::ScopedBIGNUM bn(BN_new());
@@ skipping 247 matching lines @@
           memcmp(algorithm.rsaHashedParams()->publicExponent().data(),
                  key->algorithm().rsaHashedParams()->publicExponent().data(),
                  key->algorithm().rsaHashedParams()->publicExponent().size())) {
     return Status::ErrorUnexpected();
   }
 
   return Status::Success();
 }
 
 }  // namespace webcrypto