Add tests for RSA private key import using JWK when p and q are swapped.

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 40 matching lines @@
   EXPECT_TRUE(key.handle());
   EXPECT_EQ(blink::WebCryptoKeyTypePublic, key.type());
   EXPECT_TRUE(key.extractable());
   EXPECT_EQ(blink::WebCryptoKeyUsageVerify, key.usages());
   EXPECT_EQ(kModulusLengthBits,
             key.algorithm().rsaHashedParams()->modulusLengthBits());
   EXPECT_BYTES_EQ_HEX(
       "010001",
       CryptoData(key.algorithm().rsaHashedParams()->publicExponent()));
 
-  // Failing case: Empty SPKI data
-  EXPECT_EQ(
-      Status::ErrorImportEmptyKeyData(),
-      ImportKey(blink::WebCryptoKeyFormatSpki,
-                CryptoData(std::vector<uint8_t>()),
-                CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5),
-                true,
-                blink::WebCryptoKeyUsageVerify,
-                &key));
-
-  // Failing case: Bad DER encoding.
-  EXPECT_EQ(
-      Status::DataError(),
-      ImportKey(blink::WebCryptoKeyFormatSpki,
-                CryptoData(HexStringToBytes("618333c4cb")),
-                CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5),
-                true,
-                blink::WebCryptoKeyUsageVerify,
-                &key));
-
   // Failing case: Import RSA key but provide an inconsistent input algorithm.
   EXPECT_EQ(Status::ErrorUnsupportedImportKeyFormat(),
             ImportKey(blink::WebCryptoKeyFormatSpki,
                       CryptoData(HexStringToBytes(kPublicKeySpkiDerHex)),
                       CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc),
                       true,
                       blink::WebCryptoKeyUsageEncrypt,
                       &key));
 
   // Passing case: Export a previously imported RSA public key in SPKI format
@@ skipping 56 matching lines @@
             key.algorithm().rsaHashedParams()->modulusLengthBits());
   EXPECT_BYTES_EQ_HEX(
       "010001",
       CryptoData(key.algorithm().rsaHashedParams()->publicExponent()));
 
   std::vector<uint8_t> exported_key;
   ASSERT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatPkcs8, key, &exported_key));
   EXPECT_BYTES_EQ_HEX(kPrivateKeyPkcs8DerHex, exported_key);
 
-  // Failing case: Empty PKCS#8 data
-  EXPECT_EQ(Status::ErrorImportEmptyKeyData(),
-            ImportKey(blink::WebCryptoKeyFormatPkcs8,
-                      CryptoData(std::vector<uint8_t>()),
-                      CreateRsaHashedImportAlgorithm(
-                          blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
-                          blink::WebCryptoAlgorithmIdSha1),
-                      true,
-                      blink::WebCryptoKeyUsageSign,
-                      &key));
-
-  // Failing case: Bad DER encoding.
-  EXPECT_EQ(
-      Status::DataError(),
-      ImportKey(blink::WebCryptoKeyFormatPkcs8,
-                CryptoData(HexStringToBytes("618333c4cb")),
-                CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5),
-                true,
-                blink::WebCryptoKeyUsageSign,
-                &key));
-
   // Failing case: Import RSA key but provide an inconsistent input algorithm
   // and usage. Several issues here:
   //   * AES-CBC doesn't support PKCS8 key format
   //   * AES-CBC doesn't support "sign" usage
   EXPECT_EQ(Status::ErrorUnsupportedImportKeyFormat(),
             ImportKey(blink::WebCryptoKeyFormatPkcs8,
                       CryptoData(HexStringToBytes(kPrivateKeyPkcs8DerHex)),
                       CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc),
                       true,
                       blink::WebCryptoKeyUsageSign,
                       &key));
 }
 
 // Tests importing of PKCS8 data that does not define a valid RSA key.
+// TODO(eroman): Move to bad_rsa_keys.json
 TEST(WebCryptoRsaSsaTest, ImportInvalidPkcs8) {
   if (!SupportsRsaPrivateKeyImport())
     return;
 
   // kPrivateKeyPkcs8DerHex defines an RSA private key in PKCS8 format, whose
   // parameters appear at the following offsets:
   //
   //   n: (offset=36, len=129)
   //   e: (offset=167, len=3)
   //   d: (offset=173, len=128)
@@ skipping 222 matching lines @@
                                  &key2));
 }
 
 // Import a JWK RSA private key with some optional parameters missing (q, dp,
 // dq, qi).
 //
 // The only optional parameter included is "p".
 //
 // This fails because JWA says that producers must include either ALL optional
 // parameters or NONE.
+// TODO(eroman): Move to bad_rsa_keys.json
 TEST(WebCryptoRsaSsaTest, ImportRsaPrivateKeyJwkMissingOptionalParams) {
   blink::WebCryptoKey key;
 
   base::DictionaryValue dict;
   dict.SetString("kty", "RSA");
   dict.SetString("alg", "RS1");
 
   dict.SetString(
       "n",
       "pW5KDnAQF1iaUYfcfqhB0Vby7A42rVKkTf6x5h962ZHYxRBW_-2xYrTA8oOhKoijlN_"
@@ skipping 20 matching lines @@
                                  blink::WebCryptoKeyUsageSign,
                                  &key));
 }
 
 // Import a JWK RSA private key, without any of the optional parameters.
 //
 // According to JWA, such keys are valid, but applications SHOULD
 // include all the parameters when sending, and recipients MAY
 // accept them, but are not required to. Chromium's WebCrypto does
 // not allow such degenerate keys.
+// TODO(eroman): Move to bad_rsa_keys.json
 TEST(WebCryptoRsaSsaTest, ImportRsaPrivateKeyJwkIncorrectOptionalEmpty) {
   if (!SupportsRsaPrivateKeyImport())
     return;
 
   blink::WebCryptoKey key;
 
   base::DictionaryValue dict;
   dict.SetString("kty", "RSA");
   dict.SetString("alg", "RS1");
 
@@ skipping 13 matching lines @@
             ImportKeyJwkFromDict(dict,
                                  CreateRsaHashedImportAlgorithm(
                                      blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                      blink::WebCryptoAlgorithmIdSha1),
                                  true,
                                  blink::WebCryptoKeyUsageSign,
                                  &key));
 }
 
 // Tries importing a public RSA key whose exponent contains leading zeros.
+// TODO(eroman): Move to bad_rsa_keys.json
 TEST(WebCryptoRsaSsaTest, ImportJwkRsaNonMinimalExponent) {
   base::DictionaryValue dict;
 
   dict.SetString("kty", "RSA");
   dict.SetString("e", "AAEAAQ");  // 00 01 00 01
   dict.SetString(
       "n",
       "qLOyhK-OtQs4cDSoYPFGxJGfMYdjzWxVmMiuSBGh4KvEx-CwgtaTpef87Wdc9GaFEncsDLxk"
       "p0LGxjD1M8jMcvYq6DPEC_JYQumEu3i9v5fAEH1VvbZi9cTg-rmEXLUUjvc5LdOq_5OuHmtm"
       "e7PUJHYW1PW6ENTP0ibeiNOfFvs");
@@ skipping 702 matching lines @@
       ImportKey(blink::WebCryptoKeyFormatJwk,
                 bad_data,
                 CreateRsaHashedImportAlgorithm(
                     blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                     blink::WebCryptoAlgorithmIdSha256),
                 true,
                 blink::WebCryptoKeyUsageVerify | blink::WebCryptoKeyUsageSign,
                 &key));
 }
 
+// Reads a key format string as used in bad_rsa_keys.json, and converts to a
+// WebCryptoKeyFormat.
+blink::WebCryptoKeyFormat GetKeyFormatForTestCase(
+    const base::DictionaryValue* test) {
+  std::string format;
+  EXPECT_TRUE(test->GetString("format", &format));
+  if (format == "jwk")
+    return blink::WebCryptoKeyFormatJwk;
+  else if (format == "pkcs8")
+    return blink::WebCryptoKeyFormatPkcs8;
+  else if (format == "spki")
+    return blink::WebCryptoKeyFormatSpki;
+
+  EXPECT_TRUE(false) << "Unrecognized key format: " << format;
+  return blink::WebCryptoKeyFormatRaw;
+}
+
+// Extracts the key data bytes from |test|, as it appears in bad_rsa_keys.json.
+std::vector<uint8_t> GetKeyDataForTestCase(
+    const base::DictionaryValue* test,
+    blink::WebCryptoKeyFormat key_format) {
+  if (key_format == blink::WebCryptoKeyFormatJwk) {
+    const base::DictionaryValue* json;
+    EXPECT_TRUE(test->GetDictionary("data", &json));
+    return MakeJsonVector(*json);
+  }
+  return GetBytesFromHexString(test, "data");
+}
+
+// Imports invalid JWK/SPKI/PKCS8 data and verifies that it fails as expected.
+TEST(WebCryptoRsaSsaTest, ImportInvalidKeyData) {
+  if (!SupportsRsaPrivateKeyImport())
+    return;
+
+  scoped_ptr<base::ListValue> tests;
+  ASSERT_TRUE(ReadJsonTestFileToList("bad_rsa_keys.json", &tests));
+
+  for (size_t test_index = 0; test_index < tests->GetSize(); ++test_index) {
+    SCOPED_TRACE(test_index);
+
+    const base::DictionaryValue* test;
+    ASSERT_TRUE(tests->GetDictionary(test_index, &test));
+
+    blink::WebCryptoKeyFormat key_format = GetKeyFormatForTestCase(test);
+    std::vector<uint8_t> key_data = GetKeyDataForTestCase(test, key_format);
+    std::string test_error;
+    ASSERT_TRUE(test->GetString("error", &test_error));
+
+    blink::WebCryptoKey key;
+    Status status = ImportKey(key_format, CryptoData(key_data),
+                              CreateRsaHashedImportAlgorithm(
+                                  blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
+                                  blink::WebCryptoAlgorithmIdSha256),
+                              true, 0, &key);
+    EXPECT_EQ(test_error, StatusToString(status));
+  }
+}
+
 }  // namespace
 
 }  // namespace webcrypto
 
 }  // namespace content