Post

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.

Protected Processes: PP and PPL

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) or Protected (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 WinSystem has full access to a PP WinTcb, 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

  1. Start Process Explorer elevated, right-click the column headers, choose Select Columns and enable Protection in the Process Image tab.3
  2. Note that the processes listed above are protected even though they run as SYSTEM, LOCAL SERVICE or NETWORK SERVICE.
  3. Open the properties of csrss.exe and 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-Intelligence ETW provider, can be consumed only by PPL Antimalware processes (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.Protection affects one live instance. Changing RunAsPPL or 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

  1. Microsoft Learn, Protecting Anti-Malware Services. ↩︎ ↩︎2 ↩︎3 ↩︎4

  2. 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

  3. Microsoft Learn, Process Explorer. ↩︎ ↩︎2

  4. MITRE ATT&CK, Exploitation for Privilege Escalation (T1068). ↩︎

  5. MITRE ATT&CK, Impair Defenses: Disable or Modify Tools (T1562.001). ↩︎

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

  7. Microsoft Learn, 4697(S): A service was installed in the system. ↩︎

  8. Microsoft Learn, Sysmon. ↩︎

  9. Microsoft Learn, Code Integrity event log messages. ↩︎

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

  11. Microsoft Learn, Tamper protection overview. ↩︎ ↩︎2

  12. Microsoft Learn, Enable memory integrity. ↩︎

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

  14. Microsoft Learn, Application Control for Windows. ↩︎

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