← Back to Feed CACHED · 2026-10-28 09:23:05 · CACHE_KEY CVE-2026-33096
CVE-2026-33096 · CWE-125 · Disclosed 2026-04-14

Windows HTTP.sys QUIC parsing out-of-bounds read denial of service

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

A padlocked front door that a locksmith proved can be kicked in — but nobody's tried it on the street yet

CVE-2026-33096 is an out-of-bounds read (CWE-125) in HTTP.sys, the kernel-mode HTTP request handler baked into every modern Windows installation. When HTTP.sys parses a crafted network request, it reads beyond the bounds of an allocated buffer, triggering a kernel bug check (BSOD) or an unresponsive state. Because HTTP.sys operates at ring 0, the crash takes down the entire OS — not just the web service. Affected products span Windows 11 23H2 through 26H1 and Windows Server 2022, 2022 23H2, and 2025. Anthropic's research team, who co-discovered the flaw alongside Microsoft's WARP/MORSE teams, confirmed it resides in the QUIC/HTTP3 parsing path within the Windows kernel and that a crash is reproducible with just a few network packets. Microsoft patched it in the April 14, 2026 Patch Tuesday rollup.

Microsoft rates this Important / HIGH (CVSS 7.5), and the base-score math is fair — unauthenticated, remote, low-complexity, automatable, full availability impact. However, the vendor's own temporal assessment drops the score to 6.5 (exploit maturity: Unproven, official fix available, confirmed). Six months post-patch, there is no public proof-of-concept, no observed exploitation, and Microsoft themselves label exploitation "Less Likely." The EPSS probability sits at ~1.25% (67th percentile) — below the median urgency threshold for most patch queues. The impact ceiling is denial of service only: no confidentiality breach, no integrity loss, no path to code execution or lateral movement. For a 10,000-host fleet with standard HA and patching cadence, the practical risk today is a notch below the vendor headline.

"Kernel-mode DoS with no PoC or exploitation drops HTTP.sys from HIGH to MEDIUM for now"
02 · The Attack Path

5 steps from start to impact.

STEP 01

Identify HTTP.sys listener

The attacker scans for targets accepting connections on TCP 80/443 or UDP 443 (HTTP/3). HTTP.sys announces itself via Server: Microsoft-HTTPAPI/2.0 headers or responds to QUIC initial packets. Shodan, Censys, and FOFA all index these banners. Anthropic estimates several million such servers face the internet.
Conditions required:
  • Target host runs Windows 11 23H2+ or Server 2022/2025
  • HTTP.sys is actively listening (IIS, WinRM, SSTP VPN, or custom HTTP Server API app)
  • For the QUIC path: HTTP/3 must be enabled on the listener
Where this breaks in practice:
  • HTTP/3 on IIS requires explicit per-site enablement in many Server 2022 configurations — not all HTTP.sys listeners expose the QUIC surface
  • Many production IIS deployments sit behind a CDN or L7 reverse proxy (Cloudflare, Azure Front Door, AWS ALB) that terminates HTTP before it reaches HTTP.sys
Detection/coverage: Qualys plugins 92369, 92370, 92380 detect missing patches. Nessus plugin coverage expected via standard MS Patch Tuesday audit. Banner scanning (Microsoft-HTTPAPI) or QUIC probing identifies exposed surfaces.
STEP 02

Craft OOB-read trigger payload

The attacker constructs a malformed HTTP or QUIC request designed to make HTTP.sys read past the end of a kernel buffer. Anthropic's research demonstrated that the trigger fits in a few network packets, meaning the payload is small and cheap to deliver. No authentication token, session cookie, or valid TLS client certificate is required.
Conditions required:
  • Knowledge of the specific malformed request structure that triggers the OOB read
  • No public PoC exists — attacker must reverse-engineer the April 2026 patch diff or independently discover the trigger
Where this breaks in practice:
  • No public exploit code or Nuclei/Metasploit module exists as of October 2026
  • Reverse-engineering the HTTP.sys patch diff is non-trivial — HTTP.sys is a large, heavily-audited kernel driver
  • The payoff (DoS only) lowers attacker motivation to invest in weaponization compared to RCE bugs
STEP 03

Deliver payload to HTTP.sys

The attacker sends the crafted packet(s) to the target's listening port. HTTP.sys processes the request in kernel mode before any application-layer logic (IIS worker process, ASP.NET pipeline, WAF module loaded in IIS) can inspect or reject it. The OOB read is triggered during protocol parsing at the driver level.
Conditions required:
  • Network reachability to the target port (TCP 80/443 or UDP 443)
  • No upstream L7 proxy normalizing or rejecting the malformed request before it reaches HTTP.sys
Where this breaks in practice:
  • Enterprise perimeter firewalls and CDNs often normalize HTTP traffic, potentially stripping or rejecting the malformed framing before it reaches the kernel driver
  • Internal-only servers (WinRM on management networks) are unreachable from the internet
Detection/coverage: Network IDS/IPS signatures for malformed HTTP/QUIC framing could detect the trigger, but no public signature exists for this specific CVE yet.
STEP 04

Kernel bug check (BSOD) or hang

HTTP.sys reads past the buffer boundary, corrupting kernel state or triggering a guard-page violation. Windows responds with a STOP error (BSOD) — the entire host crashes and reboots. All running services, in-flight transactions, and TCP connections are lost. If the target is not clustered, the service outage persists until the reboot completes.
Conditions required:
  • Steps 1-3 succeeded
  • No kernel-mode mitigation (e.g., patched driver) is in place
Where this breaks in practice:
  • Modern Windows Server deployments commonly use failover clustering, load balancers, or auto-scaling groups that health-check and redistribute traffic within seconds
  • A single crash is self-limiting — the system reboots and HTTP.sys resumes listening
Detection/coverage: Windows Event Log records BugCheck events (Event ID 1001, source BugCheck). SIEM correlation on repeated BugCheck events across multiple IIS hosts would indicate an active DoS campaign.
STEP 05

Sustain denial via repeated crashes

To maintain a persistent outage, the attacker must continuously re-send the trigger payload each time the target reboots. This creates a crash loop that keeps the server offline. For a fleet of targets, the attacker needs to automate scanning and re-crashing at scale.
Conditions required:
  • Attacker maintains network access and automation to re-trigger the crash on reboot
  • Target lacks upstream protection that would block repeated malformed requests
Where this breaks in practice:
  • Repeated BSODs are highly visible — SOC teams will notice a crash loop within minutes
  • Automated crash patterns from a single source are trivially blocked by IP-based rate limiting or firewall rules
  • DDoS mitigation services (if in front of the target) would absorb the repeated traffic
Detection/coverage: Repeated BSOD events with identical bug-check codes are a strong indicator. Correlate Windows Event ID 1001 with network flow logs showing unusual UDP/443 or HTTP traffic patterns immediately before each crash.
03 · Compensating Control

1
MEDIUM 6.5→IGNORE 0.0
SEVERITY REDUCED
Apply the April 2026 cumulative update — Install the relevant KB (KB5082052/KB5083769/KB5083768 for clients; KB5082142/KB5082060/KB5082063 for servers). This is the definitive fix — Microsoft states patching is the only recommended remediation. Per the noisgate remediation SLA for MEDIUM, deploy within 365 days. Given the SSVC 'Automatable' flag, aim for the next regular patching cycle rather than the outer bound.
2
MEDIUM 6.5→LOW 2.5
SEVERITY REDUCED
Disable HTTP/3 (QUIC) on HTTP.sys if not business-critical — Set the registry key HKLM\SYSTEM\CurrentControlSet\Services\HTTP\Parameters\EnableHttp3 to 0 (DWORD) and restart the HTTP service. Anthropic's research places the OOB read in the QUIC parsing path; disabling HTTP/3 removes the specific trigger surface while HTTP/1.1 and HTTP/2 continue to function. Verify that no application depends on HTTP/3 before deploying. No noisgate mitigation SLA applies for MEDIUM — go straight to the 365-day remediation window — but this is a zero-cost hardening step worth applying proactively.
3
MEDIUM 6.5→LOW 3.0
SEVERITY REDUCED
Front HTTP.sys with an L7 reverse proxy or CDN — Place Cloudflare, Azure Front Door, AWS ALB, or nginx in front of all internet-facing IIS endpoints. The proxy terminates and re-serializes HTTP/QUIC traffic, preventing malformed kernel-level payloads from reaching HTTP.sys directly. This is standard architecture for production web tiers and breaks attack-path step 3 entirely for external attackers.
4
MEDIUM 6.5→MEDIUM 5.0
Restrict network access to HTTP.sys management ports — Ensure WinRM (TCP 5985/5986) and other HTTP.sys-backed management services are firewalled to management VLANs only — never exposed to the internet or general user segments. This limits the attack surface to the web-serving role and eliminates the DC/management-plane vector for internal hosts.
5
MEDIUM 6.5→MEDIUM 4.5
Deploy HA clustering and health-check auto-recovery for critical IIS workloads — Use Windows Failover Clustering, a load balancer with active health checks, or auto-scaling groups to ensure that a single-node BSOD does not cause a service outage. This does not prevent the crash but limits the business impact to seconds of failover rather than minutes of downtime.
What doesn't work
  • Windows Defender / endpoint AV — This is a kernel-level protocol parsing bug triggered by network packets, not a file-based or behavior-based threat. AV signatures do not inspect HTTP.sys internal buffer handling.
  • Application-layer WAF modules loaded inside IIS — The OOB read occurs in the HTTP.sys kernel driver *before* the request is handed to the IIS worker process. IIS-hosted WAF modules (e.g., ModSecurity for IIS) never see the malformed request.
  • IP reputation blocking alone — The attack requires only a few packets from any IP. Attackers can trivially rotate source addresses. Reputation feeds add value but are insufficient as a standalone control.
  • TLS client certificate requirements — QUIC's initial handshake packets are processed before any client authentication. The OOB read can be triggered during protocol parsing, before mTLS validation occurs.
04 · Intelligence Metadata

The supporting signals.

In-the-Wild ExploitationNone observed. Microsoft rates exploitation as "Less Likely." Not listed in CISA KEV. No campaigns or threat actor attribution reported as of October 2026.
Proof-of-ConceptNo public PoC. No GitHub repos, no Metasploit/Nuclei modules, no ExploitDB entries. Anthropic confirmed a private working exploit exists (used for responsible disclosure), but it has not been released. The Anthropic research page describes the trigger as "a few packets" — a breadcrumb, not a blueprint.
EPSS0.01248 (1.25%), 66.7th percentile — below the typical urgency threshold. Feedly's early readings were lower (~0.17%, 38th percentile) and have since stabilized around 1.25%.
CISA KEVNot listed. No known exploitation in the wild; no federal remediation deadline.
CVSS v3.1 VectorCVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H — Base 7.5 (HIGH). Temporal 6.5 with E:U/RL:O/RC:C. The vector reflects the worst case: unauthenticated remote crash, no complexity gates. Impact is purely availability — zero confidentiality or integrity exposure.
SSVC AssessmentExploitation: None · Technical Impact: Partial · Automatable: Yes. The "Automatable" flag means a worm-like scanning campaign is feasible *if* a PoC materializes.
Affected VersionsWindows 11 23H2, 24H2, 25H2, 26H1 (ARM64 and x64). Windows Server 2022 (Full/Core), 2022 23H2 (Core), 2025 (Full/Core). Older OS versions (Server 2019, Server 2016, Windows 10) are not listed as affected.
Fixed BuildsWin11 23H2: ≥10.0.22631.6936 (KB5082052) · Win11 24H2: ≥10.0.26100.8246 (KB5083769) · Win11 25H2: ≥10.0.26200.8246 (KB5083769) · Win11 26H1: ≥10.0.28000.1836 (KB5083768) · Server 2022: ≥10.0.20348.5020 (KB5082142) · Server 2022 23H2: ≥10.0.25398.2274 (KB5082060) · Server 2025: ≥10.0.26100.32690 (KB5082063).
Scanner CoverageQualys plugins 92369, 92370, 92380. Nessus coverage via standard Patch Tuesday audit plugins. No GreyNoise or Shodan-based active exploitation tags observed for this CVE.
Discovery & CreditCo-discovered by Microsoft WARP/MORSE teams and Milad Nasr (Anthropic) with Claude. Anthropic found the bug via AI-assisted binary reverse engineering of a Windows kernel executable using Ghidra. Microsoft confirmed and patched it. Disclosed April 14, 2026 (coordinated, not publicly disclosed prior to patch).

Sources.

  1. MSRC Advisory
  2. NVD Entry
  3. Anthropic Research — Discovering Vulnerabilities with Claude
  4. StarLabs Patch Tuesday Detail
  5. Wiz Vulnerability Database
  6. Feedly CVE Intelligence
  7. GitHub Security Advisory GHSA-8cm7-r3pw-h7fx
  8. BleepingComputer — April 2026 Patch Tuesday
05 · The Call

Final Verdict
↓ DOWNGRADED to MEDIUM (6.5/10)

Why this verdict

  • No weaponization available: Six months post-disclosure, no public PoC, no Metasploit module, no Nuclei template, no GitHub repo. The Anthropic private exploit was never released. Reverse-engineering the patch diff in HTTP.sys is non-trivial for a DoS-only payoff. This alone drops the temporal score from 7.5 to 6.5.
  • DoS ceiling caps the blast radius: The impact is strictly availability — C:N/I:N/A:H. There is no path from this OOB read to code execution, information disclosure, or lateral movement. Even on high-value roles (ADFS, Exchange OWA, SharePoint), the worst outcome is a service outage that self-resolves on reboot, not domain compromise or data exfiltration.
  • Role multiplier: HTTP.sys on IIS web servers (typical role) — chain succeeds, outcome is per-host BSOD, blast radius is host-level. Load-balanced farms recover in seconds. HTTP.sys on ADFS / identity tier — chain succeeds if the ADFS server's QUIC/HTTP3 path is exposed, outcome is authentication outage for the duration of reboot (minutes). Blast radius is tenant-level auth disruption, but NOT identity compromise or credential theft. HTTP.sys on domain controllers (WinRM) — WinRM on DCs should never be internet-facing; internal-only access limits the attacker to post-compromise position. Outcome is DC reboot, not domain takeover. No high-value role produces an outcome meeting the HIGH floor criteria (domain takeover / fleet compromise / mass data egress / supply-chain pivot).
  • QUIC/HTTP3 surface is narrower than all of HTTP.sys: The Anthropic research localizes the bug to the QUIC parsing path. HTTP/3 requires explicit enablement on most IIS configurations. Many production IIS hosts still serve HTTP/1.1 and HTTP/2 only, reducing the reachable population below the full HTTP.sys installed base.
  • Upstream defenses break the chain for internet-facing servers: CDNs, L7 reverse proxies, and DDoS mitigation services (Cloudflare, Azure Front Door, AWS Shield) terminate and normalize traffic before it reaches HTTP.sys. Enterprises that follow best practices for public-facing IIS have this layer in place.

Why not higher?

The HIGH floor requires a high-value role where the chain produces domain takeover, fleet compromise, mass data egress, supply-chain pivot, or OT-safety impact. This vulnerability produces none of those outcomes in any role — the ceiling is a temporary service outage that ends on reboot. The QUIC/HTTP3 attack surface is narrower than HTTP.sys as a whole, further limiting the reachable population. Microsoft's own "Less Likely" exploitation assessment and six months of zero observed activity confirm the theoretical risk has not translated into practical threat.

Why not lower?

HTTP.sys is a kernel-mode driver processing untrusted network input on every Windows Server 2022+ with IIS, WinRM, or SSTP. The attack is unauthenticated, remote, requires zero user interaction, and is automatable (SSVC confirms). Anthropic demonstrated a reliable crash with just a few packets — if a PoC leaks or is independently rediscovered, mass-scanning for BSOD is trivial. A kernel crash is not a graceful degradation; it kills all services on the host. This is materially more severe than a LOW-tier advisory.

06 · Verification

Crowdsourced verification payload.

Run on each target Windows host as any authenticated user (no admin required). Execute: .\Check-CVE-2026-33096.ps1. Exit code 0 = PATCHED, 1 = VULNERABLE, 2 = UNKNOWN (OS not in affected product list).

noisgate-verify.ps1
POWERSHELLREAD-ONLYSAFE
<#
.SYNOPSIS
    Checks whether the local host is patched against CVE-2026-33096
    (HTTP.sys OOB read DoS, April 2026 Patch Tuesday).
.NOTES
    Run on target host. No admin privileges required.
    Exit codes: 0 = PATCHED, 1 = VULNERABLE, 2 = UNKNOWN
#>

$ErrorActionPreference = 'Stop'
try {
    $ntVer = Get-ItemProperty 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion'
    $buildNum = [int]$ntVer.CurrentBuildNumber
    $ubr = [int]$ntVer.UBR
    $displayVersion = $ntVer.DisplayVersion
    $productType = (Get-CimInstance Win32_OperatingSystem).ProductType
    # ProductType: 1 = Workstation, 2 = Domain Controller, 3 = Server
    $roleName = switch ($productType) { 1 {'Workstation'} 2 {'Domain Controller'} 3 {'Server'} default {'Unknown'} }
    $fullBuild = "10.0.$buildNum.$ubr"

    Write-Host "[CVE-2026-33096 Check]"
    Write-Host "OS Build   : $fullBuild"
    Write-Host "Version    : $displayVersion"
    Write-Host "Role       : $roleName"
    Write-Host ""

    # Fixed UBR thresholds per build number
    # Build 26100 has split thresholds: workstation (Win11 24H2) vs server (Server 2025)
    $fixedMap = @{
        22631 = @{ Threshold = 6936;  Label = 'Windows 11 23H2' }
        26200 = @{ Threshold = 8246;  Label = 'Windows 11 25H2' }
        28000 = @{ Threshold = 1836;  Label = 'Windows 11 26H1' }
        20348 = @{ Threshold = 5020;  Label = 'Windows Server 2022' }
        25398 = @{ Threshold = 2274;  Label = 'Windows Server 2022 23H2' }
    }

    $threshold = $null
    $label = $null

    if ($fixedMap.ContainsKey($buildNum)) {
        $threshold = $fixedMap[$buildNum].Threshold
        $label = $fixedMap[$buildNum].Label
    } elseif ($buildNum -eq 26100) {
        # Win11 24H2 (workstation) vs Server 2025 (server/DC)
        if ($productType -eq 1) {
            $threshold = 8246
            $label = 'Windows 11 24H2'
        } else {
            $threshold = 32690
            $label = 'Windows Server 2025'
        }
    } else {
        Write-Host "UNKNOWN - Build $buildNum is not in the affected product list."
        Write-Host "         This OS may not be vulnerable to CVE-2026-33096."
        exit 2
    }

    Write-Host "Product    : $label"
    Write-Host "Fixed UBR  : >= $threshold"
    Write-Host "Current UBR: $ubr"
    Write-Host ""

    if ($ubr -lt $threshold) {
        Write-Host "VULNERABLE - Build $fullBuild is below the fixed version ($threshold) for CVE-2026-33096." -ForegroundColor Red
        exit 1
    } else {
        Write-Host "PATCHED - Build $fullBuild meets or exceeds the fix for CVE-2026-33096." -ForegroundColor Green
        exit 0
    }
} catch {
    Write-Host "UNKNOWN - Error during check: $_" -ForegroundColor Yellow
    exit 2
}