Check that usage isn't empty when generateKey() is called

content/child/webcrypto/test/aes_cbc_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 "base/stl_util.h"
 #include "content/child/webcrypto/algorithm_dispatch.h"
 #include "content/child/webcrypto/crypto_data.h"
 #include "content/child/webcrypto/status.h"
 #include "content/child/webcrypto/test/test_helpers.h"
 #include "content/child/webcrypto/webcrypto_util.h"
@@ skipping 155 matching lines @@
     blink::WebCryptoKey key;
 
     std::vector<std::vector<uint8_t>> keys;
     std::vector<uint8_t> key_bytes;
 
     // Generate a small sample of keys.
     for (int j = 0; j < 16; ++j) {
       ASSERT_EQ(Status::Success(),
                 GenerateSecretKey(
                     CreateAesCbcKeyGenAlgorithm(kKeyLength[key_length_i]), true,
-                    0, &key));
+                    blink::WebCryptoKeyUsageEncrypt, &key));
       EXPECT_TRUE(key.handle());
       EXPECT_EQ(blink::WebCryptoKeyTypeSecret, key.type());
       ASSERT_EQ(Status::Success(),
                 ExportKey(blink::WebCryptoKeyFormatRaw, key, &key_bytes));
       EXPECT_EQ(key_bytes.size() * 8,
                 key.algorithm().aesParams()->lengthBits());
       keys.push_back(key_bytes);
     }
     // Ensure all entries in the key sample set are unique. This is a simplistic
     // estimate of whether the generated keys appear random.
@@ skipping 269 matching lines @@
     SCOPED_TRACE(i);
 
     blink::WebCryptoKey key;
 
     ASSERT_EQ(Status::ErrorCreateKeyBadUsages(),
               GenerateSecretKey(CreateAesCbcKeyGenAlgorithm(128), true,
                                 bad_usages[i], &key));
   }
 }
 
+// Generate an AES-CBC key with no usages.
+TEST(WebCryptoAesCbcTest, GenerateKeyEmptyUsages) {
+  blink::WebCryptoKey key;
+
+  ASSERT_EQ(Status::ErrorCreateKeyEmptyUsages(),
+            GenerateSecretKey(CreateAesCbcKeyGenAlgorithm(128), true, 0, &key));
+}
+
 // Generate an AES-CBC key and an RSA key pair. Use the AES-CBC key to wrap the
 // key pair (using SPKI format for public key, PKCS8 format for private key).
 // Then unwrap the wrapped key pair and verify that the key data is the same.
 TEST(WebCryptoAesCbcTest, WrapUnwrapRoundtripSpkiPkcs8) {
   if (!SupportsRsaPrivateKeyImport())
     return;
 
   // Generate the wrapping key.
   blink::WebCryptoKey wrapping_key;
   ASSERT_EQ(Status::Success(),
             GenerateSecretKey(CreateAesCbcKeyGenAlgorithm(128), true,
                               blink::WebCryptoKeyUsageWrapKey |
                                   blink::WebCryptoKeyUsageUnwrapKey,
                               &wrapping_key));
 
   // Generate an RSA key pair to be wrapped.
   const unsigned int modulus_length = 256;
   const std::vector<uint8_t> public_exponent = HexStringToBytes("010001");
 
   blink::WebCryptoKey public_key;
   blink::WebCryptoKey private_key;
   ASSERT_EQ(Status::Success(),
             GenerateKeyPair(CreateRsaHashedKeyGenAlgorithm(
                                 blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                 blink::WebCryptoAlgorithmIdSha256,
                                 modulus_length, public_exponent),
-                            true, 0, &public_key, &private_key));
+                            true, blink::WebCryptoKeyUsageSign, &public_key,
+                            &private_key));
 
   // Export key pair as SPKI + PKCS8
   std::vector<uint8_t> public_key_spki;
   ASSERT_EQ(Status::Success(), ExportKey(blink::WebCryptoKeyFormatSpki,
                                          public_key, &public_key_spki));
 
   std::vector<uint8_t> private_key_pkcs8;
   ASSERT_EQ(Status::Success(), ExportKey(blink::WebCryptoKeyFormatPkcs8,
                                          private_key, &private_key_pkcs8));
 
@@ skipping 22 matching lines @@
       Status::Success(),
       UnwrapKey(blink::WebCryptoKeyFormatSpki, CryptoData(wrapped_public_key),
                 wrapping_key, wrap_algorithm, rsa_import_algorithm, true, 0,
                 &unwrapped_public_key));
 
   blink::WebCryptoKey unwrapped_private_key;
 
   ASSERT_EQ(
       Status::Success(),
       UnwrapKey(blink::WebCryptoKeyFormatPkcs8, CryptoData(wrapped_private_key),
-                wrapping_key, wrap_algorithm, rsa_import_algorithm, true, 0,
-                &unwrapped_private_key));
+                wrapping_key, wrap_algorithm, rsa_import_algorithm, true,
+                blink::WebCryptoKeyUsageSign, &unwrapped_private_key));
 
   // Export unwrapped key pair as SPKI + PKCS8
   std::vector<uint8_t> unwrapped_public_key_spki;
   ASSERT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatSpki, unwrapped_public_key,
                       &unwrapped_public_key_spki));
 
   std::vector<uint8_t> unwrapped_private_key_pkcs8;
   ASSERT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatPkcs8, unwrapped_private_key,
                       &unwrapped_private_key_pkcs8));
 
   EXPECT_EQ(public_key_spki, unwrapped_public_key_spki);
   EXPECT_EQ(private_key_pkcs8, unwrapped_private_key_pkcs8);
 
   EXPECT_NE(public_key_spki, wrapped_public_key);
   EXPECT_NE(private_key_pkcs8, wrapped_private_key);
 }
 
 }  // namespace
 
 }  // namespace webcrypto
 
 }  // namespace content