CVE-2026-128125 is a vulnerability in aiohttp's client CookieJar where unbounded cookie storage occurs due to improper parsing of Set-Cookie headers. This allows a malicious server to cause the client to store an excessive number of cookies, leading to large Cookie headers and excessive resource consumption.
CVE-2026-128124 is a high-severity vulnerability in aiohttp's Application.add_domain() function where multiple wildcards in a domain mask cause polynomial-time matching on long Host headers, leading to event loop stalls. An attacker can exploit this by sending requests with long Host headers to stall the server. The issue is fixed in version 2.8.2_17. A workaround is to limit domain masks to at most one wildcard.
The NLTK library's function nltk.parse.dependencygraph.dot2img executes the Graphviz 'dot' binary without applying the trusted-execution security checks that NLTK uses elsewhere. This allows a local unprivileged attacker on a POSIX system to place a malicious 'dot' executable in a writable directory on the victim's PATH, leading to arbitrary code execution when the victim renders a DependencyGraph or calls dot2img. The vulnerability arises because dot2img only performs a basic binary search without ownership or environment scrubbing checks. This flaw was partially addressed in a related function but remains exploitable in dot2img. A fix is available in version 2.0.0_6.
The NLTK library's sql_query() function in the chat80 module bypasses the pathsec sandbox intended to restrict file access within configured data roots. This occurs because sql_query() uses nltk.data.find() which does not resolve symlinks, allowing an attacker with write access to a trusted data root to plant a symlink to an out-of-root SQLite database. When sql_query() accesses this symlinked database, it can read data outside the sandbox. This vulnerability affects NLTK versions >=2.0.0_3 and <2.0.0_6 and is fixed in version 2.0.0_6.
NLTK's save_maxent_params() and load_maxent_params() functions contain a path traversal vulnerability that allows arbitrary file read and write outside the intended directories. This occurs because these functions use Python's built-in open() directly on paths derived from a user-controlled tab_dir argument, bypassing NLTK's pathsec security mechanism. The vulnerability enables attackers who can control tab_dir to read or overwrite files outside the permitted filesystem boundaries. The issue affects versions prior to 3.9.4 for load_maxent_params and is fixed in 3.9.4 and later for loading; the save functionality fix is merged but not yet released. The CVE assigned is CVE-2026-15367, with a CVSS 4.0 score of 6.3 (medium severity).
The lampouali package on PyPI version 1.0.0 is identified as malicious code that uses fake HTTP-downloaded dependencies to track downloads. It serves no legitimate purpose beyond this tracking behavior and is associated with dependency confusion tactics. The package is categorized as low-harm, likely related to pentesting or research activities.
A vulnerability in aiohttp's WebSocket implementation allows bypassing receive queue limits by sending many small or compressed messages. The WebSocket reader continues parsing frames after the receive queue pauses the transport, and empty messages are not counted towards the queue size. When permessage-deflate compression is used, a single read of compressed frames can add many megabytes of decompressed data to the queue. This can lead to excessive memory consumption on the server or client side.
AIOHTTP suffers from a vulnerability where decompressing concatenated compressed streams (gzip, deflate, or zstd) causes excessive CPU usage due to quadratic time complexity. This can be exploited by an attacker to block the event loop of a server or client using specially crafted compressed payloads.
AIOHTTP versions 0.5.0 and later have a vulnerability where data received during an HTTP upgrade request (such as a WebSocket handshake) is buffered without limit until the upgrade handler completes. This unbounded buffering can lead to excessive memory consumption if an attacker streams large amounts of data behind the upgrade request. The issue has been patched in the referenced commit.
AIOHTTP's WebSocket implementation contains an integer overflow vulnerability in the max_msg_size check within the C extension. This flaw allows an attacker to bypass the maximum message size restriction by sending a specially crafted WebSocket message with a declared frame length near 2^63, causing unbounded memory consumption. The issue affects versions of the homeassistant-cli starting from 0.5.0. A patch is available to address this vulnerability.
AIOHTTP's Request.post() method lacked limits on the number of URL-encoded form fields, causing insertion of many repeated keys into a MultiDict to take quadratic time on the event loop. This flaw allows an attacker to block the event loop by sending a form POST within the default client_max_size to any handler using Request.post(). A patch addressing this issue is available.
A vulnerability in the pure-Python HTTP parser used by aiohttp can cause excessive memory consumption and repeated processing of pipelined requests. This occurs when the pipelined request queue is full and an upgrade request is declined, causing the internal buffer to grow and requests to be replayed. The issue affects users relying on the Python parser instead of the default C parser.
AIOHTTP contains a vulnerability in its multipart handling where base64-encoded parts can bypass the client_max_size limit. This occurs because the BodyPartReader.read_chunk() method reads until the chunk length is a multiple of 4 without enforcing a byte limit, allowing an attacker to cause excessive memory consumption or event loop blocking by sending specially crafted multipart requests.