Convert crypto to std::unique_ptr

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 <stddef.h>
 
+#include <memory>
 #include <string>
 
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "crypto/symmetric_key.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 TEST(EncryptorTest, EncryptDecrypt) {
-  scoped_ptr<crypto::SymmetricKey> key(
+  std::unique_ptr<crypto::SymmetricKey> key(
       crypto::SymmetricKey::DeriveKeyFromPassword(
           crypto::SymmetricKey::AES, "password", "saltiest", 1000, 256));
   EXPECT_TRUE(key.get());
 
   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(), 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 decrypted;
   EXPECT_TRUE(encryptor.Decrypt(ciphertext, &decrypted));
 
   EXPECT_EQ(plaintext, decrypted);
 }
 
 TEST(EncryptorTest, DecryptWrongKey) {
-  scoped_ptr<crypto::SymmetricKey> key(
+  std::unique_ptr<crypto::SymmetricKey> key(
       crypto::SymmetricKey::DeriveKeyFromPassword(
           crypto::SymmetricKey::AES, "password", "saltiest", 1000, 256));
   EXPECT_TRUE(key.get());
 
   // A wrong key that can be detected by implementations that validate every
   // byte in the padding.
-  scoped_ptr<crypto::SymmetricKey> wrong_key(
-        crypto::SymmetricKey::DeriveKeyFromPassword(
-            crypto::SymmetricKey::AES, "wrongword", "sweetest", 1000, 256));
+  std::unique_ptr<crypto::SymmetricKey> wrong_key(
+      crypto::SymmetricKey::DeriveKeyFromPassword(
+          crypto::SymmetricKey::AES, "wrongword", "sweetest", 1000, 256));
   EXPECT_TRUE(wrong_key.get());
 
   // A wrong key that can't be detected by any implementation.  The password
   // "wrongword;" would also work.
-  scoped_ptr<crypto::SymmetricKey> wrong_key2(
-        crypto::SymmetricKey::DeriveKeyFromPassword(
-            crypto::SymmetricKey::AES, "wrongword+", "sweetest", 1000, 256));
+  std::unique_ptr<crypto::SymmetricKey> wrong_key2(
+      crypto::SymmetricKey::DeriveKeyFromPassword(
+          crypto::SymmetricKey::AES, "wrongword+", "sweetest", 1000, 256));
   EXPECT_TRUE(wrong_key2.get());
 
   // A wrong key that can be detected by all implementations.
-  scoped_ptr<crypto::SymmetricKey> wrong_key3(
-        crypto::SymmetricKey::DeriveKeyFromPassword(
-            crypto::SymmetricKey::AES, "wrongwordx", "sweetest", 1000, 256));
+  std::unique_ptr<crypto::SymmetricKey> wrong_key3(
+      crypto::SymmetricKey::DeriveKeyFromPassword(
+          crypto::SymmetricKey::AES, "wrongwordx", "sweetest", 1000, 256));
   EXPECT_TRUE(wrong_key3.get());
 
   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(), crypto::Encryptor::CBC, iv));
 
   std::string plaintext("this is the plaintext");
   std::string ciphertext;
@@ skipping 107 matching lines @@
   0xdf, 0xc9, 0xc5, 0x8d, 0xb6, 0x7a, 0xad, 0xa6,
   0x13, 0xc2, 0xdd, 0x08, 0x45, 0x79, 0x41, 0xa6
 };
 
 void TestAESCTREncrypt(
     const unsigned char* key, size_t key_size,
     const unsigned char* init_counter, size_t init_counter_size,
     const unsigned char* plaintext, size_t plaintext_size,
     const unsigned char* ciphertext, size_t ciphertext_size) {
   std::string key_str(reinterpret_cast<const char*>(key), key_size);
-  scoped_ptr<crypto::SymmetricKey> sym_key(crypto::SymmetricKey::Import(
-      crypto::SymmetricKey::AES, key_str));
+  std::unique_ptr<crypto::SymmetricKey> sym_key(
+      crypto::SymmetricKey::Import(crypto::SymmetricKey::AES, key_str));
   ASSERT_TRUE(sym_key.get());
 
   crypto::Encryptor encryptor;
   EXPECT_TRUE(encryptor.Init(sym_key.get(), crypto::Encryptor::CTR, ""));
 
   base::StringPiece init_counter_str(
       reinterpret_cast<const char*>(init_counter), init_counter_size);
   base::StringPiece plaintext_str(
       reinterpret_cast<const char*>(plaintext), plaintext_size);
 
@@ skipping 10 matching lines @@
 
   EXPECT_EQ(plaintext_str, decrypted);
 }
 
 void TestAESCTRMultipleDecrypt(
     const unsigned char* key, size_t key_size,
     const unsigned char* init_counter, size_t init_counter_size,
     const unsigned char* plaintext, size_t plaintext_size,
     const unsigned char* ciphertext, size_t ciphertext_size) {
   std::string key_str(reinterpret_cast<const char*>(key), key_size);
-  scoped_ptr<crypto::SymmetricKey> sym_key(crypto::SymmetricKey::Import(
-      crypto::SymmetricKey::AES, key_str));
+  std::unique_ptr<crypto::SymmetricKey> sym_key(
+      crypto::SymmetricKey::Import(crypto::SymmetricKey::AES, key_str));
   ASSERT_TRUE(sym_key.get());
 
   crypto::Encryptor encryptor;
   EXPECT_TRUE(encryptor.Init(sym_key.get(), crypto::Encryptor::CTR, ""));
 
   // Counter is set only once.
   EXPECT_TRUE(encryptor.SetCounter(base::StringPiece(
       reinterpret_cast<const char*>(init_counter), init_counter_size)));
 
   std::string ciphertext_str(reinterpret_cast<const char*>(ciphertext),
@@ skipping 41 matching lines @@
 
 TEST(EncryptorTest, EncryptAES256CTR_MultipleDecrypt) {
   TestAESCTRMultipleDecrypt(
       kAES256CTRKey, arraysize(kAES256CTRKey),
       kAESCTRInitCounter, arraysize(kAESCTRInitCounter),
       kAESCTRPlaintext, arraysize(kAESCTRPlaintext),
       kAES256CTRCiphertext, arraysize(kAES256CTRCiphertext));
 }
 
 TEST(EncryptorTest, EncryptDecryptCTR) {
-  scoped_ptr<crypto::SymmetricKey> key(
+  std::unique_ptr<crypto::SymmetricKey> key(
       crypto::SymmetricKey::GenerateRandomKey(crypto::SymmetricKey::AES, 128));
 
   EXPECT_TRUE(key.get());
   const std::string kInitialCounter = "0000000000000000";
 
   crypto::Encryptor encryptor;
   EXPECT_TRUE(encryptor.Init(key.get(), crypto::Encryptor::CTR, ""));
   EXPECT_TRUE(encryptor.SetCounter(kInitialCounter));
 
   std::string plaintext("normal plaintext of random length");
@@ skipping 102 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*>(kRawKey), sizeof(kRawKey));
-  scoped_ptr<crypto::SymmetricKey> sym_key(crypto::SymmetricKey::Import(
-      crypto::SymmetricKey::AES, key));
+  std::unique_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.
   std::string iv(reinterpret_cast<const char*>(kRawIv), sizeof(kRawIv));
   EXPECT_EQ(16U, iv.size());
   EXPECT_TRUE(encryptor.Init(sym_key.get(), crypto::Encryptor::CBC, iv));
 
   std::string plaintext(reinterpret_cast<const char*>(kRawPlaintext),
                         sizeof(kRawPlaintext));
@@ skipping 11 matching lines @@
 
 // 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<crypto::SymmetricKey> sym_key(crypto::SymmetricKey::Import(
-      crypto::SymmetricKey::AES, key));
+  std::unique_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);
 }
 
 // Symmetric keys with an unsupported size should be rejected. Whether they are
 // rejected by SymmetricKey::Import or Encryptor::Init depends on the platform.
 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));
+  std::unique_ptr<crypto::SymmetricKey> sym_key(
+      crypto::SymmetricKey::Import(crypto::SymmetricKey::AES, key));
   if (!sym_key.get())
     return;
 
   crypto::Encryptor encryptor;
   // The IV must be exactly as long as the cipher block size.
   EXPECT_EQ(16U, iv.size());
   EXPECT_FALSE(encryptor.Init(sym_key.get(), crypto::Encryptor::CBC, iv));
 }
 
 TEST(EncryptorTest, UnsupportedIV) {
   std::string key = "128=SixteenBytes";
   std::string iv = "OnlyForteen :(";
-  scoped_ptr<crypto::SymmetricKey> sym_key(crypto::SymmetricKey::Import(
-      crypto::SymmetricKey::AES, key));
+  std::unique_ptr<crypto::SymmetricKey> sym_key(
+      crypto::SymmetricKey::Import(crypto::SymmetricKey::AES, key));
   ASSERT_TRUE(sym_key.get());
 
   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<crypto::SymmetricKey> sym_key(crypto::SymmetricKey::Import(
-      crypto::SymmetricKey::AES, key));
+  std::unique_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()));
 }
 
 TEST(EncryptorTest, CipherTextNotMultipleOfBlockSize) {
   std::string key = "128=SixteenBytes";
   std::string iv = "Sweet Sixteen IV";
 
-  scoped_ptr<crypto::SymmetricKey> sym_key(crypto::SymmetricKey::Import(
-      crypto::SymmetricKey::AES, key));
+  std::unique_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));
 
   // Use a separately allocated array to improve the odds of the memory tools
   // catching invalid accesses.
   //
   // Otherwise when using std::string as the other tests do, accesses several
   // bytes off the end of the buffer may fall inside the reservation of
   // the string and not be detected.
-  scoped_ptr<char[]> ciphertext(new char[1]);
+  std::unique_ptr<char[]> ciphertext(new char[1]);
 
   std::string plaintext;
   EXPECT_FALSE(
       encryptor.Decrypt(base::StringPiece(ciphertext.get(), 1), &plaintext));
 }