Pentesting en Aplicaciones Móviles: Guía Completa 2026 (Android + iOS)

📘 Este artículo forma parte de nuestra Guía Completa de Hacking Ético 2026 y complementa a nuestra Guía Completa de Ciberseguridad. Si quieres dominar el pentesting, esas guías son tu punto de partida.

Introducción

El pentesting de aplicaciones móviles es una de las disciplinas más demandadas en ciberseguridad. Con más de 7.000 millones de dispositivos móviles en el mundo y aplicaciones que manejan datos bancarios, médicos y personales, las vulnerabilidades en apps móviles pueden tener consecuencias devastadoras.

En 2026, el pentesting móvil ya no es opcional: es un requisito para:

• Cumplimiento normativo (PCI-DSS, ISO 27001, NIS2).
• Publicación en tiendas (Google Play, App Store).
• Confianza del usuario.
• Prevención de brechas millonarias.

En esta guía completa vas a aprender:

• Qué es el pentesting móvil y por qué es diferente del web.
• OWASP MASVS y MASTG, los estándares de referencia.
• Metodología completa: reconocimiento, análisis, explotación, reporte.
• Configuración del entorno en Android e iOS.
• Herramientas esenciales con comandos reales.
• Análisis estático y dinámico paso a paso.
• Bypass de SSL pinning (técnica crítica).
• Vulnerabilidades comunes y cómo detectarlas.
• Troubleshooting de problemas frecuentes.
• FAQ con las preguntas más frecuentes.

Si te interesa el hacking ético en general, consulta nuestra Guía Completa de Hacking Ético. Para el análisis forense, nuestra Guía de forense digital.

Índice de contenidos

1. ¿Qué es el pentesting móvil?
2. Diferencias Android vs iOS
3. OWASP MASVS y MASTG
4. Metodología completa
5. Configuración del entorno
6. Herramientas esenciales
7. Análisis estático
8. Análisis dinámico
9. Bypass de SSL pinning
10. Vulnerabilidades comunes
11. Troubleshooting
12. FAQ
13. Conclusión

1. ¿Qué es el pentesting móvil?

El pentesting de aplicaciones móviles es una simulación controlada de ataques sobre una app móvil (Android o iOS) con el objetivo de:

• Identificar vulnerabilidades.
• Evaluar su impacto.
• Documentar hallazgos.
• Recomendar mitigaciones.

1.1 Diferencias con el pentesting web

1.2 Objetivos típicos del pentesting móvil

• Almacenamiento inseguro de datos sensibles.
• Comunicaciones inseguras (SSL pinning ausente, HTTP).
• Autenticación débil (tokens, sesiones).
• Autorización incorrecta (IDOR, privilege escalation).
• Código ofuscado o no.
• Fugas de información en logs.
• Análisis de API backend.

1.3 Marco legal

⚠️ NUNCA hagas pentesting sin autorización por escrito:

• Contrato con alcance definido.
• NDA firmado.
• RoE (Reglas de enfrentamiento).
• Contacto técnico disponible.

Consulta Guía Completa de Hacking Ético para el marco legal.

2. Diferencias Android vs iOS

Conclusión:

• Android: más fácil de analizar, más vulnerable históricamente.
• iOS: más seguro por diseño, pero no invulnerable.

3. OWASP MASVS y MASTG

OWASP mantiene dos estándares esenciales para pentesting móvil:

3.1 MASVS (Mobile Application Security Verification Standard)

Define 7 categorías de requisitos de seguridad:

Niveles:

• L1: básico (apps estándar).
• L2: defensivo (apps con datos sensibles).
• L3: avanzado (apps críticas, banca).

3.2 MASTG (Mobile Application Security Testing Guide)

Guía técnica con cientos de tests específicos:

• Cómo probar cada requisito de MASVS.
• Herramientas recomendadas.
• Ejemplos reales.
• Actualizada continuamente.

Recursos:

• MASVS: https://mas.owasp.org/MASVS/
• MASTG: https://mas.owasp.org/MASTG/

Recomendación: usa MASVS como checklist y MASTG como guía técnica.

Consulta Guía Completa de Hacking Ético para otros frameworks (PTES, MITRE).

4. Metodología completa

El pentesting móvil sigue estas fases:

4.1 Pre-engagement

• Definir alcance: versión, plataforma, backend.
• Firmar contratos (NDA, RoE).
• Establecer ventanas de prueba.
• Preparar entorno y credenciales.

4.2 Reconocimiento

• Recopilar información de la app (tienda, web, código abierto).
• Identificar tecnologías (frameworks, SDKs).
• Enumerar endpoints de API.
• Analizar permisos solicitados.

4.3 Análisis estático

• Descompilar APK/IPA.
• Analizar código fuente.
• Buscar secretos, claves, endpoints.
• Revisar AndroidManifest / Info.plist.
• Verificar ofuscación.

4.4 Análisis dinámico

• Ejecutar la app en entorno controlado.
• Interceptar tráfico (Burp, ZAP).
• Analizar almacenamiento local.
• Probar autenticación y autorización.
• Fuzzing de APIs.

4.5 Explotación

• Explotar vulnerabilidades encontradas.
• Escalar privilegios.
• Bypass de controles (SSL pinning, root detection).
• Documentar con evidencias.

4.6 Reporte

• Clasificar hallazgos por severidad.
• Documentar con PoC.
• Recomendar mitigaciones.
• Presentar al cliente.

Consulta Cómo realizar un análisis de vulnerabilidades para profundizar.

5. Configuración del entorno

5.1 Entorno Android

Dispositivo:

• Físico recomendado (rooted con Magisk).
• Emulador alternativa: Genymotion, Android Studio AVD.
• Alternativa: Mobexler, Corellium (cloud).

Requisitos:

• Android 10+ para apps modernas.
• Root (Magisk): para análisis profundo.
• Frida Server instalado.
• Burp Suite configurado.

Instalación de Frida:

# En el host
pip install frida-tools

# En el dispositivo (rooted)
# Descargar frida-server compatible con la arquitectura
adb push frida-server /data/local/tmp/
adb shell "chmod 755 /data/local/tmp/frida-server"
adb shell "/data/local/tmp/frida-server &"

# Verificar
frida-ps -U

5.2 Entorno iOS

Dispositivo:

• iPhone/iPad con jailbreak (checkra1n, unc0ver).
• Alternativa: Corellium (cloud).
• Simulador: limitado para pentesting real.

Requisitos:

• iOS compatible con jailbreak.
• Cydia/Sileo para instalar herramientas.
• Frida instalado.
• Burp Suite configurado.

Instalación de Frida:

# En el dispositivo jailbroken
# Añadir repo https://build.frida.re en Cydia/Sileo
# Instalar Frida

# En el host
pip install frida-tools
frida-ps -U

5.3 Burp Suite

Configuración:

1. Instalar Burp Suite (Community o Pro).
2. Generar certificado CA de Burp.
3. Instalar CA en el dispositivo:
   • Android 7+: ya no basta con instalarlo como usuario. Requiere moverlo a system (con root).
   • iOS: instalar perfil y confiar en él.
4. Configurar proxy en el dispositivo:
   • IP del host.
   • Puerto 8080.
5. Verificar: navega en el dispositivo y comprueba que el tráfico aparece en Burp.

Consejo: usa Burp Suite Pro si puedes (Scanner automático).

Consulta Beneficios del uso de CDN para entender proxies.

6. Herramientas esenciales

6.1 MobSF (Mobile Security Framework)

Análisis estático y dinámico automatizado:

• Android: APK, XAPK.
• iOS: IPA.
• Windows, Linux, macOS.

Instalación:

git clone https://github.com/MobSF/Mobile-Security-Framework-MobSF.git
cd Mobile-Security-Framework-MobSF
./setup.sh
./run.sh

Uso:

1. Accede a http://localhost:8000.
2. Sube la APK/IPA.
3. Revisa el informe: permisos, actividades, endpoints, claves…

Ventajas:

• Rápido.
• Reportes detallados.
• API REST para automatización.

6.2 Frida

Framework de instrumentación dinámica:

• Modifica apps en runtime.
• Hookea funciones.
• Bypass SSL pinning, root detection.
• Android + iOS.

Ejemplo básico:

// hook.js
Java.perform(function() {
    var MainActivity = Java.use('com.example.app.MainActivity');
    MainActivity.checkPassword.implementation = function(password) {
        console.log('Password attempted: ' + password);
        return true;  // Siempre devuelve true
    };
});

Ejecutar:

frida -U -f com.example.app -l hook.js --no-pause

6.3 Objection

Framework basado en Frida para pentesting móvil:

Instalación:

pip install objection

Uso típico:

# Ejecutar con la app
objection -g com.example.app explore

# En el prompt de objection:
android sslpinning disable    # Bypass SSL pinning
android root disable          # Bypass root detection
ios sslpinning disable        # Bypass SSL pinning (iOS)
ios jailbreak disable         # Bypass jailbreak detection

# Ver almacenamiento
env
ls

6.4 Drozer

Framework para Android (análisis de seguridad):

Instalación:

pip install drozer
# O descarga el .deb desde https://github.com/WithSecureLabs/drozer

Uso:

# Conectar al dispositivo
adb forward tcp:31415 tcp:31415
drozer console connect

# Enumerar apps
run app.package.list

# Analizar una app
run app.package.info -a com.example.app

# Buscar activities exportadas
run app.activity.info -a com.example.app

6.5 APKTool

Descompilar y recompilar APKs:

# Instalar
sudo apt install apktool

# Descompilar
apktool d app.apk -o app_decompiled/

# Recompilar
apktool b app_decompiled/ -o app_modified.apk

6.6 JADX

Descompilador Java para Android:

# GUI
jadx-gui app.apk

# CLI
jadx -d output/ app.apk

6.7 Ghidra / IDA Pro

Ingeniería inversa de código nativo:

• Ghidra (open source, NSA).
• IDA Pro (comercial).

Consulta Análisis de malware con Cuckoo Sandbox para más herramientas.

6.8 Burp Suite / ZAP

Interceptación de tráfico:

• Burp Suite (estándar).
• OWASP ZAP (open source).

Consulta Guía completa para configurar SSL en Nginx para entender certificados.

7. Análisis estático

7.1 Obtener la APK

Métodos:

1. Desde el dispositivo:

adb shell pm list packages | grep example
adb shell pm path com.example.app
adb pull /data/app/com.example.app-xxx/base.apk

2. Desde Google Play: con herramientas como apkpure, apkcombo.
3. Desde el desarrollador (en pentesting autorizado).

7.2 Descompilar la APK

# Con apktool
apktool d app.apk -o app_decompiled/

# Con jadx
jadx -d output/ app.apk

# Con MobSF (automático)
# Subir APK a MobSF web

7.3 Analizar AndroidManifest.xml

cat app_decompiled/AndroidManifest.xml

Buscar:

• Permisos solicitados: uses-permission.
• Activities exportadas: android:exported="true".
• Services exportados.
• Receivers.
• Providers.
• Debug habilitado: android:debuggable="true".

7.4 Analizar código fuente

Con jadx-gui:

• Abre el APK.
• Busca strings: grep -r "password" output/.
• Revisa clases sospechosas.
• Busca claves de API.

Ejemplo de búsqueda:

# Buscar claves de API
grep -rE "(api_key|secret|token|password)" output/

# Buscar endpoints
grep -rE "https?://" output/

# Buscar URLs de backend
grep -rE "https://api\." output/

7.5 Buscar secretos con TruffleHog

trufflehog filesystem app_decompiled/ --only-verified

7.6 Analizar iOS

Extraer IPA:

• Desde el dispositivo jailbroken con frida-ios-dump.
• Con herramientas como Clutch, bagbak.

Descompilar:

• class-dump para headers Objective-C.
• Hopper/Ghidra para binarios.
• Frida para instrumentación dinámica.

7.7 Reportar hallazgos estáticos

Formato:

ID: STATIC-001
Título: API Key hardcodeada
Severidad: Alta
Ubicación: com.example.app.API
Descripción: Clave de API expuesta en el código
Evidencia: "api_key": "sk_live_abc123..."
Impacto: Acceso no autorizado a servicios
Remediación: Usar variables de entorno / backend proxy
Referencias: OWASP MASVS-CODE-1

8. Análisis dinámico

8.1 Preparar el entorno

1. Instalar la app en dispositivo rooted/jailbroken.
2. Configurar proxy (Burp Suite).
3. Instalar certificado CA de Burp.
4. Verificar que la app funciona con proxy.

8.2 Interceptar tráfico

Con Burp Suite:

1. Configura proxy en el dispositivo.
2. Abre la app.
3. Realiza acciones (login, compras, etc.).
4. Analiza peticiones en Burp.

Buscar:

• HTTP sin cifrado.
• Parámetros manipulables.
• Tokens de autenticación.
• Endpoints sensibles.

8.3 Analizar almacenamiento local

Android:

# Bases de datos
adb shell "run-as com.example.app ls /data/data/com.example.app/databases/"

# SharedPreferences
adb shell "run-as com.example.app cat /data/data/com.example.app/shared_prefs/*.xml"

# Archivos
adb shell "run-as com.example.app ls -la /data/data/com.example.app/files/"

iOS:

# Con frida-ios-dump
# O accede directamente en el dispositivo jailbroken
ls /var/mobile/Containers/Data/Application/<UUID>/

Buscar:

• Contraseñas en texto plano.
• Tokens sin cifrar.
• Datos de usuario.
• Cookies.

8.4 Manipular peticiones

Con Burp Repeater:

• Modifica parámetros.
• Prueba inyecciones.
• Salta controles.

Ejemplos:

• Cambiar user_id (IDOR).
• Modificar is_admin.
• Inyectar SQL.
• Manipular precio.

8.5 Fuzzing de APIs

Con Burp Intruder o ffuf:

ffuf -w endpoints.txt -u https://api.example.com/FUZZ

8.6 Automatización con Frida

// Ejemplo: interceptar login
Java.perform(function() {
    var LoginActivity = Java.use('com.example.app.LoginActivity');
    LoginActivity.onLogin.implementation = function(username, password) {
        console.log('Login: ' + username + ':' + password);
        return this.onLogin(username, password);
    };
});

Ejecutar:

frida -U -f com.example.app -l login_hook.js --no-pause

9. Bypass de SSL pinning

SSL pinning es una técnica que hace que la app solo confíe en certificados específicos. Impide interceptar tráfico con Burp.

Bypass con objection:

objection -g com.example.app explore
# En el prompt:
android sslpinning disable
# iOS:
ios sslpinning disable

Bypass con Frida (script manual):

// frida-ssl-bypass.js
setTimeout(function() {
    Java.perform(function() {
        var X509TrustManager = Java.use('javax.net.ssl.X509TrustManager');
        var SSLContext = Java.use('javax.net.ssl.SSLContext');

        var TrustManager = Java.registerClass({
            name: 'com.example.TrustManager',
            implements: [X509TrustManager],
            methods: {
                checkClientTrusted: function(chain, authType) {},
                checkServerTrusted: function(chain, authType) {},
                getAcceptedIssuers: function() { return []; }
            }
        });

        var TrustManagers = [TrustManager.$new()];
        var SSLContextInit = SSLContext.init.overload(
            '[Ljavax.net.ssl.KeyManager;', 
            '[Ljavax.net.ssl.TrustManager;', 
            'java.security.SecureRandom'
        );
        
        SSLContextInit.implementation = function(km, tm, sr) {
            SSLContextInit.call(this, km, TrustManagers, sr);
        };
    });
}, 0);

Ejecutar:

frida -U -f com.example.app -l frida-ssl-bypass.js --no-pause

Alternativa para Android 7+ con root:

Usa Magisk TrustUserCerts o mueve el certificado a /system/etc/security/cacerts/.

Consulta Criptografía en la ciberseguridad para entender certificados.

10. Vulnerabilidades comunes

10.1 Almacenamiento inseguro

• Contraseñas en texto plano.
• Tokens sin cifrar.
• Datos de usuario en SharedPreferences.

Test: revisa /data/data/com.example.app/.

10.2 Comunicaciones inseguras

• HTTP sin cifrado.
• SSL pinning ausente.
• Certificados inválidos aceptados.

Test: intercepta con Burp.

10.3 Autenticación débil

• Contraseñas débiles permitidas.
• Sin MFA.
• Tokens sin expiración.

Test: intenta logins débiles.

10.4 Autorización incorrecta

• IDOR: cambiar IDs.
• Privilege escalation.
• Bypass de roles.

Test: modifica parámetros en Burp.

10.5 Inyecciones

• SQL injection en APIs.
• Command injection.
• XXE.

Test: fuzzing con Burp Intruder.

10.6 Código ofuscado insuficiente

• Decompilación fácil.
• Strings legibles.
• API keys expuestas.

Test: jadx + búsqueda de strings.

10.7 Root/Jailbreak detection bypass

• Apps que detectan root pueden ser bypasseadas.

Test: con objection.

10.8 Fugas en logs

• Logs con datos sensibles.
• Debug habilitado en producción.

Test:

adb logcat | grep -i "password\|token\|secret"

Consulta Guía Completa de Ciberseguridad para más vulnerabilidades.

11. Troubleshooting

11.1 Burp no intercepta tráfico

Causas:

• Certificado CA no instalado.
• SSL pinning activado.
• Proxy mal configurado.
• App usa otro puerto.

Solución:

• Instala el certificado CA.
• Usa objection para bypass SSL pinning.
• Verifica proxy en el dispositivo.
• Revisa puertos alternativos.

11.2 Frida no se conecta

Causas:

• frida-server no ejecutándose.
• Versión incompatible.
• USB debugging deshabilitado.

Solución:

adb shell "/data/local/tmp/frida-server &"
frida-ps -U

11.3 App no arranca en dispositivo rooted

Causas:

• Root detection activada.

Solución:

• Usa Magisk Hide o Shamiko.
• Bypass con objection: android root disable.

11.4 MobSF no analiza la APK

Causas:

• APK corrupta o protegida.
• Falta de dependencias.

Solución:

• Verifica el APK: file app.apk.
• Actualiza MobSF.
• Prueba con jadx directamente.

11.5 APK decompilada con errores

Causas:

• APK ofuscada.
• Con archivos nativos.

Solución:

• Usa múltiples herramientas (jadx + apktool + Ghidra).
• Analiza código nativo con Ghidra.

11.6 No puedo instalar la CA en Android 7+

Causas: Android 7+ no confía en CAs de usuario para apps.

Solución:

• Root + Magisk TrustUserCerts.
• Mover CA a /system/etc/security/cacerts/.
• Editar el APK para confiar en user CAs (repackaging).

11.7 iOS no acepta el certificado

Causas:

• Falta de confianza en el perfil.

Solución:

• Ajustes → General → VPN y gestión de dispositivos.
• Ajustes → General → Acerca de → Ajustes de confianza de certificados.
• Activa la confianza.

12. FAQ

¿Qué es el pentesting de aplicaciones móviles?

Es una simulación controlada de ataques sobre una app móvil para:

• Identificar vulnerabilidades.
• Evaluar su impacto.
• Documentar hallazgos.
• Recomendar mitigaciones.

Se aplica a Android e iOS, y cubre código, tráfico, almacenamiento y APIs.

¿Necesito root/jailbreak para hacer pentesting móvil?

No siempre, pero ayuda mucho.

• Sin root: análisis básico (interceptar tráfico con Burp si no hay SSL pinning).
• Con root: análisis completo (almacenamiento, Frida, manipulación).

Recomendación: usa un dispositivo de prueba rooteado.

¿Cuál es la diferencia entre MASVS y MASTG?

• MASVS: estándar de requisitos (qué hay que verificar).
• MASTG: guía técnica (cómo verificar).

Se complementan. Consulta OWASP MASVS.

¿Qué es SSL pinning y cómo lo evito?

SSL pinning hace que la app solo confíe en certificados específicos. Impide interceptar con Burp.

Bypass:

• objection: android sslpinning disable.
• Frida: scripts personalizados.
• Magisk TrustUserCerts: para Android 7+.

¿Cómo analizo una app iOS?

Métodos:

1. Dispositivo jailbroken + frida-ios-dump.
2. Corellium (cloud, pago).
3. Binario filtrado de fuentes abiertas (raro).

Herramientas: Frida, objection, class-dump, Hopper, Ghidra.

¿Cuánto tiempo lleva un pentesting móvil?

Depende del alcance:

• App simple (1 plataforma): 1-2 semanas.
• App media: 2-4 semanas.
• App compleja (multi-plataforma + backend): 4-8 semanas.

Factores: complejidad, alcance, experiencia.

¿Qué herramientas necesito?

Esenciales:

• MobSF — análisis estático/dinámico.
• Frida — instrumentación dinámica.
• Objection — bypass y automatización.
• Burp Suite — interceptar tráfico.
• APKTool / jadx — descompilar.
• Ghidra — ingeniería inversa.

Todas son gratuitas (excepto Burp Pro).

¿Es legal hacer pentesting móvil?

Sí, con autorización por escrito.

• Contrato con alcance definido.
• NDA firmado.
• RoE claras.
• Contacto técnico.

Sin autorización es delito. Consulta Guía Completa de Hacking Ético.

¿Cómo reporto los hallazgos?

Estructura:

• Resumen ejecutivo.
• Alcance y metodología.
• Hallazgos clasificados por severidad.
• PoC por hallazgo.
• Recomendaciones.
• Anexos.

Consulta Análisis de vulnerabilidades paso a paso.

¿Cómo protejo mi app contra pentesting?

No puedes evitar que la analicen, pero puedes dificultarlo:

• Ofuscación de código.
• SSL pinning.
• Root/jailbreak detection.
• Anti-debugging.
• Cifrado de datos sensibles.
• Integridad de la app.

⚠️ Ninguna protección es infalible.

¿Puedo hacer pentesting sin dispositivo físico?

Sí, con limitaciones:

• Emuladores: Genymotion, Android AVD.
• Cloud: Corellium (iOS), Mobexler (Android).
• Simuladores: limitados para análisis profundo.

Recomendación: dispositivo físico rooteado para análisis completo.

¿Cómo empiezo en pentesting móvil?

Ruta recomendada:

1. Aprende Android/Linux básico.
2. Estudia OWASP MASVS.
3. Practica con apps vulnerables (DVHMA, InsecureBankv2).
4. Domina Burp Suite + Frida.
5. Certifícate: eMAPT, OSWE (para web).

Consulta Guía Completa de Hacking Ético.

13. Conclusión

El pentesting de aplicaciones móviles es una disciplina en auge con gran demanda profesional. Las apps manejan cada vez más datos sensibles, y las vulnerabilidades pueden tener consecuencias graves.

Puntos clave:

1. Metodología clara: reconocimiento, análisis, explotación, reporte.
2. Estándares OWASP: MASVS + MASTG.
3. Herramientas esenciales: MobSF, Frida, objection, Burp.
4. Análisis estático: descompilar, buscar secretos, revisar manifest.
5. Análisis dinámico: interceptar tráfico, revisar almacenamiento.
6. Bypass de SSL pinning: técnica crítica.
7. Vulnerabilidades comunes: almacenamiento, red, auth, IDOR.
8. Marco legal: autorización por escrito.
9. Documentación: reportes claros y accionables.
10. Actualización continua: técnicas y herramientas evolucionan.

Si quieres profundizar:

• Guía Completa de Hacking Ético 2026
• Guía Completa de Ciberseguridad
• Análisis de vulnerabilidades paso a paso
• Análisis de malware con Cuckoo Sandbox
• Guía de herramientas de análisis de malware en Linux
• Cómo asegurar APIs
• Forense digital: métodos y recolección de evidencias
• Criptografía en la ciberseguridad moderna