A vulnerability in AIOHTTP's WebSocket implementation allows bypassing the max_msg_size limit due to an integer overflow in the C extension's 64-bit arithmetic. This flaw enables an attacker to send an oversized WebSocket message after a small non-final fragment, causing unbounded memory consumption. The issue affects versions 1.2.1 and later. A patch is available to fix this integer overflow. As a workaround, users can disable the C extension by setting AIOHTTP_NO_EXTENSIONS=1 to use the unaffected Python reader.
AIOHTTP's Request.post() method had no limit 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 is available to address this issue.
AIOHTTP's client CookieJar component improperly handled Set-Cookie headers by creating additional cookies from unrecognized name=value attributes and lacked limits on the number of cookies stored or sent. This flaw allows a malicious server to cause a client to store an excessive number of cookies, leading to large Cookie headers and excessive memory and CPU usage on the client side, especially during redirects.
The vulnerability in Application.add_domain() involves inefficient wildcard matching of host masks containing two or more asterisks (*). This causes polynomial-time processing on the event loop when matching long Host headers that do not fit the mask, potentially stalling the server. The issue affects versions 1.2.1 and later. The recommended workaround is to limit domain masks to at most one wildcard. A patch addressing this inefficiency has been published.
A vulnerability in AIOHTTP's pure-Python HTTP parser causes the request buffer to grow uncontrollably when handling declined upgrade requests, leading to excessive memory use and repeated processing of pipelined requests. This affects users relying on the Python parser instead of the default C parser. A patch is available to address this issue.
A vulnerability in aiohttp's multipart handling allows bypassing the client_max_size limit when processing base64-encoded multipart parts. This can lead to excessive memory consumption or event loop blocking due to unbounded reading of the request body.
CVE-2026-128132 is a vulnerability in aiohttp's WebSocket implementation where the receive queue limits can be bypassed by sending many small or compressed messages. This occurs because the WebSocket reader continues parsing frames after the receive queue has paused 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 large amounts of decompressed data to the queue, potentially causing excessive memory use.
AIOHTTP versions 6.0.0 prior to 6.0.1 contain a vulnerability where decompressing concatenated compressed streams (gzip, deflate, or zstd) causes excessive CPU usage due to quadratic time complexity. This can block the event loop of a server or client when processing specially crafted compressed payloads. The issue is fixed in version 6.0.1.
CVE-2026-128129 is a vulnerability in aiohttp versions 6.0.0 up to but not including 6.0.1 where data received during an HTTP upgrade request (such as a WebSocket handshake) is buffered without any size limit or flow control until the handler completes. 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.
The RSS widget of the dashboard allows backend users to configure the URL of the RSS feed in the widget settings. The URL was fetched by the server without restricting the target host. Backend users with access to the dashboard could therefore make the server send HTTP requests to arbitrary hosts, including internal network services and cloud metadata endpoints, which are not reachable from the outside.
The file dump controller (eID=dumpFile) delivers files, file references and processed files identified by their uid, protected by a token. The token only covered the uid value, but not the type of the requested resource. A valid token issued for a file could therefore be reused to request a file reference or a processed file with the same uid. As a result, unauthenticated visitors could download files, for example from non-public storages, for which no token had been issued.
The FileUpload and ImageUpload elements of the Form Framework use the property allowedMimeTypes as an allow list of MIME types accepted for upload. An empty allowedMimeTypes list was treated as "no restriction". Forms containing upload elements without any configured MIME type, for example in manually created form definitions or when all MIME types were deselected in the form editor, accepted any file except those blocked by the file deny pattern, which only covers PHP-related file extensions. This allowed unauthenticated users to upload files with browser-executable content, such as HTML or SVG documents, to the configured upload folder, which by default is located in a public storage. If attackers know the URL of an uploaded file (see TYPO3-CORE-SA-2026-029), this could lead to Cross-Site Scripting on web servers that do not apply the Content-Security-Policy recommended by TYPO3 to the form upload target folder.
The cHash argument, which ensures that only URL arguments originally generated by TYPO3 create separate page cache entries, was treated inconsistently when it was passed as an array. The cHash validation treated such a value as missing, while the page cache identifier treated it as present and included all URL arguments. As a result, unauthenticated visitors could create an unlimited number of page cache entries and trigger uncached page renderings by adding an array cHash with arbitrary values to any URL. This could exhaust server resources and fill the page cache storage. Only installations where the cHash validation is not enforced via $GLOBALS['TYPO3_CONF_VARS']['FE']['cacheHash']['enforceValidation'] are affected. This setting is enabled by default for new installations since TYPO3 v12, but is often still disabled in installations upgraded from older versions.
The fix for TYPO3-CORE-SA-2026-009 was incomplete. GeneralUtility::sanitizeLocalUrl performed its checks on the URL-decoded value, but returned the original, URL-encoded value. URLs containing certain percent-encoded characters therefore passed the sanitization checks as local URLs, although they point to an external host. Applications that use the sanitized URL for redirects are vulnerable to open redirect attacks. This enables attackers to redirect users to external content and carry out phishing attacks. In the TYPO3 core, this affects redirects in the backend, which require the victim to be logged in to the backend.