Move crypto files out of base, to a top level directory.

crypto/encryptor_unittest.cc

 // Copyright (c) 2011 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/crypto/encryptor.h"

[wtc, 2011/04/07 05:35:53]

It's correct to include "crypto/encryptor.h" first
in the encryptor_unittest.cc file.  The Style Guide shows
an example of this.

[rvargas (doing something else), 2011/04/08 21:04:07]

I wish the style guide did't change under me.

-
 #include <string>
 
-#include "base/crypto/symmetric_key.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_number_conversions.h"
+#include "crypto/encryptor.h"
+#include "crypto/symmetric_key.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 TEST(EncryptorTest, EncryptDecrypt) {
-  scoped_ptr<base::SymmetricKey> key(base::SymmetricKey::DeriveKeyFromPassword(
-      base::SymmetricKey::AES, "password", "saltiest", 1000, 256));
+  scoped_ptr<crypto::SymmetricKey> key(
+      crypto::SymmetricKey::DeriveKeyFromPassword(
+          crypto::SymmetricKey::AES, "password", "saltiest", 1000, 256));
   EXPECT_TRUE(NULL != key.get());
 
-  base::Encryptor encryptor;
+  crypto::Encryptor encryptor;
   // The IV must be exactly as long as the cipher block size.
   std::string iv("the iv: 16 bytes");
   EXPECT_EQ(16U, iv.size());
-  EXPECT_TRUE(encryptor.Init(key.get(), base::Encryptor::CBC, iv));
+  EXPECT_TRUE(encryptor.Init(key.get(), crypto::Encryptor::CBC, iv));
 
   std::string plaintext("this is the plaintext");
   std::string ciphertext;
   EXPECT_TRUE(encryptor.Encrypt(plaintext, &ciphertext));
 
   EXPECT_LT(0U, ciphertext.size());
 
   std::string decypted;
   EXPECT_TRUE(encryptor.Decrypt(ciphertext, &decypted));
 
@@ skipping 45 matching lines @@
     0xa5, 0x30, 0xe2, 0x63, 0x04, 0x23, 0x14, 0x61,
     // Block #4
     0xb2, 0xeb, 0x05, 0xe2, 0xc3, 0x9b, 0xe9, 0xfc,
     0xda, 0x6c, 0x19, 0x07, 0x8c, 0x6a, 0x9d, 0x1b,
     // PKCS #5 padding, encrypted.
     0x3f, 0x46, 0x17, 0x96, 0xd6, 0xb0, 0xd6, 0xb2,
     0xe0, 0xc2, 0xa7, 0x2b, 0x4d, 0x80, 0xe6, 0x44
   };
 
   std::string key(reinterpret_cast<const char*>(raw_key), sizeof(raw_key));
-  scoped_ptr<base::SymmetricKey> sym_key(base::SymmetricKey::Import(
-      base::SymmetricKey::AES, key));
+  scoped_ptr<crypto::SymmetricKey> sym_key(crypto::SymmetricKey::Import(
+      crypto::SymmetricKey::AES, key));
   ASSERT_TRUE(NULL != sym_key.get());
 
-  base::Encryptor encryptor;
+  crypto::Encryptor encryptor;
   // The IV must be exactly as long a the cipher block size.
   std::string iv(reinterpret_cast<const char*>(raw_iv), sizeof(raw_iv));
   EXPECT_EQ(16U, iv.size());
-  EXPECT_TRUE(encryptor.Init(sym_key.get(), base::Encryptor::CBC, iv));
+  EXPECT_TRUE(encryptor.Init(sym_key.get(), crypto::Encryptor::CBC, iv));
 
   std::string plaintext(reinterpret_cast<const char*>(raw_plaintext),
                         sizeof(raw_plaintext));
   std::string ciphertext;
   EXPECT_TRUE(encryptor.Encrypt(plaintext, &ciphertext));
 
   EXPECT_EQ(sizeof(raw_ciphertext), ciphertext.size());
   EXPECT_EQ(0, memcmp(ciphertext.data(), raw_ciphertext, ciphertext.size()));
 
   std::string decypted;
   EXPECT_TRUE(encryptor.Decrypt(ciphertext, &decypted));
 
   EXPECT_EQ(plaintext, decypted);
 }
 
 // Expected output derived from the NSS implementation.
 TEST(EncryptorTest, EncryptAES128CBCRegression) {
   std::string key = "128=SixteenBytes";
   std::string iv = "Sweet Sixteen IV";
   std::string plaintext = "Plain text with a g-clef U+1D11E \360\235\204\236";
   std::string expected_ciphertext_hex =
       "D4A67A0BA33C30F207344D81D1E944BBE65587C3D7D9939A"
       "C070C62B9C15A3EA312EA4AD1BC7929F4D3C16B03AD5ADA8";
 
-  scoped_ptr<base::SymmetricKey> sym_key(base::SymmetricKey::Import(
-      base::SymmetricKey::AES, key));
+  scoped_ptr<crypto::SymmetricKey> sym_key(crypto::SymmetricKey::Import(
+      crypto::SymmetricKey::AES, key));
   ASSERT_TRUE(NULL != sym_key.get());
 
-  base::Encryptor encryptor;
+  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(), base::Encryptor::CBC, iv));
+  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 decypted;
   EXPECT_TRUE(encryptor.Decrypt(ciphertext, &decypted));
   EXPECT_EQ(plaintext, decypted);
 }
 
 // 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<base::SymmetricKey> sym_key(base::SymmetricKey::Import(
-      base::SymmetricKey::AES, key));
+  scoped_ptr<crypto::SymmetricKey> sym_key(crypto::SymmetricKey::Import(
+      crypto::SymmetricKey::AES, key));
   ASSERT_TRUE(NULL != sym_key.get());
 
-  base::Encryptor encryptor;
+  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(), base::Encryptor::CBC, iv));
+  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 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)
 TEST(EncryptorTest, UnsupportedKeySize) {
   std::string key = "7 = bad";
   std::string iv = "Sweet Sixteen IV";
-  scoped_ptr<base::SymmetricKey> sym_key(base::SymmetricKey::Import(
-      base::SymmetricKey::AES, key));
+  scoped_ptr<crypto::SymmetricKey> sym_key(crypto::SymmetricKey::Import(
+      crypto::SymmetricKey::AES, key));
   ASSERT_TRUE(NULL != sym_key.get());
 
-  base::Encryptor encryptor;
+  crypto::Encryptor encryptor;
   // The IV must be exactly as long a the cipher block size.
   EXPECT_EQ(16U, iv.size());
-  EXPECT_FALSE(encryptor.Init(sym_key.get(), base::Encryptor::CBC, iv));
+  EXPECT_FALSE(encryptor.Init(sym_key.get(), crypto::Encryptor::CBC, iv));
 }
 #endif  // unsupported platforms.
 
 TEST(EncryptorTest, UnsupportedIV) {
   std::string key = "128=SixteenBytes";
   std::string iv = "OnlyForteen :(";
-  scoped_ptr<base::SymmetricKey> sym_key(base::SymmetricKey::Import(
-      base::SymmetricKey::AES, key));
+  scoped_ptr<crypto::SymmetricKey> sym_key(crypto::SymmetricKey::Import(
+      crypto::SymmetricKey::AES, key));
   ASSERT_TRUE(NULL != sym_key.get());
 
-  base::Encryptor encryptor;
-  EXPECT_FALSE(encryptor.Init(sym_key.get(), base::Encryptor::CBC, iv));
+  crypto::Encryptor encryptor;
+  EXPECT_FALSE(encryptor.Init(sym_key.get(), crypto::Encryptor::CBC, iv));
 }
 
 TEST(EncryptorTest, EmptyEncrypt) {
   std::string key = "128=SixteenBytes";
   std::string iv = "Sweet Sixteen IV";
   std::string plaintext;
   std::string expected_ciphertext_hex = "8518B8878D34E7185E300D0FCC426396";
 
-  scoped_ptr<base::SymmetricKey> sym_key(base::SymmetricKey::Import(
-      base::SymmetricKey::AES, key));
+  scoped_ptr<crypto::SymmetricKey> sym_key(crypto::SymmetricKey::Import(
+      crypto::SymmetricKey::AES, key));
   ASSERT_TRUE(NULL != sym_key.get());
 
-  base::Encryptor encryptor;
+  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(), base::Encryptor::CBC, iv));
+  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()));
 }
 
 TEST(EncryptorTest, EmptyDecrypt) {
   std::string key = "128=SixteenBytes";
   std::string iv = "Sweet Sixteen IV";
 
-  scoped_ptr<base::SymmetricKey> sym_key(base::SymmetricKey::Import(
-      base::SymmetricKey::AES, key));
+  scoped_ptr<crypto::SymmetricKey> sym_key(crypto::SymmetricKey::Import(
+      crypto::SymmetricKey::AES, key));
   ASSERT_TRUE(NULL != sym_key.get());
 
-  base::Encryptor encryptor;
+  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(), base::Encryptor::CBC, iv));
+  EXPECT_TRUE(encryptor.Init(sym_key.get(), crypto::Encryptor::CBC, iv));
 
   std::string decrypted;
   EXPECT_FALSE(encryptor.Decrypt("", &decrypted));
   EXPECT_EQ("", decrypted);
 }