Refactor: Extract some general code for asymmetric algorithms from RSA files.

content/child/webcrypto/openssl/rsa_key_openssl.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/openssl/rsa_key_openssl.h"
 
 #include <openssl/evp.h>
-#include <openssl/pkcs12.h>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "content/child/webcrypto/crypto_data.h"
 #include "content/child/webcrypto/generate_key_result.h"
 #include "content/child/webcrypto/jwk.h"
 #include "content/child/webcrypto/openssl/key_openssl.h"
+#include "content/child/webcrypto/openssl/util_openssl.h"
 #include "content/child/webcrypto/status.h"
 #include "content/child/webcrypto/webcrypto_util.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"
 
 namespace content {
 
 namespace webcrypto {
 
 namespace {
 
-Status ExportPKeySpki(EVP_PKEY* key, std::vector<uint8_t>* buffer) {
-  crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
-  crypto::ScopedBIO bio(BIO_new(BIO_s_mem()));
-
-  // TODO(eroman): Use the OID specified by webcrypto spec.
-  //               http://crbug.com/373545
-  if (!i2d_PUBKEY_bio(bio.get(), key))
-    return Status::ErrorUnexpected();
-
-  char* data = NULL;
-  long len = BIO_get_mem_data(bio.get(), &data);
-  if (!data || len < 0)
-    return Status::ErrorUnexpected();
-
-  buffer->assign(data, data + len);
-  return Status::Success();
-}
-
-Status ExportPKeyPkcs8(EVP_PKEY* key, std::vector<uint8_t>* buffer) {
-  crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
-  crypto::ScopedBIO bio(BIO_new(BIO_s_mem()));
-
-  // TODO(eroman): Use the OID specified by webcrypto spec.
-  //               http://crbug.com/373545
-  if (!i2d_PKCS8PrivateKeyInfo_bio(bio.get(), key))
-    return Status::ErrorUnexpected();
-
-  char* data = NULL;
-  long len = BIO_get_mem_data(bio.get(), &data);
-  if (!data || len < 0)
-    return Status::ErrorUnexpected();
-
-  buffer->assign(data, data + len);
-  return Status::Success();
-}
-
 // 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));
   if (!rsa.get())
     return Status::ErrorUnexpected();
 
   unsigned int modulus_length_bits = BN_num_bits(rsa.get()->n);
 
   // Convert the public exponent to big-endian representation.
   std::vector<uint8_t> e(BN_num_bytes(rsa.get()->e));
   if (e.size() == 0)
     return Status::ErrorUnexpected();
   if (e.size() != BN_bn2bin(rsa.get()->e, &e[0]))
     return Status::ErrorUnexpected();
 
   *key_algorithm = blink::WebCryptoKeyAlgorithm::createRsaHashed(
       rsa_algorithm, modulus_length_bits, &e[0], e.size(), hash_algorithm);
 
   return Status::Success();
 }
 
-Status CreateWebCryptoPrivateKey(
+// Creates a WebCryptoKey that wraps |private_key|.
+Status CreateWebCryptoRsaPrivateKey(
     crypto::ScopedEVP_PKEY private_key,
     const blink::WebCryptoAlgorithmId rsa_algorithm_id,
     const blink::WebCryptoAlgorithm& hash,
     bool extractable,
     blink::WebCryptoKeyUsageMask usages,
     blink::WebCryptoKey* key) {
   blink::WebCryptoKeyAlgorithm key_algorithm;
   Status status = CreateRsaHashedKeyAlgorithm(
       rsa_algorithm_id, hash.id(), private_key.get(), &key_algorithm);
   if (status.IsError())
     return status;
 
-  // Serialize the key at creation time so that if structured cloning is
-  // requested it can be done synchronously from the Blink thread.
-  std::vector<uint8_t> pkcs8_data;
-  status = ExportPKeyPkcs8(private_key.get(), &pkcs8_data);
-  if (status.IsError())
-    return status;
-
-  *key = blink::WebCryptoKey::create(
-      new AsymKeyOpenSsl(private_key.Pass(), CryptoData(pkcs8_data)),
-      blink::WebCryptoKeyTypePrivate,
-      extractable,
-      key_algorithm,
-      usages);
-  return Status::Success();
+  return CreateWebCryptoPrivateKey(private_key.Pass(), key_algorithm,
+                                   extractable, usages, key);
 }
 
-Status CreateWebCryptoPublicKey(
+// Creates a WebCryptoKey that wraps |public_key|.
+Status CreateWebCryptoRsaPublicKey(
     crypto::ScopedEVP_PKEY public_key,
     const blink::WebCryptoAlgorithmId rsa_algorithm_id,
     const blink::WebCryptoAlgorithm& hash,
     bool extractable,
     blink::WebCryptoKeyUsageMask usages,
     blink::WebCryptoKey* key) {
   blink::WebCryptoKeyAlgorithm key_algorithm;
   Status status = CreateRsaHashedKeyAlgorithm(
       rsa_algorithm_id, hash.id(), public_key.get(), &key_algorithm);
   if (status.IsError())
     return status;
 
-  // Serialize the key at creation time so that if structured cloning is
-  // requested it can be done synchronously from the Blink thread.
-  std::vector<uint8_t> spki_data;
-  status = ExportPKeySpki(public_key.get(), &spki_data);
-  if (status.IsError())
-    return status;
-
-  *key = blink::WebCryptoKey::create(
-      new AsymKeyOpenSsl(public_key.Pass(), CryptoData(spki_data)),
-      blink::WebCryptoKeyTypePublic,
-      extractable,
-      key_algorithm,
-      usages);
-  return Status::Success();
+  return CreateWebCryptoPublicKey(public_key.Pass(), key_algorithm, extractable,
+                                  usages, key);
 }
 
 // Converts a BIGNUM to a big endian byte array.
 std::vector<uint8_t> BIGNUMToVector(BIGNUM* n) {
   std::vector<uint8_t> v(BN_num_bytes(n));
   BN_bn2bin(n, vector_as_array(&v));
   return v;
 }
 
 // Allocates a new BIGNUM given a std::string big-endian representation.
@@ skipping 25 matching lines @@
   // TODO(eroman): This should really be a DataError, however for compatibility
   //               with NSS it is an OperationError.
   if (!RSA_check_key(rsa.get()))
     return Status::OperationError();
 
   // Create a corresponding EVP_PKEY.
   crypto::ScopedEVP_PKEY pkey(EVP_PKEY_new());
   if (!pkey || !EVP_PKEY_set1_RSA(pkey.get(), rsa.get()))
     return Status::OperationError();
 
-  return CreateWebCryptoPrivateKey(pkey.Pass(),
-                                   algorithm.id(),
-                                   algorithm.rsaHashedImportParams()->hash(),
-                                   extractable,
-                                   usages,
-                                   key);
+  return CreateWebCryptoRsaPrivateKey(pkey.Pass(), algorithm.id(),
+                                      algorithm.rsaHashedImportParams()->hash(),
+                                      extractable, usages, key);
 }
 
 Status ImportRsaPublicKey(const blink::WebCryptoAlgorithm& algorithm,
                           bool extractable,
                           blink::WebCryptoKeyUsageMask usages,
                           const CryptoData& n,
                           const CryptoData& e,
                           blink::WebCryptoKey* key) {
   crypto::ScopedRSA rsa(RSA_new());
 
   rsa->n = BN_bin2bn(n.bytes(), n.byte_length(), NULL);
   rsa->e = BN_bin2bn(e.bytes(), e.byte_length(), NULL);
 
   if (!rsa->n || !rsa->e)
     return Status::OperationError();
 
   // Create a corresponding EVP_PKEY.
   crypto::ScopedEVP_PKEY pkey(EVP_PKEY_new());
   if (!pkey || !EVP_PKEY_set1_RSA(pkey.get(), rsa.get()))
     return Status::OperationError();
 
-  return CreateWebCryptoPublicKey(pkey.Pass(),
-                                  algorithm.id(),
-                                  algorithm.rsaHashedImportParams()->hash(),
-                                  extractable,
-                                  usages,
-                                  key);
+  return CreateWebCryptoRsaPublicKey(pkey.Pass(), algorithm.id(),
+                                     algorithm.rsaHashedImportParams()->hash(),
+                                     extractable, usages, key);
 }
 
 }  // namespace
 
 Status RsaHashedAlgorithm::GenerateKey(
     const blink::WebCryptoAlgorithm& algorithm,
     bool extractable,
     blink::WebCryptoKeyUsageMask combined_usages,
     GenerateKeyResult* result) const {
   Status status = CheckKeyCreationUsages(
@@ skipping 44 matching lines @@
   if (!public_pkey ||
       !EVP_PKEY_set1_RSA(public_pkey.get(), rsa_public_key.get())) {
     return Status::OperationError();
   }
 
   blink::WebCryptoKey public_key;
   blink::WebCryptoKey private_key;
 
   // Note that extractable is unconditionally set to true. This is because per
   // the WebCrypto spec generated public keys are always public.
-  status = CreateWebCryptoPublicKey(public_pkey.Pass(),
-                                    algorithm.id(),
-                                    params->hash(),
-                                    true,
-                                    public_usages,
-                                    &public_key);
+  status = CreateWebCryptoRsaPublicKey(public_pkey.Pass(), algorithm.id(),
+                                       params->hash(), true, public_usages,
+                                       &public_key);
   if (status.IsError())
     return status;
 
-  status = CreateWebCryptoPrivateKey(private_pkey.Pass(),
-                                     algorithm.id(),
-                                     params->hash(),
-                                     extractable,
-                                     private_usages,
-                                     &private_key);
+  status = CreateWebCryptoRsaPrivateKey(private_pkey.Pass(), algorithm.id(),
+                                        params->hash(), extractable,
+                                        private_usages, &private_key);
   if (status.IsError())
     return status;
 
   result->AssignKeyPair(public_key, private_key);
   return Status::Success();
 }
 
 Status RsaHashedAlgorithm::VerifyKeyUsagesBeforeImportKey(
     blink::WebCryptoKeyFormat format,
     blink::WebCryptoKeyUsageMask usages) const {
   switch (format) {
     case blink::WebCryptoKeyFormatSpki:
       return CheckKeyCreationUsages(all_public_key_usages_, usages);
     case blink::WebCryptoKeyFormatPkcs8:
       return CheckKeyCreationUsages(all_private_key_usages_, usages);
     case blink::WebCryptoKeyFormatJwk:
       // The JWK could represent either a public key or private key. The usages
       // must make sense for one of the two. The usages will be checked again by
       // ImportKeyJwk() once the key type has been determined.
-      if (CheckKeyCreationUsages(all_private_key_usages_, usages)
-              .IsSuccess() ||
-          CheckKeyCreationUsages(all_public_key_usages_, usages)
-              .IsSuccess()) {
+      if (CheckKeyCreationUsages(all_private_key_usages_, usages).IsSuccess() ||
+          CheckKeyCreationUsages(all_public_key_usages_, usages).IsSuccess()) {
         return Status::Success();
       }
       return Status::ErrorCreateKeyBadUsages();
     default:
       return Status::ErrorUnsupportedImportKeyFormat();
   }
 }
 
 Status RsaHashedAlgorithm::ImportKeyPkcs8(
     const CryptoData& key_data,
     const blink::WebCryptoAlgorithm& algorithm,
     bool extractable,
     blink::WebCryptoKeyUsageMask usages,
     blink::WebCryptoKey* key) const {
-  if (!key_data.byte_length())
-    return Status::ErrorImportEmptyKeyData();
+  crypto::ScopedEVP_PKEY private_key;
+  Status status =
+      ImportUnverifiedPkeyFromPkcs8(key_data, EVP_PKEY_RSA, &private_key);
+  if (status.IsError())
+    return status;
 
-  crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
-
-  crypto::ScopedBIO bio(BIO_new_mem_buf(const_cast<uint8_t*>(key_data.bytes()),
-                                        key_data.byte_length()));
-  if (!bio.get())
-    return Status::ErrorUnexpected();
-
-  crypto::ScopedOpenSSL<PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO_free>::Type
-      p8inf(d2i_PKCS8_PRIV_KEY_INFO_bio(bio.get(), NULL));
-  if (!p8inf.get())
-    return Status::DataError();
-
-  crypto::ScopedEVP_PKEY private_key(EVP_PKCS82PKEY(p8inf.get()));
-  if (!private_key.get())
-    return Status::DataError();
-
-  if (EVP_PKEY_id(private_key.get()) != EVP_PKEY_RSA)
-    return Status::DataError();  // Data did not define an RSA key.
-
-  // Verify the parameters of the key (because EVP_PKCS82PKEY() happily imports
-  // invalid keys).
+  // Verify the parameters of the key.
   crypto::ScopedRSA rsa(EVP_PKEY_get1_RSA(private_key.get()));
   if (!rsa.get())
     return Status::ErrorUnexpected();
   if (!RSA_check_key(rsa.get()))
     return Status::DataError();
 
   // TODO(eroman): Validate the algorithm OID against the webcrypto provided
   // hash. http://crbug.com/389400
 
-  return CreateWebCryptoPrivateKey(private_key.Pass(),
-                                   algorithm.id(),
-                                   algorithm.rsaHashedImportParams()->hash(),
-                                   extractable,
-                                   usages,
-                                   key);
+  return CreateWebCryptoRsaPrivateKey(private_key.Pass(), algorithm.id(),
+                                      algorithm.rsaHashedImportParams()->hash(),
+                                      extractable, usages, key);
 }
 
 Status RsaHashedAlgorithm::ImportKeySpki(
     const CryptoData& key_data,
     const blink::WebCryptoAlgorithm& algorithm,
     bool extractable,
     blink::WebCryptoKeyUsageMask usages,
     blink::WebCryptoKey* key) const {
-  if (!key_data.byte_length())
-    return Status::ErrorImportEmptyKeyData();
-
-  crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
-
-  crypto::ScopedBIO bio(BIO_new_mem_buf(const_cast<uint8_t*>(key_data.bytes()),
-                                        key_data.byte_length()));
-  if (!bio.get())
-    return Status::ErrorUnexpected();
-
-  crypto::ScopedEVP_PKEY public_key(d2i_PUBKEY_bio(bio.get(), NULL));
-  if (!public_key.get())
-    return Status::DataError();
-
-  if (EVP_PKEY_id(public_key.get()) != EVP_PKEY_RSA)
-    return Status::DataError();  // Data did not define an RSA key.
+  crypto::ScopedEVP_PKEY public_key;
+  Status status =
+      ImportUnverifiedPkeyFromSpki(key_data, EVP_PKEY_RSA, &public_key);
+  if (status.IsError())
+    return status;
 
   // TODO(eroman): Validate the algorithm OID against the webcrypto provided
   // hash. http://crbug.com/389400
 
-  return CreateWebCryptoPublicKey(public_key.Pass(),
-                                  algorithm.id(),
-                                  algorithm.rsaHashedImportParams()->hash(),
-                                  extractable,
-                                  usages,
-                                  key);
+  return CreateWebCryptoRsaPublicKey(public_key.Pass(), algorithm.id(),
+                                     algorithm.rsaHashedImportParams()->hash(),
+                                     extractable, usages, key);
 }
 
 Status RsaHashedAlgorithm::ImportKeyJwk(
     const CryptoData& key_data,
     const blink::WebCryptoAlgorithm& algorithm,
     bool extractable,
     blink::WebCryptoKeyUsageMask usages,
     blink::WebCryptoKey* key) const {
   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
 
@@ skipping 11 matching lines @@
 
   // Once the key type is known, verify the usages.
   status = CheckKeyCreationUsages(
       jwk.is_private_key ? all_private_key_usages_ : all_public_key_usages_,
       usages);
   if (status.IsError())
     return status;
 
   return jwk.is_private_key
              ? ImportRsaPrivateKey(algorithm, extractable, usages, jwk, key)
-             : ImportRsaPublicKey(algorithm,
-                                  extractable,
-                                  usages,
-                                  CryptoData(jwk.n),
-                                  CryptoData(jwk.e),
-                                  key);
+             : ImportRsaPublicKey(algorithm, extractable, usages,
+                                  CryptoData(jwk.n), CryptoData(jwk.e), key);
 }
 
 Status RsaHashedAlgorithm::ExportKeyPkcs8(const blink::WebCryptoKey& key,
                                           std::vector<uint8_t>* buffer) const {
   if (key.type() != blink::WebCryptoKeyTypePrivate)
     return Status::ErrorUnexpectedKeyType();
   *buffer = AsymKeyOpenSsl::Cast(key)->serialized_key_data();
   return Status::Success();
 }
 
 Status RsaHashedAlgorithm::ExportKeySpki(const blink::WebCryptoKey& key,
                                          std::vector<uint8_t>* buffer) const {
   if (key.type() != blink::WebCryptoKeyTypePublic)
     return Status::ErrorUnexpectedKeyType();
   *buffer = AsymKeyOpenSsl::Cast(key)->serialized_key_data();
   return Status::Success();
 }
 
 Status RsaHashedAlgorithm::ExportKeyJwk(const blink::WebCryptoKey& key,
                                         std::vector<uint8_t>* buffer) const {
   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
 
-  EVP_PKEY* public_key = AsymKeyOpenSsl::Cast(key)->key();
-  crypto::ScopedRSA rsa(EVP_PKEY_get1_RSA(public_key));
+  EVP_PKEY* pkey = AsymKeyOpenSsl::Cast(key)->key();
+  crypto::ScopedRSA rsa(EVP_PKEY_get1_RSA(pkey));
   if (!rsa.get())
     return Status::ErrorUnexpected();
 
   const char* jwk_algorithm =
       GetJwkAlgorithm(key.algorithm().rsaHashedParams()->hash().id());
   if (!jwk_algorithm)
     return Status::ErrorUnexpected();
 
   switch (key.type()) {
     case blink::WebCryptoKeyTypePublic:
       WriteRsaPublicKeyJwk(CryptoData(BIGNUMToVector(rsa->n)),
-                           CryptoData(BIGNUMToVector(rsa->e)),
-                           jwk_algorithm,
-                           key.extractable(),
-                           key.usages(),
-                           buffer);
+                           CryptoData(BIGNUMToVector(rsa->e)), jwk_algorithm,
+                           key.extractable(), key.usages(), buffer);
       return Status::Success();
     case blink::WebCryptoKeyTypePrivate:
       WriteRsaPrivateKeyJwk(CryptoData(BIGNUMToVector(rsa->n)),
                             CryptoData(BIGNUMToVector(rsa->e)),
                             CryptoData(BIGNUMToVector(rsa->d)),
                             CryptoData(BIGNUMToVector(rsa->p)),
                             CryptoData(BIGNUMToVector(rsa->q)),
                             CryptoData(BIGNUMToVector(rsa->dmp1)),
                             CryptoData(BIGNUMToVector(rsa->dmq1)),
                             CryptoData(BIGNUMToVector(rsa->iqmp)),
-                            jwk_algorithm,
-                            key.extractable(),
-                            key.usages(),
+                            jwk_algorithm, key.extractable(), key.usages(),
                             buffer);
       return Status::Success();
 
     default:
       return Status::ErrorUnexpected();
   }
 }
 
 }  // namespace webcrypto
 
 }  // namespace content