crypto/encryptor_openssl.cc

   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/strings/string_util.h"
  12 #include "crypto/openssl_util.h"
  13 #include "crypto/symmetric_key.h"
  14
  15 namespace crypto {
  16
  17 namespace {
  18
  19 const EVP_CIPHER* GetCipherForKey(SymmetricKey* key) {
  20   switch (key->key().length()) {
  21     case 16: return EVP_aes_128_cbc();
  22     case 32: return EVP_aes_256_cbc();
  23     default: return NULL;
  24   }
  25 }
  26
  27 // On destruction this class will cleanup the ctx, and also clear the OpenSSL
  28 // ERR stack as a convenience.
  29 class ScopedCipherCTX {
  30  public:
  31   explicit ScopedCipherCTX() {
  32     EVP_CIPHER_CTX_init(&ctx_);
  33   }
  34   ~ScopedCipherCTX() {
  35     EVP_CIPHER_CTX_cleanup(&ctx_);
  36     ClearOpenSSLERRStack(FROM_HERE);
  37   }
  38   EVP_CIPHER_CTX* get() { return &ctx_; }
  39
  40  private:
  41   EVP_CIPHER_CTX ctx_;
  42 };
  43
  44 }  // namespace
  45
  46 Encryptor::Encryptor()
  47     : key_(NULL),
  48       mode_(CBC) {
  49 }
  50
  51 Encryptor::~Encryptor() {
  52 }
  53
  54 bool Encryptor::Init(SymmetricKey* key,
  55                      Mode mode,
  56                      const base::StringPiece& iv) {
  57   DCHECK(key);
  58   DCHECK(mode == CBC || mode == CTR);
  59
  60   EnsureOpenSSLInit();
  61   if (mode == CBC && iv.size() != AES_BLOCK_SIZE)
  62     return false;
  63
  64   if (GetCipherForKey(key) == NULL)
  65     return false;
  66
  67   key_ = key;
  68   mode_ = mode;
  69   iv.CopyToString(&iv_);
  70   return true;
  71 }
  72
  73 bool Encryptor::Encrypt(const base::StringPiece& plaintext,
  74                         std::string* ciphertext) {
  75   CHECK(!plaintext.empty() || (mode_ == CBC));
  76   return (mode_ == CTR) ?
  77       CryptCTR(true, plaintext, ciphertext) :
  78       Crypt(true, plaintext, ciphertext);
  79 }
  80
  81 bool Encryptor::Decrypt(const base::StringPiece& ciphertext,
  82                         std::string* plaintext) {
  83   CHECK(!ciphertext.empty());
  84   return (mode_ == CTR) ?
  85       CryptCTR(false, ciphertext, plaintext) :
  86       Crypt(false, ciphertext, plaintext);
  87 }
  88
  89 bool Encryptor::Crypt(bool do_encrypt,
  90                       const base::StringPiece& input,
  91                       std::string* output) {
  92   DCHECK(key_);  // Must call Init() before En/De-crypt.
  93   // Work on the result in a local variable, and then only transfer it to
  94   // |output| on success to ensure no partial data is returned.
  95   std::string result;
  96   output->clear();
  97
  98   const EVP_CIPHER* cipher = GetCipherForKey(key_);
  99   DCHECK(cipher);  // Already handled in Init();
 100
 101   const std::string& key = key_->key();
 102   DCHECK_EQ(EVP_CIPHER_iv_length(cipher), iv_.length());
 103   DCHECK_EQ(EVP_CIPHER_key_length(cipher), key.length());
 104
 105   ScopedCipherCTX ctx;
 106   if (!EVP_CipherInit_ex(ctx.get(), cipher, NULL,
 107                          reinterpret_cast<const uint8*>(key.data()),
 108                          reinterpret_cast<const uint8*>(iv_.data()),
 109                          do_encrypt))
 110     return false;
 111
 112   // When encrypting, add another block size of space to allow for any padding.
 113   const size_t output_size = input.size() + (do_encrypt ? iv_.size() : 0);
 114   CHECK_GT(output_size, 0u);
 115   CHECK_GT(output_size + 1, input.size());
 116   uint8* out_ptr = reinterpret_cast<uint8*>(WriteInto(&result,
 117                                                       output_size + 1));
 118   int out_len;
 119   if (!EVP_CipherUpdate(ctx.get(), out_ptr, &out_len,
 120                         reinterpret_cast<const uint8*>(input.data()),
 121                         input.length()))
 122     return false;
 123
 124   // Write out the final block plus padding (if any) to the end of the data
 125   // just written.
 126   int tail_len;
 127   if (!EVP_CipherFinal_ex(ctx.get(), out_ptr + out_len, &tail_len))
 128     return false;
 129
 130   out_len += tail_len;
 131   DCHECK_LE(out_len, static_cast<int>(output_size));
 132   result.resize(out_len);
 133
 134   output->swap(result);
 135   return true;
 136 }
 137
 138 bool Encryptor::CryptCTR(bool do_encrypt,
 139                          const base::StringPiece& input,
 140                          std::string* output) {
 141   if (!counter_.get()) {
 142     LOG(ERROR) << "Counter value not set in CTR mode.";
 143     return false;
 144   }
 145
 146   AES_KEY aes_key;
 147   if (AES_set_encrypt_key(reinterpret_cast<const uint8*>(key_->key().data()),
 148                           key_->key().size() * 8, &aes_key) != 0) {
 149     return false;
 150   }
 151
 152   const size_t out_size = input.size();
 153   CHECK_GT(out_size, 0u);
 154   CHECK_GT(out_size + 1, input.size());
 155
 156   std::string result;
 157   uint8* out_ptr = reinterpret_cast<uint8*>(WriteInto(&result, out_size + 1));
 158
 159   uint8_t ivec[AES_BLOCK_SIZE] = { 0 };
 160   uint8_t ecount_buf[AES_BLOCK_SIZE] = { 0 };
 161   unsigned int block_offset = 0;
 162
 163   counter_->Write(ivec);
 164
 165   AES_ctr128_encrypt(reinterpret_cast<const uint8*>(input.data()), out_ptr,
 166                      input.size(), &aes_key, ivec, ecount_buf, &block_offset);
 167
 168   // AES_ctr128_encrypt() updates |ivec|. Update the |counter_| here.
 169   SetCounter(base::StringPiece(reinterpret_cast<const char*>(ivec),
 170                                AES_BLOCK_SIZE));
 171
 172   output->swap(result);
 173   return true;
 174 }
 175
 176 }  // namespace crypto