skip to content

Your purple team Kerberoasted the forest and nothing fired — which observable can a detection actually build on?

level: seniorimportance: should knowfreq 42%

answer

  1. separate what is forced from what is chosen
  2. the KDC must issue the ticket
  3. tool, host, rate and cipher are all optional
  4. requests for user objects, not computer accounts
  5. state the false negatives out loud

basics

~20 s

Only one thing is forced: a domain controller must issue a service ticket for the targeted service account, recorded as a 4769. The encryption type, the tool, the source host and the request rate are all the adversary's choice, so detections built on them are optional to evade.

solid answer

~50 s

Split the artefacts into forced and optional. Forced: to harvest a service account's ticket the adversary must make the KDC issue one, so a domain-controller 4769 naming that service account and some requesting account always exists. Optional: requesting RC4 rather than accepting AES, requesting many accounts in a burst rather than one a week, running from a monitored Windows endpoint rather than a Linux host, and spawning a process at all — an in-process request writes no 4688 and no script-block record. So endpoint-side observables are contingent and the DC-side record is not. But the invariant record alone separates nothing, because normal workstations request service tickets constantly. The discriminator has to live inside 4769: tickets requested for service names that resolve to *user* objects carrying service principal names, rather than the computer accounts everyday traffic asks for, and fan-out of distinct such accounts per requester per window. That is the honest best available, and it is weak against one slow request.

go deeper

for a junior

Know that Kerberos service tickets are issued by a domain controller and that the request is what an adversary needs to attack a service account's password offline. Be able to say that tool names and file hashes are weak things to detect on.

for a middle

Explain the forced-versus-optional split with concrete examples: which artefact the protocol guarantees, and which ones — encryption type, request rate, source platform, process creation — the adversary chooses freely.

for a senior

Show that you find the invariant from the protocol and then still apply the separation test to it, proposing a discriminator inside the record and naming what it misses. Interviewers are listening for whether you oversell the coverage you just designed.

for a principal

Be ready to say what you do with a purple-team result like this: which estate change would create a separating field, what it costs, and how you keep a partial detection from being recorded as full coverage of the technique.

## The exercise A purple-team engineer harvested Kerberos service tickets for service accounts across the forest and reported that nothing fired. The productive question in the room is not whose fault the miss is. It is: **which record could ever have betrayed this, and which field inside it is the adversary forced to dirty?** ## Forced versus optional Work out what the behaviour cannot happen without. To attack a service account's password offline you need a ticket encrypted under that account's key. Only the KDC can issue one, and you must ask it for the specific service. Therefore, on every attempt, a domain controller writes a service-ticket record (Windows Security 4769) naming the target service account and whichever domain account asked. **That is the invariant.** Any domain user with a valid ticket-granting ticket can do the asking; there is no privileged step to catch. Now list what is *not* forced, because each is a detection people build and each is optional to evade: - **Encryption type.** Requesting RC4 (`0x17`) rather than accepting AES256 (`0x12`) makes the offline attack cheaper, so tooling historically asks for it. But it is a choice: an adversary can take the AES ticket and spend more compute. A rule on the encryption type detects a *preference*, not the behaviour. - **Volume and fan-out.** Enumerating every service principal name in the forest and requesting all of them in ninety seconds is convenient. Requesting one account per week from a normal user's workstation is equally effective and sits inside any baseline. - **The source host.** The request can come from any domain-joined machine — or from a non-Windows host on the network running an open-source toolkit, in which case no monitored Windows endpoint runs anything at all. - **A new process.** Even on Windows the request can be made in-process from a running application, so there is no process-creation record (native 4688 or Sysmon Event ID 1) and no new binary to hash. If the tooling is a script in an interpreter you have configured to log script text, you may get that instead — but that is a property of your endpoint configuration and of their tool choice, not of the technique. **Conclusion: everything on the endpoint is contingent; the domain controller's ticket record is not.** That is where the detection has to live, if one can live anywhere. ## The invariant alone is not a detection Having found the forced record, apply the separation test honestly. A domain controller writes these records continuously: every workstation requests service tickets to reach file shares, print services and applications. The presence of the record carries no information whatsoever, so the discriminator must be a relationship among its fields. Two are worth arguing about: 1. **What kind of object the ticket was for.** Ordinary traffic overwhelmingly asks for tickets on *computer* accounts — the host's own services. Ticket requests for service names that resolve to *user* objects carrying service principal names are a much smaller population, and those are precisely the accounts worth attacking, because their passwords are human-set and static. Comparing the requested service against a maintained list of SPN-bearing user accounts is the sharpest cut available inside the record. 2. **Fan-out per requester.** One client account requesting tickets for many *distinct* SPN-bearing user accounts within a short window is a shape that ordinary work rarely produces, because a given workstation talks to a handful of services repeatedly rather than to twenty different service accounts once each. ## Say the weaknesses out loud Both discriminators are defeatable and you should state how in the same breath, because a detection engineer who oversells coverage is the problem this exercise exists to expose. Fan-out logic misses a slow, single-target request entirely. The object-type cut depends on an accurate inventory of which user accounts carry service principal names, which drifts as the estate changes. And the encryption-type field, the one most rules reach for first, is worthless in a forest whose service accounts have never been re-keyed and therefore hold no AES key: there, RC4 is simply what the KDC issues, and the field's value is identical for the purple team and for every legitimate connection to those services. ## The shape of a good answer Name the invariant first, justify it from the protocol rather than from tooling, then list what the adversary is free to vary and show that each freedom kills a detection someone might propose. Finish with the discriminator you would actually build, its false-negative shape, and — if the estate's base rate leaves nothing that separates — the willingness to write that down rather than ship a rule that cannot match.

  • Why not simply alert on Ticket Encryption Type 0x17 in 4769 records?
    Because in a legacy forest whose service accounts were never re-keyed, RC4 is the encryption type the KDC issues for those accounts during entirely normal use, so the field's value is the same for the purple team and for every real client. It works only where AES is universal — which makes it a property of the estate, not of the technique, and it degrades silently as legacy accounts reappear.
  • The purple team ran it from a Linux host. What endpoint telemetry do you have?
    None. No process-creation record, no endpoint agent event, no script-block text, because nothing executed on a monitored Windows endpoint. Only the domain controller's ticket records exist. This is the cleanest demonstration that endpoint observables for this behaviour are contingent on the adversary's platform choice, while the KDC-side record is not.
  • How would a slow, single-target request defeat the fan-out logic you proposed?
    Requesting one service account's ticket from a normal user's workstation, once, sits inside every baseline: it is one record among the thousands that domain controller writes that hour, and the fan-out count never crosses a threshold. The correct move is to say the detection covers bulk harvesting and not targeted single requests, rather than describing it as coverage of the technique.

A burglar chooses the route, the tools and the hour, but cannot avoid the door opening. Detections built on the door survive the next tool; detections built on the toolmarks do not.

saying these in an interview costs you the question

  • Builds the detection on the attacker's tool name or hash
  • Assumes an RC4 ticket request is unavoidable
  • Expects endpoint process telemetry for a request made from Linux
  • Claims fan-out thresholds cover the technique
  • Presents a rate-based rule as complete coverage

context