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/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 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:
  32   explicit ScopedCipherCTX() {
  33     EVP_CIPHER_CTX_init(&ctx_);
  34   }
  35   ~ScopedCipherCTX() {
  36     EVP_CIPHER_CTX_cleanup(&ctx_);
  37     ClearOpenSSLERRStack(FROM_HERE);
  38   }
  39   EVP_CIPHER_CTX* get() { return &ctx_; }
  40
  41  private:
  42   EVP_CIPHER_CTX ctx_;
  43 };
  44
  45 }  // namespace
  46
  47 Encryptor::Encryptor()
  48     : key_(NULL),
  49       mode_(CBC) {
  50 }
  51
  52 Encryptor::~Encryptor() {
  53 }
  54
  55 bool Encryptor::Init(SymmetricKey* key,
  56                      Mode mode,
  57                      const base::StringPiece& iv) {
  58   DCHECK(key);
  59   DCHECK_EQ(CBC, mode);
  60
  61   EnsureOpenSSLInit();
  62   if (iv.size() != AES_BLOCK_SIZE)
  63     return false;
  64
  65   if (GetCipherForKey(key) == NULL)
  66     return false;
  67
  68   key_ = key;
  69   mode_ = mode;
  70   iv.CopyToString(&iv_);
  71   return true;
  72 }
  73
  74 bool Encryptor::Encrypt(const base::StringPiece& plaintext,
  75                         std::string* ciphertext) {
  76   return Crypt(true, plaintext, ciphertext);
  77 }
  78
  79 bool Encryptor::Decrypt(const base::StringPiece& ciphertext,
  80                         std::string* plaintext) {
  81   return Crypt(false, ciphertext, plaintext);
  82 }
  83
  84 bool Encryptor::Crypt(bool do_encrypt,
  85                       const base::StringPiece& input,
  86                       std::string* output) {
  87   DCHECK(key_);  // Must call Init() before En/De-crypt.
  88   // Work on the result in a local variable, and then only transfer it to
  89   // |output| on success to ensure no partial data is returned.
  90   std::string result;
  91   output->swap(result);
  92
  93   const EVP_CIPHER* cipher = GetCipherForKey(key_);
  94   DCHECK(cipher);  // Already handled in Init();
  95
  96   const std::string& key = key_->key();
  97   DCHECK_EQ(EVP_CIPHER_iv_length(cipher), static_cast<int>(iv_.length()));
  98   DCHECK_EQ(EVP_CIPHER_key_length(cipher), static_cast<int>(key.length()));
  99
 100   ScopedCipherCTX ctx;
 101   if (!EVP_CipherInit_ex(ctx.get(), cipher, NULL,
 102                          reinterpret_cast<const uint8*>(key.data()),
 103                          reinterpret_cast<const uint8*>(iv_.data()),
 104                          do_encrypt))
 105     return false;
 106
 107   // When encrypting, add another block size of space to allow for any padding.
 108   const size_t output_size = input.size() + (do_encrypt ? iv_.size() : 0);
 109   uint8* out_ptr = reinterpret_cast<uint8*>(WriteInto(&result,
 110                                                       output_size + 1));
 111   int out_len;
 112   if (!EVP_CipherUpdate(ctx.get(), out_ptr, &out_len,
 113                         reinterpret_cast<const uint8*>(input.data()),
 114                         input.length()))
 115     return false;
 116
 117   // Write out the final block plus padding (if any) to the end of the data
 118   // just written.
 119   int tail_len;
 120   if (!EVP_CipherFinal_ex(ctx.get(), out_ptr + out_len, &tail_len))
 121     return false;
 122
 123   out_len += tail_len;
 124   DCHECK_LE(out_len, static_cast<int>(output_size));
 125   result.resize(out_len);
 126
 127   output->swap(result);
 128   return true;
 129 }
 130
 131 }  // namespace crypto