Fixups to keystore_openssl.cc after BoringSSL.

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>
@@ skipping 161 matching lines @@
 
 int RsaMethodEncrypt(RSA* rsa,
                      size_t* out_len,
                      uint8_t* out,
                      size_t max_out,
                      const uint8_t* in,
                      size_t in_len,
                      int padding) {
   NOTIMPLEMENTED();
   OPENSSL_PUT_ERROR(RSA, encrypt, RSA_R_UNKNOWN_ALGORITHM_TYPE);
-  return 1;
+  return 0;
 }
 
 int RsaMethodSignRaw(RSA* rsa,
                      size_t* out_len,
                      uint8_t* out,
                      size_t max_out,
                      const uint8_t* in,
                      size_t in_len,
                      int padding) {
   DCHECK_EQ(RSA_PKCS1_PADDING, padding);
   if (padding != RSA_PKCS1_PADDING) {
     // TODO(davidben): If we need to, we can implement RSA_NO_PADDING
     // by using javax.crypto.Cipher and picking either the
     // "RSA/ECB/NoPadding" or "RSA/ECB/PKCS1Padding" transformation as
     // appropriate. I believe support for both of these was added in
     // the same Android version as the "NONEwithRSA"
     // java.security.Signature algorithm, so the same version checks
     // for GetRsaLegacyKey should work.
-    OPENSSL_PUT_ERROR(RSA, sign_raw, RSA_R_UNKNOWN_ALGORITHM_TYPE);
+    OPENSSL_PUT_ERROR(RSA, sign_raw, RSA_R_UNKNOWN_PADDING_TYPE);
     return 0;
   }
 
   // Retrieve private key JNI reference.
   const KeyExData *ex_data = RsaGetExData(rsa);
   if (!ex_data || !ex_data->private_key) {
     LOG(WARNING) << "Null JNI reference passed to RsaMethodPrivEnc!";
     OPENSSL_PUT_ERROR(RSA, sign_raw, ERR_R_INTERNAL_ERROR);
     return 0;
   }
@@ skipping 52 matching lines @@
 }
 
 int RsaMethodDecrypt(RSA* rsa,
                      size_t* out_len,
                      uint8_t* out,
                      size_t max_out,
                      const uint8_t* in,
                      size_t in_len,
                      int padding) {
   NOTIMPLEMENTED();
-  OPENSSL_PUT_ERROR(RSA, decrypt, RSA_R_UNKNOWN_PADDING_TYPE);
-  return 1;
+  OPENSSL_PUT_ERROR(RSA, decrypt, RSA_R_UNKNOWN_ALGORITHM_TYPE);
+  return 0;
 }
 
 int RsaMethodVerifyRaw(RSA* rsa,
                        size_t* out_len,
                        uint8_t* out,
                        size_t max_out,
                        const uint8_t* in,
                        size_t in_len,
                        int padding) {
   NOTIMPLEMENTED();
   OPENSSL_PUT_ERROR(RSA, verify_raw, RSA_R_UNKNOWN_ALGORITHM_TYPE);
-  return 1;
+  return 0;
 }
 
 const RSA_METHOD android_rsa_method = {
     {
      0 /* references */,
      1 /* is_static */
     } /* common */,
     NULL /* app_data */,
 
     NULL /* init */,
@@ skipping 140 matching lines @@
 // 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;
 }
 
-size_t EcdsaMethodGroupOrderSize(const EC_KEY* key) {
+size_t EcdsaMethodGroupOrderSize(const EC_KEY* ec_key) {
   KeyExData* ex_data = reinterpret_cast<KeyExData*>(EC_KEY_get_ex_data(
-      key, global_boringssl_engine.Get().ec_key_ex_index()));
+      ec_key, global_boringssl_engine.Get().ec_key_ex_index()));
   return ex_data->cached_size;
 }
 
 int EcdsaMethodSign(const uint8_t* digest,
                     size_t digest_len,
                     uint8_t* sig,
                     unsigned int* sig_len,
-                    EC_KEY* eckey) {
+                    EC_KEY* ec_key) {
   // Retrieve private key JNI reference.
-  jobject private_key = EcKeyGetKey(eckey);
+  jobject private_key = EcKeyGetKey(ec_key);
   if (!private_key) {
     LOG(WARNING) << "Null JNI reference passed to EcdsaMethodSign!";
     return 0;
   }
   // Sign message with it through JNI.
   std::vector<uint8> signature;
   base::StringPiece digest_sp(reinterpret_cast<const char*>(digest),
                               digest_len);
   if (!RawSignDigestWithPrivateKey(private_key, digest_sp, &signature)) {
     LOG(WARNING) << "Could not sign message in EcdsaMethodSign!";
     return 0;
   }
 
   // Note: With ECDSA, the actual signature may be smaller than
   // ECDSA_size().
-  size_t max_expected_size = ECDSA_size(eckey);
+  size_t max_expected_size = ECDSA_size(ec_key);
   if (signature.size() > max_expected_size) {
     LOG(ERROR) << "ECDSA Signature size mismatch, actual: "
                <<  signature.size() << ", expected <= "
                << max_expected_size;
     return 0;
   }
 
   memcpy(sig, &signature[0], signature.size());
   *sig_len = signature.size();
   return 1;
 }
 
 int EcdsaMethodVerify(const uint8_t* digest,
                       size_t digest_len,
                       const uint8_t* sig,
                       size_t sig_len,
-                      EC_KEY* eckey) {
+                      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.
 // 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::ScopedEC_KEY eckey(
+  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;
   }
 
   std::vector<uint8> order;
   if (!GetECKeyOrder(private_key, &order)) {
     LOG(ERROR) << "Can't extract order parameter from EC private key";
     return false;
   }
 
   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(
-      eckey.get(), global_boringssl_engine.Get().ec_key_ex_index(), ex_data);
+      ec_key.get(), global_boringssl_engine.Get().ec_key_ex_index(), ex_data);
 
-  EVP_PKEY_assign_EC_KEY(pkey, eckey.release());
+  EVP_PKEY_assign_EC_KEY(pkey, ec_key.release());
   return true;
 }
 
 const ECDSA_METHOD android_ecdsa_method = {
     {
      0 /* references */,
      1 /* is_static */
     } /* common */,
     NULL /* app_data */,
 
@@ skipping 42 matching lines @@
     default:
       LOG(WARNING)
           << "GetOpenSSLPrivateKeyWrapper() called with invalid key type";
       return NULL;
   }
   return pkey.release();
 }
 
 }  // namespace android
 }  // namespace net