Important CVSS 7 EPSS 0.00246 🔬 Patch diffed 2026-08 archive

Executive Summary

Use after free in Virtual Hard Disk (VHD) Miniport Driver allows an authorized attacker to elevate privileges locally.

Overview

7
CVSS HIGH
Important
MS Severity
Not Exploited
MS Exploit Status
Less Likely
MS Exploit Likelihood
Category Elevation of Privilege
Released Aug 11 2026
Last Updated Aug 11 2026
Publicly Disclosed No
CISA KEV Not Listed
Known Exploits None Known
EPSS Score 0.00246 — 0.16011 percentile
NVD CVSS 7 HIGH — matches MSRC

CVSS Vector

CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H/E:U/RL:O/RC:C
ATTACK VECTOR
Local
ATTACK COMPLEXITY
High
PRIVILEGES REQUIRED
Low
USER INTERACTION
None
SCOPE
Unchanged
CONFIDENTIALITY
High
INTEGRITY
High
AVAILABILITY
High
EXPLOIT CODE MATURITY
Unproven
REMEDIATION LEVEL
Official Fix
REPORT CONFIDENCE
Confirmed
Temporal Score: 6.1

EPSS Score

0.00246
probability of exploitation in the next 30 days
0.16011 percentile - updated 2026-08-14
View on FIRST.org

Affected Products

18 affected products
Product KB Article Severity Impact Restart Required
Windows 10 Version 1607 for 32-bit Systems 5120418 (Security Update) Important Elevation of Privilege Yes
Windows 10 Version 1607 for x64-based Systems 5120418 (Security Update) Important Elevation of Privilege Yes
Windows 10 Version 1809 for 32-bit Systems 5120238 (Security Update) Important Elevation of Privilege Yes
Windows 10 Version 1809 for x64-based Systems 5120238 (Security Update) Important Elevation of Privilege Yes
Windows 10 Version 21H2 for 32-bit Systems 5120249 (Security Update) Important Elevation of Privilege Yes
Windows 10 Version 21H2 for ARM64-based Systems 5120249 (Security Update) Important Elevation of Privilege Yes
Windows 10 Version 21H2 for x64-based Systems 5120249 (Security Update) Important Elevation of Privilege Yes
Windows 10 Version 22H2 for 32-bit Systems 5120249 (Security Update) Important Elevation of Privilege Yes
Windows 10 Version 22H2 for ARM64-based Systems 5120249 (Security Update) Important Elevation of Privilege Yes
Windows 10 Version 22H2 for x64-based Systems 5120249 (Security Update) Important Elevation of Privilege Yes
Windows 11 Version 23H2 for ARM64-based Systems 5120240 (Security Update) Important Elevation of Privilege Yes
Windows 11 Version 23H2 for x64-based Systems 5120240 (Security Update) Important Elevation of Privilege Yes
Windows 11 Version 24H2 for ARM64-based Systems 5120994 (Security Hotpatch Update) 5121003 (Security Update) Important Elevation of Privilege 5101650 Base: 7.0 Temporal: 6.1 Vector: CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H/E:U/RL:O/RC:C 10.0.26100.9106 10.0.26100.9168 Yes None Windows 11 Version 24H2 for x64-based Systems 5121003 (Security Update) 5120994 (Security Hotpatch Update) Important Elevation of Privilege 5101650 Base: 7.0 Temporal: 6.1 Vector: CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H/E:U/RL:O/RC:C 10.0.26100.9168 10.0.26000.9106 Yes None Windows 11 Version 25H2 for ARM64-based Systems 5121003 (Security Update) 5120994 (Security Hotpatch Update) Important Elevation of Privilege 5101650 Base: 7.0 Temporal: 6.1 Vector: CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H/E:U/RL:O/RC:C 10.0.26200.9168 10.0.26100.9106 Yes None Windows 11 Version 25H2 for x64-based Systems 5121003 (Security Update) 5120994 (Security Hotpatch Update) Important Elevation of Privilege 5101650 Base: 7.0 Temporal: 6.1 Vector: CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H/E:U/RL:O/RC:C 10.0.26200.9168 10.0.26100.9106 Yes None Windows 11 Version 26H1 for ARM64-based Systems 5121000 (Security Update) Important Elevation of Privilege Yes
Windows 11 version 26H1 for x64-based Systems 5121000 (Security Update) Important Elevation of Privilege Yes
Windows Server 2016 5120418 (Security Update) Important Elevation of Privilege Yes
Windows Server 2016 (Server Core installation) 5120418 (Security Update) Important Elevation of Privilege Yes
Windows Server 2019 5120238 (Security Update) Important Elevation of Privilege Yes
Windows Server 2019 (Server Core installation) 5120238 (Security Update) Important Elevation of Privilege Yes

Patches

5 patches
Article Type Restart
5120418 Security Update Yes
5120238 Security Update Yes
5120249 Security Update Yes
5120240 Security Update Yes
5121000 Security Update Yes

Patch Diff

ghidriff · vhdmp.sys (KB5121003)

Rundown-nesting use-after-free in vhdmp.sys VhdmpiQueueIoRequest. The function read Request->VirtualDisk->Parent (+0xc8) and acquired only the parent's inner rundown (+0x610), never pinning the virtual disk (+0xd8) it read that pointer from. A concurrent detach frees the disk in the window, so the rundown acquire and the prefetch-state read (+0x5f8) operate on reclaimed pool; VhdmpiRecordForPrefetchWorker then performs an interlocked increment and an indexed 8-byte write through the freed block. Attach is unprivileged and both threads belong to the same user, so the race is self-staged. Patch acquires the disk rundown first and releases it last -- but is gated behind Feature_3417294137, so the vulnerable path still ships in the patched binary and runs when the flag is off. A sibling site at Parent+0x50 on the write path has the same missing-outer-pin shape and was not changed. Full ghidriff (10.0.26100.8972 -> .9168) shows 5 added / 7 modified functions and TWO new CFR flags: Feature_3417294137 (prefetch rundown reorder) and Feature_1070577979 (backing-store access, new VhdmpiReleaseBackingStoreAccessLocked helper). VhdmpiQueueIoRequest matched at only 28%.

Pre-patch version 10.0.26100.8972
Post-patch version 10.0.26100.9168
Loading diff…
Select a function to see its diff.
View full diff report View RCA report

Root Cause Analysis

CVE-2026-59125 — Windows vhdmp.sys Elevation of Privilege via Rundown-Nesting Use-After-Free in VhdmpiQueueIoRequest


Summary

Product Microsoft Windows — vhdmp.sys (Virtual Hard Disk Miniport Driver)
Vendor Microsoft Corporation
Severity Important
Impact Elevation of Privilege — local user to SYSTEM
CVE ID CVE-2026-59125
CVSS (MSRC) 7.0 — Exploitation Less Likely
CWE CWE-416: Use After Free
Patch Date August 11, 2026
Pre-patch binary vhdmp.sys 10.0.26100.8972 (2026-07-28, KB5101684) — SHA256 A5E97F3B5A2E49FA74DC104118667250BC8331B0BAEF5D0597F3919B301E8A8D
Post-patch binary vhdmp.sys 10.0.26100.9168 (2026-08-11, KB5121003) — SHA256 690C256F6C5045ADBEB68452A0147F802A89B3BCD49532CAA26C89654113C739

Product Description

vhdmp.sys is the kernel miniport behind every virtual hard disk format Windows supports natively — VHD and VHDX. Attaching a .vhd or .vhdx (Hyper-V, Windows Backup, Mount-VHD, WIM deployment) opens the file, parses its header and block-allocation tables, and builds an in-memory object tree that downstream I/O travels through.

Attach is unprivileged. Any local user can mount an image they own, which makes every field the parser reads off that image attacker-controlled, and makes every lifetime rule inside the resulting object tree security-relevant.


Vulnerability Summary

Each queued I/O carries a back-pointer to the virtual disk it targets. The disk object owns a rundown reference at +0xd8 that pins its whole allocation, plus a pointer at +0xc8 to a parent object — the active surface hosting the prefetch machinery. That parent carries its own inner rundown at +0x610 and a prefetch-state pointer at +0x5f8.

VhdmpiQueueIoRequest walked from the request, through the virtual disk, into the parent’s prefetch state, and took only the parent’s inner rundown. The virtual disk it read that parent pointer from was never pinned. A concurrent detach can therefore tear down the virtual disk in the window between the +0xc8 read and the +0x610 acquire — and because the parent pointer lives inside the disk’s own allocation, the rundown acquire and the subsequent prefetch-state walk operate on reclaimed pool.

The Windows rundown idiom has one nesting rule that matters here: the object you used to reach an inner object must stay pinned for as long as you hold the inner one. It is the object-lifetime analogue of “lock the parent before the child”.


Prerequisites and Constraints

  • Local authenticated session (standard user; no administrative rights)
  • Ability to attach a VHD/VHDX the attacker owns — unprivileged by design
  • Ability to issue I/O against the mounted volume (any read/write)
  • Ability to detach the same VHD concurrently — same user, so the race is self-staged
  • Prefetch must be active on the surface (PrefetchState->Ready at +0xac non-zero)
  • No kernel driver, special hardware, or pre-existing elevated token required

The trigger is entirely self-contained: one thread drives I/O, another detaches. Both are ordinary operations available to the user who mounted the image.


Vulnerability Details

Call Chain (Ghidra MCP–Verified)

Verified by get_function_xrefs against the pre-patch binary (vhdmp.sys 10.0.26100.8972). All call edges are UNCONDITIONAL_CALL.

User mode:
  Mount-VHD / AttachVirtualDisk()      → unprivileged attach
  ReadFile / WriteFile on the volume   → SCSI request into the miniport
                                          ↓
Kernel mode (vhdmp.sys):
  VhdmpParserStartIo              @ 14000365a  ┐
  VhdmpiExecuteScsi               @ 14000477b  │
    → VhdmpiExecuteScsiRequest    @ 140003eb4  ├→ VhdmpiQueueIoRequest @ 140004cc0
  VhdmpiHandleScsiParsingResult   @ 140002edb  │        [*** VULNERABLE ***]
  VhdmpiCompleteParserRequest     @ 140006621  │
  VhdmpiIssueLowerIoContext       @ 1400b117b  ┘
      → VhdmpiRecordForPrefetchWorker           [sink: writes through freed state]

Every read and write to a mounted VHD passes through this function.

Pre-patch decompilation (10.0.26100.8972)

// VhdmpiQueueIoRequest — VULNERABLE
lVar15 = *(longlong *)(*param_2 + 200);              /* param_2[0] = VirtualDisk; +200 = 0xC8 → Parent
                                                        read with NO rundown held on the disk */
if (lVar15 != 0) {
    if (ExAcquireRundownProtection(lVar15 + 0x610)) { /* +0x610 — inner rundown ONLY */
        p_Var4 = *(_VHD_PREFETCH_STATE **)(lVar15 + 0x5f8);   /* +0x5f8 — prefetch state */
        if (p_Var4[0xac] != 0)                                /* +0xac — "recordable" flag */
            VhdmpiRecordForPrefetchWorker((_VHD_SRB_EXTENSION *)param_2, p_Var4);
        ExReleaseRundownProtection(lVar15 + 0x610);
    }
}

The sink

VhdmpiRecordForPrefetchWorker immediately dereferences the prefetch state and performs an interlocked increment plus an indexed write:

lVar3 = *(longlong *)(param_2 + 0x98);      // log segment, read from the (possibly freed) state
LOCK(); *(uint *)(lVar3 + 0x10) += 1;       // interlocked increment into reclaimed pool
...
*(ulonglong *)(lVar3 + 0x18 + uVar6 * 8) = uVar4;   // indexed write, index from the same block

So the UAF is not a read-only touch: it produces an atomic increment and an 8-byte write at an index derived from the freed allocation’s own contents.

Root Cause

Three separate mistakes compound:

  1. Request->VirtualDisk (+0xc8) is dereferenced with no rundown held on the virtual disk.
  2. Only the inner rundown (Parent->+0x610) is acquired — the object that owns the pointer used to find it is left unprotected.
  3. The prefetch state pointer (+0x5f8) is read from the same unprotected allocation and passed to a function that writes through it.

The codebase already had the correct idiom available — VhdmpiAddRundownRefSurfaceByVirtualDisk @ 140002e14 exists precisely to take a surface reference via a pinned virtual disk. VhdmpiQueueIoRequest simply didn’t use it.

EX_RUNDOWN_REF is a small, frequently allocated kernel object, so the freed slot sits in a predictable pool bucket. Reclaiming it with a controlled allocation before the acquire turns the increment and the indexed write into a corrupted-kernel-object primitive rather than a bare bugcheck.


Full-diff findings (ghidriff, 10.0.26100.8972 → 10.0.26100.9168)

Targeted decompilation of VhdmpiQueueIoRequest confirmed the prefetch fix but did not show the whole patch. The full binary diff reports 5 added and 7 modified functions, and two new Controlled Feature Rollout flags:

Feature_3417294137 prefetch rundown reorder (analysed above)
Feature_1070577979 backing-store access — a second, separate lifetime fix

Added: VhdmpiReleaseBackingStoreAccessLocked. Modified: VhdmpiAcquireBackingStoreAccessLocked, VhdmpiReleaseBackingStoreAccessForSecurityContext, VhdmpiQueueIoRequest (matched at only 28%).

The backing-store change is the same class of fix — acquire/release ordering on a shared object, with a new explicitly-Locked variant introduced — but it is a distinct code path from the prefetch bug. MSRC published exactly one VHD Miniport CVE for August 2026, so either both changes belong to CVE-2026-59125, or one of them is a silent fix shipped alongside it. This is not resolved here.

Methodological note: the targeted-decompile approach confirms a hypothesis efficiently but systematically under-reports scope. The full diff is what surfaces the parts of a patch nobody told you to look for.


Patch Analysis

Patch Mechanism

The fix takes the virtual disk’s rundown first, holds it across the parent access, and releases it last — outer-before-inner, release in reverse:

// VhdmpiQueueIoRequest — PATCHED (feature-enabled branch)
lVar12 = *(longlong *)param_2;
if (ExAcquireRundownProtection(lVar12 + 0xd8)) {              /* +0xd8 — pin the DISK first */
    lVar12 = *(longlong *)(*(longlong *)param_2 + 200);       /* +0xc8 — now safe */
    if (lVar12 != 0) {
        if (ExAcquireRundownProtection(lVar12 + 0x610)) {     /* +0x610 — inner */
            p_Var4 = *(_VHD_PREFETCH_STATE **)(lVar12 + 0x5f8);
            if (p_Var4[0xac] != 0)
                VhdmpiRecordForPrefetchWorker(param_2, p_Var4);
            ExReleaseRundownProtection(lVar12 + 0x610);
        }
    }
    ExReleaseRundownProtection(*(longlong *)param_2 + 0xd8);  /* release LAST */
}

Once the disk rundown is held, the +0xc8 slot cannot be freed until it is released, which makes the parent access and everything below it safe.

Patch Completeness Assessment

Two observations that materially change the security picture, neither of which appears in the public write-up of this bug.

1. The fix is gated behind a Controlled Feature Rollout flag.

if (Feature_3417294137__private_IsEnabledDeviceUsageNoInline() == 0) {
    /* ORIGINAL VULNERABLE CODE — SHIPS VERBATIM IN THE PATCHED BINARY */
    lVar12 = *(longlong *)(*(longlong *)param_2 + 200);   // Parent, no disk pin
    if (lVar12 != 0) {
        if (ExAcquireRundownProtection(lVar12 + 0x610)) { ... }
    }
} else {
    /* fixed path shown above */
}

Both branches are present in 10.0.26100.9168. Which one executes depends on Feature_3417294137. This is an input-gated fix, not a root-cause fix — on a fully patched machine with the flag disabled, the original UAF is still reachable. Any assessment that treats “patched build installed” as equivalent to “not vulnerable” is incomplete for this CVE.

2. A sibling call site with the same shape was not changed.

The write path, roughly forty lines earlier in the same function, is byte-identical between the two builds and sits outside the feature gate:

lVar15 = *(longlong *)(param_1 + 200);              // VirtualDisk->Parent — still no disk pin
if (!ExAcquireRundownProtection(lVar15 + 0x50)) {   // different inner rundown
    // trace: "Failed to reference an active surface for write"
    return 0xc0000010;
}

Same object, reached the same unsafe way, different inner rundown (+0x50). Whether this is independently exploitable depends on whether the SRB path holds a disk reference by other means — not established here, so this is a variant lead, not a confirmed second vulnerability. Structurally it is the exact pattern the patch was written to eliminate.


Attack Path

Thread A (I/O)                     Thread B (detach)
──────────────                     ─────────────────
VhdmpiQueueIoRequest
  reads VirtualDisk->Parent (+0xc8)
  ── no rundown held on the disk ──
                                   AttachVirtualDisk detach path
                                   drains the disk rundown (+0xd8)
                                   frees the virtual disk allocation
  ExAcquireRundownProtection(
      Parent + 0x610)              ← writes into reclaimed pool
  reads PrefetchState (+0x5f8)
  VhdmpiRecordForPrefetchWorker
      LOCK inc [seg + 0x10]        ← atomic increment into reclaimed pool
      write [seg + 0x18 + idx*8]   ← 8-byte write, index from freed contents

Both threads belong to the same unprivileged user; the race needs no external trigger and can be retried indefinitely.


Detection Guidance

Crash signature. Bugchecks inside vhdmp!VhdmpiQueueIoRequest or vhdmp!VhdmpiRecordForPrefetchWorker, typically 0xC4 (Driver Verifier Detected Violation) or 0x50 (PAGE_FAULT_IN_NONPAGED_AREA), on a machine with VHD attach activity. Special Pool on vhdmp.sys plus Driver Verifier makes the window far more observable.

Behavioural. Rapid attach/detach cycling of a VHD or VHDX by a non-administrative account, concurrent with sustained I/O to the same volume, is the trigger shape. Legitimate mount workloads rarely detach while I/O is in flight, and effectively never in a tight loop.

Event sources.

  • Microsoft-Windows-VHDMP/Operational — attach and detach records
  • Microsoft-Windows-Hyper-V-VMMS/Storage
  • ETW provider Microsoft-Windows-VHDMP (VHD_START_IO is emitted from the vulnerable function itself)

Hunting query shape. Correlate AttachVirtualDisk / DetachVirtualDisk calls per-process per-minute; alert on non-SYSTEM processes exceeding a low threshold against the same image path.

Config note. Because the fix is CFR-gated, endpoint verification should not rely on file version alone. Confirming Feature_3417294137 is enabled is the only way to establish that the fixed path is actually live.


References

  • MSRC advisory — CVE-2026-59125, August 2026
  • Winbindex — vhdmp.sys version index
  • Independent write-up: tinysec.net/post/2026/08/vhdmp-vhdmpi-queue-io-request-prefetch-uaf (documents the +0x610 prefetch site; does not cover the feature gate or the +0x50 sibling site)

Attack Path

Rundown-nesting use-after-free: an I/O thread follows VirtualDisk->Parent without pinning the disk, while a concurrent detach frees it

Attack path for CVE-2026-59125 Rundown-nesting use-after-free: an I/O thread follows VirtualDisk->Parent without pinning the disk, while a concurrent detach frees it Thread A: VHD I/O Virtual disk (+0xd8) Parent surface (+0x610) Thread B: detach Attach a VHD/VHDX the attacker owns, then issue reads/writes 1 Attach is unprivileged by design. I/O reaches VhdmpiQueueIoRequest @ 140004cc0 via VhdmpParserStartIo / VhdmpiExecuteScsi / VhdmpiIssueLowerIoContext -- every read and write to the mounted volume passes through it. Reads Request->VirtualDisk->Parent at +0xc8 with NO disk rundown held 2 The parent pointer lives inside the virtual disk's own allocation. Nothing pins that allocation at this point. Concurrent detach drains the disk rundown (+0xd8) and frees the disk 3 Same unprivileged user. Process-level detach is an ordinary operation and can be retried in a loop, so the window is attacker-timed rather than incidental. ExAcquireRundownProtection(Parent + 0x610) on reclaimed pool 4 Only the inner rundown is taken. The nesting rule -- pin the object you used to reach the inner one -- is violated, so the acquire itself writes into memory that has already been returned. PrefetchState read from +0x5f8, Ready byte checked at +0xac 5 Both reads come out of the freed allocation. VhdmpiRecordForPrefetchWorker: LOCK inc [seg+0x10], write [seg+0x18+idx*8] 6 Atomic increment plus an 8-byte write, index derived from the freed block's own contents. EX_RUNDOWN_REF sits in a small, predictable pool bucket, so reclaiming the slot before the acquire turns this into a corrupted-kernel-object primitive rather than a bugcheck.

Derived from the patch delta: the checks added by the vendor identify which fields crossed a trust boundary unvalidated. Reachability and privilege are taken from the call chain in the RCA report.

Exploits & PoC

Detection Rules

Acknowledgments