MÓDULO 16 — EXTENSÃO iOS (iPhone/iPad): Fluxo completo de teste de IPA

MÓDULO 16 — EXTENSÃO iOS (iPhone/iPad): Fluxo completo de teste de IPA Objetivo: testar um aplicativo iOS de ponta a ponta — obter o IPA, analisar estática (binário, entitlements, Info.plist), interceptar tráfego HTTPS (incluindo bypass de pinning), instrumentar com Frida, extrair dados do Keychain e storage, e documentar os achados — tudo dentro de um ambiente de laboratório controlado.

MÓDULO 16 — Mobile Hacking: Tópico 9 — iOS: o que muda (e o que é igual ao Android) O que é igual:

Análise estática e dinâmica se complementam O backend/API é o verdadeiro alvo SSL pinning, root/jailbreak detection, storage inseguro — mesmas classes de falha Frida é a mesma ferramenta (os scripts JS mudam a API iOS — ObjC em vez de Java) O que muda — o ecossistema iOS:

Para fazer pentest mobile iOS de verdade, você precisa de um dispositivo com Jailbreak (ou usar um dispositivo corporativo com perfil de desenvolvedor) O Jailbreak hoje (2026) existe para versões específicas (checkra1n para A5-A11, palera1n, Fugu15 Max). Nem todo iPhone tem jailbreak disponível Alternativa sem jailbreak: você pode analisar o IPA estaticamente e rodar o app no simulador (com limitações — sem Keychain, sem push, sem alguns sensores). Mas interceptação com Frida exige jailbreak Para este módulo: você vai precisar de um iPhone/iPad jailbreakável (iPhone 8/X ou anterior com checkra1n, ou versão compatível com palera1n), ou um device de desenvolvimento corporativo ⚠️ Se você não tem dispositivo iOS para teste, faça a análise estática (que responde 70% dos achados) e leia a parte dinâmica como referência para quando tiver o hardware.

MÓDULO 16 — Mobile Hacking: Tópico 10 — Ambiente iOS: o setup (hardware + ferramentas) Hardware necessário (mínimo viável)

Mac (qualquer, para ferramentas nativas) OU Kali + algumas ferramentas iPhone/iPad jailbreakado (ex.: iPhone 8, iOS 15-16, checkra1n/palera1n) USB cable para o device Ferramentas no Kali/Mac

# No Kali (via pip / brew / apt):
# Ferramentas principais:
sudo apt install ideviceinstaller libimobiledevice-utils
pipx install frida-tools objection
# IPA análise:
sudo apt install binutils    # strings, nm, otool (via cctools no Linux)
# class-dump (no Mac — extrai headers ObjC):
# brew install class-dump   # (ou baixar o binário)

# No Mac (adicional):
# - Hopper Disassembler (pago, mas tem trial — o melhor para iOS)
# - Ghidra (grátis, da NSA — funciona, mais pesado)
# - Apple Configurator 2 (para baixar IPAs oficiais de dispositivos próprios)

Jailbreak (o passo que define tudo)

# checkra1n (A5-A11, iOS 12-15):
# 1. Baixe checkra1n no Mac (checkra.in)
# 2. Conecte o iPhone em DFU Mode
# 3. Rode checkra1n → jailbreak instalado (sem Cydia? Sileo ou Zebra)

# palera1n (A9-A11, iOS 15-16):
# https://github.com/palera1n/palera1n
# Roteiro:
./palera1n.sh --tweaks 14.3  # (ou versão do iOS)

# Pós-jailbreak: instale SSH (openssh via Sileo/Cydia) e confirme:
ssh root@192.168.56.XXX       # senha: alpine (TROQUE A SENHA!)

# Ferramentas que vão no device (via Cydia/Sileo/Zebra):
# - frida-server (instalar via Cydia na repo build.frida.re)
# - adv-cmds (para ps, etc.)
# - UIKit Tools (para uicache, etc.)

Serviços essenciais no device

# SSH (já vem com OpenSSH pós-jailbreak):
ssh root@IP_DO_IPHONE
# Verificar se o frida-server está rodando:
ps aux | grep frida
# Se não: 
frida-server &

# No Kali, testar:
frida-ps -U      # USB
frida-ps -R      # Remote (se usar TCP)

Extrair o IPA (como obter o binário)

# Se o app está instalado no device (precisa de jailbreak + ferramentas):
# Método 1 — via SSH no device:
ssh root@IPHONE
dpkg -L com.empresa.app | grep .app  # (se instalado via Cydia)
# ou:  ps aux | grep MobileMail  (ache o bundle identifier)
# Método 2 — extrair do App Store via Apple Configurator 2 (no Mac):
#   Abra o app, selecione o app, File → Save → .ipa
# Método 3 — baixar de serviços como ipatool (exige conta Apple):
#   ipatool download com.empresa.app -o app.ipa

MÓDULO 16 — Mobile Hacking: Tópico 11 — Análise estática do IPA Estrutura do IPA

# IPA é um ZIP:
unzip app.ipa -d app_ipa
cd app_ipa/Payload/
ls -la                      # um diretório .app

# Estrutura do .app:
AppName.app/
├── Info.plist              ← o "manifesto iOS" (configurações, permissões, URLs)
├── AppName                 ← binário Mach-O executável (o código compilado)
├── Frameworks/             ← frameworks embutidos (Flutter, React Native, libs)
├── _CodeSignature/         ← assinatura do desenvolvedor
├── embedded.mobileprovision   ← perfil de provisionamento (entitlements!)
├── Assets.car              ← assets comprimidos
├── .lproj/                 ← localizações
└── *.nib / *.storyboardc   ← interfaces

Info.plist — o "manifesto" iOS

# Decodificar (plist pode ser binário — use plutil):
plutil -convert xml1 Info.plist -o Info.plist.xml
cat Info.plist.xml

O que procurar:

<!-- 1. Permissões (Privacidade — são as "permissões" do iOS) -->
<key>NSLocationWhenInUseUsageDescription</key>
<key>NSPhotoLibraryUsageDescription</key>
<key>NSCameraUsageDescription</key>
<key>NSMicrophoneUsageDescription</key>

<!-- 2. App Transport Security (ATS) — HTTP permitido? -->
<key>NSAppTransportSecurity</key>
<dict>
    <key>NSAllowsArbitraryLoads</key>
    <true/>              <!-- ← ATS COMPLETAMENTE DESLIGADO = HTTP em claro! -->
</dict>

<!-- 3. Esquemas de URL registrados (outros apps podem invocar) -->
<key>CFBundleURLTypes</key>
<array>
    <dict>
        <key>CFBundleURLSchemes</key>
        <array>
            <string>appcliente</string>  <!-- outro app pode abrir appcliente:// -->
        </array>
    </dict>
</array>

<!-- 4. Backup (iCloud) -->
<key>UIBackupModes</key>   <!-- aplicativo faz backup do que não deveria? -->

<!-- 5. Debuggable? (só se for compilado em debug — mas detectável no entitlements) -->

Entitlements (permissões reais do app)

# Extrair do IPA (ou do binário):
codesign -d --entitlements - AppName.app/AppName
# ou no IPA extraído:
codesign -d --entitlements - AppName.app/AppName 2>&1 | plutil -convert xml1 - -o -
O que procurar:

xml

<!-- Permissões de segurança (as que importam) --> <key>keychain-access-groups</key> <!-- acesso ao Keychain --> <key>com.apple.security.exception.files.downloads.read-write</key> <!-- acesso a arquivos --> <key>com.apple.developer.associated-domains</key> <!-- universal links -->

Análise do binário — extrair headers e strings

bash

# Strings (secretos, endpoints, chaves): strings AppName.app/AppName | grep -iE "api[_-]?key|secret|token|password|AKIA|sk-|https?://" strings AppName.app/AppName | grep -iE "AES|RSA|secretKey|keychain" strings AppName.app/AppName | grep -iE "com.empresa|endpoint|staging|sandbox"

# Extrair headers Objective-C (class-dump no Mac): class-dump AppName.app/AppName > headers.txt # Procure classes que pareçam conter lógica sensível: grep -i "password|token|keychain|crypto|secret" headers.txt

# Ghidra/Hopper (para análise mais profunda — código Swift/ObjC descompilado): # Abra o Mach-O no Ghidra; procure funções que tratam autenticação, criptografia

Bibliotecas de terceiros (Risco Módulo 6 — componentes vulneráveis)

bash

# Frameworks embutidos: ls -la AppName.app/Frameworks/ # Versões conhecidas vulneráveis (Alamofire, AFNetworking, Firebase, etc.) strings AppName.app/Frameworks/Alamofire.framework/Alamofire | grep "Alamofire"

## MÓDULO 16 — Mobile Hacking: Tópico 12 — Análise dinâmica e interceptação HTTPS (iOS)
Configurar o proxy no iPhone

bash

# 1. Burp no Kali: Proxy → 0.0.0.0:8080 (mesmo do Módulo 8) # 2. iPhone: Settings → Wi-Fi → (rede) → HTTP Proxy → Manual # Servidor: IP_DO_KALI, Porta: 8080 # 3. Instalar CA do Burp no iPhone: # Safari → http://burp → baixar cacert.der # Settings → General → About → Certificate Trust Settings → ativar # 4. ATS: se o app só aceita HTTPS com pinning, você precisa do bypass (16.13)

bypass.completo do ATS (se o app bloquear HTTP)
Se o Info.plist tem NSAllowsArbitraryLoads=false (ou não tem a chave), o iOS bloqueia HTTP. Mesmo com seu proxy, ele não aceita a CA do Burp sem bypass. Duas formas:

a) Frida (com jailbreak):

javascript

// ats_bypass.js — desliga ATS na hora ObjC.perform(function () { console.log("[] Bypass de ATS"); var cls = ObjC.classes.NSAllowsArbitraryLoads; // Hook no NSURLSession/NSURLConnection para ignorar ATS var Session = ObjC.classes.NSURLSession; Session.configuration = function () { console.log("[] Cacheando config"); return this.configuration(); }; // Hook direto no ATS: var ATS = ObjC.classes.NSAppTransportSecurity; // (varia por versão do iOS — use objection para simplificar) });

b) objection (mais fácil, mesmo resultado):

bash

objection -g com.empresa.app explore ios disable pindisabler # desabilita pinning ios info plist # vê o plist em tempo real

Interceptação com Frida + Burp (o que você vai ver)

bash

# Rode o script de bypass de pinning (16.13) e depois: # 1. Abra o app no iPhone # 2. Burp: HTTP History mostra as requisições # 3. Mapeie endpoints, tokens, parâmetros (mesmo fluxo do Android)

## MÓDULO 16 — Mobile Hacking: Tópico 13 — Frida em iOS (Hooks ObjC)
No iOS, o Frida hooka Objective-C runtime com ObjC.classes em vez de Java.use. Fora isso, o conceito é idêntico.

Bypass de SSL Pinning iOS (o script mais importante)

javascript

// ssl_bypass_ios.js — rode com: frida -U -l ssl_bypass_ios.js com.empresa.app if (ObjC.available) { console.log("[*] Bypass de SSL pinning iOS");

// Método 1 — NSURLSession (o padrão iOS) var NSURLSession = ObjC.classes.NSURLSession; var origSessionWithDelegate = NSURLSession.sessionWithConfiguration_delegate_delegateQueue; NSURLSession.sessionWithConfiguration_delegate_delegateQueue = function (config, delegate, queue) { console.log("[*] NSURLSession criado: " + config); return origSessionWithDelegate(config, null, queue); // delegate = null → sem validação };

// Método 2 — AFNetworking (framework comum) var AFSecurityPolicy = ObjC.classes.AFSecurityPolicy; if (AFSecurityPolicy) { AFSecurityPolicy.pinnedCertificates = function () { return null; }; AFSecurityPolicy.allowInvalidCertificates = function () { return true; }; AFSecurityPolicy.validatesDomainName = function () { return false; }; }

// Método 3 — Alamofire (outro framework comum) var ServerTrustManager = ObjC.classes.ServerTrustManager; if (ServerTrustManager) { ServerTrustManager.evaluateTrust_ = function (trust) { return true; }; }

// Método 4 — HTTP body capture (opcional) var HTTPSBody = ObjC.classes.NSHTTPBody; // (interceptar corpo de requisições) }

Bypass de Jailbreak Detection iOS

bash

# objection (mais prático): objection -g com.empresa.app explore ios jailbreak disable # ou manual: ios jailbreak bypass enable

javascript

// jailbreak_bypass_ios.js — hooks nas checagens comuns if (ObjC.available) { console.log("[*] Bypass de jailbreak detection");

// Hook no NSFileManager (checar /Applications/Cydia.app, /bin/bash...) var NSFileManager = ObjC.classes.NSFileManager; NSFileManager.fileExistsAtPath = function (path) { if (path.toString().indexOf("Cydia") !== -1 || path.toString().indexOf("bash") !== -1 || path.toString().indexOf("ssh") !== -1) { console.log("[*] Bloqueando checagem de: " + path); return false; } return this.fileExistsAtPath(path); };

// Hook no stat() via POSIX (outra checagem comum) var Module = ObjC.classes.UIDevice; Module.jailbreakStatus = function () { return false; }; }

Outros hooks úteis no iOS

javascript

// Hook no Keychain (ver o que o app guarda no Keychain) var Keychain = ObjC.classes.KeychainWrapper; // nome depende do app Keychain.objectForKey = function (key) { var val = this.objectForKey(key); console.log("[*] Keychain leitura: " + key + " = " + val); return val; };

// Hook no NSUserDefaults (equivalente ao SharedPreferences)
var UserDefaults = ObjC.classes.NSUserDefaults;
UserDefaults.stringForKey = function (key) {
    var val = this.stringForKey(key);
    console.log("[*] NSUserDefaults: " + key + " = " + val);
    return val;
};

MÓDULO 16 — Mobile Hacking: Tópico 14 — Extração de dados do storage iOS Keychain (o "cofre" do iOS — onde os apps guardam tokens e senhas) Com jailbreak, o Keychain é acessível:

# Via SSH no device:
ssh root@IPHONE
# Listar Keychain (ferramenta keychain_dumper no Cydia):
keychain_dumper -a       # dump de todos os itens do Keychain (precisa ser root)
# ou: keychain_dumper | grep -A5 "Generic|password|token"

O que o Keychain guarda: tokens de sessão (JWT), senhas, chaves de criptografia, cookies de autenticação. É o jackpot do storage iOS.

NSUserDefaults (o "SharedPreferences" do iOS)

# Path no device:
/var/mobile/Containers/Data/Application/<UUID>/Library/Preferences/com.empresa.app.plist

# Extrair:
scp root@IPHONE:/var/mobile/.../com.empresa.app.plist .
plutil -convert json com.empresa.app.plist -o -
# → dados em JSON legível (tokens, config, dados do usuário)

CoreData / SQLite (o banco local)

ssh root@IPHONE
find /var/mobile/Containers/Data/Application/ -name "*.sqlite" -o -name "*.db"
# Extrair e analisar:
scp root@IPHONE:/caminho/do/app.sqlite .
sqlite3 app.sqlite ".tables"
sqlite3 app.sqlite "SELECT * FROM usuarios;"

Arquivos do app (Documents, Caches, tmp)

# Navegar no container do app:
ssh root@IPHONE
ls -la /var/mobile/Containers/Data/Application/<UUID>/Documents/
ls -la /var/mobile/Containers/Data/Application/<UUID>/Library/Caches/
# Arquivos de log, imagens baixadas, cache de API com dados

Backup do iPhone (análise forense sem jailbreak — se o app não marca UIBackupModes)

# 1. Conecte o iPhone ao Mac
# 2. iTunes/Apple Configurator: fazer backup (não criptografado)
# 3. Extrair dados do backup:
brew install libimobiledevice
idevicebackup2 backup --full ./
# ou use iPhone Backup Extractor / iMazing
# Os dados do app ficam em:
#   /Applications/.../Library/Preferences/ → NSUserDefaults
#   /Applications/.../Documents/ → arquivos do app

MÓDULO 16 — Mobile Hacking: Tópico 15 — Vulnerabilidades específicas iOS 1. UIPasteboard (dados sensíveis na área de transferência) Apps que copiam senhas/tokens para o clipboard — qualquer outro app pode ler a área de transferência (iOS 14+ mostra aviso, mas ainda permite):

// Hook no UIPasteboard (Frida)
var UIPasteboard = ObjC.classes.UIPasteboard;
UIPasteboard.generalPasteboard = function () {
    var pb = this.generalPasteboard();
    console.log("[*] Pasteboard lido: " + pb.string());
    return pb;
};

• Snapshot no background (dados na tela de app switcher)
• Senhas/tokens visíveis na tela de "app switcher" quando o app vai para background — o iOS tira um snapshot automático e guarda no disco:

# Achado: app não implementa applicationDidEnterBackground para limpar a tela
# Correção: usar blur/cover view antes de ir para background

• URL Scheme Injection (um app abre outro sem validação)
• O app registra appcliente:// — outros apps podem invocá-lo. Se o handler de URL confiar no parâmetro sem validação, há injeção:

# Teste do terminal no device:
# (via SSH)  open appcliente://reset-password?token=123456
# Se o app aceitar e processar o token — falha.

• Insecure WebView (XSS no contexto do app)
• Se o app carrega conteúdo web em WebView com JavaScript ativo e sem validação:

# Teste: intercepte a requisição (Burp) e injete:
<script>alert(document.cookie)</script>
# Se o alerta aparecer, o WebView não sanitiza — pode haver XSS e exfiltração

MÓDULO 16 — Mobile Hacking: Tópico 16 — Ferramenta: objection

# objection no device iOS:
objection -g com.empresa.app explore

# Comandos essenciais iOS:
ios info bundle              # Info.plist em tempo real
ios info plist               # plist legível
ios keychain dump            # Keychain inteiro (sem jailbreak? só com jailbreak+entitlement)
ios jailbreak disable        # bypass de jailbreak detection
ios sslpinning disable       # bypass de SSL pinning
ios cookies list             # cookies do app
ios pasteboard monitor       # monitorar área de transferência
ios nsuserdefaults get       # ler NSUserDefaults
ios view hierarchy           # ver elementos visuais (para UI tests)
env                          # variáveis de ambiente do app (segredos?)
sqlite connect <caminho>     # conectar em bancos SQLite locais

MÓDULO 16 — Mobile Hacking: Tópico 17 — O fluxo iOS completo (resumo)

• OBTER IPA (extrair ou baixar)
• ANÁLISE ESTÁTICA:
• - Info.plist (ATS, permissões, URL schemes, backup)
• - Entitlements (keychain, permissões)
• - Strings do binário (endpoints, chaves, tokens)
• - Headers ObjC (class-dump) → procura classes de segurança
• ANÁLISE DINÂMICA (com jailbreak):
• - Frida/objection: bypass de pinning e jailbreak detection
• - Burp: interceptar tráfego (endpoints, tokens, IDOR)
• - Keychain dump (keychain_dumper / objection)
• - NSUserDefaults + SQLite (extração)
• - Pastas Documents/Caches (arquivos)
• EXPLORAÇÃO:
• - API key/token → testar backend (IDOR, auth)
• - Keychain token → sessão como o usuário
• - URL scheme injection → abrir app como atacante
• - WebView XSS → exfiltração
• RELATÓRIO (mesmo padrão do Android)
• ## MÓDULO 16 — Mobile Hacking: Tópico 18 — Atividade prática (iOS)
• Se não tem dispositivo iOS, faça a análise estática sobre um IPA de laboratório (OWASP iGoat-Swift, Damn Vulnerable iOS App — DVIA) — ambos disponíveis no GitHub para estudo.

Setup: jailbreak no dispositivo + instalar frida-server (via Cydia) + SSH + keychain_dumper Estática: descompacte o IPA, leia Info.plist, extraia strings do binário, extraia entitlements ATS: no Info.plist, veja se NSAllowsArbitraryLoads está true (achado!) Segredos: do strings do binário, encontre 2+ segredos ou endpoints Interceptação: Burp + proxy no iPhone + bypass de pinning (objection ou Frida) — veja o tráfego Bypass JB: aplique ios jailbreak disable no objection e veja o app aceitar o device Keychain: dump do Keychain com keychain_dumper ou ios keychain dump do objection NSUserDefaults: extraia o plist de Preferences e leia os dados SQLite: extraia bancos e procure dados sensíveis Exploração: com um token do Keychain, teste na API (se no escopo) Desafio — o teste iOS completo documentado: crie ios_report.md em ~/pentest/evidencias/mobile/ (ou adicione ao mobile_report.md existente como seção iOS):

escopo (app, versão, device, iOS version, jailbreak usado) análise estática (Info.plist, entitlements, strings, headers) análise dinâmica (Burp, Frida/objection, bypasses) storage (Keychain, NSUserDefaults, SQLite, Caches) exploração (o que os achados permitiram fazer) correções por achado (Keychain seguro, ATS, pinning, backup) ### ✅ Checklist de extensão iOS Entendo as diferenças iOS vs Android no pentest (IPA, Mach-O, ObjC, Keychain, ATS) Tenho dispositivo jailbreakado (ou uso análise estática pura para estudo) Extraio IPA e analiso Info.plist (ATS, permissões, URL schemes) Extraio strings do binário (endpoints, segredos, chaves) Faço class-dump para headers ObjC Intercepto HTTPS (Burp + proxy + bypass de pinning via Frida/objection) Bypasso jailbreak detection (objection ou Frida) Extraio dados do Keychain (keychain_dumper / objection) Extraio NSUserDefaults + SQLite + arquivos Testo URL scheme injection e WebView XSS Documento achados com OWASP Mobile Top 10 + correções iOS

---