CVE-2026-128132 is a high-severity vulnerability in aiohttp's WebSocket implementation where the receive queue limits can be bypassed by sending many small or compressed messages. This allows an attacker to cause excessive memory consumption by overwhelming the WebSocket server or client with messages faster than they can be processed. The issue arises because empty messages were not counted towards the queue size and compressed frames could decompress into large amounts of data. A patch is available in version 0.21.0_2 to address this flaw.
A security vulnerability in the yunikorn-k8shim package prior to version 1.9.0-r1 involves lax handling of malformed framing-related headers in its HTTP/2 implementation. Although these malformed headers cannot disrupt HTTP/2 framing, they can lead to a high-impact integrity issue. The vulnerability is rated with a CVSS score of 7.5 (high severity).
A vulnerability in the pure-Ruby IDNA implementation of Addressable allows certain invalid Punycode A-labels to be decoded incorrectly by the to_unicode method. This causes the display_uri method to show misleading hostnames that differ from the actual host used in connections. An attacker controlling a domain with such a label can have a URI displayed as a host they do not control, potentially misleading applications that rely on display_uri or to_unicode for security decisions. The native IDNA implementation is not affected. The issue is fixed in Addressable version 2.9.1.
CVE-2026-115559 is a vulnerability in Python's imaplib library where the STARTTLS implementation improperly handles buffered plaintext bytes received before the TLS handshake. These bytes are returned as if they were protected by TLS, allowing a network attacker to inject forged lines after the server's STARTTLS OK response. This can cause the client to accept forged server responses, leading to command/response injection similar to CVE-2011-0411. The issue affects CPython versions prior to 3.16.0 and has a medium severity rating.
Node-forge versions prior to 1.4.1 contain a vulnerability in their RSA key generation implementation where the use of BigInteger.prototype.modInverse() with a negative value or modulus can cause an infinite loop. This can lead to a denial of service by blocking the Node.js event loop at full CPU. The issue does not affect parsed DER, PEM, JWK, PKCS#12, X.509, and TLS values as they are unsigned. The vulnerability is fixed in version 1.4.1.
## Summary
When cache interception is enabled, `@opennextjs/cloudflare` can interpret percent-encoded paths differently during middleware matching and cache lookup.
An encoded request may fail to match authorization middleware, then be decoded into the cache key of a protected route. The cached response may consequently be returned without invoking the middleware.
`enableCacheInterception` is disabled by default.
## Impact
A remote unauthenticated attacker may retrieve cached content from routes intended to be protected by middleware.
An application is affected when it:
- explicitly enables `enableCacheInterception`;
- relies on middleware for access control; and
- has a matching cached route.
## Details
Middleware matching previously used the encoded request pathname, while cache interception decoded the pathname before selecting a cache entry.
For example, consider an application with:
- middleware matcher `/admin/:path*`;
- middleware returning `401 Authentication required` for `/admin`;
- a statically generated, cached `/admin` route; and
- cache interception enabled:
```ts
export default defineCloudflareConfig({
incrementalCache: staticAssetsIncrementalCache,
enableCacheInterception: true,
});
```
An attacker can request:
```http
GET /%61dmin
```
The encoded pathname does not match `/admin/:path*`, so the authorization middleware is not invoked. Cache interception then decodes `%61dmin` to `admin` and may return the cached `/admin` response:
```http
HTTP/1.1 200 OK
x-opennext-cache: HIT
Protected content
```
Malformed paths exposed an additional inconsistency. For example:
```http
GET /%61dmin/%ZZ
```
The previous implementation decoded each segment independently. It decoded `%61dmin` to `admin` but retained the malformed `%ZZ` segment, allowing cache lookup to continue using a partially decoded pathname.
## Patches
The fix aligns encoded-path handling across middleware matching and cache lookup, and rejects malformed paths instead of partially decoding them. See the upstream fixes in [opennextjs-aws#1199](https://github.com/opennextjs/opennextjs-aws/pull/1199) and [opennextjs-aws#1200](https://github.com/opennextjs/opennextjs-aws/pull/1200).
Users should upgrade to `@opennextjs/cloudflare@1.20.2` or later.
## Workarounds
If upgrading is not immediately possible for an application:
1. Disable cache interception by removing `enableCacheInterception: true`.
2. Enforce authorization inside protected route handlers rather than relying exclusively on middleware.
3. Reject encoded paths for protected routes at a trusted proxy before they reach the Worker.
Adding individual encoded matcher variants is not a complete workaround because pathnames can have multiple equivalent encodings.
A vulnerability in the Linux kernel TCP implementation allowed old ACK packets, outside the expected sequence window, to be processed in the fast path without proper validation. This could lead to connection state being incorrectly modified by segments with excessively old ACKs. The issue has been resolved by excluding such old ACKs from the fast path, ensuring they are validated in the slow path according to RFC5961.
Plane, an open-source project management tool, has a missing authorization vulnerability prior to version 1.4.0. An authenticated user who knows a workspace slug can access workspace member information and project member data via a specific API endpoint, even if they are not a member of that workspace. This issue is due to the lack of workspace-membership checks in the API's permission implementation. The vulnerability is fixed in version 1.4.0.
### Summary
`pyvenv.cfg` is a line-based format with no escape syntax. `PyEnvCfg.write()` wrote values verbatim, while `PyEnvCfg._read_values()` parses the file with `str.splitlines()`. A value containing a line boundary therefore became additional configuration lines, and because reading is last-wins, the injected keys replaced any key written earlier in the file.
### Impact
The `prompt` value is the reachable input: it is set by `--prompt`, by the `VIRTUALENV_PROMPT` environment variable, or from the config file, and `write()` emits `prompt` before `home`. A crafted prompt can therefore set `home` in the generated `pyvenv.cfg`:
```console
$ virtualenv --prompt $'x"\nhome = /attacker/path\nprompt = "z' venv
$ grep '^home' venv/pyvenv.cfg
home = /attacker/path
```
`home` is what tooling reads to locate the base interpreter, so a consumer that trusts it can be pointed elsewhere. `implementation`, `version_info`, `version`, `executable`, `command` and `virtualenv` are also written before `prompt` and can be replaced the same way.
This requires the prompt to come from somewhere other than the person running the command, for example a CI job templating a branch name into it, tooling deriving an environment name from user-supplied data, or an inherited `VIRTUALENV_PROMPT`. Where the operator supplies the prompt directly they already control the command line, and the effect is corruption rather than privilege gain: the value is truncated at the boundary and read back with a dangling quote.
### Details
The boundary set is the one `str.splitlines()` recognizes, which is wider than `\n`: `\r`, `\v`, `\f`, the file, group and record separators, `U+0085`, `U+2028` and `U+2029` were all written through unchanged and all split the line when read back.
### Patches
`PyEnvCfg.write()` now collapses those boundaries to spaces as it serializes each line, so it cannot emit a structurally invalid file regardless of what a caller places in `content`.
### Workarounds
Do not pass externally influenced data as the virtualenv prompt. Strip line boundaries from any value before using it as `--prompt` or `VIRTUALENV_PROMPT`.
CVE-2026-90149 is a vulnerability in the Linux kernel's NFSv4/flexfiles implementation affecting NFSv4.0 data servers. The flaw involves NULL pointer dereferences due to assumptions that NFSv4.0 clients have sessions, which they do not. This leads to kernel oops conditions during I/O operations on affected servers. The issue has been fixed in specific Linux kernel commits.
Published: 2026-09-09 Reference: GHSA-p7v4-vr35-mj6f Description Severity A security vulnerability GHSA-p7v4-vr35-mj6f (CVE assignment pending) in containerd's CRI implementation allows a container restored from an untrusted checkpoint through the CreateContainer API to bypass the destination security context and execute with elevated privileges. When restoring a container from a checkpoint archive or annotated OCI image, CRIU restores process credentials, Linux capabilities, no_new_privs , and seccomp state directly from checkpoint data rather than enforcing the destination CRI ContainerConfig . An attacker who can run a container with a crafted checkpoint image can execute processes as the root user with full capabilities and no enforced seccomp filters despite restrictive security policies requested by the orchestrator. Additionally, containerd's CRI status reporting reflects the requested configuration rather than the actual restored process state, masking the privilege discrepancy from orchestrators. GKE clusters are not vulnerable by default. GKE node images do not include the criu tool. Implicit container restore is not supported without criu installed on the node. Standard container creation operations in GKE Standard and GKE Autopilot remain unaffected. GKE Autopilot clusters do not support custom runtime configuration and are not impacted. Additionally, Pod snapshots in GKE do not exercise the vulnerable implicit restore codepath. In updated containerd versions (2.3.4 and later, or 2.2.7 and later), implicit restore is disabled by default through the enable_experimental_restore_via_create configuration option. Version 2.4 of containerd will remove this codepath completely in favor of the explicit Pod-level restore API (KEP-5823). Warning: Administrators can manually re-enable the feature in containerd (2.3.4 and later, or 2.2.7 and later) by setting the enable_experimental_restore_via_create configuration option. However, doing so leaves this vulnerability present because containerd cannot enforce destination security policy while it restores the criu process. What should I do? Because GKE does not include the criu binary on default node images, no immediate cluster upgrades or configuration changes are required for default workloads. If you install custom runtime software or node tools on your nodes that include the criu binary, consider taking the following actions as appropriate for your environment: Re-create existing restored containers: Stop, delete, and re-create any running containers that were restored from untrusted checkpoints. Disable experimental restore (containerd 2.3.4 and later, or 2.2.7 and later): If operating nodes with containerd (2.3.4 and later, or 2.2.7 and later) and custom criu installations, ensure the enable_experimental_restore_via_create configuration option remains set to false in your containerd node configuration. Audit containerd logs: If criu is installed, inspect node logs for implicit restore log entries containing search strings such as "Found checkpoint of container" , "Prepared for restore" , or "Restored container successfully" . Monitor deprecation warnings for containerd: Look for the following deprecation warning event: io.containerd.deprecation/cri-create-container-checkpoint-restore . Restrict Pod creation permissions: Ensure Kubernetes RBAC restricts Pod creation permissions ( create pods ) strictly to trusted users and service accounts. Enforce trusted image registries: Ensure that the values for the Pod's image: field reference verified image repositories. Prepare for KEP-5823: Update operational procedures to rely on explicit Pod-level Checkpoint or Restore APIs after they are available in future Kubernetes releases. Medium
Implementation of JOSE for C/C++
Security Fix(es):
OpenIDC/cjose is a C library implementing the Javascript Object Signing and Encryption (JOSE). Prior to version 0.6.2.5, cjose's JWE decryption path for the AES Key Wrap key-management algorithms (`alg` = `A128KW`, `A192KW`, `A256KW`) does not validate the length of the attacker-supplied `encrypted_key` (JWE Encrypted Key) before unwrapping it into a fixed-size, heap-allocated Content Encryption Key (CEK) buffer. A remote, unauthenticated attacker who can submit a crafted JWE to an application that decrypts it with an AES-KW symmetric key can trigger an out-of-bounds heap write, corrupting the heap. This leads at minimum to a crash (denial of service) and, depending on the heap layout and allocator, may be leverageable for further memory-corruption impact. `cjose_jwe_import()` / `cjose_jwe_decrypt()` are pre-authentication entry points: they parse and process fully attacker-controlled input. Upgrade to cjose 0.6.2.5 to receive a patch. If upgrading is not immediately possible, reject the AES Key Wrap algorithms (`A128KW`/`A192KW`/`A256KW`) for untrusted JWEs at the application layer.(CVE-2026-53938)
OpenIDC/cjose is a C library implementing the Javascript Object Signing and Encryption (JOSE). In versions 0.6.1 through 0.6.2.5, when cjose encrypts a JWE using an AES-CBC-HMAC content-encryption algorithm (`A128CBC-HS256`, `A192CBC-HS384`, or `A256CBC-HS512`) together with any key-management algorithm that generates a fresh content-encryption key (CEK), the CEK is all zero bytes instead of being randomly generated. The resulting JWE is therefore encrypted and authenticated under a fixed, publicly known key, so anyone who obtains the JWE can recover the plaintext and forge or modify the content. This is fixed in version 0.6.2.6 by `_cjose_jwe_set_cek_aes_cbc()` generating the CEK from `RAND_bytes`. A regression test asserts that the `encrypted_key` differs across two encryptions for each AES-CBC-HMAC variant. Until upgrading, for data encrypted with cjose, three options are available. Use an AES-GCM `enc` (`A128GCM` / `A192GCM` / `A256GCM`) instead of an AES-CBC-HMAC `enc`, use `alg=dir` with a caller-supplied CEK, or avoid using cjose for JWE encryption with the affected algorithm pair. These are mitigations for new ciphertexts only; data already encrypted under the zero key remains compromised and should be re-encrypted (and any secrets it contained rotated).(CVE-2026-53939)
In the Linux kernel, the following vulnerability has been resolved: erofs: remove fscache backend entirely EROFS over fscache was introduced to provide image lazy pulling functionality. After the feature landed, the fscache subsystem made netfs a new hard dependency, which is unexpected for a local filesystem and has an kernel-defined caching hierarchy which could be inflexible compared to the fanotify pre-content hooks. Therefore, this feature has been deprecated for almost two years. As EROFS file-backed mounts and fanotify pre-content hooks both upstream for a while and already providing equivalent functionality (erofs-utils has supported fanotify pre-content hooks), let's remove the fscache backend now. The main application of this feature is Nydus [1], and they plan to move to use fanotify pre-content hooks in the near future too. I hope this patch can be merged into Linux 7.2, which is also motivated by newly found implementation issues [2][3] that are not worth investigating given the deprecation and limited development resources. The associated fscache/cachefiles cleanup patch will follow separately through the vfs tree (netfs) later: it seems fine since the codebase is isolated by CONFIG_CACHEFILES_ONDEMAND. [1] https://github.com/dragonflyoss/nydus/blob/v2.1.0/docs/nydus-fscache.md [2] https://github.com/dragonflyoss/nydus/pull/1824 [3] https://lore.kernel.org/r/20260619135800.1594811-1-michael.bommarito@gmail.com
A vulnerability in the Linux kernel NFC subsystem's LLCP implementation allows an unbounded walk of the connect_sn TLV list. This flaw occurs because the nfc_llcp_connect_sn() function reads TLV headers and values without verifying that they remain within the buffer boundaries, potentially leading to out-of-bounds reads. The vulnerability is reachable by a nearby NFC device without authentication via received CONNECT and CC PDUs. The issue was fixed by bounding the TLV walk to the skb buffer and adding length checks.
A vulnerability in the Linux kernel's CIFS implementation allows improper validation of DFS referral string offsets, potentially leading to out-of-bounds reads. This flaw occurs because string offsets from the server are not checked to ensure they point inside the response buffer, which can cause memory corruption. The issue has been fixed in multiple Linux kernel versions.
A beginner-level firewall for large language models (LLMs) has been developed as a project by college students. The firewall uses a two-tiered approach combining heuristic methods and a machine learning classifier to detect injection and jailbreak attempts before they reach the LLM. The implementation is based on llama-3.3 and may experience occasional delays in detection time. The project is shared publicly for feedback but does not represent a known vulnerability or active threat.