Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify aiohttp backend behind proxy
-
DeliverySend HEAD request with Content-Length and trailing payload
-
ExploitPure-Python parser mis-frames body as new request
-
ExecutionBackend executes smuggled request out of band
-
ImpactBypass front-end controls or poison responses
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V4 - API and Web Service HTTP request consistency
|
| Exploitation Conditions | Exploitation requires BOTH: (1) the application running aiohttp's pure-Python HTTP parser - triggered by setting the AIOHTTP_NO_EXTENSIONS environment variable or running without the standard compiled (llhttp C extension) wheel; and (2) a front-end intermediary/reverse proxy that interprets the ambiguous HEAD-with-Content-Length framing differently than the backend. Default installations that use the compiled C parser are NOT vulnerable. The flaw is unauthenticated (PR:N) and needs no user interaction, but the non-default parser configuration plus the required proxy/backend parsing disagreement (CVSS 4.0 AT:P) are the primary factors limiting real-world exploitability. |
| Impact | This is a medium-severity, conditionally-exploitable HTTP request smuggling flaw (CWE-444) rather than a drop-everything priority. The vendor CVSS 4.0 score of 6.3 encodes the key caveat directly in the vector: AT:P (attack requirements present) reflects that exploitation is not possible against default deployments. Although PR:N/UI:N/AV:N signal an unauthenticated, remote, no-interaction vector, the impact metrics are only Low across integrity/availability (VI:L/VA:L/SI:L/SA:L) with no confidentiality on the vulnerable system (VC:N), consistent with a desync bug that corrupts request framing rather than directly leaking data or granting code execution. No EPSS score, CISA KEV listing, or public exploit was provided in the intelligence set, so there is no evidence of active or at-scale exploitation; the only exploitation artifact is a regression test embedded in the fix commit, which is not a weaponized POC. The decisive limiting factor is that the bug lives in the pure-Python parser, which only runs when AIOHTTP_NO_EXTENSIONS is set or the compiled C (llhttp) extension is unavailable - the standard wheel install is not affected. Net: treat as a real but niche risk, high priority only for the subset of deployments knowingly running the pure-Python parser behind a differently-parsing intermediary. |
| Exploit ScenarioDerived | An aiohttp application is deployed with AIOHTTP_NO_EXTENSIONS (or without the compiled wheel) behind a reverse proxy that frames HTTP differently. An unauthenticated attacker sends a HEAD request carrying a Content-Length and a trailing smuggled request; because the pure-Python parser wrongly treats the HEAD body as absent, the proxy and backend disagree on message boundaries and the attacker's hidden request is processed as if legitimate. No public weaponized exploit was provided - only a regression test in the fix commit demonstrates the framing desync. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 19, 2026
HTTP request smuggling in aiohttp's pure-Python HTTP parser (versions prior to 3.14.4) can let an unauthenticated remote attacker desynchronize request framing between aiohttp and a front-end proxy when the application runs without the standard compiled llhttp extension - for example with AIOHTTP_NO_EXTENSIONS set or when no compatible wheel is installed. Exploitation additionally requires an intermediary that interprets ambiguous HEAD-with-Content-Length framing differently from the backend, so default installations using the C extension are not vulnerable; no public exploit was identified at the time of analysis, and this is a medium-severity, conditionally exploitable flaw rather than a broadly exploitable one.
RemediationAI
Upgrade to aiohttp 3.14.4 (vendor-released patch), which contains the parser fix and regression test referenced by commit 9b27347e61454d9f8ca2055f4c67a37dee336e83 and the release at https://github.com/aio-libs/aiohttp/releases/tag/v3.14.4. If upgrading cannot be done immediately, ensure the compiled llhttp extension is in use: install a standard platform wheel, do not set AIOHTTP_NO_EXTENSIONS, and verify the extension is loaded; this removes the vulnerable pure-Python parser path but may not be possible on unsupported platforms. Because exploitation also depends on an intermediary interpreting HEAD-with-Content-Length framing differently, configure reverse proxies to reject or normalize ambiguous HEAD requests carrying a body or Content-Length and enforce one consistent request-framing policy; note that strict rejection can break clients that legitimately send such requests. Review the vendor advisory for additional guidance.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in pypi
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The issue is CWE-444 (inconsistent interpretation of HTTP requests, commonly called request smuggling) in aiohttp's pure-Python parser. Per the upstream fix in commit 9b27347e61454d9f8ca2055f4c67a37dee336e83, the parser was applying EMPTY_BODY_METHODS logic to requests as well as responses, so a HEAD request carrying a Content-Length header could be treated as having no body. The bytes that should have been consumed as the HEAD request body were instead left in the stream and could be parsed as a subsequent request. The patch restricts the empty-body-method behavior to responses by checking self.method, which is None on the request parser, and adds a regression test showing a HEAD request with Content-Length followed by a smuggled GET request. This is only reachable when the pure-Python parser is active; the standard compiled llhttp extension used by default wheels does not contain this parser path, and the CVSS 4.0 AT:P-style prerequisite is the required parsing disagreement between aiohttp and an intermediary.
Know when Aiohttp gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:L/VA:L/SC:N/SI:L/SA:L
AV:N/PR:N/UI:N since it is remote and unauthenticated; AC:H because it needs the non-default pure-Python parser plus a desyncing intermediary; S:C/C:L/I:L as smuggling crosses the proxy trust boundary with limited impact.
Primary rating from Vendor (github).
CVSS VectorVendor: github
Lifecycle Timeline
2DescriptionCVE.org
AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to 3.14.4, the pure Python parser accepts ambiguous HTTP request framing. An unauthenticated attacker can consequently smuggle requests when an application uses AIOHTTP_NO_EXTENSIONS or otherwise runs without a standard wheel and an intermediary interprets the framing differently. This issue is fixed in version 3.14.4.
Blast Radius
ecosystem impact- 20 pypi packages depend on aiohttp (15 direct, 5 indirect)
Ecosystem-wide dependent count for version 3.14.4.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
HTTP request smuggling exploits inconsistencies in how front-end and back-end servers parse HTTP message boundaries.
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
aiohttp is an asynchronous HTTP client/server framework for asyncio and Python. Rated high severity (CVSS 7.5), this vul
aiohttp is an asynchronous HTTP client/server framework for asyncio and Python. Rated high severity (CVSS 7.5), this vul
Out-of-bounds heap read in aiohttp's C HTTP response parser (versions ≤ 3.14.2) allows an attacker-controlled server to
Uncontrolled decompression in aiohttp's WebSocket client prior to version 3.14.2 allows a malicious server to exhaust CP
aiohttp is an asynchronous HTTP client/server framework for asyncio and Python. Rated medium severity (CVSS 6.5), this v
HTTP request smuggling in aiohttp's server-side parser allows unauthenticated remote attackers to inject and misdirect H
AIOHTTP 3.8.1 can report a "ValueError: Invalid IPv6 URL" outcome, which can lead to a Denial of Service (DoS). Rated me
aiohttp is an asynchronous HTTP client/server framework for asyncio and Python. Rated medium severity (CVSS 5.3), this v
aiohttp is an asynchronous HTTP client/server framework for asyncio and Python. Rated medium severity (CVSS 5.3), this v
aiohttp is an asynchronous HTTP client/server framework for asyncio and Python. Rated high severity (CVSS 8.7), this vul
Idle or half-open connections to aiohttp server deployments at version 3.14.3 and earlier are never timed out during the
Unauthenticated remote attackers can exhaust file descriptors in aiohttp-based web services by sending crafted multipart
EUVD-2026-104486
GHSA-pqxq-w44r-73xw
NVD
CVE.org
EPSS
VulDB
Exploit-DB