x64 · ARM64 · ZERO-CRT · BUILDS 26100 / 26300.9974 NT AUTHORITY\SYSTEM ADMIN / UAC GATE STANDARD USER (MED) COM MARSHALING DEFENDER: 0 THREATS NO UAC PROMPT NTELEVATOR NTELEVATOR STANDARD USER → NT AUTHORITY\SYSTEM · x64 & ARM64 LPE

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 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:

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 [timp, trev) after verifying that CoImpersonateClient succeeded at SecurityImpersonation or SecurityDelegation level. This piecewise transition creates two distinct classes of failure:

  1. Pre-impersonation parsing (t < timp). In typical configurations without automatic impersonation, Network Data Representation unmarshaling executes inside the server process under Tservice 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 ≥ trev). If the server validates a caller-controlled path, object name, or registry key during [timp, trev) 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 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

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. 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: 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, 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 [timp, trev) 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 — 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

human test