"Una buena defensa es la mejor ofensiva". Alguien dijo una vez eso.

Bueno, eso es en parte cierto en Android cuando se trata de almacenar claves API y protegerlas contra piratas informáticos.

Debe mantener sus claves API privadas y seguras por múltiples razones. Si un hacker obtiene acceso a su clave API, podría:

• hacer llamadas API y que podrían aumentar enormemente sus costos de facturación, y / o
• úselo para interrumpir los datos de sus usuarios.

Antes de sumergirnos en mejorar la seguridad de sus claves API, hablemos de cómo la mayoría de los desarrolladores almacenan actualmente las claves API.

La forma tradicional de almacenar claves API

Almacenar claves API en strings.xml: Este es un gran no-no. Definitivamente no es seguro, y con un poco de ingeniería inversa, los piratas informáticos pueden descifrar fácilmente la clave API si la almacena en cualquier archivo XML en su proyecto de Android. Además, en una nota más obvia, si su repositorio es público, su archivo strings.xml también lo sería. Esto significa que su clave API también sería pública.

Almacenar claves API en gradle.properties: Esta parece ser la opción más popular. Es posible que haya agregado este archivo a .gitignore, declarando su clave API dentro, refiriéndose a ella en el nivel de aplicación build.gradle y usarlo en su aplicación a través de la clase BuildConfig generada. Si bien esto es más seguro que almacenarlo en archivos XML, alguien puede decodificar su clave API mediante ingeniería inversa. Por lo tanto, esta no es una forma muy segura de almacenar sus claves API.

La mejor manera: llevar el poder de CMake a Android

CMake es una herramienta de software que gestiona los procesos de compilación de otro software.

En este artículo, compartiré cómo escribir un código C ++ corto para almacenar su clave API de forma segura y acceder a su clave API desde su archivo C ++.

El código nativo C / C ++ es más difícil de descompilar y, por lo tanto, los piratas informáticos tendrán más dificultades para obtener acceso a sus claves API. Se ha demostrado que esto es más seguro que almacenarlo en su gradle.properties archivo, y definitivamente es algo que recomendaría implementar en su aplicación si está buscando mejorar la seguridad en torno a su sistema de almacenamiento de claves API.

Paso 1: instale las herramientas necesarias

Deberá instalar 3 herramientas en Android Studio a través del Administrador de SDK:

• NDK (Kit de desarrollo nativo): Esta es una herramienta que se utiliza para trabajar con código C / C ++ en Android. También le permite acceder a ciertos componentes del dispositivo, como sensores, entrada táctil, etc.
• LLDB (depurador de bajo nivel): Este es un depurador de código nativo.
• CMake: Esta es la herramienta que construye su biblioteca nativa de C / C ++.

Paso 2: Crea un native-lib.cpp presentar

Crear una nueva carpeta, cpp, dentro app/src/main.

Una vez que lo haya creado, haga clic derecho en el cpp carpeta, haga clic en Nuevo → Archivo fuente C / C ++y nombra tu archivo native-lib.cpp.

Paso 3: Almacene su clave API dentro de native-lib.cpp presentar

Dentro de su native-lib.cpp, agregue el siguiente código:

#include <jni.h>
#include <string> extern "C" JNIEXPORT jstring JNICALL
Java_com_package_name_Keys_apiKey(JNIEnv *env, jobject object) { std::string api_key = "your_api_key_goes_here"; return env->NewStringUTF(api_key.c_str());
}

Echemos un vistazo más de cerca al nombre de la función C ++ Java_com_package_name_Keys_apiKey(...) declarado arriba de derecha a izquierda:

• apiKey: Esto se refiere directamente al nombre del método que usará en Kotlin más adelante.
• Keys: Esto se refiere al objeto Kotlin en el que desea usar su clave API, donde interactuará con el código C ++ y obtendrá una referencia a su clave API (que puede usar en toda su aplicación).
• com_package_name: Esto se refiere al nombre del paquete correspondiente a Keys Kotlin se opone aquí. Esto siempre debe apuntar al paquete de la clase donde tiene la intención de usarlo. Entonces, si el nombre del paquete es com.package.name, el . (períodos) se reemplazan con _ (subrayado), y se convierte com_package_name.

Almacene su clave API en el api_key variable en la función C ++ anterior y devuélvala como se muestra en el fragmento de código anterior.

Note: No olvides agregar tu native-lib.cpp para usted .gitignore. ¡NO desea que este archivo esté en su control de versiones! Si no sabe qué es el control de versiones, consulte este tutorial esta página.

Paso 4: Crea un CMakeLists.txt presentar

Bajo la app/ carpeta, cree un nuevo archivo de texto y asígnele un nombre CMakeLists.txt. Agregue el siguiente código en el archivo:

# For more information about using CMake with Android Studio, read the
# documentation: https://d.android.com/studio/projects/add-native-code.html # Sets the minimum version of CMake required to build the native library. cmake_minimum_required(VERSION 3.4.1) # Creates and names a library, sets it as either STATIC
# or SHARED, and provides the relative paths to its source code.
# You can define multiple libraries, and CMake builds them for you.
# Gradle automatically packages shared libraries with your APK. add_library( # Sets the name of the library. native-lib # Sets the library as a shared library. SHARED # Provides a relative path to your source file(s). src/main/cpp/native-lib.cpp ) # Searches for a specified prebuilt library and stores the path as a
# variable. Because CMake includes system libraries in the search path by
# default, you only need to specify the name of the public NDK library
# you want to add. CMake verifies that the library exists before
# completing its build. find_library( # Sets the name of the path variable. log-lib # Specifies the name of the NDK library that # you want CMake to locate. log ) # Specifies libraries CMake should link to your target library. You
# can link multiple libraries, such as libraries you define in this
# build script, prebuilt third-party libraries, or system libraries. target_link_libraries( # Specifies the target library. native-lib # Links the target library to the log library # included in the NDK. ${log-lib} )

Paso 5: Configurar Gradle para CMake

Agregue las siguientes líneas al android bloquear en su nivel de aplicación build.gradle archivo:

android { ... externalNativeBuild { cmake { path "CMakeLists.txt" } }
}

Reconstruya su proyecto después de haber modificado su archivo Gradle.

Paso 6: Crear el Keys.kt presentar

Crea un objeto Kotlin, Keys.kt, y obtenga su clave API de la siguiente manera:

object Keys { init { System.loadLibrary("native-lib") } external fun apiKey(): String
}

Ahora, debes llamar al System.loadLibrary("native-lib") método en el init bloque para cargar el código C ++ que ha escrito en el native-lib.cpp archivo.

Una vez que haya hecho esto, puede obtener una referencia a su método declarando una función Kotlin externa con el mismo nombre que el mencionado anteriormente en el Paso 3. En este ejemplo, es apiKey().

Ahora, para obtener su clave API de cualquier parte de su aplicación, simplemente llame:

Keys.apiKey()

Conclusión

Nunca es una buena idea dejar sus claves de API en su base de código de una manera que sea fácilmente decodificable.

Aquí hay una aplicación de muestra que está configurada para que la veas y comiences:

Zona de juegos segura API Key Store

¡Así que pruebe este pequeño truco para asegurarse de que sus claves API no caigan en las manos equivocadas, o que no termine con una factura API tan alta como una montaña! 😇

Fuente: https://www.codementor.io/blog/kotlin-apikeys-7o0g54qk5b