Post

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.

Kerberos Internals: Principals, Tickets and the Authentication Exchange

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 krbtgt account, 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.com or MSSQLSvc/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 servicePrincipalName attribute 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

klist shows 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

setspn lists 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/4771 patterns 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 4768 and 4769 encryption 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 krbtgt key 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

  1. IETF, RFC 4120: The Kerberos Network Authentication Service (V5). ↩︎ ↩︎2 ↩︎3 ↩︎4

  2. Microsoft Learn, Kerberos authentication overview. ↩︎ ↩︎2

  3. Microsoft Learn, Service Principal Names. ↩︎ ↩︎2

  4. Microsoft Open Specifications, [MS-PAC]: Privilege Attribute Certificate Data Structure. ↩︎

  5. Microsoft Learn, Maximum lifetime for user ticket. ↩︎

  6. Microsoft Learn, Maximum tolerance for computer clock synchronization. ↩︎

  7. MITRE ATT&CK, Steal or Forge Kerberos Tickets: AS-REP Roasting (T1558.004). ↩︎ ↩︎2

  8. Microsoft Learn, klist. ↩︎

  9. Microsoft Learn, setspn. ↩︎

  10. MITRE ATT&CK, Account Discovery: Domain Account (T1087.002). ↩︎

  11. MITRE ATT&CK, Brute Force: Password Spraying (T1110.003). ↩︎

  12. Microsoft Learn, 4768(S, F): A Kerberos authentication ticket (TGT) was requested. ↩︎ ↩︎2

  13. Microsoft Learn, 4771(F): Kerberos pre-authentication failed. ↩︎ ↩︎2

  14. Microsoft Learn, Account lockout threshold. ↩︎

  15. Microsoft Learn, 4738(S): A user account was changed. ↩︎

  16. MITRE ATT&CK, Steal or Forge Kerberos Tickets: Kerberoasting (T1558.003). ↩︎

  17. Microsoft Learn, Detect and remediate RC4 usage in Kerberos. ↩︎ ↩︎2

  18. Microsoft Learn, Group Managed Service Accounts overview. ↩︎

  19. MITRE ATT&CK, Steal or Forge Kerberos Tickets: Golden Ticket (T1558.001). ↩︎

  20. Microsoft Learn, Active Directory forest recovery: reset the krbtgt password. ↩︎

  21. MITRE ATT&CK, Steal or Forge Kerberos Tickets: Silver Ticket (T1558.002). ↩︎

  22. Microsoft Learn, 4624(S): An account was successfully logged on. ↩︎ ↩︎2

  23. Microsoft Learn, 4769(S, F): A Kerberos service ticket was requested. ↩︎

This post is licensed under CC BY 4.0 by the author.