[refactor] Use base::CheckedNumeric<> in place of manual checks.

content/child/webcrypto/openssl/aes_cbc_openssl.cc

 // Copyright 2014 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 <openssl/aes.h>
 #include <openssl/evp.h>
 
 #include "base/logging.h"
+#include "base/numerics/safe_math.h"
 #include "content/child/webcrypto/crypto_data.h"
 #include "content/child/webcrypto/openssl/aes_key_openssl.h"
 #include "content/child/webcrypto/openssl/key_openssl.h"
 #include "content/child/webcrypto/status.h"
 #include "content/child/webcrypto/webcrypto_util.h"
 #include "crypto/scoped_openssl_types.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
 
 namespace content {
 
@@ skipping 21 matching lines @@
                             const blink::WebCryptoKey& key,
                             const CryptoData& data,
                             std::vector<uint8_t>* buffer) {
   const blink::WebCryptoAesCbcParams* params = algorithm.aesCbcParams();
   const std::vector<uint8_t>& raw_key =
       SymKeyOpenSsl::Cast(key)->raw_key_data();
 
   if (params->iv().size() != 16)
     return Status::ErrorIncorrectSizeAesCbcIv();
 
-  if (data.byte_length() >= INT_MAX - AES_BLOCK_SIZE) {
-    // TODO(padolph): Handle this by chunking the input fed into OpenSSL. Right
-    // now it doesn't make much difference since the one-shot API would end up
-    // blowing out the memory and crashing anyway.
+  // According to the openssl docs, the amount of data written may be as large
+  // as (data_size + cipher_block_size - 1), constrained to a multiple of
+  // cipher_block_size.
+  base::CheckedNumeric<int> output_max_len = data.byte_length();
+  output_max_len += AES_BLOCK_SIZE - 1;
+  if (!output_max_len.IsValid())
     return Status::ErrorDataTooLarge();
-  }
+
+  const unsigned remainder = output_max_len.ValueOrDie() % AES_BLOCK_SIZE;
+  if (remainder != 0)
+    output_max_len += AES_BLOCK_SIZE - remainder;
+  if (!output_max_len.IsValid())
+    return Status::ErrorDataTooLarge();
 
   // Note: PKCS padding is enabled by default
   crypto::ScopedOpenSSL<EVP_CIPHER_CTX, EVP_CIPHER_CTX_free>::Type context(
       EVP_CIPHER_CTX_new());
 
   if (!context.get())
     return Status::OperationError();
 
   const EVP_CIPHER* const cipher = GetAESCipherByKeyLength(raw_key.size());
   DCHECK(cipher);
 
   if (!EVP_CipherInit_ex(context.get(),
                          cipher,
                          NULL,
                          &raw_key[0],
                          params->iv().data(),
                          cipher_operation)) {
     return Status::OperationError();
   }
 
-  // According to the openssl docs, the amount of data written may be as large
-  // as (data_size + cipher_block_size - 1), constrained to a multiple of
-  // cipher_block_size.
-  unsigned int output_max_len = data.byte_length() + AES_BLOCK_SIZE - 1;
-  const unsigned remainder = output_max_len % AES_BLOCK_SIZE;
-  if (remainder != 0)
-    output_max_len += AES_BLOCK_SIZE - remainder;
-  DCHECK_GT(output_max_len, data.byte_length());
-
-  buffer->resize(output_max_len);
+  buffer->resize(output_max_len.ValueOrDie());
 
   unsigned char* const buffer_data = Uint8VectorStart(buffer);
 
   int output_len = 0;
   if (!EVP_CipherUpdate(context.get(),
                         buffer_data,
                         &output_len,
                         data.bytes(),
                         data.byte_length()))
     return Status::OperationError();
   int final_output_chunk_len = 0;
   if (!EVP_CipherFinal_ex(
           context.get(), buffer_data + output_len, &final_output_chunk_len)) {
     return Status::OperationError();
   }
 
   const unsigned int final_output_len =
       static_cast<unsigned int>(output_len) +
       static_cast<unsigned int>(final_output_chunk_len);
-  DCHECK_LE(final_output_len, output_max_len);
 
   buffer->resize(final_output_len);
 
   return Status::Success();
 }
 
 class AesCbcImplementation : public AesAlgorithm {
  public:
   AesCbcImplementation() : AesAlgorithm("CBC") {}
 
@@ skipping 14 matching lines @@
 
 }  // namespace
 
 AlgorithmImplementation* CreatePlatformAesCbcImplementation() {
   return new AesCbcImplementation;
 }
 
 }  // namespace webcrypto
 
 }  // namespace content