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

crypto/encryptor_mac.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 <CommonCrypto/CommonCryptor.h>
 
 #include "base/logging.h"
 #include "base/string_util.h"
@@ skipping 31 matching lines @@
 bool Encryptor::Crypt(int /*CCOperation*/ op,
                       const base::StringPiece& input,
                       std::string* output) {
   DCHECK(key_);
   CSSM_DATA raw_key = key_->cssm_data();
   // CommonCryptor.h: "A general rule for the size of the output buffer which
   // must be provided by the caller is that for block ciphers, the output
   // length is never larger than the input length plus the block size."
 
   size_t output_size = input.size() + iv_.size();
+  DCHECK_GT(output_size, 0u);
+  DCHECK_GT(output_size + 1, input.size());

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

Both of these can be changed to CHECK_GT

   CCCryptorStatus err = CCCrypt(op,
                                 kCCAlgorithmAES128,
                                 kCCOptionPKCS7Padding,
                                 raw_key.Data, raw_key.Length,
                                 iv_.data(),
                                 input.data(), input.size(),
-                                WriteInto(output, output_size+1),
+                                WriteInto(output, output_size + 1),
                                 output_size,
                                 &output_size);
   if (err) {
-    output->resize(0);
+    output->clear();
     LOG(ERROR) << "CCCrypt returned " << err;
     return false;
   }
   output->resize(output_size);
   return true;
 }
 
 bool Encryptor::Encrypt(const base::StringPiece& plaintext,
                         std::string* ciphertext) {
+  DCHECK(!plaintext.empty() || (mode_ == CBC));
   return Crypt(kCCEncrypt, plaintext, ciphertext);
 }
 
 bool Encryptor::Decrypt(const base::StringPiece& ciphertext,
                         std::string* plaintext) {
+  DCHECK(!ciphertext.empty());
   return Crypt(kCCDecrypt, ciphertext, plaintext);
 }
 
 }  // namespace crypto