Upstream version 5.34.92.0
[platform/framework/web/crosswalk.git] / src / net / android / java / src / org / chromium / net / AndroidKeyStore.java
1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 package org.chromium.net;
6
7 import android.util.Log;
8
9 import org.chromium.base.CalledByNative;
10 import org.chromium.base.JNINamespace;
11
12 import java.lang.reflect.Method;
13 import java.security.NoSuchAlgorithmException;
14 import java.security.PrivateKey;
15 import java.security.Signature;
16 import java.security.interfaces.DSAKey;
17 import java.security.interfaces.DSAParams;
18 import java.security.interfaces.DSAPrivateKey;
19 import java.security.interfaces.ECKey;
20 import java.security.interfaces.ECPrivateKey;
21 import java.security.interfaces.RSAKey;
22 import java.security.interfaces.RSAPrivateKey;
23 import java.security.spec.ECParameterSpec;
24
25 @JNINamespace("net::android")
26 public class AndroidKeyStore {
27
28     private static final String TAG = "AndroidKeyStore";
29
30     ////////////////////////////////////////////////////////////////////
31     //
32     // Message signing support.
33
34     /**
35      * Returns the public modulus of a given RSA private key as a byte
36      * buffer.
37      * This can be used by native code to convert the modulus into
38      * an OpenSSL BIGNUM object. Required to craft a custom native RSA
39      * object where RSA_size() works as expected.
40      *
41      * @param key A PrivateKey instance, must implement RSAKey.
42      * @return A byte buffer corresponding to the modulus. This is
43      * big-endian representation of a BigInteger.
44      */
45     @CalledByNative
46     public static byte[] getRSAKeyModulus(PrivateKey key) {
47         if (key instanceof RSAKey) {
48             return ((RSAKey) key).getModulus().toByteArray();
49         } else {
50             Log.w(TAG, "Not a RSAKey instance!");
51             return null;
52         }
53     }
54
55     /**
56      * Returns the 'Q' parameter of a given DSA private key as a byte
57      * buffer.
58      * This can be used by native code to convert it into an OpenSSL BIGNUM
59      * object where DSA_size() works as expected.
60      *
61      * @param key A PrivateKey instance. Must implement DSAKey.
62      * @return A byte buffer corresponding to the Q parameter. This is
63      * a big-endian representation of a BigInteger.
64      */
65     @CalledByNative
66     public static byte[] getDSAKeyParamQ(PrivateKey key) {
67         if (key instanceof DSAKey) {
68             DSAParams params = ((DSAKey) key).getParams();
69             return params.getQ().toByteArray();
70         } else {
71             Log.w(TAG, "Not a DSAKey instance!");
72             return null;
73         }
74     }
75
76     /**
77      * Returns the 'order' parameter of a given ECDSA private key as a
78      * a byte buffer.
79      * @param key A PrivateKey instance. Must implement ECKey.
80      * @return A byte buffer corresponding to the 'order' parameter.
81      * This is a big-endian representation of a BigInteger.
82      */
83     @CalledByNative
84     public static byte[] getECKeyOrder(PrivateKey key) {
85         if (key instanceof ECKey) {
86             ECParameterSpec params = ((ECKey) key).getParams();
87             return params.getOrder().toByteArray();
88         } else {
89             Log.w(TAG, "Not an ECKey instance!");
90             return null;
91         }
92     }
93
94     /**
95      * Returns the encoded data corresponding to a given PrivateKey.
96      * Note that this will fail for platform keys on Android 4.0.4
97      * and higher. It can be used on 4.0.3 and older platforms to
98      * route around the platform bug described below.
99      * @param key A PrivateKey instance
100      * @return encoded key as PKCS#8 byte array, can be null.
101      */
102     @CalledByNative
103     public static byte[] getPrivateKeyEncodedBytes(PrivateKey key) {
104         return key.getEncoded();
105     }
106
107     /**
108      * Sign a given message with a given PrivateKey object. This method
109      * shall only be used to implement signing in the context of SSL
110      * client certificate support.
111      *
112      * The message will actually be a hash, computed by OpenSSL itself,
113      * depending on the type of the key. The result should match exactly
114      * what the vanilla implementations of the following OpenSSL function
115      * calls do:
116      *
117      *  - For a RSA private key, this should be equivalent to calling
118      *    RSA_private_encrypt(..., RSA_PKCS1_PADDING), i.e. it must
119      *    generate a raw RSA signature. The message must be either a
120      *    combined, 36-byte MD5+SHA1 message digest or a DigestInfo
121      *    value wrapping a message digest.
122      *
123      *  - For a DSA and ECDSA private keys, this should be equivalent to
124      *    calling DSA_sign(0,...) and ECDSA_sign(0,...) respectively. The
125      *    message must be a hash and the function shall compute a direct
126      *    DSA/ECDSA signature for it.
127      *
128      * @param privateKey The PrivateKey handle.
129      * @param message The message to sign.
130      * @return signature as a byte buffer.
131      *
132      * Important: Due to a platform bug, this function will always fail on
133      *            Android < 4.2 for RSA PrivateKey objects. See the
134      *            getOpenSSLHandleForPrivateKey() below for work-around.
135      */
136     @CalledByNative
137     public static byte[] rawSignDigestWithPrivateKey(PrivateKey privateKey,
138                                                      byte[] message) {
139         // Get the Signature for this key.
140         Signature signature = null;
141         // Hint: Algorithm names come from:
142         // http://docs.oracle.com/javase/6/docs/technotes/guides/security/StandardNames.html
143         try {
144             if (privateKey instanceof RSAPrivateKey) {
145                 // IMPORTANT: Due to a platform bug, this will throw NoSuchAlgorithmException
146                 // on Android 4.0.x and 4.1.x. Fixed in 4.2 and higher.
147                 // See https://android-review.googlesource.com/#/c/40352/
148                 signature = Signature.getInstance("NONEwithRSA");
149             } else if (privateKey instanceof DSAPrivateKey) {
150                 signature = Signature.getInstance("NONEwithDSA");
151             } else if (privateKey instanceof ECPrivateKey) {
152                 signature = Signature.getInstance("NONEwithECDSA");
153             }
154         } catch (NoSuchAlgorithmException e) {
155             ;
156         }
157
158         if (signature == null) {
159             Log.e(TAG, "Unsupported private key algorithm: " + privateKey.getAlgorithm());
160             return null;
161         }
162
163         // Sign the message.
164         try {
165             signature.initSign(privateKey);
166             signature.update(message);
167             return signature.sign();
168         } catch (Exception e) {
169             Log.e(TAG, "Exception while signing message with " + privateKey.getAlgorithm() +
170                         " private key: " + e);
171             return null;
172         }
173     }
174
175     /**
176      * Return the type of a given PrivateKey object. This is an integer
177      * that maps to one of the values defined by org.chromium.net.PrivateKeyType,
178      * which is itself auto-generated from net/android/private_key_type_list.h
179      * @param privateKey The PrivateKey handle
180      * @return key type, or PrivateKeyType.INVALID if unknown.
181      */
182     @CalledByNative
183     public static int getPrivateKeyType(PrivateKey privateKey) {
184         if (privateKey instanceof RSAPrivateKey)
185             return PrivateKeyType.RSA;
186         if (privateKey instanceof DSAPrivateKey)
187             return PrivateKeyType.DSA;
188         if (privateKey instanceof ECPrivateKey)
189             return PrivateKeyType.ECDSA;
190         else
191             return PrivateKeyType.INVALID;
192     }
193
194     /**
195      * Return the system EVP_PKEY handle corresponding to a given PrivateKey
196      * object, obtained through reflection.
197      *
198      * This shall only be used when the "NONEwithRSA" signature is not
199      * available, as described in rawSignDigestWithPrivateKey(). I.e.
200      * never use this on Android 4.2 or higher.
201      *
202      * This can only work in Android 4.0.4 and higher, for older versions
203      * of the platform (e.g. 4.0.3), there is no system OpenSSL EVP_PKEY,
204      * but the private key contents can be retrieved directly with
205      * the getEncoded() method.
206      *
207      * This assumes that the target device uses a vanilla AOSP
208      * implementation of its java.security classes, which is also
209      * based on OpenSSL (fortunately, no OEM has apperently changed to
210      * a different implementation, according to the Android team).
211      *
212      * Note that the object returned was created with the platform version
213      * of OpenSSL, and _not_ the one that comes with Chromium. Whether the
214      * object can be used safely with the Chromium OpenSSL library depends
215      * on differences between their actual ABI / implementation details.
216      *
217      * To better understand what's going on below, please refer to the
218      * following source files in the Android 4.0.4 and 4.1 source trees:
219      * libcore/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRSAPrivateKey.java
220      * libcore/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
221      *
222      * @param privateKey The PrivateKey handle.
223      * @return The EVP_PKEY handle, as a 32-bit integer (0 if not available)
224      */
225     @CalledByNative
226     public static int getOpenSSLHandleForPrivateKey(PrivateKey privateKey) {
227         // Sanity checks
228         if (privateKey == null) {
229             Log.e(TAG, "privateKey == null");
230             return 0;
231         }
232         if (!(privateKey instanceof RSAPrivateKey)) {
233             Log.e(TAG, "does not implement RSAPrivateKey");
234             return 0;
235         }
236         // First, check that this is a proper instance of OpenSSLRSAPrivateKey
237         // or one of its sub-classes.
238         Class<?> superClass;
239         try {
240             superClass = Class.forName(
241                     "org.apache.harmony.xnet.provider.jsse.OpenSSLRSAPrivateKey");
242         } catch (Exception e) {
243             // This may happen if the target device has a completely different
244             // implementation of the java.security APIs, compared to vanilla
245             // Android. Highly unlikely, but still possible.
246             Log.e(TAG, "Cannot find system OpenSSLRSAPrivateKey class: " + e);
247             return 0;
248         }
249         if (!superClass.isInstance(privateKey)) {
250             // This may happen if the PrivateKey was not created by the "AndroidOpenSSL"
251             // provider, which should be the default. That could happen if an OEM decided
252             // to implement a different default provider. Also highly unlikely.
253             Log.e(TAG, "Private key is not an OpenSSLRSAPrivateKey instance, its class name is:" +
254                        privateKey.getClass().getCanonicalName());
255             return 0;
256         }
257
258         try {
259             // Use reflection to invoke the 'getOpenSSLKey()' method on
260             // the private key. This returns another Java object that wraps
261             // a native EVP_PKEY. Note that the method is final, so calling
262             // the superclass implementation is ok.
263             Method getKey = superClass.getDeclaredMethod("getOpenSSLKey");
264             getKey.setAccessible(true);
265             Object opensslKey = null;
266             try {
267                 opensslKey = getKey.invoke(privateKey);
268             } finally {
269                 getKey.setAccessible(false);
270             }
271             if (opensslKey == null) {
272                 // Bail when detecting OEM "enhancement".
273                 Log.e(TAG, "getOpenSSLKey() returned null");
274                 return 0;
275             }
276
277             // Use reflection to invoke the 'getPkeyContext' method on the
278             // result of the getOpenSSLKey(). This is an 32-bit integer
279             // which is the address of an EVP_PKEY object.
280             Method getPkeyContext;
281             try {
282                 getPkeyContext = opensslKey.getClass().getDeclaredMethod("getPkeyContext");
283             } catch (Exception e) {
284                 // Bail here too, something really not working as expected.
285                 Log.e(TAG, "No getPkeyContext() method on OpenSSLKey member:" + e);
286                 return 0;
287             }
288             getPkeyContext.setAccessible(true);
289             int evp_pkey = 0;
290             try {
291                 evp_pkey = (Integer) getPkeyContext.invoke(opensslKey);
292             } finally {
293                 getPkeyContext.setAccessible(false);
294             }
295             if (evp_pkey == 0) {
296                 // The PrivateKey is probably rotten for some reason.
297                 Log.e(TAG, "getPkeyContext() returned null");
298             }
299             return evp_pkey;
300
301         } catch (Exception e) {
302             Log.e(TAG, "Exception while trying to retrieve system EVP_PKEY handle: " + e);
303             return 0;
304         }
305     }
306 }