[webcrypto] Disable RSA key import for NSS versions less than 3.16.2.

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 104 matching lines @@
 
   if (status.IsError())
     EXPECT_EQ(blink::WebCryptoErrorTypeNotSupported, status.error_type());
   return status.IsSuccess();
 }
 
 bool SupportsRsaOaep() {
 #if defined(USE_OPENSSL)
   return false;
 #else
+  // TODO(eroman): Exclude version test for OS_CHROMEOS
 #if defined(USE_NSS)
   if (!NSS_VersionCheck("3.16.2"))
     return false;
 #endif
   crypto::ScopedPK11Slot slot(PK11_GetInternalKeySlot());
   return !!PK11_DoesMechanism(slot.get(), CKM_RSA_PKCS_OAEP);
 #endif
 }
 
+bool SupportsRsaKeyImport() {
+// TODO(eroman): Exclude version test for OS_CHROMEOS
+#if defined(USE_NSS)
+  if (!NSS_VersionCheck("3.16.2")) {
+    LOG(WARNING) << "RSA key import is not supported by this version of NSS. "
+                    "Skipping some tests";
+    return false;
+  }
+#endif
+  return true;
+}
+
 blink::WebCryptoAlgorithm CreateRsaHashedKeyGenAlgorithm(
     blink::WebCryptoAlgorithmId algorithm_id,
     const blink::WebCryptoAlgorithmId hash_id,
     unsigned int modulus_length,
     const std::vector<uint8>& public_exponent) {
   DCHECK(algorithm_id == blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5 ||
          algorithm_id == blink::WebCryptoAlgorithmIdRsaOaep);
   DCHECK(blink::WebCryptoAlgorithm::isHash(hash_id));
   return blink::WebCryptoAlgorithm::adoptParamsAndCreate(
       algorithm_id,
@@ skipping 1352 matching lines @@
 
   // Fail on k actual length (192 bits) inconsistent with the embedded JWK alg
   // value (128) for an AES key.
   dict.SetString("k", "dGhpcyAgaXMgIDI0ICBieXRlcyBsb25n");
   EXPECT_EQ(Status::ErrorJwkIncorrectKeyLength(),
             ImportKeyJwkFromDict(dict, algorithm, false, usage_mask, &key));
   RestoreJwkOctDictionary(&dict);
 }
 
 TEST_F(SharedCryptoTest, MAYBE(ImportExportJwkRsaPublicKey)) {
+  if (!SupportsRsaKeyImport())
+    return;
+
   const bool supports_rsa_oaep = SupportsRsaOaep();
   if (!supports_rsa_oaep) {
     LOG(WARNING) << "RSA-OAEP not supported on this platform. Skipping some"
                  << "tests.";
   }
 
   struct TestCase {
     const blink::WebCryptoAlgorithm algorithm;
     const blink::WebCryptoKeyUsageMask usage;
     const char* const jwk_alg;
@@ skipping 453 matching lines @@
   EXPECT_EQ(0u, key.algorithm().hmacParams()->lengthBits());
 
   std::vector<uint8> exported_key_data;
   EXPECT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatRaw, key, &exported_key_data));
 
   EXPECT_EQ(0u, exported_key_data.size());
 }
 
 TEST_F(SharedCryptoTest, MAYBE(ImportExportSpki)) {
+  if (!SupportsRsaKeyImport())
+    return;
+
   // 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)),
                       CreateRsaHashedImportAlgorithm(
                           blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                           blink::WebCryptoAlgorithmIdSha256),
                       true,
                       blink::WebCryptoKeyUsageVerify,
@@ skipping 66 matching lines @@
 
   // TODO(eroman): Failing test: Import a SPKI with an unrecognized hash OID
   // TODO(eroman): Failing test: Import a SPKI with invalid algorithm params
   // TODO(eroman): Failing test: Import a SPKI with inconsistent parameters
   // (e.g. SHA-1 in OID, SHA-256 in params)
   // TODO(eroman): Failing test: Import a SPKI for RSA-SSA, but with params
   // as OAEP/PSS
 }
 
 TEST_F(SharedCryptoTest, MAYBE(ImportExportPkcs8)) {
+  if (!SupportsRsaKeyImport())
+    return;
+
   // Passing case: Import a valid RSA key in PKCS#8 format.
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   ASSERT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatPkcs8,
                       CryptoData(HexStringToBytes(kPrivateKeyPkcs8DerHex)),
                       CreateRsaHashedImportAlgorithm(
                           blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                           blink::WebCryptoAlgorithmIdSha1),
                       true,
                       blink::WebCryptoKeyUsageSign,
@@ skipping 47 matching lines @@
                       true,
                       blink::WebCryptoKeyUsageSign,
                       &key));
 }
 
 // Tests JWK import and export by doing a roundtrip key conversion and ensuring
 // it was lossless:
 //
 //   PKCS8 --> JWK --> PKCS8
 TEST_F(SharedCryptoTest, MAYBE(ImportRsaPrivateKeyJwkToPkcs8RoundTrip)) {
+  if (!SupportsRsaKeyImport())
+    return;
+
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   ASSERT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatPkcs8,
                       CryptoData(HexStringToBytes(kPrivateKeyPkcs8DerHex)),
                       CreateRsaHashedImportAlgorithm(
                           blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                           blink::WebCryptoAlgorithmIdSha1),
                       true,
                       blink::WebCryptoKeyUsageSign,
                       &key));
@@ skipping 45 matching lines @@
 }
 
 // Tests importing multiple RSA private keys from JWK, and then exporting to
 // PKCS8.
 //
 // This is a regression test for http://crbug.com/378315, for which importing
 // a sequence of keys from JWK could yield the wrong key. The first key would
 // be imported correctly, however every key after that would actually import
 // the first key.
 TEST_F(SharedCryptoTest, MAYBE(ImportMultipleRSAPrivateKeysJwk)) {
+  if (!SupportsRsaKeyImport())
+    return;
+
   scoped_ptr<base::ListValue> key_list;
   ASSERT_TRUE(ReadJsonTestFileToList("rsa_private_keys.json", &key_list));
 
   // For this test to be meaningful the keys MUST be kept alive before importing
   // new keys.
   std::vector<blink::WebCryptoKey> live_keys;
 
   for (size_t key_index = 0; key_index < key_list->GetSize(); ++key_index) {
     SCOPED_TRACE(key_index);
 
@@ skipping 141 matching lines @@
                                  &key));
 }
 
 // Import a JWK RSA private key, without any of the optional parameters.
 //
 // This is expected to work, however based on the current NSS implementation it
 // does not.
 //
 // TODO(eroman): http://crbug/com/374927
 TEST_F(SharedCryptoTest, MAYBE(ImportRsaPrivateKeyJwkIncorrectOptionalEmpty)) {
+  if (!SupportsRsaKeyImport())
+    return;
+
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
 
   base::DictionaryValue dict;
   dict.SetString("kty", "RSA");
   dict.SetString("alg", "RS1");
 
   dict.SetString(
       "n",
       "pW5KDnAQF1iaUYfcfqhB0Vby7A42rVKkTf6x5h962ZHYxRBW_-2xYrTA8oOhKoijlN_"
       "1JqtykcuzB86r_OCx39XNlQgJbVsri2311nHvY3fAkhyyPCcKcOJZjm_4nRnxBazC0_"
@@ skipping 55 matching lines @@
   EXPECT_EQ(extractable, private_key.extractable());
   EXPECT_EQ(usage_mask, public_key.usages());
   EXPECT_EQ(usage_mask, private_key.usages());
 
   // Try exporting the generated key pair, and then re-importing to verify that
   // the exported data was valid.
   std::vector<uint8> public_key_spki;
   EXPECT_EQ(
       Status::Success(),
       ExportKey(blink::WebCryptoKeyFormatSpki, public_key, &public_key_spki));
-  public_key = blink::WebCryptoKey::createNull();
-  EXPECT_EQ(Status::Success(),
-            ImportKey(blink::WebCryptoKeyFormatSpki,
-                      CryptoData(public_key_spki),
-                      CreateRsaHashedImportAlgorithm(
-                          blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
-                          blink::WebCryptoAlgorithmIdSha256),
-                      true,
-                      usage_mask,
-                      &public_key));
-  EXPECT_EQ(modulus_length,
-            public_key.algorithm().rsaHashedParams()->modulusLengthBits());
 
-  std::vector<uint8> private_key_pkcs8;
-  EXPECT_EQ(
-      Status::Success(),
-      ExportKey(
-          blink::WebCryptoKeyFormatPkcs8, private_key, &private_key_pkcs8));
-  private_key = blink::WebCryptoKey::createNull();
-  EXPECT_EQ(Status::Success(),
-            ImportKey(blink::WebCryptoKeyFormatPkcs8,
-                      CryptoData(private_key_pkcs8),
-                      CreateRsaHashedImportAlgorithm(
-                          blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
-                          blink::WebCryptoAlgorithmIdSha256),
-                      true,
-                      usage_mask,
-                      &private_key));
-  EXPECT_EQ(modulus_length,
-            private_key.algorithm().rsaHashedParams()->modulusLengthBits());
+  if (SupportsRsaKeyImport()) {
+    public_key = blink::WebCryptoKey::createNull();
+    EXPECT_EQ(Status::Success(),
+              ImportKey(blink::WebCryptoKeyFormatSpki,
+                        CryptoData(public_key_spki),
+                        CreateRsaHashedImportAlgorithm(
+                            blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
+                            blink::WebCryptoAlgorithmIdSha256),
+                        true,
+                        usage_mask,
+                        &public_key));
+    EXPECT_EQ(modulus_length,
+              public_key.algorithm().rsaHashedParams()->modulusLengthBits());
+
+    std::vector<uint8> private_key_pkcs8;
+    EXPECT_EQ(
+        Status::Success(),
+        ExportKey(
+            blink::WebCryptoKeyFormatPkcs8, private_key, &private_key_pkcs8));
+    private_key = blink::WebCryptoKey::createNull();
+    EXPECT_EQ(Status::Success(),
+              ImportKey(blink::WebCryptoKeyFormatPkcs8,
+                        CryptoData(private_key_pkcs8),
+                        CreateRsaHashedImportAlgorithm(
+                            blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
+                            blink::WebCryptoAlgorithmIdSha256),
+                        true,
+                        usage_mask,
+                        &private_key));
+    EXPECT_EQ(modulus_length,
+              private_key.algorithm().rsaHashedParams()->modulusLengthBits());
+  }
 
   // Fail with bad modulus.
   algorithm =
       CreateRsaHashedKeyGenAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                      blink::WebCryptoAlgorithmIdSha256,
                                      0,
                                      public_exponent);
   EXPECT_EQ(Status::ErrorGenerateRsaZeroModulus(),
             GenerateKeyPair(
                 algorithm, extractable, usage_mask, &public_key, &private_key));
@@ skipping 122 matching lines @@
     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));
   }
 }
 
 TEST_F(SharedCryptoTest, MAYBE(RsaSsaSignVerifyFailures)) {
+  if (!SupportsRsaKeyImport())
+    return;
+
   // Import a key pair.
   blink::WebCryptoAlgorithm import_algorithm =
       CreateRsaHashedImportAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                      blink::WebCryptoAlgorithmIdSha1);
   blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
   blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
   ASSERT_NO_FATAL_FAILURE(
       ImportRsaKeyPair(HexStringToBytes(kPublicKeySpkiDerHex),
                        HexStringToBytes(kPrivateKeyPkcs8DerHex),
                        import_algorithm,
@@ skipping 110 matching lines @@
             VerifySignature(
                 CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5),
                 public_key_256,
                 CryptoData(signature),
                 CryptoData(data),
                 &is_match));
   EXPECT_FALSE(is_match);
 }
 
 TEST_F(SharedCryptoTest, MAYBE(RsaSignVerifyKnownAnswer)) {
+  if (!SupportsRsaKeyImport())
+    return;
+
   scoped_ptr<base::ListValue> tests;
   ASSERT_TRUE(ReadJsonTestFileToList("pkcs1v15_sign.json", &tests));
 
   // Import the key pair.
   blink::WebCryptoAlgorithm import_algorithm =
       CreateRsaHashedImportAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                      blink::WebCryptoAlgorithmIdSha1);
   blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
   blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
   ASSERT_NO_FATAL_FAILURE(
@@ skipping 1462 matching lines @@
                             &private_key));
 
   EXPECT_EQ(0, public_key.usages());
   EXPECT_EQ(blink::WebCryptoKeyUsageSign, private_key.usages());
 }
 
 // Generate an AES-CBC key and an RSA key pair. Use the AES-CBC key to wrap the
 // key pair (using SPKI format for public key, PKCS8 format for private key).
 // Then unwrap the wrapped key pair and verify that the key data is the same.
 TEST_F(SharedCryptoTest, MAYBE(WrapUnwrapRoundtripSpkiPkcs8UsingAesCbc)) {
+  if (!SupportsRsaKeyImport())
+    return;
+
   // Generate the wrapping key.
   blink::WebCryptoKey wrapping_key = blink::WebCryptoKey::createNull();
   ASSERT_EQ(Status::Success(),
             GenerateSecretKey(CreateAesCbcKeyGenAlgorithm(128),
                               true,
                               blink::WebCryptoKeyUsageWrapKey |
                                   blink::WebCryptoKeyUsageUnwrapKey,
                               &wrapping_key));
 
   // Generate an RSA key pair to be wrapped.
@@ skipping 90 matching lines @@
   EXPECT_EQ(public_key_spki, unwrapped_public_key_spki);
   EXPECT_EQ(private_key_pkcs8, unwrapped_private_key_pkcs8);
 
   EXPECT_NE(public_key_spki, wrapped_public_key);
   EXPECT_NE(private_key_pkcs8, wrapped_private_key);
 }
 
 }  // namespace webcrypto
 
 }  // namespace content