[webcrypto] Check for empty key usages *after* key creation rather than before, to match the spec's…

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 <utility>
 
 #include "base/logging.h"
@@ skipping 318 matching lines @@
   status = CreateWebCryptoRsaPrivateKey(std::move(private_pkey), 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 {
-  return VerifyUsagesBeforeImportAsymmetricKey(format, all_public_key_usages_,
-                                               all_private_key_usages_, usages);
+Status RsaHashedAlgorithm::ImportKey(blink::WebCryptoKeyFormat format,
+                                     const CryptoData& key_data,
+                                     const blink::WebCryptoAlgorithm& algorithm,
+                                     bool extractable,
+                                     blink::WebCryptoKeyUsageMask usages,
+                                     blink::WebCryptoKey* key) const {
+  switch (format) {
+    case blink::WebCryptoKeyFormatPkcs8:
+      return ImportKeyPkcs8(key_data, algorithm, extractable, usages, key);
+    case blink::WebCryptoKeyFormatSpki:
+      return ImportKeySpki(key_data, algorithm, extractable, usages, key);
+    case blink::WebCryptoKeyFormatJwk:
+      return ImportKeyJwk(key_data, algorithm, extractable, usages, key);
+    default:
+      return Status::ErrorUnsupportedImportKeyFormat();
+  }
+}
+
+Status RsaHashedAlgorithm::ExportKey(blink::WebCryptoKeyFormat format,
+                                     const blink::WebCryptoKey& key,
+                                     std::vector<uint8_t>* buffer) const {
+  switch (format) {
+    case blink::WebCryptoKeyFormatPkcs8:
+      return ExportKeyPkcs8(key, buffer);
+    case blink::WebCryptoKeyFormatSpki:
+      return ExportKeySpki(key, buffer);
+    case blink::WebCryptoKeyFormatJwk:
+      return ExportKeyJwk(key, buffer);
+    default:
+      return Status::ErrorUnsupportedExportKeyFormat();
+  }
 }
 
 Status RsaHashedAlgorithm::ImportKeyPkcs8(
     const CryptoData& key_data,
     const blink::WebCryptoAlgorithm& algorithm,
     bool extractable,
     blink::WebCryptoKeyUsageMask usages,
     blink::WebCryptoKey* key) const {
-  crypto::ScopedEVP_PKEY private_key;
-  Status status =
-      ImportUnverifiedPkeyFromPkcs8(key_data, EVP_PKEY_RSA, &private_key);
+  Status status = CheckKeyCreationUsages(all_private_key_usages_, usages);
   if (status.IsError())
     return status;
 
+  crypto::ScopedEVP_PKEY private_key;
+  status = ImportUnverifiedPkeyFromPkcs8(key_data, EVP_PKEY_RSA, &private_key);
+  if (status.IsError())
+    return status;
+
   // 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 CreateWebCryptoRsaPrivateKey(std::move(private_key), 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 {
-  crypto::ScopedEVP_PKEY public_key;
-  Status status =
-      ImportUnverifiedPkeyFromSpki(key_data, EVP_PKEY_RSA, &public_key);
+  Status status = CheckKeyCreationUsages(all_public_key_usages_, usages);
   if (status.IsError())
     return status;
 
+  crypto::ScopedEVP_PKEY public_key;
+  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 CreateWebCryptoRsaPublicKey(std::move(public_key), algorithm.id(),
                                      algorithm.rsaHashedImportParams()->hash(),
                                      extractable, usages, key);
 }
 
 Status RsaHashedAlgorithm::ImportKeyJwk(
     const CryptoData& key_data,
@@ skipping 10 matching lines @@
     return Status::ErrorUnexpected();
 
   JwkRsaInfo jwk;
   Status status =
       ReadRsaKeyJwk(key_data, jwk_algorithm, extractable, usages, &jwk);
   if (status.IsError())
     return status;
 
   // Once the key type is known, verify the usages.
   if (jwk.is_private_key) {
-    status = CheckPrivateKeyCreationUsages(all_private_key_usages_, usages);
+    status = CheckKeyCreationUsages(all_private_key_usages_, usages);
   } else {
-    status = CheckPublicKeyCreationUsages(all_public_key_usages_, usages);
+    status = CheckKeyCreationUsages(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);
 }
@@ skipping 112 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