---
title: 'NTElevator — Local Privilege Escalation to NT AUTHORITY\SYSTEM on Windows 11 (x64 & ARM64)'
url: 'https://kvc.pl/research/ntelevator'
markdown: 'https://kvc.pl/research/ntelevator.md'
date: '2026-11-18'
description: 'Technical research note and proof-of-concept demonstration of NTElevator: local privilege escalation from a standard non-administrative user account to NT AUTHORITY\SYSTEM across Windows 11 x64 and ARM64 (OS Builds 26100 and 26300.9974) with UAC enabled and Microsoft Defender active.'
---

# NTElevator — Local Privilege Escalation to NT AUTHORITY\SYSTEM on Windows 11 (x64 & ARM64)

> `NTElevator` is a modified Zero-CRT `x64` and `ARM64` research implementation derived from public CLFS and privileged remediation boundary techniques, tested on Windows 11 Pro Builds `26100` and `26300.9974`. Under a standard non-administrative account with UAC enforced and Microsoft Defender active, execution transitions from Medium Integrity to `NT AUTHORITY\SYSTEM` without an elevation prompt. Source code, compiled binaries, and reproduction primitives are withheld.

---

## 1. Scope, Environment, and Attribution

This note documents two concrete engineering outcomes: a native `x64` and `ARM64` Zero-CRT rebuild of the CLFS/remediation privilege-boundary class, and an empirical observation of Microsoft Defender's response under real-time protection on Builds `26100` and `26300.9974`. The video capture demonstrates the native `ARM64` build on an Oracle Ampere A1 host, while the same codebase compiles natively for `x64`. Source code, binaries, RPC interface identifiers, and step-by-step exploitation details are withheld.

| Parameter | Verification Host Specification |
|---|---|
| **Supported Targets** | Native `x64` and `ARM64` from a unified Zero-CRT C++20 codebase |
| **Video Demo Host** | Native AArch64 / ARM64, 4 OCPU Ampere A1 (`VM.Standard.A1.Flex`), 24 GB RAM, 200 GB boot volume |
| **Target OS Builds** | Windows 11 Pro `24H2` (Build `26100`) and `26H2` (Build `26300.9974`) |
| **Initial Token** | Standard local account `User` in `Users` and `Remote Desktop Users`, Medium Integrity |
| **Security Posture** | UAC enforced at default prompt level, Microsoft Defender Antivirus Service active |

---

## 2. Video Demonstration

Observed execution sequence:

1. **Privilege baseline.** The administrative session verifies platform identity and confirms that the test account `User` holds no administrative group memberships.
2. **Native ARM64 build.** `NTElevator.exe` and its companion broker module `hid.dll` compile natively for `ARM64` without C-runtime dependencies. PE resource inspection shows an application manifest and one `RT_BITMAP` payload carrier.
3. **Antivirus verification.** Scanning the compiled binary with Microsoft Defender returns zero threats while real-time protection remains active in Task Manager.
4. **Cross-boundary elevation.** After signing out and authenticating via RDP as `user`, attempting to open UAC configuration triggers an interactive credential prompt for `Administrator`. Launching `NTElevator.exe` directly spawns `cmd.exe` under `NT AUTHORITY\SYSTEM` with zero prompts.

---

## 3. Structural Weaknesses in Windows Privilege Boundaries

> **Analytical scope:** While `NTElevator` exercises the CLFS and privileged remediation boundary class visible in the build output, this section also examines the parallel COM impersonation and marshaling boundary (`CoImpersonateClient`, `CoRevertToSelf`, and `IElevator`) documented across our Windows research. Both classes share the same underlying defect: privileged `SYSTEM` state machines trusting caller-influenced context across an integrity boundary. Specific RPC identifiers and trigger sequences for `NTElevator` are omitted.

A local privilege escalation from Medium Integrity to `NT AUTHORITY\SYSTEM` is rarely the product of a missing `AccessCheck` call. It emerges at the composition boundary where user-controlled activation paths, marshaling semantics, and privileged service state machines intersect.

%%{init: {"themeVariables": {"fontFamily": "Segoe UI", "lineColor": "#0891b2", "primaryTextColor": "#083344"}, "flowchart": {"curve": "basis", "nodeSpacing": 32, "rankSpacing": 52}}}%% flowchart LR U["Standard User
Medium IL Token"] COM["COM / RPC Client
Proxy & Stub Dispatch"] NDR["NDR Unmarshaling
Attacker Buffer in SYSTEM"] IMP["CoImpersonateClient
Caller Token Window"] REV["CoRevertToSelf
Restored SYSTEM Token"] SYS["Privileged State
NT AUTHORITY\SYSTEM"] U -->|activation + marshaled OBJREF| COM COM -->|ALPC / LRPC wire frame| NDR NDR -->|method dispatch| IMP IMP -->|validation gate| REV REV -->|post-revert act-as-SYSTEM| SYS U -.->|bypasses Admin / UAC gate| SYS classDef user fill:#f1f5f9,stroke:#475569,color:#0f172a,stroke-width:1.5px; classDef boundary fill:#e0f2fe,stroke:#0284c7,color:#0c4a6e,stroke-width:1.9px; classDef danger fill:#fff7ed,stroke:#ea580c,color:#431407,stroke-width:1.8px; classDef sys fill:#ecfdf5,stroke:#059669,color:#064e3b,stroke-width:1.9px; class U user; class COM,IMP boundary; class NDR,REV danger; class SYS sys; linkStyle default stroke:#0891b2,stroke-width:1.5px; 

### 3.1. Formalizing the Impersonation Window

Out-of-process COM servers running under a privileged service context rely on thread-level impersonation to enforce caller access rights. Let *T*eff(*t*) denote the effective security token evaluated by the Windows Object Manager at time *t* during a server method invocation, where *T*service is typically `NT AUTHORITY\SYSTEM` or a service-scoped token:

**Teff(t) =**

 Tserviceif t < timpdefault RPC / NDR unmarshaling and dispatch Tcallerif timp ≤ t < trevactive `CoImpersonateClient` window Tserviceif t ≥ trevpost-`CoRevertToSelf` execution 

The necessary boundary invariant is that all access checks and object handle acquisitions must execute within \[*t*imp, *t*rev) after verifying that `CoImpersonateClient` succeeded at `SecurityImpersonation` or `SecurityDelegation` level. This piecewise transition creates two distinct classes of failure:

1. **Pre-impersonation parsing (*t* < *t*imp).** In typical configurations without automatic impersonation, Network Data Representation unmarshaling executes inside the server process under *T*service before the target COM method body begins. Any length miscalculation, pointer coercion, or type confusion in custom stub or marshaling logic executes directly at service privilege.
2. **Post-revert TOCTOU (*t* ≥ *t*rev).** If the server validates a caller-controlled path, object name, or registry key during \[*t*imp, *t*rev) and then re-opens or modifies that resource after `CoRevertToSelf`, the validation and the privileged operation occur under different security principals. Similarly, failing to verify the `HRESULT` of `CoImpersonateClient` or accepting `SecurityIdentification` silently executes subsequent operations under *T*service or fails handle delegation.

| Execution Phase | Active Token | Security Check Target | Structural Failure Class |
|---|---|---|---|
| NDR unmarshaling | `NT AUTHORITY\SYSTEM` | None on wire structure | Memory corruption, arbitrary pointer or interface unmarshal |
| `CoImpersonateClient` | Caller Medium IL | Caller DACL and IL | Safe only if all object handles are opened inside this window |
| After `CoRevertToSelf` | `NT AUTHORITY\SYSTEM` | `SYSTEM` DACL | Junction redirection, symlink race, handle or path TOCTOU |

### 3.2. Reference Case: Browser COM Elevation Services (`Edge` and `Chrome`)

The architectural mechanics of this boundary are documented in detail in the [ChromiumTap Elevation-Service Boundary analysis](https://kvc.pl/repositories/chromiumtap#security-considerations-the-elevation-service-boundary). Chromium-based browsers (`GoogleChromeElevationService`, `MicrosoftEdgeElevationService`, `BraveElevationService`) expose `IElevator` COM interfaces from a `SYSTEM` service to unwrap `os_crypt.app_bound_encrypted_key`.

Examining that design exposes three structural weak points shared across Windows elevation brokers:

1. **Identity attestation without execution provenance.** The service impersonates the caller via `CoImpersonateClient` and verifies the calling process's on-disk executable path and Authenticode signature. That gate binds trust to a static file on disk rather than to the provenance of code executing in memory. Same-user injection into a Medium-IL browser process satisfies the path and signature check by construction.
2. **Persistent `SYSTEM` token inside the broker process.** Even when `IElevator::DecryptData` does not hand a `SYSTEM` token back to the client, the `SYSTEM` token remains resident inside the service process while parsing caller-supplied DPAPI and ASN.1 blobs after `CoRevertToSelf`. A single parser defect or auxiliary file-handling method inside the service collapses the boundary.
3. **Asymmetric trust in auxiliary service methods.** Decrypt oracles that accept fixed-size byte blobs by value avoid path-based TOCTOU, whereas updater, installer, and remediation methods hosted inside the same `SYSTEM` service routinely manipulate filesystem and registry paths across the `CoRevertToSelf` boundary.

%%{init: {"themeVariables": {"fontFamily": "Segoe UI", "lineColor": "#0891b2"}}}%% sequenceDiagram autonumber participant C as Caller Process (Medium IL) participant N as RPC / NDR Layer (SYSTEM) participant S as COM Elevation Service (SYSTEM) C->>N: Invoke marshaled COM interface Note over N: Unmarshal wire payload under SYSTEM token N->>S: Dispatch method to server object S->>S: CoImpersonateClient -> Caller Medium IL S->>S: Validate caller image path + Authenticode Note over S: Blind spot: in-memory provenance unverified S->>S: CoRevertToSelf -> Restore SYSTEM token Note over S: Parse payload or act on state under SYSTEM S-->>C: Return result or side-effect across boundary 

---

## 4. COM Marshaling, Trampolines, and Cross-Architecture Execution Geometry

When a research harness interacts with out-of-process COM objects across `x64` and `ARM64`, control flow crosses multiple abstraction layers: apartment initialization, `CoCreateInstance` or moniker binding, `OBJREF` marshaling, proxy/stub vtable dispatch, and architecture-specific ABI call gates.

### 4.1. Proxy/Stub Dispatch and Marshaling Indirection

In standard COM, an interface pointer obtained across apartment or process boundaries is not a direct pointer to the server's C++ vtable. It is a pointer to a dynamically constructed proxy object backed by `RPCRT4.dll` and `combase.dll`:

- **Standard vs. Custom Marshaling.** Standard marshaling serializes parameters through MIDL-generated NDR descriptors. Custom marshaling allows an object implementing `IMarshal` to control its own `OBJREF` serialization and unmarshaling CLSID on the receiving side, shifting control over which proxy class is instantiated in the target apartment.
- **Vtable Trampolines and ABI Symmetry (`x64` and `ARM64`).** Under the Microsoft `x64` calling convention, the first four integer or pointer arguments pass in `rcx`, `rdx`, `r8`, and `r9` with `rcx` holding the implicit `this` pointer, a mandatory 32-byte shadow space, and 16-byte stack alignment; Control-Flow Enforcement Technology (`CETCOMPAT`) constrains indirect return targets. Under `ARM64` (`AArch64`), procedure calls pass the first eight arguments in `x0` through `x7` with `x0` holding `this`, `x30` (`lr`) holding the return address, and `sp` enforcing 16-byte alignment alongside Control Flow Guard and Pointer Authentication metadata. While the trampoline stub geometry differs between `x64` and `ARM64`, the logical COM marshaling and state-machine invariants remain identical across both architectures.

### 4.2. Unified Zero-CRT Footprint (`x64` & `ARM64`)

Compiling both the primary executable and companion broker modules natively for `x64` and `ARM64` with `/NODEFAULTLIB` eliminates emulation layers and removes C-runtime initialization tables from the import directory:

- **Deterministic import surface.** Dependency inspection confirms imports restricted to core Windows system libraries such as `KERNEL32.dll`, `USER32.dll`, `RPCRT4.dll`, `ntdll.dll`, `Cabinet.dll`, and `bcrypt.dll`, with zero C-runtime imports.
- **Single-binary resource carrier.** Companion modules remain compressed inside a single `RT_BITMAP` resource and unpacked on demand, keeping the static PE footprint at approximately 25.5 KB with zero external runtime dependencies.

---

## 5. Resident Security Services as a Privileged Attack Surface

The behavior recorded on Windows 11 Builds `26100` and `26300.9974` aligns with the broader engineering position documented in [ChromiumTap](https://kvc.pl/repositories/chromiumtap#why-this-blog-does-not-worship-avedr): resident antivirus and EDR agents do not form an external, unassailable boundary around the operating system. They are complex privileged software stacks executing inside Ring-0 and `NT AUTHORITY\SYSTEM`.

%%{init: {"themeVariables": {"fontFamily": "Segoe UI", "lineColor": "#0891b2", "primaryTextColor": "#083344"}, "flowchart": {"curve": "basis", "nodeSpacing": 28, "rankSpacing": 50}}}%% flowchart LR ACT["Untrusted User Action
File / Process / IPC Event"] FLT["Kernel Minifilter
Ring-0 Interception"] ENG["Privileged Scan Engine
NT AUTHORITY\SYSTEM Parser"] REM["Remediation Handler
SYSTEM File & Link Operations"] ESC["Boundary Collapse
TOCTOU / Parser LPE to SYSTEM"] ACT -->|triggers telemetry| FLT FLT -->|passes handle or path| ENG ENG -->|remediation decision| REM REM -->|path resolution / race| ESC ACT -.->|0 static detections| ENG classDef user fill:#f1f5f9,stroke:#475569,color:#0f172a,stroke-width:1.5px; classDef kernel fill:#e0f2fe,stroke:#0284c7,color:#0c4a6e,stroke-width:1.9px; classDef danger fill:#fff7ed,stroke:#ea580c,color:#431407,stroke-width:1.8px; class ACT user; class FLT,ENG kernel; class REM,ESC danger; linkStyle default stroke:#0891b2,stroke-width:1.5px; 

Every resident protection stack introduces:

- **Kernel-mode minifilters and callback drivers** that intercept filesystem, registry, and process creation events before user-mode code completes.
- **`SYSTEM`-context inspection parsers** that decode PE headers, scripts, archives, and RPC payloads from untrusted callers.
- **Privileged remediation handlers** that delete, quarantine, or restore files across user-writable directories, historically producing recurring TOCTOU and link-resolution LPE vulnerabilities.

Public vulnerability records demonstrate that this pattern spans multiple vendors: Microsoft Defender's `mpengine.dll` and platform remediation chain produced successive bypasses across 2026 (`CVE-2026-33825` BlueHammer, `CVE-2026-50656` RoguePlanet, `CVE-2026-69414` ShieldBreak), CrowdStrike Falcon's remediation engine exposed an oplock-timed TOCTOU LPE (`CVE-2026-40058` FalconFlank), Kaspersky kernel drivers exhibited IOCTL and pool defects (`klif.sys`, `kldisk.sys`), and K7 Ultimate Security exposed a named-pipe and registry LPE (`CVE-2025-67826`) alongside `K7RKScan.sys` arbitrary process-termination and DoS flaws (`CVE-2025-1055`, `CVE-2025-52915`). Public CVE advisories represent a conservative lower bound rather than the actual defect density; private audits of signed third-party drivers and privileged platform brokers routinely identify undisclosed `SYSTEM` escalation primitives that never appear in public trackers.

In the `NTElevator` demonstration, Microsoft Defender reports zero threats on static scan and remains active throughout execution, yet fails to prevent a direct transition from Medium Integrity to `NT AUTHORITY\SYSTEM`. Static reputation and signature scanning evaluate known byte patterns; they do not verify state-machine invariants across privileged OS boundaries.

### 5.1. Legacy Subsystem Composition and Sub-Ring-0 Execution

The underlying architectural constraint in Windows 11 is not a single missing check, but the continuous composition of thirty years of backwards-compatible Win32 and NT subsystems. Modern isolation mechanisms — `VBS`, `HVCI`, `PPL`, `UAC`, and resident EDR telemetry — sit atop legacy `COM`, `RPC`/`ALPC`, `Registry`, `SMSS`, reparse-point, and thread-impersonation machinery designed decades earlier under a cooperative trust model. Maintaining binary compatibility across three decades forces modern security boundaries to share mutable state with legacy parsers and cross-process brokers.

Below Ring-3 and Ring-0 altogether, the pre-boot firmware boundary remains equally exposed. As documented in [EfiTool](https://kvc.pl/research/efitool-uefi-registry-patch), execution in UEFI pre-boot space operates below the operating system kernel — intercepting `gBS->ExitBootServices` prior to NT kernel initialization and patching the `SYSTEM` registry hive directly in RAM (`SetupType` and `CmdLine`) without disk writes or kernel drivers. That mechanism remains operative on modern Windows 11 builds, confirming that OS-resident AV and EDR layers cannot govern state transitions established before Ring-0 initializes.

### 5.2. Attack-Surface Minimization and Third-Party AV/EDR Exposure

From a strict systems-engineering standpoint, installing third-party resident security suites — including **Kaspersky, ESET NOD32, K7, McAfee, SentinelOne, and CrowdStrike Falcon** — replaces a single OS-native surface with an additional, vendor-maintained Ring-0 and `SYSTEM` attack surface. Each resident agent acts as a high-privilege amplifier that an unprivileged user can intentionally stimulate through normal filesystem, process, or IPC activity:

1. **Privileged remediation as a manipulation primitive.** Quarantine, delete, and rollback handlers execute as `NT AUTHORITY\SYSTEM` on paths originally created or controlled by Medium-IL users. Any gap between path validation and file operation turns the security agent itself into an oracle for arbitrary file deletion, overwrite, or privilege escalation.
2. **Expanded Ring-0 driver surface.** Third-party minifilters, callout drivers, and telemetry collectors introduce additional IOCTL handlers, pool allocations, and kernel-to-user serialization channels that bypass standard user-mode sandboxing.
3. **Host-wide availability risk.** Kernel-mode security drivers execute at the highest privilege level without fault isolation; a single malformed channel update or out-of-bounds read in a resident driver induces immediate kernel instability across entire fleets, as demonstrated by the `CSAgent.sys` incident.

Consequently, the operational policy applied across research and production hosts on this blog is **complete avoidance of third-party resident AV/EDR agents** and **controlled suspension or removal of Microsoft Defender** where deterministic execution and minimal `SYSTEM` surface are required. Disabling or stopping Defender through native service, policy, and minifilter controls preserves Windows servicing integrity without resorting to destructive third-party removal scripts that strip system components.

---

## 6. Defensive Engineering Takeaways

Closing privilege escalation classes across COM, marshaling, and privileged service boundaries requires architectural constraints rather than heuristic detection layers:

1. **Bind resource access to the impersonation window and verify impersonation state.** Privileged COM and RPC servers must check the return status of `CoImpersonateClient` or `RpcImpersonateClient`, confirm `SecurityImpersonation` or `SecurityDelegation` level, and open all file, registry, and section handles inside \[*t*imp, *t*rev) rather than re-opening paths after `CoRevertToSelf`.
2. **Harden COM and RPC endpoint security.** Enforce `CoInitializeSecurity` with `RPC_C_AUTHN_LEVEL_PKT_PRIVACY`, restrictive security descriptors, and `RPC_IF_ALLOW_SECURE_ONLY` to eliminate unauthenticated or low-authentication broker exposure.
3. **Block reparse-point traversal rather than relying on access checks alone.** `OBJ_FORCE_ACCESS_CHECK` alone does not prevent junction or symlink redirection; pair it with `IO_STOP_ON_SYMLINK` or `FILE_FLAG_OPEN_REPARSE_POINT` and handle-based operations (`SetFileInformationByHandle`, `NtSetInformationFile`), while protecting Object Manager namespace directories against substitution.
4. **Minimize `SYSTEM`-context unmarshaling and parsing.** Custom `IMarshal` implementations and complex binary parsers should be isolated inside low-privilege AppContainer or restricted service SIDs rather than executing directly under `NT AUTHORITY\SYSTEM`.
5. **Separate identity checks from memory trust.** Validating a caller's on-disk binary path and Authenticode signature does not establish code integrity when same-user process injection is permitted; sensitive elevation operations require process-level isolation boundaries such as Protected Process Light or explicit interactive UAC consent.

---

## 7. Beyond Resident AV: Breaking OS Monoculture from Pre-Boot

Adding heavier Ring-0 minifilters and `SYSTEM`-level heuristic engines does not resolve privilege-boundary failures; as shown in Section 5, it multiplies them. Mass-market malware, commodity exploit chains, and automated post-exploitation scripts succeed primarily because every Windows endpoint is an identical instance of the same monoculture: fixed shell paths (`cmd.exe`, `powershell.exe`), invariant service and object names, deterministic DLL export tables, and uniform ABI/syscall layouts.

An alternative defensive architecture replaces passive signature scanning with **per-host OS diversification initiated from UEFI pre-boot**:

1. **Pre-boot state shaping before Ring-0 initialization.** Operating below the NT kernel at boot time — using the same pre-boot execution plane demonstrated in [EfiTool](https://kvc.pl/research/efitool-uefi-registry-patch) — allows an endpoint owner to diversify critical OS namespaces, system shell identifiers, and selected API entry-point bindings in memory before user-mode or kernel services initialize.
2. **Breaking attacker assumptions without breaking user software.** Legitimate desktop applications resolve APIs through standard dynamic linking, loader tables, and host-local configuration. A diversified endpoint preserves full functional compatibility for installed user software while invalidating hardcoded paths, static shell invocations, direct syscall assumptions, and generic payload chains built for the default Windows template.
3. **Eliminating the `SYSTEM` parser tax.** Shifting defense from reactive Ring-0/SYSTEM inspection to structural endpoint heterogeneity removes the need for third-party resident AV/EDR drivers altogether, collapsing both the remediation TOCTOU surface and the kernel-driver attack surface.

### Add a comment

---

## Navigation

- Parent: [Research](https://kvc.pl/research.md)
- Previous: [From smss.exe Early Boot to KnownDlls Kernel Injection — Investigating Windows Object Namespace Security on Windows 11 26H1](https://kvc.pl/research/knowndlls-kernel-injection.md)
