Renaming _openssl files to _impl

net/android/keystore_impl.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 "net/android/keystore_impl.h"
 
 #include <jni.h>
 #include <openssl/bn.h>
 #include <openssl/ec.h>
 #include <openssl/engine.h>
 #include <openssl/err.h>
 #include <openssl/evp.h>
 #include <openssl/rsa.h>
 #include <stdint.h>
 
@@ skipping 81 matching lines @@
 
 // ExDataFree is called when one of the RSA or EC_KEY objects is freed.
 void ExDataFree(void* parent,
                 void* ptr,
                 CRYPTO_EX_DATA* ad,
                 int index,
                 long argl,
                 void* argp) {
   // Ensure the global JNI reference created with this wrapper is
   // properly destroyed with it.
-  KeyExData *ex_data = reinterpret_cast<KeyExData*>(ptr);
+  KeyExData* ex_data = reinterpret_cast<KeyExData*>(ptr);
   delete ex_data;
 }
 
 // BoringSSLEngine is a BoringSSL ENGINE that implements RSA and ECDSA by
 // forwarding the requested operations to the Java libraries.
 class BoringSSLEngine {
  public:
   BoringSSLEngine()
       : rsa_index_(RSA_get_ex_new_index(0 /* argl */,
                                         NULL /* argp */,
                                         NULL /* new_func */,
                                         ExDataDup,
                                         ExDataFree)),
         ec_key_index_(EC_KEY_get_ex_new_index(0 /* argl */,
                                               NULL /* argp */,
                                               NULL /* new_func */,
                                               ExDataDup,
                                               ExDataFree)),
         engine_(ENGINE_new()) {
-    ENGINE_set_RSA_method(
-        engine_, &android_rsa_method, sizeof(android_rsa_method));
-    ENGINE_set_ECDSA_method(
-        engine_, &android_ecdsa_method, sizeof(android_ecdsa_method));
+    ENGINE_set_RSA_method(engine_, &android_rsa_method,
+                          sizeof(android_rsa_method));
+    ENGINE_set_ECDSA_method(engine_, &android_ecdsa_method,
+                            sizeof(android_ecdsa_method));
   }
 
   int rsa_ex_index() const { return rsa_index_; }
   int ec_key_ex_index() const { return ec_key_index_; }
 
   const ENGINE* engine() const { return engine_; }
 
  private:
   const int rsa_index_;
   const int ec_key_index_;
   ENGINE* const engine_;
 };
 
 base::LazyInstance<BoringSSLEngine>::Leaky global_boringssl_engine =
     LAZY_INSTANCE_INITIALIZER;
 
-
 // VectorBignumSize returns the number of bytes needed to represent the bignum
 // given in |v|, i.e. the length of |v| less any leading zero bytes.
 size_t VectorBignumSize(const std::vector<uint8_t>& v) {
   size_t size = v.size();
   // Ignore any leading zero bytes.
   for (size_t i = 0; i < v.size() && v[i] == 0; i++) {
     size--;
   }
   return size;
 }
 
 KeyExData* RsaGetExData(const RSA* rsa) {
   return reinterpret_cast<KeyExData*>(
       RSA_get_ex_data(rsa, global_boringssl_engine.Get().rsa_ex_index()));
 }
 
-size_t RsaMethodSize(const RSA *rsa) {
-  const KeyExData *ex_data = RsaGetExData(rsa);
+size_t RsaMethodSize(const RSA* rsa) {
+  const KeyExData* ex_data = RsaGetExData(rsa);
   return ex_data->cached_size;
 }
 
 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) {
@@ skipping 16 matching lines @@
     // "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, RSA_R_UNKNOWN_PADDING_TYPE);
     return 0;
   }
 
   // Retrieve private key JNI reference.
-  const KeyExData *ex_data = RsaGetExData(rsa);
+  const KeyExData* ex_data = RsaGetExData(rsa);
   if (!ex_data || !ex_data->private_key.obj()) {
     LOG(WARNING) << "Null JNI reference passed to RsaMethodSignRaw!";
     OPENSSL_PUT_ERROR(RSA, ERR_R_INTERNAL_ERROR);
     return 0;
   }
 
   // Pre-4.2 legacy codepath.
   if (ex_data->legacy_rsa) {
     int ret = ex_data->legacy_rsa->meth->rsa_priv_enc(
         in_len, in, out, ex_data->legacy_rsa, ANDROID_RSA_PKCS1_PADDING);
@@ skipping 19 matching lines @@
   // PKCS#1 padding.
   if (!RawSignDigestWithPrivateKey(ex_data->private_key.obj(), from_piece,
                                    &result)) {
     LOG(WARNING) << "Could not sign message in RsaMethodSignRaw!";
     OPENSSL_PUT_ERROR(RSA, ERR_R_INTERNAL_ERROR);
     return 0;
   }
 
   size_t expected_size = static_cast<size_t>(RSA_size(rsa));
   if (result.size() > expected_size) {
-    LOG(ERROR) << "RSA Signature size mismatch, actual: "
-               <<  result.size() << ", expected <= " << expected_size;
+    LOG(ERROR) << "RSA Signature size mismatch, actual: " << result.size()
+               << ", expected <= " << expected_size;
     OPENSSL_PUT_ERROR(RSA, ERR_R_INTERNAL_ERROR);
     return 0;
   }
 
   if (max_out < expected_size) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE);
     return 0;
   }
 
   // Copy result to OpenSSL-provided buffer. RawSignDigestWithPrivateKey
@@ skipping 25 matching lines @@
                        const uint8_t* in,
                        size_t in_len,
                        int padding) {
   NOTIMPLEMENTED();
   OPENSSL_PUT_ERROR(RSA, RSA_R_UNKNOWN_ALGORITHM_TYPE);
   return 0;
 }
 
 const RSA_METHOD android_rsa_method = {
     {
-     0 /* references */,
-     1 /* is_static */
+        0 /* references */, 1 /* is_static */
     } /* common */,
     nullptr /* app_data */,
 
     nullptr /* init */,
     nullptr /* finish */,
     RsaMethodSize,
     nullptr /* sign */,
     nullptr /* verify */,
     RsaMethodEncrypt,
     RsaMethodSignRaw,
@@ skipping 14 matching lines @@
 // backing |private_key|. This parameter is only used for Android < 4.2 to
 // implement key operations not exposed by the platform.
 // 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.
 crypto::ScopedEVP_PKEY CreateRsaPkeyWrapper(
     jobject private_key,
     AndroidRSA* legacy_rsa,
     const crypto::OpenSSLErrStackTracer& tracer) {
-  crypto::ScopedRSA rsa(
-      RSA_new_method(global_boringssl_engine.Get().engine()));
+  crypto::ScopedRSA rsa(RSA_new_method(global_boringssl_engine.Get().engine()));
 
   std::vector<uint8_t> modulus;
   if (!GetRSAKeyModulus(private_key, &modulus)) {
     LOG(ERROR) << "Failed to get private key modulus";
     return nullptr;
   }
 
   std::unique_ptr<KeyExData> ex_data(new KeyExData);
   ex_data->private_key.Reset(nullptr, private_key);
   if (ex_data->private_key.is_null()) {
@@ skipping 55 matching lines @@
   crypto::OpenSSLErrStackTracer tracer(FROM_HERE);
 
   if (base::android::BuildInfo::GetInstance()->sdk_int() >=
       kAndroid42ApiLevel) {
     return CreateRsaPkeyWrapper(private_key, nullptr, tracer);
   }
 
   // Route around platform limitation: if Android < 4.2, then
   // base::android::RawSignDigestWithPrivateKey() cannot work, so try to get the
   // system OpenSSL's EVP_PKEY backing this PrivateKey object.
-  AndroidEVP_PKEY* sys_pkey =
-      GetOpenSSLSystemHandleForPrivateKey(private_key);
+  AndroidEVP_PKEY* sys_pkey = GetOpenSSLSystemHandleForPrivateKey(private_key);
   if (sys_pkey == nullptr)
     return nullptr;
 
   if (sys_pkey->type != ANDROID_EVP_PKEY_RSA) {
     LOG(ERROR) << "Private key has wrong type!";
     return nullptr;
   }
 
   AndroidRSA* sys_rsa = sys_pkey->pkey.rsa;
   if (sys_rsa->engine) {
@@ skipping 42 matching lines @@
                               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(ec_key);
   if (signature.size() > max_expected_size) {
-    LOG(ERROR) << "ECDSA Signature size mismatch, actual: "
-               <<  signature.size() << ", expected <= "
-               << 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,
@@ skipping 36 matching lines @@
                      ex_data.release());
 
   crypto::ScopedEVP_PKEY pkey(EVP_PKEY_new());
   if (!pkey || !EVP_PKEY_set1_EC_KEY(pkey.get(), ec_key.get()))
     return nullptr;
   return pkey;
 }
 
 const ECDSA_METHOD android_ecdsa_method = {
     {
-     0 /* references */,
-     1 /* is_static */
+        0 /* references */, 1 /* is_static */
     } /* common */,
     NULL /* app_data */,
 
     NULL /* init */,
     NULL /* finish */,
     EcdsaMethodGroupOrderSize,
     EcdsaMethodSign,
     EcdsaMethodVerify,
     ECDSA_FLAG_OPAQUE,
 };
@@ skipping 10 matching lines @@
       return GetEcdsaPkeyWrapper(private_key);
     default:
       LOG(WARNING)
           << "GetOpenSSLPrivateKeyWrapper() called with invalid key type";
       return nullptr;
   }
 }
 
 }  // namespace android
 }  // namespace net