[webcrypto] Fix AES-KW unwrapping for symmetric keys (NSS).

content/child/webcrypto/shared_crypto_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 "content/child/webcrypto/shared_crypto.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 2767 matching lines @@
                   CryptoData(test_ciphertext),
                   wrapping_key,
                   wrapping_algorithm,
                   webcrypto::CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc),
                   true,
                   blink::WebCryptoKeyUsageEncrypt,
                   &unwrapped_key));
     EXPECT_FALSE(key.isNull());
     EXPECT_TRUE(key.handle());
     EXPECT_EQ(blink::WebCryptoKeyTypeSecret, key.type());
-    EXPECT_EQ(
-        webcrypto::CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc).id(),
-        key.algorithm().id());
+    EXPECT_EQ(blink::WebCryptoAlgorithmIdAesCbc, key.algorithm().id());
     EXPECT_EQ(true, key.extractable());
     EXPECT_EQ(blink::WebCryptoKeyUsageEncrypt, key.usages());
 
     // Export the new key and compare its raw bytes with the original known key.
     std::vector<uint8> raw_key;
     EXPECT_EQ(Status::Success(),
               ExportKey(blink::WebCryptoKeyFormatRaw, unwrapped_key, &raw_key));
     EXPECT_BYTES_EQ(test_key, raw_key);
   }
 }
 
+// Unwrap a HMAC key using AES-KW, and then try signing using the unwrapped key.

[Ryan Sleevi, 2014/05/08 00:58:44]

"then try doing a sign/verify with the unwrapped key"

[eroman, 2014/05/08 01:02:40]

Done.

+TEST_F(SharedCryptoTest, MAYBE(AesKwRawSymkeyUnwrapSignVerifyHmac)) {
+  scoped_ptr<base::ListValue> tests;
+  ASSERT_TRUE(ReadJsonTestFileToList("aes_kw.json", &tests));
+
+  base::DictionaryValue* test;
+  ASSERT_TRUE(tests->GetDictionary(0, &test));
+  const std::vector<uint8> test_kek = GetBytesFromHexString(test, "kek");
+  const std::vector<uint8> test_ciphertext =
+      GetBytesFromHexString(test, "ciphertext");
+  const blink::WebCryptoAlgorithm wrapping_algorithm =
+      CreateAlgorithm(blink::WebCryptoAlgorithmIdAesKw);
+
+  // Import the wrapping key.
+  blink::WebCryptoKey wrapping_key = ImportSecretKeyFromRaw(
+      test_kek, wrapping_algorithm, blink::WebCryptoKeyUsageUnwrapKey);
+
+  // Unwrap the known ciphertext.
+  blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
+  ASSERT_EQ(
+      Status::Success(),
+      UnwrapKey(blink::WebCryptoKeyFormatRaw,
+                CryptoData(test_ciphertext),
+                wrapping_key,
+                wrapping_algorithm,
+                CreateHmacImportAlgorithm(blink::WebCryptoAlgorithmIdSha1),
+                false,
+                blink::WebCryptoKeyUsageSign | blink::WebCryptoKeyUsageVerify,
+                &key));
+
+  EXPECT_EQ(blink::WebCryptoKeyTypeSecret, key.type());
+  EXPECT_EQ(blink::WebCryptoAlgorithmIdHmac, key.algorithm().id());
+  EXPECT_EQ(false, key.extractable());
+  EXPECT_EQ(blink::WebCryptoKeyUsageSign | blink::WebCryptoKeyUsageVerify,
+            key.usages());
+
+  // Sign an empty message and ensure it is verified.
+  std::vector<uint8> test_message;
+  std::vector<uint8> signature;
+
+  ASSERT_EQ(Status::Success(),
+            Sign(CreateAlgorithm(blink::WebCryptoAlgorithmIdHmac),
+                 key,
+                 CryptoData(test_message),
+                 &signature));
+
+  EXPECT_GT(signature.size(), 0u);
+
+  bool verify_result;
+  ASSERT_EQ(Status::Success(),
+            VerifySignature(CreateAlgorithm(blink::WebCryptoAlgorithmIdHmac),
+                            key,
+                            CryptoData(signature),
+                            CryptoData(test_message),
+                            &verify_result));
+}
+
 TEST_F(SharedCryptoTest, MAYBE(AesKwRawSymkeyWrapUnwrapErrors)) {
   scoped_ptr<base::ListValue> tests;
   ASSERT_TRUE(ReadJsonTestFileToList("aes_kw.json", &tests));
   base::DictionaryValue* test;
   // Use 256 bits of data with a 256-bit KEK
   ASSERT_TRUE(tests->GetDictionary(5, &test));
   const std::vector<uint8> test_kek = GetBytesFromHexString(test, "kek");
   const std::vector<uint8> test_key = GetBytesFromHexString(test, "key");
   const std::vector<uint8> test_ciphertext =
       GetBytesFromHexString(test, "ciphertext");
@@ skipping 607 matching lines @@
                       algorithm,
                       CreateAesCbcAlgorithm(std::vector<uint8>(0, 16)),
                       true,
                       blink::WebCryptoKeyUsageEncrypt,
                       &unwrapped_key));
 }
 
 }  // namespace webcrypto
 
 }  // namespace content