Use new BoringSSL scopers in //components.

components/webcrypto/algorithms/aes_ctr.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 <openssl/bn.h>
+#include <openssl/cipher.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/numerics/safe_math.h"
 #include "components/webcrypto/algorithms/aes.h"
 #include "components/webcrypto/algorithms/util.h"
 #include "components/webcrypto/blink_key_handle.h"
 #include "components/webcrypto/crypto_data.h"
 #include "components/webcrypto/status.h"
 #include "crypto/openssl_util.h"
-#include "crypto/scoped_openssl_types.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
 
 namespace webcrypto {
 
 namespace {
 
 const EVP_CIPHER* GetAESCipherByKeyLength(size_t key_length_bytes) {
   // 192-bit AES is intentionally unsupported (http://crbug.com/533699).
   switch (key_length_bytes) {
     case 16:
@@ skipping 11 matching lines @@
 // |input.byte_length()|.
 Status AesCtrEncrypt128BitCounter(const EVP_CIPHER* cipher,
                                   const CryptoData& raw_key,
                                   const CryptoData& input,
                                   const CryptoData& counter,
                                   uint8_t* output) {
   DCHECK(cipher);
   DCHECK_EQ(16u, counter.byte_length());
 
   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
-  crypto::ScopedOpenSSL<EVP_CIPHER_CTX, EVP_CIPHER_CTX_free> context(
-      EVP_CIPHER_CTX_new());
-
-  if (!context.get())
-    return Status::OperationError();
-
+  bssl::ScopedEVP_CIPHER_CTX context;
   if (!EVP_CipherInit_ex(context.get(), cipher, NULL, raw_key.bytes(),
                          counter.bytes(), ENCRYPT)) {
     return Status::OperationError();
   }
 
   int output_len = 0;
   if (!EVP_CipherUpdate(context.get(), output, &output_len, input.bytes(),
                         input.byte_length())) {
     return Status::OperationError();
   }
@@ skipping 11 matching lines @@
 }
 
 // Returns ceil(a/b), where a and b are integers.
 template <typename T>
 T CeilDiv(T a, T b) {
   return a == 0 ? 0 : 1 + (a - 1) / b;
 }
 
 // Extracts the counter as a BIGNUM. The counter is the rightmost
 // "counter_length_bits" of the block, interpreted as a big-endian number.
-crypto::ScopedBIGNUM GetCounter(const CryptoData& counter_block,
-                                unsigned int counter_length_bits) {
+bssl::UniquePtr<BIGNUM> GetCounter(const CryptoData& counter_block,
+                                   unsigned int counter_length_bits) {
   unsigned int counter_length_remainder_bits = (counter_length_bits % 8);
 
   // If the counter is a multiple of 8 bits then can call BN_bin2bn() directly.
   if (counter_length_remainder_bits == 0) {
     unsigned int byte_length = counter_length_bits / 8;
-    return crypto::ScopedBIGNUM(BN_bin2bn(
+    return bssl::UniquePtr<BIGNUM>(BN_bin2bn(
         counter_block.bytes() + counter_block.byte_length() - byte_length,
         byte_length, NULL));
   }
 
   // Otherwise make a copy of the counter and zero out the topmost bits so
   // BN_bin2bn() can be called with a byte stream.
   unsigned int byte_length = CeilDiv(counter_length_bits, 8u);
   std::vector<uint8_t> counter(
       counter_block.bytes() + counter_block.byte_length() - byte_length,
       counter_block.bytes() + counter_block.byte_length());
   counter[0] &= ~(0xFF << counter_length_remainder_bits);
 
-  return crypto::ScopedBIGNUM(BN_bin2bn(counter.data(), counter.size(), NULL));
+  return bssl::UniquePtr<BIGNUM>(
+      BN_bin2bn(counter.data(), counter.size(), NULL));
 }
 
 // Returns a counter block with the counter bits all set all zero.
 std::vector<uint8_t> BlockWithZeroedCounter(const CryptoData& counter_block,
                                             unsigned int counter_length_bits) {
   unsigned int counter_length_bytes = counter_length_bits / 8;
   unsigned int counter_length_bits_remainder = counter_length_bits % 8;
 
   std::vector<uint8_t> new_counter_block(
       counter_block.bytes(),
@@ skipping 45 matching lines @@
     return Status::ErrorDataTooLarge();
 
   const EVP_CIPHER* const cipher = GetAESCipherByKeyLength(raw_key.size());
   if (!cipher)
     return Status::ErrorUnexpected();
 
   const CryptoData counter_block(params->counter());
   buffer->resize(output_max_len.ValueOrDie());
 
   // The total number of possible counter values is pow(2, counter_length_bits)
-  crypto::ScopedBIGNUM num_counter_values(BN_new());
+  bssl::UniquePtr<BIGNUM> num_counter_values(BN_new());
   if (!BN_lshift(num_counter_values.get(), BN_value_one(), counter_length_bits))
     return Status::ErrorUnexpected();
 
-  crypto::ScopedBIGNUM current_counter =
+  bssl::UniquePtr<BIGNUM> current_counter =
       GetCounter(counter_block, counter_length_bits);
 
   // The number of AES blocks needed for encryption/decryption. The counter is
   // incremented this many times.
-  crypto::ScopedBIGNUM num_output_blocks(BN_new());
+  bssl::UniquePtr<BIGNUM> num_output_blocks(BN_new());
   if (!BN_set_word(
           num_output_blocks.get(),
           CeilDiv(buffer->size(), static_cast<size_t>(AES_BLOCK_SIZE)))) {
     return Status::ErrorUnexpected();
   }
 
   // If the counter is going to be incremented more times than there are counter
   // values, fail. (Repeating values of the counter block is bad).
   if (BN_cmp(num_output_blocks.get(), num_counter_values.get()) > 0)
     return Status::ErrorAesCtrInputTooLongCounterRepeated();
 
   // This is the number of blocks that can be successfully encrypted without
   // overflowing the counter. Encrypting the subsequent block will need to
   // reset the counter to zero.
-  crypto::ScopedBIGNUM num_blocks_until_reset(BN_new());
+  bssl::UniquePtr<BIGNUM> num_blocks_until_reset(BN_new());
 
   if (!BN_sub(num_blocks_until_reset.get(), num_counter_values.get(),
               current_counter.get())) {
     return Status::ErrorUnexpected();
   }
 
   // If the counter can be incremented for the entire input without
   // wrapping-around, do it as a single call into BoringSSL.
   if (BN_cmp(num_blocks_until_reset.get(), num_output_blocks.get()) >= 0) {
     return AesCtrEncrypt128BitCounter(cipher, CryptoData(raw_key), data,
@@ skipping 47 matching lines @@
   }
 };
 
 }  // namespace
 
 std::unique_ptr<AlgorithmImplementation> CreateAesCtrImplementation() {
   return base::WrapUnique(new AesCtrImplementation);
 }
 
 }  // namespace webcrypto