Separating the Stages of Kerberoasting

An ordinary domain account discovers service principal names associated with other accounts. Separating the stages of Kerberoasting prevents that list from becoming an unsupported claim of compromise. The path from a service identity to usable access contains several different r…

An ordinary domain account discovers service principal names associated with other accounts. Separating the stages of Kerberoasting prevents that list from becoming an unsupported claim of compromise. The path from a service identity to usable access contains several different results, and each can stop short. We will follow the SPN-linked account, the requested service ticket, the offline test, and the access a recovered credential actually supports.

The useful question isn’t whether a tool can display those accounts. It’s whether an account with a service principal name, or SPN, can lead to service-ticket material that you’re authorized to test offline. You also need to know what that material would prove, what it wouldn’t prove, and how the result should influence your next decision.

This lesson stays focused on the connection between SPN enumeration, service-ticket requests, and offline password guessing. Ticket forgery and other forms of credential abuse are separate subjects. Here, you’re examining a normal Kerberos function and asking whether the password protecting a service account creates an avoidable risk.

Before testing, establish the boundaries. Identify the authorized domain, the systems included in the lab, your current account, and the specific account or service you’re evaluating. Record what access you already have. If your current account can only enumerate the directory, don’t write as though you’ve compromised a service account. Your baseline is simply an authenticated identity with certain observable permissions.

Now make a prediction. If an account has an appropriate SPN and your current identity can request a service ticket for that service, you expect to receive ticket material suitable for authorized offline analysis. If no relevant SPN exists, the request can’t be formed around that service identity. If a ticket is returned but no candidate password succeeds, you’ve shown that ticket retrieval was possible. You haven’t shown that the service account password is recoverable within your available time and resources.

That distinction turns enumeration into a decision rather than a collection exercise. You aren’t choosing Kerberoasting merely because you remember a command. You’re choosing it because the observed identity configuration supports a specific hypothesis, and because a bounded test can either strengthen or weaken that hypothesis. Your notes should preserve the prediction before the result, not reconstruct it afterward.

To understand the mechanism, start with the role of the SPN. In Active Directory, an SPN identifies an instance of a service. It connects a service name to the account under which that service identity is registered. An account associated with an SPN is therefore interesting because Kerberos clients need a way to identify the service for which they’re requesting access.

Kerberos authentication in an Active Directory domain involves a Key Distribution Center, commonly provided through the domain controller. After a domain user has an appropriate Kerberos authentication context, that user can request a service ticket for a named service. The service-ticket exchange is often called the Ticket Granting Service exchange, and the resulting ticket is commonly described as a TGS ticket.

This request is not inherently evidence of malicious behavior. Requesting service tickets is part of normal Kerberos operation. Kerberoasting abuses the fact that ticket material associated with an SPN can be collected and analyzed offline in an attempt to recover the service account’s password. The protocol operation can be legitimate while the password protecting the associated account is still too weak to withstand guessing.

The critical relationship is between the service ticket and the service account’s credential. Part of the returned ticket is protected using key material associated with the account represented by the SPN. An authorized tester can preserve the relevant ticket representation and try candidate passwords offline. Each candidate is used to test whether it produces the expected cryptographic result. A matching candidate indicates that the password guess is consistent with the captured material.

People often call the exported ticket representation a hash, but that shorthand can hide what happened. You didn’t retrieve the account’s cleartext password from the domain controller. You requested a service ticket through Kerberos, extracted material from that response, and obtained something against which password candidates may be checked. Keeping those stages separate makes your explanation more accurate and your troubleshooting much easier.

Offline testing changes the risk because the guesses don’t require a new authentication request to the domain for every candidate. Once the ticket material has been collected, analysis can continue away from the domain controller. That doesn’t guarantee recovery. It means the practical resistance now depends heavily on the service account password and on the candidate set, time, and computing resources available to the tester.

A weak or predictable password may appear quickly in a relevant candidate set. A long, randomly generated service-account password may make the same captured material impractical to crack. Two accounts can therefore expose service tickets through the same normal Kerberos behavior while presenting very different password-recovery risks. The ticket request establishes that offline testing is possible. Password strength largely determines whether that opportunity becomes a recovered credential.

Suppose your authorized lab contains two SPN-associated accounts. One runs an application service under a human-managed account with a password based on the application name. The other uses a long, randomly generated password. You request valid service tickets for both and preserve both results. A targeted candidate set recovers the first password but not the second.

You haven’t proved that the second account is uncrackable. You’ve proved that your permitted test, using its recorded candidates and resources, did not recover it. You also haven’t proved that the first account can access every system in the domain. You’ve recovered a credential candidate for one account. The account’s actual permissions, service relationships, and usable access still require separate validation.

This is why positive-looking output isn’t a verdict. An SPN listing proves that the directory returned an SPN-associated object. A successful ticket request proves that your context could request ticket material for the named service. An offline match supports recovery of a candidate password. None of those observations, by itself, proves administrative control, lateral movement, or completion of an attack chain.

Apply the technique with a narrow workflow. Begin by preserving the identity and domain context from which you’re working. Enumerate for relevant SPNs and record the account-to-service associations you actually observe. Choose one justified target rather than immediately collecting everything. Request the corresponding service ticket, retain the meaningful output, and verify that what you captured is in the expected form for offline analysis.

Then conduct only the offline password test allowed by your lab authorization and rules. Record the candidate source, any transformations you deliberately permitted, the start and end state, and whether a candidate matched. If one does, validate the credential carefully against an authorized service where doing so answers a legitimate assessment question. A successful offline match should not become an excuse to try the credential indiscriminately across unrelated systems.

Manual understanding matters even when a training tool automates several of these actions. You should still be able to explain which identity performed the enumeration, which account owned the SPN, which service ticket was requested, what material was exported, and what offline test produced the result. Otherwise, a convenient tool can leave you with output that you can neither validate nor defend in a report.

The ticket request uses a normal Kerberos function. The password risk concerns suitable ticket material and whether offline testing can recover the account’s secret. An obtained ticket, a recovered password, and a permitted action under that account must not be reported as the same event.

Now consider an unsuccessful first attempt. Your enumeration shows what appears to be an SPN-associated account, but your ticket request returns an error or produces no usable offline material. Don’t jump directly to the conclusion that Kerberoasting is impossible. First identify which prerequisite you observed and which one you merely assumed.

Did the directory query return the exact SPN you used, or did you copy an account name and infer the service identifier? Are you operating in the expected domain and user context? Does your current Kerberos context exist and correspond to the identity in your notes?

Did the request reach the intended domain service? Did the tool parse the returned data, or are you treating a display problem as a protocol failure? These are different failure points.

Choose a lower-impact check that isolates one of them. Confirm the exact SPN and its associated account. Confirm your current domain identity.

Confirm that the relevant domain service is reachable in the authorized environment. Recheck the captured error rather than relying on a summary line. Then alter only the assumption that the evidence contradicted and repeat the bounded request.

Suppose the first request used a convenient service name that wasn’t the exact SPN stored in the directory. The failure doesn’t refute the broader Kerberoasting hypothesis. It shows that the requested identifier didn’t match the observed configuration. After recording that failed request, you use the exact enumerated SPN and receive a service ticket. Your corrected conclusion is specific: the first attempt failed because the request was built from an assumed identifier, while the second was supported by the directory evidence.

A different failure occurs when you obtain valid offline material but recover no password. Repeating the ticket request won’t make the password weaker. Check whether the offline format was identified correctly, whether the captured material was complete, and whether the password candidates were relevant to the authorized test. If those conditions hold, preserve the negative result. It may indicate that the account resisted that particular guessing effort, not that the ticket was invalid or the account was immune to every possible attempt.

Failed observations have evidentiary value when you preserve their context. They can eliminate an incorrect SPN, expose a domain mismatch, reveal an execution-context problem, or show that a particular candidate set was ineffective. Randomly switching tools erases that reasoning. Changing one assumption at a time leaves you with an explanation another technically competent person can follow.

For the ticket request, retain the exact request or command, the execution context, and the meaningful response. Your evidence should make clear which service was requested and whether usable ticket material was obtained. A screenshot may support the record where required, but it shouldn’t replace reproducible text, commands, or requests. A reviewer needs enough context to distinguish a genuine service-ticket result from an unlabeled block of output.

For offline testing, document the material’s origin, the authorized candidate strategy, the tool or method used, and the result. If a password is recovered, protect it in accordance with the assessment’s handling requirements. The report can establish the finding without carelessly exposing a reusable secret. If no password is recovered, say exactly that. Don’t silently discard the attempt or convert a time-limited failure into a claim that the password is secure.

Your final explanation should connect cause to consequence. An SPN-associated service account allowed an authenticated domain user to request service-ticket material. That material permitted offline password guessing.

A weak password was recovered, or the tested password resisted the recorded effort. If recovery succeeded, explain the access that was actually validated and why that access matters. Don’t claim permissions you never tested.

The next penetration-testing decision follows the evidence. A recovered credential may justify carefully validating the account’s authorized service access and actual privileges. A ticket that resists your permitted offline test may push you toward another evidence-supported path rather than endless guessing. An absence of suitable SPNs removes the immediate basis for this technique, though it says nothing universal about every other Active Directory risk.

In the lab, the original list of SPNs is therefore only a starting observation. The justified chain is narrower and stronger. Associate a specific SPN with an account, request the corresponding service ticket, preserve offline-testable material, evaluate it within the permitted bounds, and validate only the access that the result supports. Each link answers a different question, and your report should keep those answers distinct.

Kerberoasting starts from an SPN-linked account and a requested service ticket, while password recovery and resulting access remain separate transitions. Before reaching for a tool, answer this: Which SPN-linked account produced the service ticket, and have password recovery and resulting access been validated as separate steps? The matching study reference keeps these review points together for later practice. This lesson was produced by Bare Metal Cyber dot com.

Separating the Stages of Kerberoasting
Broadcast by