
Kerberoasting: What It Is, How the Attack Works, and How to Detect and Prevent It
Kerberoasting is a post-exploitation attack against Microsoft Active Directory in which an attacker who already has a low-privileged domain account requests Kerberos service tickets for service accounts, then cracks those tickets offline to recover the service account passwords. It does not need malware, a privileged account, or a vulnerability in Kerberos itself. It uses Kerberos the way it was designed to work, and it exploits weak service account passwords and the use of the RC4 encryption type.
Kerberoasting was first described publicly by Tim Medin in 2014, and it is still one of the most common ways attackers move from a single compromised workstation to domain admin. This guide explains how Kerberoasting works, how to tell it apart from similar attacks such as AS-REP Roasting and Golden Tickets, how to detect it in your logs, and how to prevent it with strong service account passwords, Group Managed Service Accounts, AES encryption, and monitoring.
What Is Kerberoasting?
Kerberoasting targets service accounts in Active Directory. A service account is a domain account that runs a service, such as a SQL Server, a web application, or a scheduled task, and has a Service Principal Name, or SPN, registered in Active Directory. The SPN links the service to the account, for example MSSQLSvc/sql01.example.com:1433 for a SQL Server instance.
When a user wants to access a service, they ask the Kerberos Key Distribution Center, which runs on a domain controller, for a Ticket Granting Service ticket, or TGS ticket, for that service. The KDC encrypts part of that ticket with a key derived from the service account password, using the encryption type negotiated for that account. The user can then present the ticket to the service to prove they are authenticated.
Kerberoasting turns that normal process into an offline password attack. Any authenticated domain user, even a low-privileged one, can request a TGS ticket for any service account, without needing to access the service itself, and without needing special permissions. The attacker then takes that ticket offline, extracts the encrypted part, and tries to crack it with a password-cracking tool such as Hashcat, using a wordlist or a brute-force attack. If the service account password is weak, short, or based on a common word, the attacker can recover it in minutes or hours, without generating any more traffic to the domain controller.
Once the attacker has the service account password, they can log in as that service account. Service accounts often have more privileges than a normal user, are not subject to the same password policies, and are not monitored as closely. In many environments, a service account has local administrator rights on servers, or even domain administrator rights, so cracking one service account can give the attacker the keys to the whole domain.
How Kerberoasting Works, Step by Step
- Initial access: The attacker gains a foothold in the domain, for example by phishing a user, exploiting a workstation, or using a stolen low-privileged credential. They need only a valid domain user account, not an administrator account.
- Enumerate SPNs: The attacker queries Active Directory for accounts with an SPN, using a tool such as PowerShell, BloodHound, or the Rubeus tool. That list tells them which service accounts exist, and which services they run.
- Request TGS tickets: The attacker requests a TGS ticket for each SPN they want to target, using the Kerberos protocol. This is a normal, legitimate request, and it is not blocked by default in most environments.
- Extract the ticket: The attacker exports the TGS ticket from memory, or requests it in a format that can be cracked, such as a Kerberoastable hash in Hashcat format.
- Crack offline: The attacker runs Hashcat or a similar tool on the ticket, trying passwords from a wordlist, a dictionary, or a brute-force attack. Because the cracking is offline, there is no lockout, no rate limiting, and no alert from the domain controller during the cracking itself.
- Use the password: If the password is cracked, the attacker logs in as the service account, and uses its privileges to move laterally, access sensitive data, or escalate to domain admin.
For a detailed explanation of SPNs and how Kerberos uses them, see our guide to Server Principal Name (SPN): What It Is, How Kerberos Uses It, and How to Secure It. Kerberoasting is, in effect, an attack on the SPN system, so understanding SPNs is the first step to defending against it.
Why Kerberoasting Works: RC4, Weak Passwords, and Service Accounts
Kerberoasting is not a bug in Kerberos. It works because of three design and operational choices that are common in real Active Directory environments.
| Factor | How it helps the attacker | What to change |
|---|---|---|
| RC4 encryption | RC4-HMAC tickets are much faster to crack than AES tickets, and RC4 is still enabled for many service accounts | Move service accounts to AES256, and disable RC4 where possible |
| Weak service account passwords | Service accounts often have short, human-chosen, or never-changed passwords, sometimes shared across services | Use long, random, unique passwords, at least 25 characters, or use a Group Managed Service Account |
| Any user can request any TGS ticket | Kerberos does not check whether the user is allowed to use the service before issuing a ticket | Monitor TGS requests, and remove unnecessary SPNs |
| Service accounts with high privileges | A cracked service account often has local admin or domain admin rights | Give service accounts only the privileges they need, and no more |
| Passwords that never expire | A cracked password stays valid for years | Rotate service account passwords regularly, or use a managed service account that rotates automatically |
RC4 deserves special attention. Kerberos supports several encryption types, including AES128 and AES256, which are much stronger than RC4. Many service accounts still use RC4 because they were created years ago, or because an old application requires it. A ticket encrypted with RC4 can be cracked far faster than one encrypted with AES256, often in hours instead of years, for the same password. Moving to AES is one of the highest-value steps you can take against Kerberoasting.
Service account passwords are also a problem because they are often set once, when a service is installed, and never changed. A password that was set in 2018, with a simple pattern such as Service123, is a gift to an attacker with a wordlist. Use a password manager or a managed service account to generate and store a long, random password that no human needs to remember or type.
Kerberoasting vs AS-REP Roasting vs Golden Ticket
These three Kerberos attacks are often confused, but they target different parts of Kerberos.
| Attack | What the attacker requests | What is cracked | Who is vulnerable |
|---|---|---|---|
| Kerberoasting | TGS ticket for a service account, with an SPN | Service account password hash | Any service account with an SPN and a weak password, especially with RC4 |
| AS-REP Roasting | AS-REP response for a user account with Kerberos pre-authentication disabled | User account password hash | Any user account with pre-authentication disabled |
| Golden Ticket | Forged Ticket Granting Ticket, using the krbtgt account hash | Nothing to crack, the ticket is forged | Any domain, if the attacker has already compromised the krbtgt hash, usually after domain admin access |
Kerberoasting and AS-REP Roasting are both offline password attacks, but they target different accounts and different Kerberos messages. A Golden Ticket is not a password attack at all; it is a forgery attack that requires the attacker to already have domain-level access. Defending against Kerberoasting will not stop a Golden Ticket, and vice versa, so you need to defend against all three.
Who Is Most at Risk?
Any Active Directory environment with service accounts is at risk, but some are more exposed than others. You are at higher risk if you have many service accounts with SPNs, if those accounts have weak or old passwords, if RC4 is still enabled, if service accounts have domain admin or local admin rights, or if you do not monitor Kerberos ticket requests.
Common high-risk service accounts include SQL Server service accounts, IIS application pool identities, SharePoint, Exchange, and other line-of-business applications that were installed with a domain account and an SPN. Those accounts are often created by a vendor or a contractor, with a simple password, and then forgotten. Audit your SPNs regularly, and ask for each one: does this service still exist, does this account need an SPN, and does it need the privileges it has?
Use LDAP queries and Active Directory tools to inventory SPNs, and use the Global Catalog in Active Directory to search across domains. A complete inventory is the starting point for any Kerberoasting defence, because you cannot protect service accounts you do not know about.
How to Detect Kerberoasting
Kerberoasting is hard to detect because the ticket request itself is legitimate Kerberos traffic. The cracking happens offline, so there is no alert during cracking. Detection therefore relies on spotting unusual ticket requests, and on looking for the tools and behaviours that accompany the attack.
The most useful Windows event is Event ID 4769, A Kerberos service ticket was requested, on domain controllers. Look for the following patterns in 4769 events:
- A single user requesting tickets for many different service accounts in a short time: A normal user usually accesses a small number of services. An attacker enumerating SPNs will request tickets for many services, often in quick succession.
- Requests for service accounts that the user never normally uses: A user in Finance requesting a ticket for a SQL Server service account they have never used is suspicious.
- RC4 encryption in the ticket: Event 4769 includes the ticket encryption type. RC4, or 0x17, is a warning sign, especially for a service that should use AES.
- Requests with no corresponding service use: A ticket is requested, but the user never actually connects to the service. That pattern suggests the ticket was requested only to crack it.
- Unusual tools: Tools such as Rubeus, Mimikatz, and Impacket leave traces in process logs, command-line history, and endpoint detection and response (EDR) alerts. Look for those tools, and for PowerShell commands that query SPNs.
Microsoft also recommends monitoring for Event ID 4769 with a ticket encryption type of RC4, and for a high volume of 4769 events from a single account. A SIEM rule that alerts on, for example, more than ten TGS requests for different SPNs from one user in ten minutes, with RC4 encryption, is a good starting point. Tune the threshold for your environment, and test it with normal traffic first, so you do not drown in false positives.
Other detection ideas include honeypot SPNs, also called canary SPNs. Create a fake service account with an SPN and a weak-looking name, such as SQLProd, that no legitimate user should ever request a ticket for. If anyone requests a ticket for that SPN, alert immediately, because it is almost certainly an attacker enumerating SPNs.
How to Prevent Kerberoasting
Prevention is about making Kerberoasting unprofitable: strong passwords, AES encryption, least privilege, and removing unnecessary SPNs. No single control stops it, but together they make the attack much harder.
- Use Group Managed Service Accounts (gMSA): A gMSA is a special Active Directory account whose password is long, random, and automatically rotated by the domain controller, typically every 30 days. The password is never known to a human, and it cannot be cracked easily. Migrate service accounts to gMSAs where the application supports them, and use standalone Managed Service Accounts (sMSA) where a gMSA is not supported.
- Use long, random, unique passwords: For service accounts that cannot use a gMSA, set a password of at least 25 characters, generated randomly, unique to that account, and stored in a password manager or vault. Rotate it regularly, and never reuse a service account password for another service.
- Move to AES256: Set service accounts to use AES256, and disable RC4 where possible. In Active Directory, you can set the account option for Kerberos AES, and you can use Group Policy to control the encryption types allowed. Test applications that require RC4 before you disable it, and plan a migration for those that do.
- Remove unnecessary SPNs: Audit SPNs regularly, and remove SPNs for services that no longer exist, for duplicate SPNs, and for accounts that do not need an SPN. Fewer SPNs mean fewer targets for an attacker.
- Apply least privilege: Give service accounts only the permissions they need to run the service, and no more. Do not make a service account a domain admin, a local admin on many servers, or a member of a privileged group, unless the service genuinely requires it.
- Enable Kerberos Armoring (FAST) and other hardening: Kerberos Armoring, also called Flexible Authentication Secure Tunneling, protects Kerberos pre-authentication, and other hardening settings, such as disabling RC4 for the krbtgt account and using AES for the krbtgt account, reduce the overall Kerberos attack surface.
- Monitor and alert: Enable auditing for Event 4769, send those events to a SIEM, and alert on the patterns described above. Test your detection with a safe, authorized test in a lab, or with a red team exercise, so you know the alert works before a real attack.
What to Do If You Suspect Kerberoasting
If your monitoring alerts on unusual TGS requests, or you find evidence that a service account password was cracked, act quickly. A cracked service account can lead to a full domain compromise in hours.
- Contain the account: Disable or reset the affected service account, and reset the password to a long, random value. Do not simply change the password to another weak value.
- Check for lateral movement: Look for logons from that service account on servers it should not access, for new accounts, for changes to group membership, and for scheduled tasks or services created by that account.
- Reset the krbtgt account twice: If you suspect domain-level compromise, reset the krbtgt account password twice, with at least ten hours between resets, to invalidate all Kerberos tickets, including any Golden Tickets. This is a significant step, so plan it carefully and follow Microsoft guidance.
- Review the initial access: Find how the attacker got the first low-privileged account, whether by phishing, a weak password, or an unpatched workstation, and fix that entry point.
- Preserve evidence: Save the 4769 events, the SIEM alerts, and the endpoint logs before they are overwritten. That evidence is needed for incident response and for any later investigation.
Kerberoasting Hardening Checklist
| Action | Priority | Done? |
|---|---|---|
| Inventory all SPNs and service accounts | High | List every SPN, its account, and its privileges |
| Remove unnecessary SPNs | High | Delete SPNs for retired services and duplicates |
| Migrate to gMSA where possible | High | Use Group Managed Service Accounts for new and existing services |
| Set 25+ character random passwords for remaining service accounts | High | Use a vault, and rotate regularly |
| Move service accounts to AES256, disable RC4 | High | Test applications that require RC4 first |
| Apply least privilege to service accounts | High | Remove domain admin and unnecessary local admin rights |
| Enable auditing for Event 4769 and send to SIEM | Medium | Alert on many TGS requests from one user, and on RC4 tickets |
| Create a honeypot SPN | Medium | Alert immediately if anyone requests a ticket for it |
| Review SPNs and service account passwords quarterly | Medium | Make it a recurring task, with an owner and a date |
| Test detection with a safe, authorized exercise | Medium | Confirm your SIEM rule works before a real attack |
Frequently Asked Questions
Is Kerberoasting a vulnerability in Kerberos?
No. Kerberoasting uses Kerberos as designed. It exploits weak service account passwords, RC4 encryption, and the fact that any authenticated user can request a TGS ticket. Fixing those operational issues, not patching Kerberos, is the defence.
Can Kerberoasting be done without a domain account?
No. The attacker needs a valid, authenticated domain account to request TGS tickets. That is why phishing, password reuse, and weak user passwords are often the first step in a Kerberoasting attack.
Does multi-factor authentication stop Kerberoasting?
Multi-factor authentication helps stop the initial access, but it does not stop Kerberoasting itself, because the attacker already has a domain account and is requesting tickets with Kerberos, not with an interactive logon that triggers multi-factor authentication. Strong service account passwords and AES are the direct defences.
How long does it take to crack a Kerberoasted ticket?
It depends on the password and the encryption type. A short, common password with RC4 can be cracked in minutes. A long, random password with AES256 can take years, or effectively never, with current hardware. That is why password length and encryption type matter so much.
Will disabling RC4 break my applications?
It can, if an application was built to use only RC4. Test each application before you disable RC4, and migrate those that support AES. For applications that cannot use AES, use a gMSA with a long, random password, and monitor them closely, as a temporary measure.
What is the difference between Kerberoasting and Pass-the-Ticket?
Kerberoasting cracks a service account password offline from a TGS ticket. Pass-the-Ticket reuses a stolen Kerberos ticket directly, without cracking a password, to impersonate a user. Both are Kerberos attacks, but they use different techniques and need different defences.
Bottom Line
Kerberoasting is a quiet, effective attack because it uses legitimate Kerberos traffic, cracks passwords offline, and targets service accounts that are often weak, over-privileged, and forgotten. You cannot patch it away, but you can make it unprofitable. Inventory your SPNs, remove the ones you do not need, migrate service accounts to Group Managed Service Accounts, set long, random, unique passwords for the rest, move to AES256 and disable RC4, apply least privilege, and monitor Event 4769 for unusual TGS requests. Do those things, and test your detection, and a Kerberoasting attempt will be slow, noisy, and likely to fail, instead of a quick path to domain admin.


