Detecting Kerberoasting using Windows Event ID 4769 analysis

Latest Comments

No comments to show.
Abstract security operations dashboard showing Kerberos event analysis with subtle gold and purple highlights

Kerberoasting remains one of the more practical credential attack paths in Active Directory environments because it targets service accounts rather than interactive users. The attacker does not need to break encryption in real time. Instead, they request service tickets for accounts with Service Principal Names, then work offline against the ticket material. That makes the detection problem less about blocking a single action and more about spotting unusual service ticket request patterns early enough to investigate.

For defenders, Windows Event ID 4769 is the most useful starting point. It records Kerberos service ticket requests, which means it gives you visibility into who requested a ticket, for which service, from which source, and with which encryption type. In practice, that is enough to build a useful detection layer for Kerberoasting, especially when you combine it with baseline analysis and a small amount of correlation. If you already monitor other identity abuse patterns, such as Kerberos and NTLM abuse in enterprise environments, 4769 analysis fits naturally into the same detection stack.

Key takeaways

  • Event ID 4769 is the key Windows log for spotting Kerberoasting because it shows service ticket requests, source context, and encryption type.
  • The strongest detection patterns are high-volume requests, many distinct service principals, and suspicious use of legacy encryption such as RC4.
  • False positives usually come from management hosts, service accounts, and scheduled jobs, so baseline those sources before you tune alerts.
  • Correlate 4769 with 4768, 4770, and endpoint telemetry to confirm whether the activity matches normal authentication behaviour.
  • Reducing RC4 exposure, tightening service account hygiene, and limiting SPN sprawl all make Kerberoasting harder to carry out.

What Kerberoasting is and why Event ID 4769 matters

Kerberoasting is an Active Directory attack technique where an authenticated user requests Kerberos service tickets for one or more service accounts. Those tickets are then taken offline and analysed for weak passwords or weakly protected service principals. The key point for defenders is that the request itself is legitimate Kerberos behaviour. The malicious part is the volume, breadth, or context of the requests.

That is why Event ID 4769 matters. It is generated when a client requests a service ticket from the Key Distribution Centre. Unlike a generic authentication failure, 4769 tells you which service was targeted and what encryption was used. Those two details are often enough to separate normal application traffic from suspicious enumeration. If you are already using a broader identity detection programme, it is worth treating 4769 as one of the core telemetry sources alongside logon and directory events.

From a MITRE ATT&CK perspective, Kerberoasting sits in the credential access and lateral movement space, because it is usually a precursor to privilege escalation or deeper domain compromise. In a small team, the practical objective is not perfect attribution. It is to identify unusual service ticket harvesting before it becomes a password cracking exercise.

Understanding Event ID 4769 fields for detection

To make 4769 useful, you need to understand the fields that matter. The exact field names vary a little depending on whether you are reading raw Windows Event Logs, forwarding into a SIEM, or normalising through an agent, but the same core data is present.

The most important fields are the service name, account name, client address, and ticket encryption type. The service name identifies the target service principal. The account name tells you which user or computer requested the ticket. The client address gives you the source host, which is useful for spotting one workstation requesting tickets for many services. The ticket encryption type tells you how the ticket was encrypted, which is often the strongest signal for Kerberoasting risk.

In many environments, the ticket encryption type is where the first useful triage decision happens. Values such as 0x17, 0x12, and 0x18 are commonly discussed because they map to different Kerberos encryption algorithms. In simple terms, 0x17 is associated with RC4-HMAC, which is older and often more attractive to attackers because it can be easier to work with offline. 0x12 is associated with AES256, and 0x18 is associated with AES256-CTS-HMAC-SHA1-96 in many Windows contexts. The exact interpretation can depend on your environment and logging format, so it is better to validate the mapping in your own telemetry before you build hard rules around it.

A useful operational rule is this: do not alert only on one encryption type. Alert on suspicious combinations of volume, service diversity, and encryption type. A single RC4 ticket request is not enough. A burst of RC4 requests for many service accounts from one source host is much more interesting.

What suspicious Kerberoasting activity looks like in 4769 data

The most obvious pattern is high-volume service ticket requests from a single host or user. In a normal environment, a workstation may request tickets for a handful of services as a user opens applications, accesses file shares, or authenticates to internal systems. Kerberoasting activity tends to look broader and more mechanical. You may see one account requesting tickets for many service principals in a short time window, often with little sign of corresponding application use.

Another common pattern is requests for many different service principals in a short period. This is especially suspicious when the services are unrelated, such as database services, application pools, and legacy line-of-business systems all being requested from the same source. That breadth is often a better indicator than raw count alone. A single busy application server can generate a lot of 4769 events, but it usually does so against a stable and predictable set of services.

Look for clustering as well. If the same source host requests tickets for multiple service accounts across different departments or business units, that is worth investigating. In a small UK SME, where infrastructure is often simpler than in a large enterprise, the normal pattern is usually easier to define. That can make anomalies stand out more clearly, provided you have enough baseline data.

How to distinguish Kerberoasting from normal Kerberos traffic

The main challenge is avoiding false positives. Many legitimate systems generate a lot of 4769 events. Admin tools, service accounts, scheduled jobs, backup software, monitoring agents, and application pools can all produce dense ticket activity. The trick is to distinguish expected operational noise from unusual breadth or timing.

Start by baselining known service accounts and management hosts. For example, a jump server used by administrators may legitimately request tickets for many systems. A monitoring platform may request tickets for dozens of services every few minutes. Scheduled jobs may also create regular bursts at predictable times. Those patterns should be documented and, where appropriate, allowlisted or thresholded differently.

Encryption choice also changes the signal. If you still have legacy services that negotiate RC4, you will see more 0x17 traffic than you would like. That does not automatically mean Kerberoasting is underway, but it does increase the value of monitoring. If you can reduce RC4 exposure over time, the remaining RC4 traffic becomes more interesting. This is one of the reasons service account hygiene and encryption policy matter together.

It is also worth checking whether the source is a user workstation, a server, or a service account. A workstation requesting tickets for many service principals is often more suspicious than a server doing the same thing, because servers usually have a narrower role. If the source is a service account, ask whether that account is meant to perform discovery or orchestration. If not, the behaviour deserves closer scrutiny.

Detection logic you can implement in a SIEM

In Microsoft Sentinel, KQL is usually the most practical way to start. The exact table depends on your ingestion path, but many teams work with SecurityEvent or a custom WindowsEvent table. The simplest useful logic is to count distinct service names per source host and user over a short time window, then flag unusually high values.

SecurityEvent
| where EventID == 4769
| summarize TicketCount = count(), DistinctServices = dcount(ServiceName)
    by bin(TimeGenerated, 15m), Account, ClientAddress
| where DistinctServices > 10 or TicketCount > 25

That is only a starting point. In practice, you will want to add filters for known service accounts, known management hosts, and known noisy applications. You may also want to break out RC4 requests separately:

SecurityEvent
| where EventID == 4769
| where TicketEncryptionType in ("0x17", "0x18")
| summarize RC4Tickets = count(), DistinctServices = dcount(ServiceName)
    by bin(TimeGenerated, 30m), Account, ClientAddress
| where RC4Tickets > 5 and DistinctServices > 3

For Splunk-style logic, the same idea applies. Group by source, user, and time window, then count distinct service principals and filter on suspicious encryption types. If you are building detections as code, a Sigma rule can express the same logic in a portable way, although you will still need backend-specific tuning for field names and aggregation. If you are already using Sigma for other Windows detections, such as building SIEM detections using Sigma rules, Kerberoasting is a good candidate for the same workflow.

The main implementation point is to avoid a binary rule that fires on every RC4 ticket. That approach usually creates too much noise. A better pattern is a correlation rule that combines ticket encryption type, service diversity, and source rarity.

Reducing false positives in Event ID 4769 detections

False positives are usually caused by predictable infrastructure. The first control is allowlisting, but it should be used carefully. Allowlist known service accounts and management hosts only after you have verified their behaviour over time. If you allowlist too early, you may hide the very activity you are trying to detect.

Threshold tuning matters as well. A 15-minute window may be appropriate in a busy environment, but a smaller SME with fewer servers may benefit from a one-hour window because the baseline is lower and the signal is easier to see. Conversely, a high-volume environment may need per-subnet or per-application thresholds rather than a single global rule.

It is also worth separating interactive users from service identities. A user account requesting a small number of tickets for a few services may be normal. A service account requesting tickets for many unrelated services from a workstation is more unusual. If your SIEM supports enrichment, add asset role, owner, and criticality so analysts can see whether the source is a server, a jump box, or a standard endpoint.

What to check alongside 4769 for stronger confidence

Event ID 4769 is useful, but it should not be treated in isolation. Correlating with 4768 and 4770 can help you understand whether the activity is part of a normal authentication sequence or something more unusual. 4768 shows ticket-granting ticket requests, while 4770 relates to ticket renewals. If 4769 activity appears without the expected surrounding authentication pattern, that can strengthen suspicion.

Domain controller logon activity can also help. If a source host is generating many 4769 events but has little corresponding user activity, that is worth a closer look. Endpoint telemetry is equally valuable. Process creation logs, EDR telemetry, and network connections can tell you whether the source host is running administrative tools, scripts, or unusual binaries at the same time as the ticket requests.

For a broader identity investigation, it can help to compare the pattern with other credential abuse detections. If you already hunt for credential theft and misuse patterns, you can reuse the same investigative logic: identify the source, confirm the account context, and check whether the activity aligns with the host’s normal role.

Hardening measures that reduce Kerberoasting exposure

Detection is only half the job. Reducing exposure makes the detection problem easier. One of the most effective steps is to reduce or disable RC4 where feasible. If your domain and applications support stronger Kerberos encryption, moving away from legacy algorithms reduces the usefulness of captured tickets. This should be tested carefully because older applications may still depend on legacy settings.

Service account hygiene is equally important. Use strong, unique passwords for service accounts, and review whether each service principal is still needed. SPN sprawl creates unnecessary attack surface because every extra service principal is another potential target. If you can consolidate services or move them to managed identities or gMSA-style patterns where appropriate, you reduce the number of credentials that can be roasted.

It also helps to review privilege. Service accounts should have the minimum rights needed for their role. If a service account has excessive domain or local administrator privileges, Kerberoasting becomes more damaging because a cracked password has a larger blast radius. This is a good place to align with least privilege work already in progress, including least privilege access using IAM and RBAC principles.

Investigation workflow when a 4769 pattern looks suspicious

When a 4769 pattern looks unusual, the first question is whether the source and account make sense together. Ask who owns the source host, what role it performs, and whether it is expected to request tickets for those services. Then check whether the ticket requests line up with a known job, application deployment, or admin activity window.

Next, review the service principals involved. Are they business-critical, legacy, or rarely used? Are they all on the same server, or spread across multiple systems? A broad spread across unrelated services is more concerning than repeated requests for a single application.

Preserve the evidence before you make changes. Export the relevant 4769 events, the surrounding 4768 and 4770 records, any correlated endpoint telemetry, and the asset metadata for the source host. If your environment supports it, capture the time window in UTC and local time so you can align with user reports and change records later. For a small team, a simple case note with timestamps, hostnames, account names, and ticket types is often enough to keep the investigation organised.

If you suspect a real compromise, do not jump straight to broad remediation without understanding the scope. A service account password reset may be appropriate, but only after you have identified the affected services and any dependencies. In many cases, the immediate goal is to contain the source, preserve evidence, and determine whether the activity was a test, a misconfiguration, or an actual attack.

Practical monitoring checklist for small security teams

A workable minimum setup is straightforward. Collect 4769 events from all domain controllers, retain enough history to compare current activity with prior weeks, and normalise the fields you need for analysis. At a minimum, you want account name, service name, client address, ticket encryption type, and timestamp.

Build one alert for high-volume distinct service requests from a single source, and a second alert for suspicious encryption types combined with service diversity. Add exclusions for known management hosts and service accounts only after validation. Review alert volume weekly at first, then monthly once the rule is stable.

Over time, tune the detection using real incidents and benign cases. If the rule is too noisy, narrow the time window, increase the distinct service threshold, or add asset role context. If it is too quiet, lower the threshold or add a second condition for rare source hosts. This kind of iterative tuning is part of normal detection engineering, not a sign that the rule is failing.

Finally, document what good looks like. A short baseline note for each major service account or management host is often enough. That makes future triage faster and helps new analysts understand why a given burst of 4769 activity is expected rather than suspicious.

Kerberoasting detection is rarely about one perfect indicator. It is about combining ticket request volume, service diversity, encryption type, and source context into a pattern that stands out from normal Kerberos traffic. If you get those pieces right, Event ID 4769 becomes a practical and high-value source of identity telemetry rather than just another noisy log stream.

If you want help turning that into a working detection rule set, or you need support aligning identity monitoring with a broader control framework, you can speak to a consultant about a pragmatic next step.

Frequently asked questions

What does Event ID 4769 mean in Windows?

Event ID 4769 records a Kerberos service ticket request. It is useful for detection because it shows which account requested a ticket, which service was targeted, the source address, and the ticket encryption type.

How do I identify Kerberoasting from Kerberos service ticket activity?

Look for unusual patterns such as many service ticket requests from one host or user, requests for many different service principals in a short period, and repeated use of legacy encryption types such as RC4. Correlate the activity with 4768, 4770, and endpoint telemetry before escalating.

How do I check whether RC4 is disabled?

Check your domain and service account Kerberos settings, then validate the observed ticket encryption types in 4769 events. If you still see 0x17 traffic, some accounts or services are still negotiating RC4 somewhere in the environment.

Tags:

Comments are closed