src/net/android/keystore_openssl.cc

   1 // Copyright (c) 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 #include "net/android/keystore_openssl.h"
   6
   7 #include <jni.h>
   8 #include <openssl/bn.h>
   9 // This include is required to get the ECDSA_METHOD structure definition
  10 // which isn't currently part of the OpenSSL official ABI. This should
  11 // not be a concern for Chromium which always links against its own
  12 // version of the library on Android.
  13 #include <openssl/crypto/ecdsa/ecs_locl.h>
  14 // And this one is needed for the EC_GROUP definition.
  15 #include <openssl/crypto/ec/ec_lcl.h>
  16 #include <openssl/dsa.h>
  17 #include <openssl/ec.h>
  18 #include <openssl/engine.h>
  19 #include <openssl/evp.h>
  20 #include <openssl/rsa.h>
  21
  22 #include "base/android/build_info.h"
  23 #include "base/android/jni_android.h"
  24 #include "base/android/scoped_java_ref.h"
  25 #include "base/basictypes.h"
  26 #include "base/lazy_instance.h"
  27 #include "base/logging.h"
  28 #include "crypto/openssl_util.h"
  29 #include "net/android/keystore.h"
  30 #include "net/ssl/ssl_client_cert_type.h"
  31
  32 // IMPORTANT NOTE: The following code will currently only work when used
  33 // to implement client certificate support with OpenSSL. That's because
  34 // only the signing operations used in this use case are implemented here.
  35 //
  36 // Generally speaking, OpenSSL provides many different ways to sign
  37 // digests. This code doesn't support all these cases, only the ones that
  38 // are required to sign the digest during the OpenSSL handshake for TLS.
  39 //
  40 // The OpenSSL EVP_PKEY type is a generic wrapper around key pairs.
  41 // Internally, it can hold a pointer to a RSA, DSA or ECDSA structure,
  42 // which model keypair implementations of each respective crypto
  43 // algorithm.
  44 //
  45 // The RSA type has a 'method' field pointer to a vtable-like structure
  46 // called a RSA_METHOD. This contains several function pointers that
  47 // correspond to operations on RSA keys (e.g. decode/encode with public
  48 // key, decode/encode with private key, signing, validation), as well as
  49 // a few flags.
  50 //
  51 // For example, the RSA_sign() function will call "method->rsa_sign()" if
  52 // method->rsa_sign is not NULL, otherwise, it will perform a regular
  53 // signing operation using the other fields in the RSA structure (which
  54 // are used to hold the typical modulus / exponent / parameters for the
  55 // key pair).
  56 //
  57 // This source file thus defines a custom RSA_METHOD structure whose
  58 // fields point to static methods used to implement the corresponding
  59 // RSA operation using platform Android APIs.
  60 //
  61 // However, the platform APIs require a jobject JNI reference to work.
  62 // It must be stored in the RSA instance, or made accessible when the
  63 // custom RSA methods are called. This is done by using RSA_set_app_data()
  64 // and RSA_get_app_data().
  65 //
  66 // One can thus _directly_ create a new EVP_PKEY that uses a custom RSA
  67 // object with the following:
  68 //
  69 //    RSA* rsa = RSA_new()
  70 //    RSA_set_method(&custom_rsa_method);
  71 //    RSA_set_app_data(rsa, jni_private_key);
  72 //
  73 //    EVP_PKEY* pkey = EVP_PKEY_new();
  74 //    EVP_PKEY_assign_RSA(pkey, rsa);
  75 //
  76 // Note that because EVP_PKEY_assign_RSA() is used, instead of
  77 // EVP_PKEY_set1_RSA(), the new EVP_PKEY now owns the RSA object, and
  78 // will destroy it when it is itself destroyed.
  79 //
  80 // Unfortunately, such objects cannot be used with RSA_size(), which
  81 // totally ignores the RSA_METHOD pointers. Instead, it is necessary
  82 // to manually setup the modulus field (n) in the RSA object, with a
  83 // value that matches the wrapped PrivateKey object. See GetRsaPkeyWrapper
  84 // for full details.
  85 //
  86 // Similarly, custom DSA_METHOD and ECDSA_METHOD are defined by this source
  87 // file, and appropriate field setups are performed to ensure that
  88 // DSA_size() and ECDSA_size() work properly with the wrapper EVP_PKEY.
  89 //
  90 // Note that there is no need to define an OpenSSL ENGINE here. These
  91 // are objects that can be used to expose custom methods (i.e. either
  92 // RSA_METHOD, DSA_METHOD, ECDSA_METHOD, and a large number of other ones
  93 // for types not related to this source file), and make them used by
  94 // default for a lot of operations. Very fortunately, this is not needed
  95 // here, which saves a lot of complexity.
  96
  97 using base::android::ScopedJavaGlobalRef;
  98
  99 namespace net {
 100 namespace android {
 101
 102 namespace {
 103
 104 typedef crypto::ScopedOpenSSL<EVP_PKEY, EVP_PKEY_free> ScopedEVP_PKEY;
 105 typedef crypto::ScopedOpenSSL<RSA, RSA_free> ScopedRSA;
 106 typedef crypto::ScopedOpenSSL<DSA, DSA_free> ScopedDSA;
 107 typedef crypto::ScopedOpenSSL<EC_KEY, EC_KEY_free> ScopedEC_KEY;
 108 typedef crypto::ScopedOpenSSL<EC_GROUP, EC_GROUP_free> ScopedEC_GROUP;
 109
 110 // Custom RSA_METHOD that uses the platform APIs.
 111 // Note that for now, only signing through RSA_sign() is really supported.
 112 // all other method pointers are either stubs returning errors, or no-ops.
 113 // See <openssl/rsa.h> for exact declaration of RSA_METHOD.
 114
 115 int RsaMethodPubEnc(int flen,
 116                     const unsigned char* from,
 117                     unsigned char* to,
 118                     RSA* rsa,
 119                     int padding) {
 120   NOTIMPLEMENTED();
 121   RSAerr(RSA_F_RSA_PUBLIC_ENCRYPT, RSA_R_RSA_OPERATIONS_NOT_SUPPORTED);
 122   return -1;
 123 }
 124
 125 int RsaMethodPubDec(int flen,
 126                     const unsigned char* from,
 127                     unsigned char* to,
 128                     RSA* rsa,
 129                     int padding) {
 130   NOTIMPLEMENTED();
 131   RSAerr(RSA_F_RSA_PUBLIC_DECRYPT, RSA_R_RSA_OPERATIONS_NOT_SUPPORTED);
 132   return -1;
 133 }
 134
 135 // See RSA_eay_private_encrypt in
 136 // third_party/openssl/openssl/crypto/rsa/rsa_eay.c for the default
 137 // implementation of this function.
 138 int RsaMethodPrivEnc(int flen,
 139                      const unsigned char *from,
 140                      unsigned char *to,
 141                      RSA *rsa,
 142                      int padding) {
 143   DCHECK_EQ(RSA_PKCS1_PADDING, padding);
 144   if (padding != RSA_PKCS1_PADDING) {
 145     // TODO(davidben): If we need to, we can implement RSA_NO_PADDING
 146     // by using javax.crypto.Cipher and picking either the
 147     // "RSA/ECB/NoPadding" or "RSA/ECB/PKCS1Padding" transformation as
 148     // appropriate. I believe support for both of these was added in
 149     // the same Android version as the "NONEwithRSA"
 150     // java.security.Signature algorithm, so the same version checks
 151     // for GetRsaLegacyKey should work.
 152     RSAerr(RSA_F_RSA_PRIVATE_ENCRYPT, RSA_R_UNKNOWN_PADDING_TYPE);
 153     return -1;
 154   }
 155
 156   // Retrieve private key JNI reference.
 157   jobject private_key = reinterpret_cast<jobject>(RSA_get_app_data(rsa));
 158   if (!private_key) {
 159     LOG(WARNING) << "Null JNI reference passed to RsaMethodPrivEnc!";
 160     RSAerr(RSA_F_RSA_PRIVATE_ENCRYPT, ERR_R_INTERNAL_ERROR);
 161     return -1;
 162   }
 163
 164   base::StringPiece from_piece(reinterpret_cast<const char*>(from), flen);
 165   std::vector<uint8> result;
 166   // For RSA keys, this function behaves as RSA_private_encrypt with
 167   // PKCS#1 padding.
 168   if (!RawSignDigestWithPrivateKey(private_key, from_piece, &result)) {
 169     LOG(WARNING) << "Could not sign message in RsaMethodPrivEnc!";
 170     RSAerr(RSA_F_RSA_PRIVATE_ENCRYPT, ERR_R_INTERNAL_ERROR);
 171     return -1;
 172   }
 173
 174   size_t expected_size = static_cast<size_t>(RSA_size(rsa));
 175   if (result.size() > expected_size) {
 176     LOG(ERROR) << "RSA Signature size mismatch, actual: "
 177                <<  result.size() << ", expected <= " << expected_size;
 178     RSAerr(RSA_F_RSA_PRIVATE_ENCRYPT, ERR_R_INTERNAL_ERROR);
 179     return -1;
 180   }
 181
 182   // Copy result to OpenSSL-provided buffer. RawSignDigestWithPrivateKey
 183   // should pad with leading 0s, but if it doesn't, pad the result.
 184   size_t zero_pad = expected_size - result.size();
 185   memset(to, 0, zero_pad);
 186   memcpy(to + zero_pad, &result[0], result.size());
 187
 188   return expected_size;
 189 }
 190
 191 int RsaMethodPrivDec(int flen,
 192                      const unsigned char* from,
 193                      unsigned char* to,
 194                      RSA* rsa,
 195                      int padding) {
 196   NOTIMPLEMENTED();
 197   RSAerr(RSA_F_RSA_PRIVATE_DECRYPT, RSA_R_RSA_OPERATIONS_NOT_SUPPORTED);
 198   return -1;
 199 }
 200
 201 int RsaMethodInit(RSA* rsa) {
 202   return 0;
 203 }
 204
 205 int RsaMethodFinish(RSA* rsa) {
 206   // Ensure the global JNI reference created with this wrapper is
 207   // properly destroyed with it.
 208   jobject key = reinterpret_cast<jobject>(RSA_get_app_data(rsa));
 209   if (key != NULL) {
 210     RSA_set_app_data(rsa, NULL);
 211     ReleaseKey(key);
 212   }
 213   // Actual return value is ignored by OpenSSL. There are no docs
 214   // explaining what this is supposed to be.
 215   return 0;
 216 }
 217
 218 const RSA_METHOD android_rsa_method = {
 219   /* .name = */ "Android signing-only RSA method",
 220   /* .rsa_pub_enc = */ RsaMethodPubEnc,
 221   /* .rsa_pub_dec = */ RsaMethodPubDec,
 222   /* .rsa_priv_enc = */ RsaMethodPrivEnc,
 223   /* .rsa_priv_dec = */ RsaMethodPrivDec,
 224   /* .rsa_mod_exp = */ NULL,
 225   /* .bn_mod_exp = */ NULL,
 226   /* .init = */ RsaMethodInit,
 227   /* .finish = */ RsaMethodFinish,
 228   // This flag is necessary to tell OpenSSL to avoid checking the content
 229   // (i.e. internal fields) of the private key. Otherwise, it will complain
 230   // it's not valid for the certificate.
 231   /* .flags = */ RSA_METHOD_FLAG_NO_CHECK,
 232   /* .app_data = */ NULL,
 233   /* .rsa_sign = */ NULL,
 234   /* .rsa_verify = */ NULL,
 235   /* .rsa_keygen = */ NULL,
 236 };
 237
 238 // Copy the contents of an encoded big integer into an existing BIGNUM.
 239 // This function modifies |*num| in-place.
 240 // |new_bytes| is the byte encoding of the new value.
 241 // |num| points to the BIGNUM which will be assigned with the new value.
 242 // Returns true on success, false otherwise. On failure, |*num| is
 243 // not modified.
 244 bool CopyBigNumFromBytes(const std::vector<uint8>& new_bytes,
 245                          BIGNUM* num) {
 246   BIGNUM* ret = BN_bin2bn(
 247       reinterpret_cast<const unsigned char*>(&new_bytes[0]),
 248       static_cast<int>(new_bytes.size()),
 249       num);
 250   return (ret != NULL);
 251 }
 252
 253 // Decode the contents of an encoded big integer and either create a new
 254 // BIGNUM object (if |*num_ptr| is NULL on input) or copy it (if
 255 // |*num_ptr| is not NULL).
 256 // |new_bytes| is the byte encoding of the new value.
 257 // |num_ptr| is the address of a BIGNUM pointer. |*num_ptr| can be NULL.
 258 // Returns true on success, false otherwise. On failure, |*num_ptr| is
 259 // not modified. On success, |*num_ptr| will always be non-NULL and
 260 // point to a valid BIGNUM object.
 261 bool SwapBigNumPtrFromBytes(const std::vector<uint8>& new_bytes,
 262                             BIGNUM** num_ptr) {
 263   BIGNUM* old_num = *num_ptr;
 264   BIGNUM* new_num = BN_bin2bn(
 265       reinterpret_cast<const unsigned char*>(&new_bytes[0]),
 266       static_cast<int>(new_bytes.size()),
 267       old_num);
 268   if (new_num == NULL)
 269     return false;
 270
 271   if (old_num == NULL)
 272     *num_ptr = new_num;
 273   return true;
 274 }
 275
 276 // Setup an EVP_PKEY to wrap an existing platform RSA PrivateKey object.
 277 // |private_key| is the JNI reference (local or global) to the object.
 278 // |pkey| is the EVP_PKEY to setup as a wrapper.
 279 // Returns true on success, false otherwise.
 280 // On success, this creates a new global JNI reference to the object
 281 // that is owned by and destroyed with the EVP_PKEY. I.e. caller can
 282 // free |private_key| after the call.
 283 // IMPORTANT: The EVP_PKEY will *only* work on Android >= 4.2. For older
 284 // platforms, use GetRsaLegacyKey() instead.
 285 bool GetRsaPkeyWrapper(jobject private_key, EVP_PKEY* pkey) {
 286   ScopedRSA rsa(RSA_new());
 287   RSA_set_method(rsa.get(), &android_rsa_method);
 288
 289   // HACK: RSA_size() doesn't work with custom RSA_METHODs. To ensure that
 290   // it will return the right value, set the 'n' field of the RSA object
 291   // to match the private key's modulus.
 292   std::vector<uint8> modulus;
 293   if (!GetRSAKeyModulus(private_key, &modulus)) {
 294     LOG(ERROR) << "Failed to get private key modulus";
 295     return false;
 296   }
 297   if (!SwapBigNumPtrFromBytes(modulus, &rsa.get()->n)) {
 298     LOG(ERROR) << "Failed to decode private key modulus";
 299     return false;
 300   }
 301
 302   ScopedJavaGlobalRef<jobject> global_key;
 303   global_key.Reset(NULL, private_key);
 304   if (global_key.is_null()) {
 305     LOG(ERROR) << "Could not create global JNI reference";
 306     return false;
 307   }
 308   RSA_set_app_data(rsa.get(), global_key.Release());
 309   EVP_PKEY_assign_RSA(pkey, rsa.release());
 310   return true;
 311 }
 312
 313 // Setup an EVP_PKEY to wrap an existing platform RSA PrivateKey object
 314 // for Android 4.0 to 4.1.x. Must only be used on Android < 4.2.
 315 // |private_key| is a JNI reference (local or global) to the object.
 316 // |pkey| is the EVP_PKEY to setup as a wrapper.
 317 // Returns true on success, false otherwise.
 318 EVP_PKEY* GetRsaLegacyKey(jobject private_key) {
 319   EVP_PKEY* sys_pkey =
 320       GetOpenSSLSystemHandleForPrivateKey(private_key);
 321   if (sys_pkey != NULL) {
 322     CRYPTO_add(&sys_pkey->references, 1, CRYPTO_LOCK_EVP_PKEY);
 323   } else {
 324     // GetOpenSSLSystemHandleForPrivateKey() will fail on Android
 325     // 4.0.3 and earlier. However, it is possible to get the key
 326     // content with PrivateKey.getEncoded() on these platforms.
 327     // Note that this method may return NULL on 4.0.4 and later.
 328     std::vector<uint8> encoded;
 329     if (!GetPrivateKeyEncodedBytes(private_key, &encoded)) {
 330       LOG(ERROR) << "Can't get private key data!";
 331       return NULL;
 332     }
 333     const unsigned char* p =
 334         reinterpret_cast<const unsigned char*>(&encoded[0]);
 335     int len = static_cast<int>(encoded.size());
 336     sys_pkey = d2i_AutoPrivateKey(NULL, &p, len);
 337     if (sys_pkey == NULL) {
 338       LOG(ERROR) << "Can't convert private key data!";
 339       return NULL;
 340     }
 341   }
 342   return sys_pkey;
 343 }
 344
 345 // Custom DSA_METHOD that uses the platform APIs.
 346 // Note that for now, only signing through DSA_sign() is really supported.
 347 // all other method pointers are either stubs returning errors, or no-ops.
 348 // See <openssl/dsa.h> for exact declaration of DSA_METHOD.
 349 //
 350 // Note: There is no DSA_set_app_data() and DSA_get_app_data() functions,
 351 //       but RSA_set_app_data() is defined as a simple macro that calls
 352 //       RSA_set_ex_data() with a hard-coded index of 0, so this code
 353 //       does the same thing here.
 354
 355 DSA_SIG* DsaMethodDoSign(const unsigned char* dgst,
 356                          int dlen,
 357                          DSA* dsa) {
 358   // Extract the JNI reference to the PrivateKey object.
 359   jobject private_key = reinterpret_cast<jobject>(DSA_get_ex_data(dsa, 0));
 360   if (private_key == NULL)
 361     return NULL;
 362
 363   // Sign the message with it, calling platform APIs.
 364   std::vector<uint8> signature;
 365   if (!RawSignDigestWithPrivateKey(
 366           private_key,
 367           base::StringPiece(
 368               reinterpret_cast<const char*>(dgst),
 369               static_cast<size_t>(dlen)),
 370           &signature)) {
 371     return NULL;
 372   }
 373
 374   // Note: With DSA, the actual signature might be smaller than DSA_size().
 375   size_t max_expected_size = static_cast<size_t>(DSA_size(dsa));
 376   if (signature.size() > max_expected_size) {
 377     LOG(ERROR) << "DSA Signature size mismatch, actual: "
 378                << signature.size() << ", expected <= "
 379                << max_expected_size;
 380     return NULL;
 381   }
 382
 383   // Convert the signature into a DSA_SIG object.
 384   const unsigned char* sigbuf =
 385       reinterpret_cast<const unsigned char*>(&signature[0]);
 386   int siglen = static_cast<size_t>(signature.size());
 387   DSA_SIG* dsa_sig = d2i_DSA_SIG(NULL, &sigbuf, siglen);
 388   return dsa_sig;
 389 }
 390
 391 int DsaMethodSignSetup(DSA* dsa,
 392                        BN_CTX* ctx_in,
 393                        BIGNUM** kinvp,
 394                        BIGNUM** rp) {
 395   NOTIMPLEMENTED();
 396   DSAerr(DSA_F_DSA_SIGN_SETUP, DSA_R_INVALID_DIGEST_TYPE);
 397   return -1;
 398 }
 399
 400 int DsaMethodDoVerify(const unsigned char* dgst,
 401                       int dgst_len,
 402                       DSA_SIG* sig,
 403                       DSA* dsa) {
 404   NOTIMPLEMENTED();
 405   DSAerr(DSA_F_DSA_DO_VERIFY, DSA_R_INVALID_DIGEST_TYPE);
 406   return -1;
 407 }
 408
 409 int DsaMethodFinish(DSA* dsa) {
 410   // Free the global JNI reference that was created with this
 411   // wrapper key.
 412   jobject key = reinterpret_cast<jobject>(DSA_get_ex_data(dsa,0));
 413   if (key != NULL) {
 414     DSA_set_ex_data(dsa, 0, NULL);
 415     ReleaseKey(key);
 416   }
 417   // Actual return value is ignored by OpenSSL. There are no docs
 418   // explaining what this is supposed to be.
 419   return 0;
 420 }
 421
 422 const DSA_METHOD android_dsa_method = {
 423   /* .name = */ "Android signing-only DSA method",
 424   /* .dsa_do_sign = */ DsaMethodDoSign,
 425   /* .dsa_sign_setup = */ DsaMethodSignSetup,
 426   /* .dsa_do_verify = */ DsaMethodDoVerify,
 427   /* .dsa_mod_exp = */ NULL,
 428   /* .bn_mod_exp = */ NULL,
 429   /* .init = */ NULL,  // nothing to do here.
 430   /* .finish = */ DsaMethodFinish,
 431   /* .flags = */ 0,
 432   /* .app_data = */ NULL,
 433   /* .dsa_paramgem = */ NULL,
 434   /* .dsa_keygen = */ NULL
 435 };
 436
 437 // Setup an EVP_PKEY to wrap an existing DSA platform PrivateKey object.
 438 // |private_key| is a JNI reference (local or global) to the object.
 439 // |pkey| is the EVP_PKEY to setup as a wrapper.
 440 // Returns true on success, false otherwise.
 441 // On success, this creates a global JNI reference to the same object
 442 // that will be owned by and destroyed with the EVP_PKEY.
 443 bool GetDsaPkeyWrapper(jobject private_key, EVP_PKEY* pkey) {
 444   ScopedDSA dsa(DSA_new());
 445   DSA_set_method(dsa.get(), &android_dsa_method);
 446
 447   // DSA_size() doesn't work with custom DSA_METHODs. To ensure it
 448   // returns the right value, set the 'q' field in the DSA object to
 449   // match the parameter from the platform key.
 450   std::vector<uint8> q;
 451   if (!GetDSAKeyParamQ(private_key, &q)) {
 452     LOG(ERROR) << "Can't extract Q parameter from DSA private key";
 453     return false;
 454   }
 455   if (!SwapBigNumPtrFromBytes(q, &dsa.get()->q)) {
 456     LOG(ERROR) << "Can't decode Q parameter from DSA private key";
 457     return false;
 458   }
 459
 460   ScopedJavaGlobalRef<jobject> global_key;
 461   global_key.Reset(NULL, private_key);
 462   if (global_key.is_null()) {
 463     LOG(ERROR) << "Could not create global JNI reference";
 464     return false;
 465   }
 466   DSA_set_ex_data(dsa.get(), 0, global_key.Release());
 467   EVP_PKEY_assign_DSA(pkey, dsa.release());
 468   return true;
 469 }
 470
 471 // Custom ECDSA_METHOD that uses the platform APIs.
 472 // Note that for now, only signing through ECDSA_sign() is really supported.
 473 // all other method pointers are either stubs returning errors, or no-ops.
 474 //
 475 // Note: The ECDSA_METHOD structure doesn't have init/finish
 476 //       methods. As such, the only way to to ensure the global
 477 //       JNI reference is properly released when the EVP_PKEY is
 478 //       destroyed is to use a custom EX_DATA type.
 479
 480 // Used to ensure that the global JNI reference associated with a custom
 481 // EC_KEY + ECDSA_METHOD wrapper is released when its EX_DATA is destroyed
 482 // (this function is called when EVP_PKEY_free() is called on the wrapper).
 483 void ExDataFree(void* parent,
 484                 void* ptr,
 485                 CRYPTO_EX_DATA* ad,
 486                 int idx,
 487                 long argl,
 488                 void* argp) {
 489   jobject private_key = reinterpret_cast<jobject>(ptr);
 490   if (private_key == NULL)
 491     return;
 492
 493   CRYPTO_set_ex_data(ad, idx, NULL);
 494   ReleaseKey(private_key);
 495 }
 496
 497 int ExDataDup(CRYPTO_EX_DATA* to,
 498               CRYPTO_EX_DATA* from,
 499               void* from_d,
 500               int idx,
 501               long argl,
 502               void* argp) {
 503   // This callback shall never be called with the current OpenSSL
 504   // implementation (the library only ever duplicates EX_DATA items
 505   // for SSL and BIO objects). But provide this to catch regressions
 506   // in the future.
 507   CHECK(false) << "ExDataDup was called for ECDSA custom key !?";
 508   // Return value is currently ignored by OpenSSL.
 509   return 0;
 510 }
 511
 512 class EcdsaExDataIndex {
 513 public:
 514   int ex_data_index() { return ex_data_index_; }
 515
 516   EcdsaExDataIndex() {
 517     ex_data_index_ = ECDSA_get_ex_new_index(0,           // argl
 518                                             NULL,        // argp
 519                                             NULL,        // new_func
 520                                             ExDataDup,   // dup_func
 521                                             ExDataFree); // free_func
 522   }
 523
 524 private:
 525   int ex_data_index_;
 526 };
 527
 528 // Returns the index of the custom EX_DATA used to store the JNI reference.
 529 int EcdsaGetExDataIndex(void) {
 530   // Use a LazyInstance to perform thread-safe lazy initialization.
 531   // Use a leaky one, since OpenSSL doesn't provide a way to release
 532   // allocated EX_DATA indices.
 533   static base::LazyInstance<EcdsaExDataIndex>::Leaky s_instance =
 534       LAZY_INSTANCE_INITIALIZER;
 535   return s_instance.Get().ex_data_index();
 536 }
 537
 538 ECDSA_SIG* EcdsaMethodDoSign(const unsigned char* dgst,
 539                              int dgst_len,
 540                              const BIGNUM* inv,
 541                              const BIGNUM* rp,
 542                              EC_KEY* eckey) {
 543   // Retrieve private key JNI reference.
 544   jobject private_key = reinterpret_cast<jobject>(
 545       ECDSA_get_ex_data(eckey, EcdsaGetExDataIndex()));
 546   if (!private_key) {
 547     LOG(WARNING) << "Null JNI reference passed to EcdsaMethodDoSign!";
 548     return NULL;
 549   }
 550   // Sign message with it through JNI.
 551   std::vector<uint8> signature;
 552   base::StringPiece digest(
 553       reinterpret_cast<const char*>(dgst),
 554       static_cast<size_t>(dgst_len));
 555   if (!RawSignDigestWithPrivateKey(
 556           private_key, digest, &signature)) {
 557     LOG(WARNING) << "Could not sign message in EcdsaMethodDoSign!";
 558     return NULL;
 559   }
 560
 561   // Note: With ECDSA, the actual signature may be smaller than
 562   // ECDSA_size().
 563   size_t max_expected_size = static_cast<size_t>(ECDSA_size(eckey));
 564   if (signature.size() > max_expected_size) {
 565     LOG(ERROR) << "ECDSA Signature size mismatch, actual: "
 566                <<  signature.size() << ", expected <= "
 567                << max_expected_size;
 568     return NULL;
 569   }
 570
 571   // Convert signature to ECDSA_SIG object
 572   const unsigned char* sigbuf =
 573       reinterpret_cast<const unsigned char*>(&signature[0]);
 574   long siglen = static_cast<long>(signature.size());
 575   return d2i_ECDSA_SIG(NULL, &sigbuf, siglen);
 576 }
 577
 578 int EcdsaMethodSignSetup(EC_KEY* eckey,
 579                          BN_CTX* ctx,
 580                          BIGNUM** kinv,
 581                          BIGNUM** r) {
 582   NOTIMPLEMENTED();
 583   ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ECDSA_R_ERR_EC_LIB);
 584   return -1;
 585 }
 586
 587 int EcdsaMethodDoVerify(const unsigned char* dgst,
 588                         int dgst_len,
 589                         const ECDSA_SIG* sig,
 590                         EC_KEY* eckey) {
 591   NOTIMPLEMENTED();
 592   ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ECDSA_R_ERR_EC_LIB);
 593   return -1;
 594 }
 595
 596 const ECDSA_METHOD android_ecdsa_method = {
 597   /* .name = */ "Android signing-only ECDSA method",
 598   /* .ecdsa_do_sign = */ EcdsaMethodDoSign,
 599   /* .ecdsa_sign_setup = */ EcdsaMethodSignSetup,
 600   /* .ecdsa_do_verify = */ EcdsaMethodDoVerify,
 601   /* .flags = */ 0,
 602   /* .app_data = */ NULL,
 603 };
 604
 605 // Setup an EVP_PKEY to wrap an existing platform PrivateKey object.
 606 // |private_key| is the JNI reference (local or global) to the object.
 607 // |pkey| is the EVP_PKEY to setup as a wrapper.
 608 // Returns true on success, false otherwise.
 609 // On success, this creates a global JNI reference to the object that
 610 // is owned by and destroyed with the EVP_PKEY. I.e. the caller shall
 611 // always free |private_key| after the call.
 612 bool GetEcdsaPkeyWrapper(jobject private_key, EVP_PKEY* pkey) {
 613   ScopedEC_KEY eckey(EC_KEY_new());
 614   ECDSA_set_method(eckey.get(), &android_ecdsa_method);
 615
 616   // To ensure that ECDSA_size() works properly, craft a custom EC_GROUP
 617   // that has the same order than the private key.
 618   std::vector<uint8> order;
 619   if (!GetECKeyOrder(private_key, &order)) {
 620     LOG(ERROR) << "Can't extract order parameter from EC private key";
 621     return false;
 622   }
 623   ScopedEC_GROUP group(EC_GROUP_new(EC_GFp_nist_method()));
 624   if (!group.get()) {
 625     LOG(ERROR) << "Can't create new EC_GROUP";
 626     return false;
 627   }
 628   if (!CopyBigNumFromBytes(order, &group.get()->order)) {
 629     LOG(ERROR) << "Can't decode order from PrivateKey";
 630     return false;
 631   }
 632   EC_KEY_set_group(eckey.get(), group.release());
 633
 634   ScopedJavaGlobalRef<jobject> global_key;
 635   global_key.Reset(NULL, private_key);
 636   if (global_key.is_null()) {
 637     LOG(ERROR) << "Can't create global JNI reference";
 638     return false;
 639   }
 640   ECDSA_set_ex_data(eckey.get(),
 641                     EcdsaGetExDataIndex(),
 642                     global_key.Release());
 643
 644   EVP_PKEY_assign_EC_KEY(pkey, eckey.release());
 645   return true;
 646 }
 647
 648 }  // namespace
 649
 650 EVP_PKEY* GetOpenSSLPrivateKeyWrapper(jobject private_key) {
 651   // Create new empty EVP_PKEY instance.
 652   ScopedEVP_PKEY pkey(EVP_PKEY_new());
 653   if (!pkey.get())
 654     return NULL;
 655
 656   // Create sub key type, depending on private key's algorithm type.
 657   PrivateKeyType key_type = GetPrivateKeyType(private_key);
 658   switch (key_type) {
 659     case PRIVATE_KEY_TYPE_RSA:
 660       {
 661         // Route around platform bug: if Android < 4.2, then
 662         // base::android::RawSignDigestWithPrivateKey() cannot work, so
 663         // instead, obtain a raw EVP_PKEY* to the system object
 664         // backing this PrivateKey object.
 665         const int kAndroid42ApiLevel = 17;
 666         if (base::android::BuildInfo::GetInstance()->sdk_int() <
 667             kAndroid42ApiLevel) {
 668           EVP_PKEY* legacy_key = GetRsaLegacyKey(private_key);
 669           if (legacy_key == NULL)
 670             return NULL;
 671           pkey.reset(legacy_key);
 672         } else {
 673           // Running on Android 4.2.
 674           if (!GetRsaPkeyWrapper(private_key, pkey.get()))
 675             return NULL;
 676         }
 677       }
 678       break;
 679     case PRIVATE_KEY_TYPE_DSA:
 680       if (!GetDsaPkeyWrapper(private_key, pkey.get()))
 681         return NULL;
 682       break;
 683     case PRIVATE_KEY_TYPE_ECDSA:
 684       if (!GetEcdsaPkeyWrapper(private_key, pkey.get()))
 685         return NULL;
 686       break;
 687     default:
 688       LOG(WARNING)
 689           << "GetOpenSSLPrivateKeyWrapper() called with invalid key type";
 690       return NULL;
 691   }
 692   return pkey.release();
 693 }
 694
 695 }  // namespace android
 696 }  // namespace net