/

CVE-2026-73494

Severity:

HIGH RISK

(7.4)

HTTP Request Smuggling (CWE-444) in Blaze HTTP Parser

CVE-2026-73494

Deferred

Vulnerability type

Category:

HTTP Request Smuggling

CWE:

CWE-444

Impact:

Request Boundary Desynchronization

Severity:

HIGH RISK

(7.4)

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

Blaze's hand-written HTTP/1.1 parser accepts several malformed request forms that stricter intermediaries may interpret differently. When a proxy and Blaze derive different request boundaries, an attacker may bypass front-end authorization, poison a pooled backend connection, or manipulate cached responses.

Affected context

The issue occurs in Blaze HTTP/1.1 server deployments using the default parser behavior. Risk is present when Blaze is positioned behind a proxy, load balancer, cache, or other intermediary whose parsing rules differ regarding invalid header names, obsolete folded lines, unsupported transfer encodings, duplicate Content-Length fields, or simultaneous Transfer-Encoding and Content-Length headers.

Exploit preconditions

  • Attack surface: HTTP/1.1 request handling through Blaze and a fronting intermediary
  • Required access: Ability to send crafted HTTP requests to the intermediary or exposed service
  • Trigger point: Parsing and forwarding of malformed or ambiguous HTTP/1.1 messages
  • Why exploitation is possible: Two components disagree about request validity or message boundaries, allowing bytes intended for one request to be interpreted as part of another

Why this happens

The vulnerability results from lax HTTP/1.1 conformance checks in the hand-written parser. Accepting ambiguous framing and header structures, including conflicting length indicators and obsolete line folding, can cause Blaze to derive a request boundary that differs from a stricter or legacy intermediary.

This behavior maps to CWE-444: Inconsistent Interpretation of HTTP Requests, where multiple HTTP components parse the same message differently. The insecure pattern is allowing malformed or conflicting request metadata to pass through without enforcing a single, standards-aligned interpretation.

Potential impact

  • An attacker may bypass authorization enforced by a fronting intermediary
  • Backend connection queues could be poisoned or desynchronized
  • Requests may be routed to an unintended backend operation
  • Shared caches could be poisoned with attacker-controlled responses
  • Session or tenant isolation may be weakened in pooled deployments

General mitigation guidance

Mitigation generally focuses on ensuring every HTTP-processing layer applies consistent, strict request parsing.

Common defensive patterns include:

  • Rejecting malformed header names, obsolete folded lines, unsupported transfer encodings, duplicate Content-Length values, and conflicting framing headers
  • Using one standards-aligned interpretation of request boundaries across proxies, gateways, caches, and application servers
  • Configuring intermediaries to reject ambiguous requests rather than normalize and forward them
  • Avoiding connection reuse when request framing cannot be confidently validated
  • Limiting backend privileges and isolating services so parser discrepancies have a narrower security impact
  • Testing parser behavior across all components in the request path

How teams detect issues like this

Organizations commonly detect HTTP request smuggling exposure through:

  • Static and configuration analysis for permissive HTTP parser settings
  • Code review checks for inconsistent handling of Transfer-Encoding and Content-Length
  • Tests covering duplicate length headers, obsolete folding, invalid field names, and unsupported transfer encodings
  • Differential request parsing tests comparing proxies, gateways, caches, and application servers
  • Runtime monitoring for malformed requests, unexpected request counts, backend queue anomalies, and desynchronized connection logs
  • Policy enforcement requiring strict HTTP conformance at every request boundary

Sources

SourceLink
github.comgithub.com/http4s/blaze/commit/3f7c022e306631b006dcb43a1d7f65c0d1966f17
github.comgithub.com/http4s/blaze/commit/4eec2007806aa9acfefb00ebb636ddc39a147a96
github.comgithub.com/http4s/blaze/commit/927b67753a78c13c4445dac9307f511f5c4878c3
github.comgithub.com/http4s/blaze/commit/a54bc9cd31758335c7f24e29763622fd03fcf734
github.comgithub.com/http4s/blaze/commit/c47d9675f87603f11b32a11d503626bdf9be5c7a
github.comgithub.com/http4s/blaze/commit/e871ebb1d27f50c98fd56988526ce42d0fee74d6
github.comgithub.com/http4s/blaze/releases/tag/v0.23.18
github.comgithub.com/http4s/blaze/releases/tag/v1.0.0-M42
github.comgithub.com/http4s/blaze/security/advisories/GHSA-mhvj-jhpq-885v

Frequently asked

questions

It can be remotely exploitable when an attacker can send HTTP requests through a fronting intermediary to an affected Blaze server. Exploitation depends on a parsing disagreement between the intermediary and Blaze.

No. The described laxities can be present with the default server behavior, although a suitable intermediary and pooled connection path are generally required for meaningful impact.

Enforce strict, consistent HTTP/1.1 parsing across Blaze and every intermediary, rejecting ambiguous framing and malformed header structures before requests are forwarded.

Use differential parser testing, include malformed-message cases in security tests, monitor for desynchronization indicators, and apply a policy that forbids conflicting or ambiguous request framing.

Find out what's already
exploitable in your codebase.