Summary
A malformed Transfer-Encoding handling flaw in ServiceTalk HTTP/1.x can cause different components to interpret HTTP request boundaries inconsistently. An attacker who can send crafted HTTP requests may bypass front-end controls, interfere with request routing, or access data intended for another request.
Affected context
The vulnerability occurs in ServiceTalk deployments that process HTTP/1.x traffic and encounter malformed or ambiguous Transfer-Encoding headers. Risk is greater when ServiceTalk is positioned behind a reverse proxy, load balancer, gateway, or other intermediary that parses request boundaries differently from the backend service.
Exploit preconditions
- Attack surface: HTTP/1.x request-processing endpoints
- Required access: Ability to send HTTP requests to an exposed ServiceTalk service or an intermediary forwarding requests to it
- Trigger point: Parsing of malformed or ambiguous
Transfer-Encodingheaders - Why exploitation is possible: Inconsistent interpretation of message framing can cause front-end and back-end components to disagree about where one request ends and another begins
Why this happens
The underlying issue is improper handling and normalization of malformed Transfer-Encoding values during HTTP/1.x message framing. When a server or intermediary accepts ambiguous framing instead of applying consistent parsing and rejection rules, separate components may desynchronize their request boundaries. This behavior maps to CWE-444, HTTP Request/Response Smuggling, because attacker-controlled framing data can influence how multiple HTTP components interpret the same connection.
Potential impact
- An attacker may bypass security controls enforced by an HTTP intermediary
- Requests could be routed to unintended backend handlers
- Sensitive responses may be exposed to an attacker
- Session or authorization boundaries could be confused
- Backend services may process attacker-controlled or queued requests unexpectedly
General mitigation guidance
Mitigation generally focuses on making HTTP message-framing behavior consistent
across every proxy, gateway, server, and application component.
Common defensive patterns include:
- Rejecting malformed, duplicated, conflicting, or ambiguous Transfer-Encoding headers
- Applying strict, standards-aligned HTTP/1.x parsing and canonicalization
- Ensuring intermediaries and backend services use compatible request-framing rules
- Prefering HTTP/2 or another framing model where appropriate, while validating protocol transitions
- Limiting unnecessary intermediary hops and isolating backend services from direct public access
- Applying least-privilege network policies and minimizing sensitive actions available through affected routes
How teams detect issues like this
Organizations commonly detect request-smuggling risks through:
- Static and dynamic analysis of HTTP parser behavior around Content-Length and Transfer-Encoding combinations
- Code review checks for permissive header parsing, inconsistent canonicalization, or acceptance of malformed framing
- Integration tests that compare request-boundary interpretation across proxies, gateways, and backend services
- Web application firewall and gateway policies that reject ambiguous or invalid transfer-coding syntax
- Network monitoring for unusual connection reuse, desynchronized requests, or unexpected backend responses
Automated security testing tools can help identify parser differentials in controlled environments.

