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.
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.
- Secure Attention Sequence.
Ctrl+Alt+Delis trapped by the system and always delivered towinlogon.exe. No user-mode application can intercept it. Winlogon switches to the Secure Desktop, which ordinary user processes cannot reach. - Credential collection.
LogonUI.exeloads the credential providers (password, PIN, smart card, Windows Hello) and returns the collected credentials to Winlogon. - Logon request. Winlogon calls
LsaLogonUser, which reaches LSASS through an ALPC channel. The request names the authentication package that must process it.3 - 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.
- 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
UseLogonCredentialsetting 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
ntdllstub 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
krbtgtkeys 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
SECURITYhive. - 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.
Related controls
| 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 SilentlyContinueThe running state of VBS and Credential Guard is exposed through WMI. The value
1inSecurityServicesRunningmeans that Credential Guard is active:17
1 2 Get-CimInstance -Namespace root\Microsoft\Windows\DeviceGuard -ClassName Win32_DeviceGuard | Select-Object VirtualizationBasedSecurityStatus, SecurityServicesConfigured, SecurityServicesRunning
msinfo32also reports VBS and Credential Guard in the System Summary page. The WMI state above is preferable to checking only for a visibleLsaIso.exeprocess, 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
-
Microsoft Learn, Credentials Processes in Windows Authentication. ↩︎ ↩︎2 ↩︎3 ↩︎4
-
MITRE ATT&CK, OS Credential Dumping: LSASS Memory (T1003.001). ↩︎ ↩︎2
-
Microsoft Learn, LsaLogonUser function (ntsecapi.h). ↩︎
-
Microsoft Learn, 4624(S): An account was successfully logged on. ↩︎
-
Microsoft Learn, Kerberos authentication overview. ↩︎
-
Microsoft, Microsoft Security Advisory: Update to improve credentials protection and management (KB2871997). ↩︎ ↩︎2
-
Microsoft Learn, CryptProtectData function (dpapi.h). ↩︎
-
Microsoft Learn, Interactive logon: Number of previous logons to cache (in case domain controller is not available). ↩︎ ↩︎2
-
MITRE ATT&CK, OS Credential Dumping: Security Account Manager (T1003.002). ↩︎
-
MITRE ATT&CK, OS Credential Dumping: Cached Domain Credentials (T1003.005). ↩︎
-
MITRE ATT&CK, OS Credential Dumping: NTDS (T1003.003). ↩︎
-
MITRE ATT&CK, OS Credential Dumping: DCSync (T1003.006). ↩︎
-
MITRE ATT&CK, Use Alternate Authentication Material: Pass the Hash (T1550.002). ↩︎
-
MITRE ATT&CK, Use Alternate Authentication Material: Pass the Ticket (T1550.003). ↩︎
-
Microsoft Learn, Configure added LSA protection. ↩︎ ↩︎2 ↩︎3 ↩︎4
-
Microsoft Learn, How Credential Guard works. ↩︎ ↩︎2
-
Microsoft Learn, Configure Credential Guard. ↩︎ ↩︎2
-
Microsoft Learn, Microsoft recommended driver block rules. ↩︎
-
Microsoft Learn, Protected Users security group. ↩︎
-
Microsoft Learn, Remote Credential Guard. ↩︎
-
Microsoft Learn, Attack surface reduction rules reference. ↩︎ ↩︎2
-
Microsoft Learn, Windows LAPS overview. ↩︎
-
Microsoft Learn, 4656(S, F): A handle to an object was requested. ↩︎
-
Microsoft Learn, 4688(S): A new process has been created. ↩︎
-
Microsoft Learn, 4662(S, F): An operation was performed on an object. ↩︎
-
Microsoft Learn, 1102(S): The audit log was cleared. ↩︎