Use NSS for symmetric key crypto operations on Windows and Mac.

crypto/encryptor_unittest.cc

 // Copyright (c) 2012 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 "crypto/encryptor.h"
 
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/string_number_conversions.h"
@@ skipping 74 matching lines @@
   }
 
   std::string decypted;
 
   // This wrong key causes the last padding byte to be 5, which is a valid
   // padding length, and the second to last padding byte to be 137, which is
   // invalid.  If an implementation simply uses the last padding byte to
   // determine the padding length without checking every padding byte,
   // Encryptor::Decrypt() will still return true.  This is the case for NSS
   // (crbug.com/124434) and Mac OS X 10.7 (crbug.com/127586).
-#if !defined(USE_NSS)
+#if !defined(USE_NSS) && !defined(OS_WIN) && !defined(OS_MACOSX)
   crypto::Encryptor decryptor;
   EXPECT_TRUE(decryptor.Init(wrong_key.get(), crypto::Encryptor::CBC, iv));
   EXPECT_FALSE(decryptor.Decrypt(ciphertext, &decypted));
 #endif
 
   // This demonstrates that not all wrong keys can be detected by padding
   // error. This wrong key causes the last padding byte to be 1, which is
   // a valid padding block of length 1.
   crypto::Encryptor decryptor2;
   EXPECT_TRUE(decryptor2.Init(wrong_key2.get(), crypto::Encryptor::CBC, iv));
   EXPECT_TRUE(decryptor2.Decrypt(ciphertext, &decypted));
 
   // This wrong key causes the last padding byte to be 253, which should be
   // rejected by all implementations.
   crypto::Encryptor decryptor3;
   EXPECT_TRUE(decryptor3.Init(wrong_key3.get(), crypto::Encryptor::CBC, iv));
   EXPECT_FALSE(decryptor3.Decrypt(ciphertext, &decypted));
 }
 
 // CTR mode encryption is only implemented using NSS.
-#if defined(USE_NSS)
+#if defined(USE_NSS) || defined(OS_WIN) || defined(OS_MACOSX)
 
 TEST(EncryptorTest, EncryptDecryptCTR) {
   scoped_ptr<crypto::SymmetricKey> key(
       crypto::SymmetricKey::GenerateRandomKey(
           crypto::SymmetricKey::AES, 128));
 
   EXPECT_TRUE(NULL != key.get());
   const std::string kInitialCounter = "0000000000000000";
 
   crypto::Encryptor encryptor;
@@ skipping 15 matching lines @@
   EXPECT_TRUE(encryptor.Encrypt(plaintext, &ciphertext));
   EXPECT_LT(0U, ciphertext.size());
 
   EXPECT_TRUE(encryptor.SetCounter(kInitialCounter));
   EXPECT_TRUE(encryptor.Decrypt(ciphertext, &decypted));
   EXPECT_EQ(plaintext, decypted);
 }
 
 TEST(EncryptorTest, CTRCounter) {
   const int kCounterSize = 16;
-  const char kTest1[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+  const uint8 kTest1[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

[Ryan Sleevi, 2012/06/14 19:35:26]

unsigned char, to be consistent with the rest of this file.

[ddorwin, 2012/06/14 20:44:19]

Done.

   uint8 buf[16];
 
   // Increment 10 times.
-  crypto::Encryptor::Counter counter1(std::string(kTest1, kCounterSize));
+  crypto::Encryptor::Counter counter1(
+      std::string(reinterpret_cast<const char*>(kTest1), kCounterSize));
   for (int i = 0; i < 10; ++i)
     counter1.Increment();
   counter1.Write(buf);
   EXPECT_EQ(0, memcmp(buf, kTest1, 15));
   EXPECT_TRUE(buf[15] == 10);
 
   // Check corner cases.
-  const char kTest2[] = {0, 0, 0, 0, 0, 0, 0, 0,
+  const uint8 kTest2[] = {0, 0, 0, 0, 0, 0, 0, 0,
                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
-  const char kExpect2[] = {0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0};
-  crypto::Encryptor::Counter counter2(std::string(kTest2, kCounterSize));
+  const uint8 kExpect2[] = {0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0};
+  crypto::Encryptor::Counter counter2(
+      std::string(reinterpret_cast<const char*>(kTest2), kCounterSize));
   counter2.Increment();
   counter2.Write(buf);
   EXPECT_EQ(0, memcmp(buf, kExpect2, kCounterSize));
 
-  const char kTest3[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  const uint8 kTest3[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
                          0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
-  const char kExpect3[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-  crypto::Encryptor::Counter counter3(std::string(kTest3, kCounterSize));
+  const uint8 kExpect3[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+  crypto::Encryptor::Counter counter3(
+      std::string(reinterpret_cast<const char*>(kTest3), kCounterSize));
   counter3.Increment();
   counter3.Write(buf);
   EXPECT_EQ(0, memcmp(buf, kExpect3, kCounterSize));
 }
 
 #endif
 
 // TODO(wtc): add more known-answer tests.  Test vectors are available from
 // http://www.ietf.org/rfc/rfc3602
 // http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
@@ skipping 119 matching lines @@
   EXPECT_EQ(expected_ciphertext_hex, base::HexEncode(ciphertext.data(),
                                                      ciphertext.size()));
 
   std::string decypted;
   EXPECT_TRUE(encryptor.Decrypt(ciphertext, &decypted));
   EXPECT_EQ(plaintext, decypted);
 }
 
 // Not all platforms allow import/generation of symmetric keys with an
 // unsupported size.
-#if !defined(OS_WIN) && !defined(USE_NSS)
+#if !defined(USE_NSS) && !defined(OS_WIN) && !defined(OS_MACOSX)
 TEST(EncryptorTest, UnsupportedKeySize) {
   std::string key = "7 = bad";
   std::string iv = "Sweet Sixteen IV";
   scoped_ptr<crypto::SymmetricKey> sym_key(crypto::SymmetricKey::Import(
       crypto::SymmetricKey::AES, key));
   ASSERT_TRUE(NULL != sym_key.get());
 
   crypto::Encryptor encryptor;
   // The IV must be exactly as long a the cipher block size.
   EXPECT_EQ(16U, iv.size());
@@ skipping 25 matching lines @@
   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()));
 }