Kerberoasting: The Silent Credential Heist Targeting Business Networks in 2026
• BizVuln Staff
Learn how Kerberoasting exploits Active Directory service accounts, why businesses are prime targets in 2026, and actionable steps to detect and prevent this credential theft attack.
Kerberoasting: The Silent Credential Heist Targeting Business Networks in 2026
Every 39 seconds, a new cyberattack targets a business network. In 2026, that statistic feels almost quaint—because the real threat isn’t the frequency, but the sophistication. Among the most insidious and persistently effective attacks is Kerberoasting, a technique that turns a core authentication protocol against the very organizations that rely on it.
If you are a security leader, IT administrator, or CISO, you need to understand why Kerberoasting remains a top-tier credential threat for business networks—and why the attack surface has only widened in the past two years. This deep dive will explain the mechanics, the evolving tactics, and—most importantly—how to defend against it. By the end, you’ll have a clear, actionable roadmap to harden your Active Directory environment and reduce your risk of a devastating credential compromise.
---
Understanding Kerberoasting: The Mechanics of the Attack
The Kerberos Protocol and Service Tickets
Kerberos is the default authentication protocol in Microsoft Active Directory (AD). It is elegant, secure when properly configured, and ubiquitous in enterprise environments. The protocol uses a trusted third party—the Key Distribution Center (KDC)—to issue Ticket Granting Tickets (TGTs) and Service Tickets that allow users to access network services without repeatedly entering passwords.
Here’s the simplified flow:
1. A user authenticates to the KDC and receives a TGT.
2. When the user needs to access a service (e.g., SQL Server, SharePoint, a web application), they request a Service Ticket from the KDC.
3. The KDC creates a service ticket encrypted with the service account’s password hash (derived from the NTLM hash of the service’s account in AD).
4. The user presents that service ticket to the target service, which decrypts it using its own password hash.
The critical detail for attackers: the service ticket is encrypted with the service account’s password hash. If an attacker can obtain that ticket, they can attempt to crack the hash offline—without ever triggering a failed login attempt or locking the account.
How Attackers Extract and Crack Ticket Hashes
Kerberoasting is a post-exploitation attack. The attacker must already have a foothold on the network—typically as a domain user with low privileges. From there, the attack unfolds in three steps:
1. Enumerate Service Principal Names (SPNs) – The attacker queries Active Directory for all accounts that have an SPN registered. SPNs are unique identifiers for services running under a specific account. Any domain user can request this information via LDAP queries (e.g., using PowerShell: `Get-ADUser -Filter {ServicePrincipalName -like "*"} -Properties ServicePrincipalName`).
2. Request Service Tickets – The attacker then requests a TGS (Ticket Granting Service) ticket for each SPN. Because the user has a valid TGT, the KDC will happily issue service tickets for any SPN the user is authorized to access. In many environments, domain users can request tickets for any SPN.
3. Extract and Crack the Hash – The service ticket is returned in a format that includes the encrypted portion. Tools like Rubeus, Impacket, or Mimikatz can extract the encrypted part (the service account’s NTLM hash, wrapped in Kerberos encryption). The attacker then cracks this hash offline using GPU-accelerated tools like Hashcat or John the Ripper.
If the service account password is weak—and many are—the attacker will recover the plaintext password in hours or even minutes. Once they have the password, they can impersonate that service account, escalate privileges, move laterally, and potentially gain Domain Admin access if the service account is over-privileged.
---
Why Business Networks Are Prime Targets
Prevalence of Weak Service Account Passwords
In 2026, despite decades of security awareness, the vast majority of service accounts still use passwords that are:
- Set to never expire (to avoid service interruptions).
- Shared across multiple services.
- Simple, dictionary-based, or default (e.g., `P@ssw0rd`, `Service123`).
- Stored in plaintext in scripts or configuration files.
A 2025 study by the Identity Theft Resource Center found that over 60% of service accounts in mid-sized organizations had passwords crackable within 24 hours using a standard wordlist. Attackers know this. Kerberoasting directly exploits this weakness because the offline cracking process is computationally cheap for weak passwords.
Lack of Monitoring for Anomalous TGS Requests
Most organizations do not monitor for unusual patterns of TGS requests. A single user requesting hundreds of service tickets in a short period is a red flag—but it often goes unnoticed because:
- Default Windows security auditing does not log every TGS request (Event ID 4769 must be explicitly enabled).
- Security Information and Event Management (SIEM) systems are not tuned to detect mass TGS enumeration.
- Many blue teams focus on failed logins, not successful ticket requests.
Attackers can also throttle their requests to evade detection, making Kerberoasting a low-and-slow attack that slips under the radar.
Privilege Escalation Pathways
The real danger of Kerberoasting is not the initial compromise of a low-privilege service account—it’s the privilege escalation that follows. Service accounts are often granted excessive permissions: local admin on servers, access to sensitive databases, or even membership in privileged groups like Domain Admins (a cardinal sin, yet still common). Once the attacker cracks the password, they inherit all those rights.
In 2026, attackers combine Kerberoasting with other techniques—like Pass-the-Hash, DCSync, or Silver Ticket attacks—to move rapidly toward total domain compromise. The average time from initial foothold to Domain Admin via Kerberoasting is measured in hours, not days.
---
The 2026 Threat Landscape: Evolving Kerberoasting Techniques
AI-Assisted Password Cracking
The most significant evolution in the past two years is the use of AI and machine learning to accelerate password cracking. Tools like Hashcat now integrate neural network models that can generate password guesses based on patterns in breached credential databases, company names, and common service account naming conventions. An AI-assisted cracker can recover a 10-character mixed-case password in under an hour—a task that would have taken days on traditional GPU clusters.
Cross-Forest and Cloud Kerberoasting
As organizations adopt hybrid identities—on-premises AD synced with Azure AD, or multiple AD forests—attackers have expanded Kerberoasting beyond a single domain. In cross-forest Kerberoasting, an attacker with a foothold in one forest can request service tickets for SPNs in a trusting forest. This bypasses traditional boundary controls.
Similarly, Azure AD Kerberoasting (sometimes called Cloud Kerberoasting) targets service principals in Azure AD that are synced from on-premises. While the cloud-side tickets are encrypted differently, the underlying principle remains the same: if the service principal password is weak, it can be cracked.
Kerberoasting as a Service (RaaS)
Cybercriminal marketplaces now offer Kerberoasting as a Service. For a fee, an attacker can upload a list of SPN hashes and receive cracked passwords within 24 hours. This lowers the barrier to entry dramatically; even script kiddies can now execute a sophisticated credential theft attack without understanding the underlying protocol. In 2026, Kerberoasting is no longer the exclusive domain of advanced persistent threats (APTs)—it is a commodity attack.
---
How to Detect and Prevent Kerberoasting: A Practical Checklist
Defending against Kerberoasting requires a layered approach that combines technical controls, monitoring, and policy. Use this checklist to assess and harden your environment.
✅ 1. Audit and Clean Up Service Accounts and SPNs
- **Action:** Run a script to enumerate all accounts with SPNs. Identify which are truly needed. Remove stale SPNs and decommission unused service accounts.
- **Tool:** `Get-ADUser -Filter {ServicePrincipalName -like "*"} -Properties * | Export-CSV spn_accounts.csv`
✅ 2. Enforce Strong, Long, Random Passwords
- **Action:** All service account passwords should be at least 25 characters, randomly generated, and stored in a secure vault (e.g., Azure Key Vault, CyberArk, or HashiCorp Vault).
- **Policy:** Set passwords to expire regularly (every 180 days) unless using managed service accounts.
✅ 3. Use Group Managed Service Accounts (gMSAs)
- **Action:** For services that support it (IIS, SQL Server, etc.), migrate to gMSAs. gMSAs have automatically rotated, complex passwords that are managed by AD—no human ever knows the password, making cracking impossible.
- **Note:** gMSAs cannot be used for all services, but they cover the majority of common enterprise workloads.
✅ 4. Enable and Monitor Event ID 4769
- **Action:** Enable Kerberos service ticket auditing on all Domain Controllers. Configure your SIEM to alert on:
- A single user requesting >10 service tickets within a short window.
- Requests for service tickets from accounts that normally never request them.
- Requests for high-value SPNs (e.g., `MSSQLSvc`, `HTTP`, `CIFS` on critical servers).
- **Threshold:** Tune based on your environment; start with 5 tickets per minute per user.
✅ 5. Implement Tiered Administrative Access
- **Action:** Ensure no service account is a member of Domain Admins, Enterprise Admins, or any highly privileged group. Use a tiering model (e.g., Microsoft’s ESAE / Red Forest) to isolate administrative accounts from service accounts.
✅ 6. Deploy Endpoint Detection and Response (EDR) with Behavioral Analytics
- **Action:** Modern EDR tools can detect the use of Kerberoasting tools (e.g., Rubeus, Mimikatz) by monitoring process creation, memory access, and command-line arguments. Enable these detections.
✅ 7. Regularly Test Your Defenses
- **Action:** Conduct purple-team exercises that simulate Kerberoasting. Use tools like **Rubeus** or **BloodHound** to map attack paths. Remediate weaknesses before attackers find them.
✅ 8. Partner with Experts for Remediation
- **Action:** If your internal team lacks bandwidth or specialized skills, engage a trusted partner. **ZoeSquad** offers comprehensive IT remediation services, including Active Directory hardening, Kerberoasting risk assessments, and continuous monitoring. Their team can help you implement gMSAs, configure SIEM rules, and run tabletop exercises to validate your defenses.
---
Frequently Asked Questions (FAQ)
1. What is the difference between Kerberoasting and a Golden Ticket attack?
Kerberoasting cracks the password of a service account by extracting the hash from a service ticket. Golden Ticket attacks forge a TGT using the KRBTGT account hash, granting the attacker domain-wide access. Both are dangerous, but Kerberoasting is easier to execute (requires only a low-privilege account) and harder to detect.
2. Can Kerberoasting be detected without a SIEM?
Yes, but it’s more difficult. You can manually review Event ID 4769 logs on Domain Controllers using PowerShell. However, without automation, you’ll likely miss low-volume attacks. At minimum, enable auditing and set up a scheduled script to flag anomalous TGS requests.
3. Does Kerberoasting work against Azure AD or cloud-only environments?
Classic Kerberoasting targets on-premises AD. However, Azure AD uses a different authentication protocol (OAuth 2.0 / SAML) for cloud services. That said, hybrid environments that sync service accounts to Azure AD can be vulnerable if the password hash is weak. Additionally, Azure AD Kerberos tickets for cloud resources (e.g., Azure Files) can be targeted. Always treat synced service accounts as high-risk.
4. What is the best defense against Kerberoasting?
Group Managed Service Accounts (gMSAs) are the gold standard. They eliminate the human element—passwords are complex, random, and automatically rotated. Combine gMSAs with strict monitoring (Event ID 4769) and least-privilege policies for a robust defense.
5. How often should I rotate service account passwords?
For standard user-created service accounts, rotate every 90–180 days. For gMSAs, rotation is automatic (default 30 days). However, rotation alone doesn’t protect against Kerberoasting if the password is weak when requested. The key is password complexity combined with rotation.
6. Is Kerberoasting only a Windows/AD attack?
Primarily, yes, because Kerberos is the default in AD. However, any system using Kerberos authentication (e.g., Linux with MIT Kerberos, Samba AD) can be vulnerable if service principal names and weak passwords exist. The attack methodology is protocol-agnostic.
7. Can Kerberoasting be prevented by disabling Kerberos?
No. Disabling Kerberos would break nearly all enterprise authentication. The protocol is secure by design; the vulnerability lies in weak service account passwords and lack of monitoring. Focus on hardening the accounts, not the protocol.
---
Conclusion: Strengthen Your Defenses with Expert Guidance
Kerberoasting is not a theoretical threat—it is a proven, practical attack that adversaries use every day to compromise business networks. In 2026, the attack is more accessible than ever, thanks to AI-assisted cracking, cross-forest exploitation, and even crimeware-as-a-service. Yet, the defenses are equally well-understood: strong service account hygiene, managed accounts, vigilant monitoring, and least-privilege architecture.
The organizations that survive—and thrive—are those that take a proactive stance. They don’t wait for an incident to audit their SPNs. They don’t assume their service accounts are safe because they’re “internal.” They invest in detection, response, and continuous improvement.
If your team needs help assessing your Kerberoasting risk, implementing gMSAs, or tuning your SIEM for credential theft, consider partnering with ZoeSquad. Their expertise in IT remediation and Active Directory security can help you close the gaps before attackers exploit them. In a landscape where the next credential heist could be just a ticket request away, the best defense is a prepared one.
Don’t let Kerberoasting be the silent breach that costs you everything. Act now.