This article teaches Kerberoasting, an Active Directory attack where low-privilege domain users request encrypted service tickets (TGS) that can be cracked offline to reveal service account passwords. The technique works because any authenticated domain user can request tickets for any SPN-registered service without access checks, and service account passwords—typically set manually by administrators—are often weak enough to crack with wordlists. The article matters because Kerberoasting appears in nearly every successful red team engagement and can escalate to full domain compromise if service accounts hold elevated privileges.
- Core vulnerability in Kerberos ticket issuanceThe Domain Controller issues TGS tickets encrypted with the service account's NTLM password hash to any authenticated domain user who requests one, regardless of whether that user actually needs access to the service. No access check occurs. This means a low-privilege user can request tickets for all SPN-registered services in Active Directory, take them offline, and crack them with tools like Hashcat mode 13100—entirely without further domain interaction or noise.
- Why service accounts are realistic cracking targetsComputer account passwords are randomly generated and 120+ characters long, making their TGS hashes computationally infeasible to crack. Service account passwords, however, are typically set manually by administrators and follow predictable patterns like 'Company2019!' or 'SqlServer2022'—patterns that exist in mutation-based wordlists and crack in seconds. This fundamental difference makes service accounts the practical target of Kerberoasting attacks.
- Attack execution with three commandsThe article provides the exact GetUserSPNs.py workflow: first enumerate all kerberoastable accounts and their group memberships via LDAP, then request TGS tickets with the `-request` flag to extract $krb5tgs$23$ format hashes to a file, finally crack them with Hashcat mode 13100 against wordlists like rockyou.txt. These operations appear as normal Active Directory behavior to domain controllers, generating no exploitation signatures or errors.
- Prioritization by privilege level determines impactThe article emphasizes examining the MemberOf column from enumeration output to identify which cracked accounts will have highest impact. Domain Admins and Enterprise Admins provide immediate or forest-wide compromise; SQL Server service accounts enable database lateral movement; backup operator accounts bypass NTFS permissions across servers. A printer scan service account granted Domain Admin 'temporarily' in 2016 exemplified how privilege creep combined with password non-rotation creates critical risk.
- Detection signature in Windows Event logsKerberoasting creates detectable patterns in Event ID 4769 (TGS requests): multiple 4769 entries from a single source in short time, using RC4 encryption type (0x17) instead of modern AES, originating from unusual sources like workstations requesting service tickets, or occurring outside business hours. Kerberoasting tools default to RC4 specifically because it produces crackable hashes, making encryption type a strong detection indicator.
- Defense through managed accounts and monitoringThe article describes three defenses: (1) Group Managed Service Accounts (gMSAs) automatically rotate 240-character random passwords, eliminating offline cracking entirely; (2) manually set service account passwords to 25+ random characters; (3) monitor Event ID 4769 for the RC4 encryption pattern described above. Forcing AES-only encryption across the domain requires updating msDS-SupportedEncryptionTypes attributes on service accounts.
- Low privilege requirement enables broad exploitationThe attack requires only a standard domain user account with no admin rights and no special permissions—this is the vulnerability's critical aspect. Any user in the domain can perform steps 1-3 (enumeration and ticket extraction), making Kerberoasting accessible to attackers who have compromised even minimal-access accounts through phishing, weak passwords, or other initial access methods.
- Offline cracking eliminates domain detection riskSteps 1-3 require domain interaction and appear as normal AD operations, but step 4 (Hashcat cracking) happens entirely offline with no DC communication. This separation means attackers can extract dozens of hashes during a single reconnaissance phase, then spend days or weeks cracking them on local machines or cloud compute without generating additional security alerts, making the attack difficult to detect in real time.
Bottom line: Kerberoasting succeeds because it exploits a fundamental design feature of Kerberos (any user can request service tickets) combined with human password patterns (manually-set service account passwords are weak and rarely rotated), making it possible for any low-privilege domain user to extract and crack service account credentials in four steps with publicly available tools. Defense requires moving away from manually-managed service accounts to Group Managed Service Accounts, enforcing long rand
Part of the 100-Day Ethical Hacking Course — the most structured free ethical hacking training online
🎯 What You’ll Master in Day 25
⏱️ 24 min read · 3 hands-on exercises
📊 Where are you with Active Directory attacks coming into Day 25?
📋 What You’ll Master in Day 25 — Kerberoasting Guide
On Day 24 we covered the core Active Directory attack techniques including LDAP enumeration and password spraying. Today we go deeper into the Kerberos authentication protocol with Kerberoasting — one of the most reliable privilege escalation paths in Windows AD environments. This is Day 25 of the 100-Day Ethical Hacking Course.
How Kerberoasting Exploits Kerberos Authentication
Kerberos authentication uses tickets — when a user wants to access a service, they request a Ticket Granting Service (TGS) ticket from the Domain Controller. The DC issues this ticket encrypted with the service account’s NTLM password hash. Here is the vulnerability: any authenticated domain user can request a TGS ticket for any service registered in AD. There is no access check. The DC will hand it out. And since the ticket is encrypted with the service account’s password hash, taking it offline and cracking it reveals the service account’s plaintext password.
⏱️ Time: 3 minutes · No tools required
Both produce Kerberos TGS tickets that can be requested offline.
Answer these before reading on:
1. Computer account passwords are randomly generated and 120+ chars long.
What does this mean for cracking their TGS hashes?
2. Service account passwords are typically set manually by an admin.
What patterns do admins typically use for “secure” service account passwords?
3. If a service account has Domain Admin privileges, what does cracking it give you?
4. Why would an attacker prioritise an account named svc_sql over svc_printer?
📸 Write your answers and share in your notes.
SPNs — What Makes an Account Kerberoastable
A Service Principal Name (SPN) is the unique label that ties a running service to the Active Directory account that runs it. It follows the format service-class/host:port — for example MSSQLSvc/db01.corp.local:1433 for a SQL Server instance, or HTTP/intranet.corp.local for an internal web app. When a client wants to use that service, it asks the Domain Controller for a ticket “for this SPN”, and the DC hands back a TGS encrypted with the password hash of whichever account owns the SPN.
That one design fact is what makes kerberoasting possible. The account that owns an SPN is almost always a service account, and service accounts carry two weaknesses ordinary users do not: their passwords are often set once by an administrator and left for years, and they rarely expire. Because any authenticated user is allowed to request a ticket for any SPN, a low-privilege attacker can pull a ticket encrypted with that stale password and crack it offline at leisure — no special rights required.
Not every account with an SPN is worth attacking. Computer accounts and Group Managed Service Accounts (gMSA) also carry SPNs, but their passwords are 120+ random characters that the domain rotates automatically, so cracking one is not realistic. The accounts that matter are user objects whose servicePrincipalName attribute is set, because a human chose that password. Recognising them is the whole game: a user account + a populated servicePrincipalName = kerberoastable.
Enumerating Kerberoastable Accounts
⏱️ Time: 15 minutes · Lab: HackTheBox AD lab or your own AD home lab
📸 Screenshot the extracted $krb5tgs$ hashes and share in your notes.
Extracting and Cracking TGS Hashes
Once you know which accounts are kerberoastable, the attack is two moves: request the TGS tickets, then crack them offline. Nothing here looks suspicious to the Domain Controller — asking for a service ticket is exactly what normal Kerberos clients do all day, which is why kerberoasting is so quiet. The cracking runs on your own machine, so there is no account lockout and no failed-logon noise on the DC.
Impacket’s GetUserSPNs.py requests the tickets and prints them in a crackable format; from a domain-joined Windows box, Rubeus does the same. Each ticket comes out as a $krb5tgs$23$ string — the 23 is RC4 (etype 23), the fastest type to crack.
When the hash will not crack: modern service accounts may hand out AES tickets instead of RC4 — you will see $krb5tgs$18$ (AES-256) or $krb5tgs$17$ (AES-128), which need Hashcat modes 19700 and 19600 and are far slower. A ticket only falls to a wordlist when the underlying password is weak, which is exactly why the next section and the defences focus on password length and gMSA.
Prioritising Targets by Privilege
Not all kerberoastable accounts are equal. Before investing cracking time, review the MemberOf column from GetUserSPNs output to identify which accounts will have the highest impact if cracked.
Detection and Defence
⏱️ Time: 10 minutes · Target: Your AD lab DC
📸 Screenshot the 4769 events from your lab and share in your notes
🧠 QUICK CHECK — Day 25
📋 Commands Used Today — Day 25 Reference Card
🏆 Mark Day 25 as Complete
Kerberoasting — attack and defence both mastered. 25% through the course.
❓ Frequently Asked Questions
What is Kerberoasting?
Why is Kerberoasting so effective?
What makes an account kerberoastable?
How do you defend against Kerberoasting?
What comes after Kerberoasting in this course?
Day 24: Active Directory Attacks
Day 26: Pass the Hash
📚 Further Reading
- Day 24: Active Directory Attacks — The previous session covering LDAP enumeration, password spraying, and the AD attack surface overview that sets up Kerberoasting.
- Password Cracking Explained 2026 — Deep dive into Hashcat modes, wordlist strategy, and rule-based mutations — directly applicable to cracking TGS hashes from Kerberoasting.
- Ethical Hacking Course Hub — The full 100-day course map showing where Kerberoasting fits in the complete AD attack methodology.
- MITRE ATT&CK: Kerberoasting (T1558.003) — Official MITRE reference for Kerberoasting — procedure examples, detection, and mitigation guidance used by real threat intelligence teams.
- Impacket GitHub Repository — The official Impacket toolkit including GetUserSPNs.py, GetNPUsers.py (AS-REP Roasting), and the full suite of AD attack utilities.

