Kerberos gets filed under authentication, but the protocol is a ticket distribution system. The password is used once, at the beginning, to prove possession of a key. After that, every access decision is made by presenting a ticket that was encrypted and signed by someone further up the chain.

That design is what makes single sign-on work. It is also what makes ticket theft so useful to an attacker: a ticket is a bearer credential, and the protocol has no way to ask whether the bearer is the entity it was issued to.

Principals, realms, and the KDC

A handful of names cover almost everything. A principal is an identity, written alice@CORP.EXAMPLE for a user or HTTP/web.corp.example@CORP.EXAMPLE for a service. The realm is the administrative domain, usually the DNS domain in uppercase. The KDC is the Key Distribution Center, which runs two logical services, the Authentication Service (AS) and the Ticket Granting Service (TGS); in Active Directory, every domain controller is a KDC.

The krbtgt account is special: its key encrypts ticket-granting tickets. It has no interactive logon, and its password is normally never used by a human. An SPN is a service principal name, the identifier a client asks for when it wants a ticket to a particular service.

The important structural point is that the KDC never talks to the service during a normal logon. It issues a ticket that the service can decrypt with a key it already shares with the KDC. Authentication is offline from the service’s perspective.

From password to key

Kerberos does not send the password. It converts it into a long-term key using a string-to-key function, then uses that key to encrypt a timestamp.

For AES in Active Directory, the conversion is PBKDF2-HMAC-SHA1 with 4096 iterations, salted with the realm and principal name. The result is an AES-128 or AES-256 key. RC4-HMAC uses a different, much cheaper derivation, which is one reason RC4 tickets are so much easier to attack offline.

The etype names are slightly misleading. aes256-cts-hmac-sha1-96 means AES-256 in CTS mode with an HMAC-SHA1-96 integrity check. It is still a reasonable choice, but the “SHA1” in the name is not a typo.

Because the key is derived from the password, changing the password changes the key. It does not, however, invalidate tickets that were already issued. A TGT is encrypted with the krbtgt key, not the user’s key, and the client’s copy of the session key lives in memory. Resetting a user’s password in response to an incident does not log them out of Kerberos. Only expiring the tickets, or resetting the key that protects them, does that.

The two-ticket flow

Every interactive logon uses the same sequence. The client talks to the AS once, then to the TGS for each service it needs.

client                        KDC (AS)            KDC (TGS)              service
  |                              |                    |                     |
  | AS-REQ                       |                    |                     |
  |  preauth: enc(timestamp)     |                    |                     |
  |----------------------------->|                    |                     |
  | AS-REP                       |                    |                     |
  |  TGT (encrypted with krbtgt) |                    |                     |
  |  session key (encrypted      |                    |                     |
  |  with client key)            |                    |                     |
  |<-----------------------------|                    |                     |
  |                              |                    |                     |
  | TGS-REQ: TGT + authenticator + SPN                |                     |
  |-------------------------------------------------->|                     |
  | TGS-REP: service ticket (encrypted with           |                     |
  |  service key) + service session key               |                     |
  |<--------------------------------------------------|                     |
  |                              |                    |                     |
  | AP-REQ: service ticket + authenticator            |                     |
  |------------------------------------------------------------------------>|
  | AP-REP: optional mutual authentication            |                     |
  |<------------------------------------------------------------------------|

The client cannot read its own TGT. The encrypted ticket blob is opaque to it. What the client holds is the TGT plus a session key, and that session key arrived encrypted under the client’s long-term key. The TGT is for the KDC; the session key is for proving to the KDC that the client is the same client that received the TGT.

The AS-REQ usually contains pre-authentication. The client encrypts a timestamp with its long-term key (PA-ENC-TIMESTAMP). The KDC decrypts it to verify that the client knows the key before issuing anything. Without pre-authentication, anyone can ask for a TGT for any principal and receive material encrypted with that principal’s key, which can then be attacked offline. That is AS-REP roasting, and it exists because some accounts are configured with “Do not require Kerberos preauthentication.”

The authenticator is what prevents replay. In the TGS-REQ and AP-REQ, the client encrypts a timestamp with the session key. The receiver checks the timestamp against its clock and keeps a cache of recently seen authenticators. The default tolerance in Active Directory is five minutes, which is why clock drift produces KRB_AP_ERR_SKEW and why NTP matters more than most people think.

What is inside a ticket

A ticket is an encrypted blob with a small plaintext header. The header names the client, the service, the ticket flags, and the session key’s encryption type. The encrypted part contains the session key, the client’s identity, the validity window, and the authorization data.

In Active Directory, that authorization data is the PAC: the user’s SID, the group SIDs, logon hours, and a set of checksums. The PAC has two signatures, one keyed with the service’s long-term key and one keyed with the krbtgt key. A service can verify the first; the second is supposed to let it detect a PAC that was forged or altered by someone who only knows the service key.

There is a gap here that matters later. Services generally do not call the KDC to validate every ticket. They decrypt the ticket with their own key, check the PAC signature, and proceed. The KDC is not consulted, because the whole point of the ticket is that it can be verified without one.

Service tickets and SPNs

The TGS-REQ names the service by its SPN. The KDC looks up which account owns that SPN, encrypts the service ticket with that account’s key, and returns it along with a fresh session key for the client and service.

This creates a direct relationship between an SPN and a credential. If an SPN is registered on a user account, the service ticket is encrypted with that user’s password-derived key. If it is registered on a computer account, it uses the machine account key, which rotates automatically. If it is registered on a group Managed Service Account, the key is 240 bytes of random data that rotates on a schedule.

That relationship is why SPN hygiene matters: every SPN points at an account whose key can decrypt tickets for that service.

Delegation models

Kerberos has three delegation models, and they all extend the same bearer-ticket problem.

Unconstrained delegation lets a service impersonate a user to any service in the domain. When a user authenticates to a service marked TRUSTED_FOR_DELEGATION, the KDC returns a forwardable copy of the user’s TGT alongside the service ticket, and the client passes it to the service. That service can then present the TGT anywhere. Compromise of such a service is equivalent to compromise of every user who has ever authenticated to it, including domain admins.

Constrained delegation limits the service to a fixed list of target SPNs. The service uses S4U2Self to obtain a ticket to itself on behalf of the user, then S4U2Proxy to exchange it for a ticket to an allowed target. The list is the control. If the list includes a service that itself has broad rights, the constraint is weaker than it looks.

Resource-based constrained delegation moves the control to the target. The target computer’s msDS-AllowedToActOnBehalfOfOtherIdentity attribute names who may impersonate to it. Anyone with write access to that attribute can grant themselves the right, which is why it shows up in privilege-escalation paths.

These are features with sharp edges, and they are worth auditing before an incident rather than during one.

Common attacks

Kerberoasting abuses the fact that any authenticated user can request a service ticket for any SPN. The ticket is encrypted with the service account’s key, and the requesting user can take it away and attack it offline. Service accounts with weak passwords and RC4 enabled fall quickly. AES-256 tickets are still attackable, just at a much higher cost per guess. Kerberoasting depends on a weak key, so the fix is to make the key unguessable: group Managed Service Accounts or long random passwords, and no RC4 tickets.

AS-REP roasting is the same idea at the AS. If an account does not require pre-authentication, an attacker can request a TGT for it and receive a blob encrypted with the account’s key, without proving anything. Those accounts are rare, but they are trivially findable and often forgotten.

Golden tickets are forged TGTs. The attacker needs the krbtgt key, usually obtained by replicating credentials from a domain controller (DCSync) after compromising a domain admin. With that key, they can mint a TGT for any user, with any SID, any group membership, and any lifetime. The KDC will accept it because the signature is valid. It will then issue real service tickets, properly encrypted with each service’s key, so the services see nothing unusual.

That last point is why golden tickets are so hard to detect. The service tickets are genuine. The only anomaly is that the TGT was never issued by the KDC, and most services have no way to know that. A forged TGT with a ten-year lifetime can sit in an environment for years if nobody looks at ticket metadata.

Silver tickets skip the KDC entirely. The attacker forges a service ticket using a service account or computer account key, sets the PAC to whatever groups they want, and presents it directly. The service decrypts it with its own key and, if it does not validate the KDC’s PAC signature, accepts it. Silver tickets are narrower than golden tickets, limited to one service, but they also survive a krbtgt reset, because the krbtgt key was never involved. Only rotating the service account’s key invalidates them.

Hardening the keys and privileges

Reset the krbtgt password twice, separated by at least one maximum ticket lifetime (ten hours by default in Active Directory), with domain controller replication completed in between. The first reset moves the old key into the “previous” slot, which is still accepted. The second reset removes it. Tickets minted with the original key stop working at the TGS once that key is gone. A single reset is not enough.

Rotate service account keys. Use gMSAs where possible, long random passwords where not, and stop putting SPNs on ordinary user accounts. A kerberoastable service account with a 12-character password is a liability regardless of how strong the domain password policy is.

Disable RC4. Every RC4 ticket is a much cheaper offline attack than its AES equivalent, and modern domains have no reason to issue them. Audit the exceptions before flipping the switch, because old appliances are usually the reason RC4 is still enabled.

Enable Kerberos armoring (FAST) where the domain supports it. It wraps the AS exchange in a key derived from the client’s machine account, which removes the easy offline capture that makes password guessing practical.

Privilege paths need the same treatment. Remove unconstrained delegation from anything that is not a tier-0 service. Audit constrained delegation target lists and resource-based delegation ACLs. Put privileged accounts in Protected Users, which among other things blocks delegation and restricts credential caching. Keep domain admins off workstations.

Monitoring helps, within limits. The useful events are 4768 (TGT issued), 4769 (service ticket issued), 4770 (TGT renewed), 4771 (pre-authentication failed), and 4662 (directory object access, which is where DCSync shows up). A golden ticket often appears as a 4769 with no matching 4768 for the same logon, or as a TGT with an implausible lifetime. A kerberoasting burst looks like many 4769 events with RC4 encryption for accounts that should be using AES. None of these is conclusive on its own, and all of them depend on logs from every domain controller being collected somewhere they can be correlated.

A canary account with an SPN and no real purpose is cheap and effective for kerberoasting. A fake privileged account with pre-authentication disabled and a known-bad password can serve the same role for AS-REP roasting. Golden tickets are harder to trap, but a TGT with a lifetime measured in years is not subtle if anyone is looking.

Why tickets remain the weak point

Kerberos does exactly what it says: it issues bearer tickets that are valid until they expire, and it delegates trust to anyone holding the right key. The difficulty is operational. A domain accumulates delegation settings, stale SPNs, legacy encryption types, and service accounts with passwords from 2011, and each of those is a place where the key is weaker than the protocol assumes.

The mental model worth keeping is simple. Authentication happens once, at the AS. Everything after that is possession. If an attacker gets possession of a key that can mint tickets, the distinction between a legitimate ticket and a forged one is a signature that most services never check with anyone. That is the design, and it is why the krbtgt key and the service account keys deserve the same protection as domain admin credentials.