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

components/webcrypto/algorithm_dispatch.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/algorithm_dispatch.h"
 
 #include "base/logging.h"
 #include "components/webcrypto/algorithm_implementation.h"
 #include "components/webcrypto/algorithm_implementations.h"
 #include "components/webcrypto/algorithm_registry.h"
@@ skipping 85 matching lines @@
                    GenerateKeyResult* result) {
   const AlgorithmImplementation* impl = NULL;
   Status status = GetAlgorithmImplementation(algorithm.id(), &impl);
   if (status.IsError())
     return status;
 
   status = impl->GenerateKey(algorithm, extractable, usages, result);
   if (status.IsError())
     return status;
 
+  // The Web Crypto spec says to reject secret and private keys generated with
+  // empty usages:
+  //
+  // https://w3c.github.io/webcrypto/Overview.html#dfn-SubtleCrypto-method-generateKey
+  //
+  // (14.3.6.8):
+  // If result is a CryptoKey object:
+  //     If the [[type]] internal slot of result is "secret" or "private"
+  //     and usages is empty, then throw a SyntaxError.
+  //
+  // (14.3.6.9)
+  // If result is a CryptoKeyPair object:
+  //     If the [[usages]] internal slot of the privateKey attribute of
+  //     result is the empty sequence, then throw a SyntaxError.
   const blink::WebCryptoKey* key = NULL;
   if (result->type() == GenerateKeyResult::TYPE_SECRET_KEY)
     key = &result->secret_key();
   if (result->type() == GenerateKeyResult::TYPE_PUBLIC_PRIVATE_KEY_PAIR)
     key = &result->private_key();
   if (key == NULL)
     return Status::ErrorUnexpected();
 
-  // This should only fail if an algorithm is implemented incorrectly and
-  // does not do its own check of the usages.
   if (key->usages() == 0) {
-    DCHECK(false) << "Key usages for generateKey() must not be empty";
     return Status::ErrorCreateKeyEmptyUsages();
   }
-  return status;
+
+  return Status::Success();
 }
 
 Status ImportKey(blink::WebCryptoKeyFormat format,
                  const CryptoData& key_data,
                  const blink::WebCryptoAlgorithm& algorithm,
                  bool extractable,
                  blink::WebCryptoKeyUsageMask usages,
                  blink::WebCryptoKey* key) {
   const AlgorithmImplementation* impl = NULL;
   Status status = GetAlgorithmImplementation(algorithm.id(), &impl);
   if (status.IsError())
     return status;
 
-  status = impl->VerifyKeyUsagesBeforeImportKey(format, usages);
+  status =
+      impl->ImportKey(format, key_data, algorithm, extractable, usages, key);
   if (status.IsError())
     return status;
 
-  return impl->ImportKey(format, key_data, algorithm, extractable, usages, key);
+  // The Web Crypto spec says to reject secret and private keys imported with
+  // empty usages:
+  //
+  // https://w3c.github.io/webcrypto/Overview.html#dfn-SubtleCrypto-method-importKey
+  //
+  // 14.3.9.9: If the [[type]] internal slot of result is "secret" or "private"
+  //           and usages is empty, then throw a SyntaxError.
+  if (key->usages() == 0 && (key->type() == blink::WebCryptoKeyTypeSecret ||
+                             key->type() == blink::WebCryptoKeyTypePrivate)) {
+    return Status::ErrorCreateKeyEmptyUsages();
+  }
+
+  return Status::Success();
 }
 
 Status ExportKey(blink::WebCryptoKeyFormat format,
                  const blink::WebCryptoKey& key,
                  std::vector<uint8_t>* buffer) {
   if (!key.extractable())
     return Status::ErrorKeyNotExtractable();
   return ExportKeyDontCheckExtractability(format, key, buffer);
 }
 
@@ skipping 54 matching lines @@
                  const blink::WebCryptoAlgorithm& wrapping_algorithm,
                  const blink::WebCryptoAlgorithm& algorithm,
                  bool extractable,
                  blink::WebCryptoKeyUsageMask usages,
                  blink::WebCryptoKey* key) {
   if (!wrapping_key.keyUsageAllows(blink::WebCryptoKeyUsageUnwrapKey))
     return Status::ErrorUnexpected();
   if (wrapping_algorithm.id() != wrapping_key.algorithm().id())
     return Status::ErrorUnexpected();
 
-  // Fail fast if the import is doomed to fail.
-  const AlgorithmImplementation* import_impl = NULL;
-  Status status = GetAlgorithmImplementation(algorithm.id(), &import_impl);
+  std::vector<uint8_t> buffer;
+  Status status = DecryptDontCheckKeyUsage(wrapping_algorithm, wrapping_key,
+                                           wrapped_key_data, &buffer);
   if (status.IsError())
     return status;
 
-  status = import_impl->VerifyKeyUsagesBeforeImportKey(format, usages);
-  if (status.IsError())
-    return status;
-
-  std::vector<uint8_t> buffer;
-  status = DecryptDontCheckKeyUsage(wrapping_algorithm, wrapping_key,
-                                    wrapped_key_data, &buffer);
-  if (status.IsError())
-    return status;
-
   // NOTE that returning the details of ImportKey() failures may leak
   // information about the plaintext of the encrypted key (for instance the JWK
   // key_ops). As long as the ImportKey error messages don't describe actual
   // key bytes however this should be OK. For more discussion see
   // http://crbug.com/372040
   return ImportKey(format, CryptoData(buffer), algorithm, extractable, usages,
                    key);
 }
 
 Status DeriveBits(const blink::WebCryptoAlgorithm& algorithm,
@@ skipping 30 matching lines @@
 
   if (import_algorithm.id() != key_length_algorithm.id())
     return Status::ErrorUnexpected();
 
   const AlgorithmImplementation* import_impl = NULL;
   Status status =
       GetAlgorithmImplementation(import_algorithm.id(), &import_impl);
   if (status.IsError())
     return status;
 
-  // Fail fast if the requested key usages are incorect.
-  status = import_impl->VerifyKeyUsagesBeforeImportKey(
-      blink::WebCryptoKeyFormatRaw, usages);
-  if (status.IsError())
-    return status;
-
   // Determine how many bits long the derived key should be.
   unsigned int length_bits = 0;
   bool has_length_bits = false;
   status = import_impl->GetKeyLength(key_length_algorithm, &has_length_bits,
                                      &length_bits);
   if (status.IsError())
     return status;
 
   // Derive the key bytes.
   const AlgorithmImplementation* derive_impl = NULL;
@@ skipping 39 matching lines @@
   Status status = GetAlgorithmImplementation(algorithm.id(), &impl);
   if (status.IsError())
     return false;
 
   status = impl->DeserializeKeyForClone(algorithm, type, extractable, usages,
                                         key_data, key);
   return status.IsSuccess();
 }
 
 }  // namespace webcrypto