CVE-2024-52304

What it actually does

The flaw is an HTTP request parsing inconsistency in aiohttp versions prior to 3.10.11 when the pure-Python HTTP parser is used instead of the C extensions, including deployments where AIOHTTP_NO_EXTENSIONS is enabled. The parser mishandles newline characters inside HTTP chunk extensions, which can cause aiohttp and an upstream proxy, firewall, load balancer, or gateway to disagree about where one HTTP request ends and the next begins. Under the right proxying conditions, this can enable HTTP request smuggling, allowing an attacker to hide or prepend a second request that is interpreted differently by backend services than by front-end controls.

Why it matters to the business

Successful exploitation can let an attacker bypass front-end security controls, routing rules, authentication assumptions, web application firewall checks, or cache boundaries for affected aiohttp-based services. The most serious outcomes depend on the application and deployment topology, but may include unauthorized access to internal endpoints, session confusion, cache poisoning, request tampering, or reaching functionality that operators expected to be protected by a proxy. This issue is not listed in CISA KEV, is not currently associated with ransomware use, and has a low EPSS score, but it has been public for an extended period and should still be remediated wherever aiohttp is exposed through reverse proxies or API gateways.

How an attack unfolds

An attacker targets an aiohttp service that receives HTTP traffic through a front-end proxy, gateway, WAF, CDN, or load balancer. The attacker sends a crafted HTTP/1.1 request using chunked transfer encoding with a malformed chunk extension containing newline characters. Because the vulnerable pure-Python aiohttp parser and the front-end component may parse the malformed chunked body differently, the front end may believe it has forwarded one well-formed request while the aiohttp backend interprets additional bytes as a separate or altered request. The attacker can then attempt to smuggle a hidden request to a backend-only path, bypass front-end filtering, poison a cache entry, desynchronize a connection used by another request, or manipulate how the application processes subsequent traffic. Exploitability depends heavily on use of the pure-Python parser, HTTP/1.1 keep-alive behavior, proxy buffering behavior, and whether sensitive backend routes are reachable through the same connection path.

How to fix it

Upgrade aiohttp to version 3.10.11 or later. For source-based deployments, ensure the code includes the upstream fix commit 3e09325e4839117df13fbac301f360edf8d3a0ee. Rebuild and redeploy application containers or virtual environments so the runtime package actually uses the patched aiohttp version. Where immediate upgrade is not possible, prefer enabling and validating the normal aiohttp C extensions rather than the pure-Python parser, remove any AIOHTTP_NO_EXTENSIONS setting, and block or normalize malformed chunked requests at the edge. Additional compensating controls include disabling HTTP/1.1 keep-alive between front-end proxies and aiohttp backends where operationally acceptable, rejecting requests with chunk extensions at the proxy layer, enforcing strict HTTP request normalization, and ensuring backend-only administrative routes are not reachable through the same public listener.

How to confirm the fix worked

Confirm package inventory shows aiohttp 3.10.11 or later in every runtime image, virtual environment, and dependency lockfile. Validate with commands such as `python -c "import aiohttp; print(aiohttp.__version__)"` inside the deployed runtime, not only in source control. Check deployment configuration, container environment, service files, and orchestration manifests for AIOHTTP_NO_EXTENSIONS and remove it unless there is a documented operational reason. Confirm the installed aiohttp build includes compiled extensions where expected. At the network layer, test that the front-end proxy rejects or safely normalizes HTTP/1.1 chunked requests containing malformed chunk extensions with embedded newline characters. Review reverse proxy behavior for request buffering, connection reuse, and backend keep-alive settings. A successful fix should eliminate parser desynchronization behavior and should not allow a crafted chunked request to produce different request interpretation between the proxy and backend.

Typical attack path

1. Identify an internet-facing or proxy-exposed service built with aiohttp before version 3.10.11.
2. Determine whether the deployment is likely using the pure-Python parser, such as because aiohttp C extensions are unavailable or AIOHTTP_NO_EXTENSIONS is enabled.
3. Send probing HTTP/1.1 requests using Transfer-Encoding: chunked and unusual chunk extensions to test for parser desynchronization between the front-end proxy and aiohttp backend.
4. Craft a request where a newline in a chunk extension causes the front end and backend to disagree about request boundaries.
5. Embed a second HTTP request after the malformed chunked payload so that the backend processes it as a separate smuggled request.
6. Use the smuggled request to attempt access to protected routes, bypass proxy/WAF rules, poison cacheable responses, or interfere with another request on the same connection.
7. Repeat and tune payloads based on response timing, status codes, connection reuse behavior, and application-specific effects.

How to detect it

Historical exploitation is difficult to confirm because request smuggling payloads often rely on raw HTTP framing that many application logs do not preserve. Prioritize raw access logs from reverse proxies, WAFs, CDNs, API gateways, packet captures, load balancer logs, and aiohttp application logs around suspicious requests. Look for HTTP/1.1 requests using `Transfer-Encoding: chunked` with chunk extensions, malformed control characters, embedded newlines, unusual connection reuse patterns, unexpected backend-only route access, unexplained 400/408/502 responses, WAF/proxy parser errors, cache anomalies, and mismatches between front-end and backend request counts. Investigate cases where a front-end log shows one request but the backend logs show two requests on the same connection, or where backend access appears to bypass expected front-end authentication or routing rules. Also review deployment artifacts for exposure indicators such as `AIOHTTP_NO_EXTENSIONS` or aiohttp installations lacking compiled extensions, because those conditions increase relevance of this vulnerability.

• AIOHTTP_NO_EXTENSIONS
• Transfer-Encoding: chunked
• transfer-encoding: chunked
• Transfer-Encoding: Chunked
• BadHttpMessage
• BadStatusLine
• InvalidHeader
• aiohttp.http_exceptions
• chunk extension
• malformed chunked
• invalid chunk
• upstream sent invalid chunked response
• client sent invalid chunked body
• 400 Bad Request
• 408 Request Timeout
• 502 Bad Gateway

What your security team should do

• Inventory all services and containers using aiohttp and prioritize externally reachable HTTP services behind reverse proxies, WAFs, CDNs, API gateways, or load balancers.
• Upgrade affected deployments to aiohttp 3.10.11 or later, or to a build containing commit 3e09325e4839117df13fbac301f360edf8d3a0ee.
• Search runtime configuration for AIOHTTP_NO_EXTENSIONS and remove it unless explicitly required; if it must remain, treat the service as higher risk until upgraded.
• Add or confirm edge controls that reject malformed chunked transfer encoding, especially chunk extensions containing control characters or embedded newlines.
• Review proxy-to-backend HTTP/1.1 keep-alive and buffering settings for services where request smuggling would have high impact.
• Perform targeted request-smuggling testing in staging and, where safe, production validation using approved tooling and controlled payloads.
• Review recent HTTP logs and proxy error logs for malformed chunked requests, connection desynchronization symptoms, unexplained 400 responses, or anomalous access to backend-only paths.
• Ensure dependency scanning covers Python lockfiles, container images, and runtime environments, not only repository manifests.