← Back to Feed CACHED · 2026-10-07 00:00:15 · CACHE_KEY CVE-2026-42980
CVE-2026-42980 · CWE-122 · Disclosed 2026-06-09

NT OS Kernel Elevation of Privilege via WMI Integer Underflow

ASSESSED — NOISGATE
Vendor
—
—
—
Reassessed
—
—
—
Verdict: —
Do you agree?
01 · The Real Story

A subtraction without a safety net that lets any local user become God on every Windows box

CVE-2026-42980 is an integer underflow in the Windows NT kernel's WMI serialization layer — specifically in nt!WmipQuerySingleMultiple and nt!WmipQueryAllDataMultiple inside ntoskrnl.exe. When processing multi-instance WMI queries through IOCTL 0x228130 on \Device\WMIDataDevice, the kernel subtracts an aligned provider-reported record size from a 32-bit remaining-output counter *without checking whether the subtraction would go negative*. The unsigned result wraps to a massive value (~0xFFFFFFFC), blowing past all subsequent boundary checks and enabling a controlled heap-based buffer overflow. Affected versions span Windows 10 Version 1607 through current, Windows 11 22H2–26H1, and Windows Server 2012 through 2025 — essentially every supported Windows release. A weaponized public PoC by researcher G4sp4rCS was released around July 7, 2026, roughly four weeks after Microsoft's June 2026 Patch Tuesday fix.

Microsoft rated this Important / 7.8 HIGH with an "Exploitation More Likely" exploitability assessment — and that call is reasonable but slightly optimistic given the current threat landscape. The vendor's temporal score of 6.8 was set with E:U (Unproven exploit code); that assumption is now stale. The PoC demonstrates a reliable multi-stage chain: named-pipe pool grooming → WMI underflow trigger → NP_DATA_QUEUE_ENTRY corruption → arbitrary kernel read/write → SYSTEM token theft. The local/authenticated prerequisite applies genuine friction against drive-by exploitation, but this is *exactly* the kind of post-access privilege escalation that ransomware operators and red teams weaponize immediately. On domain controllers and other identity-tier hosts, SYSTEM access is functionally equivalent to domain admin. We keep the vendor's HIGH 7.8 as the correct severity — but flag it as an urgent HIGH that should not be deprioritized just because it's "only local."

"Public PoC turns kernel WMI underflow into instant SYSTEM — every Windows host is in scope."
02 · The Attack Path

6 steps from start to impact.

STEP 01

Obtain low-privilege code execution on target host

The attacker needs an authenticated session on the target Windows machine — any domain user or local account with interactive/remote logon rights suffices. In practice this comes from phishing (initial access to a workstation), credential stuffing, compromised service accounts, or lateral movement from an already-compromised host via PSRemoting, RDP, or PsExec.
Conditions required:
  • Low-privilege local or domain user account on the target
  • Ability to execute arbitrary code (shell, script, or uploaded binary)
Where this breaks in practice:
  • Requires prior initial access — this is not a remote unauthenticated exploit
  • EDR/AV on the endpoint may detect the exploit binary or its behavioral signature
Detection/coverage: EDR behavioral detection on suspicious child-process spawning; SIEM correlation of unusual interactive logons to high-value servers.
STEP 02

Open handle to WMI kernel device

The exploit opens a handle to \Device\WMIDataDevice and prepares an IOCTL 0x228130 request targeting the multi-instance WMI query path. Any authenticated user can reach this device node — no special privileges or group memberships are required. The call surface is part of the default Windows kernel and cannot be disabled without breaking WMI entirely.
Conditions required:
  • Code execution on the host (from step 1)
  • WMI subsystem operational (default on all Windows installs)
Where this breaks in practice:
  • WMI cannot be disabled on production systems without breaking SCCM, monitoring, and management tooling
  • Application-whitelisting (WDAC/AppLocker) may block the exploit binary from executing
Detection/coverage: Sysmon Event ID 1 (process creation) combined with DeviceIoControl call monitoring; Snort 2 rules 66572-66577 and Snort 3 rules 301523-301525 (Talos June 2026 Patch Tuesday coverage).
STEP 03

Heap grooming via named pipe spray

The exploit sprays approximately 4,096 named pipe allocations at size 0xFF0 bytes each to condition the kernel non-paged pool. It selectively frees one pipe to create a precisely-sized 4KB hole, then forces the WMI SystemBuffer allocation into that gap. This deterministic heap layout is necessary for the subsequent overflow to corrupt a predictable adjacent object.
Conditions required:
  • Ability to create named pipes (any authenticated user)
  • Sufficient system memory for ~4096 pool allocations
Where this breaks in practice:
  • Named pipe spray at this volume may trigger behavioral EDR heuristics
  • Pool randomization on newer Windows builds adds some non-determinism, though the PoC accounts for this
Detection/coverage: Monitor for rapid named pipe creation events (>1000 in <1 second) from non-privileged processes; ETW kernel pool allocation tracing.
STEP 04

Trigger integer underflow and corrupt adjacent pool object

The crafted WMI IOCTL causes OutBufferSize -= AlignedActualSize to wrap to ~0xFFFFFFFC, bypassing subsequent boundary validation. The kernel writes out-of-bounds into the adjacent freed pipe slot, corrupting NP_DATA_QUEUE_ENTRY structures belonging to a neighboring named pipe. This gives the attacker a kernel-mode read/write primitive via the corrupted pipe metadata.
Conditions required:
  • Successful heap grooming (step 3)
  • Vulnerable ntoskrnl.exe (unpatched, pre-June 2026 CU)
Where this breaks in practice:
  • If June 2026 patch is applied, branchless saturating subtraction clamps counter to zero and IOCTL fails safely
  • HVCI/VBS-enabled systems may constrain what the attacker can do with the write primitive
Detection/coverage: Kernel crash dumps (BSoD) from failed exploitation attempts; Windows Defender Exploit Guard memory integrity alerts.
STEP 05

Achieve arbitrary kernel read/write and steal SYSTEM token

Using the corrupted pipe metadata, the attacker leaks kernel pointers to defeat KASLR, then executes a secondary underflow to gain a stable arbitrary read/write primitive. The exploit walks the EPROCESS linked list, locates the System process (PID 4) token, and copies it to the attacker's process — a classic token-swapping technique. The attacker's process now runs as NT AUTHORITY\SYSTEM.
Conditions required:
  • Successful pool corruption (step 4)
  • Ability to read/write named pipe data (any user)
Where this breaks in practice:
  • Credential Guard may protect some credential material even after SYSTEM is obtained
  • On domain controllers, post-exploitation activity (DCSync) may trigger identity-tier detection
Detection/coverage: Detect SYSTEM-level process spawned by a low-privilege parent; ETW Security audit Event ID 4672 (special privilege assigned) and Event ID 4624 Type 2.
STEP 06

Post-exploitation: domain escalation on identity-tier targets

On a domain controller, SYSTEM access is equivalent to domain admin. The attacker can perform DCSync via Mimikatz, dump NTDS.dit, forge golden tickets, or pivot to any domain-joined host. On a Hyper-V host, SYSTEM enables VM configuration access. On ADCS servers, SYSTEM enables CA private key extraction and rogue certificate issuance.
Conditions required:
  • SYSTEM access on target (step 5)
  • Target is a high-value asset (DC, Hyper-V, ADCS, backup server)
Where this breaks in practice:
  • Tier-0 monitoring and PAW architecture limits who can interactively log onto DCs
  • Network segmentation may limit lateral movement after escalation
Detection/coverage: DCSync detection (replication requests from non-DC sources); ADCS certificate enrollment anomalies; Hyper-V management event log monitoring.
03 · Compensating Control

1
HIGH 7.8→IGNORE 0.0
SEVERITY REDUCED
Apply June 2026 cumulative updates on Tier-0 assets immediately — Deploy the relevant KB (KB5093998 and related) to all domain controllers, ADCS servers, Hyper-V hosts, and backup infrastructure first. This is the only complete fix — Microsoft confirmed there is no configuration workaround. Per the noisgate mitigation SLA for HIGH severity, begin fleet-wide deployment within 30 days; prioritize Tier-0 within 7 days given the public PoC.
2
HIGH 7.8→MEDIUM 5.5
SEVERITY REDUCED
Enforce WDAC / AppLocker on high-value servers — Windows Defender Application Control in enforced mode prevents unsigned or unauthorized binaries — including the exploit — from executing on protected hosts. Does not fix the vulnerability but breaks step 1 of the attack path for any binary not on the allow list. Deploy within 30 days on all Tier-0 and Tier-1 servers.
3
HIGH 7.8→MEDIUM 5.0
SEVERITY REDUCED
Restrict interactive logon to Tier-0 assets via PAW and tiered admin — Limit which accounts can obtain interactive or remote shells on domain controllers, ADCS, and Hyper-V hosts using Privileged Access Workstations and tiered administration group policies. If low-privilege users cannot get a shell on a DC, the domain-takeover attack path is broken at step 1. This is a long-term architectural control; begin scoping within 30 days.
4
HIGH 7.8→MEDIUM 6.0
SEVERITY REDUCED
Enable VBS and HVCI on all compatible hardware — Virtualization-Based Security and Hypervisor-protected Code Integrity harden the kernel against arbitrary code execution even after memory corruption. While not a guaranteed block for this specific token-manipulation chain, they significantly constrain post-exploitation options and raise exploit complexity. Enable across the fleet within 30 days.
5
HIGH 7.8→HIGH 7.0
Deploy EDR detection rules for named pipe spray and SYSTEM token theft — Configure EDR to alert on rapid named pipe creation (>1000 pipes in <1 second from a single non-SYSTEM process) and on SYSTEM-level process spawning from low-integrity parents. Monitor ETW Security audit Event IDs 4672 and 4624 Type 2. This is detection-only — it does not prevent exploitation but shortens dwell time. Deploy detection rules within 7 days.
What doesn't work
  • Disabling WMI — breaks SCCM/MECM, monitoring agents, Group Policy processing, and most enterprise management tooling. Not viable in any production environment.
  • Network segmentation alone — this is a local privilege escalation; network controls do not affect the exploit path once the attacker has code execution on the host. Segmentation helps limit *lateral movement to* the target, not the LPE itself.
  • Windows Firewall rules — the exploit uses a local kernel IOCTL (0x228130 to \Device\WMIDataDevice), not a network protocol. Host firewall rules are irrelevant to this attack path.
  • Credential Guard — protects LSASS-cached credentials but does not prevent the SYSTEM token theft itself. The attacker still achieves SYSTEM; Credential Guard only limits which *additional* credentials they can harvest afterward. On a DC, DCSync does not require LSASS credential access.
04 · Intelligence Metadata

The supporting signals.

In-the-wild exploitationNo confirmed exploitation as of 2026-10-07. Not listed on CISA KEV. Microsoft assessed as "Exploitation More Likely" — their highest non-exploited urgency rating.
Proof-of-conceptPublic PoC available. G4sp4rCS/CVE-2026-42980-POC released ~July 7, 2026. Fork by ohio813. Multi-stage exploit: named pipe heap spray → WMI IOCTL underflow → NP_DATA_QUEUE_ENTRY corruption → arbitrary kernel R/W → SYSTEM token theft → elevated shell. Confirmed functional on lab builds.
EPSS0.00333 (0.333%) per user-provided data. Some aggregators report higher values (3.2–5.66%); EPSS updates daily. Even at the lower bound, the public PoC and Microsoft's "More Likely" tag make EPSS a lagging indicator here.
KEV statusNot listed on CISA Known Exploited Vulnerabilities catalog as of 2026-10-07.
CVSS vectorCVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H (base 7.8). Temporal: E:U/RL:O/RC:C → 6.8, though E:U (Unproven) is stale given the public PoC. Interpretation: local attack, low complexity, low privilege, no user interaction, unchanged scope, full confidentiality/integrity/availability impact.
Affected versionsWindows 10 (1607, 1809, 21H2, 22H2), Windows 11 (22H2, 23H2, 24H2, 25H2, 26H1), Windows Server 2012/R2, 2016, 2019, 2022, 2025 including Server Core. Every supported Windows release.
Fixed versions / KBsJune 2026 Patch Tuesday (2026-06-09): KB5093998, KB5094041, KB5094042, KB5094122, KB5094123, KB5094125, KB5094126, KB5094127, KB5094128, KB5095051. Superseded by any July 2026 or later cumulative update.
Scanning / exposureLocal-only exploit — no internet-facing attack surface. Shodan/GreyNoise/Censys not applicable. Tenable and Qualys have detection plugins. Talos Snort 2 rules 66572-66577 and Snort 3 rules 301523-301525 cover June 2026 Patch Tuesday kernel vulnerabilities.
Disclosure timeline2026-06-09: Microsoft advisory + patch (June Patch Tuesday). ~2026-07-07: Public PoC released by G4sp4rCS. 2026-07-29: NVD last updated.
Reporter / researcherPoC author: G4sp4rCS (GitHub). Original vulnerability reporter not publicly credited by Microsoft in available advisories.

Sources.

  1. Microsoft Security Response Center — CVE-2026-42980
  2. G4sp4rCS PoC — CVE-2026-42980-POC (GitHub)
  3. CVE Reports — Technical Analysis
  4. Senserva — CVE-2026-42980 Patch Details and Affected Versions
  5. Talos Intelligence — June 2026 Patch Tuesday Snort Rules
  6. Mallory.ai — Public PoC Enables SYSTEM Privilege Escalation
  7. Tenable — CVE-2026-42980
  8. Strix.ai — CVE-2026-42980 Heap Buffer Overflow Analysis
05 · The Call

Final Verdict
= UNCHANGED to HIGH (7.8/10)

Why this verdict

  • Vendor baseline is fair. Microsoft's CVSS 7.8 accurately reflects the local/authenticated prerequisite with full CIA impact. The vector AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H is technically correct for what this vulnerability does on a single host.
  • Public PoC eliminates exploit-development friction. G4sp4rCS released a working multi-stage exploit roughly four weeks post-patch. Microsoft's temporal E:U (Unproven) designation is now stale. The exploit requires no exotic conditions — just a low-privilege shell and an unpatched kernel. Ransomware operators and red-team frameworks routinely absorb public kernel LPE PoCs.
  • Local prerequisite applies genuine downward friction. The attacker must already have code execution on the target host. This is not remotely exploitable, which limits mass-exploitation scenarios and excludes drive-by or wormable attack patterns. This friction prevents an upgrade to CRITICAL.
  • Role multiplier: Domain controllers (verdict floor = HIGH). ntoskrnl.exe runs on every Windows host including DCs. SYSTEM on a DC = DCSync = full domain takeover. DCs represent ~2-5% of a typical enterprise Windows fleet but constitute 100% of the identity trust plane. The chain succeeds: compromised domain user → lateral movement to DC → this LPE → SYSTEM → DCSync → domain compromise. Blast radius: domain-scale.
  • Role multiplier: Hyper-V hosts. SYSTEM on a Hyper-V host grants access to VM configurations and potentially guest VM virtual disk storage. Blast radius: fleet-scale. Chain succeeds if attacker reaches the hypervisor host with any local account.
  • Role multiplier: ADCS / certificate authority servers. SYSTEM on an ADCS server enables CA private key extraction and rogue certificate issuance. Blast radius: domain-scale trust compromise.
  • Microsoft's "Exploitation More Likely" aligns with the public PoC reality. This is Microsoft's highest-urgency tag short of confirmed exploitation. Combined with a functional PoC, four months since patch availability, and the universal attack surface of ntoskrnl.exe, the risk of adoption by threat actors is elevated and rising.

Why not higher?

An upgrade to CRITICAL would require either remote/unauthenticated access, confirmed in-the-wild exploitation, or wormable characteristics — none of which apply here. The local/authenticated prerequisite means the attacker must already have a foothold on the target host, which is a compounding friction point that narrows the reachable population per-hop. The EPSS remains at 0.333%, CISA has not added it to KEV, and no threat intelligence vendor has reported active campaigns leveraging this CVE as of October 2026.

Why not lower?

A downgrade below HIGH is blocked by the deployment-role floor. The affected component is ntoskrnl.exe — the Windows kernel itself — present on every Windows host in the enterprise including domain controllers, Hyper-V hosts, ADCS servers, and backup infrastructure. On any identity-tier or infrastructure-tier target, SYSTEM access translates to domain-scale or fleet-scale compromise. A working public PoC exists, Microsoft assessed exploitation as "More Likely," and the vulnerability affects every supported Windows release. These factors combined make a downgrade below HIGH indefensible.

06 · Verification

Crowdsourced verification payload.

Run this script on each target Windows host as any user (no admin required for hotfix enumeration). Invoke with: powershell -ExecutionPolicy Bypass -File .\Check-CVE-2026-42980.ps1. The script checks whether any of the 10 fixing KBs from June 2026 Patch Tuesday are installed, or whether a superseding cumulative update has been applied.

noisgate-verify.ps1
POWERSHELLREAD-ONLYSAFE
# Check-CVE-2026-42980.ps1
# Verifies whether the host is patched against CVE-2026-42980
# NT OS Kernel integer underflow -> Elevation of Privilege
# Exit codes: 0 = PATCHED, 1 = VULNERABLE, 2 = UNKNOWN

$ErrorActionPreference = 'Stop'

$fixingKBs = @(
    'KB5093998',
    'KB5094041',
    'KB5094042',
    'KB5094122',
    'KB5094123',
    'KB5094125',
    'KB5094126',
    'KB5094127',
    'KB5094128',
    'KB5095051'
)

try {
    $installed = @()
    try {
        $installed = Get-HotFix -ErrorAction SilentlyContinue |
            Select-Object -ExpandProperty HotFixID
    } catch {
        # Fallback to CIM/WMI
        $installed = (Get-CimInstance -ClassName Win32_QuickFixEngineering -ErrorAction SilentlyContinue).HotFixID
    }

    if (-not $installed -or $installed.Count -eq 0) {
        Write-Host 'UNKNOWN - Could not enumerate installed hotfixes.'
        exit 2
    }

    $matched = $fixingKBs | Where-Object { $installed -contains $_ }

    if ($matched.Count -gt 0) {
        Write-Host "PATCHED - Found fixing update(s): $($matched -join ', ')"
        exit 0
    }

    # Check for superseding cumulative update (July 2026 or later)
    $laterCU = Get-HotFix -ErrorAction SilentlyContinue |
        Where-Object {
            $_.InstalledOn -and $_.InstalledOn -ge [DateTime]'2026-07-01'
        } |
        Sort-Object InstalledOn -Descending |
        Select-Object -First 1

    if ($laterCU) {
        Write-Host "PATCHED - Superseding cumulative update found: $($laterCU.HotFixID) installed $($laterCU.InstalledOn.ToString('yyyy-MM-dd'))"
        exit 0
    }

    Write-Host "VULNERABLE - None of the fixing KBs are installed and no superseding CU found."
    Write-Host "Fixing KBs: $($fixingKBs -join ', ')"
    Write-Host 'Action: Apply the June 2026 cumulative update for your OS version.'
    exit 1

} catch {
    Write-Host "UNKNOWN - Error during check: $($_.Exception.Message)"
    exit 2
}