Use new BoringSSL scopers in //components.

components/webcrypto/algorithms/ec.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 "components/webcrypto/algorithms/ec.h"
 
+#include <openssl/bn.h>
+#include <openssl/bytestring.h>
 #include <openssl/ec.h>
 #include <openssl/ec_key.h>
 #include <openssl/evp.h>
+#include <openssl/mem.h>
 #include <stddef.h>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "components/webcrypto/algorithms/asymmetric_key_util.h"
 #include "components/webcrypto/algorithms/util.h"
 #include "components/webcrypto/blink_key_handle.h"
 #include "components/webcrypto/crypto_data.h"
 #include "components/webcrypto/generate_key_result.h"
 #include "components/webcrypto/jwk.h"
 #include "components/webcrypto/status.h"
-#include "crypto/auto_cbb.h"
 #include "crypto/openssl_util.h"
-#include "crypto/scoped_openssl_types.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
 #include "third_party/WebKit/public/platform/WebCryptoKeyAlgorithm.h"
 
 namespace webcrypto {
 
 namespace {
 
 // Maps a blink::WebCryptoNamedCurve to the corresponding NID used by
 // BoringSSL.
 Status WebCryptoCurveToNid(blink::WebCryptoNamedCurve named_curve, int* nid) {
@@ skipping 99 matching lines @@
     return status;
 
   if (named_curve != expected_named_curve)
     return Status::ErrorImportedEcKeyIncorrectCurve();
 
   return Status::Success();
 }
 
 // Creates an EC_KEY for the given WebCryptoNamedCurve.
 Status CreateEC_KEY(blink::WebCryptoNamedCurve named_curve,
-                    crypto::ScopedEC_KEY* ec) {
+                    bssl::UniquePtr<EC_KEY>* ec) {
   int curve_nid = 0;
   Status status = WebCryptoCurveToNid(named_curve, &curve_nid);
   if (status.IsError())
     return status;
 
   ec->reset(EC_KEY_new_by_curve_name(curve_nid));
   if (!ec->get())
     return Status::OperationError();
 
   return Status::Success();
 }
 
 // Writes an unsigned BIGNUM into |jwk|, zero-padding it to a length of
 // |padded_length|.
 Status WritePaddedBIGNUM(const std::string& member_name,
                          const BIGNUM* value,
                          size_t padded_length,
                          JwkWriter* jwk) {
   std::vector<uint8_t> padded_bytes(padded_length);
   if (!BN_bn2bin_padded(padded_bytes.data(), padded_bytes.size(), value))
     return Status::OperationError();
   jwk->SetBytes(member_name, CryptoData(padded_bytes));
   return Status::Success();
 }
 
 // Reads a fixed length BIGNUM from a JWK.
 Status ReadPaddedBIGNUM(const JwkReader& jwk,
                         const std::string& member_name,
                         size_t expected_length,
-                        crypto::ScopedBIGNUM* out) {
+                        bssl::UniquePtr<BIGNUM>* out) {
   std::string bytes;
   Status status = jwk.GetBytes(member_name, &bytes);
   if (status.IsError())
     return status;
 
   if (bytes.size() != expected_length) {
     return Status::JwkOctetStringWrongLength(member_name, expected_length,
                                              bytes.size());
   }
 
   out->reset(CreateBIGNUM(bytes));
   return Status::Success();
 }
 
 int GetGroupDegreeInBytes(EC_KEY* ec) {
   const EC_GROUP* group = EC_KEY_get0_group(ec);
   return NumBitsToBytes(EC_GROUP_get_degree(group));
 }
 
 // Extracts the public key as affine coordinates (x,y).
 Status GetPublicKey(EC_KEY* ec,
-                    crypto::ScopedBIGNUM* x,
-                    crypto::ScopedBIGNUM* y) {
+                    bssl::UniquePtr<BIGNUM>* x,
+                    bssl::UniquePtr<BIGNUM>* y) {
   const EC_GROUP* group = EC_KEY_get0_group(ec);
   const EC_POINT* point = EC_KEY_get0_public_key(ec);
 
   x->reset(BN_new());
   y->reset(BN_new());
 
   if (!EC_POINT_get_affine_coordinates_GFp(group, point, x->get(), y->get(),
                                            NULL)) {
     return Status::OperationError();
   }
@@ skipping 23 matching lines @@
       combined_usages, all_public_key_usages_, all_private_key_usages_,
       &public_usages, &private_usages);
   if (status.IsError())
     return status;
 
   const blink::WebCryptoEcKeyGenParams* params = algorithm.ecKeyGenParams();
 
   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
 
   // Generate an EC key pair.
-  crypto::ScopedEC_KEY ec_private_key;
+  bssl::UniquePtr<EC_KEY> ec_private_key;
   status = CreateEC_KEY(params->namedCurve(), &ec_private_key);
   if (status.IsError())
     return status;
 
   if (!EC_KEY_generate_key(ec_private_key.get()))
     return Status::OperationError();
 
   // Construct an EVP_PKEY for the private key.
-  crypto::ScopedEVP_PKEY private_pkey(EVP_PKEY_new());
+  bssl::UniquePtr<EVP_PKEY> private_pkey(EVP_PKEY_new());
   if (!private_pkey ||
       !EVP_PKEY_set1_EC_KEY(private_pkey.get(), ec_private_key.get())) {
     return Status::OperationError();
   }
 
   // Construct an EVP_PKEY for just the public key.
-  crypto::ScopedEC_KEY ec_public_key;
-  crypto::ScopedEVP_PKEY public_pkey(EVP_PKEY_new());
+  bssl::UniquePtr<EC_KEY> ec_public_key;
+  bssl::UniquePtr<EVP_PKEY> public_pkey(EVP_PKEY_new());
   status = CreateEC_KEY(params->namedCurve(), &ec_public_key);
   if (status.IsError())
     return status;
   if (!EC_KEY_set_public_key(ec_public_key.get(),
                              EC_KEY_get0_public_key(ec_private_key.get()))) {
     return Status::OperationError();
   }
   if (!public_pkey ||
       !EVP_PKEY_set1_EC_KEY(public_pkey.get(), ec_public_key.get())) {
     return Status::OperationError();
@@ skipping 67 matching lines @@
   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
 
   Status status = CheckKeyCreationUsages(all_public_key_usages_, usages);
   if (status.IsError())
     return status;
 
   const blink::WebCryptoEcKeyImportParams* params =
       algorithm.ecKeyImportParams();
 
   // Create an EC_KEY.
-  crypto::ScopedEC_KEY ec;
+  bssl::UniquePtr<EC_KEY> ec;
   status = CreateEC_KEY(params->namedCurve(), &ec);
   if (status.IsError())
     return status;
 
-  crypto::ScopedEC_POINT point(EC_POINT_new(EC_KEY_get0_group(ec.get())));
+  bssl::UniquePtr<EC_POINT> point(EC_POINT_new(EC_KEY_get0_group(ec.get())));
   if (!point.get())
     return Status::OperationError();
 
   // Convert the "raw" input from X9.62 format to an EC_POINT.
   if (!EC_POINT_oct2point(EC_KEY_get0_group(ec.get()), point.get(),
                           key_data.bytes(), key_data.byte_length(), nullptr)) {
     return Status::DataError();
   }
 
   // Copy the point (public key) into the EC_KEY.
   if (!EC_KEY_set_public_key(ec.get(), point.get()))
     return Status::OperationError();
 
   // Verify the key.
   if (!EC_KEY_check_key(ec.get()))
     return Status::ErrorEcKeyInvalid();
 
   // Wrap the EC_KEY into an EVP_PKEY.
-  crypto::ScopedEVP_PKEY pkey(EVP_PKEY_new());
+  bssl::UniquePtr<EVP_PKEY> pkey(EVP_PKEY_new());
   if (!pkey || !EVP_PKEY_set1_EC_KEY(pkey.get(), ec.get()))
     return Status::OperationError();
 
   blink::WebCryptoKeyAlgorithm key_algorithm =
       blink::WebCryptoKeyAlgorithm::createEc(algorithm.id(),
                                              params->namedCurve());
 
   // Wrap the EVP_PKEY into a WebCryptoKey
   return CreateWebCryptoPublicKey(std::move(pkey), key_algorithm, extractable,
                                   usages, key);
 }
 
 Status EcAlgorithm::ImportKeyPkcs8(const CryptoData& key_data,
                                    const blink::WebCryptoAlgorithm& algorithm,
                                    bool extractable,
                                    blink::WebCryptoKeyUsageMask usages,
                                    blink::WebCryptoKey* key) const {
   Status status = CheckKeyCreationUsages(all_private_key_usages_, usages);
   if (status.IsError())
     return status;
 
-  crypto::ScopedEVP_PKEY private_key;
+  bssl::UniquePtr<EVP_PKEY> private_key;
   status = ImportUnverifiedPkeyFromPkcs8(key_data, EVP_PKEY_EC, &private_key);
   if (status.IsError())
     return status;
 
   const blink::WebCryptoEcKeyImportParams* params =
       algorithm.ecKeyImportParams();
 
   status = VerifyEcKeyAfterSpkiOrPkcs8Import(private_key.get(),
                                              params->namedCurve());
   if (status.IsError())
     return status;
 
   return CreateWebCryptoPrivateKey(std::move(private_key),
                                    blink::WebCryptoKeyAlgorithm::createEc(
                                        algorithm.id(), params->namedCurve()),
                                    extractable, usages, key);
 }
 
 Status EcAlgorithm::ImportKeySpki(const CryptoData& key_data,
                                   const blink::WebCryptoAlgorithm& algorithm,
                                   bool extractable,
                                   blink::WebCryptoKeyUsageMask usages,
                                   blink::WebCryptoKey* key) const {
   Status status = CheckKeyCreationUsages(all_public_key_usages_, usages);
   if (status.IsError())
     return status;
 
-  crypto::ScopedEVP_PKEY public_key;
+  bssl::UniquePtr<EVP_PKEY> public_key;
   status = ImportUnverifiedPkeyFromSpki(key_data, EVP_PKEY_EC, &public_key);
   if (status.IsError())
     return status;
 
   const blink::WebCryptoEcKeyImportParams* params =
       algorithm.ecKeyImportParams();
 
   status =
       VerifyEcKeyAfterSpkiOrPkcs8Import(public_key.get(), params->namedCurve());
   if (status.IsError())
@@ skipping 48 matching lines @@
   if (is_private_key) {
     status = CheckKeyCreationUsages(all_private_key_usages_, usages);
   } else {
     status = CheckKeyCreationUsages(all_public_key_usages_, usages);
   }
 
   if (status.IsError())
     return status;
 
   // Create an EC_KEY.
-  crypto::ScopedEC_KEY ec;
+  bssl::UniquePtr<EC_KEY> ec;
   status = CreateEC_KEY(params->namedCurve(), &ec);
   if (status.IsError())
     return status;
 
   // JWK requires the length of x, y, d to match the group degree.
   int degree_bytes = GetGroupDegreeInBytes(ec.get());
 
   // Read the public key's uncompressed affine coordinates.
-  crypto::ScopedBIGNUM x;
+  bssl::UniquePtr<BIGNUM> x;
   status = ReadPaddedBIGNUM(jwk, "x", degree_bytes, &x);
   if (status.IsError())
     return status;
 
-  crypto::ScopedBIGNUM y;
+  bssl::UniquePtr<BIGNUM> y;
   status = ReadPaddedBIGNUM(jwk, "y", degree_bytes, &y);
   if (status.IsError())
     return status;
 
   // TODO(eroman): Distinguish more accurately between a DataError and
   // OperationError. In general if this fails it was due to the key being an
   // invalid EC key.
   if (!EC_KEY_set_public_key_affine_coordinates(ec.get(), x.get(), y.get()))
     return Status::DataError();
 
   // Extract the "d" parameters.
   if (is_private_key) {
-    crypto::ScopedBIGNUM d;
+    bssl::UniquePtr<BIGNUM> d;
     status = ReadPaddedBIGNUM(jwk, "d", degree_bytes, &d);
     if (status.IsError())
       return status;
 
     if (!EC_KEY_set_private_key(ec.get(), d.get()))
       return Status::OperationError();
   }
 
   // Verify the key.
   if (!EC_KEY_check_key(ec.get()))
     return Status::ErrorEcKeyInvalid();
 
   // Wrap the EC_KEY into an EVP_PKEY.
-  crypto::ScopedEVP_PKEY pkey(EVP_PKEY_new());
+  bssl::UniquePtr<EVP_PKEY> pkey(EVP_PKEY_new());
   if (!pkey || !EVP_PKEY_set1_EC_KEY(pkey.get(), ec.get()))
     return Status::OperationError();
 
   blink::WebCryptoKeyAlgorithm key_algorithm =
       blink::WebCryptoKeyAlgorithm::createEc(algorithm.id(),
                                              params->namedCurve());
 
   // Wrap the EVP_PKEY into a WebCryptoKey
   if (is_private_key) {
     return CreateWebCryptoPrivateKey(std::move(pkey), key_algorithm,
@@ skipping 12 matching lines @@
 
   EVP_PKEY* pkey = GetEVP_PKEY(key);
 
   EC_KEY* ec = EVP_PKEY_get0_EC_KEY(pkey);
   if (!ec)
     return Status::ErrorUnexpected();
 
   // Serialize the public key as an uncompressed point in X9.62 form.
   uint8_t* raw;
   size_t raw_len;
-  crypto::AutoCBB cbb;
+  bssl::ScopedCBB cbb;
   if (!CBB_init(cbb.get(), 0) ||
       !EC_POINT_point2cbb(cbb.get(), EC_KEY_get0_group(ec),
                           EC_KEY_get0_public_key(ec),
                           POINT_CONVERSION_UNCOMPRESSED, nullptr) ||
       !CBB_finish(cbb.get(), &raw, &raw_len)) {
     return Status::OperationError();
   }
   buffer->assign(raw, raw + raw_len);
   OPENSSL_free(raw);
 
@@ skipping 41 matching lines @@
   std::string crv;
   Status status =
       WebCryptoCurveToJwkCrv(key.algorithm().ecParams()->namedCurve(), &crv);
   if (status.IsError())
     return status;
 
   int degree_bytes = GetGroupDegreeInBytes(ec);
 
   jwk.SetString("crv", crv);
 
-  crypto::ScopedBIGNUM x;
-  crypto::ScopedBIGNUM y;
+  bssl::UniquePtr<BIGNUM> x;
+  bssl::UniquePtr<BIGNUM> y;
   status = GetPublicKey(ec, &x, &y);
   if (status.IsError())
     return status;
 
   status = WritePaddedBIGNUM("x", x.get(), degree_bytes, &jwk);
   if (status.IsError())
     return status;
 
   status = WritePaddedBIGNUM("y", y.get(), degree_bytes, &jwk);
   if (status.IsError())
@@ skipping 50 matching lines @@
 
   if (algorithm.ecParams()->namedCurve() !=
       key->algorithm().ecParams()->namedCurve()) {
     return Status::ErrorUnexpected();
   }
 
   return Status::Success();
 }
 
 }  // namespace webcrypto