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

