Summary
Tornado versions before 6.3.3 may improperly parse Content-Length headers containing non-standard characters, creating inconsistent interpretations of request boundaries. When deployed behind certain proxies, an attacker could exploit this behavior to bypass proxy validation and smuggle additional requests to the backend.
Affected context
The vulnerability occurs in Tornado deployments that process HTTP Content-Length headers and operate behind a reverse proxy, load balancer, or other intermediary with different header-parsing behavior. Risk depends on whether the intermediary and Tornado disagree about request boundaries and whether crafted requests can reach the affected application path.
Exploit preconditions
- Attack surface: HTTP or HTTPS endpoint exposed through a proxy or intermediary
- Required access: Ability to send requests to the affected Tornado service
- Trigger point: Parsing of a crafted Content-Length header containing non-standard characters
- Why exploitation is possible: Different components may interpret the same header differently, allowing request boundaries to become desynchronized
Why this happens
The underlying bug is inconsistent or overly permissive parsing of Content-Length headers. When an HTTP server accepts characters or formats that an upstream proxy interprets differently, the two components can disagree about where one request ends and another begins. This behavior maps to CWE-444: Inconsistent Interpretation of HTTP Requests, commonly known as HTTP request smuggling.
Potential impact
- An attacker may bypass security checks enforced by an upstream proxy.
- Requests could be routed to unintended backend endpoints.
- Sensitive data may be exposed through unauthorized request access.
- Web caches, authentication boundaries, or audit controls could be bypassed.
- Backend services may receive attacker-controlled smuggled requests.
General mitigation guidance
Mitigation generally focuses on making HTTP parsing behavior consistent across
every component in the request path.
Common defensive patterns include:
- Using HTTP parser behavior that strictly conforms to the applicable protocol specifications.
- Rejecting malformed or ambiguous Content-Length headers rather than normalizing them permissively.
- Aligning proxy, load balancer, and application-server request parsing policies.
- Enforcing a single authoritative request-framing policy at the edge.
- Limiting backend privileges and separating sensitive administrative routes from publicly reachable paths.
- Applying layered controls so that proxy validation is not the sole protection for authorization-sensitive requests.
How teams detect issues like this
Organizations commonly detect request-smuggling risks through:
- Static and dependency analysis that identifies affected HTTP parsing components.
- Code review checks for permissive parsing, header normalization, or inconsistent request-framing logic.
- Proxy-to-backend testing using malformed, ambiguous, or non-standard request headers in controlled environments.
- Monitoring for unusual request desynchronization symptoms, unexpected backend routes, and mismatched proxy and application logs.
- Policy enforcement requiring consistent HTTP parsing configurations across network tiers.

