Eliminate ScopedOpenSSL in favour of scoped_ptr<> specializations.

net/android/keystore_openssl.cc

 // Copyright (c) 2013 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 "net/android/keystore_openssl.h"
 
 #include <jni.h>
 #include <openssl/bn.h>
 // This include is required to get the ECDSA_METHOD structure definition
 // which isn't currently part of the OpenSSL official ABI. This should
 // not be a concern for Chromium which always links against its own
 // version of the library on Android.
 #include <openssl/crypto/ecdsa/ecs_locl.h>
 // And this one is needed for the EC_GROUP definition.
 #include <openssl/crypto/ec/ec_lcl.h>
 #include <openssl/dsa.h>
 #include <openssl/ec.h>
 #include <openssl/engine.h>
 #include <openssl/evp.h>
 #include <openssl/rsa.h>
 
 #include "base/android/build_info.h"
 #include "base/android/jni_android.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/basictypes.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "crypto/openssl_util.h"
+#include "crypto/scoped_openssl_types.h"
 #include "net/android/keystore.h"
 #include "net/ssl/ssl_client_cert_type.h"
 
 // IMPORTANT NOTE: The following code will currently only work when used
 // to implement client certificate support with OpenSSL. That's because
 // only the signing operations used in this use case are implemented here.
 //
 // Generally speaking, OpenSSL provides many different ways to sign
 // digests. This code doesn't support all these cases, only the ones that
 // are required to sign the digest during the OpenSSL handshake for TLS.
@@ skipping 55 matching lines @@
 // default for a lot of operations. Very fortunately, this is not needed
 // here, which saves a lot of complexity.
 
 using base::android::ScopedJavaGlobalRef;
 
 namespace net {
 namespace android {
 
 namespace {
 
-typedef crypto::ScopedOpenSSL<EVP_PKEY, EVP_PKEY_free> ScopedEVP_PKEY;
-typedef crypto::ScopedOpenSSL<RSA, RSA_free> ScopedRSA;
-typedef crypto::ScopedOpenSSL<DSA, DSA_free> ScopedDSA;
-typedef crypto::ScopedOpenSSL<EC_KEY, EC_KEY_free> ScopedEC_KEY;
-typedef crypto::ScopedOpenSSL<EC_GROUP, EC_GROUP_free> ScopedEC_GROUP;
+typedef scoped_ptr<EC_GROUP, crypto::OpenSSLDestroyer<EC_GROUP, EC_GROUP_free> >
+    ScopedEC_GROUP;
 
 // Custom RSA_METHOD that uses the platform APIs.
 // Note that for now, only signing through RSA_sign() is really supported.
 // all other method pointers are either stubs returning errors, or no-ops.
 // See <openssl/rsa.h> for exact declaration of RSA_METHOD.
 
 int RsaMethodPubEnc(int flen,
                     const unsigned char* from,
                     unsigned char* to,
                     RSA* rsa,
@@ skipping 157 matching lines @@
 // Setup an EVP_PKEY to wrap an existing platform RSA PrivateKey object.
 // |private_key| is the JNI reference (local or global) to the object.
 // |pkey| is the EVP_PKEY to setup as a wrapper.
 // Returns true on success, false otherwise.
 // On success, this creates a new global JNI reference to the object
 // that is owned by and destroyed with the EVP_PKEY. I.e. caller can
 // free |private_key| after the call.
 // IMPORTANT: The EVP_PKEY will *only* work on Android >= 4.2. For older
 // platforms, use GetRsaLegacyKey() instead.
 bool GetRsaPkeyWrapper(jobject private_key, EVP_PKEY* pkey) {
-  ScopedRSA rsa(RSA_new());
+  crypto::ScopedRSA rsa(RSA_new());
   RSA_set_method(rsa.get(), &android_rsa_method);
 
   // HACK: RSA_size() doesn't work with custom RSA_METHODs. To ensure that
   // it will return the right value, set the 'n' field of the RSA object
   // to match the private key's modulus.
   std::vector<uint8> modulus;
   if (!GetRSAKeyModulus(private_key, &modulus)) {
     LOG(ERROR) << "Failed to get private key modulus";
     return false;
   }
@@ skipping 23 matching lines @@
 // https://android.googlesource.com/platform/libcore/+/106a8928fb4249f2f3d4dba1dddbe73ca5cb3d61
 //
 // https://crbug.com/381465
 class KeystoreEngineWorkaround {
  public:
   KeystoreEngineWorkaround() : leaked_engine_(false) {}
 
   void LeakRsaEngine(EVP_PKEY* pkey) {
     if (leaked_engine_)
       return;
-    ScopedRSA rsa(EVP_PKEY_get1_RSA(pkey));
+    crypto::ScopedRSA rsa(EVP_PKEY_get1_RSA(pkey));
     if (!rsa.get() ||
         !rsa.get()->engine ||
         strcmp(ENGINE_get_id(rsa.get()->engine), "keystore") ||
         !ENGINE_init(rsa.get()->engine)) {
       NOTREACHED();
       return;
     }
     leaked_engine_ = true;
   }
 
@@ skipping 132 matching lines @@
   /* .dsa_keygen = */ NULL
 };
 
 // Setup an EVP_PKEY to wrap an existing DSA platform PrivateKey object.
 // |private_key| is a JNI reference (local or global) to the object.
 // |pkey| is the EVP_PKEY to setup as a wrapper.
 // Returns true on success, false otherwise.
 // On success, this creates a global JNI reference to the same object
 // that will be owned by and destroyed with the EVP_PKEY.
 bool GetDsaPkeyWrapper(jobject private_key, EVP_PKEY* pkey) {
-  ScopedDSA dsa(DSA_new());
+  crypto::ScopedDSA dsa(DSA_new());
   DSA_set_method(dsa.get(), &android_dsa_method);
 
   // DSA_size() doesn't work with custom DSA_METHODs. To ensure it
   // returns the right value, set the 'q' field in the DSA object to
   // match the parameter from the platform key.
   std::vector<uint8> q;
   if (!GetDSAKeyParamQ(private_key, &q)) {
     LOG(ERROR) << "Can't extract Q parameter from DSA private key";
     return false;
   }
@@ skipping 148 matching lines @@
 };
 
 // Setup an EVP_PKEY to wrap an existing platform PrivateKey object.
 // |private_key| is the JNI reference (local or global) to the object.
 // |pkey| is the EVP_PKEY to setup as a wrapper.
 // Returns true on success, false otherwise.
 // On success, this creates a global JNI reference to the object that
 // is owned by and destroyed with the EVP_PKEY. I.e. the caller shall
 // always free |private_key| after the call.
 bool GetEcdsaPkeyWrapper(jobject private_key, EVP_PKEY* pkey) {
-  ScopedEC_KEY eckey(EC_KEY_new());
+  crypto::ScopedEC_KEY eckey(EC_KEY_new());
   ECDSA_set_method(eckey.get(), &android_ecdsa_method);
 
   // To ensure that ECDSA_size() works properly, craft a custom EC_GROUP
   // that has the same order than the private key.
   std::vector<uint8> order;
   if (!GetECKeyOrder(private_key, &order)) {
     LOG(ERROR) << "Can't extract order parameter from EC private key";
     return false;
   }
   ScopedEC_GROUP group(EC_GROUP_new(EC_GFp_nist_method()));
@@ skipping 18 matching lines @@
                     global_key.Release());
 
   EVP_PKEY_assign_EC_KEY(pkey, eckey.release());
   return true;
 }
 
 }  // namespace
 
 EVP_PKEY* GetOpenSSLPrivateKeyWrapper(jobject private_key) {
   // Create new empty EVP_PKEY instance.
-  ScopedEVP_PKEY pkey(EVP_PKEY_new());
+  crypto::ScopedEVP_PKEY pkey(EVP_PKEY_new());
   if (!pkey.get())
     return NULL;
 
   // Create sub key type, depending on private key's algorithm type.
   PrivateKeyType key_type = GetPrivateKeyType(private_key);
   switch (key_type) {
     case PRIVATE_KEY_TYPE_RSA:
       {
         // Route around platform bug: if Android < 4.2, then
         // base::android::RawSignDigestWithPrivateKey() cannot work, so
@@ skipping 24 matching lines @@
     default:
       LOG(WARNING)
           << "GetOpenSSLPrivateKeyWrapper() called with invalid key type";
       return NULL;
   }
   return pkey.release();
 }
 
 }  // namespace android
 }  // namespace net