In mcp-server-git versions prior to 2025.12.17, when the server is started with the --repository flag to restrict operations to a specific repository path, it did not validate that repo_path arguments in subsequent tool calls were actually within that configured path. This could allow tool calls to operate on other repositories accessible to the server process. The fix adds path validation that resolves both the configured repository and the requested path (following symlinks) and verifies the requested path is within the allowed repository before executing any git operations. Users are advised to upgrade to 2025.12.17 upon release to remediate this issue.
In mcp-server-git versions prior to 2025.12.17, the git_diff and git_checkout functions passed user-controlled arguments directly to git CLI commands without sanitization. Flag-like values (e.g., `--output=/path/to/file` for `git_diff`) would be interpreted as command-line options rather than git refs, enabling arbitrary file overwrites. The fix adds validation that rejects arguments starting with - and verifies the argument resolves to a valid git ref via rev_parse before execution. Users are advised to update to 2025.12.17 resolve this issue when it is released.
Red Hat released an update for Ansible Automation Platform 2.6 addressing multiple issues including bug fixes, feature enhancements, and stability improvements. The update fixes errors such as Redis broken pipe in long-running jobs, issues with object storage secrets in backups, and problems with project sync and job templates. It also adds support for IPv6 dual stack by default, improves API accessibility for AI tools, and includes developer preview features like Ansible MCP Server support. The advisory does not describe any specific security vulnerability exploitation or active threats.
MCP Server Kubernetes is an MCP Server that can connect to a Kubernetes cluster and manage it. Prior to 2.9.8, there is a security issue exists in the exec_in_pod tool of the mcp-server-kubernetes MCP Server. The tool accepts user-provided commands in both array and string formats. When a string format is provided, it is passed directly to shell interpretation (sh -c) without input validation, allowing shell metacharacters to be interpreted. This vulnerability can be exploited through direct command injection or indirect prompt injection attacks, where AI agents may execute commands without explicit user intent. This vulnerability is fixed in 2.9.8.
CVE-2025-66222 is a critical vulnerability in ThinkInAIXYZ's DeepChat versions prior to 0.5.0, involving a stored Cross-Site Scripting (XSS) flaw in the Mermaid diagram renderer. This XSS vulnerability allows attackers to execute arbitrary JavaScript within the application context. Exploiting the exposed Electron IPC bridge, attackers can escalate this to Remote Code Execution (RCE) by registering and starting a malicious Model Context Protocol (MCP) server. The vulnerability has a CVSS score of 9.7, indicating high impact on confidentiality, integrity, and availability without requiring privileges but needing user interaction. European organizations using DeepChat in sensitive environments face significant risks including data breaches, system compromise, and operational disruption. Mitigation requires immediate upgrading beyond version 0.5.
In Splunk MCP Server app versions below 0.2.4, a user with access to the "run_splunk_query" Model Context Protocol (MCP) tool could bypass the SPL command allowlist controls in MCP by embedding SPL commands as sub-searches, leading to unauthorized actions beyond the intended MCP restrictions.
### Description
The Model Context Protocol (MCP) Python SDK does not enable DNS rebinding protection by default for HTTP-based servers. When an HTTP-based MCP server is run on localhost without authentication using `FastMCP` with streamable HTTP or SSE transport, and has not configured `TransportSecuritySettings`, a malicious website could exploit DNS rebinding to bypass same-origin policy restrictions and send requests to the local MCP server. This could allow an attacker to invoke tools or access resources exposed by the MCP server on behalf of the user in those limited circumstances.
Note that running HTTP-based MCP servers locally without authentication is not recommended per MCP security best practices. This issue does not affect servers using stdio transport.
Servers created via `FastMCP()` now have DNS rebinding protection enabled by default when the `host` parameter is `127.0.0.1` or `localhost`. Users are advised to update to version `1.23.0` to receive this automatic protection. Users with custom low-level server configurations using `StreamableHTTPSessionManager` or `SseServerTransport` directly should explicitly configure `TransportSecuritySettings` when running an unauthenticated server on localhost.
CVE-2025-66454 is a medium severity vulnerability in ArcadeAI's arcade-mcp HTTP server versions prior to 1.5.4. The server uses a hardcoded default worker secret key "dev" that is never validated or overridden during startup. This allows unauthenticated attackers who know the default key to forge valid JWT tokens, bypassing FastAPI authentication entirely. Exploitation grants remote access to all worker endpoints, including tool enumeration and invocation, without any credentials. The vulnerability does not require user interaction or privileges and is exploitable over the network. It is fixed in version 1.5.4.
MCP TypeScript SDK is the official TypeScript SDK for Model Context Protocol servers and clients. Prior to 1.24.0, The Model Context Protocol (MCP) TypeScript SDK does not enable DNS rebinding protection by default for HTTP-based servers. When an HTTP-based MCP server is run on localhost without authentication with StreamableHTTPServerTransport or SSEServerTransport and has not enabled enableDnsRebindingProtection, a malicious website could exploit DNS rebinding to bypass same-origin policy restrictions and send requests to the local MCP server. This could allow an attacker to invoke tools or access resources exposed by the MCP server on behalf of the user in those limited circumstances. Note that running HTTP-based MCP servers locally without authentication is not recommended per MCP security best practices. This issue does not affect servers using stdio transport. This vulnerability is fixed in 1.24.0.
By providing a command-line argument starting with a semi-colon ; to an API endpoint created by the EnhancedCommandExecutor class of the HexStrike AI MCP server, the resultant composed command is executed directly in the context of the MCP server’s normal privilege; typically, this is root. There is no attempt to sanitize these arguments in the default configuration of this MCP server at the affected version (as of commit 2f3a5512 in September of 2025).
The npm package @postman/postman-mcp-server versions 2.4.10, 2.4.11, and 2.4.12 was found to contain malicious code. This malicious payload, associated with the Sha1-Hulud: The Second Coming NPM worm, steals tokens and credentials, publishes them to GitHub, propagates itself to other NPM packages owned by the user, and establishes persistence via a GitHub action. It may also destroy the user's home directory.
The npm package lite-serper-mcp-server version 0.2.2 contains malicious code introduced by the Sha1-Hulud: The Second Coming NPM worm. This malware steals tokens and credentials, publishes them to GitHub, propagates itself to other NPM packages owned by the user, and establishes persistence via a GitHub action. It may also destroy the user's home directory. Any system with this package installed should be considered fully compromised.
The AI Engine plugin for WordPress is vulnerable to Server-Side Request Forgery in all versions up to, and including, 3.1.8 via the rest_helpers_create_images function. This makes it possible for authenticated attackers, with Editor-level access and above, to make web requests to arbitrary locations originating from the web application and can be used to query and modify information from internal services. On Cloud instances, this issue allows for metadata retrieving.
CVE-2025-63604 is a code injection vulnerability in baryhuang/mcp-server-aws-resources-python 0.1.0 that enables remote code execution via the execute_query method due to insufficient input validation. The vulnerability arises from exposing dangerous Python built-ins (__import__, getattr, hasattr) and using exec() on user-supplied input. Exploitation can lead to theft of AWS credentials, unauthorized file system and environment access, and full system compromise. No authentication or user interaction is required, and the attack can be performed remotely over the network. The CVSS score is 6.5 (medium severity), reflecting the ease of exploitation but limited impact on availability. European organizations using this package to manage AWS resources are at risk, especially those with critical cloud infrastructure. Mitigation requires removing dangerous built-ins from execution contexts, avoiding exec() on untrusted input, and implementing strict input validation and sandboxing.
A command injection vulnerability exists in the MCP Data Science Server's (reading-plus-ai/mcp-server-data-exploration) 0.1.6 in the safe_eval() function (src/mcp_server_ds/server.py:108). The function uses Python's exec() to execute user-supplied scripts but fails to restrict the __builtins__ dictionary in the globals parameter. When __builtins__ is not explicitly defined, Python automatically provides access to all built-in functions including __import__, exec, eval, and open. This allows an attacker to execute arbitrary Python code with full system privileges, leading to complete system compromise. The vulnerability can be exploited by submitting a malicious script to the run_script tool, requiring no authentication or special privileges.
CVE-2025-58337 is an improper access control vulnerability in Apache Doris MCP Server that allows an attacker with a valid read-only account to bypass the read-only mode and perform unauthorized modifications. The issue is fixed in version 0.6.0.
### Summary
While setting up an oauth client, it was noticed that the callback page hosted by the client during the flow embeds user-controlled content without escaping or sanitizing it. This leads to a reflected Cross-Site-Scripting vulnerability.
### Details
The affected code is located in *https://github.com/jlowin/fastmcp/blob/main/src/fastmcp/client/oauth_callback.py*, which embeds all values passed to the `create_callback_html` function via the `message` parameter it into the callback page without escaping them. This can, for example, be abused by calling the callback server with an XSS payload inside the `error` GET parameter, the value of which will then be inserted into the callback page, causing the execution of attacker-controlled JavaScript code in the callback server's origin. Note that besides the `error` parameter, other parameters reaching this function are affected too.
### PoC
1. Setup a simple fastmcp client such as this one (the callback server's port was fixated for simplicity):
```
url="http://127.0.0.1:8000/mcp"
oauth = OAuth(mcp_url=url,callback_port=1337)
async def main():
async with Client(url, auth=oauth) as client:
await client.ping()
# List available operations
tools = await client.list_tools()
print(f"tools: {tools}")
asyncio.run(main())
```
2. Ensure that the MCP server located at `http://127.0.0.1:8000/mcp` supports oauth.
3. Start the client.
4. As soon as the callback server has been started, access `http://localhost:1337/callback?error=<img/src/onerror=alert(window.origin)>`
Note that the exploitation could also for example be initiated by a malicious authorization server by returning the exploitation URL mentioned before in the `authorization_endpoint` field. The client would then automatically open, causing the XSS to trigger immediatly.
### Impact
The impact of this XSS vulnerability is the arbitrary JavaScript execution in the victim's browser in the callback server's origin.
### Summary
A command-injection vulnerability lets any attacker who can influence the server_name field of an MCP execute arbitrary OS commands on Windows hosts that run fastmcp install cursor
### Details
1. generate_cursor_deeplink(server_name, …) embeds server_name verbatim in a cursor://…?name= query string.
2. open_deeplink() is invoked with shell=True only on Windows. That calls cmd.exe /c start <deeplink>.
3. Any cmd metacharacter inside server_name (&, |, >, ^, …) escapes the start command and spawns an attacker-chosen process.
### PoC
server.py
```
import random
from fastmcp import FastMCP
mcp = FastMCP(name="test&calc")
@mcp.tool
def roll_dice(n_dice: int) -> list[int]:
"""Roll `n_dice` 6-sided dice and return the results."""
return [random.randint(1, 6) for _ in range(n_dice)]
if __name__ == "__main__":
mcp.run()
```
then run in the terminal:
`fastmcp install cursor server.py`
### Impact
OS Command / Shell Injection (CWE-78)
Every Windows host that runs fastmcp install cursor is at risk. Developers on their local workstations, CI/CD agents and corporate build machines alike.