Severity:

CRITICAL RISK

(9.1)

HTTP Request Smuggling in Pingora HTTP/1.0 and

CVE-2026-2835

Analyzed

Vulnerability type

Category:

HTTP Request Smuggling

CWE:

CWE-444

Impact:

Proxy Desync Leading to ACL Bypass, Cache Poisoning, and Cross-User Attacks

Severity:

CRITICAL RISK

(9.1)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

A request smuggling vulnerability in Pingora's HTTP parser allows crafted HTTP/1.0 and malformed Transfer-Encoding requests to desynchronize how Pingora and backend servers interpret request boundaries.

Under specific backend configurations that accept HTTP/1.0 and ambiguous message framing, an attacker can smuggle hidden requests through the proxy to bypass controls, poison shared connections, and target other users.

Affected context

This issue affects deployments where Pingora is used as a standalone reverse proxy in front of backends that:

  • Accept HTTP/1.0 requests
  • Tolerate close-delimited request bodies
  • Allow multiple or ambiguous Transfer-Encoding headers
  • Do not strictly enforce RFC 9112 message framing semantics

In these configurations, Pingora's interpretation of request length and boundaries can diverge from the backend's, creating an opportunity for HTTP request smuggling.

Exploit preconditions

  • Attack surface: HTTP endpoints exposed through a Pingora proxy, reachable by an attacker over the network.
  • Required access: Ability to send arbitrary HTTP requests to Pingora (no prior authentication necessarily required, depending on deployment).
  • Trigger point: Submission of specially crafted HTTP/1.0 or malformed HTTP/1.x requests using:
  • Close-delimited bodies for HTTP/1.0, and/or
  • Multiple or inconsistent Transfer-Encoding headers, or
  • Conflicting message length indicators.
  • Why exploitation is possible: Pingora's parser previously:
  • Allowed HTTP/1.0 request bodies to be treated as close-delimited, and
  • Mishandled multiple Transfer-Encoding values,

causing the proxy's view of where one request ends and the next begins to differ from the backend's framing, enabling a smuggled "hidden" request.

Why this happens

The root cause is a mismatch between Pingora's HTTP parsing behavior and strict RFC 9112 requirements for message length handling.

By:

  • Permitting HTTP/1.0 request bodies to be close-delimited, and
  • Not strictly rejecting requests with multiple or ambiguous Transfer-Encoding headers,

Pingora accepted ambiguous framing that backends could interpret differently.

This maps to CWE-444: Inconsistent Interpretation of HTTP Requests ('HTTP Request Smuggling'), where front-end and back-end components disagree on HTTP message boundaries, allowing hidden requests to be tunneled through trusted intermediaries.

Potential impact

  • Attackers may bypass proxy-level ACLs, IP-based controls, and WAF rules by hiding requests inside smuggled payloads.
  • Attackers could poison shared upstream connections, causing legitimate users to receive responses intended for an attacker's smuggled request.
  • Session hijacking and cross-user request forgery could occur by making malicious requests appear to originate from the proxy's trusted IP.
  • Cache poisoning may lead to delivery of attacker-controlled content to subsequent users.
  • Reduced integrity and reliability of backend applications due to desynchronized request routing and logging.

General mitigation guidance

Effective mitigation focuses on enforcing unambiguous HTTP message framing and aligning proxy/backend behavior with modern RFCs:

  • Parse request length strictly according to RFC 9112, disallowing close-delimited request bodies for HTTP requests.
  • Reject any non-HTTP/1.1 request at the proxy boundary if not strictly required by the application.
  • Enforce rules that:
  • Disallow multiple Transfer-Encoding headers, and
  • Require an exact Transfer-Encoding: chunked match when Transfer-Encoding is present.
  • Reject requests with invalid or conflicting Content-Length and Transfer-Encoding combinations.
  • Normalize and validate inbound headers before forwarding to backends, avoiding divergent interpretations.
  • Configure backends to follow the same strict framing rules as the proxy, reducing front-end/back-end parsing inconsistencies.
  • Minimize connection reuse or apply stricter isolation (e.g., per-client or per-tenant pooling) where smuggling risk is a concern.

How teams detect issues like this

Detection strategies generally focus on identifying ambiguous framing paths and anomalies in proxy-backend behavior:

  • Static and configuration analysis:
  • Scan proxy configuration and code for logic that accepts HTTP/1.0 with bodies or allows close-delimited request bodies.
  • Flag handling of multiple Transfer-Encoding headers or non-strict checks on Content-Length.
  • Verify adherence to RFC 9112 in message length computation.
  • Code review signals:
  • Places where HTTP request parsing relies on custom logic for message boundaries.
  • Conditional branches that treat HTTP/1.0 differently or allow fallback to connection-close semantics for bodies.
  • Logic that forwards headers to backends without normalization or conflict checks.
  • Runtime and log-based detection:
  • Monitoring for requests containing both Content-Length and Transfer-Encoding headers, or multiple Transfer-Encoding values.
  • Detecting unexpected 4xx/5xx patterns on backends following unusual client requests.
  • Alerting on inconsistent request/response pairing or misaligned logging (e.g., responses without clear corresponding requests).
  • Automated tools:
  • Use HTTP smuggling testing tools and DAST scanners that probe for CL/TE, TE/TE, and protocol-version desync patterns.

Sources

SourceLink
github.comgithub.com/cloudflare/pingora

Frequently asked

questions

Yes, in typical deployments where Pingora is exposed as an internet-facing reverse proxy and fronts backends that accept HTTP/1.0 and ambiguous framing, an attacker can exploit this remotely by sending crafted HTTP requests.

Not necessarily. If the vulnerable endpoints are publicly accessible and do not require authentication for initial requests, an unauthenticated attacker can attempt smuggling attacks. Authentication requirements will depend on how Pingora and the protected applications are deployed.

The safest approach is to enforce strict, RFC-compliant HTTP parsing and message length handling at the proxy:

  • Only accept well-formed HTTP/1.1 requests where possible.
  • Reject ambiguous or conflicting Content-Length and Transfer-Encoding combinations.
  • Ensure front-end and back-end components use consistent, clearly defined parsing rules so that no smuggled data can be interpreted as a separate request downstream.

Prevention relies on:

  • Adopting strict protocol compliance (e.g., RFC 9112) across the stack.
  • Centralizing and hardening HTTP parsing logic rather than re-implementing it in multiple places.
  • Integrating security-focused code review and automated testing that explicitly checks for CL/TE, TE/TE, and protocol version desync scenarios.
  • Regularly validating proxy and backend configurations to ensure they do not accept legacy or ambiguous framing behaviors unless absolutely necessary.
Find out what's already
exploitable in your codebase.