NTElevatoris a modified Zero-CRTx64andARM64research implementation derived from public CLFS and privileged remediation boundary techniques, tested on Windows 11 Pro Builds26100and26300.9974. Under a standard non-administrative account with UAC enforced and Microsoft Defender active, execution transitions from Medium Integrity toNT AUTHORITY\SYSTEMwithout an elevation prompt. Source code, compiled binaries, and reproduction primitives are withheld.
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 |
Observed execution sequence:
User holds no administrative group memberships.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.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.Analytical scope: While
NTElevatorexercises 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, andIElevator) documented across our Windows research. Both classes share the same underlying defect: privilegedSYSTEMstate machines trusting caller-influenced context across an integrity boundary. Specific RPC identifiers and trigger sequences forNTElevatorare 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.
Out-of-process COM servers running under a privileged service context rely on thread-level impersonation to enforce caller access rights. Let Teff(t) denote the effective security token evaluated by the Windows Object Manager at time t during a server method invocation, where Tservice is typically NT AUTHORITY\SYSTEM or a service-scoped token:
CoImpersonateClient window
Tserviceif t ≥ trevpost-CoRevertToSelf execution
The necessary boundary invariant is that all access checks and object handle acquisitions must execute within [timp, trev) after verifying that CoImpersonateClient succeeded at SecurityImpersonation or SecurityDelegation level. This piecewise transition creates two distinct classes of failure:
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 Tservice 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 |
Edge and Chrome)The architectural mechanics of this boundary are documented in detail in the ChromiumTap Elevation-Service Boundary analysis. 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:
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.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.SYSTEM service routinely manipulate filesystem and registry paths across the CoRevertToSelf boundary.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.
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:
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.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.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:
KERNEL32.dll, USER32.dll, RPCRT4.dll, ntdll.dll, Cabinet.dll, and bcrypt.dll, with zero C-runtime imports.RT_BITMAP resource and unpacked on demand, keeping the static PE footprint at approximately 25.5 KB with zero external runtime dependencies.The behavior recorded on Windows 11 Builds 26100 and 26300.9974 aligns with the broader engineering position documented in ChromiumTap: 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.
Every resident protection stack introduces:
SYSTEM-context inspection parsers that decode PE headers, scripts, archives, and RPC payloads from untrusted callers.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.
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, 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.
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:
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.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.
Closing privilege escalation classes across COM, marshaling, and privileged service boundaries requires architectural constraints rather than heuristic detection layers:
CoImpersonateClient or RpcImpersonateClient, confirm SecurityImpersonation or SecurityDelegation level, and open all file, registry, and section handles inside [timp, trev) rather than re-opening paths after CoRevertToSelf.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.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.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.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:
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