AIOHTTP's Application.add_domain() function had a performance issue where domain masks with two or more wildcards caused polynomial-time matching delays on the event loop when processing long Host headers. This could be exploited by an attacker to stall the server. A patch is available in version 1.6.1_1 that fixes this issue.
A vulnerability in AIOHTTP WebSocket handling allows attackers to bypass receive queue limits by sending many small or compressed messages. This can cause excessive memory consumption on the server or client side. The issue arises because the WebSocket reader continues parsing frames after the receive queue pauses the transport, and empty messages are not counted towards the queue size. With permessage-deflate compression, a single read can decompress many megabytes, exacerbating the memory impact. A patch is available to address this issue.
AIOHTTP contains a vulnerability where decompressing concatenated compressed streams (gzip, deflate, or zstd) causes excessive CPU usage due to quadratic time complexity. This occurs because each compressed member is decompressed by passing the entire remaining input to a new decompressor. An attacker can exploit this to block the event loop of a server or client by sending specially crafted compressed payloads. A patch addressing this issue is available.
A vulnerability in the pure-Python parser of AIOHTTP allows an attacker to cause excessive memory consumption and replay of pipelined HTTP requests when the pipelined request queue is full and an upgrade request is declined. This occurs because the parser buffers unparsed data and re-feeds it after a declined upgrade, leading to buffer growth and repeated request processing. The issue affects users relying on the Python parser instead of the default C parser.
AIOHTTP versions 1.5.2 and later have a vulnerability where data received during an upgrade request (such as a WebSocket handshake) is buffered without any size limit or flow control until the handler finishes processing. This can lead to unbounded memory consumption if an attacker streams large amounts of data behind the upgrade request to a handler that does not promptly accept or reject the upgrade.
AIOHTTP's WebSocket implementation contains an integer overflow vulnerability in the max_msg_size check, allowing an attacker to bypass message size limits. This can lead to unbounded memory consumption by streaming an oversized WebSocket message after a small non-final fragment. The issue affects versions starting from 1.5.2. A workaround exists by disabling C extensions, and a patch is available.
A vulnerability in aiohttp's multipart handling allows bypass of the client_max_size limit when processing parts with Content-Transfer-Encoding set to base64. The BodyPartReader.read_chunk() method reads until the chunk length is a multiple of 4 without enforcing a byte limit, enabling an attacker to cause excessive memory consumption or event loop blocking by sending a specially crafted multipart request.
### Summary
`Request.post()` had no limit on the number of fields in a URL-encoded form body. Inserting a large number of repeated keys into a `MultiDict` took quadratic time on the event loop.
### Impact
An attacker could block the event loop with a form POST within the default `client_max_size` to any handler that calls `Request.post()`.
---
Patch: https://github.com/aio-libs/aiohttp/commit/615fec3d4f088f30d2ee72cad760152e92aa1c53
### Summary
`Set-Cookie` parsing created additional cookies from unrecognised `name=value` attributes, and `CookieJar` had no limit on the number of cookies stored or sent. A server could make the client store a very large number of cookies and generate very large `Cookie` headers.
### Impact
A malicious server could cause excessive memory and CPU use in a client, repeated on every redirect, and cause later requests to the same domain to build an excessively large `Cookie` header.
---
Patch: https://github.com/aio-libs/aiohttp/commit/6963ee0befec1502b6bb7b4db6c72d044c08f4fa
The RubyGems package 'node-test-repo' version 1.0.1 has been identified as malicious by the OpenSSF Package Analysis project. The package is considered malicious because it communicates with a domain associated with malicious activity. No CVSS score or detailed technical impact information is provided.