[webcrypto] Make operations run on worker threads.

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 34 matching lines @@
   ASSERT_EQ(expected.ToString(), (code).ToString())
 #define EXPECT_STATUS_SUCCESS(code) EXPECT_STATUS(Status::Success(), code)
 #define ASSERT_STATUS_SUCCESS(code) ASSERT_STATUS(Status::Success(), code)
 
 namespace content {
 
 namespace webcrypto {
 
 namespace {
 
+// -----------------------------------------------------------------------------
+// TODO(eroman): Remove these helpers and convert all of the tests to using the
+//               std::vector<> flavor of functions directly.

[Ryan Sleevi, 2014/04/18 00:51:26]

At the risk of being a PITA, can you rename the functions, rather than overload?
Seeing Encrypt call Encrypt is surprising, and I had to dig through the impl to
see that, ah yes, the function args are different.

EncryptVector / EncryptWebArrayBuffer, even though that will cause churn, I
know.

[eroman, 2014/04/18 18:45:56]

Agreed. My plan is to refactor the tests to call the std::vector<> version
directly before committing. I wanted to reach agreement that switching to
std::vector<> is the right approach before doing that though.

+// -----------------------------------------------------------------------------
+
+blink::WebArrayBuffer CreateArrayBuffer(const uint8* data,
+                                        unsigned int data_size) {
+  blink::WebArrayBuffer buffer = blink::WebArrayBuffer::create(data_size, 1);
+  DCHECK(!buffer.isNull());
+  if (data_size)  // data_size == 0 might mean the data pointer is invalid
+    memcpy(buffer.data(), data, data_size);
+  return buffer;
+}
+
+void AssignWebArrayBuffer(const std::vector<uint8>& in,
+                          blink::WebArrayBuffer* out) {
+  *out = CreateArrayBuffer(Uint8VectorStart(in), in.size());
+}
+
+Status Encrypt(const blink::WebCryptoAlgorithm& algorithm,
+               const blink::WebCryptoKey& key,
+               const CryptoData& data,
+               blink::WebArrayBuffer* web_buffer) {
+  std::vector<uint8> buffer;
+  Status status = Encrypt(algorithm, key, data, &buffer);
+  AssignWebArrayBuffer(buffer, web_buffer);
+  return status;
+}
+
+Status Decrypt(const blink::WebCryptoAlgorithm& algorithm,
+               const blink::WebCryptoKey& key,
+               const CryptoData& data,
+               blink::WebArrayBuffer* web_buffer) {
+  std::vector<uint8> buffer;
+  Status status = Decrypt(algorithm, key, data, &buffer);
+  AssignWebArrayBuffer(buffer, web_buffer);
+  return status;
+}
+
+Status Digest(const blink::WebCryptoAlgorithm& algorithm,
+              const CryptoData& data,
+              blink::WebArrayBuffer* web_buffer) {
+  std::vector<uint8> buffer;
+  Status status = Digest(algorithm, data, &buffer);
+  AssignWebArrayBuffer(buffer, web_buffer);
+  return status;
+}
+
+Status ExportKey(blink::WebCryptoKeyFormat format,
+                 const blink::WebCryptoKey& key,
+                 blink::WebArrayBuffer* web_buffer) {
+  std::vector<uint8> buffer;
+  Status status = webcrypto::ExportKey(format, key, &buffer);
+  AssignWebArrayBuffer(buffer, web_buffer);
+  return status;
+}
+
+Status Sign(const blink::WebCryptoAlgorithm& algorithm,
+            const blink::WebCryptoKey& key,
+            const CryptoData& data,
+            blink::WebArrayBuffer* web_buffer) {
+  std::vector<uint8> buffer;
+
+  Status status = Sign(algorithm, key, data, &buffer);
+  AssignWebArrayBuffer(buffer, web_buffer);
+  return status;
+}
+
+Status WrapKey(blink::WebCryptoKeyFormat format,
+               const blink::WebCryptoKey& wrapping_key,
+               const blink::WebCryptoKey& key_to_wrap,
+               const blink::WebCryptoAlgorithm& wrapping_algorithm,
+               blink::WebArrayBuffer* web_buffer) {
+  std::vector<uint8> buffer;
+
+  Status status = webcrypto::WrapKey(
+      format, wrapping_key, key_to_wrap, wrapping_algorithm, &buffer);
+  AssignWebArrayBuffer(buffer, web_buffer);
+  return status;
+}
+
+// -----------------------------------------------------------------------------
+
 // TODO(eroman): For Linux builds using system NSS, AES-GCM support is a
 // runtime dependency. Test it by trying to import a key.
 // TODO(padolph): Consider caching the result of the import key test.
 bool SupportsAesGcm() {
   std::vector<uint8> key_raw(16, 0);
 
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   Status status = ImportKey(blink::WebCryptoKeyFormatRaw,
                             CryptoData(key_raw),
                             CreateAlgorithm(blink::WebCryptoAlgorithmIdAesGcm),
@@ skipping 1719 matching lines @@
     EXPECT_EQ(test.usage, key.usages());
 
     // Export the key in raw format and compare to the original.
     blink::WebArrayBuffer key_raw_out;
     ASSERT_STATUS_SUCCESS(
         ExportKey(blink::WebCryptoKeyFormatRaw, key, &key_raw_out));
     ExpectArrayBufferMatchesHex(test.key_hex, key_raw_out);
   }
 }
 
+TEST_F(SharedCryptoTest, MAYBE(ExportJwkEmptySymmetricKey)) {
+  const blink::WebCryptoAlgorithm import_algorithm =
+      webcrypto::CreateHmacImportAlgorithm(blink::WebCryptoAlgorithmIdSha1);
+
+  blink::WebCryptoKeyUsageMask usages = blink::WebCryptoKeyUsageSign;
+  blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
+
+  // Import a zero-byte HMAC key.
+  const char key_data_hex[] = "";
+  key = ImportSecretKeyFromRaw(
+      HexStringToBytes(key_data_hex), import_algorithm, usages);
+  EXPECT_EQ(0u, key.algorithm().hmacParams()->lengthBits());
+
+  // Export the key in JWK format and validate.
+  blink::WebArrayBuffer json;
+  ASSERT_STATUS_SUCCESS(ExportKey(blink::WebCryptoKeyFormatJwk, key, &json));
+  EXPECT_TRUE(VerifySecretJwk(json, "HS1", key_data_hex, usages));
+
+  // Now try re-importing the JWK key.
+  key = blink::WebCryptoKey::createNull();
+  EXPECT_STATUS_SUCCESS(ImportKey(blink::WebCryptoKeyFormatJwk,
+                                  CryptoData(json),
+                                  import_algorithm,
+                                  true,
+                                  usages,
+                                  &key));
+
+  EXPECT_EQ(blink::WebCryptoKeyTypeSecret, key.type());
+  EXPECT_EQ(0u, key.algorithm().hmacParams()->lengthBits());
+
+  blink::WebArrayBuffer exported_key_data;
+  EXPECT_STATUS_SUCCESS(
+      ExportKey(blink::WebCryptoKeyFormatRaw, key, &exported_key_data));
+
+  EXPECT_EQ(0u, exported_key_data.byteLength());
+}
+
 TEST_F(SharedCryptoTest, MAYBE(ImportExportSpki)) {
   // Passing case: Import a valid RSA key in SPKI format.
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   ASSERT_STATUS_SUCCESS(
       ImportKey(blink::WebCryptoKeyFormatSpki,
                 CryptoData(HexStringToBytes(kPublicKeySpkiDerHex)),
                 CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5),
                 true,
                 blink::WebCryptoKeyUsageEncrypt,
                 &key));
@@ skipping 226 matching lines @@
       algorithm, extractable, usage_mask, &public_key, &private_key));
   EXPECT_FALSE(public_key.isNull());
   EXPECT_FALSE(private_key.isNull());
   EXPECT_EQ(blink::WebCryptoKeyTypePublic, public_key.type());
   EXPECT_EQ(blink::WebCryptoKeyTypePrivate, private_key.type());
   EXPECT_TRUE(public_key.extractable());
   EXPECT_EQ(extractable, private_key.extractable());
   EXPECT_EQ(usage_mask, public_key.usages());
   EXPECT_EQ(usage_mask, private_key.usages());
 
-  // Successful WebCryptoAlgorithmIdRsaOaep key generation.
-  algorithm = CreateRsaHashedKeyGenAlgorithm(blink::WebCryptoAlgorithmIdRsaOaep,
-                                             blink::WebCryptoAlgorithmIdSha256,
-                                             modulus_length,
-                                             public_exponent);
+  // Successful WebCryptoAlgorithmIdRsaSsaPkcs1v1_5 key generation (sha256)
+  algorithm =
+      CreateRsaHashedKeyGenAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
+                                     blink::WebCryptoAlgorithmIdSha256,
+                                     modulus_length,
+                                     public_exponent);
   EXPECT_STATUS_SUCCESS(GenerateKeyPair(
       algorithm, extractable, usage_mask, &public_key, &private_key));
   EXPECT_FALSE(public_key.isNull());
   EXPECT_FALSE(private_key.isNull());
   EXPECT_EQ(blink::WebCryptoKeyTypePublic, public_key.type());
   EXPECT_EQ(blink::WebCryptoKeyTypePrivate, private_key.type());
   EXPECT_EQ(modulus_length,
             public_key.algorithm().rsaHashedParams()->modulusLengthBits());
   EXPECT_EQ(modulus_length,
             private_key.algorithm().rsaHashedParams()->modulusLengthBits());
@@ skipping 1205 matching lines @@
                           algorithm,
                           CreateAesCbcAlgorithm(std::vector<uint8>(0, 16)),
                           true,
                           blink::WebCryptoKeyUsageEncrypt,
                           &unwrapped_key));
 }
 
 }  // namespace webcrypto
 
 }  // namespace content