Threats affecting pkg:pypi/aiohttp

AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to 3.14.1, no limit was present on the number of pipelined requests that could be queued. An attacker may be able to use pipelined requests to use excessive amounts of memory, potentially leading to DoS. This vulnerability is fixed in 3.14.1.

AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to 3.14.0, attacker-controlled input included into multipart/payload headers can be used to modify a request to inject additional headers or similar. In the unlikely situation that an application is passing user-controlled strings into MultipartWriter.append(headers=...) or Payload.headers, then an attacker may be able to modify the request to inject headers or change the contents of the request. This vulnerability is fixed in 3.14.0.

A vulnerability in aiohttp versions prior to 3.14.1 causes host-only cookies saved and later restored via CookieJar persistence to lose their host-only status. This results in cookies being sent to subdomains that should not receive them, potentially exposing sensitive session data. The issue is fixed in version 3.14.1.

### Summary Cookies set with the `cookies` parameter on requests are sent after following a cross-origin redirect. ### Impact If a developer uses the `cookies` parameter on a per-request basis then sensitive data might be leaked to an attacker if they manage to control a redirect. ### Workaround If unable to upgrade, using a `Cookie` header in the `headers` parameter is not vulnerable. ----- Patch: https://github.com/aio-libs/aiohttp/commit/f54c40851b0d6c4bbdab97ba518a223adda32478

AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to version 3.14.0, using ``CookieJar.load()`` with untrusted input may allow arbitrary code execution. Most applications using this function will be doing so with the user's own data, so this is unlikely to affect many applications. Version 3.14.0 patches the issue. If an application does allow attacker controlled files to be loaded, a workaround on older releases would be to sanitize the files before loading.

### Summary A response with an excessive number of multipart headers may be allowed to use more memory than intended, potentially allowing a DoS vulnerability. ### Impact Multipart headers were not subject to the same size restrictions in place for normal headers, potentially allowing substantially more data to be loaded into memory than intended. However, other restrictions in place limit the impact of this vulnerability. ----- Patch: https://github.com/aio-libs/aiohttp/commit/8a74257b3804c9aac0bf644af93070f68f6c5a6f

### Summary For some multipart form fields, aiohttp read the entire field into memory before checking client_max_size. ### Impact If an application uses `Request.post()` an attacker can send a specially crafted multipart request to force significant temporary memory allocation even when the request is ultimately rejected. ----- Patch: https://github.com/aio-libs/aiohttp/commit/cbb774f38330563422ca0c413a71021d7b944145

### Summary An unbounded DNS cache could result in excessive memory usage possibly resulting in a DoS situation. ### Impact If an application makes requests to a very large number of hosts, this could cause the DNS cache to continue growing and slowly use excessive amounts of memory. ----- Patch: https://github.com/aio-libs/aiohttp/commit/c4d77c3533122be353b8afca8e8675e3b4cbda98

### Summary On Windows the static resource handler may expose information about a NTLMv2 remote path. ### Impact If an application is running on Windows, and using aiohttp's static resource handler (not recommended in production), then it may be possible for an attacker to extract the hash from an NTLMv2 path and then extract the user's credentials from there. ----- Patch: https://github.com/aio-libs/aiohttp/commit/0ae2aa076c84573df83fc1fdc39eec0f5862fe3d

CVE-2026-34518 is a low-severity vulnerability in aiohttp versions prior to 3.13.4 where the Authorization header is improperly handled during redirects to a different origin. Specifically, while the Authorization header is dropped as intended, the Cookie and Proxy-Authorization headers are retained, potentially exposing sensitive information to unauthorized actors. This issue has been addressed in aiohttp version 3.13.4.

### Summary An attacker who controls the `content_type` parameter in aiohttp could use this to inject extra headers or similar exploits. ### Impact If an application allows untrusted data to be used for the multipart `content_type` parameter when constructing a request, an attacker may be able to manipulate the request to send something other than what the developer intended. ----- Patch: https://github.com/aio-libs/aiohttp/commit/9a6ada97e2c6cf1ce31727c6c9fcea17c21f6f06

### Summary Multiple Host headers were allowed in aiohttp. ### Impact Mostly this doesn't affect aiohttp security itself, but if a reverse proxy is applying security rules depending on the target Host, it is theoretically possible that the proxy and aiohttp could process different host names, possibly resulting in bypassing a security check on the proxy and getting a request processed by aiohttp in a privileged sub app when using `Application.add_domain()`. ----- Patch: https://github.com/aio-libs/aiohttp/commit/e00ca3cca92c465c7913c4beb763a72da9ed8349 Patch: https://github.com/aio-libs/aiohttp/commit/53e2e6fc58b89c6185be7820bd2c9f40216b3000

### Summary The C parser (the default for most installs) accepted null bytes and control characters in request headers. ### Impact An attacker could send header values that are interpreted differently than expected due to the presence of control characters. For example, `request.url.origin()` may return a different value than the raw Host header, or what a reverse proxy interpreted it as., potentially resulting in some kind of security bypass. ----- Patch: https://github.com/aio-libs/aiohttp/commit/9370b9714a7a56003cacd31a9b4ae16eab109ba4

### Summary An attacker who controls the `reason` parameter when creating a `Response` may be able to inject extra headers or similar exploits. ### Impact In the unlikely situation that an application allows untrusted data to be used in the response's `reason` parameter, then an attacker could manipulate the response to send something different from what the developer intended. ----- Patch: https://github.com/aio-libs/aiohttp/commit/53b35a2f8869c37a133e60bf1a82a1c01642ba2b

AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. Prior to version 3.13.4, insufficient restrictions in header/trailer handling could cause uncapped memory usage. This issue has been patched in version 3.13.4.

AIOHTTP is an asynchronous HTTP client/server framework for asyncio and Python. In versions 3.13.2 and below, reading multiple invalid cookies can lead to a logging storm. If the cookies attribute is accessed in an application, then an attacker may be able to trigger a storm of warning-level logs using a specially crafted Cookie header. This issue is fixed in 3.13.3.

CVE-2025-69229 is a medium severity vulnerability in aiohttp versions prior to 3.13.3, an asynchronous HTTP client/server framework for Python. The flaw arises from improper handling of chunked HTTP messages, causing excessive CPU blocking when processing many chunks via the request.read() method. An attacker can exploit this to induce moderate CPU consumption (around 1 second per request), potentially leading to denial-of-service (DoS) by preventing the server from handling other requests. No authentication or user interaction is required, and the vulnerability is remotely exploitable over the network. Although no known exploits are currently in the wild, affected servers remain at risk until patched. The issue is fixed in aiohttp version 3.13.

CVE-2025-69228 is a medium severity vulnerability in aiohttp versions prior to 3.13.3 that allows an attacker to exhaust server memory by crafting malicious HTTP requests targeting handlers using the Request.post() method. This flaw arises from the lack of resource allocation limits or throttling, causing uncontrolled memory consumption and potential server freeze or denial of service. The vulnerability requires no authentication or user interaction and can be exploited remotely over the network. Although no known exploits are currently in the wild, affected servers remain at risk until patched. European organizations using aiohttp-based asynchronous Python web servers should prioritize updating to version 3.13.3 to mitigate this risk.

CVE-2025-69225 is a low-severity HTTP request smuggling vulnerability in aio-libs aiohttp versions prior to 3.13.3. It arises from the parser allowing non-ASCII decimal characters in the HTTP Range header, potentially enabling inconsistent interpretation of HTTP requests. Although no known exploits or impacts have been reported, this flaw could theoretically be leveraged to smuggle HTTP requests, leading to request desynchronization between front-end and back-end servers. The vulnerability is fixed in aiohttp 3.13.3. European organizations using vulnerable aiohttp versions in asynchronous Python web services should upgrade promptly to mitigate risk. Given the low CVSS score and lack of known exploits, the threat is currently low but should not be ignored in sensitive environments.