Post

LSASS Internals: Authentication Packages and Credential Protection

How the Local Security Authority Subsystem Service handles an interactive logon on Windows: the path from the Secure Attention Sequence to the access token, the authentication packages loaded in lsass.exe, the role of the SAM and the domain controller, how credentials are extracted and reused, and the protections, telemetry and hardening that keep the process and its secrets out of reach.

LSASS Internals: Authentication Packages and Credential Protection

Introduction

The Local Security Authority Subsystem Service (lsass.exe) is the user-mode process that enforces the local security policy of a Windows system. It authenticates users, creates logon sessions and access tokens, manages the audit policy and writes security events to the Security event log.1

Every interactive, network or service logon goes through LSASS. To provide single sign-on (SSO), LSASS also keeps the credential material that lets the user reach network resources without retyping a password. This makes it one of the most sensitive processes on the system. Its integrity and confidentiality are central to the security of the whole host, and in a domain of the whole environment. Credential access against LSASS memory is catalogued by MITRE ATT&CK as technique T1003.001.2

This article describes the architecture of LSASS from a defender’s point of view: how a logon flows through it, which components it hosts, and which platform features, telemetry sources and configuration settings protect it.

The interactive logon flow

An interactive logon involves several processes, each with a well-defined role (Figure 1).1

flowchart TB
    U["User presses Ctrl+Alt+Del (SAS)"] --> W["winlogon.exe<br/>Secure Desktop"]
    W --> LU["LogonUI.exe<br/>credential providers"]
    LU -->|"collected credentials"| W
    W -->|"LsaLogonUser (ALPC)"| L
    subgraph L["lsass.exe: LSA server"]
        direction LR
        MSV["MSV1_0 (NTLM)"]
        KRB["Kerberos"]
        OTH["Other packages"]
    end
    MSV -->|"local account"| SAM[("SAM database")]
    MSV -->|"domain account (Netlogon)"| DC["Domain controller"]
    KRB -->|"AS-REQ / TGS-REQ"| DC
    L -->|"success"| T["Logon session + access token<br/>SIDs, groups, privileges"]

Figure 1. Path of an interactive logon through winlogon and LSASS.

  1. Secure Attention Sequence. Ctrl+Alt+Del is trapped by the system and always delivered to winlogon.exe. No user-mode application can intercept it. Winlogon switches to the Secure Desktop, which ordinary user processes cannot reach.
  2. Credential collection. LogonUI.exe loads the credential providers (password, PIN, smart card, Windows Hello) and returns the collected credentials to Winlogon.
  3. Logon request. Winlogon calls LsaLogonUser, which reaches LSASS through an ALPC channel. The request names the authentication package that must process it.3
  4. Validation. The authentication package checks the credentials. For a local account, MSV1_0 compares them with the SAM database. For a domain account, Kerberos runs the AS and TGS exchanges against the KDC on a domain controller. When Kerberos cannot be used, MSV1_0 forwards the NTLM validation to the domain controller through Netlogon.
  5. Token creation. On success, LSASS creates a logon session, identified by a locally unique identifier (LUID), and an access token containing the user’s SID, group SIDs and privileges. Winlogon then starts the user’s shell with that token.

The same entry point serves non-interactive logons. Network, batch, service and remote interactive logons all end up in an authentication package inside LSASS. They differ by logon type, which is recorded in the resulting Security event.4

Inside lsass.exe

Security packages

LSASS is a host for pluggable DLLs called security packages. Some of them are authentication packages (AP), which validate logons. Others are security support providers (SSP), which implement the SSPI protocols used by applications to authenticate over the network. Many packages are both (Figure 2).1

flowchart TB
    subgraph LSASS["lsass.exe: SYSTEM, optionally PPL"]
        direction TB
        subgraph PKG["Security packages"]
            direction LR
            MSV["msv1_0.dll<br/>NTLM"]
            KRB["kerberos.dll<br/>Kerberos"]
            WD["wdigest.dll<br/>Digest (legacy)"]
            TS["tspkg.dll<br/>CredSSP / RDP SSO"]
            CA["cloudap.dll<br/>Microsoft Entra ID"]
        end
        DP["DPAPI / Credential Manager"]
    end
    subgraph VTL1["VBS: Isolated User Mode"]
        ISO["LsaIso.exe<br/>Credential Guard"]
    end
    LSASS <-.->|"opaque handles only"| VTL1

Figure 2. Security packages hosted by LSASS and the isolated LSA process.

Package DLL Role
Negotiate lsasrv.dll Picks Kerberos when possible and falls back to NTLM
MSV1_0 msv1_0.dll NTLM authentication; validates local accounts against the SAM
Kerberos kerberos.dll Kerberos client; obtains and caches TGTs and service tickets5
WDigest wdigest.dll Digest authentication (HTTP, SASL); legacy
TsPkg / CredSSP tspkg.dll, credssp.dll Delegation of credentials to remote hosts, for example RDP single sign-on
CloudAP cloudap.dll Authentication against Microsoft Entra ID and Microsoft accounts
Schannel schannel.dll TLS/SSL; certificate-based authentication

Credential material and single sign-on

After a successful logon, several packages keep credential material for the lifetime of the logon session, so that later network authentications succeed without prompting the user again. In broad terms:1

  • MSV1_0 keeps the NTLM one-way function of the password, with the logon session metadata (user SID, logon type, logon time).
  • Kerberos keeps the TGT, the service tickets obtained so far and their session keys.
  • WDigest keeps a reversible form of the password, but only when the legacy UseLogonCredential setting is enabled. Since Windows 8.1 and Windows Server 2012 R2 it is disabled by default.6
  • TsPkg / CredSSP keeps delegable credentials when credential delegation is configured.
  • DPAPI keeps the user’s master keys, which protect secrets such as Credential Manager entries and application-encrypted data.7

For a defender this list is the reason LSASS is a tier-0 asset. Any code that can read LSASS memory with sufficient privileges can reach material that authenticates the user elsewhere in the network. The protections described below aim to make that read impossible or useless.

Cached domain logons

Cached logon credentials (MS-Cache v2) are a separate mechanism. They let a domain user log on interactively when no domain controller is reachable, for example on a laptop offline. They are salted, iterated verifiers derived from the password, and they are stored in the HKLM\SECURITY hive, not in LSASS memory. They cannot be used directly for network authentication. The number of cached entries defaults to 10 and is set by the policy Interactive logon: Number of previous logons to cache.8

Credential theft and reuse

Credential dumping is not a single API call. It is a chain that crosses several security boundaries: obtaining a privileged context, acquiring a handle to LSASS, reading or snapshotting its address space, understanding the private structures maintained by each security package and finally reusing the extracted material. A control can break one stage without protecting the others.

Direct memory access and process dumps

The classic LSASS-memory path is shown in Figure 3. On a system without LSA protection, an administrator who can enable SeDebugPrivilege, or code already running as SYSTEM, may be able to request a process handle with memory-query and read rights. The reader can then inspect the address space directly or write a process dump and parse it on another system.2

flowchart LR
    P["1. Privileged context<br/>administrator + SeDebugPrivilege<br/>or SYSTEM"]
    H["2. Obtain an LSASS handle<br/>query and memory-read rights"]
    R["3. Read, snapshot or dump<br/>selected memory pages"]
    S["4. Parse package structures<br/>logon sessions and credentials"]
    C["5. Recover material<br/>hashes, tickets, keys or secrets"]
    P --> H --> R --> S --> C

Figure 3. The stages of an LSASS credential-dumping operation.

Two implementation families leave different traces:

  • A live reader keeps a handle to LSASS and repeatedly performs virtual memory reads. The sensitive operation remains the kernel-mediated read, no matter whether the caller reached it through a Win32 API, an ntdll stub or a directly issued system call.
  • A dump-and-parse workflow obtains the handle once, captures all or part of the process and performs the package-specific parsing offline. This adds a file-creation, staging and often compression or exfiltration phase that a defender can correlate with the original process access.

The parser must understand undocumented structures that differ by Windows build and by authentication package. It usually starts from the logon-session lists and follows package-specific pointers to NTLM material, Kerberos tickets and keys, WDigest state or DPAPI master keys. What it finds depends on the logon types present and on the protections enabled: there is no universal “password list” in LSASS.

An attacker may also duplicate a handle already held by a trusted process or coerce a signed component into creating a dump. These variants change the process that opens LSASS, but not the underlying security boundary: at some point a handle with sufficient rights must exist and memory must be read or copied.

Moving below or around PPL

LSA protection changes the prerequisite. Administrator or SYSTEM status no longer implies a memory-readable LSASS handle: the kernel compares protection levels and strips or denies dangerous rights. Techniques that remain entirely in user mode therefore have to find a trusted handle, abuse code already inside an appropriate trust boundary or first defeat PPL.

Route What it changes What it does not bypass
Direct or indirect system calls Avoids user-mode API hooks and recognizable call paths Kernel access checks, PPL, EDR kernel callbacks and Credential Guard
Handle duplication Reuses access granted to another process instead of opening LSASS directly PPL checks on the original handle and monitoring of handle duplication
Trusted-component abuse Makes an allowed or signed component perform the access or dump Kernel telemetry and behavioural correlation around the resulting artifact
Vulnerable signed driver (BYOVD) Gives the attacker a kernel read/write primitive that can bypass or tamper with PPL HVCI, Secure Boot policy, the vulnerable-driver blocklist and hypervisor-isolated VTL1 secrets

A malicious kernel driver can read VTL0 memory, copy LSASS pages or tamper with process protection state. This is why PPL is not a complete boundary without kernel code-integrity controls. Conversely, Credential Guard places selected domain secrets in VTL1: compromising the ordinary VTL0 kernel is serious, but does not by itself grant raw access to the isolated memory.

Credential theft without reading LSASS

An absence of LSASS access does not imply an absence of credential theft. Several techniques obtain related material from a different trust boundary:

Target or technique Material exposed Boundary being attacked
Local SAM plus the corresponding boot-key material NT hashes of local accounts Registry and offline system files9
SECURITY hive LSA secrets and cached domain-logon verifiers Registry and offline system files10
NTDS.dit on a domain controller Domain credential data AD DS database, backups or volume snapshots11
DCSync Replicated password data for selected domain accounts Directory replication rights and the MS-DRSR protocol12
AS-REP roasting and Kerberoasting Ciphertexts that can be tested offline Normal Kerberos AS/TGS exchanges

DCSync is especially important operationally: a principal with the required replication rights can request password data remotely while imitating a domain controller, so no process ever opens LSASS on the attacker’s endpoint. LSA protection, Credential Guard and the LSASS ASR rule do not stop it. Replication rights, domain-controller hardening and event 4662 therefore belong in the same credential-protection strategy.

The Kerberos roasting techniques are covered in detail in the Kerberos article. They demonstrate the same lesson: credential access has to be monitored at the identity system and the domain controllers, not only at the endpoint process.

From extracted material to authentication

Credential theft and credential use are separate events. The first obtains a secret or ticket; the second presents it to another machine or injects it into a logon session (Figure 4).

flowchart LR
    PW["Plaintext password"] --> AUTH["Normal authentication"]
    NT["NT hash"] --> PTH["NTLM Pass-the-Hash"]
    NT -->|"only where compatible Kerberos RC4 remains"| OPTH["Overpass-the-Hash<br/>obtain a TGT"]
    T["TGT or service ticket"] --> PTT["Pass-the-Ticket"]
    DP["DPAPI master key"] --> DEC["Decrypt saved application secrets"]
    SK["Service account key"] --> SIL["Silver Ticket"]
    KR["krbtgt key"] --> GOLD["Golden Ticket"]

Figure 4. Credential material enables different forms of reuse.

  • Pass-the-Hash (T1550.002) uses an NT hash as the NTLM long-term key; the plaintext password is unnecessary.13 The NTLM article explains why the hash is password-equivalent for that protocol.
  • Overpass-the-Hash uses key material to obtain Kerberos credentials. An NT hash maps to the Kerberos RC4 key, so an NT hash alone is insufficient where RC4 has been removed and AES keys are required.
  • Pass-the-Ticket (T1550.003) reuses a stolen TGT or service ticket without recovering the password.14
  • Compromised service-account and krbtgt keys enable Silver and Golden Tickets respectively, as described in the Kerberos article.

This separation matters for response. Terminating the dumping process or deleting a dump does not revoke material that has already left the host. Containment must include the exposed logon sessions and accounts, ticket and key rotation where appropriate, and a hunt for the subsequent authentication from other systems.

Hardening and mitigations

LSA protection (RunAsPPL)

LSA protection runs lsass.exe as a Protected Process Light (PPL). A PPL can be opened only with limited access rights by processes that are not protected at the same or a higher level, even when they run as SYSTEM or hold SeDebugPrivilege. In addition, LSASS loads only plug-ins (security packages, notification packages) signed with the appropriate signature.15

LSA protection is enabled through the RunAsPPL value under HKLM\SYSTEM\CurrentControlSet\Control\Lsa, or through Group Policy. On UEFI systems with Secure Boot the setting can be stored in a UEFI variable, so that it cannot be turned off by editing the registry alone. Microsoft provides an audit mode to identify plug-ins that would fail to load before enforcing the protection.15

LSA protection is enabled automatically on new, enterprise-joined Windows 11 22H2 or later installations that are capable of HVCI. Upgrades and systems that do not meet those conditions can differ. An explicit enterprise policy is still useful: it makes the intended state measurable and prevents an inherited exception from being mistaken for the platform default.15

PPL is a defence enforced by the kernel. It assumes that the kernel itself is trustworthy, so a malicious or vulnerable signed driver weakens it. This is why LSA protection should be combined with driver control (HVCI, the Microsoft vulnerable driver blocklist) and with Credential Guard.

Credential Guard

Windows Defender Credential Guard uses Virtualization-Based Security (VBS) to move the most sensitive secrets out of lsass.exe. The hypervisor splits the system into two Virtual Trust Levels. The normal OS runs in VTL0; a minimal Isolated User Mode runs in VTL1, where the process LsaIso.exe (the isolated LSA) holds the NTLM one-way functions and the Kerberos TGT keys.16

LSASS in VTL0 communicates with LsaIso through RPC and receives only opaque references to the protected secrets. Even code running in the VTL0 kernel cannot read VTL1 memory, because that memory is protected by the hypervisor.

Credential Guard has limits that a defender should know:16

  • It does not protect credentials typed into applications or stored by them.
  • It does not protect cached domain logons in the SECURITY hive.
  • It blocks NTLMv1, unconstrained Kerberos delegation and DES, so these must be retired before deployment.
  • It does not protect a session while the user is logged on against an attacker who can act as the user: it protects stored secrets, not the live session.

Starting with Windows 11 22H2 and Windows Server 2025, Credential Guard is enabled by default on eligible domain-joined systems that are not domain controllers. Eligibility, upgrade history and explicit policy still matter, so its running state must be measured rather than inferred from the operating system version.17

Kernel and driver integrity

PPL trusts the kernel, and a BYOVD path attacks that trust. Memory integrity (HVCI) moves kernel code-integrity decisions behind VBS and prevents code that does not satisfy policy from becoming executable in kernel mode. Secure Boot protects the boot chain, while the Microsoft vulnerable driver blocklist prevents known-abusable signed drivers from loading. On supported Windows versions the blocklist is enforced when memory integrity, Smart App Control or S mode is active.18

These controls are complementary rather than interchangeable:

  • RunAsPPL protects the process boundary and the plug-ins loaded by LSASS;
  • HVCI and the driver blocklist protect the kernel trust boundary on which PPL depends;
  • Credential Guard protects selected secret material in VTL1 even if ordinary VTL0 memory is exposed;
  • Secure Boot anchors the policies and code-integrity state before Windows starts.

Driver compatibility should be tested before broad HVCI enforcement, but compatibility exceptions must be treated as security debt. A signed driver is not automatically a safe driver.

Control Effect
Protected Users group Members do not use NTLM, Digest or CredSSP delegation, use Kerberos with AES only and get short-lived TGTs; no long-term credentials are cached19
WDigest disabled (UseLogonCredential = 0) No reversible password form is kept by WDigest6
Remote Credential Guard / Restricted Admin RDP sessions do not send reusable credentials to the remote host20
Reduced cached logons Lowers the number of verifiers in HKLM\SECURITY on servers that do not need offline logon8
ASR rule: Block credential stealing from LSASS Microsoft Defender for Endpoint blocks untrusted processes from opening LSASS with memory-read rights21
Windows LAPS and unique local admin passwords Prevents one recovered local administrator hash from authenticating across many hosts22
Administrative tiering / no privileged logon on workstations Keeps high-value domain credentials out of lower-trust LSASS instances
Restricted replication rights Limits which principals can perform DCSync; rights should be inventoried and changes alerted
Reduce or disable NTLM Shrinks the value and reach of an extracted NT hash; audit dependencies before enforcement

Experiment: checking the protection state of LSASS

The configured LSA protection and the WDigest setting can be read from the registry:

1
2
Get-ItemProperty 'HKLM:\SYSTEM\CurrentControlSet\Control\Lsa' -Name RunAsPPL -ErrorAction SilentlyContinue
Get-ItemProperty 'HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest' -Name UseLogonCredential -ErrorAction SilentlyContinue

The running state of VBS and Credential Guard is exposed through WMI. The value 1 in SecurityServicesRunning means that Credential Guard is active:17

1
2
Get-CimInstance -Namespace root\Microsoft\Windows\DeviceGuard -ClassName Win32_DeviceGuard |
    Select-Object VirtualizationBasedSecurityStatus, SecurityServicesConfigured, SecurityServicesRunning

msinfo32 also reports VBS and Credential Guard in the System Summary page. The WMI state above is preferable to checking only for a visible LsaIso.exe process, which is not authoritative on every supported configuration.

Telemetry

Access to LSASS by other processes is rare in a healthy system and limited to a small, stable set of binaries: security products, svchost.exe instances, Windows Error Reporting and a few management agents. This makes it a high-value detection point. It is not the only one: the strongest analytics join the process access to the dump or memory read, the staging of an artifact and the later use of the credential.

The kernel callback and ETW collection architecture used by endpoint sensors is described in the EDR article.

Layer / source Signal Defensive use
EDR kernel callbacks and protected ETW consumers Process-handle creation/duplication and cross-process memory operations targeting LSASS Observes the kernel operation even when direct system calls bypass user-mode hooks; a pre-operation callback can also remove dangerous rights or deny the handle
Sysmon Event 10 (ProcessAccess), TargetImage = lsass.exe23 Source image, user, requested access and call trace for unexpected LSASS handles
Security log with the required object-access policy and SACL 4656 (handle requested), correlated with 4663 (access attempted)24 Native auditing of object access; 4656 alone proves a request, not that the read completed
Microsoft-Windows-CodeIntegrity/Operational 3065, 3066 (audit mode); 3033, 3063 (enforced)15 Plug-ins that would be, or were, blocked from loading into protected LSASS
Security log 4614, 4622 A notification package or security package was loaded by the LSA; unexpected entries indicate an untrusted plug-in
Microsoft Defender for Endpoint ASR events 1121 (blocked), 1122 (audit)21 Attempts covered by the Block credential stealing from LSASS rule
Process and driver telemetry Security 4688, Sysmon 1, Code Integrity and driver/service installation events25 Correlates an unexpected process or newly loaded driver with LSASS access
File telemetry Creation, rename, compression or upload of a process dump Finds dump-and-parse workflows even when a trusted component created the file
Domain-controller Security log 4662 with directory-replication extended rights26 Detects DCSync-like replication by principals or hosts that are not expected domain controllers
Security log 1102 (audit log cleared)27 High-priority anti-forensics signal, especially near credential-access activity
Authentication logs 4624, 4768, 4769, 4776 Finds reuse of a stolen hash or ticket from an unusual source, protocol or time

Detection patterns

Handle-to-dump sequence. Alert when an unusual process obtains PROCESS_VM_READ, PROCESS_QUERY_INFORMATION, PROCESS_DUP_HANDLE or broad access to LSASS and a dump-like file appears shortly afterwards. Include signed binaries in the model: signature and path reduce uncertainty, but do not prove benign intent. Parent process, user, integrity level, call trace and destination path provide the context.

Live memory reads. A process may read only selected pages and never create a dump. Kernel callbacks and the Microsoft-Windows-Threat-Intelligence-backed telemetry used by security products are more useful here than command-line signatures. Direct system calls change the user-mode path, not the kernel operation that the sensor observes.

PPL or driver bypass chain. Correlate a driver or service installed from a user-writable path, a Code Integrity or vulnerable-driver alert, changes to RunAsPPL or VBS policy and subsequent LSASS access. A single event may be ambiguous; this sequence is not.

Protection drift. Alert when RunAsPPL, UseLogonCredential, HVCI, Credential Guard or the ASR rule changes. Registry auditing, configuration management and Sysmon registry events (12, 13) can cover the corresponding keys. Drift is valuable even when no immediate memory access follows.

No-touch credential access. On domain controllers, flag directory replication operations from non-DC accounts or hosts and unexpected access to NTDS.dit, registry hives, backups and volume snapshots. Endpoint-only LSASS rules are blind to these paths.

Credential reuse. Follow a credential-access alert with authentication analytics: NTLM network logons from a new host, Kerberos ticket activity that does not fit the account’s normal sequence, privileged logons and lateral movement within the lifetime of the exposed session. This catches the second half of the attack even when the original dump was missed.

Summary

LSASS is the user-mode core of Windows authentication. Winlogon collects credentials on the Secure Desktop and passes them to LSASS through LsaLogonUser. The selected authentication package validates them, MSV1_0 against the SAM or a domain controller and Kerberos against the KDC, and LSASS creates the logon session and the access token. To provide single sign-on, the security packages keep credential material for the lifetime of the session, which makes LSASS a high-value target. A typical dump chain obtains a privileged context, acquires or duplicates a handle, reads or snapshots memory, parses package-specific structures and then reuses hashes, tickets or keys. Other techniques avoid LSASS entirely by targeting the SAM, the SECURITY hive, NTDS.dit, directory replication or the Kerberos protocol.

No single mitigation covers all of those paths. LSA protection limits who can open the process and what it loads; HVCI, Secure Boot and the vulnerable driver blocklist protect the kernel boundary beneath it; Credential Guard moves selected domain secrets into LsaIso.exe behind the hypervisor; and Protected Users, Remote Credential Guard, LAPS, administrative tiering and protocol hardening reduce which reusable credentials exist. Detection should correlate LSASS handles and memory operations with dump artifacts, driver and configuration changes, directory replication and the later authentication performed with the stolen material.

References

  1. Microsoft Learn, Credentials Processes in Windows Authentication. ↩︎ ↩︎2 ↩︎3 ↩︎4

  2. MITRE ATT&CK, OS Credential Dumping: LSASS Memory (T1003.001). ↩︎ ↩︎2

  3. Microsoft Learn, LsaLogonUser function (ntsecapi.h). ↩︎

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

  5. Microsoft Learn, Kerberos authentication overview. ↩︎

  6. Microsoft, Microsoft Security Advisory: Update to improve credentials protection and management (KB2871997). ↩︎ ↩︎2

  7. Microsoft Learn, CryptProtectData function (dpapi.h). ↩︎

  8. Microsoft Learn, Interactive logon: Number of previous logons to cache (in case domain controller is not available). ↩︎ ↩︎2

  9. MITRE ATT&CK, OS Credential Dumping: Security Account Manager (T1003.002). ↩︎

  10. MITRE ATT&CK, OS Credential Dumping: Cached Domain Credentials (T1003.005). ↩︎

  11. MITRE ATT&CK, OS Credential Dumping: NTDS (T1003.003). ↩︎

  12. MITRE ATT&CK, OS Credential Dumping: DCSync (T1003.006). ↩︎

  13. MITRE ATT&CK, Use Alternate Authentication Material: Pass the Hash (T1550.002). ↩︎

  14. MITRE ATT&CK, Use Alternate Authentication Material: Pass the Ticket (T1550.003). ↩︎

  15. Microsoft Learn, Configure added LSA protection. ↩︎ ↩︎2 ↩︎3 ↩︎4

  16. Microsoft Learn, How Credential Guard works. ↩︎ ↩︎2

  17. Microsoft Learn, Configure Credential Guard. ↩︎ ↩︎2

  18. Microsoft Learn, Microsoft recommended driver block rules. ↩︎

  19. Microsoft Learn, Protected Users security group. ↩︎

  20. Microsoft Learn, Remote Credential Guard. ↩︎

  21. Microsoft Learn, Attack surface reduction rules reference. ↩︎ ↩︎2

  22. Microsoft Learn, Windows LAPS overview. ↩︎

  23. Microsoft Learn, Sysmon. ↩︎

  24. Microsoft Learn, 4656(S, F): A handle to an object was requested. ↩︎

  25. Microsoft Learn, 4688(S): A new process has been created. ↩︎

  26. Microsoft Learn, 4662(S, F): An operation was performed on an object. ↩︎

  27. Microsoft Learn, 1102(S): The audit log was cleared. ↩︎

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