/

CVE-2026-48743

Severity:

HIGH RISK

(7.5)

Request Desync (CWE-444) in Envoy HTTP/3 to HTTP/1

CVE-2026-48743

Analyzed

Vulnerability type

Category:

HTTP Request Smuggling / Desynchronization

CWE:

CWE-444

Impact:

Request smuggling and route bypass at HTTP/1 origins

Severity:

HIGH RISK

(7.5)

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

Envoy can mis-handle downstream HTTP/3 requests that are transport-level complete but still advertise a nonzero Content-Length, translating them into upstream HTTP/1 requests with unresolved body debt.

In certain HTTP/1 upstream configurations, this mismatch can desynchronize request boundaries, allowing later bytes to be interpreted as a new request and enabling route bypass or origin-level request smuggling.

Affected context

This vulnerability arises in Envoy deployments that proxy HTTP/3 traffic downstream to HTTP/1 upstream origins.

It is most relevant when:

  • Downstream clients send headers-only HTTP/3 requests that still carry a nonzero Content-Length.
  • Upstream HTTP/1 origins respond without fully consuming the declared request body and leave the connection reusable.
  • Envoy treats the downstream request as complete while the origin still expects body bytes.

Under these conditions, the origin may consume the start of the next Envoy-generated request as body data and parse the remainder as a separate HTTP/1 request.

Exploit preconditions

  • Attack surface: Downstream HTTP/3 interface exposed by Envoy.
  • Required access: Ability to send crafted HTTP/3 requests to Envoy (typically as any client).
  • Trigger point: An HTTP/3 request that is complete at the QUIC/transport layer (HEADERS with FIN) but declares a nonzero Content-Length header.
  • Upstream behavior requirement: An HTTP/1 origin that replies before reading the declared body, keeps the TCP connection open, and treats it as reusable.
  • Why exploitation is possible: Envoy's translation from HTTP/3 to HTTP/1 can leave "body debt" on the upstream connection, causing the origin to consume the beginning of the next upstream request as body data and parse the remaining bytes as a distinct HTTP/1 request, leading to desynchronization and route bypass.

Why this happens

At its core, this issue stems from inconsistent handling of HTTP message framing semantics across protocol boundaries.

Envoy treats an HTTP/3 request as complete when the transport-level stream is closed with headers-only, even if the Content-Length header indicates a body should follow.

When translating to HTTP/1, this mismatch creates unresolved "body debt" on the upstream connection: Envoy believes the first request is fully delivered, while the HTTP/1 origin believes more body bytes are pending.

This framing desynchronization is characteristic of CWE-444: Inconsistent Interpretation of HTTP Requests, where intermediaries and origins interpret request boundaries differently and inadvertently allow one logical request to influence or merge with another.

Potential impact

  • Route bypass at the Envoy layer, allowing access to backend paths that Envoy policies intend to deny.
  • HTTP request smuggling between downstream clients and upstream HTTP/1 origins.
  • Confusion of origin-side logging and security controls due to misattributed or split requests.
  • Potential exploitation of origin-specific quirks or vulnerabilities that depend on precise request framing.
  • Increased risk of cache poisoning or authorization bypass in complex proxy and cache topologies.

General mitigation guidance

Mitigation patterns focus on enforcing coherent HTTP message framing and minimizing trust in downstream-supplied length and completeness indicators.

Effective strategies include:

  • Normalizing and validating HTTP/3 requests so that headers, Content-Length, and stream closure semantics remain consistent before translation to HTTP/1.
  • Rejecting or sanitizing requests where the transport-level completion (headers-only with FIN) conflicts with a nonzero Content-Length.
  • Ensuring that proxy components fully account for "body debt" when reusing connections to upstream HTTP/1 origins, avoiding partial body delivery across multiple logical requests.
  • Applying strict routing and authorization enforcement based on normalized request metadata rather than raw upstream-parsed paths.
  • Designing proxy configurations to minimize complex reuse of connections where framing ambiguities can accumulate, while maintaining least-privilege access from the proxy to backend routes.

How teams detect issues like this

Detection commonly involves a mix of protocol-aware analysis and configuration review:

  • Static analysis or configuration linting focused on HTTP/3-to-HTTP/1 translation logic, looking for places where Content-Length and stream closure are not reconciled.
  • Targeted code reviews to ensure that request completeness is defined consistently across protocols, with special attention to headers-only requests and connection reuse logic.
  • Observability and logging that capture downstream and upstream request IDs, framing metadata, and routing decisions, enabling correlation of unexpected route hits or mismatched responses.
  • Deployment of automated HTTP desync testing tools against Envoy edges, using crafted multi-request sequences to detect smuggling and route bypass behaviors without revealing exploit payloads.

Sources

SourceLink
github.comgithub.com/envoyproxy/envoy/security/advisories/GHSA-8phg-2h2q-jgxf

Frequently asked

questions

Exploitability depends on having an Envoy deployment that translates downstream HTTP/3 to HTTP/1 and an upstream origin that reuses connections without fully consuming declared request bodies. In such setups, any client capable of sending crafted HTTP/3 requests can potentially trigger desynchronization.

The attacker generally needs network access to Envoy's downstream HTTP/3 interface, which often corresponds to standard client access to the edge proxy. No special authentication is required beyond whatever Envoy already enforces for reaching the vulnerable routes.

The safest pattern is to ensure strict alignment between request framing semantics across all protocols: treat headers, Content-Length, and stream closure consistently, reject contradictory requests, and fully account for any expected body bytes before reusing upstream connections.

Prevention relies on designing proxies and gateways with protocol-aware validation, enforcing normalized request representations, testing for desync scenarios as part of regular security assessments, and applying policy that prioritizes secure framing and route enforcement over aggressive connection reuse or performance optimizations.

Find out what's already
exploitable in your codebase.