[webcrypto] Remove support for null import algorithms.

content/child/webcrypto/shared_crypto_unittest.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 <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 987 matching lines @@
   EXPECT_EQ(blink::WebCryptoAlgorithmIdHmac, key.algorithm().id());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdSha512,
             key.algorithm().hmacParams()->hash().id());
 #if defined(WEBCRYPTO_HMAC_KEY_HAS_LENGTH)
     EXPECT_EQ(1024u, key.algorithm().hmacParams()->lengthBits());
 #endif
   ASSERT_STATUS_SUCCESS(ExportKey(blink::WebCryptoKeyFormatRaw, key, &raw_key));
   EXPECT_EQ(128U, raw_key.byteLength());
 }
 
-TEST_F(SharedCryptoTest, MAYBE(ImportSecretKeyNoAlgorithm)) {
-  blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
-
-  // This fails because the algorithm is null.
-  EXPECT_STATUS(Status::ErrorMissingAlgorithmImportRawKey(),
-                ImportKey(blink::WebCryptoKeyFormatRaw,
-                          CryptoData(HexStringToBytes("00000000000000000000")),
-                          blink::WebCryptoAlgorithm::createNull(),
-                          true,
-                          blink::WebCryptoKeyUsageEncrypt,
-                          &key));
-}
-
 TEST_F(SharedCryptoTest, ImportJwkKeyUsage) {
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   base::DictionaryValue dict;
   dict.SetString("kty", "oct");
   dict.SetBoolean("ext", false);
   dict.SetString("k", "GADWrMRHwQfoNaXU5fZvTg==");
   const blink::WebCryptoAlgorithm aes_cbc_algorithm =
       webcrypto::CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc);
   const blink::WebCryptoAlgorithm hmac_algorithm =
       webcrypto::CreateHmacImportAlgorithm(blink::WebCryptoAlgorithmIdSha256);
@@ skipping 150 matching lines @@
       Status::ErrorJwkNotDictionary(),
       ImportKeyJwk(
           CryptoData(bad_json_vec), algorithm, false, usage_mask, &key));
 
   // Fail on JWK alg present but unrecognized.
   dict.SetString("alg", "A127CBC");
   EXPECT_STATUS(Status::ErrorJwkUnrecognizedAlgorithm(),
                 ImportKeyJwkFromDict(dict, algorithm, false, usage_mask, &key));
   RestoreJwkOctDictionary(&dict);
 
-  // Fail on both JWK and input algorithm missing.
-  dict.Remove("alg", NULL);
-  EXPECT_STATUS(Status::ErrorJwkAlgorithmMissing(),
-                ImportKeyJwkFromDict(dict,
-                                     blink::WebCryptoAlgorithm::createNull(),
-                                     false,
-                                     usage_mask,
-                                     &key));
-  RestoreJwkOctDictionary(&dict);
-
   // Fail on invalid kty.
   dict.SetString("kty", "foo");
   EXPECT_STATUS(Status::ErrorJwkUnrecognizedKty(),
                 ImportKeyJwkFromDict(dict, algorithm, false, usage_mask, &key));
   RestoreJwkOctDictionary(&dict);
 
   // Fail on missing kty.
   dict.Remove("kty", NULL);
   EXPECT_STATUS(Status::ErrorJwkPropertyMissing("kty"),
                 ImportKeyJwkFromDict(dict, algorithm, false, usage_mask, &key));
@@ skipping 217 matching lines @@
   // Fail: Input algorithm (HMAC SHA1) is inconsistent with JWK value
   // (HMAC SHA256).
   EXPECT_STATUS(
       Status::ErrorJwkAlgorithmInconsistent(),
       ImportKeyJwk(CryptoData(json_vec),
                    CreateHmacImportAlgorithm(blink::WebCryptoAlgorithmIdSha1),
                    extractable,
                    usage_mask,
                    &key));
 
-  // Pass: JWK alg valid but input algorithm isNull: use JWK algorithm value.
-  EXPECT_STATUS_SUCCESS(ImportKeyJwk(CryptoData(json_vec),
-                                     blink::WebCryptoAlgorithm::createNull(),
-                                     extractable,
-                                     usage_mask,
-                                     &key));
-  EXPECT_EQ(blink::WebCryptoAlgorithmIdHmac, algorithm.id());
-
   // Pass: JWK alg missing but input algorithm specified: use input value
   dict.Remove("alg", NULL);
   EXPECT_STATUS_SUCCESS(ImportKeyJwkFromDict(
       dict,
       CreateHmacImportAlgorithm(blink::WebCryptoAlgorithmIdSha256),
       extractable,
       usage_mask,
       &key));
   EXPECT_EQ(blink::WebCryptoAlgorithmIdHmac, algorithm.id());
   dict.SetString("alg", "HS256");
@@ skipping 206 matching lines @@
   EXPECT_TRUE(key.handle());
   EXPECT_EQ(blink::WebCryptoKeyTypePublic, key.type());
   EXPECT_TRUE(key.extractable());
   EXPECT_EQ(blink::WebCryptoKeyUsageEncrypt, key.usages());
   EXPECT_EQ(kModulusLengthBits,
             key.algorithm().rsaParams()->modulusLengthBits());
   ExpectCryptoDataMatchesHex(
       "010001", CryptoData(key.algorithm().rsaParams()->publicExponent()));
 
   // Failing case: Empty SPKI data
-  EXPECT_STATUS(Status::ErrorImportEmptyKeyData(),
-                ImportKey(blink::WebCryptoKeyFormatSpki,
-                          CryptoData(std::vector<uint8>()),
-                          blink::WebCryptoAlgorithm::createNull(),
-                          true,
-                          blink::WebCryptoKeyUsageEncrypt,
-                          &key));
-
-  // Failing case: Import RSA key with NULL input algorithm. This is not
-  // allowed because the SPKI ASN.1 format for RSA keys is not specific enough
-  // to map to a Web Crypto algorithm.
-  EXPECT_STATUS(Status::Error(),
-                ImportKey(blink::WebCryptoKeyFormatSpki,
-                          CryptoData(HexStringToBytes(kPublicKeySpkiDerHex)),
-                          blink::WebCryptoAlgorithm::createNull(),
-                          true,
-                          blink::WebCryptoKeyUsageEncrypt,
-                          &key));
+  EXPECT_STATUS(
+      Status::ErrorImportEmptyKeyData(),
+      ImportKey(blink::WebCryptoKeyFormatSpki,
+                CryptoData(std::vector<uint8>()),
+                CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5),
+                true,
+                blink::WebCryptoKeyUsageEncrypt,
+                &key));
 
   // Failing case: Bad DER encoding.
   EXPECT_STATUS(
       Status::Error(),
       ImportKey(blink::WebCryptoKeyFormatSpki,
                 CryptoData(HexStringToBytes("618333c4cb")),
                 CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5),
                 true,
                 blink::WebCryptoKeyUsageEncrypt,
                 &key));
@@ skipping 52 matching lines @@
   EXPECT_EQ(kModulusLengthBits,
             key.algorithm().rsaHashedParams()->modulusLengthBits());
   ExpectCryptoDataMatchesHex(
       "010001",
       CryptoData(key.algorithm().rsaHashedParams()->publicExponent()));
 
   // Failing case: Empty PKCS#8 data
   EXPECT_STATUS(Status::ErrorImportEmptyKeyData(),
                 ImportKey(blink::WebCryptoKeyFormatPkcs8,
                           CryptoData(std::vector<uint8>()),
-                          blink::WebCryptoAlgorithm::createNull(),
+                          CreateRsaHashedImportAlgorithm(
+                              blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
+                              blink::WebCryptoAlgorithmIdSha1),
                           true,
                           blink::WebCryptoKeyUsageSign,
                           &key));
-
-  // Failing case: Import RSA key with NULL input algorithm. This is not
-  // allowed because the PKCS#8 ASN.1 format for RSA keys is not specific enough
-  // to map to a Web Crypto algorithm.
-  EXPECT_STATUS(Status::Error(),
-                ImportKey(blink::WebCryptoKeyFormatPkcs8,
-                          CryptoData(HexStringToBytes(kPrivateKeyPkcs8DerHex)),
-                          blink::WebCryptoAlgorithm::createNull(),
-                          true,
-                          blink::WebCryptoKeyUsageSign,
-                          &key));
 
   // Failing case: Bad DER encoding.
   EXPECT_STATUS(
       Status::Error(),
       ImportKey(blink::WebCryptoKeyFormatPkcs8,
                 CryptoData(HexStringToBytes("618333c4cb")),
                 CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5),
                 true,
                 blink::WebCryptoKeyUsageSign,
                 &key));
@@ skipping 729 matching lines @@
   blink::WebCryptoKey wrapping_key = ImportSecretKeyFromRaw(
       test_kek,
       wrapping_algorithm,
       blink::WebCryptoKeyUsageWrapKey | blink::WebCryptoKeyUsageUnwrapKey);
   // Import the key to be wrapped.
   blink::WebCryptoKey key = ImportSecretKeyFromRaw(
       test_key,
       webcrypto::CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc),
       blink::WebCryptoKeyUsageEncrypt);
 
-  // Unwrap with null algorithm must fail.
-  blink::WebCryptoKey unwrapped_key = blink::WebCryptoKey::createNull();
-  EXPECT_STATUS(Status::ErrorMissingAlgorithmUnwrapRawKey(),
-                UnwrapKey(blink::WebCryptoKeyFormatRaw,
-                          CryptoData(test_ciphertext),
-                          wrapping_key,
-                          wrapping_algorithm,
-                          blink::WebCryptoAlgorithm::createNull(),
-                          true,
-                          blink::WebCryptoKeyUsageEncrypt,
-                          &unwrapped_key));
-
   // Unwrap with wrapped data too small must fail.
   const std::vector<uint8> small_data(test_ciphertext.begin(),
                                       test_ciphertext.begin() + 23);
+  blink::WebCryptoKey unwrapped_key = blink::WebCryptoKey::createNull();
   EXPECT_STATUS(Status::ErrorDataTooSmall(),
                 UnwrapKey(blink::WebCryptoKeyFormatRaw,
                           CryptoData(small_data),
                           wrapping_key,
                           wrapping_algorithm,
                           key_algorithm,
                           true,
                           blink::WebCryptoKeyUsageEncrypt,
                           &unwrapped_key));
 
@@ skipping 64 matching lines @@
       HexStringToBytes("000102030405060708090A0B0C0D0E0F");
   const blink::WebCryptoAlgorithm wrapping_algorithm =
       webcrypto::CreateAlgorithm(blink::WebCryptoAlgorithmIdAesKw);
 
   // Import the wrapping key.
   blink::WebCryptoKey wrapping_key = ImportSecretKeyFromRaw(
       wrapping_key_data, wrapping_algorithm, blink::WebCryptoKeyUsageUnwrapKey);
 
   // Unwrap the known wrapped key data to produce a new key
   blink::WebCryptoKey unwrapped_key = blink::WebCryptoKey::createNull();
-  ASSERT_STATUS_SUCCESS(UnwrapKey(blink::WebCryptoKeyFormatJwk,
-                                  CryptoData(wrapped_key_data),
-                                  wrapping_key,
-                                  wrapping_algorithm,
-                                  blink::WebCryptoAlgorithm::createNull(),
-                                  true,
-                                  blink::WebCryptoKeyUsageVerify,
-                                  &unwrapped_key));
+  ASSERT_STATUS_SUCCESS(
+      UnwrapKey(blink::WebCryptoKeyFormatJwk,
+                CryptoData(wrapped_key_data),
+                wrapping_key,
+                wrapping_algorithm,
+                CreateHmacImportAlgorithm(blink::WebCryptoAlgorithmIdSha256),
+                true,
+                blink::WebCryptoKeyUsageVerify,
+                &unwrapped_key));
 
   // Validate the new key's attributes.
   EXPECT_FALSE(unwrapped_key.isNull());
   EXPECT_TRUE(unwrapped_key.handle());
   EXPECT_EQ(blink::WebCryptoKeyTypeSecret, unwrapped_key.type());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdHmac, unwrapped_key.algorithm().id());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdSha256,
             unwrapped_key.algorithm().hmacParams()->hash().id());
 #if defined(WEBCRYPTO_HMAC_KEY_HAS_LENGTH)
   EXPECT_EQ(256u, unwrapped_key.algorithm().hmacParams()->lengthBits());
@@ skipping 471 matching lines @@
                           algorithm,
                           CreateAesCbcAlgorithm(std::vector<uint8>(0, 16)),
                           true,
                           blink::WebCryptoKeyUsageEncrypt,
                           &unwrapped_key));
 }
 
 }  // namespace webcrypto
 
 }  // namespace content