Jlleitschuh

Three code paths bypass the existing Server-Side Request Forgery (SSRF) protections by using raw `http.Get()` instead of the validated `hostmatcher.NewDialContext()` dialer. This allows an attacker to make requests to internal services, scan internal networks (such as `127.0.0.1`, `10.x`, `172.16-31.x`, and `192.168.x`), and steal cloud metadata from endpoints like `169.254.169.254` (e.g., AWS IMDSv1 credentials or GCP tokens). Additionally, the use of the `file://` scheme in the `Open()` function enables local file read, potentially exposing sensitive files such as `/etc/gitea/app.ini` which may contain database credentials and JWT signing secrets. The issue affects the following components: - The `Open()` function in `modules/uri/uri.go`. - Release asset and PR patch downloads in `services/migrations/gitea uploader.go` and `services/migrations/dump.go`. - The `oauth2UpdateAvatarIfNeed()` function in `routers/web/auth/oauth.go`.

Incomplete Server-Side Request Forgery (SSRF) protection exists within the webhook and migration allow-list filtering. SSRF is a flaw that allows an attacker to induce the server-side application to make requests to an unintended location.

The software fails to validate HTTPS connections when loading stylesheets, which allows a Man-in-the-Middle (MITM) attacker to inject or modify CSS content. This occurs because the connection is established using `OpenSSL::SSL::VERIFY NONE`, causing the system to accept any HTTPS certificate, including untrusted ones, without validation. The issue is located in the `http.verify mode` setting within the `lib/css parser/parser.rb` file.

The Streamable HTTP server transport in the `rmcp` crate fails to validate the incoming `Host` header. This allows a malicious public website to use a DNS rebinding attack—a technique where a domain name is redirected to a different IP address after the initial DNS resolution—to send authenticated requests to an MCP server on a victim's loopback or private-network interface. An attacker can enumerate and invoke tools, read resources, and trigger side effects such as file writes or shell execution. In `dynoxide`, this issue also enables a cross-origin CSRF (Cross-Site Request Forgery) gap, where a page can send requests to a local server using `fetch` with `mode: 'no-cors'`, bypassing the `Host` check because the `Origin` header remains unchecked. Affected write tools in `dynoxide` include `put item()`, `update item()`, `delete item()`, `create table()`, and `batch write item()`.

Name of the Vulnerable Software and Affected Versions MCP Java SDK versions prior to 1.0.0 Description The MCP Java SDK contains a DNS rebinding vulnerability. This allows an attacker to access a locally or network-private MCP server via a victim's browser. An attacker can then make any tool call to the server as if they were a locally running AI agent. The vulnerability exists because no Origin header validation was occurring, violating the Model Context Protocol (MCP) specification. When the web server serving HTTP traffic to the MCP server does not perform standard CORS checks, a DNS rebinding attack is possible. Recommendations Update to version 1.0.0 or later. As a workaround, run the MCP server behind a reverse proxy configured to strictly validate the `Host` and `Origin` headers. Alternatively, use a framework that inherently enforces strict CORS and Origin validation.

The software contains an insecure transport issue due to the use of the `-k` or `--insecure` flag with `curl`, which disables SSL/TLS certificate validation. This allows attackers with network access to conduct man-in-the-middle attacks, potentially intercepting and modifying downloaded dependencies or code during the build process. Successful exploitation could lead to remote code execution and compromise the supply chain. The vulnerable component is the `curl` command used within the provisioning scripts and Dockerfiles.

A critical Remote Code Execution (RCE) vulnerability exists in the @nestjs/devtools-integration package. When enabled, the package exposes a local development HTTP server with an API endpoint that uses an unsafe JavaScript sandbox implementation. Due to improper sandboxing and missing cross-origin protections, a malicious website visited by a developer can execute arbitrary code on their local machine. The vulnerable endpoint, `/inspector/graph/interact`, accepts JSON input containing a `code` field, which is then executed in a Node.js `vm.runInNewContext` sandbox. The sandbox implementation is similar to the abandoned `safe-eval` library and is easily escapable. The server lacks proper CORS/Origin checking, allowing attackers to bypass security measures.

Name of the Vulnerable Software and Affected Versions: arduino-esp32 versions prior to 3.2.1 Description: The issue affects several OTA update examples and the HTTPUpdateServer implementation in the arduino-esp32 core, allowing an attacker to upload and execute arbitrary firmware due to a lack of Cross-Site Request Forgery (CSRF) protection for firmware uploads via POST requests. This results in remote code execution (RCE). Recommendations: For versions prior to 3.2.1, update to version 3.2.1 to resolve the issue. As a temporary workaround, consider disabling the OTA update feature until the patch is applied. Restrict access to the update endpoints to minimize the risk of exploitation. Avoid using the HTTPUpdateServer implementation until the issue is resolved.

Name of the Vulnerable Software and Affected Versions: ESPAsyncWebServer versions up to and including 3.7.8 Description: A CRLF injection vulnerability exists in the construction and output of HTTP headers within `AsyncWebHeader.cpp`. Unsanitized input allows attackers to inject CR (`r`) or LF (` `) characters into header names or values, leading to arbitrary header or response manipulation. This can enable a wide range of attacks. Recommendations: For versions up to and including 3.7.8, apply the fix available at pull request 211, which is expected to be part of version 3.7.9. As a temporary workaround, consider restricting the input to `AsyncWebHeader.cpp` to prevent CR and LF character injections until the patch is applied.

Name of the Vulnerable Software and Affected Versions: arduino-esp32 versions prior to 3.3.0-RC1 and 3.2.1 Description: The issue concerns a HTTP Response Splitting vulnerability. The `sendHeader` function takes arbitrary input for the HTTP header name and value, concatenates them into an HTTP header line, and appends this to the outgoing HTTP response headers. There is no validation or sanitization of the `name` or `value` parameters before they are included in the HTTP response. If an attacker can control the input to `sendHeader`, they could inject carriage return (`r`) or line feed (` `) characters into either the header name or value. This could allow the attacker to inject additional headers, manipulate the structure of the HTTP response, potentially inject an entire new HTTP response, and/or cause header confusion or other HTTP protocol attacks. Recommendations: For versions prior to 3.3.0-RC1, update to version 3.3.0-RC1 or later. For versions prior to 3.2.1, update to version 3.2.1 or later. As a temporary workaround, consider validating and sanitizing the input to the `sendHeader` function to prevent injection of malicious characters.

The issue is related to a partial-path traversal bypass vulnerability in the `ZipSecurity#isBelowCurrentDirectory` function. This vulnerability allows attackers to "escape" into sibling paths, although it still protects against escaping into higher-level directories. For example, if the running path is /my/app/path, an attacker could navigate into /my/app/path-something-else. The vulnerability is patched in version 1.1.2.

The issue affects CC: Tweaked, a mod for Minecraft, allowing any player to gain access to sensitive information exposed via metadata services API endpoints on cloud hosting providers like AWS, GCP, and Azure. This could potentially allow them to pivot or privilege escalate into the hosting provider.

This issue affects OpenComputers with the Internet Card feature enabled, allowing players to gain access to sensitive information exposed via metadata services' API endpoints, such as those provided by cloud hosting providers like AWS, GCP, and Azure. The lack of proper filtering for IPv6 addresses enables broader access into the local IPv6 network, potentially allowing players to retrieve sensitive information from the private IPv4 address space and the whole IPv6 address space.

The typed-rest-client library is vulnerable to leaking authentication data to third parties. This occurs when a request is sent with `BasicCredentialHandler`, `BearerCredentialHandler`, or `PersonalAccessTokenCredentialHandler`, and the target host returns a redirection with a link to a second host. The next request will then use the credentials to authenticate with the second host by setting the `Authorization` header, which is not the expected behavior. The problem was fixed in version 1.8.0.

The issue allows attackers to copy arbitrary files to certain directories via directory traversal, if an allowed directory name is a substring of the directory name chosen by the attacker. This is due to an incomplete fix for a previous issue.

A critical vulnerability was found in jLEMS, affecting the `unpackJar` function of the file `src/main/java/org/lemsml/jlems/io/util/JUtil.java`. This vulnerability leads to path traversal and can be exploited remotely.

MPXJ is an open source library to read and write project plans from a variety of file formats and databases. On Unix-like operating systems, MPXJ's use of `File.createTempFile(..)` results in temporary files being created with the permissions `-rw-r--r--`. This means that any other user on the system can read the contents of this file. When MPXJ is reading a schedule file which requires the creation of a temporary file or directory, a knowledgeable local user could locate these transient files while they are in use and would then be able to read the schedule being processed by MPXJ.

The issue is related to the implementation of the `PreparedStatement.setText()` or `PreparedStatement.setBytea()` methods in the PgJDBC driver, which can lead to the creation of temporary files that are readable by other users on Unix-like systems. This is an information disclosure issue, where an attacker could potentially access sensitive information. The vulnerability is dependent on the version of the JDK being used.

QTIWorks is a software suite for standards-based assessment delivery. The ZIP handling code does not sufficiently check the paths of files contained within ZIP files, allowing files to be inserted into other locations in the filesystem if they are writable by the process running the QTIWorks Engine. This could potentially allow anonymous users to change files in arbitrary locations in the filesystem. However, in normal QTIWorks Engine deployments, the impact is somewhat reduced because the default QTIWorks configuration does not enable the public demo functionality, so ZIP files can only be uploaded by users with "instructor" privileges.

Knowage is an open source suite for modern business analytics alternative over big data systems. The software is vulnerable to cross-site scripting because the `XSSRequestWrapper::stripXSS` method can be bypassed.