[WebCrypto] Throw syntaxError if keyUsage is empty in ImportKey

content/child/webcrypto/webcrypto_util.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/webcrypto_util.h"
 
 #include <set>
 
 #include "base/logging.h"
 #include "base/numerics/safe_math.h"
@@ skipping 253 matching lines @@
     return Status::Success();
 
   // BoringSSL does not support 192-bit AES.
   if (keylen_bytes == 24)
     return Status::ErrorAes192BitUnsupported();
 
   return Status::ErrorImportAesKeyLength();
 }
 
 Status CheckKeyCreationUsages(blink::WebCryptoKeyUsageMask all_possible_usages,
-                              blink::WebCryptoKeyUsageMask actual_usages) {
+                              blink::WebCryptoKeyUsageMask actual_usages,
+                              bool allow_empty_usages) {
+  if (!allow_empty_usages && actual_usages == 0)
+    return Status::ErrorCreateKeyEmptyUsages();
+
   if (!ContainsKeyUsages(all_possible_usages, actual_usages))
     return Status::ErrorCreateKeyBadUsages();
   return Status::Success();
 }
 
 Status GetRsaKeyGenParameters(
     const blink::WebCryptoRsaHashedKeyGenParams* params,
     unsigned int* public_exponent,
     unsigned int* modulus_length_bits) {
   *modulus_length_bits = params->modulusLengthBits();
@@ skipping 19 matching lines @@
   return Status::Success();
 }
 
 Status VerifyUsagesBeforeImportAsymmetricKey(
     blink::WebCryptoKeyFormat format,
     blink::WebCryptoKeyUsageMask all_public_key_usages,
     blink::WebCryptoKeyUsageMask all_private_key_usages,
     blink::WebCryptoKeyUsageMask usages) {
   switch (format) {
     case blink::WebCryptoKeyFormatSpki:
-      return CheckKeyCreationUsages(all_public_key_usages, usages);
+      return CheckKeyCreationUsages(all_public_key_usages, usages, true);
     case blink::WebCryptoKeyFormatPkcs8:
-      return CheckKeyCreationUsages(all_private_key_usages, usages);
+      return CheckKeyCreationUsages(all_private_key_usages, usages, false);
     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_public_key_usages, usages).IsError() &&
-          CheckKeyCreationUsages(all_private_key_usages, usages).IsError()) {
+      if (CheckKeyCreationUsages(
+              all_public_key_usages, usages, true).IsError() &&
+          CheckKeyCreationUsages(
+              all_private_key_usages, usages, false).IsError()) {
         return Status::ErrorCreateKeyBadUsages();
       }
       return Status::Success();
     }
     default:
       return Status::ErrorUnsupportedImportKeyFormat();
   }
 }
 
 void TruncateToBitLength(size_t length_bits, std::vector<uint8_t>* bytes) {
@@ skipping 48 matching lines @@
   return GetShaBlockSizeBits(params->hash(), length_bits);
 }
 
 Status GetUsagesForGenerateAsymmetricKey(
     blink::WebCryptoKeyUsageMask combined_usages,
     blink::WebCryptoKeyUsageMask all_public_usages,
     blink::WebCryptoKeyUsageMask all_private_usages,
     blink::WebCryptoKeyUsageMask* public_usages,
     blink::WebCryptoKeyUsageMask* private_usages) {
   Status status = CheckKeyCreationUsages(all_public_usages | all_private_usages,
-                                         combined_usages);
+                                         combined_usages, true);
   if (status.IsError())
     return status;
 
   *public_usages = combined_usages & all_public_usages;
   *private_usages = combined_usages & all_private_usages;
 
   if (*private_usages == 0)
     return Status::ErrorCreateKeyEmptyUsages();
 
   return Status::Success();
 }
 
 }  // namespace webcrypto
 
 }  // namespace content