Refactor the interface for generating keys.

content/child/webcrypto/test/rsa_ssa_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/logging.h"
 #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"
@@ skipping 526 matching lines @@
       CreateRsaHashedKeyGenAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                      blink::WebCryptoAlgorithmIdSha256,
                                      modulus_length,
                                      public_exponent);
   bool extractable = true;
   const blink::WebCryptoKeyUsageMask usage_mask = 0;
   blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
   blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
 
   EXPECT_EQ(Status::Success(),
-            GenerateKeyPair(
+            GenerateKey(
                 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());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdSha256,
@@ skipping 45 matching lines @@
               private_key.algorithm().rsaHashedParams()->modulusLengthBits());
   }
 
   // Fail with bad modulus.
   algorithm =
       CreateRsaHashedKeyGenAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                      blink::WebCryptoAlgorithmIdSha256,
                                      0,
                                      public_exponent);
   EXPECT_EQ(Status::ErrorGenerateRsaUnsupportedModulus(),
-            GenerateKeyPair(
+            GenerateKey(
                 algorithm, extractable, usage_mask, &public_key, &private_key));
 
   // Fail with bad exponent: larger than unsigned long.
   unsigned int exponent_length = sizeof(unsigned long) + 1;  // NOLINT
   const std::vector<uint8_t> long_exponent(exponent_length, 0x01);
   algorithm =
       CreateRsaHashedKeyGenAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                      blink::WebCryptoAlgorithmIdSha256,
                                      modulus_length,
                                      long_exponent);
   EXPECT_EQ(Status::ErrorGenerateKeyPublicExponent(),
-            GenerateKeyPair(
+            GenerateKey(
                 algorithm, extractable, usage_mask, &public_key, &private_key));
 
   // Fail with bad exponent: empty.
   const std::vector<uint8_t> empty_exponent;
   algorithm =
       CreateRsaHashedKeyGenAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                      blink::WebCryptoAlgorithmIdSha256,
                                      modulus_length,
                                      empty_exponent);
   EXPECT_EQ(Status::ErrorGenerateKeyPublicExponent(),
-            GenerateKeyPair(
+            GenerateKey(
                 algorithm, extractable, usage_mask, &public_key, &private_key));
 
   // Fail with bad exponent: all zeros.
   std::vector<uint8_t> exponent_with_leading_zeros(15, 0x00);
   algorithm =
       CreateRsaHashedKeyGenAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                      blink::WebCryptoAlgorithmIdSha256,
                                      modulus_length,
                                      exponent_with_leading_zeros);
   EXPECT_EQ(Status::ErrorGenerateKeyPublicExponent(),
-            GenerateKeyPair(
+            GenerateKey(
                 algorithm, extractable, usage_mask, &public_key, &private_key));
 
   // Key generation success using exponent with leading zeros.
   exponent_with_leading_zeros.insert(exponent_with_leading_zeros.end(),
                                      public_exponent.begin(),
                                      public_exponent.end());
   algorithm =
       CreateRsaHashedKeyGenAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                      blink::WebCryptoAlgorithmIdSha256,
                                      modulus_length,
                                      exponent_with_leading_zeros);
   EXPECT_EQ(Status::Success(),
-            GenerateKeyPair(
+            GenerateKey(
                 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 WebCryptoAlgorithmIdRsaSsaPkcs1v1_5 key generation (sha1)
   algorithm =
       CreateRsaHashedKeyGenAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                      blink::WebCryptoAlgorithmIdSha1,
                                      modulus_length,
                                      public_exponent);
   EXPECT_EQ(
       Status::Success(),
-      GenerateKeyPair(algorithm, false, usage_mask, &public_key, &private_key));
+      GenerateKey(algorithm, false, 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());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdSha1,
             public_key.algorithm().rsaHashedParams()->hash().id());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdSha1,
             private_key.algorithm().rsaHashedParams()->hash().id());
   // Even though "extractable" was set to false, the public key remains
   // extractable.
   EXPECT_TRUE(public_key.extractable());
   EXPECT_FALSE(private_key.extractable());
   EXPECT_EQ(usage_mask, public_key.usages());
   EXPECT_EQ(usage_mask, private_key.usages());
 
   // Exporting a private key as SPKI format doesn't make sense. However this
   // will first fail because the key is not extractable.
   std::vector<uint8_t> output;
   EXPECT_EQ(Status::ErrorKeyNotExtractable(),
             ExportKey(blink::WebCryptoKeyFormatSpki, private_key, &output));
 
   // Re-generate an extractable private_key and try to export it as SPKI format.
   // This should fail since spki is for public keys.
   EXPECT_EQ(
       Status::Success(),
-      GenerateKeyPair(algorithm, true, usage_mask, &public_key, &private_key));
+      GenerateKey(algorithm, true, usage_mask, &public_key, &private_key));
   EXPECT_EQ(Status::ErrorUnexpectedKeyType(),
             ExportKey(blink::WebCryptoKeyFormatSpki, private_key, &output));
 }
 
 TEST(WebCryptoRsaSsaTest, GenerateKeyPairRsaBadModulusLength) {
   const unsigned int kBadModulusBits[] = {
       0,
       248,         // Too small.
       257,         // Not a multiple of 8.
       1023,        // Not a multiple of 8.
@@ skipping 10 matching lines @@
         blink::WebCryptoAlgorithmIdSha256,
         modulus_length_bits,
         public_exponent);
     bool extractable = true;
     const blink::WebCryptoKeyUsageMask usage_mask = 0;
     blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
     blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
 
     EXPECT_EQ(
         Status::ErrorGenerateRsaUnsupportedModulus(),
-        GenerateKeyPair(
+        GenerateKey(
             algorithm, extractable, usage_mask, &public_key, &private_key));
   }
 }
 
 // Try generating RSA key pairs using unsupported public exponents. Only
 // exponents of 3 and 65537 are supported. While both OpenSSL and NSS can
 // support other values, OpenSSL hangs when given invalid exponents, so use a
 // whitelist to validate the parameters.
 TEST(WebCryptoRsaSsaTest, GenerateKeyPairRsaBadExponent) {
   const unsigned int modulus_length = 1024;
 
   const char* const kPublicExponents[] = {
       "11",  // 17 - This is a valid public exponent, but currently disallowed.
       "00",     "01", "02",
       "010000",  // 65536
   };
 
   for (size_t i = 0; i < arraysize(kPublicExponents); ++i) {
     SCOPED_TRACE(i);
     blink::WebCryptoAlgorithm algorithm = CreateRsaHashedKeyGenAlgorithm(
         blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
         blink::WebCryptoAlgorithmIdSha256,
         modulus_length,
         HexStringToBytes(kPublicExponents[i]));
 
     blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
     blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
 
     EXPECT_EQ(Status::ErrorGenerateKeyPublicExponent(),
-              GenerateKeyPair(algorithm, true, 0, &public_key, &private_key));
+              GenerateKey(algorithm, true, 0, &public_key, &private_key));
   }
 }
 
 TEST(WebCryptoRsaSsaTest, SignVerifyFailures) {
   if (!SupportsRsaPrivateKeyImport())
     return;
 
   // Import a key pair.
   blink::WebCryptoAlgorithm import_algorithm =
       CreateRsaHashedImportAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
@@ skipping 247 matching lines @@
   const unsigned int modulus_length = 256;
   const std::vector<uint8_t> public_exponent = HexStringToBytes("010001");
 
   for (size_t i = 0; i < arraysize(bad_usages); ++i) {
     SCOPED_TRACE(i);
 
     blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
     blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
 
     ASSERT_EQ(Status::ErrorCreateKeyBadUsages(),
-              GenerateKeyPair(CreateRsaHashedKeyGenAlgorithm(
-                                  blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
-                                  blink::WebCryptoAlgorithmIdSha256,
-                                  modulus_length,
-                                  public_exponent),
-                              true,
-                              bad_usages[i],
-                              &public_key,
-                              &private_key));
+              GenerateKey(CreateRsaHashedKeyGenAlgorithm(
+                              blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
+                              blink::WebCryptoAlgorithmIdSha256,
+                              modulus_length,
+                              public_exponent),
+                          true,
+                          bad_usages[i],
+                          &public_key,
+                          &private_key));
   }
 }
 
 // Generate an RSA-SSA key pair. The public and private keys should select the
 // key usages which are applicable, and not have the exact same usages as was
 // specified to GenerateKey
 TEST(WebCryptoRsaSsaTest, GenerateKeyPairIntersectUsages) {
   const unsigned int modulus_length = 256;
   const std::vector<uint8_t> public_exponent = HexStringToBytes("010001");
 
   blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
   blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
 
-  ASSERT_EQ(Status::Success(),
-            GenerateKeyPair(
-                CreateRsaHashedKeyGenAlgorithm(
-                    blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
-                    blink::WebCryptoAlgorithmIdSha256,
-                    modulus_length,
-                    public_exponent),
-                true,
-                blink::WebCryptoKeyUsageSign | blink::WebCryptoKeyUsageVerify,
-                &public_key,
-                &private_key));
+  ASSERT_EQ(
+      Status::Success(),
+      GenerateKey(CreateRsaHashedKeyGenAlgorithm(
+                      blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
+                      blink::WebCryptoAlgorithmIdSha256,
+                      modulus_length,
+                      public_exponent),
+                  true,
+                  blink::WebCryptoKeyUsageSign | blink::WebCryptoKeyUsageVerify,
+                  &public_key,
+                  &private_key));
 
   EXPECT_EQ(blink::WebCryptoKeyUsageVerify, public_key.usages());
   EXPECT_EQ(blink::WebCryptoKeyUsageSign, private_key.usages());
 
   // Try again but this time without the Verify usages.
   ASSERT_EQ(Status::Success(),
-            GenerateKeyPair(CreateRsaHashedKeyGenAlgorithm(
-                                blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
-                                blink::WebCryptoAlgorithmIdSha256,
-                                modulus_length,
-                                public_exponent),
-                            true,
-                            blink::WebCryptoKeyUsageSign,
-                            &public_key,
-                            &private_key));
+            GenerateKey(CreateRsaHashedKeyGenAlgorithm(
+                            blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
+                            blink::WebCryptoAlgorithmIdSha256,
+                            modulus_length,
+                            public_exponent),
+                        true,
+                        blink::WebCryptoKeyUsageSign,
+                        &public_key,
+                        &private_key));
 
   EXPECT_EQ(0, public_key.usages());
   EXPECT_EQ(blink::WebCryptoKeyUsageSign, private_key.usages());
 }
 
 TEST(WebCryptoRsaSsaTest, ImportExportJwkRsaPublicKey) {
   struct TestCase {
     const blink::WebCryptoAlgorithmId hash;
     const blink::WebCryptoKeyUsageMask usage;
     const char* const jwk_alg;
@@ skipping 104 matching lines @@
               ImportKeyJwkFromDict(dict, algorithm, false, usage_mask, &key));
     RestoreJwkRsaDictionary(&dict);
   }
 }
 
 }  // namespace
 
 }  // namespace webcrypto
 
 }  // namespace content