Protected Processes: PP and PPL
How Windows protects selected processes from other processes, including administrators: the history of Protected Processes and Protected Process Light, protection types and signer levels, the dominance rules between them, which system and antimalware processes run protected, how the boundary can be degraded from kernel mode, and the telemetry and hardening of the model.
Introduction
In the classic Windows security model an administrator, or any process with
SeDebugPrivilege, can open every other process with full access: read and
write its memory, inject threads, terminate it. Protected processes break
this rule. The kernel refuses to grant most access rights on a protected
process to callers that are not themselves protected at an adequate level,
regardless of their token.1
The model protects code integrity and secrets in user mode: the memory of
lsass.exe when LSA protection is on, the antimalware engine against
tampering, and critical system processes against injection. It is enforced
by the kernel and relies on code signing, so it cannot protect against
code that already runs in the kernel.
History
| Protected Process (PP) | Protected Process Light (PPL) | |
|---|---|---|
| Introduced in | Windows Vista | Windows 8.1 / Windows Server 2012 R2 |
| Original purpose | DRM: the Protected Media Path for high-definition content | Protection of system services, LSASS and antimalware services |
| Levels | A single level | Several levels, defined by signer |
| Third parties | No | Antimalware vendors, through ELAM |
The first protected processes, introduced with Windows Vista, existed to
protect media playback (for example audiodg.exe). Toward a non-protected
caller, a protected process only allows a small set of access rights, among
them PROCESS_QUERY_LIMITED_INFORMATION, PROCESS_SET_LIMITED_INFORMATION,
PROCESS_SUSPEND_RESUME and PROCESS_TERMINATE; rights such as
PROCESS_VM_READ, PROCESS_VM_WRITE or PROCESS_CREATE_THREAD are
denied. Threads are restricted in the same way, to
THREAD_QUERY_LIMITED_INFORMATION and a few others.2
PPL extends the model with signer levels. Most core system processes run as PPL since Windows 8.1, and antimalware vendors can register their own services to run as PPL.1
Protection levels
Type and signer
The protection of a process is described by a byte with two main fields:2
- the type:
None,ProtectedLight(PPL) orProtected(PP); - the signer: the kind of signature that the process image, and every DLL it loads, must carry.
| Signer | Level | Used for |
|---|---|---|
WinSystem |
7 | The System process and minimal processes |
WinTcb |
6 | Critical Windows components: smss.exe, csrss.exe, wininit.exe, services.exe |
Windows |
5 | Important Windows components that handle sensitive data |
Lsa |
4 | lsass.exe, when configured to run protected |
Antimalware |
3 | Antimalware services, including third-party ones; PROCESS_TERMINATE is also denied |
CodeGen |
2 | .NET native code generation |
Authenticode |
1 | Hosting DRM content |
None |
0 | Not valid (no protection) |
The signer is not chosen freely. When a protected process starts, Code
Integrity checks that the image carries a signature with the Enhanced Key
Usage corresponding to the requested signer, and enforces the matching
signature level for every DLL loaded afterwards.2 A PPL
Lsa process, for example, cannot load an unsigned authentication package;
this is the mechanism behind LSA protection (see the
LSASS article).
Dominance between protected processes
Protected processes can open each other, but only according to dominance rules (Figure 1):2
- a PP dominates a PPL: a protected process can open a PPL with full access, while a PPL can never obtain full access to a PP;
- between processes of the same type, the caller must have a signer level
equal to or higher than the target’s: a PP
WinSystemhas full access to a PPWinTcb, and so on down the hierarchy.
flowchart TB
subgraph PPLB["PPL: lower signers"]
direction TB
L3["Antimalware"] --> L2["CodeGen"] --> L1["Authenticode"]
end
subgraph PPLA["PPL: higher signers"]
direction TB
L7["WinSystem"] --> L6["WinTcb"] --> L5["Windows"] --> L4["Lsa"]
end
subgraph PP["PP: dominates every PPL"]
direction TB
PP7["WinSystem"] --> PP6["WinTcb"] --> PP5["Windows"] --> PP1["Authenticode"]
end
Figure 1. Simplified hierarchy of PP and PPL. Each level can fully access the levels it dominates.
The figure is a simplification. The kernel keeps an internal table that defines, for each signer, the set of signers it can access, and a few signers are not strictly ordered. The general rule (PP above PPL, higher signers above lower ones) is enough to reason about most cases.
A non-protected process, even running as SYSTEM with SeDebugPrivilege,
is at the bottom of the hierarchy and receives only the limited rights.
Which processes run protected
On a current Windows installation, Process Explorer’s Protection column shows a pattern similar to the following:3
| Protection | Processes |
|---|---|
PsProtectedSignerWinTcb-Light |
smss.exe, csrss.exe, wininit.exe, services.exe |
PsProtectedSignerWindows-Light |
Several svchost.exe instances, SecurityHealthService.exe, Defender for Endpoint sensor processes (MsSense.exe, SenseIR.exe) |
PsProtectedSignerAntimalware-Light |
Microsoft Defender Antivirus: MsMpEng.exe, NisSrv.exe, MpDefenderCoreService.exe |
PsProtectedSignerLsa-Light |
lsass.exe, when LSA protection is enabled |
Experiment: observing process protection
- Start Process Explorer elevated, right-click the column headers, choose Select Columns and enable Protection in the Process Image tab.3
- Note that the processes listed above are protected even though they run as
SYSTEM,LOCAL SERVICEorNETWORK SERVICE.- Open the properties of
csrss.exeand select the Threads tab. The start addresses are shown only partially, and opening a thread fails with Unable to access thread: Process Explorer runs elevated, but it is not protected, so the thread handles it receives carry only limited rights.The protection configured for a service can be queried with
sc.exe:
1 sc.exe qprotection WinDefend
Antimalware services as PPL
Third-party security vendors can run their user-mode service as PPL
Antimalware. The vendor must ship an Early Launch Antimalware (ELAM)
driver that contains, as a resource, the certificate information of the
binaries allowed to run protected. After the ELAM driver is installed, the
service is configured with SERVICE_LAUNCH_PROTECTED_ANTIMALWARE_LIGHT, and
the Service Control Manager starts it as PPL.1
Running as PPL Antimalware gives the service two properties:
- self-protection: an administrator, or malware with administrative rights, cannot inject code into it or terminate it through the normal APIs;
- access to protected telemetry: some sources, such as the
Microsoft-Windows-Threat-IntelligenceETW provider, can be consumed only by PPLAntimalwareprocesses (see How an EDR works).1
Attacking the protection boundary
There is no supported user-mode operation that changes a running PPL into an
ordinary process. SYSTEM and SeDebugPrivilege remain below the boundary:
they may satisfy the process DACL, but the kernel still removes or denies the
rights forbidden by the target’s protection level. A runtime downgrade
therefore requires one of three conditions: code already running at a
dominating protected level, a vulnerability inside the protected process, or
the ability to execute or write from kernel mode.
The runtime protection state
The byte described earlier is represented internally by PS_PROTECTION. Its
three fields occupy the _EPROCESS.Protection member (Figure 2). This is an
implementation detail, not a documented driver interface; both the structure
layout and the member offset can change between Windows builds.
flowchart LR
B["_EPROCESS.Protection<br/>one PS_PROTECTION byte"]
T["Type: 3 bits<br/>None, ProtectedLight, Protected"]
A["Audit: 1 bit"]
S["Signer: 4 bits<br/>None ... WinSystem"]
B --> T
B --> A
B --> S
Figure 2. Logical layout of the runtime PS_PROTECTION value.
A kernel debugger can resolve the correct structure layout from symbols and
inspect this value in a laboratory. A Lsa-Light process, for example, has
type ProtectedLight and signer Lsa; an unprotected process has type and
signer None. A hard-coded offset copied from another system is unsafe: the
same offset may refer to unrelated state on a different build.
Clearing protection at runtime
With an arbitrary kernel write, an attacker can replace the protection byte
with None or otherwise corrupt the protection metadata (Figure 3). Subsequent
handle opens are then evaluated as if the target were unprotected, subject to
the ordinary DACL, token and integrity checks. Existing limited handles do not
magically gain rights; the attacker normally opens a new handle after the
downgrade.
flowchart TB
U["User-mode process<br/>SYSTEM + SeDebugPrivilege"]
O1["OpenProcess with VM or injection rights"]
K1{"Kernel compares<br/>caller and target protection"}
D["Denied or rights stripped"]
KW["Kernel debugger or exploited driver<br/>arbitrary kernel write"]
EP["Locate target EPROCESS<br/>using build-matched symbols/knowledge"]
Z["Change PS_PROTECTION to None"]
O2["Open a new target handle"]
N["Normal access check only"]
U --> O1 --> K1 --> D
KW --> EP --> Z --> O2 --> N
Figure 3. User-mode privilege does not disable PPL; modifying the kernel’s runtime metadata changes later access decisions.
The write is not persistent. At the next process start, the Service Control
Manager or the process-creation path requests the configured protection again,
Code Integrity validates the image and the kernel creates a new _EPROCESS.
The technique is nevertheless valuable to an attacker because the unprotected
window can be enough to dump credentials, inject code or terminate a security
service. A kernel adversary may also skip the downgrade and read or modify the
target’s VTL0 memory directly.
BYOVD: reaching the kernel boundary
Modern Windows normally refuses unsigned kernel code, so attackers commonly abuse a legitimately signed driver that exposes a vulnerable device-control interface. This Bring Your Own Vulnerable Driver (BYOVD) chain turns local administrative execution into a kernel read/write primitive and is covered by MITRE ATT&CK T1068 and T1562.001.45
sequenceDiagram
participant A as Administrator-level attacker
participant SCM as Service Control Manager
participant CI as Code Integrity / policy
participant D as Vulnerable signed driver
participant K as Kernel process state
participant P as Protected process
A->>SCM: Register and start a driver service
SCM->>CI: Request driver load
alt Driver allowed by signature and policy
CI-->>SCM: Load permitted
A->>D: Send input that reaches the vulnerable interface
D->>K: Expose kernel read/write capability
K->>K: Alter protection metadata or access VTL0 memory
A->>P: Open, read, inject or terminate
else Blocklist or App Control denies it
CI-->>SCM: Driver load blocked and logged
end
Figure 4. A BYOVD chain attacks the kernel trust boundary beneath PPL.
A signature proves publisher identity and file integrity; it does not prove that a driver’s IOCTL surface is safe. HVCI strengthens kernel Code Integrity, but a signed, HVCI-compatible driver with a logic vulnerability can still be dangerous unless the vulnerable-driver blocklist or an App Control policy denies it.
Trusted-code and configuration paths
Kernel modification is not the only route:
| Route | Effect | Boundary that still applies |
|---|---|---|
| Exploit a memory-safety or logic flaw in a PPL | Executes in the target’s existing protected context | Image-load policy still blocks arbitrary unsigned modules; exploit mitigations and CFG/CET still matter |
| Compromise an equal or higher protected signer | The compromised process can exercise the dominance rights of its level | Lower-signing or non-protected code cannot simply request that level |
| Abuse a trusted, signed plug-in | Runs code accepted by the target’s signature policy | The plug-in must be allowed for that signer and remains subject to Code Integrity |
| Disable launch protection in configuration, then reboot/restart | The next process instance starts unprotected | Requires control of the setting and, for UEFI-locked LSA protection, the firmware-backed state |
| Steal or duplicate a privileged handle | Reuses rights already granted to another process | Obtaining access to the source process is itself subject to PPL and Object Manager callbacks |
The inheritance and duplication rules behind the last row are covered in the
Object Manager article.
Generic handle inheritance from a PPL parent to a non-PPL child is blocked;
PPL is not bypassed merely by calling DuplicateHandle from an ordinary
administrator process.
Limits and scope of the model
PPL is an access-control and code-integrity boundary, not a complete security perimeter:
- Kernel compromise outranks it. A driver can alter VTL0 process state or access VTL0 memory directly. PPL therefore depends on Secure Boot, HVCI, driver policy and the integrity of the kernel.
- Trusted code can still contain vulnerabilities. Protection prevents an external untrusted module from loading; it does not make the protected code correct or make its inputs trustworthy.
- PPL protects a process, not every secret it handles. For LSASS, Credential Guard adds a separate VBS boundary by moving selected domain secrets into VTL1. Clearing LSASS PPL does not by itself expose those isolated values.
- Runtime state and persistent configuration differ. Changing
_EPROCESS.Protectionaffects one live instance. ChangingRunAsPPLor a service launch-protection setting affects a future start and may be blocked by UEFI lock, tamper protection or policy.6
Telemetry
Windows has no general Security event that says “_EPROCESS.Protection was
modified.” Detection therefore combines state verification with the events
that precede and follow a downgrade.
| Source | Event or state | Use and limitation |
|---|---|---|
| System log / WinInit | Event 12: LSASS started as a protected process6 |
Positive evidence that LSA protection was active at start; it does not continuously attest the runtime byte |
Process Explorer, EDR inventory, sc.exe qprotection |
Current process and service protection levels | Detects drift from an expected signer/type baseline; poll or collect centrally because the state can change without a native audit event |
| Security and System logs | 4697 and 7045: a service was installed7 |
New driver-service registration; distinguish kernel/file-system drivers from ordinary services and baseline planned installations |
| Sysmon | Event 6 (DriverLoad)8 |
Loaded driver path, hash and signature; high value when the driver is newly written, old, vulnerable or loaded from an unusual path |
| Microsoft-Windows-CodeIntegrity/Operational and App Control logs | Driver allow/deny decisions and policy violations9 | Shows a blocklist or App Control prevention and unexpected drivers that policy still permitted |
| Microsoft-Windows-CodeIntegrity/Operational | LSA plug-in audit/enforcement events 3065, 3066, 3033, 30636 |
Unsigned or incorrectly signed modules that would be, or were, refused by protected LSASS |
| Sysmon / EDR process access | Sysmon 10, Object Manager callbacks |
A successful high-rights handle to a protected target after a driver event is strong evidence; EDR pre/post callbacks can also retain denied attempts |
| Microsoft Defender | ASR and tamper-protection alerts1011 | Attempts to stage vulnerable drivers or weaken protected Defender settings |
| Boot and configuration monitoring | Changes to kernel debugging, test signing, Secure Boot, HVCI, App Control, RunAsPPL or service launch protection |
Finds preparation for the next boot or restart; registry-only monitoring is insufficient for UEFI-backed state |
Detection patterns
BYOVD sequence. Correlate a driver file written by an unusual process, a
new driver service (4697/7045), a Sysmon 6 load, device-handle and IOCTL
activity, then a high-rights handle, memory read or termination against a PPL.
The sequence is more durable than a filename rule because vulnerable drivers
and their service names change.
Protection-state drift. Maintain an allowlist of processes and expected
Type/Signer pairs. A live lsass.exe, antimalware service or sensor that
changes from protected to None without a corresponding approved restart is
a critical signal. Since the runtime write itself may be invisible to Windows
logs, state collection must be periodic or event-driven through a trusted
sensor.
Post-downgrade access. A non-protected process obtaining VM read/write,
thread-creation, termination or duplicate-handle rights to a normally higher
PPL is an invariant violation. Correlate the granted mask with dump creation,
remote-thread or image-load telemetry and subsequent security-service failure.
Sysmon 10 records successful process access, not every failed attempt, so an
EDR’s kernel callback data provides the fuller picture.
Trusted-code path. Monitor new or unusual DLLs accepted into a PPL, crashes and exploit telemetry inside the protected process, and changes to ELAM or service certificate registration. A valid signature lowers uncertainty about origin; it does not make unexpected loading benign.
Configuration downgrade. Alert when RunAsPPL, Credential Guard, HVCI,
the driver blocklist, App Control or tamper protection changes, and verify the
effective state after restart. A registry change that appears to succeed may
still be rejected by UEFI lock or tamper protection, so configuration events
must be paired with boot-time and runtime state.
Hardening
| Control | Effect |
|---|---|
LSA protection (RunAsPPL, preferably UEFI-locked) |
lsass.exe runs as PPL Lsa6 |
| Secure Boot and Memory Integrity (HVCI) | Anchor the boot chain and isolate Code Integrity in VBS so unsigned, tampered or incompatible kernel code cannot execute12 |
| Microsoft vulnerable driver blocklist | Denies known-abusable signed drivers; keep Windows and the blocklist current13 |
| App Control for Business driver policy | Replaces trust in every signed driver with an explicit organizational allow policy14 |
| ASR rule: Block abuse of exploited vulnerable signed drivers | Prevents applications from writing known-vulnerable signed drivers to disk; it complements, rather than replaces, load-time policy10 |
| Remove standing local administration | Makes driver installation and service registration harder; use controlled elevation and application deployment paths |
| Driver lifecycle management | Remove obsolete vendor drivers, patch known vulnerabilities and inventory publisher, version and hash across the fleet |
| Disable kernel debugging and test signing in production | Removes intentional paths that weaken the kernel trust boundary; monitor BCD, Secure Boot and BitLocker recovery state |
| Tamper protection | Protects supported Microsoft Defender settings from local administrative or malware changes11 |
| Security products as PPL | Prefer endpoint products whose services run as PPL Antimalware and whose ELAM certificate registrations are tightly controlled |
| Credential Guard for LSASS | Keeps selected domain secrets in VTL1 even if LSASS PPL or VTL0 memory is compromised (see the LSASS article) |
| Minimize trusted plug-ins | Remove obsolete SSPs, notification packages and in-process extensions; patch every module accepted into a PPL |
The controls form a chain. PPL stops ordinary user-mode tampering; HVCI and App Control constrain what can reach kernel mode; the blocklist removes known bad exceptions; tamper and UEFI-backed configuration resist administrative downgrades; Credential Guard limits the value of an LSASS compromise that still succeeds. Omitting any layer leaves a different path open.
Summary
Protected processes restrict the access rights that the kernel grants on a
process, independently of the caller’s token. PP, introduced in Windows
Vista for DRM, was extended in Windows 8.1 by PPL, which adds signer
levels (WinSystem, WinTcb, Windows, Lsa, Antimalware, CodeGen,
Authenticode) enforced by Code Integrity on the process image and on every
DLL it loads. A protected process can fully access only the processes it
dominates: PP over PPL, and higher signers over lower ones; everything
else, including elevated administrator tools, receives only limited rights.
Core system processes, LSASS with LSA protection and antimalware services all
run protected. SYSTEM and SeDebugPrivilege cannot disable that protection in
user mode. A runtime downgrade requires a dominating protected context, an
exploit in trusted code or kernel capability. In the kernel, the build-specific
_EPROCESS.Protection byte controls later access decisions and can be altered
for one live instance; a BYOVD attack is a common way to obtain the required
read/write primitive.
The model therefore stops at the kernel boundary. Its strength depends on Secure Boot, HVCI, App Control, the vulnerable-driver blocklist and a controlled driver lifecycle, with UEFI-backed LSA configuration and tamper protection resisting persistent downgrade. Defenders should correlate driver staging and service installation with load-time policy, runtime protection-state drift and the first high-rights access to a protected target. For LSASS, Credential Guard adds an independent VTL1 boundary for selected secrets.
References
-
Microsoft Learn, Protecting Anti-Malware Services. ↩︎ ↩︎2 ↩︎3 ↩︎4
-
P. Yosifovich, A. Ionescu, M. Russinovich, D. Solomon, Windows Internals, Part 1, 7th edition, Microsoft Press, 2017, chapter 3 (Protected processes) and chapter 7 (Security). ↩︎ ↩︎2 ↩︎3 ↩︎4
-
Microsoft Learn, Process Explorer. ↩︎ ↩︎2
-
MITRE ATT&CK, Exploitation for Privilege Escalation (T1068). ↩︎
-
MITRE ATT&CK, Impair Defenses: Disable or Modify Tools (T1562.001). ↩︎
-
Microsoft Learn, Configure added LSA protection. ↩︎ ↩︎2 ↩︎3 ↩︎4
-
Microsoft Learn, 4697(S): A service was installed in the system. ↩︎
-
Microsoft Learn, Code Integrity event log messages. ↩︎
-
Microsoft Learn, Attack surface reduction rules reference. ↩︎ ↩︎2
-
Microsoft Learn, Tamper protection overview. ↩︎ ↩︎2
-
Microsoft Learn, Enable memory integrity. ↩︎
-
Microsoft Learn, Microsoft recommended driver block rules. ↩︎
-
Microsoft Learn, Application Control for Windows. ↩︎