Use ScopedEVP_PKEY in keystore_openssl.cc.

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>
 #include <openssl/dsa.h>
 #include <openssl/ec.h>
 #include <openssl/engine.h>
 #include <openssl/err.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/android/legacy_openssl.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
@@ skipping 274 matching lines @@
     NULL /* bn_mod_exp */,
     RSA_FLAG_OPAQUE,
     NULL /* keygen */,
 };
 
 // Setup an EVP_PKEY to wrap an existing platform RSA PrivateKey object.
 // |private_key| is the JNI reference (local or global) to the object.
 // |legacy_rsa|, if non-NULL, is a pointer to the system OpenSSL RSA object
 // backing |private_key|. This parameter is only used for Android < 4.2 to
 // implement key operations not exposed by the platform.
-// |pkey| is the EVP_PKEY to setup as a wrapper.
-// Returns true on success, false otherwise.
+// Returns a new EVP_PKEY on success, NULL 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.
-bool GetRsaPkeyWrapper(jobject private_key,
-                       AndroidRSA* legacy_rsa,
-                       EVP_PKEY* pkey) {
+crypto::ScopedEVP_PKEY GetRsaPkeyWrapper(jobject private_key,
+                                         AndroidRSA* legacy_rsa) {
   crypto::ScopedRSA rsa(
       RSA_new_method(global_boringssl_engine.Get().engine()));
 
   ScopedJavaGlobalRef<jobject> global_key;
   global_key.Reset(NULL, private_key);
   if (global_key.is_null()) {
     LOG(ERROR) << "Could not create global JNI reference";
-    return false;
+    return crypto::ScopedEVP_PKEY();
   }
 
   std::vector<uint8> modulus;
   if (!GetRSAKeyModulus(private_key, &modulus)) {
     LOG(ERROR) << "Failed to get private key modulus";
-    return false;
+    return crypto::ScopedEVP_PKEY();
   }
 
   KeyExData* ex_data = new KeyExData;
   ex_data->private_key = global_key.Release();
   ex_data->legacy_rsa = legacy_rsa;
   ex_data->cached_size = VectorBignumSize(modulus);
   RSA_set_ex_data(
       rsa.get(), global_boringssl_engine.Get().rsa_ex_index(), ex_data);
-  EVP_PKEY_assign_RSA(pkey, rsa.release());
-  return true;
+
+  crypto::ScopedEVP_PKEY pkey(EVP_PKEY_new());
+  if (!pkey ||
+      !EVP_PKEY_set1_RSA(pkey.get(), rsa.get())) {

[davidben, 2014/09/09 23:07:19]

It doesn't really matter because EVP_PKEY_set1_RSA can't fail anyway, but it
does have a return value and the EVP_PKEY_assign_RSA version has this awkward
property that it takes ownership of its argument only if it succeeds.

+    return crypto::ScopedEVP_PKEY();
+  }
+  return pkey.Pass();
 }
 
 // On Android < 4.2, the libkeystore.so ENGINE uses CRYPTO_EX_DATA and is not
 // added to the global engine list. If all references to it are dropped, OpenSSL
 // will dlclose the module, leaving a dangling function pointer in the RSA
 // CRYPTO_EX_DATA class. To work around this, leak an extra reference to the
 // ENGINE we extract in GetRsaLegacyKey.
 //
 // In 4.2, this change avoids the problem:
 // https://android.googlesource.com/platform/libcore/+/106a8928fb4249f2f3d4dba1dddbe73ca5cb3d61
@@ skipping 23 matching lines @@
   static base::LazyInstance<KeystoreEngineWorkaround>::Leaky s_instance =
       LAZY_INSTANCE_INITIALIZER;
   s_instance.Get().LeakEngine(private_key);
 }
 
 // Setup an EVP_PKEY to wrap an existing platform RSA PrivateKey object
 // for Android 4.0 to 4.1.x. Must only be used on Android < 4.2.
 // |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.
-EVP_PKEY* GetRsaLegacyKey(jobject private_key) {
+crypto::ScopedEVP_PKEY GetRsaLegacyKey(jobject private_key) {
   AndroidEVP_PKEY* sys_pkey =
       GetOpenSSLSystemHandleForPrivateKey(private_key);
   if (sys_pkey != NULL) {
     if (sys_pkey->type != ANDROID_EVP_PKEY_RSA) {
       LOG(ERROR) << "Private key has wrong type!";
-      return NULL;
+      return crypto::ScopedEVP_PKEY();
     }
 
     AndroidRSA* sys_rsa = sys_pkey->pkey.rsa;
     if (sys_rsa->engine) {
       // |private_key| may not have an engine if the PrivateKey did not come
       // from the key store, such as in unit tests.
       if (strcmp(sys_rsa->engine->id, "keystore") == 0) {
         LeakEngine(private_key);
       } else {
         NOTREACHED();
       }
     }
 
-    crypto::ScopedEVP_PKEY pkey(EVP_PKEY_new());
-    if (!GetRsaPkeyWrapper(private_key, sys_rsa, pkey.get()))
-      return NULL;
-    return pkey.release();
+    return GetRsaPkeyWrapper(private_key, sys_rsa);
   }
 
   // GetOpenSSLSystemHandleForPrivateKey() will fail on Android 4.0.3 and
   // earlier. However, it is possible to get the key content with
   // PrivateKey.getEncoded() on these platforms.  Note that this method may
   // return NULL on 4.0.4 and later.
   std::vector<uint8> encoded;
   if (!GetPrivateKeyEncodedBytes(private_key, &encoded)) {
     LOG(ERROR) << "Can't get private key data!";
-    return NULL;
+    return crypto::ScopedEVP_PKEY();
   }
   const unsigned char* p =
       reinterpret_cast<const unsigned char*>(&encoded[0]);
   int len = static_cast<int>(encoded.size());
-  EVP_PKEY* pkey = d2i_AutoPrivateKey(NULL, &p, len);
-  if (pkey == NULL) {
+  crypto::ScopedEVP_PKEY pkey(d2i_AutoPrivateKey(NULL, &p, len));
+  if (!pkey) {
     LOG(ERROR) << "Can't convert private key data!";
-    return NULL;
+    return crypto::ScopedEVP_PKEY();
   }
-  return pkey;
+  return pkey.Pass();
 }
 
 // Custom ECDSA_METHOD that uses the platform APIs.
 // Note that for now, only signing through ECDSA_sign() is really supported.
 // all other method pointers are either stubs returning errors, or no-ops.
 
 jobject EcKeyGetKey(const EC_KEY* ec_key) {
   KeyExData* ex_data = reinterpret_cast<KeyExData*>(EC_KEY_get_ex_data(
       ec_key, global_boringssl_engine.Get().ec_key_ex_index()));
   return ex_data->private_key;
@@ skipping 45 matching lines @@
                       const uint8_t* sig,
                       size_t sig_len,
                       EC_KEY* ec_key) {
   NOTIMPLEMENTED();
   OPENSSL_PUT_ERROR(ECDSA, ECDSA_do_verify, ECDSA_R_NOT_IMPLEMENTED);
   return 0;
 }
 
 // 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.
+// Returns a new EVP_PKEY on success, NULL 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) {
+crypto::ScopedEVP_PKEY GetEcdsaPkeyWrapper(jobject private_key) {
   crypto::ScopedEC_KEY ec_key(
       EC_KEY_new_method(global_boringssl_engine.Get().engine()));
 
   ScopedJavaGlobalRef<jobject> global_key;
   global_key.Reset(NULL, private_key);
   if (global_key.is_null()) {
     LOG(ERROR) << "Can't create global JNI reference";
-    return false;
+    return crypto::ScopedEVP_PKEY();
   }
 
   std::vector<uint8> order;
   if (!GetECKeyOrder(private_key, &order)) {
     LOG(ERROR) << "Can't extract order parameter from EC private key";
-    return false;
+    return crypto::ScopedEVP_PKEY();
   }
 
   KeyExData* ex_data = new KeyExData;
   ex_data->private_key = global_key.Release();
   ex_data->legacy_rsa = NULL;
   ex_data->cached_size = VectorBignumSize(order);
 
   EC_KEY_set_ex_data(
       ec_key.get(), global_boringssl_engine.Get().ec_key_ex_index(), ex_data);
 
-  EVP_PKEY_assign_EC_KEY(pkey, ec_key.release());
-  return true;
+  crypto::ScopedEVP_PKEY pkey(EVP_PKEY_new());
+  if (!pkey ||
+      !EVP_PKEY_set1_EC_KEY(pkey.get(), ec_key.get())) {
+    return crypto::ScopedEVP_PKEY();
+  }
+  return pkey.Pass();
 }
 
 const ECDSA_METHOD android_ecdsa_method = {
     {
      0 /* references */,
      1 /* is_static */
     } /* common */,
     NULL /* app_data */,
 
     NULL /* init */,
     NULL /* finish */,
     EcdsaMethodGroupOrderSize,
     EcdsaMethodSign,
     EcdsaMethodVerify,
     ECDSA_FLAG_OPAQUE,
 };
 
 }  // namespace
 
-EVP_PKEY* GetOpenSSLPrivateKeyWrapper(jobject private_key) {
-  // Create new empty EVP_PKEY instance.
-  crypto::ScopedEVP_PKEY pkey(EVP_PKEY_new());
-  if (!pkey.get())
-    return NULL;
+crypto::ScopedEVP_PKEY GetOpenSSLPrivateKeyWrapper(jobject private_key) {
+  const int kAndroid42ApiLevel = 17;
 
   // 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
-        // instead, obtain a raw EVP_PKEY* to the system object
-        // backing this PrivateKey object.
-        const int kAndroid42ApiLevel = 17;
-        if (base::android::BuildInfo::GetInstance()->sdk_int() <
-            kAndroid42ApiLevel) {
-          EVP_PKEY* legacy_key = GetRsaLegacyKey(private_key);
-          if (legacy_key == NULL)
-            return NULL;
-          pkey.reset(legacy_key);
-        } else {
-          // Running on Android 4.2.
-          if (!GetRsaPkeyWrapper(private_key, NULL, pkey.get()))
-            return NULL;
-        }
+      // Route around platform bug: if Android < 4.2, then
+      // base::android::RawSignDigestWithPrivateKey() cannot work, so
+      // instead, obtain a raw EVP_PKEY* to the system object
+      // backing this PrivateKey object.
+      if (base::android::BuildInfo::GetInstance()->sdk_int() <
+          kAndroid42ApiLevel) {
+        return GetRsaLegacyKey(private_key);
+      } else {
+        // Running on Android 4.2.
+        return GetRsaPkeyWrapper(private_key, NULL);
       }
-      break;
     case PRIVATE_KEY_TYPE_ECDSA:
-      if (!GetEcdsaPkeyWrapper(private_key, pkey.get()))
-        return NULL;
-      break;
+      return GetEcdsaPkeyWrapper(private_key);
     default:
       LOG(WARNING)
           << "GetOpenSSLPrivateKeyWrapper() called with invalid key type";
-      return NULL;
+      return crypto::ScopedEVP_PKEY();
   }
-  return pkey.release();
 }
 
 }  // namespace android
 }  // namespace net