Bypass Anti-Instrumentation e SSL Pinning su Android (Frida/Objection)

Tip

Impara e pratica il hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica il hacking GCP: HackTricks Training GCP Red Team Expert (GRTE) Impara e pratica il hacking Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Supporta HackTricks

Questa pagina fornisce un workflow pratico per recuperare l’analisi dinamica contro app Android che rilevano/bloccano l’instrumentation su dispositivi rootati o che impongono TLS pinning. Si concentra su triage rapido, rilevamenti comuni e hook/tattiche copiabili per bypassarli senza ripacchettare quando possibile.

Superficie di rilevamento (cosa controllano le app)

  • Controlli di root: il binario su, percorsi Magisk, valori di getprop, pacchetti root comuni
  • Controlli Frida/debugger (Java): Debug.isDebuggerConnected(), ActivityManager.getRunningAppProcesses(), getRunningServices(), scansione di /proc, classpath, librerie caricate
  • Anti‑debug nativo: ptrace(), syscalls, anti‑attach, breakpoints, inline hooks
  • Controlli di init precoce: Application.onCreate() o hook di avvio processo che crashano se l’instrumentation è presente
  • TLS pinning: TrustManager/HostnameVerifier personalizzati, OkHttp CertificatePinner, Conscrypt pinning, pin native

Bypass della rilevazione Anti‑Frida / Stealth Frida Servers

phantom-frida ricompila Frida da sorgente e applica ~90 patch in modo che le fingerprint comuni di Frida scompaiano mentre il protocollo Frida stock rimane compatibile (frida-tools può ancora connettersi). Target: app che fanno grep su /proc (cmdline, maps, task comm, fd readlink), nomi dei servizi D-Bus, porte di default, o simboli esportati.

Fasi:

  • Patch della sorgente: rinomina globale degli identificatori frida (server/agent/helper) e ricostruzione del helper DEX con un package Java rinominato.
  • Patch mirate a build/runtime: tweak a meson, etichetta memfd cambiata in jit-cache, etichette SELinux (es., frida_file) rinominate, hook libc su exit/signal disabilitati per evitare hook-detector.
  • Rinomina post-build: simbolo esportato frida_agent_main rinominato dopo la prima compilazione (Vala lo emette), richiedendo una seconda build incrementale.
  • Patch esadecimali sul binario: nomi dei thread (gmain, gdbus, pool-spawner) sostituiti; sweep opzionale rimuove stringhe residue frida/Frida.

Vettori di rilevamento coperti:

  • Base (1–8): nome del processo frida-server, mapping di libfrida-agent.so, nomi dei thread, etichetta memfd, simbolo esportato frida_agent_main, etichette SELinux, effetti collaterali degli hook libc, e servizio D-Bus re.frida.server sono rinominati/neutralizzati.
  • Extended (9–16): cambiare la porta di ascolto (--port), rinominare interfacce D-Bus/simboli C interni/nomi GType, percorsi temporanei come .frida/frida-, sweep delle stringhe binarie, rinominare define a build-time e percorsi asset (libdir/frida). I nomi delle interfacce D-Bus che fanno parte del protocollo wire restano invariati in modalità base per evitare di rompere i client stock.

Build/uso (esempio Android arm64):

python3 build.py --version 17.7.2 --name myserver --port 27142 --extended --verify
adb push output/myserver-server-17.7.2-android-arm64 /data/local/tmp/myserver-server
adb shell chmod 755 /data/local/tmp/myserver-server
adb shell /data/local/tmp/myserver-server -D &
adb forward tcp:27142 tcp:27142
frida -H 127.0.0.1:27142 -f com.example.app

Opzioni: --skip-build (solo patch), --skip-clone, --arch, --ndk-path, --temp-fixes; Helper WSL: wsl -d Ubuntu bash build-wsl.sh.

Passo 1 — Soluzione rapida: nascondi root con Magisk DenyList

  • Abilita Zygisk in Magisk
  • Abilita DenyList, aggiungi il pacchetto di destinazione
  • Riavvia e riprova

Molte app cercano solo indicatori ovvi (su/Magisk paths/getprop). DenyList spesso neutralizza controlli ingenui.

Riferimenti:

  • Magisk (Zygisk & DenyList): https://github.com/topjohnwu/Magisk

Play Integrity / rilevamenti Zygisk (post‑SafetyNet)

Le app bancarie/ID più recenti legano i controlli a runtime a Google Play Integrity (sostituto di SafetyNet) e possono anche crashare se Zygisk è presente. Suggerimenti rapidi per il triage:

  • Disabilita temporaneamente Zygisk (toggle off + reboot) e riprova; alcune app crashano non appena l’iniezione di Zygote si carica.
  • Se l’attestazione blocca il login, patcha Google Play Services con PlayIntegrityFix/Fork + TrickyStore o usa ReZygisk/Zygisk‑Next solo durante i test. Tieni il target in DenyList e evita i moduli LSPosed che leak props.
  • Per esecuzioni singole, usa KernelSU/APatch (no Zygote injection) per restare al di sotto delle euristiche Zygisk, poi collega Frida.

Passo 2 — Test Frida Codeshare da 30 secondi

Prova script drop‑in comuni prima di approfondire:

  • anti-root-bypass.js
  • anti-frida-detection.js
  • hide_frida_gum.js

Esempio:

frida -U -f com.example.app -l anti-frida-detection.js

Questi tipicamente effettuano lo stub di Java root/debug checks, process/service scans e native ptrace(). Utile su apps poco protette; hardened targets potrebbero richiedere tailored hooks.

  • Codeshare: https://codeshare.frida.re/

Automatizza con Medusa (Frida framework)

Medusa fornisce 90+ moduli pronti per SSL unpinning, root/emulator detection bypass, HTTP comms logging, crypto key interception e altro.

git clone https://github.com/Ch0pin/medusa
cd medusa
pip install -r requirements.txt
python medusa.py

# Example interactive workflow
show categories
use http_communications/multiple_unpinner
use root_detection/universal_root_detection_bypass
run com.target.app

Suggerimento: Medusa è eccellente per ottenere risultati rapidi prima di scrivere custom hooks. Puoi anche cherry-pick modules e combinarli con i tuoi scripts.

Passo 3 — Eludere i rilevatori init-time agganciandosi più tardi

Molte rilevazioni vengono eseguite solo durante lo spawn del processo/onCreate(). Spawn‑time injection (-f) o gadgets vengono intercettati; agganciarsi dopo il caricamento della UI può passare inosservato.

# Launch the app normally (launcher/adb), wait for UI, then attach
frida -U -n com.example.app
# Or with Objection to attach to running process
aobjection --gadget com.example.app explore  # if using gadget

Se questo funziona, mantieni la sessione stabile e procedi a mappare ed eseguire i controlli sui stub.

Fase 4 — Mappare la logica di rilevamento tramite Jadx e string hunting

Parole chiave per il triage statico in Jadx:

  • “frida”, “gum”, “root”, “magisk”, “ptrace”, “su”, “getprop”, “debugger”

Pattern Java tipici:

public boolean isFridaDetected() {
return getRunningServices().contains("frida");
}

API comuni da rivedere/hook:

  • android.os.Debug.isDebuggerConnected
  • android.app.ActivityManager.getRunningAppProcesses / getRunningServices
  • java.lang.System.loadLibrary / System.load (native bridge)
  • java.lang.Runtime.exec / ProcessBuilder (probing commands)
  • android.os.SystemProperties.get (root/emulator heuristics)

Passo 5 — Runtime stubbing con Frida (Java)

Sovrascrivi i custom guards per restituire valori sicuri senza ripacchettare:

Java.perform(() => {
const Checks = Java.use('com.example.security.Checks');
Checks.isFridaDetected.implementation = function () { return false; };

// Neutralize debugger checks
const Debug = Java.use('android.os.Debug');
Debug.isDebuggerConnected.implementation = function () { return false; };

// Example: kill ActivityManager scans
const AM = Java.use('android.app.ActivityManager');
AM.getRunningAppProcesses.implementation = function () { return java.util.Collections.emptyList(); };
});

Triaging early crashes? Dump classes poco prima che muoia per individuare i probabili detection namespaces:

Java.perform(() => {
Java.enumerateLoadedClasses({
onMatch: n => console.log(n),
onComplete: () => console.log('Done')
});
});

Esempio rapido di stub per il rilevamento root (adattalo ai nomi di package/class del target):

Java.perform(() => {
try {
const RootChecker = Java.use('com.target.security.RootCheck');
RootChecker.isDeviceRooted.implementation = function () { return false; };
} catch (e) {}
});

Registra e neutralizza i metodi sospetti per confermare il flusso di esecuzione:

Java.perform(() => {
const Det = Java.use('com.example.security.DetectionManager');
Det.checkFrida.implementation = function () {
console.log('checkFrida() called');
return false;
};
});

Bypass emulator/VM detection (Java stubs)

Euristiche comuni: Build.FINGERPRINT/MODEL/MANUFACTURER/HARDWARE che contengono generic/goldfish/ranchu/sdk; artefatti QEMU come /dev/qemu_pipe, /dev/socket/qemud; MAC predefinito 02:00:00:00:00:00; NAT 10.0.2.x; assenza di telephony/sensors.

Quick spoof of Build fields:

Java.perform(function(){
var Build = Java.use('android.os.Build');
Build.MODEL.value = 'Pixel 7 Pro';
Build.MANUFACTURER.value = 'Google';
Build.BRAND.value = 'google';
Build.FINGERPRINT.value = 'google/panther/panther:14/UP1A.231105.003/1234567:user/release-keys';
});

Completa con stub per i controlli di esistenza dei file e per gli identificatori (TelephonyManager.getDeviceId/SubscriberId, WifiInfo.getMacAddress, SensorManager.getSensorList) in modo che restituiscano valori realistici.

SSL pinning bypass quick hook (Java)

Neutralizza i TrustManagers personalizzati e forza contesti SSL permissivi:

Java.perform(function(){
var X509TrustManager = Java.use('javax.net.ssl.X509TrustManager');
var SSLContext = Java.use('javax.net.ssl.SSLContext');

// No-op validations
X509TrustManager.checkClientTrusted.implementation = function(){ };
X509TrustManager.checkServerTrusted.implementation = function(){ };

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

Note

  • Estendi per OkHttp: hook okhttp3.CertificatePinner e HostnameVerifier secondo necessità, oppure usa uno script universale di unpinning da CodeShare.
  • Esempio di esecuzione: frida -U -f com.target.app -l ssl-bypass.js --no-pause

OkHttp4 / gRPC / Cronet pinning (2024+)

Le stack moderne effettuano pinning all’interno di API più recenti (OkHttp4+, gRPC over Cronet/BoringSSL). Aggiungi questi hook quando l’hook SSLContext di base si blocca:

Java.perform(() => {
try {
const Pinner = Java.use('okhttp3.CertificatePinner');
Pinner.check.overload('java.lang.String', 'java.util.List').implementation = function(){};
Pinner.check$okhttp.implementation = function(){};
} catch (e) {}

try {
const CronetB = Java.use('org.chromium.net.CronetEngine$Builder');
CronetB.enablePublicKeyPinningBypassForLocalTrustAnchors.overload('boolean').implementation = function(){ return this; };
CronetB.setPublicKeyPins.overload('java.lang.String', 'java.util.Set', 'boolean').implementation = function(){ return this; };
} catch (e) {}
});

Se TLS continua a fallire, passa al livello nativo e patcha i punti di ingresso di verifica di BoringSSL usati da Cronet/gRPC:

const customVerify = Module.findExportByName(null, 'SSL_CTX_set_custom_verify');
if (customVerify) {
Interceptor.attach(customVerify, {
onEnter(args){
// arg0 = SSL_CTX*, arg1 = mode, arg2 = callback
args[1] = ptr(0); // SSL_VERIFY_NONE
args[2] = NULL;  // disable callback
}
});
}

Passo 6 — Segui il percorso JNI/native quando i Java hooks falliscono

Traccia i punti di ingresso JNI per localizzare i native loaders e l’inizializzazione dei rilevamenti:

frida-trace -n com.example.app -i "JNI_OnLoad"

Rapida analisi nativa dei file .so inclusi:

# List exported symbols & JNI
nm -D libfoo.so | head
objdump -T libfoo.so | grep Java_
strings -n 6 libfoo.so | egrep -i 'frida|ptrace|gum|magisk|su|root'

Interactive/native reversing:

  • Ghidra: https://ghidra-sre.org/
  • r2frida: https://github.com/nowsecure/r2frida

Esempio: neutralizzare ptrace per aggirare il semplice anti‑debug in libc:

const ptrace = Module.findExportByName(null, 'ptrace');
if (ptrace) {
Interceptor.replace(ptrace, new NativeCallback(function () {
return -1; // pretend failure
}, 'int', ['int', 'int', 'pointer', 'pointer']));
}

Vedi anche: Reversing Native Libraries

Passo 7 — Objection patching (embed gadget / strip basics)

Se preferisci il repacking rispetto ai runtime hooks, prova:

objection patchapk --source app.apk

Note:

  • Richiede apktool; assicurati di avere una versione aggiornata dalla guida ufficiale per evitare problemi di build: https://apktool.org/docs/install
  • Gadget injection consente instrumentation senza root ma può comunque essere intercettata da controlli init‑time più severi.

Facoltativamente, aggiungi moduli LSPosed e Shamiko per un nascondimento del root più robusto in ambienti Zygisk, e cura DenyList per coprire i processi figli.

Per un flusso di lavoro completo, inclusa la configurazione Gadget in script-mode e l’incorporamento del tuo agente Frida 17+ nell’APK, vedi:

Frida Tutorial — Self-contained agent + Gadget embedding

References:

  • Objection: https://github.com/sensepost/objection

Step 8 — Fallback: Patch TLS pinning for network visibility

Se instrumentation è bloccata, puoi comunque ispezionare il traffico rimuovendo staticamente il pinning:

apk-mitm app.apk
# Then install the patched APK and proxy via Burp/mitmproxy
  • Strumento: https://github.com/shroudedcode/apk-mitm
  • Per i trucchi di network config CA‑trust (e la user CA trust su Android 7+), vedi:

Make APK Accept CA Certificate

Install Burp Certificate

Scheda rapida dei comandi

# List processes and attach
frida-ps -Uai
frida -U -n com.example.app

# Spawn with a script (may trigger detectors)
frida -U -f com.example.app -l anti-frida-detection.js

# Trace native init
frida-trace -n com.example.app -i "JNI_OnLoad"

# Objection runtime
objection --gadget com.example.app explore

# Static TLS pinning removal
apk-mitm app.apk

Universal proxy forcing + TLS unpinning (HTTP Toolkit Frida hooks)

Le app moderne spesso ignorano i proxy di sistema e applicano più livelli di pinning (Java + native), rendendo la cattura del traffico difficoltosa anche con CA utente/di sistema installate. Un approccio pratico è combinare l’universal TLS unpinning con il proxy forcing tramite Frida hooks già pronti, e instradare tutto tramite mitmproxy/Burp.

Flusso di lavoro

  • Esegui mitmproxy sul tuo host (o Burp). Assicurati che il dispositivo possa raggiungere l’IP/porta dell’host.
  • Carica i consolidated Frida hooks di HTTP Toolkit per sia unpin TLS che forzare l’uso del proxy attraverso gli stack comuni (OkHttp/OkHttp3, HttpsURLConnection, Conscrypt, WebView, ecc.). Questo bypassa CertificatePinner/TrustManager e sovrascrive i proxy selectors, quindi il traffico viene sempre inviato tramite il tuo proxy anche se l’app disabilita esplicitamente i proxy.
  • Avvia l’app target con Frida e lo script hook, e cattura le richieste in mitmproxy.

Esempio

# Device connected via ADB or over network (-U)
# See the repo for the exact script names & options
frida -U -f com.vendor.app \
-l ./android-unpinning-with-proxy.js \
--no-pause

# mitmproxy listening locally
mitmproxy -p 8080

Note

  • Combina con un proxy di sistema tramite adb shell settings put global http_proxy <host>:<port> quando possibile. I Frida hooks faranno rispettare l’uso del proxy anche quando le app aggirano le impostazioni globali.
  • Questa tecnica è ideale quando devi eseguire un MITM su flussi di onboarding mobile-to-IoT in cui il pinning o il bypass del proxy sono comuni.
  • Hooks: https://github.com/httptoolkit/frida-interception-and-unpinning

Riferimenti

Tip

Impara e pratica il hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica il hacking GCP: HackTricks Training GCP Red Team Expert (GRTE) Impara e pratica il hacking Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Supporta HackTricks