[webcrypto] Remove support for AES 192-bit keys (2 of 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 1065 matching lines @@
 }
 
 TEST_F(SharedCryptoTest, MAYBE(GenerateKeyAes)) {
   // Check key generation for each of AES-CBC, AES-GCM, and AES-KW, and for each
   // allowed key length.
   std::vector<blink::WebCryptoAlgorithm> algorithm;
   const unsigned short kKeyLength[] = {128, 192, 256};
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kKeyLength); ++i) {
     algorithm.push_back(CreateAesCbcKeyGenAlgorithm(kKeyLength[i]));
     algorithm.push_back(CreateAesKwKeyGenAlgorithm(kKeyLength[i]));
-    if (SupportsAesGcm())
+    if (SupportsAesGcm() && kKeyLength[i] != 192)

[Ryan Sleevi, 2014/06/10 23:44:21]

ditto re: all AES

       algorithm.push_back(CreateAesGcmKeyGenAlgorithm(kKeyLength[i]));
   }
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   std::vector<std::vector<uint8> > keys;
   std::vector<uint8> key_bytes;
   for (size_t i = 0; i < algorithm.size(); ++i) {
     SCOPED_TRACE(i);
     // Generate a small sample of keys.
     keys.clear();
     for (int j = 0; j < 16; ++j) {
@@ skipping 768 matching lines @@
        blink::WebCryptoKeyUsageEncrypt | blink::WebCryptoKeyUsageDecrypt,
        "A128CBC"},
       // AES-CBC 192
       {key_hex_192, aes_cbc_alg, blink::WebCryptoKeyUsageEncrypt, "A192CBC"},
       // AES-CBC 256
       {key_hex_256, aes_cbc_alg, blink::WebCryptoKeyUsageDecrypt, "A256CBC"},
       // AES-GCM 128
       {key_hex_128, aes_gcm_alg,
        blink::WebCryptoKeyUsageEncrypt | blink::WebCryptoKeyUsageDecrypt,
        "A128GCM"},
-      // AES-CGM 192
-      {key_hex_192, aes_gcm_alg, blink::WebCryptoKeyUsageEncrypt, "A192GCM"},
       // AES-GCM 256
       {key_hex_256, aes_gcm_alg, blink::WebCryptoKeyUsageDecrypt, "A256GCM"},
       // AES-KW 128
       {key_hex_128, aes_kw_alg,
        blink::WebCryptoKeyUsageWrapKey | blink::WebCryptoKeyUsageUnwrapKey,
        "A128KW"},
       // AES-KW 192
       {key_hex_192, aes_kw_alg,
        blink::WebCryptoKeyUsageWrapKey | blink::WebCryptoKeyUsageUnwrapKey,
        "A192KW"},
@@ skipping 1372 matching lines @@
                               test_iv,
                               test_additional_data,
                               wrong_tag_size_bits,
                               test_cipher_text,
                               test_authentication_tag,
                               &plain_text));
     }
   }
 }
 
+// AES-GCM 192-bit is not allowed: http://crbug.com/381829
+TEST_F(SharedCryptoTest, MAYBE(ImportAesGcm192Raw)) {
+  // Some Linux test runners may not have a new enough version of NSS.
+  if (!SupportsAesGcm()) {
+    LOG(WARNING) << "AES GCM not supported, skipping tests";
+    return;
+  }
+
+  std::vector<uint8> key_raw(24, 0);
+  blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
+  Status status = ImportKey(blink::WebCryptoKeyFormatRaw,
+                            CryptoData(key_raw),
+                            CreateAlgorithm(blink::WebCryptoAlgorithmIdAesGcm),
+                            true,
+                            blink::WebCryptoKeyUsageEncrypt,
+                            &key);
+  ASSERT_EQ(Status::ErrorAesGcm192Unsupported(), status);
+}
+
+// AES-GCM 192-bit is not allowed: http://crbug.com/381829
+TEST_F(SharedCryptoTest, MAYBE(GenerateAesGcm192)) {
+  // Some Linux test runners may not have a new enough version of NSS.
+  if (!SupportsAesGcm()) {
+    LOG(WARNING) << "AES GCM not supported, skipping tests";
+    return;
+  }
+
+  blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
+  Status status = GenerateSecretKey(CreateAesGcmKeyGenAlgorithm(192),
+                                    true,
+                                    blink::WebCryptoKeyUsageEncrypt,
+                                    &key);
+  ASSERT_EQ(Status::ErrorAesGcm192Unsupported(), status);
+}
+
 class SharedCryptoRsaOaepTest : public ::testing::Test {
  public:
   SharedCryptoRsaOaepTest() { Init(); }
 
   scoped_ptr<base::DictionaryValue> CreatePublicKeyJwkDict() {
     scoped_ptr<base::DictionaryValue> jwk(new base::DictionaryValue());
     jwk->SetString("kty", "RSA");
     jwk->SetString("n",
                    Base64EncodeUrlSafe(HexStringToBytes(kPublicKeyModulusHex)));
     jwk->SetString(
@@ skipping 955 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