Guía de JADX en Kali Linux

https://www.onlinetis.com

Guía de JADX en Kali Linux

Parece que estás interesado en usar JADX en Kali Linux. Es una excelente elección; si trabajas con ingeniería inversa de aplicaciones Android, JADX es básicamente el "estándar de oro" por lo limpio que deja el código fuente.

Aquí tienes una guía rápida para instalarlo y ponerlo en marcha.

¿Qué es JADX?

JADX es un descompilador de línea de comandos y de interfaz gráfica (GUI) para archivos DEX, APK, JAR y CLASS. Su función principal es transformar el código binario de una aplicación de Android de nuevo a un código Java que los humanos podamos leer.

Instalación en Kali Linux

Kali suele tener muchas herramientas preinstaladas, pero a veces es mejor descargar la última versión directamente desde el repositorio oficial para evitar errores de compatibilidad.

1. Actualizar el sistema

Primero, asegúrate de que tu sistema esté al día:

Bash

sudo apt update && sudo apt upgrade -y

2. Instalar Java (Si no lo tienes)

JADX requiere Java 11 o superior. Puedes verificarlo con java -version. Si necesitas instalarlo:

Bash

sudo apt install default-jdk -y

3. Descargar JADX

La forma más limpia es descargar los binarios desde GitHub:

Ve a la página de Releases de JADX.
Descarga el archivo jadx-<version>.zip.
Descomprímelo en una carpeta (por ejemplo, /opt/jadx).

Cómo usarlo

Uso de la Interfaz Gráfica (Recomendado)

Si prefieres ver el código con colores, buscador y árbol de carpetas (estilo IDE), usa la versión GUI:

Entra en la carpeta bin de donde descomprimiste JADX.
Ejecuta:
Bash
```
./jadx-gui
```
Selecciona tu archivo .apk y ¡listo!

Uso por Línea de Comandos

Si solo quieres extraer el código rápidamente sin abrir una ventana:

Bash

jadx archivo.apk -d ruta_de_salida

-d: Especifica el directorio donde quieres que se guarde el código fuente descompilado.

Consejos Útiles

Ofuscación: Si el código que ves tiene variables como a, b, c, es porque la app está "ofuscada" (usando ProGuard o R8). JADX tiene una opción llamada "Deobfuscation" en los ajustes que intenta renombrar estas variables para que el código sea más entendible.
Recursos: JADX no solo te da el código Java, también extrae el archivo AndroidManifest.xml y todos los recursos (imágenes, layouts en XML), lo cual es vital para entender cómo funciona la app.

Nota de seguridad: Recuerda siempre realizar ingeniería inversa en entornos controlados y con fines educativos o de auditoría autorizada.

Una vez que tienes el código descompilado en JADX, la verdadera diversión comienza. Buscar vulnerabilidades manualmente en miles de archivos es imposible, así que lo mejor es usar el buscador global (Ctrl + Shift + F en JADX-GUI) para rastrear "tesoros" ocultos.

Aquí tienes una hoja de ruta de qué buscar y cómo identificar fallos críticos:

1. Búsqueda de Secretos (Hardcoded Secrets)

Muchos desarrolladores cometen el error de dejar credenciales directamente en el código. Busca las siguientes palabras clave:

Qué buscar	Por qué es peligroso
`api_key`, `apikey`	Acceso no autorizado a servicios de terceros (AWS, Firebase, Google Maps).
`password`, `secret`, `token`	Credenciales de bases de datos o tokens de acceso administrativo.
`https://staging.`, `https://test.`	Direcciones de servidores de prueba que suelen ser menos seguros que los de producción.

Ejemplo de hallazgo:

Java
public static final String STRIPE_KEY = "sk_live_51M..."; // ¡Peligro! Acceso a pagos.

2. Debilidades en el Cifrado

A veces las apps usan cifrado, pero lo hacen mal. Busca estas malas prácticas:

Criptografía obsoleta: Busca DES o MD5. Son algoritmos rotos que no deberían usarse hoy en día.
IV o Claves estáticas: Si ves algo como new SecretKeySpec("1234567890123456".getBytes(), "AES"), la clave es fija para todos los usuarios. Si descifras la de un usuario, descifras las de todos.
Modo ECB: Busca AES/ECB. Este modo no usa vector de inicialización y es vulnerable a patrones de datos.

3. WebView y JavaScript (Puente de Inyección)

Si la app usa WebView para mostrar contenido web, busca estas líneas:

Java
webView.getSettings().setJavaScriptEnabled(true);
webView.addJavascriptInterface(new MyInterface(), "Android");

El riesgo: Si el atacante logra inyectar JavaScript en la página que carga la app, podría ejecutar código Java dentro del teléfono del usuario a través del "puente" (addJavascriptInterface).

4. Archivo `AndroidManifest.xml`

No todo es código Java. JADX te permite ver el manifiesto, donde puedes encontrar:

android:debuggable="true": Si está en true, cualquiera puede conectar el teléfono y depurar la app para extraer datos en tiempo real.
android:exported="true": Busca actividades o servicios con este parámetro. Significa que otras apps instaladas en el mismo teléfono pueden abrir esa ventana o servicio sin permiso, saltándose pantallas de login.
allowBackup="true": Permite extraer los datos privados de la app mediante un simple comando adb backup, incluso sin ser usuario root.

Herramientas para automatizar esto

Si el proyecto es muy grande, puedes usar herramientas que analizan el código de JADX automáticamente:

MobSF (Mobile Security Framework): Es una suite completa que hace todo este escaneo por ti.
grep / ripgrep: Desde la terminal de Kali, una vez extraído el código con jadx -d out/, puedes usar:
grep -rE "password|api_key|token" out/

Automatizar la búsqueda de secretos es el paso lógico después de usar la interfaz visual de JADX. Cuando tienes cientos de archivos Java, no quieres usar Ctrl + F uno por uno.

Este script en Python recorrerá todos los archivos de la carpeta que generó JADX y extraerá posibles "tesoros" usando expresiones regulares (Regex).

Script: Buscador de Secretos en Código Descompilado

Primero, asegúrate de haber exportado el código con JADX:

jadx mi_app.apk -d carpeta_codigo

Luego, guarda este script como hunter.py y ejecútalo:

Python
import os
import re

# Configuración: Carpeta donde JADX guardó el código
DIRECTORIO_BUSQUEDA = "carpeta_codigo"

# Patrones comunes de vulnerabilidades y secretos
PATRONES = {
    "API Key/Token": r'(?i)(api[_-]?key|auth[_-]?token|secret|password|access[_-]?key)["\s:=]+[A-Za-z0-9_\-\.]{16,}',
    "Firebase URL": r'https://[a-z0-9.-]+\.firebaseio\.com',
    "IP Local/Interna": r'\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b',
    "AWS Access Key": r'AKIA[0-9A-Z]{16}',
    "Google API Key": r'AIza[0-9A-Za-z\\-_]{35}'
}

def buscar_vulnerabilidades():
    print(f"[*] Iniciando escaneo en: {DIRECTORIO_BUSQUEDA}\n")
    
    for raiz, dirs, archivos in os.walk(DIRECTORIO_BUSQUEDA):
        for nombre_archivo in archivos:
            # Solo buscamos en archivos .java y .xml
            if nombre_archivo.endswith(('.java', '.xml')):
                ruta_completa = os.path.join(raiz, nombre_archivo)
                
                try:
                    with open(ruta_completa, 'r', encoding='utf-8', errors='ignore') as f:
                        contenido = f.read()
                        for nombre_riesgo, regex in PATRONES.items():
                            hallazgos = re.findall(regex, contenido)
                            if hallazgos:
                                print(f"[!] {nombre_riesgo} detectado en: {ruta_completa}")
                                for h in hallazgos:
                                    print(f"    - Valor: {h}")
                except Exception as e:
                    continue

if __name__ == "__main__":
    buscar_vulnerabilidades()

¿Cómo interpretar los resultados?

Cuando el script te devuelva una alerta, debes validar si es un Falso Positivo o una Vulnerabilidad Real:

Hardcoded Credentials: Si encuentras una clave de AWS o Stripe, intenta verificar si tiene permisos (¡con cuidado!). Muchas veces los desarrolladores dejan llaves con acceso total a sus servidores.
Firebase: Si encuentras una URL de Firebase, puedes intentar acceder a https://nombre-proyecto.firebaseio.com/.json. Si devuelve datos, la base de datos está mal configurada y es pública.
IPs Internas: Revelan la arquitectura del servidor de la empresa (ej. 10.0.0.50), lo cual ayuda en la fase de reconocimiento de un ataque.

El siguiente nivel: MobSF

Si este script te parece útil pero quieres algo profesional, en Kali puedes instalar MobSF (Mobile Security Framework). Es un contenedor Docker que hace un análisis estático y dinámico completo, mostrándote gráficas de seguridad y un score de riesgo.

MobSF (Mobile Security Framework) es, sin duda, la herramienta "todo en uno" más potente para auditoría de aplicaciones móviles. A diferencia del script manual, MobSF no solo busca texto, sino que analiza permisos, bibliotecas inseguras, configuraciones de red y hasta genera un reporte en PDF.

En Kali Linux, la forma más limpia y rápida de correrlo es usando Docker, para evitar conflictos con las versiones de Python y Java del sistema.

1. Instalar Docker en Kali

Si aún no tienes Docker instalado, abre tu terminal y ejecuta:

Bash
sudo apt update
sudo apt install -y docker.io
sudo systemctl enable docker --now
# Agrega tu usuario al grupo docker para no usar 'sudo' siempre
sudo usermod -aG docker $USER

(Nota: Después de esto, reinicia tu sesión o cierra y abre la terminal).

2. Descargar y Ejecutar MobSF

Una vez que Docker está listo, solo necesitas un comando para descargar la imagen oficial y ponerla en marcha:

Bash

docker pull opensecurity/mobsf:latest
docker run -it --rm -p 8000:8000 opensecurity/mobsf:latest

¿Qué hace este comando?

-p 8000:8000: Mapea el puerto 8000 de MobSF al puerto 8000 de tu Kali.
--rm: Borra el contenedor cuando lo detengas (ahorra espacio).
-it: Te permite ver los logs en tiempo real por si algo falla.

3. Acceder al Panel de Control

Una vez que veas en la terminal algo como [INFO] Listening at: http://0.0.0.0:8000:

Abre tu navegador (Firefox) en Kali.
Ve a la dirección: http://localhost:8000
Verás una interfaz web limpia donde simplemente tienes que arrastrar y soltar tu archivo .APK.

4. ¿Qué analizar en el reporte de MobSF?

Cuando MobSF termine de analizar (tarda de 1 a 3 minutos), fíjate especialmente en estas secciones:

Security Score: Una nota del 0 al 100. Si es menor a 50, la app es un desastre de seguridad.
Manifest Analysis: Te avisará si la app tiene permisos excesivos (ej. una app de linterna pidiendo leer tus SMS).
Code Analysis: Aquí clasifica automáticamente los hallazgos del script que hicimos antes en "High" (Crítico), "Medium" o "Info".
Domain Malware Check: MobSF extrae todas las URLs del código y las cruza con bases de datos de malware para ver si la app se comunica con servidores maliciosos.

Pro-Tip: Análisis Dinámico

Si tienes un emulador (como Genymotion) corriendo en tu Kali, MobSF puede conectarse a él. Esto te permite "interceptar" el tráfico HTTPS mientras usas la app, algo que JADX por sí solo no puede hacer.

Aquí es donde la auditoría se pone realmente interesante. Mientras que JADX y MobSF analizan el código "en reposo" (Análisis Estático), usar Burp Suite te permite ver la aplicación "en movimiento" (Análisis Dinámico).

El objetivo es interceptar las peticiones HTTP/HTTPS que la app envía al servidor para ver si puedes manipular datos (como cambiar el precio de un carrito de compras o saltarte un login).

El reto: El Certificado SSL

Las apps modernas usan HTTPS. Para que Burp Suite pueda "leer" ese tráfico, el teléfono debe confiar en Burp. Aquí tienes los pasos para configurar tu entorno en Kali:

1. Configurar el Proxy en Burp Suite

Abre Burp Suite en Kali (ya viene preinstalado).
Ve a la pestaña Proxy > Options.
En Proxy Listeners, dale a Edit al que ya existe (127.0.0.1:8080).
Cambia "Loopback only" por "All interfaces" (esto permite que el celular o emulador se conecte a tu PC).
Anota la IP de tu Kali (usa hostname -I en la terminal). Supongamos que es 192.168.1.15.

2. Configurar el Dispositivo (Android)

Ya sea un móvil físico o un emulador (como Genymotion o el de Android Studio):

Ve a Ajustes > WiFi.
Mantén presionada tu red y elige Modificar Red.
En Proxy, selecciona Manual.
Hostname: La IP de tu Kali (192.168.1.15).
Puerto: 8080.

3. Instalar el Certificado CA de Burp

Si intentas navegar ahora, verás errores de "Conexión no segura". Debes instalar el certificado de Burp en el Android:

En el navegador del móvil, ve a http://burp.
Toca el botón CA Certificate para descargar el archivo cacert.der.
Paso crítico en Android: Cambia la extensión de .der a .cer.
Ve a Ajustes > Seguridad > Instalar desde almacenamiento y selecciona el archivo. Dale un nombre como "Burp".

4. El obstáculo final: SSL Pinning

Muchas apps modernas usan SSL Pinning, una técnica que hace que la app ignore el certificado de Burp y solo confíe en el suyo propio. Si la app no tiene internet después de configurar el proxy, tiene SSL Pinning.

¿Cómo saltárselo?

Aquí es donde entra Frida, la herramienta definitiva de instrumentación dinámica.

Instala Frida en tu Kali: pip3 install frida-tools.
Frida-server: Debes meter un pequeño archivo ejecutable dentro del Android (en /data/local/tmp) y ejecutarlo.
Script de Bypass: Usas un script de la comunidad (como los de codeshare.frida.re) para "engañar" a la app en tiempo real y obligarla a aceptar el certificado de Burp.

¿Qué buscar una vez interceptes el tráfico?

IDOR (Insecure Direct Object Reference): Si la app pide GET /api/user/123, intenta cambiarlo por GET /api/user/124 en Burp para ver si puedes ver datos de otros usuarios.
Falta de Rate Limiting: ¿Puedes enviar 1,000 peticiones de "olvidé mi contraseña" en un segundo?
Parámetros ocultos: A veces las apps envían campos como is_admin: false. ¡Intenta cambiarlo a true!

Buscar este blog