Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend HTTP/2 request with mismatched Host and :authority
-
DeliveryRequest filters and access checks evaluate :authority value
-
ExploitUpstream receives and routes on client-supplied Host
-
ExecutionResponse cached under victim authority's key
-
ImpactPoisoned content served to other users
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V4 - API and Web Service HTTP request consistency
|
| Exploitation Conditions | Three concrete conditions must hold simultaneously: (1) the Pingora instance (before 0.9.0) accepts HTTP/2 connections directly from clients; (2) the application makes security or caching decisions from the request URI authority - i.e., request_filter logic, host-based access controls, or cache keys read session.req_header().uri / :authority; and (3) the upstream routes by the Host header and serves different content per Host (explicitly required for the cache-poisoning outcome). The attack needs no authentication (PR:N) and no user interaction (UI:N) and succeeds with a single request. Limiting factors: deployments that do not accept client HTTP/2, or that do not use the request authority for security or caching decisions, are not affected; Cloudflare's internal Pingora services (no HTTP/2 clients) were unaffected. |
| Impact | This is a conditional, moderate-risk request-routing discrepancy rather than a drop-everything priority. The provided CVSS 4.0 vector (6.3, Medium) reports NO impact to the vulnerable Pingora system itself (VC:N/VI:N/VA:N) and only Low confidentiality/integrity impact to subsequent systems (SC:L/SI:L), which correctly models the real harm: other users and other virtual hosts, not the proxy. Crucially the vector sets AT:P (attack requirements present), signaling that successful exploitation depends on specific environmental conditions, not merely sending a packet - consistent with the description's caveat that cache poisoning 'also requires the upstream to serve different content per Host' and that only deployments using the request authority for security/caching are affected. Attack is network-reachable and unauthenticated (AV:N/PR:N/UI:N), which raises exposure, but the preconditions cap real-world likelihood. No EPSS score was provided, so statistical exploitation probability cannot be assessed - this is a gap. There is no CISA KEV listing and no public exploit was identified, so despite a plausible high-impact outcome (cache poisoning affecting many users), there is currently no evidence of weaponization. Net: a legitimate issue to patch for affected architectures, but not a universal emergency; the vendor explicitly notes Cloudflare's own CDN customers were unaffected because internal Pingora services have no HTTP/2 clients. |
| Exploit ScenarioDerived | A remote, unauthenticated attacker sends a single crafted HTTP/2 request in which the :authority pseudo-header names the victim host but the client-supplied Host header names a different virtual host. Pingora's request filters, access controls, and cache key read the :authority while the upstream routes on the forwarded Host, so a response from the attacker-chosen virtual host is cached under the victim's key and later served to other users, or a host-based access control check passes for one host while a different host actually serves the request. No public exploit code was identified at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 20, 2026
A request-routing discrepancy in Cloudflare Pingora before 0.9.0 lets an unauthenticated remote attacker send a single HTTP/2 request that the proxy evaluates under one authority while the upstream receives a different Host, so Host-based filters, access controls, or cache keys can be applied to the wrong virtual host. Exploitation is conditional and moderate risk: the deployment must terminate client HTTP/2 in Pingora, make security or caching decisions from the request URI authority, and sit in front of an upstream that routes by Host and serves different content per Host. The outcome is limited-impact confidentiality and integrity exposure on the downstream component (possible cache poisoning or host-based access-control bypass); there is no public exploit code and no confirmed active exploitation at time of analysis, and Cloudflare's own CDN path was unaffected because its internal Pingora services do not accept HTTP/2 from clients.
RemediationAI
Upgrade to Pingora 0.9.0 or later, which rejects with 400 Bad Request any HTTP/2 request whose Host differs from :authority, that carries more than one Host, or whose authority contains userinfo, and normalizes the upstream Host/:authority to the request authority; the two upstream fix commits are 915590a91811877795531f6ba0927a3138b5cb4b and ffab8302d08d4292d1924eb8fe84647fd5cb8e76 in https://github.com/cloudflare/pingora. If the upgrade cannot be scheduled, add a request_filter that rejects client HTTP/2 requests where the Host header differs from the URI authority or where the authority contains '@' - this preserves protection but will also reject the rare legitimate client that legitimately sends an explicit Host differing from :authority or an authority with userinfo, so audit proxy and SDK behavior before enabling it in blocking mode. As a broader containment step, stop accepting client HTTP/2 at the affected listener (HTTP/1.1 only) where HTTP/2 termination is not required, which removes the divergence path entirely at the cost of losing multiplexing and header-compression benefits. Audit any downstream caches and host-routed virtual hosts for entries written under a mismatched authority before the fix was applied.
Affected VersionsENISA
Affected Packages
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 proxy framework, used both as an origin-facing reverse proxy and as an embeddable HTTP stack. The defect is an HTTP/2 authority-versus-Host interpretation conflict (no CWE was assigned; the behavior matches the request-interpretation-conflict class). RFC 9113 Section 8.3.1 requires an intermediary to derive Host from the :authority pseudo-header and to discard or replace any client-supplied Host field, and to reject userinfo in the authority. Pingora did neither: on the HTTP/2-to-HTTP/1.1 translation path it generated Host from :authority only when no Host header was present, so a conflicting client Host was passed upstream unchanged; on the HTTP/2-to-HTTP/2 path it stripped the client Host and used it to overwrite the upstream :authority, but only after request filters had already executed against the original :authority. The server also performed no Host/:authority equality check and accepted authority values containing '@' (for example user@example.com). Because session.req_header().uri exposes the :authority while the upstream routes on Host, application logic and transport can diverge with no malformed request involved. Fixes in 0.9.0 make the server return 400 Bad Request for mismatched Host/:authority, multiple Host fields, or userinfo in the authority, and keep the upstream Host or :authority consistent with the request authority.
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
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:N/SC:L/SI:L/SA:N
Remote single request with no auth or interaction (AV:N/PR:N/UI:N), but success requires specific upstream per-Host routing and authority-based security config so AC:H; harm falls on other users/vhosts (S:C, C:L/I:L).
Primary rating from Vendor (cloudflare).
CVSS VectorVendor: cloudflare
Lifecycle Timeline
1DescriptionCVE.org
Summary
Before version 0.9.0, Pingora accepted HTTP/2 requests whose Host header differed from the :authority pseudo-header. Request filters, cache keys, and logs that read the request URI (session.req_header().uri) saw the :authority value, but the upstream received the client-supplied Host value. Pingora also accepted :authority values containing userinfo (for example, user@example.com). This violates RFC 9113 Section 8.3.1, which requires an intermediary to use the :authority value for Host and replace any existing Host field.
Root cause
*
HTTP/2 to HTTP/1.1: Host was generated from :authority only when the request had no Host header, so a conflicting client Host was forwarded unchanged.
*
HTTP/2 to HTTP/2: the client Host header was removed and used to overwrite the upstream :authority, after request filters had already run against the original :authority.
*
The HTTP/2 server did not compare Host with :authority and did not reject userinfo in the authority.
Impact
A remote, unauthenticated attacker can send a single HTTP/2 request that the application sees as one host and the upstream receives as another. Where request filters, access controls, or cache keys use the URI authority and the upstream routes by Host, this can lead to:
*
Cache poisoning: a response from another virtual host is stored under the victim host's cache key and served to other users (this also requires the upstream to serve different content per Host).
*
Host-based access control bypass: a request approved for one host is served by a different virtual host on the upstream.
Deployments that do not accept HTTP/2 from clients, or that do not use the request authority for security or caching decisions, are not affected.
Note that Cloudflare CDN customers were unaffected, as internal Pingora services at Cloudflare do not have HTTP/2 clients.
Mitigation:
*
Upgrade to pingora 0.9.0 or later. Pingora now returns 400 Bad Request for HTTP/2 requests whose Host differs from :authority, that contain more than one Host, or whose authority contains userinfo, and keeps the upstream Host or :authority consistent with the request authority. Fix commits: https://github.com/cloudflare/pingora/commit/915590a91811877795531f6ba0927a3138b5cb4b , https://github.com/cloudflare/pingora/commit/ffab8302d08d4292d1924eb8fe84647fd5cb8e76
*
If you cannot upgrade: in request_filter, reject HTTP/2 requests that carry a Host header different from the URI authority, or whose authority contains '@'.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.
HTTP request smuggling exploits inconsistencies in how front-end and back-end servers parse HTTP message boundaries.
Related Vulnerabilities in Pingora HTTP/1 and HTTP/2 Processing Flaws
View all 3Remote code execution in the archived Cloudflare pages-action GitHub Action (src/index.ts) allows network-adjacent attac
Authenticated SQL injection in the WP Review Slider Pro WordPress plugin through version 12.6.8 lets Subscriber-level us
SQL injection in the WP Review Slider Pro WordPress plugin (versions ≤12.6.8) allows authenticated attackers with Subscr
Arbitrary file deletion in the WP Review Slider Pro WordPress plugin (versions up to and including 12.6.8) allows authen
SQL injection in the WP Review Slider Pro WordPress plugin (versions up to and including 12.7.2) lets unauthenticated at
EUVD-2026-104695
GHSA-fqwv-pcm9-9m42
NVD
CVE.org
EPSS
Exploit-DB