/

CVE-2026-54387

Severity:

CRITICAL RISK

(9.1)

HTTP Request Smuggling (CWE-444) in Tinyproxy Proxy

CVE-2026-54387

Deferred

Vulnerability type

Category:

HTTP Request Smuggling

CWE:

CWE-444

Impact:

Request Smuggling leading to cache poisoning and access control bypass

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

Tinyproxy up to version 1.11.3 contains an HTTP request smuggling flaw where conflicting Content-Length and Transfer-Encoding: chunked headers are not correctly reconciled before forwarding to the backend.

Under these conditions, an attacker can desynchronize parsing between Tinyproxy and the backend server, enabling the injection of hidden HTTP requests that may lead to cache poisoning, access control bypass, or hijacked requests.

Affected context

The vulnerability appears in deployments where Tinyproxy sits between clients and backend HTTP servers, relaying requests without normalizing or enforcing consistent message framing.

It is most relevant when:

  • Tinyproxy accepts connections from untrusted or semi-trusted clients (e.g., internet-facing or shared environments), and
  • Backends interpret HTTP messages differently than Tinyproxy when both Content-Length and Transfer-Encoding: chunked headers are present.

In these scenarios, the proxy and backend can disagree on where a request ends, creating space for additional hidden requests to be smuggled through.

Exploit preconditions

  • Attack surface: The Tinyproxy HTTP listener reachable by remote clients.
  • Required access: Ability to send crafted HTTP requests through Tinyproxy, including control over request headers and body.
  • Trigger point: Requests that include both Content-Length and Transfer-Encoding: chunked headers, with a body shaped to cause parsing disagreement.
  • Why exploitation is possible: Tinyproxy forwards both headers to the backend but uses only Content-Length to decide how much of the body to consume. The backend may prioritize Transfer-Encoding: chunked, causing the two components to disagree about message boundaries. This parser desynchronization allows a hidden "next" request to be interpreted by the backend as a separate, attacker-controlled request.

Why this happens

This issue stems from inconsistent HTTP message framing handling within the proxy and between the proxy and backend.

Tinyproxy fails to apply a clear precedence rule or to normalize conflicting Content-Length and Transfer-Encoding: chunked headers, and it forwards both verbatim.

Internally, it uses Content-Length to decide how many bytes to read, while many backends follow modern guidance and treat Transfer-Encoding as authoritative. This mismatch produces a classic CWE-444: Inconsistent Interpretation of HTTP Requests (HTTP Request Smuggling), where intermediary and backend parse the same bytes into different logical requests.

Potential impact

  • Attacker-controlled hidden HTTP requests can be sent to backend servers through Tinyproxy.
  • Cache poisoning, including storing malicious responses under URLs that will be served to other users.
  • Access control bypass by smuggling requests that appear internal, authenticated, or whitelisted to the backend.
  • Request hijacking, where victim traffic is coalesced or interleaved with attacker-controlled requests.
  • Potential credential or session token exposure via manipulated responses or cache behavior.

General mitigation guidance

Effective mitigation focuses on enforcing consistent HTTP message framing and reducing trust in client-supplied headers.

General patterns include:

  • Normalizing or rejecting requests that contain both Content-Length and Transfer-Encoding headers, especially when Transfer-Encoding: chunked is present.
  • Implementing strict parsing logic that follows a single, standards-aligned precedence rule for determining the body length and applying it consistently to both proxy and backend integration.
  • Sanitizing or removing conflicting or duplicate hop-by-hop headers before forwarding to the backend.
  • Limiting exposure of Tinyproxy to untrusted clients, and segmenting sensitive backend services behind additional controls.
  • Applying least-privilege and separation-of-duties patterns so that a compromised backend route has constrained access to data and internal networks.

How teams detect issues like this

Detecting this class of issue typically involves a combination of code-centric and traffic-centric approaches:

  • Static analysis and code review: Look for HTTP parsing code where both Content-Length and Transfer-Encoding are read but not reconciled, or where they are forwarded unchanged to the backend. Signals include conditional logic that uses only one header to determine body length while preserving both.
  • Protocol and regression tests: Add automated tests that send malformed or ambiguous requests (e.g., dual headers, mismatched lengths) through Tinyproxy to a test backend, verifying that no extra requests are seen by the backend.
  • Runtime monitoring: Inspect reverse proxy or backend logs for anomalous patterns such as unexpected extra requests, odd paths appearing only after certain clients, or cache entries populated by unusual request sequences.
  • Security scanning tools: Use HTTP request smuggling scanners or proxies capable of crafting ambiguous HTTP messages to probe deployed instances and identify desynchronization behavior in a controlled environment.

Sources

SourceLink
github.comgithub.com/tinyproxy/tinyproxy/commit/ff45d3bf0e61d0f8ed97ab379d3047f04eb67521
github.comgithub.com/tinyproxy/tinyproxy/issues/609
github.comgithub.com/tinyproxy/tinyproxy/pull/610
vulncheck.comvulncheck.com/advisories/tinyproxy-http-request-smuggling-via-cl-te-desynchronization

Frequently asked

questions

Yes. Any remote client that can send crafted HTTP requests through Tinyproxy may attempt to exploit the desynchronization, assuming the backend interprets the ambiguous messages differently than the proxy.

The attacker only needs network access to Tinyproxy as a client, with the ability to control request headers and bodies. No authentication is inherently required beyond whatever the proxy itself enforces.

The safest pattern is to strictly normalize and validate HTTP request framing: enforce a single, standards-compliant rule for body length, reject or strip conflicting headers, and ensure Tinyproxy and backend servers interpret requests identically.

Prevent future request smuggling flaws by adopting defensive HTTP parsing libraries, adding tests specifically for ambiguous header combinations, reviewing proxy and gateway code for framing inconsistencies, and enforcing security checks for message normalization as part of code review and CI pipelines.

Find out what's already
exploitable in your codebase.