Critical CVSS 9.8 EPSS 0.2275 🔬 Patch diffed 2026-06 archive

Executive Summary

Integer overflow or wraparound in Windows HTTP.sys allows an unauthorized attacker to execute code over a network.

Overview

9.8
CVSS CRITICAL
Critical
MS Severity
Not Exploited
MS Exploit Status
More Likely
MS Exploit Likelihood
Category Remote Code Execution
Released Jun 9 2026
Last Updated Jun 9 2026
Publicly Disclosed No
CISA KEV Not Listed
Known Exploits None Known
EPSS Score 0.2275 — 0.97522 percentile
NVD CVSS 9.8 CRITICAL — matches MSRC

CVSS Vector

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

EPSS Score

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

Affected Products

30 affected products
Product KB Article Severity Impact Restart Required
Windows 10 Version 1607 for 32-bit Systems 5094122 (Security Update) Critical Remote Code Execution Yes
Windows 10 Version 1607 for x64-based Systems 5094122 (Security Update) Critical Remote Code Execution Yes
Windows 10 Version 1809 for 32-bit Systems 5094123 (Security Update) Critical Remote Code Execution Yes
Windows 10 Version 1809 for x64-based Systems 5094123 (Security Update) Critical Remote Code Execution Yes
Windows 10 Version 21H2 for 32-bit Systems 5094127 (Security Update) Critical Remote Code Execution Yes
Windows 10 Version 21H2 for ARM64-based Systems 5094127 (Security Update) Critical Remote Code Execution Yes
Windows 10 Version 21H2 for x64-based Systems 5094127 (Security Update) Critical Remote Code Execution Yes
Windows 10 Version 22H2 for 32-bit Systems 5094127 (Security Update) Critical Remote Code Execution Yes
Windows 10 Version 22H2 for ARM64-based Systems 5094127 (Security Update) Critical Remote Code Execution Yes
Windows 10 Version 22H2 for x64-based Systems 5094127 (Security Update) Critical Remote Code Execution Yes
Windows 11 Version 23H2 for ARM64-based Systems 5093998 (Security Update) Critical Remote Code Execution Yes
Windows 11 Version 23H2 for x64-based Systems 5093998 (Security Update) Critical Remote Code Execution Yes
Windows 11 Version 24H2 for ARM64-based Systems 5094126 (Security Update) Critical Remote Code Execution Yes
Windows 11 Version 24H2 for x64-based Systems 5094126 (Security Update) Critical Remote Code Execution Yes
Windows 11 Version 25H2 for ARM64-based Systems 5094126 (Security Update) Critical Remote Code Execution Yes
Windows 11 Version 25H2 for x64-based Systems 5094126 (Security Update) Critical Remote Code Execution Yes
Windows 11 Version 26H1 for ARM64-based Systems 5095051 (Security Update) Critical Remote Code Execution Yes
Windows 11 version 26H1 for x64-based Systems 5095051 (Security Update) Critical Remote Code Execution Yes
Windows Server 2012 5094042 (Monthly Rollup) Critical Remote Code Execution Yes
Windows Server 2012 (Server Core installation) 5094042 (Monthly Rollup) Critical Remote Code Execution Yes
Windows Server 2012 R2 5094041 (Monthly Rollup) Critical Remote Code Execution Yes
Windows Server 2012 R2 (Server Core installation) 5094041 (Monthly Rollup) Critical Remote Code Execution Yes
Windows Server 2016 5094122 (Security Update) Critical Remote Code Execution Yes
Windows Server 2016 (Server Core installation) 5094122 (Security Update) Critical Remote Code Execution Yes
Windows Server 2019 5094123 (Security Update) Critical Remote Code Execution Yes
Windows Server 2019 (Server Core installation) 5094123 (Security Update) Critical Remote Code Execution Yes
Windows Server 2022 5094128 (Security Update) Critical Remote Code Execution Yes
Windows Server 2022 (Server Core installation) 5094128 (Security Update) Critical Remote Code Execution Yes
Windows Server 2025 5094125 (Security Update) Critical Remote Code Execution Yes
Windows Server 2025 (Server Core installation) 5094125 (Security Update) Critical Remote Code Execution Yes

Patches

10 patches
Article Type Restart
5094122 Security Update Yes
5094123 Security Update Yes
5094127 Security Update Yes
5093998 Security Update Yes
5094126 Security Update Yes
5095051 Security Update Yes
5094042 Monthly Rollup Yes
5094041 Monthly Rollup Yes
5094128 Security Update Yes
5094125 Security Update Yes

Patch Diff

ghidriff · http.sys (KB5060842)

Remote, pre-auth kernel pool overflow (CWE-190 -> CWE-122) in HTTP.sys HTTP/1.x header parsing. UlpParseNextRequest tracks receive buffers in a per-request buffer-reference array with 16-bit capacity (+0x640) and count (+0x642) fields. When count reaches capacity it grows the array: ExAllocatePool3(0x28 + capacity*8), memmove(count<<3), then capacity += 5 as a 16-bit add WITH NO OVERFLOW CHECK. After 13,107 growths capacity=0xFFFB; +5 = 0x10000 truncates to 0. The next reference forces a grow that allocates only 0x28+0*8 = 40 bytes but memmoves count<<3 (~524,256 bytes) -> ~500KB NonPagedPool overflow. Reachable only over HTTP/1.x-over-TLS: SChannel delivers each TLS record as a separate buffer (1:1 record->reference), so an attacker sends one header line per TLS record; plaintext HTTP coalesces and cannot climb the count. Needs MaxRequestBytes >= 262144 (non-default). IN-HOUSE ghidriff diff of 10.0.26100.8521 -> .8655 confirms the ZDI/TrendAI root cause exactly and reveals the fix: the growth logic is extracted into a new routine UlpReferenceBuffers that adds new=capacity+5; if (new < capacity) bail - the missing 16-bit overflow check. The fix is GATED behind a Known Issue Rollback global UxKirRefBufferOverflowCheck: when that byte is 0 the patched binary runs the ORIGINAL unchecked growth path, so file version alone does not determine patch state. Credit: MSRC haowei yan, goodbyeselene (@ynwarcs); public analysis Yazhi Wang & Jonathan Lein (TrendAI/ZDI).

Pre-patch version 10.0.26100.8521 Download
Post-patch version 10.0.26100.8655 Download
Loading diff…
Select a function to see its diff.
View full diff report View RCA report

Root Cause Analysis

CVE-2026-47291 — Windows HTTP.sys Kernel Pool Overflow via 16-bit Integer Overflow of the Buffer-Reference Array Capacity in UlpParseNextRequest


Summary

Product Microsoft Windows — HTTP.sys (kernel-mode HTTP protocol stack)
CVE ID CVE-2026-47291
Impact Remote Code Execution (kernel) / Denial of Service
MSRC severity Critical
CWE CWE-190: Integer Overflow or Wraparound → kernel pool heap overflow
Patch Date June 9, 2026
Pre-patch binary http.sys 10.0.26100.8521 (May 2026) — SHA256 808491dc0a89fb5f7a9bade3d7ba680bd685e184fc3de610e047eba9c366a64f
Post-patch binary http.sys 10.0.26100.8655 (KB, June 9 2026) — SHA256 1a34d70a649f461745c782f1f27bcea6f6603aafd59842b3ed412181ac5c2c9a
Rollback control UxKirRefBufferOverflowCheck — the fix is behind a Known Issue Rollback (KIR) toggle

Product Description

HTTP.sys is the kernel-mode driver implementing the Windows HTTP protocol stack — request parsing, response caching and (via SChannel) TLS termination for IIS and any application that registers a URL prefix. It listens on the configured TCP ports (80/443) and is reachable pre-authentication from the network, which is what makes a memory-corruption bug here a Critical, wormable-class RCE.

The HTTP/1.x parser keeps a per-request state object with a dynamically grown buffer-reference array: one 8-byte entry per receive buffer consumed while parsing. Three fields drive it (offsets from our diff):

  • capacity at +0x640 — allocated slot count, a 16-bit field
  • count at +0x642 — slots in use, a 16-bit field
  • ref_array_ptr at +0x648 — pointer to the entry array

Vulnerability Summary

While parsing HTTP/1.x header lines, UlpParseNextRequest adds a buffer reference each time it consumes a new receive buffer. When count reaches capacity, it grows the array. The growth arithmetic increments the 16-bit capacity by 5 with no overflow check:

// UlpParseNextRequest (http.sys 10.0.26100.8521) — PRE-PATCH, inline growth, from our diff
if (*(ushort *)(state + 0x642) < *(ushort *)(state + 0x640)) {   // count < capacity: fast path
    ref_array[count]     = new_buffer;
    *(short *)(state + 0x642) += 1;                              // count++
}
else {                                                          // grow
    _Dst = ExAllocatePool3(0x42, (ulonglong)capacity * 8 + 0x28, ...);   // 0x28 + capacity*8
    if (_Dst) {
        memmove(_Dst, ref_array_ptr, (ulonglong)count << 3);    // copy count*8 bytes
        if (1 < capacity) ExFreePoolWithTag(ref_array_ptr, 0);
        *(short *)(state + 0x640) = capacity + 5;               // *** capacity += 5, 16-bit, NO CHECK ***
        ref_array_ptr = _Dst;
    }
}

After 13,107 growth events capacity = 0xFFFB. The next growth computes 0xFFFB + 5 = 0x10000, which truncates to 0x0000 in the 16-bit field. On the following buffer reference, count (now ≥ 65,536) exceeds the zeroed capacity, forcing another growth — but this time the allocation is 0x28 + 0*8 = 40 bytes, while the memmove copies count << 3 ≈ 524,256 bytes from the old array into the 40-byte buffer. The result is a kernel NonPagedPool overflow of ~500 KB with attacker-influenced contents.


Prerequisites and Constraints

  • Remote, unauthenticated — AV:N, PR:N. Reachable by anyone who can open an HTTPS connection to the server.
  • HTTP/1.x over TLS only. HTTP/2 and HTTP/3 use different parser paths that do not touch this array. Body parsing (Content-Length / chunked) does not grow it either — only header parsing does.
  • One header line per TLS record. Over TLS, SChannel delivers each TLS application-data record to the parser as a separate buffer via UlHttpBufferReceiveEvent(), giving a 1:1 record→reference mapping. Plaintext HTTP coalesces segments (and UlpMergeBuffers merges further), so the count never climbs — the bug is specific to the per-record TLS delivery path.
  • Non-default MaxRequestBytes. ~65,536 references at ~4 bytes/line ≈ 262 KB of request; the server must have MaxRequestBytes ≥ 262,144 (default 16,384, which caps at ~4,000 lines). Keeping MaxRequestBytes ≤ 65,535 is the configuration mitigation.
  • Slow: at ~10 ms/record the overflow takes ~11 minutes of sustained connection.

Vulnerability Details

Call Chain

Remote attacker (no auth), HTTPS:
  many TLS application-data records, one HTTP/1.x header line each
        ↓  (SChannel decrypts per-record)
Kernel (http.sys):
  UlHttpBufferReceiveEvent -> UlpCopyIndicatedData
    -> UlpParseNextRequest            [*** 16-bit capacity overflow -> undersized alloc ***]
         ExAllocatePool3(0x28 + capacity*8)   // 40 bytes after wrap
         memmove(count << 3)                  // ~500 KB copy  -> POOL OVERFLOW
    -> UlpAdjustBuffers (non-merge path advances to next buffer)

Root Cause

capacity is a 16-bit counter incremented by a constant 5 with no check that the addition stays within 16 bits. Once it wraps to 0 the allocation size (derived from capacity) collapses to the 40-byte base while the copy length (derived from count) does not — a classic size-desync heap overflow born from an integer-width overflow (CWE-190 → CWE-122).

The patch

The June build extracts the growth logic out of UlpParseNextRequest into a new routine UlpReferenceBuffers and adds the missing overflow check — but ships both the old and corrected paths, selected at runtime by the global UxKirRefBufferOverflowCheck:

// UlpReferenceBuffers (http.sys 10.0.26100.8655) — PATCHED, from our diff
uVar3 = *(ushort *)(state + 0x640);                 // capacity
if (uVar3 <= *(ushort *)(state + 0x642)) {          // count >= capacity: grow
    if (UxKirRefBufferOverflowCheck == '\0') {
        /* ORIGINAL vulnerable path: ExAllocatePool3(0x28 + capacity*8),
           memmove(count<<3), capacity += 5  — no overflow check */
    }
    else {
        uVar6 = uVar3 + 5;                           // new capacity
        if (uVar6 < uVar3) goto bail;               // *** 16-bit overflow check ***
        pvVar5 = ExAllocatePool3(0x42, (ulonglong)uVar6 << 3, ...);
        if (pvVar5 == NULL) goto bail;
        memmove(pvVar5, ref_array_ptr, (ulonglong)count << 3);
        if (1 < capacity) ExFreePoolWithTag(ref_array_ptr, 0);
        *(ushort *)(state + 0x640) = uVar6;         // store the checked value
        ref_array_ptr = pvVar5;
    }
}

The fix is one comparison — new = capacity + 5; if (new < capacity) fail; — the exact 16-bit wraparound guard that was missing.

Patch Completeness Assessment

The fix is behind a Known Issue Rollback (KIR) toggle. The corrected branch runs only when the global byte UxKirRefBufferOverflowCheck is non-zero; when it is zero, the patched binary executes the original unchecked growth and remains overflowable. The Kir in the symbol name marks this as a Known Issue Rollback control — Microsoft’s mechanism for disabling a servicing change in the field without pulling the update. So, exactly as with the CFR feature-flag gating seen across the CLFS, lserver and tapisrv fixes in this corpus, file version alone does not determine patch state: a machine on .8655 with the KIR toggle rolled back still has the reachable overflow. The pattern now spans a remote, pre-auth, Critical kernel RCE — implemented here as a KIR global rather than a Feature_NNNN CFR flag, but with the same “both paths ship” consequence.


Detection Guidance

Decrypted inspection (preferred). Count header field lines per HTTP/1.x request; more than ~1,000 in a single request on one connection is suspicious (ZDI’s threshold). Legitimate requests rarely exceed a few dozen headers.

Encrypted heuristic. Without decryption, watch for a single TLS session carrying a large number (>1,000) of small application-data records, each holding one short payload — the per-record header delivery the exploit depends on. Higher false-positive rate (interactive streaming can look similar).

Duration. The attack needs sustained connection (~11 min at 10 ms/record); long-lived HTTPS connections emitting a steady stream of tiny records are a supplementary signal.

Crash signature. Bugchecks inside http.sys around UlpParseNextRequest / UlpReferenceBuffers / memmove, NonPagedPool corruption. Special Pool on http.sys makes the overrun land on a guard page at the copy.

Config. Confirm MaxRequestBytes (under HKLM\SYSTEM\CurrentControlSet\Services\HTTP\Parameters) is ≤ 65,535 on any host where the KIR-gated fix cannot be guaranteed enabled.


Mitigation

  • Patch (MS June 2026) — and ensure the KIR toggle UxKirRefBufferOverflowCheck is enabled; the fix is inert if the Known Issue Rollback is active.
  • MaxRequestBytes ≤ 65,535 blocks the request size needed to reach the wrap, for unpatched or KIR-rolled-back hosts.
  • Terminate/inspect TLS at a proxy that enforces a sane header-count limit.

References

  • ZDI / TrendAI Research — CVE-2026-47291: Remote Code Execution in the Windows HTTP.sys (Yazhi Wang, Jonathan Lein). thezdi.com/blog/2026/7/9/...
  • MSRC advisory — CVE-2026-47291 (HTTP.sys Remote Code Execution)
  • Full binary diff: /data/patch_diffs/http_sys-cve-2026-47291-ghidriff.md

Attack Path

One HTTP header line per TLS record overflows a 16-bit array-capacity counter, desyncing a 40-byte allocation from a ~500KB memmove in the kernel

Attack path for CVE-2026-47291 One HTTP header line per TLS record overflows a 16-bit array-capacity counter, desyncing a 40-byte allocation from a ~500KB memmove in the kernel 01 — ENTRY Remote unauthenticated attacker opens an HTTPS (TLS) connection to HTTP.sys AV:N, PR:N. HTTP.sys listens on 443 pre-auth. The bug is specific to HTTP/1.x over TLS - HTTP/2 and HTTP/3 use different parser paths that never touch the buffer-reference array. 02 — CONTROLLED INPUT Sends one HTTP/1.x header line per TLS application-data record SChannel decrypts each TLS record independently and delivers it as a separate buffer via UlHttpBufferReceiveEvent, giving a 1:1 record->buffer-reference mapping. ~65,536 tiny records (~262KB) are needed; MaxRequestBytes must be >= 262144 (non-default). 03 — PATH UlpParseNextRequest grows the buffer-reference array by 5 slots each time count reaches capacity capacity (+0x640) and count (+0x642) are 16-bit fields. Growth: ExAllocatePool3(0x28 + capacity*8), memmove(count<<3), capacity += 5. 04 — MISSING CHECK capacity += 5 is a 16-bit add with no overflow check After 13,107 growths capacity = 0xFFFB; the next += 5 gives 0x10000, truncated to 0x0000 in the 16-bit field. count (>= 65,536) now exceeds the zeroed capacity, forcing one more grow. 05 — PRIMITIVE 40-byte allocation vs ~500KB memmove -> kernel NonPagedPool overflow -> RCE/DoS The wrap makes ExAllocatePool3 request 0x28 + 0*8 = 40 bytes while memmove copies count<<3 (~524,256 bytes) into it - a ~500KB kernel heap overflow. Bugcheck (DoS) or, under controlled layout, kernel code execution. The June fix (UlpReferenceBuffers: if (capacity+5 < capacity) bail) is gated behind the KIR toggle UxKirRefBufferOverflowCheck.

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

Microsoft
haowei yan
goodbyeselene