Fix client certificate regressions on Android < 4.2

net/android/java/src/org/chromium/net/DefaultAndroidKeyStore.java

 // Copyright 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.
 
 package org.chromium.net;
 
 import android.util.Log;
 
 import java.lang.reflect.Method;
 import java.security.NoSuchAlgorithmException;
@@ skipping 149 matching lines @@
         try {
             superClass = Class.forName(
                     "org.apache.harmony.xnet.provider.jsse.OpenSSLRSAPrivateKey");
         } catch (Exception e) {
             // This may happen if the target device has a completely different
             // implementation of the java.security APIs, compared to vanilla
             // Android. Highly unlikely, but still possible.
             Log.e(TAG, "Cannot find system OpenSSLRSAPrivateKey class: " + e);
             return 0;
         }
-        if (!superClass.isInstance(key)) {
+        if (!superClass.isInstance(javaKey)) {
             // This may happen if the PrivateKey was not created by the "AndroidOpenSSL"
             // provider, which should be the default. That could happen if an OEM decided
             // to implement a different default provider. Also highly unlikely.
             Log.e(TAG, "Private key is not an OpenSSLRSAPrivateKey instance, its class name is:" +
                        javaKey.getClass().getCanonicalName());
             return 0;
         }
 
         try {
             // Use reflection to invoke the 'getOpenSSLKey()' method on
             // the private key. This returns another Java object that wraps
             // a native EVP_PKEY. Note that the method is final, so calling
             // the superclass implementation is ok.
             Method getKey = superClass.getDeclaredMethod("getOpenSSLKey");
             getKey.setAccessible(true);
             Object opensslKey = null;
             try {
                 opensslKey = getKey.invoke(javaKey);
             } finally {
                 getKey.setAccessible(false);
             }
             if (opensslKey == null) {
                 // Bail when detecting OEM "enhancement".
                 Log.e(TAG, "getOpenSSLKey() returned null");
                 return 0;
             }
 
             // Use reflection to invoke the 'getPkeyContext' method on the
             // result of the getOpenSSLKey(). This is an 32-bit integer
-            // which is the address of an EVP_PKEY object.
+            // which is the address of an EVP_PKEY object. Note that this
+            // method these days returns a 64-bit long, but since this code
+            // path is used for older Android versions, it may still return
+            // a 32-bit int here. To be on the safe side, we cast the return
+            // value via Number rather than directly to Integer or Long.
             Method getPkeyContext;
             try {
                 getPkeyContext = opensslKey.getClass().getDeclaredMethod("getPkeyContext");
             } catch (Exception e) {
                 // Bail here too, something really not working as expected.
                 Log.e(TAG, "No getPkeyContext() method on OpenSSLKey member:" + e);
                 return 0;
             }
             getPkeyContext.setAccessible(true);
             long evp_pkey = 0;
             try {
-                evp_pkey = (Long) getPkeyContext.invoke(opensslKey);
+                evp_pkey = ((Number) getPkeyContext.invoke(opensslKey)).longValue();
             } finally {
                 getPkeyContext.setAccessible(false);
             }
             if (evp_pkey == 0) {
                 // The PrivateKey is probably rotten for some reason.
                 Log.e(TAG, "getPkeyContext() returned null");
             }
             return evp_pkey;
 
         } catch (Exception e) {
             Log.e(TAG, "Exception while trying to retrieve system EVP_PKEY handle: " + e);
             return 0;
         }
     }
 
     @Override
     public void releaseKey(AndroidPrivateKey key) {
         // no-op for in-process. GC will handle key collection
     }
 }