Simonkoeck

The Snowflake node allows an authenticated user with valid Snowflake credentials to perform arbitrary file read and write operations. This occurs because the node passes free-form input from the Execute Query field, including client-side commands, directly to the Snowflake SDK without enforcing file-access restrictions. Consequently, an attacker can upload local files from the n8n host or overwrite existing files using a staged file.

An arbitrary file write issue exists in the Edit Image node. The node passes the output format parameter to the underlying image library without proper validation. An authenticated user with permissions to execute workflows can provide a specially crafted value for the output format to write files outside the designated working directory of the n8n instance.

Authenticated users with permissions to create and execute workflows can achieve remote code execution via the Git node. By staging a crafted local repository, an attacker can trigger git hooks under default security settings to execute arbitrary commands with the privileges of the n8n process user. This issue affects both cloud and self-hosted instances.

A type confusion issue exists in the Send Email node because message fields are not strictly enforced as strings. If a crafted non-string value is provided via a workflow expression into the text or HTML body fields, the underlying mail library (Nodemailer) may interpret it as a file path or URL. This can lead to arbitrary local file disclosure and server-side request forgery (SSRF), which is a technique used to induce the server to make requests to an unintended location. Exploitation requires a specific non-default configuration: an active workflow with an unauthenticated webhook, valid SMTP credentials, and untrusted input mapped directly to the body field.

An authenticated user with permissions to create or modify workflows can bypass a previous prototype pollution patch in the XML node. Prototype pollution occurs when an attacker manipulates the prototype of an object, potentially altering the behavior of the application. When combined with other nodes, this bypass could lead to remote code execution (RCE) on the host system.

An authenticated user with permissions to create or modify workflows can inject CLI flags during the Push operation of the Git node. This allows the attacker to read arbitrary files from the server, which can lead to a full system compromise and server-level remote code execution (RCE) by breaking sandboxes.

An authenticated user with permissions to create or modify workflows can achieve global prototype pollution via the XML Node. Prototype pollution occurs when an attacker manipulates the prototype of an object, potentially affecting all objects of that type. This can lead to remote code execution (RCE) when combined with other nodes that exploit the polluted prototype.

n8n is a workflow automation platform. A user authenticated with permissions to create or modify workflows could leverage the "Combine by SQL" mode within the Merge node to read local files on the n8n host and potentially achieve remote code execution. The AlaSQL sandbox lacked sufficient restrictions on certain SQL statements, enabling an attacker to access sensitive files on the server or compromise the instance. The vulnerable component is the Merge node and its use of AlaSQL.

H3 is a minimal H(TTP) framework. A Timing Side-Channel issue exists in the `requireBasicAuth` function because of the use of an unsafe string comparison (`!==`). This allows an attacker to deduce the valid password character-by-character by measuring the server's response time, bypassing password complexity protections. The code performs a string comparison between the provided password and the expected password. The `!==` operator is optimized to "fail fast," returning `false` as soon as a mismatch is found. By analyzing timing differences in responses to requests with slightly varying passwords, an attacker can determine the correct password one character at a time. This is effective in local networks or cloud environments where the attacker is co-located. The vulnerability is exploitable remotely. The vulnerable function is `requireBasicAuth`.

Name of the Vulnerable Software and Affected Versions Tolgee versions prior to 3.166.3 Description Tolgee is an open-source localization platform. Prior to version 3.166.3, the XML parsers used for importing Android XML resources (.xml) and .resx files do not disable external entity processing. An authenticated user with the ability to import translation files into a project can exploit this to read arbitrary files from the server and make server-side requests to internal services. Exploitation can involve reading files such as `/etc/passwd` and accessing environment secrets or cloud metadata credentials. This impacts multi-tenant deployments. Recommendations Update to version 3.166.3 or later.

Unhead is a document head and template manager. The `link.href` check within the `makeTagSafe` function (located in `safe.ts`) utilizes `String.includes()`, which is case-sensitive. Browsers, however, treat URI schemes in a case-insensitive manner. Specifically, 'DATA:text/css,...' is interpreted the same as 'data:text/css,...' by the browser, but the case-sensitive check `'DATA:...'.includes('data:')` returns false. This allows an attacker to inject arbitrary CSS for UI manipulation or data exfiltration through CSS attribute selectors with background-image callbacks. The vulnerable code segment is located on lines 68-71 of `safe.ts`. An attacker can leverage this to inject CSS, for example, by using a `link` tag with an `href` attribute like `DATA:text/css,body{display:none}`.

Unhead is a document head and template manager. Before version 2.1.11, the `useHeadSafe()` function could be bypassed, allowing the injection of arbitrary HTML attributes, including event handlers, into server-side rendered (SSR) `<head>` tags. The `acceptDataAttrs` function, located in `safe.ts` (lines 16-20), permits any property key starting with 'data-' to be included in the final HTML. It only verifies the prefix, failing to check for spaces or other characters that disrupt HTML attribute parsing. This allows for the injection of malicious code through crafted `data-*` attributes. A proof-of-concept demonstrates the injection of an `onload` event handler into a `<link>` tag, leading to script execution when the stylesheet loads. This issue can be exploited in scenarios where a Nuxt application accepts SEO metadata from a content management system (CMS) or user profile, potentially affecting every page load. The vulnerable component is the `acceptDataAttrs` function, which is used to process attributes before they are interpolated into the HTML string by the `propsToString` function.

The GitHub Webhook Trigger node fails to implement HMAC-SHA256 signature verification, which is a mechanism used to authenticate that a webhook delivery actually comes from GitHub. This allows an attacker who knows the webhook URL to send unsigned POST requests to trigger workflows with arbitrary data, effectively spoofing GitHub webhook events.

n8n, an open source workflow automation platform, contains a flaw in the Git node. This allows authenticated users with create or modify permissions for workflows to execute arbitrary system commands or read arbitrary files on the n8n host. The issue impacts systems where users have the ability to create or modify workflows. No information is available regarding the number of potentially affected devices worldwide or any real-world incidents of exploitation. The Git node is a component used for interacting with Git repositories. The `Git node` allows users to perform actions such as cloning, pulling, and pushing changes to Git repositories.

The Cache Middleware component does not properly handle HTTP cache control directives such as `Cache-Control: private` or `Cache-Control: no-store`. This can lead to private or authenticated responses being cached and exposed to unauthorized users. The vulnerability exists in the cache decision logic of the Cache Middleware. The impact of this issue is Web Cache Deception and information disclosure, potentially exposing personally identifiable information or session-related data. The issue affects applications using the hono/cache middleware and relying on it to correctly honor HTTP cache control directives.

H3 is a minimal H(TTP) framework designed for high performance and portability. A critical HTTP Request Smuggling issue exists due to a case-sensitive check for the 'Transfer-Encoding' header within the `readRawBody` function. The function specifically looks for "chunked", but the HTTP RFC specifies that this header should be case-insensitive. This allows attackers to desynchronize sockets by using mixed-case 'Transfer-Encoding' headers, potentially bypassing security controls and leading to request smuggling. The vulnerable code is located in `src/utils/body.ts`. The issue occurs because the code does not normalize the header value before checking, causing it to miss 'Transfer-Encoding' headers with mixed casing (e.g., 'ChuNked'). This can lead to the application responding immediately while the actual body remains on the socket, triggering a TE.TE desync. This is particularly impactful in containerized setups behind TCP load balancers, where attackers can smuggle requests past Web Application Firewalls (WAFs) or poison other users' connections.