CVE-2026-7811 in code-mcp
Summary
by MITRE • 05/05/2026
A vulnerability has been found in 54yyyu code-mcp up to 4cfc4643541a110c906d93635b391bf7e357f4a8. The affected element is the function is_safe_path of the file src/code_mcp/server.py of the component MCP File Handler. Such manipulation leads to path traversal. It is possible to launch the attack remotely. The exploit has been disclosed to the public and may be used. This product takes the approach of rolling releases to provide continious delivery. Therefore, version details for affected and updated releases are not available. The project was informed of the problem early through an issue report but has not responded yet.
If you want to get the best quality for vulnerability data then you always have to consider VulDB.
Analysis
by VulDB Data Team • 05/27/2026
The vulnerability identified in the 54yyyu code-mcp project represents a critical path traversal flaw within the MCP File Handler component. This security weakness resides in the is_safe_path function located in src/code_mcp/server.py, where inadequate input validation allows malicious actors to manipulate file path references. The vulnerability affects the rolling release versioning approach of the product, making it challenging to definitively identify affected versions since the project maintains continuous delivery without traditional version tagging. The flaw enables remote exploitation through manipulation of file path parameters, allowing attackers to access files outside the intended directory structure. This type of vulnerability falls under CWE-22 Path Traversal and aligns with ATT&CK technique T1083 File and Directory Discovery, as it permits unauthorized access to system files and directories beyond the application's intended scope. The vulnerability's public disclosure status increases the risk of exploitation, as threat actors can leverage existing attack vectors without requiring additional reconnaissance.
The technical implementation of the is_safe_path function demonstrates insufficient sanitization of user-supplied path inputs, creating an opportunity for attackers to craft malicious requests that bypass intended security boundaries. When the application processes file operations, it fails to properly validate or sanitize path components, allowing traversal sequences such as ../ or ..\ to be interpreted by the underlying file system. This weakness operates at the intersection of input validation and access control, where the application assumes that path parameters are safe without implementing proper security checks. The vulnerability's remote exploitation capability means that attackers can initiate malicious requests from external systems without requiring local access to the target server, making it particularly dangerous in networked environments. The continuous delivery model of the project compounds the risk as updates may not be immediately available, leaving systems exposed for extended periods. The lack of response from the project maintainers following early issue reporting indicates potential delays in vulnerability remediation that could leave deployed systems vulnerable to exploitation.
The operational impact of this path traversal vulnerability extends beyond simple unauthorized file access, as it can potentially enable attackers to read sensitive configuration files, access database credentials, or even execute arbitrary code if the application has sufficient privileges. Attackers may leverage this vulnerability to perform reconnaissance activities, gather system information, or escalate privileges within the application environment. The vulnerability's presence in the MCP File Handler component suggests potential exposure across multiple file operations that rely on path validation, creating a broad attack surface. Organizations deploying this software may face compliance violations if sensitive data is accessed through this vulnerability, particularly in regulated environments where data protection requirements apply. The continuous delivery model means that security updates may not be immediately available, leaving deployed systems in a state of ongoing vulnerability. This vulnerability also demonstrates the importance of proper input validation and the principle of least privilege in application security design, where applications should not assume that user inputs are safe without proper sanitization. The combination of remote exploitability and the project's delayed response to vulnerability disclosure creates a high-risk scenario for affected deployments.