/

CVE-2026-23527

Severity:

HIGH RISK

(8.9)

HTTP Request Smuggling in H3 readRawBody Header Parsing

CVE-2026-23527

Modified

Vulnerability type

Category:

HTTP Request Smuggling

CWE:

CWE-444

Impact:

Request Smuggling and HTTP Desynchronization

Severity:

HIGH RISK

(8.9)

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 the H3 HTTP framework arises from a case-sensitive check of the Transfer-Encoding header inside readRawBody, contrary to the HTTP specification that treats this header as case-insensitive.

Under certain proxy or load balancer configurations, an attacker can craft requests with non-lowercase Transfer-Encoding values to desynchronize how intermediaries and H3 interpret message boundaries, enabling HTTP request smuggling attacks.

Affected context

This vulnerability affects applications built on H3 (prior to 1.15.5) that:

  • Use the readRawBody helper to process incoming HTTP requests
  • Are deployed behind HTTP intermediaries such as reverse proxies, CDNs, or load balancers
  • Rely on proxies that correctly treat Transfer-Encoding as case-insensitive

The issue is triggered when a client sends a request with a Transfer-Encoding header whose value is not exactly "chunked" in lowercase, causing H3 to misinterpret the body framing while intermediaries still treat the request as chunked.

Exploit preconditions

  • Attack surface: Public or internal HTTP endpoints implemented using H3 and reachable to the attacker.
  • Required access: Ability to send crafted HTTP requests to the target application through any fronting proxy or load balancer.
  • Trigger point: Requests that include a Transfer-Encoding header with varied casing (e.g., Chunked, CHUNKED, or mixed-case) combined with specific body payloads designed to confuse request boundaries.
  • Why exploitation is possible: H3's readRawBody logic performs a strict, case-sensitive check for the exact string "chunked", while upstream intermediaries follow the HTTP RFC and treat the header as case-insensitive. This discrepancy allows an attacker to cause H3 and the intermediary to disagree on where one request ends and the next begins, enabling request smuggling.

Why this happens

The root cause is a protocol parsing flaw that violates HTTP specification rules about case-insensitivity for header values, specifically for Transfer-Encoding.

In the vulnerable versions, readRawBody checks the header using a case-sensitive comparison against the literal value "chunked". This can cause H3 to treat some requests as having a standard body (e.g., by Content-Length) while upstream components treat them as chunked-encoded. This mismatch in message framing logic maps to CWE-444: Inconsistent Interpretation of HTTP Requests (HTTP Request Smuggling), where different components in the request processing chain parse the same request differently.

Potential impact

  • Smuggling of hidden HTTP requests through front-end proxies into backend H3 services
  • Execution of unauthorized or unexpected HTTP requests in the context of another user's connection
  • Cache poisoning or pollution on intermediate caches and CDNs
  • Bypassing authentication, authorization, or request filtering enforced at proxies or WAFs
  • Cross-tenant data exposure in multi-tenant environments that reuse backend connections

General mitigation guidance

Effective mitigation focuses on ensuring consistent, RFC-compliant parsing of HTTP headers and message framing across the entire request path.

Recommended defensive patterns include:

  • Implement case-insensitive comparison for Transfer-Encoding and other HTTP headers that the RFC defines as case-insensitive.
  • Normalize incoming header names and relevant header values (e.g., lowercasing them) before applying parsing logic.
  • Avoid mixing Transfer-Encoding and Content-Length interpretation; prefer one canonical body framing policy and reject ambiguous combinations.
  • Introduce strict validation that rejects malformed or suspicious requests (e.g., multiple Content-Length headers, unexpected combinations of body-related headers).
  • Design deployments so that a single, trusted component is responsible for low-level HTTP parsing and body framing, with backend services consuming already-normalized requests.

How teams detect issues like this

Detection generally relies on analyzing both code and traffic for signs of inconsistent HTTP parsing:

  • Static analysis and code review:
  • Look for case-sensitive checks on HTTP headers or their values, particularly Transfer-Encoding, Content-Length, and other framing-related headers.
  • Flag custom HTTP parsing logic that re-implements RFC semantics instead of delegating to hardened libraries.
  • Review any conditional behavior based on header values without normalization (e.g., direct string equality checks).
  • Dynamic analysis and testing:
  • Use security testing tools that send variations of Transfer-Encoding (different casing, multiple headers) and look for differing behaviors between proxies and backends.
  • Incorporate HTTP request smuggling test cases into integration and pre-production testing with realistic proxy configurations.
  • Operational monitoring:
  • Monitor logs for malformed or unusual Transfer-Encoding usage and inconsistencies between front-end and back-end logs regarding request sizes and counts.
  • Employ WAF or API gateway rules that detect suspicious combinations of body-related headers and reject them early.

Automated HTTP security scanners and CI-integrated review tools can help flag these patterns before deployment.

Sources

SourceLink
github.comgithub.com/h3js/h3/commit/618ccf4f37b8b6148bea7f36040471af45bfb097
github.comgithub.com/h3js/h3/releases/tag/v1.15.5
github.comgithub.com/h3js/h3/security/advisories/GHSA-mp2g-9vg9-f4cg
simonkoeck.comsimonkoeck.com/writeups/h3-transfer-encoding-request-smuggling

Frequently asked

questions

Yes. As long as an attacker can send HTTP requests to an H3-based service (typically via the Internet or an internal network), they may attempt request smuggling payloads, especially in environments with proxies or load balancers.

Not necessarily. In many typical scenarios, the vulnerable parsing occurs before authentication, so unauthenticated attackers can attempt to smuggle requests. However, the practical impact may be greater if an attacker can first obtain an authenticated session and then smuggle requests using that context.

The safest pattern is to ensure strict, RFC-compliant parsing by normalizing header values and performing case-insensitive comparisons for headers like Transfer-Encoding. Additionally, reject ambiguous or conflicting combinations of body-related headers and rely on a single canonical mechanism for request body framing.

Avoid custom protocol parsing whenever possible and rely on well-tested HTTP libraries. When custom logic is unavoidable, enforce header normalization, adhere closely to RFC semantics, add unit tests for edge cases (including header casing variations), and include HTTP request smuggling checks in security review and automated testing pipelines.

Find out what's already
exploitable in your codebase.