Liran Tal

An attacker with a valid read-only account can bypass the Doris MCP Server’s read-only mode due to improper access control. This allows modifications that should have been prevented by read-only restrictions. Attackers with read-only access may perform unauthorized modifications.

The software is susceptible to a command injection issue. The tool trusts branch names without sanitization and constructs git commands by concatenating user input. This allows attackers to execute arbitrary commands through maliciously crafted branch names, potentially gained through pull requests or privileged repository access.

The package is vulnerable to Server-Side Request Forgery (SSRF) due to an incomplete denylist of IP address ranges. The package fails to classify the reserved IP address space 224.0.0.0/4 (Multicast) as invalid, allowing attackers to craft requests targeting these multicast addresses.

The package is susceptible to a Server-Side Request Forgery (SSRF) issue. An attacker can provide an IP address or hostname that resolves to a multicast IP address (224.0.0.0/4), which is not included in the package’s private IP range checks.

The package is susceptible to Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection') within the `shell` API. This occurs due to insufficient neutralization of user-supplied input. An attacker can leverage this by providing specially crafted input containing command-line arguments or shell metacharacters, potentially resulting in unintended command execution.

The package is susceptible to a Directory Traversal issue. This allows an attacker to access files outside of the intended directory by traversing the file system.

The issue is related to Server-Side Request Forgery (SSRF) where an attacker can provide a hostname that resolves to a local or reserved IP address space and bypass the SSRF protection mechanism.

The issue is related to Prototype Pollution due to improper input sanitization. An attacker can exploit this vulnerability through Bun's APIs that accept objects.

The issue concerns Arbitrary Argument Injection via the clone() API. This API allows specifying the remote URL to clone and the file on disk to clone to. However, the library fails to sanitize user input or validate a given URL scheme. Additionally, it does not properly pass command-line flags to the git binary using the double-dash POSIX characters (--) to communicate the end of options.

The issue concerns Command Injection via the `fetchTags(branch)` API, which allows user input to specify the branch to be fetched. This input is then concatenated with a git command and passed to the unsafe `exec()` Node.js child process API.

The issue is related to command injection due to missing sanitization or mitigation flags in the `process` variable of the `gitShallowClone` function. This allows for potential argument injection. No information is provided about the estimated number of potentially affected devices or real-world incidents where this issue was exploited.

The issue arises from improper input sanitization passed via the `validPath` function of server.js, leading to Directory Traversal. This vulnerability affects a popular library that had 100,000 weekly downloads up to a year ago and is still actively downloaded.

The issue is related to Arbitrary Argument Injection via the `blameByFile()` API. The library does not sanitize for user input or validate the given file path, nor does it properly pass command-line flags to the git binary using the double-dash POSIX characters (--) to communicate the end of options.

The issue arises from improper input sanitization of the path being requested via the `requestFile` function, leading to Directory Traversal. This allows unauthorized access to files and directories outside the intended directory.

The issue arises from improper file path sanitization in the `startsWith()` method within the `servePath` function, leading to Directory Traversal. This allows attackers to access files outside the intended directory.

The issue concerns a Denial of Service (DoS) condition that occurs when an attacker sends an HTTP request containing control characters that the `decodeURI()` function cannot parse. This can lead to a service disruption.

The issue is related to a directory traversal vulnerability in the HTTP server of glance, allowing an attacker to bypass access restrictions and gain unauthorized access to protected information. This vulnerability enables users to read files outside the public root directory.

The issue is related to Directory Traversal, caused by improper sanitization of the `filePath` variable. This allows for unauthorized access to files and directories.

The issue arises from missing input sanitization or other checks and protections employed to the `req.url` passed as-is to `path.join()`, leading to Directory Traversal. This allows potential access to sensitive files and directories.

The issue arises when the software detects a request to a directory and renders a file listing of its contents. This listing includes links with actual file names, but these names are not sanitized or output encoded, leading to Cross-site Scripting (XSS).