[webcrypto] Remove support for null import algorithms.

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/platform_crypto.h"
 #include "content/child/webcrypto/status.h"
@@ skipping 193 matching lines @@
 
   return platform::VerifyRsaSsaPkcs1v1_5(
       public_key,
       key.algorithm().rsaHashedParams()->hash(),
       signature,
       data,
       signature_match);
 }
 
 Status ImportKeyRaw(const CryptoData& key_data,
-                    const blink::WebCryptoAlgorithm& algorithm_or_null,
+                    const blink::WebCryptoAlgorithm& algorithm,
                     bool extractable,
                     blink::WebCryptoKeyUsageMask usage_mask,
                     blink::WebCryptoKey* key) {
-  if (algorithm_or_null.isNull())
-    return Status::ErrorMissingAlgorithmImportRawKey();
-
-  switch (algorithm_or_null.id()) {
+  switch (algorithm.id()) {
     case blink::WebCryptoAlgorithmIdAesCtr:
     case blink::WebCryptoAlgorithmIdAesCbc:
     case blink::WebCryptoAlgorithmIdAesGcm:
     case blink::WebCryptoAlgorithmIdAesKw:
       if (!IsValidAesKeyLengthBytes(key_data.byte_length()))
         return Status::Error();
     // Fallthrough intentional!
     case blink::WebCryptoAlgorithmIdHmac:
       return platform::ImportKeyRaw(
-          algorithm_or_null, key_data, extractable, usage_mask, key);
+          algorithm, key_data, extractable, usage_mask, key);
     default:
       return Status::ErrorUnsupported();
   }
 }
 
 // Returns the key format to use for structured cloning.
 blink::WebCryptoKeyFormat GetCloneFormatForKeyType(
     blink::WebCryptoKeyType type) {
   switch (type) {
     case blink::WebCryptoKeyTypeSecret:
@@ skipping 75 matching lines @@
   if (aeskw_input_data.byte_length() < 24)
     return Status::ErrorDataTooSmall();
   if (aeskw_input_data.byte_length() % 8)
     return Status::ErrorInvalidAesKwDataLength();
   return Status::Success();
 }
 
 Status UnwrapKeyRaw(const CryptoData& wrapped_key_data,
                     const blink::WebCryptoKey& wrapping_key,
                     const blink::WebCryptoAlgorithm& wrapping_algorithm,
-                    const blink::WebCryptoAlgorithm& algorithm_or_null,
+                    const blink::WebCryptoAlgorithm& algorithm,
                     bool extractable,
                     blink::WebCryptoKeyUsageMask usage_mask,
                     blink::WebCryptoKey* key) {
-  // Must provide an algorithm when unwrapping a raw key
-  if (algorithm_or_null.isNull())
-    return Status::ErrorMissingAlgorithmUnwrapRawKey();
-
   // TODO(padolph): Handle other wrapping algorithms
   switch (wrapping_algorithm.id()) {
     case blink::WebCryptoAlgorithmIdAesKw: {
       platform::SymKey* platform_wrapping_key;
       Status status = ToPlatformSymKey(wrapping_key, &platform_wrapping_key);
       if (status.IsError())
         return status;
       status = CheckAesKwInputSize(wrapped_key_data);
       if (status.IsError())
         return status;
       return platform::UnwrapSymKeyAesKw(wrapped_key_data,
                                          platform_wrapping_key,
-                                         algorithm_or_null,
+                                         algorithm,
                                          extractable,
                                          usage_mask,
                                          key);
     }
     case blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5: {
       platform::PrivateKey* platform_wrapping_key;
       Status status =
           ToPlatformPrivateKey(wrapping_key, &platform_wrapping_key);
       if (status.IsError())
         return status;
       if (!wrapped_key_data.byte_length())
         return Status::ErrorDataTooSmall();
       return platform::UnwrapSymKeyRsaEs(wrapped_key_data,
                                          platform_wrapping_key,
-                                         algorithm_or_null,
+                                         algorithm,
                                          extractable,
                                          usage_mask,
                                          key);
     }
     default:
       return Status::ErrorUnsupported();
   }
 }
 
 Status WrapKeyRaw(const blink::WebCryptoKey& wrapping_key,
@@ skipping 79 matching lines @@
     default:
       return Status::ErrorUnsupported();
   }
 }
 
 Status UnwrapKeyDecryptAndImport(
     blink::WebCryptoKeyFormat format,
     const CryptoData& wrapped_key_data,
     const blink::WebCryptoKey& wrapping_key,
     const blink::WebCryptoAlgorithm& wrapping_algorithm,
-    const blink::WebCryptoAlgorithm& algorithm_or_null,
+    const blink::WebCryptoAlgorithm& algorithm,
     bool extractable,
     blink::WebCryptoKeyUsageMask usage_mask,
     blink::WebCryptoKey* key) {
   blink::WebArrayBuffer buffer;
   Status status = DecryptDontCheckKeyUsage(
       wrapping_algorithm, wrapping_key, wrapped_key_data, &buffer);
   if (status.IsError())
     return status;
-  status = ImportKey(format,
-                     CryptoData(buffer),
-                     algorithm_or_null,
-                     extractable,
-                     usage_mask,
-                     key);
+  status = ImportKey(
+      format, CryptoData(buffer), algorithm, extractable, usage_mask, key);
   // NOTE! Returning the details of any ImportKey() failure here would leak
   // information about the plaintext internals of the encrypted key. Instead,
   // collapse any error into the generic Status::Error().
   return status.IsError() ? Status::Error() : Status::Success();
 }
 
 Status WrapKeyExportAndEncrypt(
     blink::WebCryptoKeyFormat format,
     const blink::WebCryptoKey& wrapping_key,
     const blink::WebCryptoKey& key_to_wrap,
@@ skipping 124 matching lines @@
                                           public_key,
                                           private_key);
     }
     default:
       return Status::ErrorUnsupported();
   }
 }
 
 Status ImportKey(blink::WebCryptoKeyFormat format,
                  const CryptoData& key_data,
-                 const blink::WebCryptoAlgorithm& algorithm_or_null,
+                 const blink::WebCryptoAlgorithm& algorithm,
                  bool extractable,
                  blink::WebCryptoKeyUsageMask usage_mask,
                  blink::WebCryptoKey* key) {
   switch (format) {
     case blink::WebCryptoKeyFormatRaw:
-      return ImportKeyRaw(
-          key_data, algorithm_or_null, extractable, usage_mask, key);
+      return ImportKeyRaw(key_data, algorithm, extractable, usage_mask, key);
     case blink::WebCryptoKeyFormatSpki:
       return platform::ImportKeySpki(
-          algorithm_or_null, key_data, extractable, usage_mask, key);
+          algorithm, key_data, extractable, usage_mask, key);
     case blink::WebCryptoKeyFormatPkcs8:
       return platform::ImportKeyPkcs8(
-          algorithm_or_null, key_data, extractable, usage_mask, key);
+          algorithm, key_data, extractable, usage_mask, key);
     case blink::WebCryptoKeyFormatJwk:
-      return ImportKeyJwk(
-          key_data, algorithm_or_null, extractable, usage_mask, key);
+      return ImportKeyJwk(key_data, algorithm, extractable, usage_mask, key);
     default:
       return Status::ErrorUnsupported();
   }
 }
 
 // TODO(eroman): Move this to anonymous namespace.
 Status ExportKeyDontCheckExtractability(blink::WebCryptoKeyFormat format,
                                         const blink::WebCryptoKey& key,
                                         blink::WebArrayBuffer* buffer) {
   switch (format) {
@@ skipping 99 matching lines @@
     default:
       NOTREACHED();
       return Status::ErrorUnsupported();
   }
 }
 
 Status UnwrapKey(blink::WebCryptoKeyFormat format,
                  const CryptoData& wrapped_key_data,
                  const blink::WebCryptoKey& wrapping_key,
                  const blink::WebCryptoAlgorithm& wrapping_algorithm,
-                 const blink::WebCryptoAlgorithm& algorithm_or_null,
+                 const blink::WebCryptoAlgorithm& algorithm,
                  bool extractable,
                  blink::WebCryptoKeyUsageMask usage_mask,
                  blink::WebCryptoKey* key) {
   if (!KeyUsageAllows(wrapping_key, blink::WebCryptoKeyUsageUnwrapKey))
     return Status::ErrorUnexpected();
   if (wrapping_algorithm.id() != wrapping_key.algorithm().id())
     return Status::ErrorUnexpected();
 
   switch (format) {
     case blink::WebCryptoKeyFormatRaw:
       return UnwrapKeyRaw(wrapped_key_data,
                           wrapping_key,
                           wrapping_algorithm,
-                          algorithm_or_null,
+                          algorithm,
                           extractable,
                           usage_mask,
                           key);
     case blink::WebCryptoKeyFormatJwk:
       return UnwrapKeyDecryptAndImport(format,
                                        wrapped_key_data,
                                        wrapping_key,
                                        wrapping_algorithm,
-                                       algorithm_or_null,
+                                       algorithm,
                                        extractable,
                                        usage_mask,
                                        key);
     case blink::WebCryptoKeyFormatSpki:
     case blink::WebCryptoKeyFormatPkcs8:
       return Status::ErrorUnsupported();  // TODO(padolph)
     default:
       NOTREACHED();
       return Status::ErrorUnsupported();
   }
@@ skipping 25 matching lines @@
                             key);
   if (status.IsError())
     return status;
 
   return ValidateDeserializedKey(*key, algorithm, type);
 }
 
 }  // namespace webcrypto
 
 }  // namespace content