### Summary
`Application.add_domain()` compiled each `*` in a host mask to `[^:]*`. With two or more wildcards in a mask, matching a long `Host` header that does not match the mask took polynomial time on the event loop.
### Impact
An attacker could stall a server that registers a domain mask with more than one wildcard by sending requests with a long `Host` header.
### Workaround
Use at most one `*` in a domain mask.
---
Patch: https://github.com/aio-libs/aiohttp/commit/c6ac0e44c3c573ff9616f4a6a532992538b31e43
### Summary
The WebSocket reader continued parsing frames already received after the receive queue had paused the transport, and empty messages were not counted towards the queue size. With permessage-deflate, a single read of compressed frames could add many megabytes of decompressed messages to the queue.
### Impact
An attacker could cause excessive memory use in a WebSocket server, or a malicious server against a client, by sending many small or compressed messages faster than the application consumes them.
---
Patch: https://github.com/aio-libs/aiohttp/commit/0ae507423f681161efa77d20052b4054397c7fb6
### Summary
When decompressing a payload made up of many concatenated compressed members (gzip, deflate or zstd), each member was decoded by passing the entire remaining input to a new decompressor, resulting in quadratic CPU time. Empty members produce no output, so `client_max_size` and output backpressure did not limit the work.
### Impact
An attacker could block the event loop of a server with a specially crafted compressed request body or WebSocket message. A malicious server could do the same to a client.
---
Patch: https://github.com/aio-libs/aiohttp/commit/d925a80539ffd227da1d93ab4a5bff123cc777db
### Summary
When the pipelined request queue was full, the pure-Python parser stored the unparsed remainder internally and also returned it to the caller. After a handler declined an upgrade request, the buffered data was re-fed, so the buffer grew with each handled request and already-handled requests were dispatched to the application again.
### Impact
If users are using the Python parser (`AIOHTTP_NO_EXTENSIONS`, or not a standard wheel installed), an attacker could cause excessive memory use and cause pipelined requests to be processed more than once.
### Workaround
Switch to the default C parser.
---
Patch: https://github.com/aio-libs/aiohttp/commit/47babd8c23ca79e2bae6cc8dcb5752b61e369fc7
### Summary
While a request flagged as an upgrade (e.g. a WebSocket handshake) was being handled, all further data received on the connection was buffered with no size limit or flow control until the handler completed.
### Impact
An attacker could cause unbounded memory use by streaming data behind an upgrade request to any handler that does not immediately accept or reject the upgrade.
---
Patch: https://github.com/aio-libs/aiohttp/commit/3d850ee9b92573c7e913821cbcb96005beb3f4df
### Summary
The `max_msg_size` check in the WebSocket reader added the declared frame length to the size of the partial message already buffered. In the C extension this addition is 64-bit arithmetic, so a declared length close to 2**63 overflowed and the check passed.
### Impact
An attacker could bypass `max_msg_size` and cause unbounded memory use by streaming an oversized WebSocket message after a small non-final fragment.
### Workaround
If unable to upgrade, the Python reader is unaffected and can be used with `AIOHTTP_NO_EXTENSIONS=1`.
---
Patch: https://github.com/aio-libs/aiohttp/commit/8cfbe9abe5e11b84006a10f9bdf82bf607671dab
### Summary
When reading a multipart part with `Content-Transfer-Encoding: base64`, `BodyPartReader.read_chunk()` kept reading until the chunk length was a multiple of 4, with no byte limit. A part with a short `Content-Length`, or a long run of whitespace, could cause the entire remaining body to be read into memory within a single call before any size check, or spin on the event loop.
### Impact
An attacker could bypass `client_max_size` to cause excessive memory use, or block the event loop, with a specially crafted multipart request to any handler that reads multipart data.
---
Patch: https://github.com/aio-libs/aiohttp/commit/a555ab698e08e9baea7386d5b4c0761cb8956fdd
### 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
A vulnerability in QUIC servers prior to version 3.1.7 allows a remote client to cause unbounded memory growth by repeatedly opening and resetting streams. This occurs because the server retains the state of rejected streams if the peer resets the stream before the rejection is signaled, leading to a denial of service due to memory exhaustion. The issue does not cause memory corruption or data disclosure and requires a long-lived connection for exploitation.
A vulnerability in OpenSSL versions prior to 3.1.0 affects servers configured with the Suite B certificate flag and TLS 1.3 enabled. The server may read past the end of a fixed group list when processing a ClientHello message that contains no Suite B groups in its supported_groups and key_share extensions. This out-of-bounds read does not disclose memory to the client but may cause a denial of service on builds with sanitizers or hardened allocators due to process crashes.
The MembershipWorks plugin for WordPress is affected by a stored cross-site scripting (XSS) vulnerability in all versions up to and including 6.17. This vulnerability arises from insufficient output escaping of member-supplied data retrieved from the MembershipWorks SaaS API. Specifically, fields such as member name, event title, URL, venue name, and others are output into HTML without proper escaping, allowing unauthenticated attackers to inject arbitrary scripts that execute when users access the affected pages.
A vulnerability in the Matter and Aliro Door Lock Application of the Nordic Semiconductor nRF Door Lock and Access Control Add-on versions 1.0.0 through 1.1.1 allows an attacker to bypass rollback protection. This occurs due to an off-by-one error in handling credential issuer deletion when CONFIG_DOOR_LOCK_STEP_UP_PHASE is enabled, causing the validity iteration state of an adjacent issuer to be cleared incorrectly. An attacker with an older but validly signed Access Document from the adjacent issuer can potentially gain unauthorized physical access. The issue is fixed in version 1.2.0.
A vulnerability exists in the Aliro access control reference applications of the Nordic Semiconductor nRF Door Lock and Access Control Add-on versions 1.0.0 through 1.1.1. When configured with Credential Issuer CA certificate-based issuer trust and the Aliro Step-up phase enabled, the system incorrectly treats a failed lookup of the Credential Issuer as success, skipping a critical credential rollback check. This allows a former authorized user with an old but validly signed Access Document to gain physical access even after their credential has been revoked. The issue is fixed in version 1.2.0.
A use-after-free vulnerability exists in OpenSSL versions prior to 3.0.0 in the PEM_X509_INFO_read_bio_ex() function and related functions. When an application passes an existing stack to these functions and the read operation fails, OpenSSL frees all entries in the stack but leaves dangling pointers in the stack structure. This can lead to application crashes or memory corruption if the application continues to use the stack after failure. OpenSSL itself does not pass an existing stack, so this primarily affects third-party applications that do so. The issue is fixed in OpenSSL 3.0.0.
A vulnerability in the Matter door lock applications of Nordic Semiconductor's nRF Door Lock and Access Control Add-on versions 1.0.0 through 1.1.1 allows suspended users to unlock doors. The AccessManager::ValidateCredential() function does not check the owning user's status and returns success even when no owning user is resolved. This enables users with a suspended status (OccupiedDisabled) or orphaned credentials to continue unlocking doors. The issue is fixed in version 1.2.0.
A vulnerability in the Aliro access control reference applications of the Nordic Semiconductor nRF Door Lock and Access Control Add-on versions 1.0.0 through 1.1.1 allows an attacker with a previously valid time-limited credential to continue accessing the system after the credential's expiration. This occurs because the stored Access Document record does not retain the validity period, causing the system to rely on cached keys without re-evaluating expiration. The issue is fixed in version 1.2.0.
An unauthenticated remote code execution vulnerability exists in the Joomla Extension Easy File Uploader versions prior to 2.9.7. An attacker can upload a PHP-executable file to the Joomla web root using a single multipart POST request without requiring credentials or a CSRF token.
The All in One SEO – AI SEO Plugin for WordPress versions up to 5.0.5 contains a stored cross-site scripting (XSS) vulnerability via the 'name' parameter. Authenticated users with subscriber-level access or higher can inject malicious scripts that execute when other users view affected pages. Exploitation requires specific conditions including WordPress 6.6 or later with the Interactivity runtime and an administrator placing the AIOSEO breadcrumb on the author template.