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 245 matching lines @@
        ++key_length_i) {
     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));
+                    CreateAesCbcKeyGenAlgorithm(kKeyLength[key_length_i]), true,
+                    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 675 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,
+                                modulus_length, public_exponent),
+                            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(
@@ skipping 33 matching lines @@
                       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));
+  ASSERT_EQ(
+      Status::Success(),
+      UnwrapKey(blink::WebCryptoKeyFormatPkcs8, CryptoData(wrapped_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