[webcrypto] Refactor to allow for unspecified "algorithm" to importKey().

content/renderer/webcrypto/webcrypto_impl_unittest.cc

 // Copyright 2013 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 "webcrypto_impl.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/renderer/renderer_webkitplatformsupport_impl.h"
 #include "content/renderer/webcrypto/webcrypto_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebArrayBuffer.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithm.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
 
 namespace {
 
+WebKit::WebCryptoKey NullKey() {
+  // TODO(eroman): Expose this in Blink instead.
+  return WebKit::WebCryptoKey::create(NULL, WebKit::WebCryptoKeyTypeSecret,
+                                      false,
+                                      WebKit::WebCryptoAlgorithm::createNull(),
+                                      0);
+}
+
 std::vector<uint8> HexStringToBytes(const std::string& hex) {
   std::vector<uint8> bytes;
   base::HexStringToBytes(hex, &bytes);
   return bytes;
 }
 
 void ExpectArrayBufferMatchesHex(const std::string& expected_hex,
                                  const WebKit::WebArrayBuffer& array_buffer) {
   EXPECT_STRCASEEQ(
       expected_hex.c_str(),
@@ skipping 49 matching lines @@
 }  // namespace
 
 namespace content {
 
 class WebCryptoImplTest : public testing::Test {
  protected:
   WebKit::WebCryptoKey ImportSecretKeyFromRawHexString(
       const std::string& key_hex,
       const WebKit::WebCryptoAlgorithm& algorithm,
       WebKit::WebCryptoKeyUsageMask usage) {
-    WebKit::WebCryptoKeyType type;
-    scoped_ptr<WebKit::WebCryptoKeyHandle> handle;
-
     std::vector<uint8> key_raw = HexStringToBytes(key_hex);
 
+    WebKit::WebCryptoKey key = NullKey();
+    bool extractable = true;
     EXPECT_TRUE(crypto_.ImportKeyInternal(WebKit::WebCryptoKeyFormatRaw,
                                           Start(key_raw),
                                           key_raw.size(),
                                           algorithm,
+                                          extractable,
                                           usage,
-                                          &handle,
-                                          &type));
+                                          &key));
 
-    EXPECT_EQ(WebKit::WebCryptoKeyTypeSecret, type);
-    EXPECT_TRUE(handle.get());
-
-    return WebKit::WebCryptoKey::create(
-        handle.release(), type, false, algorithm, usage);
+    EXPECT_EQ(WebKit::WebCryptoKeyTypeSecret, key.type());
+    EXPECT_TRUE(key.handle());
+    return key;
   }
 
   // Forwarding methods to gain access to protected methods of
   // WebCryptoImpl.
 
   bool DigestInternal(
       const WebKit::WebCryptoAlgorithm& algorithm,
       const std::vector<uint8>& data,
       WebKit::WebArrayBuffer* buffer) {
     return crypto_.DigestInternal(algorithm, Start(data), data.size(), buffer);
   }
 
   bool GenerateKeyInternal(
       const WebKit::WebCryptoAlgorithm& algorithm,
-      scoped_ptr<WebKit::WebCryptoKeyHandle>* handle,
-      WebKit::WebCryptoKeyType* type) {
-    return crypto_.GenerateKeyInternal(algorithm, handle, type);
+      WebKit::WebCryptoKey* key) {
+    bool extractable = true;
+    WebKit::WebCryptoKeyUsageMask usage_mask = 0;
+    return crypto_.GenerateKeyInternal(algorithm, extractable, usage_mask, key);
   }
 
   bool ImportKeyInternal(
       WebKit::WebCryptoKeyFormat format,
       const std::vector<uint8>& key_data,
       const WebKit::WebCryptoAlgorithm& algorithm,
       WebKit::WebCryptoKeyUsageMask usage_mask,
-      scoped_ptr<WebKit::WebCryptoKeyHandle>* handle,
-      WebKit::WebCryptoKeyType* type) {
+      WebKit::WebCryptoKey* key) {
+    bool extractable = true;
     return crypto_.ImportKeyInternal(format,
                                      Start(key_data),
                                      key_data.size(),
                                      algorithm,
+                                     extractable,
                                      usage_mask,
-                                     handle,
-                                     type);
+                                     key);
   }
 
   bool SignInternal(
       const WebKit::WebCryptoAlgorithm& algorithm,
       const WebKit::WebCryptoKey& key,
       const std::vector<uint8>& data,
       WebKit::WebArrayBuffer* buffer) {
     return crypto_.SignInternal(
         algorithm, key, Start(data), data.size(), buffer);
   }
@@ skipping 314 matching lines @@
     unsigned input_len = INT_MAX - 3;
 
     EXPECT_FALSE(EncryptInternal(
         CreateAesCbcAlgorithm(iv), key, input, input_len, &output));
     EXPECT_FALSE(DecryptInternal(
         CreateAesCbcAlgorithm(iv), key, input, input_len, &output));
   }
 
   // Fail importing the key (too few bytes specified)
   {
-    WebKit::WebCryptoKeyType type;
-    scoped_ptr<WebKit::WebCryptoKeyHandle> handle;
-
     std::vector<uint8> key_raw(1);
     std::vector<uint8> iv(16);
 
+    WebKit::WebCryptoKey key = NullKey();
     EXPECT_FALSE(ImportKeyInternal(WebKit::WebCryptoKeyFormatRaw,
                                    key_raw,
                                    CreateAesCbcAlgorithm(iv),
                                    WebKit::WebCryptoKeyUsageDecrypt,
-                                   &handle,
-                                   &type));
+                                   &key));
   }
 }
 
+
 TEST_F(WebCryptoImplTest, AesCbcSampleSets) {
   struct TestCase {
     const char* key;
     const char* iv;
     const char* plain_text;
     const char* cipher_text;
   };
 
   TestCase kTests[] = {
     // F.2.1 (CBC-AES128.Encrypt)
@@ skipping 115 matching lines @@
                                    cipher_text.size() - 3,
                                    &output));
     }
   }
 }
 
 // TODO (padolph): Add test to verify generated symmetric keys appear random.
 
 
 TEST_F(WebCryptoImplTest, GenerateKeyAes) {
-  scoped_ptr<WebKit::WebCryptoKeyHandle> result;
-  WebKit::WebCryptoKeyType type = WebKit::WebCryptoKeyTypePublic;
-  ASSERT_TRUE(GenerateKeyInternal(CreateAesCbcAlgorithm(128), &result, &type));
-  EXPECT_TRUE(result);
-  EXPECT_EQ(type, WebKit::WebCryptoKeyTypeSecret);
+  WebKit::WebCryptoKey key = NullKey();
+  ASSERT_TRUE(GenerateKeyInternal(CreateAesCbcAlgorithm(128), &key));
+  EXPECT_TRUE(key.handle());
+  EXPECT_EQ(WebKit::WebCryptoKeyTypeSecret, key.type());
 }
 
 TEST_F(WebCryptoImplTest, GenerateKeyAesBadLength) {
-  scoped_ptr<WebKit::WebCryptoKeyHandle> result;
-  WebKit::WebCryptoKeyType type = WebKit::WebCryptoKeyTypePublic;
-  EXPECT_FALSE(GenerateKeyInternal(CreateAesCbcAlgorithm(0), &result, &type));
-  EXPECT_FALSE(GenerateKeyInternal(CreateAesCbcAlgorithm(129), &result, &type));
+  WebKit::WebCryptoKey key = NullKey();
+  EXPECT_FALSE(GenerateKeyInternal(CreateAesCbcAlgorithm(0), &key));
+  EXPECT_FALSE(GenerateKeyInternal(CreateAesCbcAlgorithm(129), &key));
 }
 
 TEST_F(WebCryptoImplTest, GenerateKeyHmac) {
-  scoped_ptr<WebKit::WebCryptoKeyHandle> result;
-  WebKit::WebCryptoKeyType type = WebKit::WebCryptoKeyTypePublic;
+  WebKit::WebCryptoKey key = NullKey();
   WebKit::WebCryptoAlgorithm algorithm =
       CreateHmacKeyAlgorithm(WebKit::WebCryptoAlgorithmIdSha1, 128);
-  ASSERT_TRUE(GenerateKeyInternal(algorithm, &result, &type));
-  EXPECT_TRUE(result);
-  EXPECT_EQ(type, WebKit::WebCryptoKeyTypeSecret);
+  ASSERT_TRUE(GenerateKeyInternal(algorithm, &key));
+  EXPECT_TRUE(key.handle());
+  EXPECT_EQ(WebKit::WebCryptoKeyTypeSecret, key.type());
 }
 
 TEST_F(WebCryptoImplTest, GenerateKeyHmacNoLength) {
-  scoped_ptr<WebKit::WebCryptoKeyHandle> result;
-  WebKit::WebCryptoKeyType type = WebKit::WebCryptoKeyTypePublic;
+  WebKit::WebCryptoKey key = NullKey();
   WebKit::WebCryptoAlgorithm algorithm =
       CreateHmacKeyAlgorithm(WebKit::WebCryptoAlgorithmIdSha1, 0);
-  ASSERT_TRUE(GenerateKeyInternal(algorithm, &result, &type));
-  EXPECT_TRUE(result);
-  EXPECT_EQ(type, WebKit::WebCryptoKeyTypeSecret);
+  ASSERT_TRUE(GenerateKeyInternal(algorithm, &key));
+  EXPECT_TRUE(key.handle());
+  EXPECT_EQ(WebKit::WebCryptoKeyTypeSecret, key.type());
+}
+
+TEST_F(WebCryptoImplTest, ImportSecretKeyNoAlgorithm) {
+  WebKit::WebCryptoKey key = NullKey();
+
+  // This fails because the algorithm is null.
+  EXPECT_FALSE(ImportKeyInternal(
+      WebKit::WebCryptoKeyFormatRaw,
+      HexStringToBytes("00000000000000000000"),
+      WebKit::WebCryptoAlgorithm::createNull(),
+      WebKit::WebCryptoKeyUsageSign,
+      &key));
 }
 
 }  // namespace content