Desupport AES-192 in crypto::SymmetricKey.

BoringSSL does not support AES-192. No current consumer uses AES-192, so remove
the test which asserts it works. This fixes crypto_unittests in the Mac OpenSSL
port. Blacklist AES-192 in the NSS implementation so that we do not
accidentally grow a new dependency on it.

BUG=338885

Review URL: https://codereview.chromium.org/420883003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@285678 0039d316-1c4b-4281-b951-d872f2087c98

Author: davidben@chromium.org

crypto/encryptor_unittest.cc

@@ -456,32 +456,6 @@ TEST(EncryptorTest, EncryptAES128CBCRegression) {
   EXPECT_EQ(plaintext, decrypted);
 }
 
-// Expected output derived from the NSS implementation.
-TEST(EncryptorTest, EncryptAES192CBCRegression) {
-  std::string key = "192bitsIsTwentyFourByte!";
-  std::string iv = "Sweet Sixteen IV";
-  std::string plaintext = "Small text";
-  std::string expected_ciphertext_hex = "78DE5D7C2714FC5C61346C5416F6C89A";
-
-  scoped_ptr<crypto::SymmetricKey> sym_key(crypto::SymmetricKey::Import(
-      crypto::SymmetricKey::AES, key));
-  ASSERT_TRUE(sym_key.get());
-
-  crypto::Encryptor encryptor;
-  // The IV must be exactly as long a the cipher block size.
-  EXPECT_EQ(16U, iv.size());
-  EXPECT_TRUE(encryptor.Init(sym_key.get(), crypto::Encryptor::CBC, iv));
-
-  std::string ciphertext;
-  EXPECT_TRUE(encryptor.Encrypt(plaintext, &ciphertext));
-  EXPECT_EQ(expected_ciphertext_hex, base::HexEncode(ciphertext.data(),
-                                                     ciphertext.size()));
-
-  std::string decrypted;
-  EXPECT_TRUE(encryptor.Decrypt(ciphertext, &decrypted));
-  EXPECT_EQ(plaintext, decrypted);
-}
-
 // Not all platforms allow import/generation of symmetric keys with an
 // unsupported size.
 #if !defined(USE_NSS) && !defined(OS_WIN) && !defined(OS_MACOSX)

crypto/symmetric_key_nss.cc

@@ -20,7 +20,11 @@ SymmetricKey* SymmetricKey::GenerateRandomKey(Algorithm algorithm,
   DCHECK_EQ(AES, algorithm);
 
   EnsureNSSInit();
-  if (key_size_in_bits == 0)
+
+  // Whitelist supported key sizes to avoid accidentaly relying on
+  // algorithms available in NSS but not BoringSSL and vice
+  // versa. Note that BoringSSL does not support AES-192.
+  if (key_size_in_bits != 128 && key_size_in_bits != 256)
     return NULL;
 
   ScopedPK11Slot slot(PK11_GetInternalSlot());
@@ -45,6 +49,14 @@ SymmetricKey* SymmetricKey::DeriveKeyFromPassword(Algorithm algorithm,
   if (salt.empty() || iterations == 0 || key_size_in_bits == 0)
     return NULL;
 
+  if (algorithm == AES) {
+    // Whitelist supported key sizes to avoid accidentaly relying on
+    // algorithms available in NSS but not BoringSSL and vice
+    // versa. Note that BoringSSL does not support AES-192.
+    if (key_size_in_bits != 128 && key_size_in_bits != 256)
+      return NULL;
+  }
+
   SECItem password_item;
   password_item.type = siBuffer;
   password_item.data = reinterpret_cast<unsigned char*>(
@@ -84,6 +96,15 @@ SymmetricKey* SymmetricKey::DeriveKeyFromPassword(Algorithm algorithm,
 SymmetricKey* SymmetricKey::Import(Algorithm algorithm,
                                    const std::string& raw_key) {
   EnsureNSSInit();
+
+  if (algorithm == AES) {
+    // Whitelist supported key sizes to avoid accidentaly relying on
+    // algorithms available in NSS but not BoringSSL and vice
+    // versa. Note that BoringSSL does not support AES-192.
+    if (raw_key.size() != 128/8 && raw_key.size() != 256/8)
+      return NULL;
+  }
+
   CK_MECHANISM_TYPE cipher =
       algorithm == AES ? CKM_AES_CBC : CKM_SHA_1_HMAC;
 

crypto/symmetric_key_openssl.cc

@@ -24,6 +24,13 @@ SymmetricKey::~SymmetricKey() {
 SymmetricKey* SymmetricKey::GenerateRandomKey(Algorithm algorithm,
                                               size_t key_size_in_bits) {
   DCHECK_EQ(AES, algorithm);
+
+  // Whitelist supported key sizes to avoid accidentaly relying on
+  // algorithms available in NSS but not BoringSSL and vice
+  // versa. Note that BoringSSL does not support AES-192.
+  if (key_size_in_bits != 128 && key_size_in_bits != 256)
+    return NULL;
+
   size_t key_size_in_bytes = key_size_in_bits / 8;
   DCHECK_EQ(key_size_in_bits, key_size_in_bytes * 8);
 
@@ -46,6 +53,15 @@ SymmetricKey* SymmetricKey::DeriveKeyFromPassword(Algorithm algorithm,
                                                   size_t iterations,
                                                   size_t key_size_in_bits) {
   DCHECK(algorithm == AES || algorithm == HMAC_SHA1);
+
+  if (algorithm == AES) {
+    // Whitelist supported key sizes to avoid accidentaly relying on
+    // algorithms available in NSS but not BoringSSL and vice
+    // versa. Note that BoringSSL does not support AES-192.
+    if (key_size_in_bits != 128 && key_size_in_bits != 256)
+      return NULL;
+  }
+
   size_t key_size_in_bytes = key_size_in_bits / 8;
   DCHECK_EQ(key_size_in_bits, key_size_in_bytes * 8);
 
@@ -67,6 +83,14 @@ SymmetricKey* SymmetricKey::DeriveKeyFromPassword(Algorithm algorithm,
 // static
 SymmetricKey* SymmetricKey::Import(Algorithm algorithm,
                                    const std::string& raw_key) {
+  if (algorithm == AES) {
+    // Whitelist supported key sizes to avoid accidentaly relying on
+    // algorithms available in NSS but not BoringSSL and vice
+    // versa. Note that BoringSSL does not support AES-192.
+    if (raw_key.size() != 128/8 && raw_key.size() != 256/8)
+      return NULL;
+  }
+
   scoped_ptr<SymmetricKey> key(new SymmetricKey);
   key->key_ = raw_key;
   return key.release();