1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "crypto/encryptor.h"
6
7 #include <openssl/aes.h>
8 #include <openssl/evp.h>
9
10 #include "base/logging.h"
11 #include "base/string_util.h"
12 #include "crypto/openssl_util.h"
13 #include "crypto/symmetric_key.h"
14
15 namespace crypto {
16
17 namespace {
18
GetCipherForKey(SymmetricKey * key)19 const EVP_CIPHER* GetCipherForKey(SymmetricKey* key) {
20 switch (key->key().length()) {
21 case 16: return EVP_aes_128_cbc();
22 case 24: return EVP_aes_192_cbc();
23 case 32: return EVP_aes_256_cbc();
24 default: return NULL;
25 }
26 }
27
28 // On destruction this class will cleanup the ctx, and also clear the OpenSSL
29 // ERR stack as a convenience.
30 class ScopedCipherCTX {
31 public:
ScopedCipherCTX()32 explicit ScopedCipherCTX() {
33 EVP_CIPHER_CTX_init(&ctx_);
34 }
~ScopedCipherCTX()35 ~ScopedCipherCTX() {
36 EVP_CIPHER_CTX_cleanup(&ctx_);
37 ClearOpenSSLERRStack(FROM_HERE);
38 }
get()39 EVP_CIPHER_CTX* get() { return &ctx_; }
40
41 private:
42 EVP_CIPHER_CTX ctx_;
43 };
44
45 } // namespace
46
Encryptor()47 Encryptor::Encryptor()
48 : key_(NULL),
49 mode_(CBC) {
50 }
51
~Encryptor()52 Encryptor::~Encryptor() {
53 }
54
Init(SymmetricKey * key,Mode mode,const std::string & iv)55 bool Encryptor::Init(SymmetricKey* key, Mode mode, const std::string& iv) {
56 DCHECK(key);
57 DCHECK_EQ(CBC, mode);
58
59 EnsureOpenSSLInit();
60 if (iv.size() != AES_BLOCK_SIZE)
61 return false;
62
63 if (GetCipherForKey(key) == NULL)
64 return false;
65
66 key_ = key;
67 mode_ = mode;
68 iv_ = iv;
69 return true;
70 }
71
Encrypt(const std::string & plaintext,std::string * ciphertext)72 bool Encryptor::Encrypt(const std::string& plaintext, std::string* ciphertext) {
73 return Crypt(true, plaintext, ciphertext);
74 }
75
Decrypt(const std::string & ciphertext,std::string * plaintext)76 bool Encryptor::Decrypt(const std::string& ciphertext, std::string* plaintext) {
77 return Crypt(false, ciphertext, plaintext);
78 }
79
Crypt(bool do_encrypt,const std::string & input,std::string * output)80 bool Encryptor::Crypt(bool do_encrypt,
81 const std::string& input,
82 std::string* output) {
83 DCHECK(key_); // Must call Init() before En/De-crypt.
84 // Work on the result in a local variable, and then only transfer it to
85 // |output| on success to ensure no partial data is returned.
86 std::string result;
87 output->swap(result);
88
89 const EVP_CIPHER* cipher = GetCipherForKey(key_);
90 DCHECK(cipher); // Already handled in Init();
91
92 const std::string& key = key_->key();
93 DCHECK_EQ(EVP_CIPHER_iv_length(cipher), static_cast<int>(iv_.length()));
94 DCHECK_EQ(EVP_CIPHER_key_length(cipher), static_cast<int>(key.length()));
95
96 ScopedCipherCTX ctx;
97 if (!EVP_CipherInit_ex(ctx.get(), cipher, NULL,
98 reinterpret_cast<const uint8*>(key.data()),
99 reinterpret_cast<const uint8*>(iv_.data()),
100 do_encrypt))
101 return false;
102
103 // When encrypting, add another block size of space to allow for any padding.
104 const size_t output_size = input.size() + (do_encrypt ? iv_.size() : 0);
105 uint8* out_ptr = reinterpret_cast<uint8*>(WriteInto(&result,
106 output_size + 1));
107 int out_len;
108 if (!EVP_CipherUpdate(ctx.get(), out_ptr, &out_len,
109 reinterpret_cast<const uint8*>(input.data()),
110 input.length()))
111 return false;
112
113 // Write out the final block plus padding (if any) to the end of the data
114 // just written.
115 int tail_len;
116 if (!EVP_CipherFinal_ex(ctx.get(), out_ptr + out_len, &tail_len))
117 return false;
118
119 out_len += tail_len;
120 DCHECK_LE(out_len, static_cast<int>(output_size));
121 result.resize(out_len);
122
123 output->swap(result);
124 return true;
125 }
126
127 } // namespace crypto
128