Skip to main content

Cloudflare Pingora EUVDEUVD-2026-104678

| CVE-2026-105297 HIGH
Allocation of Resources Without Limits or Throttling (CWE-770)
2026-10-20 cloudflare GHSA-x6pg-x323-jhc4
7.5
CVSS 3.1 · Vendor: cloudflare
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Open HTTP/2 connection to Pingora
  2. Delivery
    Send 1-byte HPACK header references
  3. Exploit
    Allocate huge header-field counts per stream
  4. Execution
    Open unlimited concurrent streams, hold via flow control
  5. Impact
    Exhaust memory and OOM-kill process

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource allocation limits
MITRE ATT&CK

1 technique across 1 tactic: Impact

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitable only against Pingora services that terminate HTTP/2 (h2 cleartext/h2c or over TLS) and do NOT explicitly set both max_header_list_size and max_concurrent_streams - i.e., services on versions before 0.8.1 that supply no H2Options, or any version using H2Options::default() (which does not include these limits). No authentication, user interaction, or special network position is required (PR:N/UI:N/AV:N). Key limiting factors: the service must actually expose HTTP/2 termination to the attacker, and deployments that already supply custom H2Options with both limits set - or that upgrade to 0.8.1+ and start from pingora_core::protocols::http::v2::server::default_h2_options() - are not vulnerable. Cloudflare's internal CDN services were not exposed because they have no HTTP/2 clients.

Impact

Signals are largely consistent in pointing to a genuine but availability-only risk. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5 HIGH) indicates a remote, unauthenticated, low-complexity attack with high availability impact and no confidentiality or integrity exposure, which matches the CWE-770 (uncontrolled resource allocation) memory-exhaustion DoS described. KEV status is NOT present, so there is no evidence of active exploitation, and no POC=YES flag is set, so there is no confirmed public exploit; however, the Cloudflare advisory states the reporter demonstrated that a single connection could OOM-kill a Pingora process with a 2 GiB limit, so the technical feasibility is vendor-confirmed even if weaponized public code is not identified. EPSS was NOT provided in the input, so probabilistic exploitation likelihood cannot be quantified here. There is no SSVC decision data in the input. Net: this is a credible, easy-to-trigger DoS worth prioritizing for any internet-facing Pingora deployment that terminates HTTP/2 with default H2Options, but it is not a confidentiality/integrity breach and is not confirmed as being exploited in the wild - treat it as a high-priority availability patch rather than a critical compromise. Note the self-limiting exposure: Cloudflare states its own CDN customers were unaffected because internal Pingora services have no HTTP/2 clients, so real risk is concentrated in third-party operators who expose Pingora's HTTP/2 termination publicly.

Exploit ScenarioDerived

A remote, unauthenticated attacker opens a single HTTP/2 (h2 or h2c) connection to an internet-facing Pingora service that uses default h2-crate limits, then sends 1-byte HPACK references to a near-empty header to force the server to allocate hundreds of thousands of header fields per stream, opening an unlimited number of concurrent streams and holding them open via HTTP/2 flow control. Memory is exhausted and the Pingora process degrades or is OOM-killed, denying service to legitimate clients. No public exploit code is identified, but the reporter demonstrated a working single-connection OOM-kill.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.3% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Oct 20, 2026

Memory exhaustion in Cloudflare Pingora's HTTP/2 server (versions before 0.8.1) lets a single remote, unauthenticated client drive the process into OOM termination by abusing HPACK header compression and HTTP/2 flow control. Because the h2 crate defaults were left in place, an attacker can emit tiny 1-byte indexed references to an almost-empty header and multiply them into hundreds of thousands of decoded header fields per stream, across an unbounded number of concurrent streams on one connection, exhausting memory (CVSS 3.1: 7.5, AV:N/AC:L/PR:N/UI:N/C:N/I:N/A:H, CWE-770). The reporter demonstrated a lone connection getting a Pingora process capped at 2 GiB OOM-killed; no public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV, but the barrier to entry is low for any internet-facing service that terminates h2 or h2c without explicit limits, while Cloudflare CDN customers were unaffected because its internal Pingora services do not front HTTP/2 clients.

RemediationAI

Upgrade to Pingora 0.8.1 or later, which by default advertises and enforces a 64 KiB decoded header-list limit and a maximum of 100 concurrent streams per connection when no H2Options are supplied; the fix commit is https://github.com/cloudflare/pingora/commit/d193c8d49b8b7c1c1ede93183759caa4f6906bbd, referenced from the project at https://github.com/cloudflare/pingora. Critically, the new defaults do not cover applications that pass their own H2Options - those must set max_header_list_size and max_concurrent_streams explicitly (this hardening also works on versions before 0.8.1), or on 0.8.1+ should start from pingora_core::protocols::http::v2::server::default_h2_options() rather than H2Options::default(), which omits both limits. Where an immediate upgrade is not possible, compensating controls include terminating HTTP/2 at an upstream proxy or load balancer that enforces its own header-list and concurrent-stream caps (adds a hop and shifts trust to that tier), disabling HTTP/2 termination entirely and serving HTTP/1.1 only where clients permit it (loses multiplexing and HPACK benefits), rate-limiting or capping connections per source IP at the edge (blunts but does not eliminate a distributed variant of the attack), and running the Pingora process under a strict memory cgroup with restart supervision so an OOM kill degrades only that worker rather than the host (contains blast radius without preventing the DoS).

Affected VersionsENISA

https://github.com/cloudflare/pingora 0.1.0 <0.8.1

Affected Packages

cargo pingora-core fix: 0.8.1
euvd https_github_com_cloudflare_pingora fix: 0.8.1

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 2 packages in cargo, euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

Pingora is Cloudflare's Rust framework for building HTTP proxies and origin services, and its HTTP/2 server side is built on the h2 crate. When an application supplies no H2Options, Pingora previously inherited h2's defaults, which impose no meaningful cap on the decoded header-list size and no limit on concurrent streams per connection; H2Options::default() likewise does not include these limits. The attack abuses HPACK, HTTP/2's header compression scheme: indexed field representations let a client reproduce a previously seen header field with a single byte, so a near-empty header block can inflate into an enormous decoded list when the server expands each reference into a full header-field allocation. Combined with an unlimited SETTINGS_MAX_CONCURRENT_STREAMS value and HTTP/2 flow-control windows that keep streams from completing, an attacker holds open a large number of streams, each carrying hundreds of thousands of decoded header fields, and memory consumption grows until the allocator or the container's memory limit is hit. This is a textbook CWE-770 (Allocation of Resources Without Limits or Throttling) issue: the root cause is missing server-side caps rather than a memory-safety bug, so exploitation requires only that the target actually terminates HTTP/2 (h2 cleartext or h2 over TLS) and has not configured both max_header_list_size and max_concurrent_streams itself.

Know when Https gets its next vulnerability

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (cloudflare) PRIMARY 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
vuln.today AI 7.5 HIGH

Remote unauthenticated client triggers reliable memory exhaustion over HTTP/2 against default config, so AV:N/AC:L/PR:N/UI:N with availability-only impact (A:H, C:N/I:N).

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (cloudflare).

CVSS VectorVendor: cloudflare

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
High

Lifecycle Timeline

2
Patch available
Oct 20, 2026 - 02:01 EUVD
CVE Published
Oct 20, 2026 - 00:40 cve.org
HIGH 7.5

DescriptionCVE.org

Summary

Before version 0.8.1, Pingora's HTTP/2 server used the h2 crate's default limits unless the application set its own 16 MiB decoded header-list size and no limit on concurrent streams. A remote, unauthenticated client can send 1-byte HPACK references to a near-empty header, making the server allocate hundreds of thousands of header fields per stream across an unlimited number of streams on one connection, and use HTTP/2 flow control to keep those streams open. This can exhaust memory and degrade or terminate the Pingora process.

Impact

Remote, unauthenticated denial of service against any Pingora service that terminates HTTP/2 (h2 or h2c) without explicitly setting max_header_list_size and max_concurrent_streams. The reporter showed that a single connection could get a Pingora process with a 2 GiB memory limit OOM-killed.

Note that Cloudflare CDN customers were unaffected, as internal Pingora services at Cloudflare do not have HTTP/2 clients.

Mitigation:

*

Upgrade to pingora 0.8.1 or later (fix: https://github.com/cloudflare/pingora/commit/d193c8d49b8b7c1c1ede93183759caa4f6906bbd ). When no H2Options are supplied, Pingora now advertises and enforces a 64 KiB decoded header-list limit and at most 100 concurrent streams per connection.

*

Applications that supply their own H2Options are not covered by these defaults and must set max_header_list_size and max_concurrent_streams explicitly (this also works on versions before 0.8.1), or, on 0.8.1 and later, start from pingora_core::protocols::http::v2::server::default_h2_options(). H2Options::default() does not include these limits.

Executive ViewAI

Why It Matters

Cloudflare Pingora services that face the internet and terminate HTTP/2 or h2c on versions before 0.8.1 can be forced into process termination by a single remote, unauthenticated client, creating an availability risk. No public exploit identified at time of analysis, but the low barrier to entry warrants immediate containment for customer-facing services. The organizational impact is service disruption and potential SLA or reputation exposure until strict limits or a vendor fix are in place.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations include disabling h2c where possible; enforcing strict HTTP/2 limits such as maximum concurrent streams, maximum header list/block size, bounded HPACK dynamic table size, and header field count; capping per-connection and process memory via cgroups/container limits; deploying an HTTP/2-aware reverse proxy or edge with request and header limits; rate-limiting connections per IP; monitoring memory, stream counts, and oversized header patterns; and using OOM protections and monitored restarts.

Threat Intelligence Overview

EPSS Score
0.3%
Top 74% exploitable
Prevalence
Medium
popular open-source Rust proxy framework, not yet ubiquitous like nginx
Data Quality
5 sources
Confidence: Medium

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

38
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +38
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

Related Vulnerabilities in Pingora HTTP/1 and HTTP/2 Processing Flaws

View all 3

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy