Capítulo 2: Configuración de Proxy para Dispositivos Móviles

14 de enero de 2025 Por: Artiko

owasp-zapproxyandroidiosmobilecertificadosssl-pinning

Capítulo 2: Configuración de Proxy para Dispositivos Móviles

En este capítulo aprenderás a configurar OWASP ZAP como proxy para interceptar y analizar el tráfico de aplicaciones móviles en dispositivos Android e iOS.

🎯 Objetivos del Capítulo

Al finalizar este capítulo serás capaz de:

✅ Configurar ZAP para escuchar en la red local
✅ Configurar proxy en dispositivos Android
✅ Configurar proxy en dispositivos iOS
✅ Instalar certificados SSL en móviles
✅ Bypass básico de Certificate Pinning
✅ Capturar tráfico HTTPS de aplicaciones

🌐 Preparación del Entorno

Paso 1: Obtener IP Local

# Windows
ipconfig
# Buscar IPv4 Address: 192.168.1.100

# macOS/Linux
ifconfig
# O más moderno
ip addr show
# Buscar inet 192.168.1.100

# Alternativa multiplataforma
hostname -I  # Linux
ipconfig getifaddr en0  # macOS WiFi

Paso 2: Configurar ZAP para Escuchar en Red

# En ZAP:
# Tools → Options → Local Proxies

# Cambiar configuración:
Address: 0.0.0.0  # Escuchar en todas las interfaces
# O específicamente tu IP: 192.168.1.100
Port: 8080

# Opciones adicionales:
☑ Behind NAT
☑ Remove Unsupported Encodings
☑ Enable Alpha Active Scan Rules

Paso 3: Verificar Firewall

# Windows - Abrir puerto en firewall
netsh advfirewall firewall add rule name="ZAP Proxy" dir=in action=allow protocol=TCP localport=8080

# macOS - Normalmente no requiere configuración
# Si hay problemas:
sudo pfctl -d  # Deshabilitar temporalmente

# Linux - iptables
sudo iptables -A INPUT -p tcp --dport 8080 -j ACCEPT
sudo iptables-save

# Linux - ufw
sudo ufw allow 8080/tcp

📱 Configuración en Android

Método 1: Configuración WiFi Manual

# Pasos:
1. Settings → Network & Internet → WiFi
2. Long press en tu red WiFi
3. Modify network / Advanced options
4. Proxy → Manual
5. Configurar:
   - Proxy hostname: [IP de tu PC] (ej: 192.168.1.100)
   - Proxy port: 8080
   - Bypass proxy for: localhost,127.0.0.1
6. Save

Método 2: Via ADB (Android Debug Bridge)

# Conectar dispositivo
adb devices

# Configurar proxy global
adb shell settings put global http_proxy 192.168.1.100:8080

# Verificar configuración
adb shell settings get global http_proxy

# Remover proxy
adb shell settings put global http_proxy :0

Método 3: Proxy por Aplicación (Root)

# Con ProxyDroid (requiere root)
# 1. Instalar ProxyDroid desde Play Store
# 2. Configurar:
Host: 192.168.1.100
Port: 8080
Proxy Type: HTTP

# 3. Habilitar:
☑ Global Proxy
☑ DNS Proxy

Instalación de Certificado en Android

Android 10 y anteriores

# Método 1: Via Settings
1. Descargar certificado desde http://192.168.1.100:8080/OTHER/core/other/rootcert/
2. Settings → Security → Encryption & credentials
3. Install from storage / Install certificates
4. CA certificate
5. Seleccionar owasp_zap_root_ca.cer
6. Nombrar: "OWASP ZAP"
7. OK

# Método 2: Via ADB
adb push owasp_zap_root_ca.cer /sdcard/
adb shell am start -n com.android.settings/.SecuritySettings
# Luego instalar desde storage

Android 11+ (System CA - Requiere Root)

# Convertir certificado a formato PEM
openssl x509 -inform DER -in owasp_zap_root_ca.cer -out zap.pem

# Obtener hash del certificado
openssl x509 -inform PEM -subject_hash_old -in zap.pem | head -1
# Resultado: 9a5ba575

# Renombrar certificado
mv zap.pem 9a5ba575.0

# Instalar como System CA (requiere root)
adb root
adb remount
adb push 9a5ba575.0 /system/etc/security/cacerts/
adb shell chmod 644 /system/etc/security/cacerts/9a5ba575.0
adb reboot

Android con Magisk (Método Preferido)

# 1. Instalar módulo MagiskTrustUserCerts
# https://github.com/NVISOsecurity/MagiskTrustUserCerts

# 2. Instalar certificado normalmente como User CA
# 3. El módulo lo moverá automáticamente a System CA

🍎 Configuración en iOS

Configuración de Proxy WiFi

# Pasos:
1. Settings → Wi-Fi
2. Tap en (i) junto a tu red WiFi
3. Scroll hasta "HTTP Proxy"
4. Configure Proxy → Manual
5. Configurar:
   - Server: [IP de tu PC] (ej: 192.168.1.100)
   - Port: 8080
   - Authentication: Off
6. Save

Instalación de Certificado en iOS

Método 1: Via Safari

# Pasos:
1. Abrir Safari en el iPhone
2. Navegar a: http://192.168.1.100:8080/OTHER/core/other/rootcert/
3. Descargar certificado
4. Aparecerá "Profile Downloaded"
5. Settings → General → VPN & Device Management
6. Bajo "Downloaded Profile" → OWASP ZAP Root CA
7. Install → Enter Passcode → Install → Install
8. Done

Método 2: Via Email/AirDrop

# Enviar certificado por email o AirDrop
# El archivo debe tener extensión .cer o .crt

# Al recibirlo:
1. Abrir archivo
2. "Install Profile" aparecerá
3. Seguir pasos de instalación

Habilitar Confianza Total (iOS 10.3+)

# IMPORTANTE: Paso adicional necesario
1. Settings → General → About → Certificate Trust Settings
2. Enable Full Trust For Root Certificates
3. Toggle ON para "OWASP ZAP Root CA"
4. Confirmar con "Continue"

Verificación en iOS

// Verificar con Safari
// Navegar a https://www.example.com
// No debería mostrar advertencia de certificado

// Verificar certificados instalados
Settings → General → VPN & Device Management → Configuration Profiles
// Debe aparecer OWASP ZAP Root CA

// Verificar confianza
Settings → General → About → Certificate Trust Settings
// OWASP ZAP Root CA debe estar en verde

🔓 Bypass de Certificate Pinning

Android - Métodos Básicos

Método 1: Frida (Recomendado)

// Instalar Frida
pip install frida-tools

// Script universal SSL pinning bypass
// Archivo: ssl-pinning-bypass.js
Java.perform(function() {
    // TrustManager bypass
    var TrustManager = Java.use('com.android.org.conscrypt.TrustManagerImpl');
    TrustManager.verifyChain.implementation = function(untrustedChain, untrustedHost, clientAuth, ocspData, tlsSctData) {
        return untrustedChain;
    };

    // OkHttp3 bypass
    try {
        var OkHttpClient = Java.use("com.squareup.okhttp3.OkHttpClient");
        OkHttpClient.newBuilder.implementation = function() {
            var builder = this.newBuilder();
            builder.hostnameVerifier(function() { return true; });
            return builder;
        };
    } catch(e) {}

    // Retrofit bypass
    try {
        var CertificatePinner = Java.use("com.squareup.okhttp3.CertificatePinner");
        CertificatePinner.check.overload('java.lang.String', 'java.util.List').implementation = function() {
            return;
        };
    } catch(e) {}
});

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

Método 2: Objection

# Instalar objection
pip install objection

# Iniciar app con objection
objection -g com.example.app explore

# Deshabilitar SSL pinning
android sslpinning disable

# Listar actividades
android hooking list activities

# Ver clases
android hooking list classes

Método 3: Xposed Framework

// Módulo Xposed: SSLUnpinning
// Instalar desde Xposed Installer

// O crear módulo personalizado
public class SSLUnpinning implements IXposedHookLoadPackage {
    public void handleLoadPackage(LoadPackageParam lpparam) {
        // Hook TrustManagerFactory
        findAndHookMethod("javax.net.ssl.TrustManagerFactory",
            lpparam.classLoader,
            "getTrustManagers",
            new XC_MethodReplacement() {
                @Override
                protected Object replaceHookedMethod(MethodHookParam param) {
                    return new TrustManager[] { new X509TrustManager() {
                        public void checkClientTrusted(X509Certificate[] chain, String authType) {}
                        public void checkServerTrusted(X509Certificate[] chain, String authType) {}
                        public X509Certificate[] getAcceptedIssuers() { return new X509Certificate[0]; }
                    }};
                }
            }
        );
    }
}

iOS - Métodos Básicos

Método 1: SSL Kill Switch 2 (Jailbreak)

# Instalar desde Cydia/Sileo
# Repo: https://julioverne.github.io/

# Configurar:
Settings → SSL Kill Switch 2
→ Enable for all apps

# O específico por app:
→ Disable in Apple Apps: ON
→ Select apps to disable

Método 2: Frida iOS

// ssl-bypass-ios.js
if (ObjC.available) {
    // NSURLSession bypass
    var className = "NSURLSession";
    var funcName = "- URLSession:didReceiveChallenge:completionHandler:";
    
    var hook = ObjC.classes[className][funcName];
    Interceptor.attach(hook.implementation, {
        onEnter: function(args) {
            var completionHandler = new ObjC.Block(args[4]);
            completionHandler.implementation(1, null);
        }
    });
    
    // AFNetworking bypass
    try {
        var AFSecurityPolicy = ObjC.classes.AFSecurityPolicy;
        AFSecurityPolicy["- setAllowInvalidCertificates:"].implementation = function(allow) {
            this.setAllowInvalidCertificates_(true);
        };
    } catch(e) {}
}

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

🧪 Verificación de Configuración

Test Básico de Conectividad

# Desde el móvil, navegar a:
http://www.example.com

# Verificar en ZAP:
# - Sites tree debe mostrar example.com
# - History debe mostrar las peticiones

Test de HTTPS

# Navegar a sitio HTTPS
https://www.google.com

# Si aparece error de certificado:
# - Verificar instalación del certificado
# - Verificar confianza total (iOS)
# - Verificar System CA (Android 11+)

Test con Aplicación

# Script Python para verificar captura
from zapv2 import ZAPv2
import time

zap = ZAPv2(apikey='tu-api-key',
            proxies={'http': 'http://192.168.1.100:8080',
                    'https': 'http://192.168.1.100:8080'})

# Iniciar monitoreo
print("Abre la app en tu móvil...")
time.sleep(10)

# Ver últimas URLs capturadas
urls = zap.core.urls()
print(f"URLs capturadas: {len(urls)}")
for url in urls[-10:]:  # Últimas 10
    print(f" - {url}")

🔍 Análisis del Tráfico Capturado

Identificar Endpoints de API

// En ZAP, buscar patrones comunes:
/api/v1/*
/rest/*
/graphql
/ws  // WebSocket
/auth/login
/user/profile

Analizar Headers de Seguridad

# Headers importantes a revisar:
Authorization: Bearer eyJ...
X-API-Key: abc123
X-CSRF-Token: xyz789
Cookie: session=...
User-Agent: MyApp/1.0 (Android 11)
X-Certificate-Pin: sha256/...

Identificar Datos Sensibles

# Buscar en ZAP:
# Search → Regex

# Patrones comunes:
# Tarjetas de crédito
\b(?:\d{4}[\s-]?){3}\d{4}\b

# Emails
\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b

# Tokens JWT
eyJ[A-Za-z0-9-_=]+\.[A-Za-z0-9-_=]+\.?[A-Za-z0-9-_.+/=]*

# API Keys
[a-zA-Z0-9]{32,}

🛠️ Herramientas Complementarias

Android

# APK Decompiler
apktool d app.apk -o app_decompiled/

# Buscar configuración de red
grep -r "CertificatePinner" app_decompiled/
grep -r "TrustManager" app_decompiled/
grep -r "pinning" app_decompiled/

# Ver certificados embebidos
find app_decompiled -name "*.cer" -o -name "*.crt" -o -name "*.pem"

iOS

# Con Clutch (Jailbreak requerido)
Clutch -d com.example.app

# Analizar binario
otool -L app.app/app
strings app.app/app | grep -i "pinning\|certificate\|ssl"

# Ver Info.plist
plutil -p app.app/Info.plist | grep -i "security\|transport"

Network Monitoring

# tcpdump en el móvil (root/jailbreak)
tcpdump -i any -s 0 -w capture.pcap

# Wireshark para análisis detallado
# Filtros útiles:
ip.addr == 192.168.1.100 and tcp.port == 8080
http.request or http.response
ssl.handshake

📋 Troubleshooting Común

Problema: “No se puede conectar al proxy”

# Verificar:
1. ZAP escuchando en 0.0.0.0:8080
2. Firewall permite conexiones
3. Móvil y PC en misma red
4. IP correcta configurada

# Test desde móvil:
# Browser → http://[IP_PC]:8080
# Debe mostrar página de ZAP

Problema: “Error de certificado SSL”

# Android:
- Verificar instalación en User Certificates
- Android 11+: Necesita System CA o bypass
- Verificar fecha/hora del dispositivo

# iOS:
- Verificar Profile instalado
- Habilitar Full Trust
- Reiniciar aplicación

Problema: “App no usa el proxy”

# Posibles causas:
1. Certificate Pinning activo → Usar Frida
2. App usa conexión directa → Verificar con tcpdump
3. VPN activa → Desactivar VPN
4. Proxy bypass list → Verificar configuración

# Solución alternativa:
# Usar transparent proxy con iptables (Android root)
iptables -t nat -A OUTPUT -p tcp --dport 80 -j DNAT --to-destination 192.168.1.100:8080
iptables -t nat -A OUTPUT -p tcp --dport 443 -j DNAT --to-destination 192.168.1.100:8080

Problema: “WebSocket no funciona”

// En ZAP habilitar WebSocket support
// Tools → Options → WebSockets
☑ Forward all WebSocket messages

// Si sigue sin funcionar, usar Burp Suite o mitmproxy

🔒 Consideraciones de Seguridad

Durante el Testing

# Buenas prácticas:
- Usar red WiFi aislada/dedicada
- No usar credenciales reales
- Documentar todo el tráfico
- Cifrar capturas almacenadas
- Eliminar certificados después del test

Post-Testing

# Android - Limpiar configuración
adb shell settings put global http_proxy :0
# Eliminar certificados instalados
Settings → Security → Trusted credentials → User → Remove

# iOS - Limpiar configuración
Settings → Wi-Fi → (i) → Configure Proxy → Off
Settings → General → VPN & Device Management → Remove Profile

🎯 Ejercicios Prácticos

Ejercicio 1: Configuración Básica Android

Configura ZAP para escuchar en tu red local
Configura proxy en un dispositivo Android
Instala el certificado de ZAP
Captura tráfico de Chrome
Analiza las peticiones HTTP/HTTPS

Ejercicio 2: Bypass Certificate Pinning

Instala una app con certificate pinning (ej: Twitter)
Intenta capturar tráfico (fallará)
Usa Frida para bypass
Captura y analiza el tráfico de la API

Ejercicio 3: Análisis de App iOS

Configura proxy en iPhone/iPad
Instala certificado con confianza total
Captura tráfico de una app de banca (sandbox/demo)
Identifica endpoints sensibles
Busca posibles vulnerabilidades

📚 Resumen

En este capítulo aprendiste:

✅ Configurar ZAP para escuchar en red local
✅ Configurar proxy en Android e iOS
✅ Instalar certificados SSL en móviles
✅ Técnicas básicas de bypass de Certificate Pinning
✅ Analizar tráfico HTTPS capturado
✅ Resolver problemas comunes de configuración

🚀 Próximo Capítulo

En el siguiente capítulo profundizaremos en la Captura y Análisis de Tráfico HTTP/HTTPS, incluyendo:

Interceptación y modificación de requests
Análisis de APIs REST y GraphQL
Fuzzing de parámetros
Identificación de vulnerabilidades

← Capítulo 1: Instalación | Siguiente: Captura de Tráfico →