[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 49 matching lines @@
          a.error_details() == b.error_details();
 }
 
 bool operator!=(const content::webcrypto::Status& a,
                 const content::webcrypto::Status& b) {
   return !(a == b);
 }
 
 namespace {
 
+// -----------------------------------------------------------------------------
+// TODO(eroman): Remove these helpers and convert all of the tests to using the
+//               std::vector<> flavor of functions directly.
+// -----------------------------------------------------------------------------
+
+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 1788 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_EQ(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_EQ(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_EQ(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_EQ(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_EQ(
       Status::Success(),
       ImportKey(blink::WebCryptoKeyFormatSpki,
                 CryptoData(HexStringToBytes(kPublicKeySpkiDerHex)),
                 CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5),
                 true,
                 blink::WebCryptoKeyUsageEncrypt,
@@ skipping 233 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_EQ(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,
@@ skipping 1252 matching lines @@
                       algorithm,
                       CreateAesCbcAlgorithm(std::vector<uint8>(0, 16)),
                       true,
                       blink::WebCryptoKeyUsageEncrypt,
                       &unwrapped_key));
 }
 
 }  // namespace webcrypto
 
 }  // namespace content