Unify the error checking of crypto::Encryptor and add WARN_UNUSED_RESULT to prevent misuse.

crypto/encryptor.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 "base/logging.h"
 #include "build/build_config.h"
 
 // Include headers to provide bswap for all platforms.
@@ skipping 76 matching lines @@
 
 bool Encryptor::GenerateCounterMask(size_t plaintext_len,
                                     uint8* mask,
                                     size_t* mask_len) {
   DCHECK_EQ(CTR, mode_);
   CHECK(mask);
   CHECK(mask_len);
 
   const size_t kBlockLength = counter_->GetLengthInBytes();
   size_t blocks = (plaintext_len + kBlockLength - 1) / kBlockLength;
-  CHECK(blocks);
+  if (blocks == 0)
+    return false;

[wtc, 2011/12/15 02:03:58]

Should we also mark the GenerateCounterMask method with
WARN_UNUSED_RESULT?

It seems that we should support the encryption of nothing.
Does this failure return prevent us from supporting that?

[Ryan Sleevi, 2011/12/15 02:18:16]

Yes. It matches the previous CHECK, but empty plaintext in CTR mode is treated
as a failure.

[wtc, 2011/12/15 22:04:14]

Thanks for the explanation.  This is fine.

 
   *mask_len = blocks * kBlockLength;
 
   for (size_t i = 0; i < blocks; ++i) {
     counter_->Write(mask);
     mask += kBlockLength;
 
     bool ret = counter_->Increment();
     if (!ret)
       return false;
   }
   return true;
 }
 
 void Encryptor::MaskMessage(const void* plaintext,
                             size_t plaintext_len,
                             const void* mask,
                             void* ciphertext) const {
   DCHECK_EQ(CTR, mode_);
   const uint8* plaintext_ptr = reinterpret_cast<const uint8*>(plaintext);
   const uint8* mask_ptr = reinterpret_cast<const uint8*>(mask);
   uint8* ciphertext_ptr = reinterpret_cast<uint8*>(ciphertext);
 
   for (size_t i = 0; i < plaintext_len; ++i)
     ciphertext_ptr[i] = plaintext_ptr[i] ^ mask_ptr[i];
 }
 
 }  // namespace crypto