Make string_util::WriteInto() DCHECK() that the supplied |length_with_null| > 1, meaning that the...

crypto/encryptor_openssl.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 "crypto/encryptor.h"
 
 #include <openssl/aes.h>
 #include <openssl/evp.h>
 
 #include "base/logging.h"
@@ skipping 55 matching lines @@
     return false;
 
   key_ = key;
   mode_ = mode;
   iv.CopyToString(&iv_);
   return true;
 }
 
 bool Encryptor::Encrypt(const base::StringPiece& plaintext,
                         std::string* ciphertext) {
+  DCHECK(!plaintext.empty() || (mode_ == CBC));
   return Crypt(true, plaintext, ciphertext);
 }
 
 bool Encryptor::Decrypt(const base::StringPiece& ciphertext,
                         std::string* plaintext) {
+  DCHECK(!ciphertext.empty());
   return Crypt(false, ciphertext, plaintext);
 }
 
 bool Encryptor::Crypt(bool do_encrypt,
                       const base::StringPiece& input,
                       std::string* output) {
   DCHECK(key_);  // Must call Init() before En/De-crypt.
   // Work on the result in a local variable, and then only transfer it to
   // |output| on success to ensure no partial data is returned.
   std::string result;
-  output->swap(result);
+  output->clear();
 
   const EVP_CIPHER* cipher = GetCipherForKey(key_);
   DCHECK(cipher);  // Already handled in Init();
 
   const std::string& key = key_->key();
   DCHECK_EQ(EVP_CIPHER_iv_length(cipher), static_cast<int>(iv_.length()));
   DCHECK_EQ(EVP_CIPHER_key_length(cipher), static_cast<int>(key.length()));
 
   ScopedCipherCTX ctx;
   if (!EVP_CipherInit_ex(ctx.get(), cipher, NULL,
                          reinterpret_cast<const uint8*>(key.data()),
                          reinterpret_cast<const uint8*>(iv_.data()),
                          do_encrypt))
     return false;
 
   // When encrypting, add another block size of space to allow for any padding.
   const size_t output_size = input.size() + (do_encrypt ? iv_.size() : 0);
+  DCHECK_GT(output_size, 0u);
+  DCHECK_GT(output_size + 1, input.size());

[Ryan Sleevi, 2011/11/01 23:08:59]

Promote both of these to CHECK_GT

   uint8* out_ptr = reinterpret_cast<uint8*>(WriteInto(&result,
                                                       output_size + 1));
   int out_len;
   if (!EVP_CipherUpdate(ctx.get(), out_ptr, &out_len,
                         reinterpret_cast<const uint8*>(input.data()),
                         input.length()))
     return false;
 
   // Write out the final block plus padding (if any) to the end of the data
   // just written.
   int tail_len;
   if (!EVP_CipherFinal_ex(ctx.get(), out_ptr + out_len, &tail_len))
     return false;
 
   out_len += tail_len;
   DCHECK_LE(out_len, static_cast<int>(output_size));
   result.resize(out_len);
 
   output->swap(result);
   return true;
 }
 
 }  // namespace crypto