← Back to Feed CACHED · 2026-07-20 08:38:44 · CACHE_KEY CVE-2026-44909
CVE-2026-44909 · CWE-770 · Disclosed 2026-07-16

HTTP/2 stalled flow-control denial-of-service in Apache Traffic Server and other HTTP/2 servers

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

A polite HTTP/2 client that never actually drinks the water, forcing the bartender to keep pouring until the bar collapses

CVE-2026-44909 is a class of HTTP/2 denial-of-service abuses tracked under CERT/CC VU#885548 ("stalled flow-control"). A remote unauthenticated client opens one or many streams, advertises a small or zero WINDOW_UPDATE, and never consumes buffered response bytes. Origin servers behind the proxy keep generating response data, the HTTP/2 endpoint keeps buffering it waiting for the client to open its window, and RAM runs out. Confirmed affected: Apache Traffic Server (fixed in 9.2.14 and 10.1.3 by hard-enforcing proxy.config.http2.max_active_streams_in with REFUSED_STREAM), plus advisories in progress from Citrix NetScaler ADC/Gateway, F5 BIG-IP, nginx, apache2, and Meta / Red Hat / SUSE / Yahoo stacks.

There is no vendor CVSS baseline — this is a *first assessment*. The bug is architecturally similar to Rapid Reset (CVE-2023-44487) and MadeYouReset in that it abuses HTTP/2 protocol semantics rather than an implementation memory-safety bug, so any TLS-terminating HTTP/2 proxy is a candidate. It is availability-only — no code execution, no data disclosure — but the affected footprint is the load-balancer and CDN tier that fronts every public app, and the attack requires no authentication and cheap client resources.

"Unauthenticated remote memory exhaustion against every HTTP/2 reverse proxy and load balancer on your edge — availability, not confidentiality, but fleet-wide."
02 · The Attack Path

4 steps from start to impact.

STEP 01

Locate an HTTP/2-enabled endpoint

Attacker enumerates internet-facing origins/proxies negotiating h2 via ALPN. Any BIG-IP virtual server, NetScaler content switch, ATS forward/reverse proxy, or nginx front-end with http2 on the listener qualifies.
Conditions required:
  • Public reachability of the HTTP/2 listener
  • ALPN advertises h2
Where this breaks in practice:
  • Some deployments still terminate at HTTP/1.1
  • HTTP/2 disabled behind CDNs that already mitigated Rapid Reset
Detection/coverage: Shodan/Censys alpn:h2 queries; nmap ssl-enum-ciphers + ALPN probe
STEP 02

Open streams and immediately stall flow control

Using an off-the-shelf h2 client (nghttp2, h2load, or a custom Go golang.org/x/net/http2 script), the attacker sends HEADERS for a response-heavy path (large object, dynamic report, video segment), then sends WINDOW_UPDATE = 0 or simply never acknowledges DATA frames. The server continues to fetch the origin response and buffer it in memory.
Conditions required:
  • Backend origin actually produces sizable response bodies
  • Proxy buffers response bytes rather than back-pressuring the origin
Where this breaks in practice:
  • Small-response APIs limit per-stream buffer growth
  • Some proxies stream-through without buffering when origin is HTTP/1.1 keep-alive
Detection/coverage: No IDS signature specifically for this pattern yet; look for high stream_open counts with near-zero client-side data ACK
STEP 03

Multiply streams past the advisory limit

On pre-patch Apache Traffic Server, max_active_streams_in was *advisory* — the check occurred after stream creation, so a burst of HEADERS could race past the ceiling before enforcement kicked in. The attacker opens hundreds or thousands of stalled streams per TCP connection, and scales horizontally across many source IPs.
Conditions required:
  • Race window between stream accept and limit check
  • No SETTINGS_MAX_CONCURRENT_STREAMS hard-enforcement
Where this breaks in practice:
  • Patched ATS 9.2.14 / 10.1.3 now sends REFUSED_STREAM synchronously
  • Modern nginx and Envoy enforce concurrent streams before allocating buffers
Detection/coverage: Proxy metrics: http2_streams_active divergent from http2_streams_completed
STEP 04

Exhaust memory, degrade or crash the proxy

The proxy process RSS grows monotonically as buffered response bytes accumulate. Eventually OOM-killer terminates the proxy, or health checks flip the node out of rotation. Repeat against every node in the load-balancer pool for a full-fleet outage of anything fronted by that tier.
Conditions required:
  • No cgroup / rlimit ceiling that kills the attacker's connection before killing the service
  • No connection-level memory accounting
Where this breaks in practice:
  • Proxies with per-connection memory quotas (Envoy overload_manager) shed load rather than crash
  • Anycast + autoscaling may absorb bursts
Detection/coverage: SRE-side: p99 latency spike + RSS growth + 5xx from LB tier; classic DoS telemetry
03 · Intelligence Metadata

The supporting signals.

In-the-wild exploitationNone publicly reported as of 2026-07-20. Class-level abuse (Rapid Reset, MadeYouReset) has been weaponized in the past against CDNs.
Public PoCNo named public PoC repo yet. Trivially reproducible with nghttp2 + custom WINDOW_UPDATE control or a ~30-line Go x/net/http2 client.
EPSSNot yet scored by FIRST (CVE published 2026-07-16).
KEVNot listed on CISA KEV as of 2026-07-20.
CVSSNo CNA-published CVSS. noisgate estimate: AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H` → 7.5 HIGH**.
Affected versionsApache Traffic Server ≤ 9.2.13 and ≤ 10.1.2. Additional vendors (Citrix NetScaler, F5 BIG-IP, nginx, apache2, Red Hat, SUSE, Meta, Yahoo) named in CERT/CC VU#885548 with advisories pending.
Fixed versionsApache Traffic Server 9.2.14, 10.1.3. Other vendors: track VU#885548 vendor status matrix.
Exposure populationShodan reports >4M internet-facing HTTP/2 endpoints (alpn:h2). Not all are affected implementations, but the LB/proxy tier is broadly at risk.
Disclosure date2026-07-16 (coordinated via CERT/CC).
ReporterOkta Red Team via CERT/CC coordinated disclosure.
04 · The Call

noisgate verdict.

Final Verdict
= UNCHANGED to HIGH (7.5/10)

The single decisive factor is role multiplier: the affected component class is the internet-facing HTTP/2 reverse-proxy and load-balancer tier (ATS, NetScaler, BIG-IP, nginx), where availability loss cascades to every application behind it. Impact is availability-only — no RCE, no data disclosure — which caps the verdict below CRITICAL.

HIGH Vulnerability class and Apache Traffic Server affected/fixed versions
MEDIUM Exact scope across NetScaler / BIG-IP / nginx pending vendor advisories
HIGH Impact ceiling is availability-only (no code exec pathway)

Why this verdict

  • Unauthenticated + remote + network vector — no credentials, no user interaction, no prior foothold required. This alone keeps the baseline elevated.
  • Role multiplier: the affected components are canonically network-edge appliances and reverse proxies (F5 BIG-IP, Citrix NetScaler, Apache Traffic Server, nginx). The chain succeeds against every deployment role — there is no benign role for these components. Blast radius = every application fronted by that node → tenant-scale to fleet-scale outage.
  • Availability-only impact caps the verdict — no confidentiality/integrity loss, no lateral movement, no code execution. This is the reason the verdict is HIGH and not CRITICAL.
  • Friction: cost to attacker is low, cost to defender is high — a single attacker box with an h2 client can stall gigabytes of proxy RAM. Rate limits at L4 don't help because the traffic volume is tiny.
  • No KEV, no public PoC yet — but the class (Rapid Reset lineage) has been weaponized within weeks of past disclosures, so the exploitation-timeline expectation is short.

Why not higher?

CRITICAL is reserved for chains ending in code execution, credential theft, or data exfiltration. This is a memory-exhaustion DoS; a successful attack takes the service offline but leaves the substrate intact. Recovery is a process restart, not a rebuild.

Why not lower?

MEDIUM would ignore that the affected components are the load-balancer tier for entire enterprises — a single node outage takes down every app behind it. MEDIUM would also ignore the unauthenticated network vector. The role multiplier forbids dropping below HIGH.

05 · Compensating Control

What to do — in priority order.

  1. Hard-cap per-connection HTTP/2 concurrent streams — Set SETTINGS_MAX_CONCURRENT_STREAMS to ≤ 100 and enforce synchronously. On ATS pre-9.2.14, set proxy.config.http2.max_active_streams_in low AND deploy an nginx/Envoy sidecar that enforces it hard. Deploy within 30 days per noisgate mitigation SLA for HIGH.
  2. Enable per-connection memory accounting / overload manager — On Envoy, configure overload_manager with envoy.resource_monitors.fixed_heap thresholds. On nginx, cap http2_recv_buffer_size and http2_max_field_size. On BIG-IP, apply the HTTP/2 profile memory limits per F5 KB when the advisory ships. Deploy within 30 days.
  3. Idle/stall timeout on HTTP/2 streams — Terminate streams where the client has not consumed DATA within N seconds (typically 10–30s). Kills the flow-control-stall pattern at the root.
  4. Front the proxy tier with a CDN that already mitigated the class — Cloudflare, Fastly, Akamai patched analogous flow-control bugs post-Rapid Reset. Terminating h2 at the CDN edge shifts the memory-exhaustion risk to a provider whose per-connection accounting is battle-tested.
  5. Upgrade Apache Traffic Server to 9.2.14 or 10.1.3 — The remediation path. Track vendor advisories at CERT/CC VU#885548 for NetScaler, BIG-IP, nginx, apache2 and schedule production upgrades within the noisgate remediation SLA of 180 days.
What doesn't work
  • Web Application Firewalls in signature mode — the traffic is protocol-conformant HTTP/2, no malicious payload to match.
  • L4 rate-limiting on packets/sec — attacker traffic volume is trivial; the damage is server-side buffering.
  • IP-based blocklists — attacker rotates or uses a small distributed set; per-IP thresholds high enough to allow legitimate multiplexing are also high enough to allow the attack.
  • Disabling HTTP/2 entirely — technically works but forfeits performance and breaks modern clients; only viable as an emergency lever.
06 · Verification

Crowdsourced verification payload.

Run on each Apache Traffic Server node as root or the trafficserver service user. Invoke: sudo bash check-cve-2026-44909.sh. For non-ATS proxies, replace the version probe with the vendor's equivalent (e.g., nginx -v, tmsh show sys version on BIG-IP).

noisgate-verify.sh
BASHREAD-ONLYSAFE
#!/usr/bin/env bash
# noisgate verification for CVE-2026-44909 (HTTP/2 stalled flow-control DoS)
# Target: Apache Traffic Server. Extend for other h2 proxies as needed.
set -u

VULN=0
UNKNOWN=0

if ! command -v traffic_server >/dev/null 2>&1; then
  echo "traffic_server binary not found — this host may not run ATS"
  UNKNOWN=1
else
  RAW=$(traffic_server -V 2>&1 | head -n1)
  # Expected format: "Apache Traffic Server - traffic_server - 10.1.3 - ..."
  VER=$(echo "$RAW" | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' | head -n1)
  if [ -z "$VER" ]; then
    echo "Could not parse ATS version from: $RAW"
    UNKNOWN=1
  else
    MAJOR=$(echo "$VER" | cut -d. -f1)
    MINOR=$(echo "$VER" | cut -d. -f2)
    PATCH=$(echo "$VER" | cut -d. -f3)
    echo "Detected ATS version: $VER"
    # Fixed: 9.2.14+ on 9.2.x line, 10.1.3+ on 10.x line
    if [ "$MAJOR" -eq 9 ] && [ "$MINOR" -eq 2 ] && [ "$PATCH" -lt 14 ]; then
      VULN=1
    elif [ "$MAJOR" -eq 10 ]; then
      if [ "$MINOR" -lt 1 ] || { [ "$MINOR" -eq 1 ] && [ "$PATCH" -lt 3 ]; }; then
        VULN=1
      fi
    elif [ "$MAJOR" -lt 9 ]; then
      VULN=1
    fi
  fi
fi

# Secondary check: is HTTP/2 enabled and is the stream cap set low?
CONF="/etc/trafficserver/records.config"
[ -f /opt/ts/etc/trafficserver/records.config ] && CONF=/opt/ts/etc/trafficserver/records.config
if [ -f "$CONF" ]; then
  STREAMS=$(grep -E '^\s*CONFIG\s+proxy\.config\.http2\.max_active_streams_in' "$CONF" | awk '{print $NF}')
  echo "proxy.config.http2.max_active_streams_in = ${STREAMS:-unset}"
fi

if [ "$VULN" -eq 1 ]; then
  echo "VULNERABLE"
  exit 2
elif [ "$UNKNOWN" -eq 1 ]; then
  echo "UNKNOWN"
  exit 1
else
  echo "PATCHED"
  exit 0
fi
07 · Bottom Line

If you remember one thing.

TL;DR
Monday morning: inventory every HTTP/2 termination point in your edge — F5 BIG-IP virtual servers with h2 profiles, NetScaler content switches, Apache Traffic Server, nginx front-ends, and any Envoy/ingress-controller instance. Per noisgate mitigation SLA for HIGH, deploy the hard stream-concurrency cap and per-connection memory / idle-stream timeout controls within 30 days; for ATS specifically, that means upgrading to 9.2.14 or 10.1.3, which is both mitigation and remediation. Per noisgate remediation SLA, complete the full vendor-patch rollout across NetScaler, BIG-IP, nginx, and apache2 within 180 days as their advisories publish — track CERT/CC VU#885548 for the vendor matrix. Because this is not KEV-listed and no in-the-wild exploitation is reported yet, you do NOT need to page anyone tonight, but treat the 30-day mitigation clock as firm: the class lineage (Rapid Reset) went from disclosure to weaponization inside a month.

Sources

  1. CERT/CC VU#885548 — HTTP/2 stalled flow-control DoS
  2. Apache Traffic Server security advisories
  3. CVE Project cvelistV5
  4. IETF RFC 9113 — HTTP/2 (flow control semantics)
  5. Rapid Reset class background (CVE-2023-44487)
  6. Envoy overload manager documentation
  7. nginx HTTP/2 module directives
  8. F5 BIG-IP HTTP/2 profile reference
Peer Review

What defenders are saying.

Submit a review attribution: handle + country only
0 flags selected · stored anonymously
Validation Results

Crowdsourced verification outputs.

Results submitted by users who ran the verification payload against their environment.