A denial of service vulnerability (CVE-2025-62727) exists in the Python Starlette ASGI framework used by Red Hat Satellite and other Red Hat products. An unauthenticated attacker can send a crafted HTTP Range header that triggers quadratic-time processing in Starlette's FileResponse Range parsing logic, causing CPU exhaustion and denial of service for file-serving endpoints. The vulnerability has a high severity rating and affects specific versions of Red Hat Satellite components. A fix is available in later versions.
CVE-2026-48710 is a vulnerability in the Starlette ASGI framework where a specially crafted HTTP Host header can cause the reconstructed request URL to differ from the actual requested path. This discrepancy can lead to bypassing security restrictions if an application relies on the reconstructed URL for access control instead of the canonical ASGI path. The impact is rated low to moderate depending on application design, with no direct access granted by the flaw itself. Red Hat products using Starlette as a dependency have low impact due to their deployment architectures and authentication methods. A fix is available in specified versions.
CVE-2026-10690 is a server-side request forgery (SSRF) vulnerability in wonderwhy-er DesktopCommanderMCP version 0.2.37. The issue occurs in the readFileFromUrl function within the src/tools/filesystem.ts file, where manipulation of the URL argument can lead to SSRF. The vulnerability can be exploited remotely. A patch identified by commit 53699bebba9950047bca16ac4dc8f0568f596aaa is available to fix this issue. The CVSS 4.0 base score is 5.3, indicating a medium severity level.
A vulnerability was determined in ahujasid blender-mcp up to 7636d13bded82eca58eb93c3f4cd8708dfdfbe8b. The impacted element is the function execute_blender_code of the file /src/blender_mcp/server.py. This manipulation of the argument code causes code injection. The attack is possible to be carried out remotely. The exploit has been publicly disclosed and may be utilized. This product adopts a rolling release strategy to maintain continuous delivery. Therefore, version details for affected or updated releases cannot be specified. The project was informed of the problem early through an issue report but has not responded yet.
LibreChat is an enhanced ChatGPT clone that supports multiple AI providers. In versions up to and including 0.8.3, users with only `VIEW` access to an MCP server can retrieve the server's decrypted admin-managed secrets through `GET /api/mcp/servers` and `GET /api/mcp/servers/:serverName`. The returned config includes plaintext values for `apiKey.key` and `oauth.client_secret`. This allows viewers of a shared MCP server to exfiltrate the underlying provider credentials. Version 0.8..4 contains a patch. Other remediations include: never returning decrypted admin-managed secrets to non-owners; redacting apiKey.key and oauth.client_secret from all API responses consider returning only boolean presence indicators for secrets, similar to the auth-values route pattern; and, if owners need to edit configs without re-entering secrets, preserving secrets server-side and returning placeholders instead of plaintext.
LibreChat is an enhanced ChatGPT clone that supports multiple AI providers. In versions up to and including 0.8.3, the Model Context Protocol (MCP) server integration resolves ${VAR} placeholders against the server's process.env during Zod schema validation of user-supplied MCP server URLs. Any authenticated user can create a malicious MCP server configuration with a URL pointing to an attacker-controlled domain containing environment variable references, causing the LibreChat server to connect to the attacker's server and transmit critical secrets such as CREDS_KEY, CREDS_IV, JWT_SECRET, and MONGO_URI in the request URL. This enables full compromise of the installation's cryptographic materials and database credentials without requiring administrative privileges. This is patched in version 0.8.4-rc1.
A vulnerability was found in ahujasid blender-mcp up to 7636d13bded82eca58eb93c3f4cd8708dfdfbe8b. The affected element is the function requests.get of the file src/blender_mcp/server.py of the component ZIP File Handler. The manipulation of the argument zip_file_url results in server-side request forgery. The attack can be executed remotely. The exploit has been made public and could be used. This product implements a rolling release for ongoing delivery, which means version information for affected or updated releases is unavailable. The patch is identified as 5b37be25242e73dc4cf1328974d30458b9e5d67e. It is advisable to implement a patch to correct this issue.
OpenClaude is an open-source coding-agent command line interface for cloud and local model providers. Prior to version 0.5.1, the OpenClaude MCP authentication flow starts a temporary local HTTP server to handle OAuth callbacks. To prevent CSRF attacks, the server validates a state parameter against an internally stored value. However, due to a logic flaw in the order of conditionals, an attacker can completely bypass this check and force the server to shut down — without knowing the state value at all. This issue has been patched in version 0.5.1.
A security flaw has been discovered in horizon921 mcpilot 0.1.0. The impacted element is an unknown function of the file client/src/app/api/mcp/call/route.ts of the component MCP API Call Endpoint. The manipulation of the argument serverBaseUrl results in server-side request forgery. The attack can be launched remotely. The exploit has been released to the public and may be used for attacks. The project was informed of the problem early through an issue report but has not responded yet.
CVE-2026-10276 is a server-side request forgery (SSRF) vulnerability in hekmon8 Jenkins-server-mcp version 0.1.0. The flaw exists in the jobPath function within the src/index.ts file, affecting components related to getting build status, build logs, and triggering builds. This vulnerability can be exploited remotely without user interaction and has been publicly disclosed. The vendor has not yet responded or provided a fix. The CVSS 4.0 base score is 5.3, indicating a medium severity level.
A vulnerability was determined in indrasishbanerjee aem-mcp-server up to b5f833aef9b5dfd17a5991b3b18a8a11edbdc583. This impacts the function getAssetMetadata of the file src/mcp-server.ts of the component Axios Request Flow. Executing a manipulation of the argument assetPath can lead to server-side request forgery. The attack can be launched remotely. The exploit has been publicly disclosed and may be utilized. This product does not use versioning. This is why information about affected and unaffected releases are unavailable. The project was informed of the problem early through an issue report but has not responded yet.
mcp-security provides Security and Authorization support for Model Context Protocol in Spring AI. Prior to 0.1.9, the mcp-security framework fails to implement the mandatory SSRF mitigations outlined in the Model Context Protocol (MCP) security specifications. Specifically, it processes untrusted URLs for OAuth-related discovery and metadata without verifying if the targets are malicious or internal to the network. This only affects installations with Dynamic Client Registration (DCR) enabled This vulnerability is fixed in 0.1.9.
Roslyn CodeLens MCP Server is a Roslyn-based MCP server providing semantic code intelligence for .NET codebases. From 0.0.9 to 1.17.0, the get_diagnostics MCP tool loads and executes all DiagnosticAnalyzer assemblies referenced by the target solution without any allowlist, signature check, or user confirmation; includeAnalyzers defaults to true, so no explicit opt-in is required. An attacker who can place a malicious .csproj referencing an attacker-controlled DLL in a location the victim opens with the MCP server will achieve arbitrary code execution in the server process with the server's OS privileges. This vulnerability is fixed in 1.17.0.
> [!NOTE]
> Practical impact depends on whether request body-size limits are enforced upstream (proxy/web-server/framework). Deployments with typical body-size caps (≤2 MB) bound the amplifier significantly; deployments accepting larger token inputs are more exposed.
When verifying detached JWS tokens using the unencoded-payload option (`"b64": false`, RFC 7797), PyJWT performs **Base64URL decoding of the compact-serialization payload segment** *before* enforcing the detached-payload rules.
For `b64=false`, PyJWT later **discards** that decoded payload and replaces it with the caller-provided `detached_payload`. In practice, this turns the middle segment into an attacker-controlled “work amplifier”: a remote client can supply an arbitrarily large Base64URL payload segment that forces **CPU work + memory allocations** even if the signature is invalid.
This creates an **unauthenticated DoS** vector against any endpoint that verifies detached JWS using PyJWT.
---
## Affected Component(s)
* `jwt/api_jws.py`
* `PyJWS.decode()` / `PyJWS.decode_complete()`
* `_load()` (parsing and Base64URL decoding)
---
## Root Cause (exact logic flaw)
### What happens in the code
In `jwt/api_jws.py`, `decode_complete()` does the following (order matters):
* Calls `_load(jwt)` first, which decodes the token segments
* Only after that, checks `header.get("b64")` and if `False`, it replaces `payload = detached_payload` and rebuilds the signing input
This behavior is visible in `decode_complete()`:
* `_load(jwt)` happens **before** the `b64=false` handling
* then `payload = detached_payload` and `signing_input = ... detached_payload` happens afterward ([GitHub][1])
Inside `_load()`, PyJWT unconditionally performs:
* `payload = base64url_decode(payload_segment)`
This is the expensive step the attacker can amplify ([GitHub][1])
### Why this becomes a vulnerability
For `b64=false` detached JWS, the payload segment in compact form is effectively **not needed** for verification in PyJWT’s own logic (since the library uses `detached_payload` as the real payload). Yet PyJWT still decodes it first, meaning:
* cost is paid **even when signature is invalid**
* the decoded bytes are **discarded**
* attacker controls the size of this cost via token length
---
## Impact (evidence-driven)
### Security impact
* **Unauthenticated remote DoS**: decoding work happens before signature rejection → attacker does not need signing key.
* **CPU amplification**: Base64URL decode time scales linearly with payload segment size.
* **Memory amplification**: decoded output allocates large byte buffers (tens of MB per request).
* **Operational impact**: request queueing / worker starvation under modest concurrency bursts.
### Standards context (RFC 7797)
RFC 7797 explicitly notes this option is used when payload is large and/or detached, and discusses interoperability requirements around marking it critical (“crit” with “b64”). ([IETF Datatracker][2])
(PyJWT supports `crit` validation, but the issue here is decode order / unbounded decode of an unused segment.)
---
## Affected Versions
* **Confirmed affected:** PyJWT **2.12.1** (tested from your local editable install and repo).
* **Likely affected:** all versions that include detached payload support for JWS decoding, which was introduced in **2.4.0** (“Add detached payload support for JWS encoding and decoding”). ([pyjwt.readthedocs.io][3])
(For GHSA, this phrasing is strong: “confirmed” + “likely since feature introduction”.)
---
# Threat Model
### Typical real deployment
A service verifies signed HTTP requests or webhooks using detached JWS:
* token is provided in JSON body / query / header
* actual payload is the HTTP request body passed as `detached_payload`
### Attacker
* remote unauthenticated client
* can send requests to verify endpoint
* does **not** need a valid signature (invalid signature still triggers the expensive decode path)
### Attack chain
1. Attacker crafts a JWS compact token with header containing `"b64": false` and `crit:["b64"]`.
2. Attacker inflates the **payload segment** (middle segment) to millions of Base64URL characters.
3. Server calls `PyJWS.decode(...detached_payload=...)`.
4. PyJWT decodes the inflated segment (CPU + memory).
5. Signature is rejected afterward (401) — but resources already consumed.
6. Repeated requests or bursts cause queueing/worker starvation → DoS.
---
# Proof of Concept - file names + results
## PoC placement
* [server_localhost.py](https://github.com/user-attachments/files/26132755/server_localhost.py)
* [client_localhost.py](https://github.com/user-attachments/files/26132757/client_localhost.py)
* [flood_localhost.py](https://github.com/user-attachments/files/26132760/flood_localhost.py)
---
## PoC # 1 - Localhost verification server
**File:** [server_localhost.py](https://github.com/user-attachments/files/26132755/server_localhost.py)
**Purpose:** real HTTP endpoint (`POST /verify`) that calls PyJ
> [!NOTE]
> Scored assuming a deployment where algorithm policy functions as an authentication/authorization boundary. In deployments where the algorithm policy enforces crypto agility only, the practical confidentiality impact is lower and the issue is closer to an integrity-of-policy-enforcement bug.
PyJWT `2.9.0` through `2.12.1` allows a verifier-side algorithm allow-list bypass when `jwt.decode()` or `jwt.decode_complete()` are called with a `PyJWK` key. The token header `alg` is checked against the caller-supplied `algorithms` allow-list, but signature verification is performed with the algorithm bound to the `PyJWK` object instead of the header algorithm. An attacker who controls a registered JWK/JWKS private key can sign with a disallowed algorithm, advertise an allowed algorithm in the JWT header, and still be accepted. The issue affects the documented `PyJWKClient.get_signing_key_from_jwt(...)` flow.
### Summary
PyJWT's `PyJWK` verification path allows a verifier-side algorithm allow-list bypass.
In affected versions, when a JWT is decoded with a `PyJWK` object, PyJWT verifies that the header `alg` string is present in the caller's `algorithms=[...]` list, but it does not actually use the header algorithm to verify the signature. Instead, it verifies with the algorithm already bound to the `PyJWK` object.
This lets an attacker who controls a registered JWK/JWKS private key sign with a disallowed algorithm and have the token accepted as long as the JWT header advertises an allowed algorithm. This affects the documented `PyJWKClient` usage flow and does not require any non-default flags or unsafe configuration.
### Details
In `jwt/api_jws.py` in `2.12.1`, `_verify_signature()` treats `PyJWK` keys differently from normal PEM/public-key inputs:
```python
if algorithms is None and isinstance(key, PyJWK):
algorithms = [key.algorithm_name]
...
if not alg or (algorithms is not None and alg not in algorithms):
raise InvalidAlgorithmError("The specified alg value is not allowed")
if isinstance(key, PyJWK):
alg_obj = key.Algorithm
prepared_key = key.key
else:
alg_obj = self.get_algorithm_by_name(alg)
prepared_key = alg_obj.prepare_key(key)
```
This logic means:
1. The JWT header `alg` is checked only as a string against the caller-supplied allow-list.
2. If the key is a `PyJWK`, the actual verifier is not selected from the header algorithm.
3. Instead, PyJWT always verifies with `key.Algorithm`, which is fixed when the `PyJWK` object is created.
`PyJWK` binds its algorithm in `jwt/api_jwk.py` from the JWK's `alg` field or from key-type defaults:
```python
if not algorithm and isinstance(self._jwk_data, dict):
algorithm = self._jwk_data.get("alg", None)
...
self.algorithm_name = algorithm
self.Algorithm = get_default_algorithms()[algorithm]
self.key = self.Algorithm.from_jwk(self._jwk_data)
```
So once a `PyJWK` is constructed, the verifier uses the `PyJWK`'s bound algorithm, not the JWT header algorithm.
The issue is reachable through the documented JWKS flow. In `docs/usage.rst`, the project documents:
```python
signing_key = jwks_client.get_signing_key_from_jwt(token)
jwt.decode(
token,
signing_key,
audience="https://expenses-api",
options={"verify_exp": False},
algorithms=["RS256"],
)
```
`PyJWKClient.get_signing_key_from_jwt()` returns a `PyJWK`, so this documented path is affected.
This is not a "no-key forgery" issue. The attacker still needs control of an accepted JWK/JWKS private key. However, that is realistic in deployments such as:
- self-service OAuth client assertions
- multi-tenant key registration
- federation / BYO-JWKS trust models
- any system where external parties sign JWTs with their own registered keys
In those cases, the attacker can bypass verifier-side algorithm policy. For example, if the server intends to only accept `PS256`, an attacker controlling an accepted RSA JWK can sign with `RS256`, set `alg=PS256` in the JWT header, and still be accepted through the `PyJWK` path.
The same forged token is rejected through the normal PEM/public-key verification path, which shows the bug is specific to `PyJWK` verification rather than expected JWT behavior.
This behavior was introduced by commit `ab8176abe21e550dbc1c9a6bb7e78ad80853bfb1` (`Decode with PyJWK (#886)`), which is present in tagged releases `2.9.0`, `2.10.0`, `2.10.1`, `2.11.0`, `2.12.0`, and `2.12.1`.
### PoC
Tested locally against PyJWT `2.12.1` on Python `3.12.10` with `cryptography 45.0.6`.
Install dependencies:
```bash
python -m pip install pyjwt==2.12.1 cryptography
```
Run the following script:
```python
import json
import jwt
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives.serialization import Encoding, PublicFormat
from jwt.api_jwk import PyJWK
from jwt.algorithms import RSAAlgorithm
from jwt.utils import base64url_encode
# Generate an RSA keypair controlled by the attacker.
priv = rsa.generate_p
CVE-2026-46155 is a critical out-of-bounds read vulnerability in the Linux kernel's SMB client implementation. It occurs in the smb2_compound_op() function when a server sends a truncated response with a large OutputBufferLength, causing memcpy to read beyond allocated memory and potentially leak kernel heap data. This flaw affects Linux kernel versions from 6.6.32 up to but not including 6.6.140, and version 6.9. A fix has been implemented in version 6.6.140 and related commits.
Authlib versions prior to 1.6.12 and 1.7.1 contain an unauthenticated open redirect vulnerability in the OpenIDImplicitGrant and OpenIDHybridGrant authorization endpoints. This flaw is triggered by omitting the 'openid' scope in authorization requests, causing the server to redirect to an attacker-chosen URL without validating the redirect URI. The vulnerability affects servers supporting OpenID Connect Implicit or Hybrid flows and can be exploited without authentication or valid client IDs. While it does not directly leak tokens or authorization codes, it enables phishing attacks by leveraging the trusted authorization server's domain in the browser's URL bar. A fix is available for this vulnerability.
Nocturne Memory is a lightweight, rollbackable, and visual Long-Term Memory Server for MCP Agents. Prior to 2.4.1, when API_TOKEN is unset or empty, the BearerTokenAuthMiddleware bypasses authentication for all HTTP requests. Combined with the default 0.0.0.0 host binding and CORS allow_origins=["*"], operators following the Docker setup without explicitly setting API_TOKEN expose the full Knowledge-Graph read/write API to any LAN-reachable client. An attacker on the same network can read, write, or delete all memory entries — including system://boot and core://* URIs that auto-load into downstream agent sessions, enabling persistent prompt-injection. This vulnerability is fixed in 2.4.1.
GitLab MCP Server lets an AI agent talk directly to GitLab. Prior to 0.6.0, the HTTP transport in src/transport.ts ships with no authentication layer at all and a wildcard Access-Control-Allow-Origin: * on every response. The structural defect is that the SSE server stands up a stateful, mutation-capable RPC endpoint that is backed by the operator's GITLAB_PERSONAL_ACCESS_TOKEN without any inbound credential check, then advertises itself to every cross-origin browser context via the wildcard CORS header. The httpServer.listen(port) call at line 97 also passes no host argument, so the bind defaults to 0.0.0.0 and exposes the auth-less surface on every interface. This vulnerability is fixed in 0.6.0.
Lumiverse is a full-featured AI chat application. Prior to 0.9.7, the MCP server creation endpoint validates the command field against an allowlist of binary names but forwards the args array to the child process without any validation. Every binary on the allowlist accepts an inline-code execution flag (-e for node/bun, -c for python3/deno), giving any logged-in user arbitrary OS-level code execution on the Lumiverse server. The route requires only requireAuth (not requireOwner). The server binds on all interfaces (::) and the host-header rebinding check is bypassed trivially by any HTTP client that sends Host: localhost:<port> directly, making this exploitable from any machine with network access to the server port. This vulnerability is fixed in 0.9.7.