Description

knowns versions before 0.30.0 contain a path traversal vulnerability in the handleCodeReplace() function that allows attackers to overwrite arbitrary files outside the project root. Attackers can supply absolute paths or relative paths containing directory traversal sequences to write malicious content to sensitive files like shell startup scripts or SSH configuration files.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "8.3",
  "pubDate": "2026-09-07T23:16:53.863Z",
  "pubdate": "2026-09-07T23:16:53.863Z",
  "executiveSummary": "The application knowns contains a critical path traversal vulnerability within the handleCodeReplace() function, affecting all versions prior to 0.30.0. This flaw permits an attacker to perform arbitrary file overwriting outside of the intended project root directory. By manipulating input parameters to include directory traversal sequences (e.g., ../) or absolute system paths, a remote attacker can replace sensitive system configuration files or executable scripts. The vulnerability poses a significant risk to system integrity and confidentiality, as it facilitates unauthorized code execution and potential full system compromise. No specific authentication or complex exploitation requirements are noted, indicating a high risk to deployments exposed to untrusted input sources. Successful exploitation results in an attacker's ability to inject malicious payloads into critical startup files, such as shell initialization scripts or SSH configuration data, granting them persistent access or elevated privileges upon subsequent system activity.",
  "technicalDetails": "The vulnerability resides in the handleCodeReplace() function within the knowns codebase. The root cause is the failure of the application to perform adequate input validation and sanitization on user-supplied file paths before performing file write operations. Specifically, the function does not implement a canonicalization check or a restriction mechanism to verify that the target destination remains within the designated project directory structure.\nThe attack flow begins when an attacker submits a crafted request to the knowns interface that triggers the handleCodeReplace() function. Instead of providing a benign filename, the attacker supplies a path containing directory traversal sequences such as '../' or an absolute filesystem path (e.g., '/home/user/.ssh/authorized_keys' or '/etc/profile').\nUpon receiving the malicious input, the handleCodeReplace() function fails to validate the requested file path against a whitelist or a sandbox boundary. The underlying file system API processes the path as provided, resolving the traversal sequences or absolute path, and proceeds to write the attacker-supplied content to the targeted location. Because the application processes this file operation with the privileges of the service account running the knowns process, the attacker can overwrite any file the service user has write access to.\nThe impact of this vulnerability is severe. By overwriting sensitive configuration files, an attacker can achieve Remote Code Execution (RCE). For example, by overwriting a shell startup script like ~/.bashrc or /etc/profile, the attacker ensures that malicious commands are executed whenever a user logs in or a shell session is initiated. Similarly, overwriting SSH authorized_keys allows an attacker to add their own public key to the server, granting them persistent, passwordless access to the system. The lack of path validation ensures that no protective barriers prevent the transition from a restricted application context to the underlying host operating system's critical files. This vulnerability is effective in all versions before 0.30.0 and does not explicitly require authenticated access to the application, depending on the exposure of the handleCodeReplace() endpoint."
}