Análisis de APK: Herramientas y Workflow de Reverse Engineering

Desmontar para entender

El análisis de APK es la disciplina de desmontar aplicaciones Android para entender qué hacen, cómo lo hacen y si su comportamiento es malicioso. Es una habilidad fundamental para analistas de malware, investigadores de seguridad y equipos de respuesta a incidentes que necesitan determinar rápidamente si una app sospechosa es una amenaza.

Este artículo cubre el proceso completo: desde la estructura interna de un APK hasta un workflow paso a paso de análisis, pasando por las herramientas de análisis estático y dinámico más relevantes.

Estructura de un APK

Un archivo APK es fundamentalmente un archivo ZIP con una estructura definida. Al descomprimirlo, encontramos:

AndroidManifest.xml

El manifiesto es el archivo más importante para el análisis inicial. Declara:

• Package name: Identificador único de la app (com.example.app).
• Permisos: Todos los permisos que la app solicita al sistema.
• Componentes: Activities, Services, BroadcastReceivers y ContentProviders declarados.
• Intent Filters: Qué eventos del sistema activan los componentes (BOOT_COMPLETED, SMS_RECEIVED, etc.).
• Versiones de SDK: minSdkVersion y targetSdkVersion indican las versiones de Android soportadas.
• Características de hardware: Cámara, GPS, NFC requeridos.

En el APK, el AndroidManifest.xml está en formato binario (AXML). Herramientas como APKTool lo decodifican a XML legible.

<!-- Ejemplo de permisos sospechosos en AndroidManifest.xml -->
<uses-permission android:name="android.permission.RECEIVE_SMS"/>
<uses-permission android:name="android.permission.READ_SMS"/>
<uses-permission android:name="android.permission.SEND_SMS"/>
<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
<uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>
<uses-permission android:name="android.permission.READ_CONTACTS"/>
<uses-permission android:name="android.permission.CAMERA"/>

<!-- Accessibility Service declaration (muy sospechoso si no es app de accesibilidad) -->
<service
    android:name=".MyAccessibilityService"
    android:permission="android.permission.BIND_ACCESSIBILITY_SERVICE">
    <intent-filter>
        <action android:name="android.accessibilityservice.AccessibilityService"/>
    </intent-filter>
    <meta-data
        android:name="android.accessibilityservice"
        android:resource="@xml/accessibility_config"/>
</service>

<!-- BOOT_COMPLETED receiver (persistence) -->
<receiver android:name=".BootReceiver">
    <intent-filter>
        <action android:name="android.intent.action.BOOT_COMPLETED"/>
    </intent-filter>
</receiver>

classes.dex (y classes2.dex, classes3.dex...)

Los archivos DEX (Dalvik Executable) contienen el bytecode de la aplicación. En apps grandes que superan el límite de 65.536 métodos, se utilizan múltiples archivos DEX (multidex).

El bytecode DEX es el que las herramientas de decompilación (JADX, Procyon, CFR) traducen de vuelta a Java/Kotlin legible. El código original no se recupera perfectamente (se pierden nombres de variables locales, comentarios y parte de la estructura), pero el resultado es suficiente para entender la lógica.

resources.arsc

Contiene los recursos compilados: strings, estilos, dimensiones y otros valores definidos en XML. Es importante para el análisis porque:

• Las strings pueden contener URLs de C2, mensajes de phishing, o configuraciones.
• Los nombres de recursos pueden revelar la intención de la app.

res/

Directorio con recursos no compilados:

• layouts/ (XML): Definen la interfaz de usuario. Los overlays de banking trojans suelen estar aquí.
• drawable/ y mipmap/: Imágenes e iconos. Los iconos pueden revelar suplantación de apps legítimas.
• xml/: Configuraciones como la de Accessibility Service (accessibility_config.xml).
• raw/: Archivos sin procesar que la app incluye. El malware puede esconder payloads cifrados aquí.

lib/

Librerías nativas (.so) para diferentes arquitecturas: armeabi-v7a, arm64-v8a, x86, x86_64. El malware que usa código nativo (C/C++) para evadir la decompilación Java almacena su lógica aquí. El análisis de binarios .so requiere herramientas como Ghidra o IDA Pro.

META-INF/

Contiene la firma digital del APK:

• MANIFEST.MF: Hashes SHA de cada archivo del APK.
• CERT.SF: Hashes de las entradas del manifiesto.
• CERT.RSA (o .DSA, .EC): Certificado del firmante.

El certificado de firma es un indicador forense: apps del mismo desarrollador malicioso suelen compartir certificado. Sin embargo, muchos actores usan certificados auto-firmados sin información útil.

Herramientas de análisis estático

JADX

JADX es el decompilador de referencia para APKs. Convierte bytecode DEX directamente a código Java legible sin necesidad de pasos intermedios (smali).

# Instalación
# macOS
brew install jadx

# Linux
wget https://github.com/skylot/jadx/releases/latest/download/jadx-*.zip
unzip jadx-*.zip

# Uso CLI
jadx -d output_dir sample.apk

# Uso GUI (recomendado para análisis manual)
jadx-gui sample.apk

Funcionalidades clave para análisis de malware:

• Búsqueda de strings: Buscar URLs, IPs, dominios, claves de API, nombres de paquetes bancarios.
• Búsqueda de usos: Click derecho en una clase o método para encontrar todas las referencias.
• Deobfuscación parcial: JADX intenta reconstruir nombres de variables y simplificar el control flow.
• Navegación por el manifest: Visualizar permisos y componentes directamente.
• Exportación a proyecto Gradle: Para importar en Android Studio y analizar con herramientas IDE.

Limitaciones: Los packers comerciales (Jiagu, Bangcle) cifran el DEX original. JADX solo ve el código del unpacker, no el payload. En estos casos, es necesario análisis dinámico para extraer el DEX descifrado de memoria.

APKTool

APKTool decompila el APK a su representación intermedia: smali (el lenguaje ensamblador de Dalvik) y recursos XML decodificados.

# Instalación
brew install apktool  # macOS
apt install apktool   # Debian/Ubuntu

# Decompilación
apktool d sample.apk -o output_dir

# Recompilación (útil para instrumentación)
apktool b output_dir -o modified.apk

Ventajas sobre JADX:

• AndroidManifest.xml completo: APKTool decodifica el manifiesto binario a XML legible de forma más fiable.
• Smali editable: Permite modificar el código smali y recompilar el APK. Útil para parchear anti-análisis o inyectar logging.
• Recursos completos: Decodifica todos los recursos XML (layouts, strings, configuraciones).

Uso combinado: APKTool para obtener el manifest y recursos; JADX para leer el código Java. Es el combo estándar.

MobSF (Mobile Security Framework)

MobSF es un framework automatizado de análisis estático y dinámico para APKs (Android) e IPAs (iOS).

# Instalación via Docker (recomendado)
docker pull opensecurity/mobile-security-framework-mobsf
docker run -it --rm -p 8000:8000 opensecurity/mobile-security-framework-mobsf

# Acceder via navegador
# http://localhost:8000

Análisis automatizado de MobSF:

1. Manifest analysis: Identifica permisos peligrosos, componentes exportados, debuggable=true.
2. Code analysis: Busca patrones de código inseguro: hardcoded secrets, uso de HTTP sin TLS, logging excesivo, cifrado débil.
3. Binary analysis: Analiza librerías nativas buscando protecciones (PIE, RELRO, stack canaries).
4. Malware indicators: Detecta strings sospechosas, URLs de C2, y patrones conocidos de familias de malware.
5. CVSS scoring: Asigna una puntuación de riesgo a cada hallazgo.
6. Report: Genera un informe completo en HTML/PDF.

MobSF es ideal como primer paso del análisis: proporciona una visión rápida de los indicadores principales antes de profundizar con JADX.

Androguard

Androguard es una librería Python para análisis programático de APKs. Permite automatizar análisis a escala.

from androguard.misc import AnalyzeAPK

# Cargar APK
a, d, dx = AnalyzeAPK("sample.apk")

# Permisos
print("Permisos:", a.get_permissions())

# Package name
print("Package:", a.get_package())

# Activities
print("Activities:", a.get_activities())

# Services (buscar Accessibility Services)
print("Services:", a.get_services())

# Receivers (buscar BOOT_COMPLETED)
print("Receivers:", a.get_receivers())

# Strings del DEX
for s in dx.get_strings():
    # Buscar URLs, IPs, dominios
    if "http" in str(s) or "." in str(s):
        print("String:", s)

# Certificado de firma
cert = a.get_certificates()
for c in cert:
    print("Issuer:", c.issuer)
    print("Subject:", c.subject)
    print("Serial:", c.serial_number)

Androguard es la herramienta de elección para construir pipelines de análisis automatizado: clasificación de muestras, extracción de IOCs, y detección de familias conocidas.

VirusTotal y servicios online

VirusTotal ofrece análisis multi-motor. Subir un APK a VirusTotal proporciona:

• Detecciones de 60+ motores antivirus.
• Análisis de comportamiento (sandbox de Google, VirusTotal Droidy).
• Strings, URLs, IPs extraídas.
• Relaciones con otras muestras (misma firma, mismo C2).

Precaución: Si se analiza una muestra que no debe compartirse públicamente (investigación confidencial), no subirla a VirusTotal. Usar su API con el hash de la muestra para consultar si ya ha sido analizada.

Herramientas de análisis dinámico

Entorno de análisis

El análisis dinámico requiere un entorno controlado:

Emulador Android (Android Studio AVD):

• Ventajas: gratuito, fácil de configurar, snapshots para restaurar estado.
• Desventajas: mucho malware detecta emuladores y modifica su comportamiento.

Dispositivo físico rooteado:

• Ventajas: sin problemas de detección de emulador, rendimiento real.
• Desventajas: riesgo de comprometer el dispositivo, más difícil de restaurar.

Genymotion:

• Emulador comercial basado en VirtualBox. Mejor rendimiento que AVD.
• Tiene una versión gratuita para uso personal.

Configuración recomendada:

• Red aislada (sin acceso a Internet o con proxy controlado).
• DNS fake para capturar dominios C2 sin que se resuelvan realmente.
• Proxy HTTP/HTTPS (mitmproxy, Burp Suite) para interceptar tráfico.
• Servidor C2 simulado (si se quiere observar el protocolo).

Frida

Frida es el framework de instrumentación dinámica más potente para análisis de malware móvil. Permite inyectar scripts JavaScript en procesos Android para observar y modificar su comportamiento en tiempo de ejecución.

# Instalación
pip3 install frida-tools

# Descargar frida-server para la arquitectura del dispositivo/emulador
# https://github.com/frida/frida/releases
# Copiar al dispositivo y ejecutar como root
adb push frida-server-16.x.x-android-arm64 /data/local/tmp/
adb shell chmod +x /data/local/tmp/frida-server-16.x.x-android-arm64
adb shell su -c "/data/local/tmp/frida-server-16.x.x-android-arm64 &"

Scripts Frida comunes para análisis de malware:

// Hook de funciones de cifrado para ver datos en claro
Java.perform(function() {
    var Cipher = Java.use("javax.crypto.Cipher");

    Cipher.doFinal.overload("[B").implementation = function(data) {
        console.log("[Cipher.doFinal] Input: " + bytesToHex(data));
        var result = this.doFinal(data);
        console.log("[Cipher.doFinal] Output: " + bytesToHex(result));
        return result;
    };
});

// Hook de conexiones HTTP para ver URLs de C2
Java.perform(function() {
    var URL = Java.use("java.net.URL");

    URL.$init.overload("java.lang.String").implementation = function(url) {
        console.log("[URL] " + url);
        return this.$init(url);
    };
});

// Bypass de deteccion de root
Java.perform(function() {
    var RootCheck = Java.use("com.malware.utils.RootDetection");

    RootCheck.isRooted.implementation = function() {
        console.log("[Root Check] Bypassed");
        return false;
    };
});

// Hook de SharedPreferences para ver configuracion guardada
Java.perform(function() {
    var SharedPrefs = Java.use("android.app.SharedPreferencesImpl");

    SharedPrefs.getString.implementation = function(key, defValue) {
        var result = this.getString(key, defValue);
        console.log("[SharedPrefs] Key: " + key + " Value: " + result);
        return result;
    };
});

Objection

Objection es un toolkit de exploración basado en Frida que automatiza tareas comunes de análisis.

# Instalación
pip3 install objection

# Conectar a la app objetivo
objection -g com.target.package explore

# Comandos útiles dentro de objection
# Listar activities
android hooking list activities

# Listar services
android hooking list services

# Listar receivers
android hooking list receivers

# Buscar clases que contengan "crypto" o "cipher"
android hooking search classes crypto

# Hook de una clase completa (todos sus metodos)
android hooking watch class com.malware.crypto.AESHelper

# Bypass de SSL pinning
android sslpinning disable

# Bypass de root detection
android root disable

# Dump de la memoria de la app
memory dump all app_memory.bin

# Listar archivos del sandbox de la app
env

Análisis de tráfico de red

La interceptación del tráfico de red es esencial para identificar comunicaciones C2.

mitmproxy:

# Instalar
pip3 install mitmproxy

# Iniciar proxy
mitmproxy -p 8080

# Configurar el emulador/dispositivo para usar el proxy
# En el emulador: Settings > Wi-Fi > proxy manual > IP:8080

# Para interceptar HTTPS, instalar el certificado CA de mitmproxy
# en el dispositivo como certificado de usuario

Burp Suite:

Burp Suite Community (gratuito) o Professional proporciona interceptación HTTP/HTTPS con interfaz gráfica, history, repeater y scanner.

SSL Pinning bypass:

Muchas apps (incluyendo malware) implementan SSL pinning para impedir la interceptación de HTTPS. Métodos de bypass:

1. Frida script: Hook de las funciones de verificación de certificados.
2. Objection: android sslpinning disable automatiza el bypass.
3. Modificación del APK: Parchear el código de SSL pinning con APKTool y recompilar.

Análisis de permisos

El análisis de permisos es el primer filtro de triage. Combinaciones sospechosas:

Patrón: Banking Trojan

RECEIVE_SMS + READ_SMS + INTERNET
+ BIND_ACCESSIBILITY_SERVICE
+ SYSTEM_ALERT_WINDOW (opcional en versiones modernas)
+ RECEIVE_BOOT_COMPLETED

Patrón: Spyware / RAT

CAMERA + RECORD_AUDIO + ACCESS_FINE_LOCATION
+ READ_CONTACTS + READ_CALL_LOG + READ_SMS
+ INTERNET + RECEIVE_BOOT_COMPLETED
+ READ_EXTERNAL_STORAGE

Patrón: Stalkerware

ACCESS_FINE_LOCATION + ACCESS_BACKGROUND_LOCATION
+ CAMERA + RECORD_AUDIO + READ_SMS + READ_CALL_LOG
+ READ_CONTACTS + INTERNET
+ RECEIVE_BOOT_COMPLETED + FOREGROUND_SERVICE

Permisos que requieren atención especial

Permiso	Riesgo	Contexto
BIND_ACCESSIBILITY_SERVICE	Critico	Control total de la UI. Solo legítimo en apps de accesibilidad
BIND_DEVICE_ADMIN	Alto	Impide desinstalación. Solo legítimo en apps MDM
SYSTEM_ALERT_WINDOW	Alto	Overlay attacks. Legítimo en apps de chat heads
BIND_NOTIFICATION_LISTENER	Alto	Lee todas las notificaciones. Legítimo en launchers
REQUEST_INSTALL_PACKAGES	Alto	Puede instalar otros APKs. Dropper indicator
RECEIVE_SMS / READ_SMS	Alto	Intercepción de OTP. Solo legítimo en apps de SMS

Extracción y análisis de strings

Las strings embebidas en el APK son una fuente rica de inteligencia:

Qué buscar

• URLs y dominios: Endpoints de C2, URLs de descarga de payload.
• IPs: Servidores C2, infraestructura del atacante.
• Rutas de API: /gate, /api/bot, /panel/, /inject/.
• Nombres de paquetes bancarios: com.bbva., com.bankia., es.lacaixa..
• Claves de cifrado: Strings con longitud de clave (16, 24, 32 bytes) en Base64 o hex.
• User-Agents: Strings que identifican el bot en comunicaciones con el C2.
• Comandos: Keywords como sms_intercept, screen_record, keylog, overlay.

Extracción automatizada

# Extraer strings del APK con strings (Unix)
unzip -o sample.apk -d extracted/
strings extracted/classes.dex | grep -E "http[s]?://" > urls.txt
strings extracted/classes.dex | grep -E "[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}" > ips.txt

# Con Androguard (Python)
python3 -c "
from androguard.misc import AnalyzeAPK
a, d, dx = AnalyzeAPK('sample.apk')
for s in dx.get_strings():
    s_str = str(s)
    if any(kw in s_str.lower() for kw in ['http', 'gate', 'bot', 'inject', 'c2']):
        print(s_str)
"

Strings ofuscadas

El malware frecuentemente ofusca strings sensibles:

• Base64: Decodificar con base64 -d.
• XOR: Cada carácter XORed con una clave. Buscar funciones de "decrypt" o "decode" en el código decompilado.
• AES/DES: Strings cifradas con clave embebida. Buscar la clave en el código.
• Custom encoding: Tablas de sustitución, inversión de strings, split en arrays.

Desobfuscación de código

Identificar el tipo de ofuscación

1. ProGuard/R8: Clases y métodos renombrados a a, b, c. Estructura del código intacta pero nombres ilegibles.
2. DexGuard: Ofuscación más agresiva: string encryption, control flow obfuscation, class encryption.
3. Packer (Jiagu, Bangcle): El DEX completo está cifrado. JADX solo muestra el stub del unpacker.

Estrategias de desobfuscación

Para ProGuard/R8:

• JADX maneja bien esta ofuscación. Renombrar manualmente las clases y métodos identificados.
• Buscar clases no ofuscadas (librerías externas, APIs de Android) como puntos de entrada.
• Seguir el flujo desde componentes declarados en el manifest (Activities, Services, Receivers).

Para string encryption:

• Identificar la función de descifrado en el código decompilado.
• Reimplementar la función en Python o usar Frida para hookearla en tiempo de ejecución.

// Frida: hookear funcion de descifrado de strings
Java.perform(function() {
    var StringDecryptor = Java.use("com.malware.obf.a");

    StringDecryptor.b.implementation = function(encrypted) {
        var decrypted = this.b(encrypted);
        console.log("[Decrypt] " + encrypted + " -> " + decrypted);
        return decrypted;
    };
});

Para packers:

• Ejecutar la app en un emulador/dispositivo.
• Usar Frida para dumpear el DEX descifrado de memoria:

// Frida: dump DEX from memory
Java.perform(function() {
    Java.enumerateClassLoaders({
        onMatch: function(loader) {
            console.log("ClassLoader: " + loader);
            // Buscar el DexFile cargado dinámicamente
        },
        onComplete: function() {}
    });
});

• Herramientas especializadas como FART (First Android Unpacker Tool), DexDump y FDex2.

Workflow paso a paso

Paso 1: Triage inicial (5 minutos)

# Calcular hashes
md5sum sample.apk
sha256sum sample.apk

# Consultar VirusTotal por hash (sin subir la muestra)
# https://www.virustotal.com/gui/file/{sha256}

# Si ya está en VT: revisar detecciones, tags, comportamiento
# Si no está: decidir si subir según política de la investigación

Paso 2: Análisis automatizado (10 minutos)

# Subir a MobSF local
# http://localhost:8000 -> Upload & Analyze

# Revisar el report:
# - Permisos peligrosos
# - Componentes exportados
# - Strings sospechosas
# - Hardcoded secrets
# - Análisis de código

Paso 3: Análisis del manifest (10 minutos)

# Decompilar con APKTool
apktool d sample.apk -o sample_decoded/

# Revisar AndroidManifest.xml
# Buscar:
# - Permisos (patrón banking trojan, spyware, stalkerware)
# - Services con BIND_ACCESSIBILITY_SERVICE
# - Receivers para BOOT_COMPLETED, SMS_RECEIVED
# - Device Admin receivers
# - Package name y versión

Paso 4: Decompilación y análisis de código (30-60 minutos)

# Abrir en JADX GUI
jadx-gui sample.apk

# Orden de análisis:
# 1. Ir a los componentes declarados en el manifest (Activities, Services, Receivers)
# 2. Buscar strings: URLs, IPs, "http", "gate", "bot", "inject"
# 3. Buscar clases con nombres sugerentes: *Crypto*, *C2*, *Overlay*, *SMS*
# 4. Seguir el flujo desde el main Activity o Application class
# 5. Identificar funciones de cifrado/descifrado
# 6. Mapear la comunicación con el C2 (endpoints, protocolo, datos)

Paso 5: Extracción de IOCs (15 minutos)

Documentar todos los indicadores extraídos:

• Hashes del APK (MD5, SHA1, SHA256).
• URLs de C2.
• IPs de C2.
• Dominios.
• Certificado de firma (serial, issuer).
• Package name y versión.
• Nombres de archivos DEX descargados.
• Claves de cifrado (si se identifican).
• User-Agent utilizado en comunicaciones HTTP.

Paso 6: Análisis dinámico (30-60 minutos, si es necesario)

# Instalar la app en el emulador
adb install sample.apk

# Iniciar Frida server
adb shell su -c "/data/local/tmp/frida-server &"

# Conectar con objection
objection -g com.target.package explore

# Bypass SSL pinning
android sslpinning disable

# Observar tráfico de red con mitmproxy

# Hookear funciones clave con Frida scripts

# Documentar comportamiento observado:
# - ¿Solicita Accessibility Service?
# - ¿Muestra overlays?
# - ¿Envía datos al C2?
# - ¿Intercepta SMS?
# - ¿Descarga DEX adicionales?

Paso 7: Documentación y reporte

Documentar los hallazgos en un formato estructurado:

• Metadata: Hashes, package name, versión, certificado.
• Clasificación: Tipo de malware (banking trojan, RAT, spyware, etc.).
• Familia: Si se identifica (Xenomorph, TeaBot, SpyNote, etc.).
• Capacidades: Lista de funcionalidades maliciosas documentadas.
• IOCs: Tabla de indicadores extraídos con tipo y contexto.
• TTPs: Mapeo a MITRE ATT&CK Mobile.
• Recomendaciones de detección: Reglas YARA, Sigma o indicadores de red.

Muestras de práctica seguras

Para desarrollar habilidades de análisis de APK sin riesgo:

Recurso	Tipo	Descripción
DIVA	App vulnerable	13 retos de vulnerabilidades Android
InsecureBankv2	App vulnerable	Simula una app bancaria insegura
OWASP MSTG CrackMe	Retos RE	Retos de reverse engineering Android/iOS
MalwareBazaar	Muestras reales	Repositorio de muestras etiquetadas (precaución)
Koodous	Muestras Android	Plataforma colaborativa de análisis Android

Precauciones al trabajar con muestras reales:

• Usar siempre un entorno aislado (VM, emulador sin acceso a red).
• No instalar muestras en dispositivos personales.
• No conectar el entorno de análisis a redes de producción.
• No subir muestras confidenciales a servicios públicos (VT, MobSF online).

Recursos

• JADX (decompilador DEX a Java, código abierto)
• APKTool (herramienta de ingeniería inversa de APK)
• MobSF (framework de análisis automatizado)
• Frida (instrumentación dinámica multiplataforma)
• Objection (toolkit de exploración basado en Frida)
• Androguard (librería Python para análisis de APK)
• OWASP Mobile Security Testing Guide (metodología completa de testing)
• MITRE ATT&CK Mobile (marco de referencia de TTPs)
• Ghidra (herramienta de ingeniería inversa de la NSA para binarios nativos)
• MalwareIntel (plataforma de inteligencia sobre familias de malware)