Kerberos Internals: Principals, Tickets and the Authentication Exchange
How Kerberos authentication works in a Windows domain: the KDC and its two services, principals and SPNs, the structure of TGTs and service tickets, the six messages of the exchange, the keys that protect each of them and the protocol mechanics behind roasting and forged-ticket attacks, with the telemetry and hardening relevant to a defender.
Introduction
Kerberos is a network authentication protocol that lets two entities, a client and a service, prove their identities to each other across an untrusted network. Neither side has to send a password, and neither side has to trust the network.1 It achieves this through a trusted third party, the Key Distribution Center (KDC), and symmetric cryptography: every participant shares a long-term secret key with the KDC, and the KDC uses those keys to hand out short-lived session keys and tickets.
Public-key cryptography is not part of the base protocol. It appears only through extensions such as PKINIT, which Windows uses for smart card and Windows Hello for Business logons.
Kerberos is the default authentication protocol in Active Directory domains.
On Windows, the KDC runs on every domain controller, and the client side is
implemented by the Kerberos security support provider inside
lsass.exe.2
Kerberos structure
The KDC provides two logically separate services. Authentication therefore happens in two phases (Figure 1).1
flowchart TB
subgraph KDC["Key Distribution Center (KDC)"]
direction LR
AS["Authentication Service (AS)"]
TGS["Ticket Granting Service (TGS)"]
end
subgraph P1["Phase 1: initial authentication"]
TGT["Ticket Granting Ticket (TGT)"]
end
subgraph P2["Phase 2: access to a service"]
ST["Service Ticket (ST)"]
end
AS -->|"issues"| TGT
TGT -->|"presented to, checked for validity"| TGS
TGS -->|"issues"| ST
Figure 1. The two phases of Kerberos authentication.
- Phase 1, the Authentication Service (AS), handles initial authentication.
The client proves knowledge of its long-term key, and the AS issues a
Ticket Granting Ticket (TGT). The TGT is encrypted with the key of the
krbtgtaccount, which only the KDC knows, so only the KDC can read and verify it. - Phase 2, the Ticket Granting Service (TGS), handles access to services. The client presents its TGT, the TGS checks that it is valid, and it issues a Service Ticket (ST) for the requested service.
The separation means the user’s long-term key is needed only once per logon session, in phase 1. Every subsequent request for a service is authenticated with the TGT and its session key.
Kerberos principals
Every entity Kerberos can authenticate is a principal, and every principal
belongs to a realm, the administrative domain of a KDC. In Active Directory
the realm is the domain’s DNS name in upper case, for example CORP.EXAMPLE.COM.
Figure 2 shows the three kinds of principals in a realm.
flowchart TB
subgraph REALM["Kerberos realm"]
direction LR
subgraph U["User principals (UPN)"]
direction TB
u1["user1"]
u2["user2"]
u3["user3"]
end
subgraph S["Service principals (SPN)"]
direction TB
s1["ldap"]
s2["fileserver"]
s3["iis"]
end
subgraph H["Host principals"]
direction TB
h1["host1"]
h2["host2"]
end
end
Figure 2. User, service and host principals within a realm.
- User principals identify people, and in Active Directory also accounts
used by applications. They are written as a User Principal Name (UPN),
such as
alice@corp.example.com. - Service principals identify a service instance. They are written as a
Service Principal Name (SPN), such as
HTTP/web01.corp.example.comorMSSQLSvc/sql01.corp.example.com:1433.3 - Host principals identify computers. In Active Directory every computer
account has
HOST/<name>SPNs, which cover the built-in services running as the computer account.
A principal name follows the generic structure primary/instance@REALM:
| Component | Role | Example |
|---|---|---|
primary |
Identifies the identity (a user, or the service class) | alice, HTTP |
instance |
Optional, further qualifies the primary (for services, the host) | web01.corp.example.com |
REALM |
The Kerberos realm in which the authentication takes place | CORP.EXAMPLE.COM |
SPNs must be registered. A client asks for a ticket by SPN, and the KDC uses the SPN to find the account whose key will encrypt the ticket. A service must therefore register its SPNs in the
servicePrincipalNameattribute of the account it runs as. Without a registered SPN the KDC cannot issue tickets for it, and the client usually falls back to NTLM.3
Keys and tickets
Keys
Kerberos uses two kinds of keys:
| Key | Lifetime | Known by | Purpose |
|---|---|---|---|
| Client key | Long-term | Client, KDC | Derived from the user’s password; protects the AS exchange |
krbtgt key |
Long-term | KDC only | Encrypts and signs every TGT issued in the domain |
| Service key | Long-term | Service account, KDC | Derived from the service account’s password; encrypts service tickets |
| TGS session key | One TGT | Client, KDC | Protects the TGS exchange |
| Service session key | One service ticket | Client, service | Protects the AP exchange and, optionally, the following traffic |
The design rule is simple. Each ticket is encrypted with the long-term key of the party that must read it, and each ticket carries a session key that the KDC also gives to the party that must use it.
Ticket structure
TGTs and service tickets share the same structure. They differ only in the server they are issued for and in the key that encrypts them. The encrypted part of a ticket contains, among other fields:1
| Field | Content |
|---|---|
sname / realm (clear text) |
The server the ticket is for: krbtgt/REALM for a TGT, the service’s SPN for a service ticket |
flags |
Ticket options, such as forwardable, renewable or pre-authenticated |
key |
The session key shared between the client and that server |
crealm, cname |
The client’s realm and principal name |
authtime, starttime, endtime, renew-till |
Validity window of the ticket |
caddr |
Optional client addresses |
authorization-data |
In Active Directory, the Privilege Attribute Certificate (PAC) |
The PAC is a Microsoft extension that carries the authorization data of the client: its SID, the SIDs of its groups and other account information. It is signed by the KDC, so the service can rely on it without querying a domain controller.4
| TGT | Service ticket | |
|---|---|---|
| Issued by | AS | TGS |
| Server name | krbtgt/REALM |
SPN of the service |
| Encrypted with | krbtgt key |
Service account key |
| Session key inside | TGS session key | Service session key |
| Used to | Request service tickets from the TGS | Authenticate to the service |
Neither ticket is ever readable by the client. The client stores it and presents it, but only the KDC (for a TGT) or the service (for a service ticket) can decrypt it. Default ticket lifetimes in Active Directory are controlled by the domain Kerberos policy; a TGT is valid for 10 hours and renewable for 7 days by default.5
The authentication exchange
A complete authentication consists of three exchanges, AS, TGS and AP, each made of a request and a reply (Figure 3).
sequenceDiagram
autonumber
participant C as Client
participant AS as Authentication Service
participant TGS as Ticket Granting Service
participant S as Service
C->>AS: AS-REQ: timestamp encrypted with the client key
Note over AS: Decrypts and validates the timestamp
AS-->>C: AS-REP: TGT + TGS session key
C->>TGS: TGS-REQ: TGT + authenticator, for the SPN of the service
Note over TGS: Decrypts the TGT with the krbtgt key,<br/>validates the authenticator
TGS-->>C: TGS-REP: service ticket + service session key
C->>S: AP-REQ: service ticket + authenticator
Note over S: Decrypts the ticket with the service key,<br/>validates the authenticator
opt Mutual authentication
S-->>C: AP-REP: timestamp encrypted with the service session key
end
Figure 3. The Kerberos authentication exchange.
The table below summarizes what travels in each message and which key protects it.
| # | Message | Sent | Processing on reception |
|---|---|---|---|
| 1 | AS-REQ (client → AS) | Timestamp encrypted with the client key (pre-authentication data) | The KDC looks up the user’s key in its database and decrypts the timestamp, which proves the client’s identity and prevents replays |
| 2 | AS-REP (AS → client) | TGT encrypted with the krbtgt key; TGS session key encrypted with the client key |
The client decrypts the TGS session key with its own key. The TGT stays sealed, because the client cannot read it |
| 3 | TGS-REQ (client → TGS) | TGT, as is; authenticator encrypted with the TGS session key; the SPN of the target service | The TGS decrypts the TGT with the krbtgt key and extracts the TGS session key, then uses it to decrypt and validate the authenticator |
| 4 | TGS-REP (TGS → client) | Service ticket encrypted with the service key; service session key encrypted with the TGS session key | The client decrypts the service session key. The service ticket stays sealed |
| 5 | AP-REQ (client → service) | Service ticket, as is; authenticator encrypted with the service session key | The service decrypts the ticket offline with its own key, extracts the service session key and uses it to validate the authenticator |
| 6 | AP-REP (service → client), optional | Timestamp encrypted with the service session key | The client verifies that the service is genuine (mutual authentication) |
Two properties follow from this flow:
- The service never contacts the KDC. It validates the AP-REQ offline, using only its own key. This makes Kerberos scale, and it is also why the confidentiality of service keys matters so much.
- Timestamps limit replays. Authenticators and pre-authentication data contain a timestamp, and the receiver rejects messages outside a small window. An attacker who captures a message and replays it later finds that the time has already moved on. Clocks must therefore be synchronized: the default maximum tolerance in Active Directory is 5 minutes.6
Pre-authentication
The encrypted timestamp in the AS-REQ is called pre-authentication. Without it, anyone could send an AS-REQ on behalf of a user and receive an AS-REP containing data encrypted with that user’s key, which can then be attacked offline to recover the password. Active Directory requires pre-authentication by default. An account flagged with “Do not require Kerberos preauthentication” is exposed to exactly this attack, known as AS-REP roasting.7
Kerberos on Windows
On a domain-joined client, the Kerberos SSP runs inside lsass.exe. It
performs the exchanges on behalf of the logged-on user and keeps the tickets
in a cache tied to the logon session. The KDC runs as part of lsass.exe
on each domain controller, and reads principal keys from the Active Directory
database.2
Experiment: inspecting tickets and SPNs
klistshows the ticket cache of the current logon session, including the server name, the encryption type, the flags and the validity window of each ticket:8
1 2 klist # service tickets and the TGT in the cache klist tgt # details of the current TGT
setspnlists the SPNs registered on an account:9
1 setspn -L <account>
Attack techniques
The design choices described above have consequences that attackers exploit. This section describes them at the level of the protocol, together with the telemetry and the mitigations that apply to each one.
User enumeration
User enumeration is possible whenever an authentication mechanism answers differently for valid and invalid user names. The Kerberos AS exchange does exactly that: the KDC must look the client principal up in its database before it can ask for pre-authentication or issue a TGT, and its reply reveals the result of that lookup (Figure 4).1 An unauthenticated client that can reach a domain controller on port 88 can therefore test candidate user names without knowing any password. MITRE ATT&CK catalogues the discovery of domain accounts as T1087.002.10
sequenceDiagram
participant C as Client
participant AS as Authentication Service
rect rgba(160, 60, 60, 0.15)
Note over C,AS: Account with pre-authentication disabled
C->>AS: AS-REQ for a valid user name, no pre-authentication data
AS-->>C: AS-REP with a TGT: the account exists
end
rect rgba(160, 140, 40, 0.15)
Note over C,AS: Account with pre-authentication required (default)
C->>AS: AS-REQ, no pre-authentication data
alt The principal exists
AS-->>C: KRB-ERROR KDC_ERR_PREAUTH_REQUIRED (25)
else The principal does not exist
AS-->>C: KRB-ERROR KDC_ERR_C_PRINCIPAL_UNKNOWN (6)
end
end
Figure 4. How the replies to an AS-REQ reveal whether a user name exists.
| KDC reply to an AS-REQ without pre-authentication | Meaning |
|---|---|
| AS-REP with a TGT | The account exists and does not require pre-authentication: it is also exposed to AS-REP roasting |
KDC_ERR_PREAUTH_REQUIRED (25) |
The account exists and requires pre-authentication |
KDC_ERR_CLIENT_REVOKED (18) |
The account exists but is disabled, locked out or expired |
KDC_ERR_C_PRINCIPAL_UNKNOWN (6) |
No such principal in the realm |
The KDC_ERR_PREAUTH_REQUIRED error is the normal first step of every
Kerberos logon, so the KDC cannot suppress it without breaking the protocol.
Enumeration is not a goal in itself: it produces the list of valid accounts
that password spraying (T1110.003) then uses, trying one or two common
passwords against many accounts to stay below the lockout
threshold.11
Telemetry. On the domain controller, an AS-REQ for a non-existent
principal is logged as a failed 4768 with result code 0x6. A burst of
4768 failures with code 0x6 from a single client address, for many
different account names, is a strong indicator of enumeration. The
KDC_ERR_PREAUTH_REQUIRED replies, being part of normal logons, are not a
useful signal on their own; the spraying phase that usually follows shows up
as 4771 events with failure code 0x18 (wrong password) across many
accounts from the same source.1213
Mitigations. Enumeration itself cannot be fully prevented, because it is a property of the protocol, so the defences aim at limiting its value:
- require pre-authentication on every account, so that a valid user name alone does not yield a TGT;
- enforce strong passwords, ideally with a banned-password list, so that the accounts discovered resist spraying;
- configure an account lockout threshold and lockout duration, which do not stop enumeration (no password is tried) but limit the guesses per account in the spraying phase;14
- restrict Kerberos traffic to domain controllers from untrusted network
segments, and alert on the
4768/4771patterns described above.
AS-REP roasting
AS-REP roasting (MITRE ATT&CK T1558.004) is the direct consequence of
disabling pre-authentication. The attacker sends an AS-REQ with only the name
of a target account. If that account has the DONT_REQ_PREAUTH flag, the KDC
does not require proof of knowledge of the password and returns an AS-REP
(Figure 5).7
sequenceDiagram
participant A as Attacker
participant AS as Authentication Service
participant O as Offline cracking
A->>AS: AS-REQ for an account with DONT_REQ_PREAUTH, no pre-authentication
AS-->>A: AS-REP: TGT + response part encrypted with the client key
A->>O: Encrypted response part
loop Password candidates
O->>O: Derive a client key and test the decryption
end
O-->>A: Password / client key if a candidate matches
Figure 5. AS-REP roasting turns a KDC reply into an offline password test.
The crackable value is not the TGT itself. The TGT remains encrypted with
the krbtgt key; the useful value is the part of the AS-REP encrypted with the
target user’s long-term key. A password candidate can be converted into a key
and tested locally against that ciphertext. The domain controller sees only
the original request, not the following guesses, so account lockout does not
limit the attack. Recovering the key compromises that account; it does not by
itself reveal the krbtgt key or permit arbitrary TGTs to be forged.
Telemetry. A successful TGT request with Pre-Authentication Type 0 is
recorded in event 4768. In a correctly configured domain this should be rare
and can be correlated with the client address and the inventory of accounts
that have DONT_REQ_PREAUTH set. Changes to that account flag should also be
reviewed through account-management auditing, including event 4738.15
Mitigations. Require Kerberos pre-authentication for every account and continuously audit for exceptions. If a legacy dependency makes an exception temporarily unavoidable, use a long, randomly generated password, minimize the account’s privileges and remove the exception as soon as the dependency is fixed. Password length is only a fallback control here: the real fix is to restore pre-authentication.
Kerberoasting
Kerberoasting (T1558.003) attacks the second phase of Kerberos. Any authenticated domain principal can normally request a service ticket for a registered SPN. The KDC encrypts that ticket with the long-term key of the account that owns the SPN, then returns it in a TGS-REP. The requester can extract the encrypted ticket and test password-derived keys against it offline (Figure 6).16
sequenceDiagram
participant A as Authenticated principal
participant TGS as Ticket Granting Service
participant O as Offline cracking
A->>TGS: TGS-REQ: valid TGT + target SPN
TGS-->>A: TGS-REP: service ticket encrypted with the service account key
A->>O: Encrypted service ticket
loop Password candidates
O->>O: Derive a service key and test the decryption
end
O-->>A: Service account password / key if a candidate matches
Figure 6. Kerberoasting moves the password guesses away from the KDC.
The request is legitimate from the protocol’s point of view: the KDC is designed to issue tickets to authenticated users. The weakness lies in a human-managed service account password that has too little entropy. As with AS-REP roasting, the guesses are offline and do not trigger an account lockout. If the service key is recovered, the attacker can act as that account wherever its rights allow and may be able to forge service tickets for its SPNs: the Silver Ticket case described below.
Telemetry. Event 4769 records the requester, the target service account
and SPN, the client address and the ticket encryption type. Useful analytics
include one account requesting tickets for many unrelated SPNs, requests for
high-value services from hosts that do not normally use them, and RC4-HMAC
(0x17) tickets in an AES-capable domain. RC4 is a strong signal because it is
cheaper to guess, but it is not a necessary condition: AES tickets can also be
roasted. Newer 4769 versions expose the encryption types advertised by the
client and available to the account, which helps distinguish legacy
dependencies from deliberately selected RC4.17
Mitigations. Replace user-based service identities with group Managed Service Accounts (gMSAs) where possible, so Windows generates and rotates a long random password.18 For remaining service accounts, use long random passwords, rotate them, enable AES and remove RC4 dependencies. Keep their privileges minimal, do not assign SPNs to highly privileged user accounts, and review which hosts are allowed to retrieve and use each managed identity.
Forged tickets: Golden and Silver
Roasting recovers a principal’s key by guessing its password. A forged-ticket attack starts later in the chain: the attacker already has a ticket-signing key and constructs a ticket without the exchange that would normally issue it. Which key was compromised determines both the artifact and the blast radius (Figure 7).
flowchart LR
K["Compromised krbtgt key"] --> GT["Forged TGT<br/>Golden Ticket"]
GT --> TGS["KDC / TGS"]
TGS --> LST["Legitimate service ticket"]
LST --> S1["Many services in the domain"]
SK["Compromised service account key"] --> SST["Forged service ticket<br/>Silver Ticket"]
SST --> S2["Service identified by the SPN"]
Figure 7. A Golden Ticket forges the KDC-facing credential; a Silver Ticket forges the service-facing credential.
| Golden Ticket | Silver Ticket | |
|---|---|---|
| Forged artifact | TGT | Service ticket |
| Required secret | krbtgt key |
Key of the account that owns the target SPN |
| Normal exchange bypassed | AS exchange | AS and TGS exchanges for that service access |
| KDC contact when used | Usually yes: the forged TGT is exchanged for service tickets | Not necessarily: the forged ticket can be presented directly to the service |
| Scope | Domain-wide, subject to trusts and current validation rules | The services and SPNs backed by the compromised account |
| Key rotation that invalidates it | krbtgt password reset twice, as part of a controlled recovery |
Password/key rotation for the affected service account |
Golden Ticket
A Golden Ticket (T1558.001) is a TGT constructed with a compromised
krbtgt key.19 The attacker also supplies domain and identity
data, including a domain SID and the authorization information carried in the
PAC. Because the KDC itself uses the same key to protect TGTs, possession of
that key crosses the domain’s authentication trust boundary. The forged TGT
can be created without an AS-REQ and later submitted in TGS-REQ messages to
obtain service tickets.
This distinction matters for detection. A domain controller can log 4769
when the forged TGT is used at the TGS, but there may be no corresponding
4768 showing that the TGT was issued. Correlate the two phases and look for
impossible or unusual account/SID combinations, ticket lifetimes outside
domain policy, legacy encryption in a modern domain and privileged activity
from an account or host that does not normally perform it. No single field is
conclusive: a validly signed forgery is designed to resemble a legitimate
ticket.
Preventing a Golden Ticket is principally a Tier 0 problem. Protect domain
controllers, backups and replication privileges; monitor directory replication
rights and suspicious access to credential material; and harden LSASS against
credential theft as described in the
LSASS article.
After a confirmed krbtgt compromise, first remove the attacker’s persistence
and verify replication health, then reset the krbtgt password twice using
a controlled recovery procedure. The interval between resets must exceed the
configured maximum ticket lifetime so that legitimate tickets signed with the
old key can expire.20
Silver Ticket
A Silver Ticket (T1558.002) is a forged service ticket signed with the key
of the account behind the target SPN.21 It does not require
the krbtgt key. The attacker needs the service account key plus the domain and
identity information to place in the ticket, then presents the result directly
to the service. The scope is narrower than a Golden Ticket, but an account can
own several SPNs and can itself be privileged, so the practical impact may
still be large.
The absence of a TGS exchange is the defining telemetry gap. A forged service
ticket can produce a successful logon (4624), special-privilege assignment
or application-specific access on the target while no matching 4769 exists
on any domain controller.22 Detecting it therefore requires retaining
and correlating service-side and DC-side events. PAC validation and newer
Kerberos hardening can make some services contact a DC or reject malformed
tickets, but defenders should not assume every service performs that check.
Rotate the compromised service account’s password or key, move eligible services to gMSAs, reduce the account’s rights and inventory every SPN mapped to it. Apply current Kerberos security updates and validate service configurations, but treat protection of the service key as the primary control.
Telemetry and hardening
Every phase of the exchange leaves a trace on the domain controller, provided the Audit Kerberos Authentication Service and Audit Kerberos Service Ticket Operations subcategories are enabled.
| Event ID | Logged on | Logged when | Fields of interest |
|---|---|---|---|
4768 |
Domain controller | A TGT was requested (AS exchange)12 | Account, client address, ticket encryption type, pre-authentication type |
4769 |
Domain controller | A service ticket was requested (TGS exchange)23 | Requester, service/SPN owner, client address, ticket encryption type |
4771 |
Domain controller | Kerberos pre-authentication failed13 | Account, client address, failure code |
4624 |
Target host | A logon session was created22 | Account, logon type, authentication package, source address |
The DC events show what the KDC issued; the target-host events show what a
service accepted. Keeping both sides and correlating them is what exposes the
negative space used by forged tickets: a 4769 without a plausible earlier
4768 can indicate a Golden Ticket, while a Kerberos 4624 without a matching
4769 can indicate a Silver Ticket. Replication delays, cross-domain referrals,
RODCs, event loss and retention gaps can produce the same symptoms, so these
are investigation leads rather than standalone verdicts.
The cross-cutting hardening priorities are:
- enable the Audit Kerberos Authentication Service and Audit Kerberos Service Ticket Operations subcategories on every domain controller, and retain enough target-host telemetry to correlate both sides of an exchange;
- remove RC4 dependencies and prefer AES, using the expanded
4768and4769encryption fields to find incompatible accounts and clients;17 - protect long-term keys in proportion to their scope: user keys, service
account keys and, above all, the
krbtgtkey and domain controller material; - apply least privilege to service accounts and replication rights, and use managed identities instead of human-maintained passwords;
- maintain reliable time synchronization: clock drift beyond the tolerance breaks legitimate authentication and makes time-based analytics less useful.
Summary
Kerberos authenticates principals through a trusted KDC and symmetric keys.
In phase 1 the Authentication Service verifies the client’s
pre-authentication and issues a TGT, sealed with the krbtgt key. In
phase 2 the Ticket Granting Service exchanges the TGT for a service
ticket, sealed with the key of the account behind the requested SPN. The
client presents that ticket to the service, which validates it offline. Each
hop is protected by a different key, and each ticket carries the session key
for the next hop. In Active Directory, tickets also carry the PAC with the
client’s authorization data. Those same encryption boundaries explain the
main abuses: AS-REP roasting tests a user key, Kerberoasting tests a service
key, a Golden Ticket is signed with the krbtgt key and a Silver Ticket with
a service key. Defenders need both KDC telemetry (4768, 4769, 4771) and
service-side logons (4624) to see the complete path. The corresponding
hardening priorities are pre-authentication, managed and least-privileged
service identities, AES, correlation across systems and strict protection of
domain controller and krbtgt material.
References
-
IETF, RFC 4120: The Kerberos Network Authentication Service (V5). ↩︎ ↩︎2 ↩︎3 ↩︎4
-
Microsoft Learn, Kerberos authentication overview. ↩︎ ↩︎2
-
Microsoft Learn, Service Principal Names. ↩︎ ↩︎2
-
Microsoft Open Specifications, [MS-PAC]: Privilege Attribute Certificate Data Structure. ↩︎
-
Microsoft Learn, Maximum lifetime for user ticket. ↩︎
-
Microsoft Learn, Maximum tolerance for computer clock synchronization. ↩︎
-
MITRE ATT&CK, Steal or Forge Kerberos Tickets: AS-REP Roasting (T1558.004). ↩︎ ↩︎2
-
MITRE ATT&CK, Account Discovery: Domain Account (T1087.002). ↩︎
-
MITRE ATT&CK, Brute Force: Password Spraying (T1110.003). ↩︎
-
Microsoft Learn, 4768(S, F): A Kerberos authentication ticket (TGT) was requested. ↩︎ ↩︎2
-
Microsoft Learn, 4771(F): Kerberos pre-authentication failed. ↩︎ ↩︎2
-
Microsoft Learn, Account lockout threshold. ↩︎
-
Microsoft Learn, 4738(S): A user account was changed. ↩︎
-
MITRE ATT&CK, Steal or Forge Kerberos Tickets: Kerberoasting (T1558.003). ↩︎
-
Microsoft Learn, Detect and remediate RC4 usage in Kerberos. ↩︎ ↩︎2
-
Microsoft Learn, Group Managed Service Accounts overview. ↩︎
-
MITRE ATT&CK, Steal or Forge Kerberos Tickets: Golden Ticket (T1558.001). ↩︎
-
Microsoft Learn, Active Directory forest recovery: reset the
krbtgtpassword. ↩︎ -
MITRE ATT&CK, Steal or Forge Kerberos Tickets: Silver Ticket (T1558.002). ↩︎
-
Microsoft Learn, 4624(S): An account was successfully logged on. ↩︎ ↩︎2
-
Microsoft Learn, 4769(S, F): A Kerberos service ticket was requested. ↩︎