C0Rydoras

A sandbox escape exists in NodeVM that allows attackers to access the host ` proto ` getter/setter via `console. stdout` and `console. stderr`. By overwriting `EventEmitter.prototype.emit` and triggering process events, an attacker can execute code within the process context, effectively bypassing restrictions on code generation.

A sandbox escape allows unauthenticated attackers to execute arbitrary system commands (RCE) on the host. The issue occurs because `BaseHandler.getPrototypeOf` can be reached via `util.inspect`, enabling the retrieval of arbitrary prototypes. By manipulating object prototypes through internal bridge functions, an attacker can gain access to the host's process object.

A flaw in the Node.js sandbox library allows sandboxed code to obtain the host `Object`. This occurs due to incorrect code generation management and incomplete protections. An attacker can use the host `Object` to bypass isolation and execute arbitrary code on the host system. One method of exploitation involves using `HostObject.getOwnPropertySymbols` to obtain `Symbol(nodejs.util.inspect.custom)`.

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.

SandboxJS is a JavaScript sandboxing library susceptible to a sandbox escape. The issue arises from the ability to obtain arrays containing the `Function` constructor. Combined with `Object.fromEntries`, this allows constructing objects with properties that can execute arbitrary code, leading to a complete escape of the sandbox. The provided Proof of Concept (PoC) demonstrates the exploitation of this issue using `process.getBuiltinModule("child process").execSync("ls", {stdio: "inherit"})` to execute system commands. The vulnerability can result in Remote Code Execution (RCE). The API endpoint is not explicitly mentioned. The vulnerable variable is `Function`.

Enclave is a secure JavaScript sandbox used for safe AI agent code execution. A critical security flaw exists in versions prior to 2.11.1, allowing an attacker to escape the sandbox boundaries and achieve remote code execution (RCE) on the underlying host system. This is possible due to the ability to obtain the native `Object` constructor, allowing access to restricted properties and host functions. Two proof-of-concept exploits are described, one leveraging ` host memory track ` when a memory limit is set, and another utilizing Node's `nodejs.util.inspect.custom` symbol when a memory limit is not set. Successful exploitation results in arbitrary command execution on the host, representing a full system compromise.

n8n is an open source workflow automation platform. An authenticated user with permission to create or modify workflows could exploit a weakness in the JavaScript Task Runner sandbox to execute code outside of its intended boundary. When using the default internal Task Runners, this could lead to a complete compromise of the n8n host system. If external Task Runners are in use, an attacker might gain access to or disrupt other tasks running on the Task Runner. The Task Runners must be enabled using the `N8N RUNNERS ENABLED=true` setting. Reports indicate over 100,000 servers are potentially affected, with a significant concentration in the United States and a notable presence in Russia.

SandboxJS is a JavaScript sandboxing library affected by an issue where the return values of functions are not properly wrapped. This allows attackers to use `Object.values` or `Object.entries` to obtain an array containing the host's `Function` constructor. By utilizing `Array.prototype.at`, the host's `Function` constructor can be accessed, enabling the execution of arbitrary code outside of the sandbox. The provided proof-of-concept code demonstrates how to leverage this to execute commands like 'ls -lah' using the `child process` module. The vulnerability allows for sandbox escape, potentially leading to remote code execution (RCE).

SandboxJS is a JavaScript sandboxing library. Prior to version 0.8.29, a flaw exists where the prototype of the `Map` object, present in `SAFE PROTOYPES`, can be accessed via `Map.prototype`. By overwriting the `Map.prototype.has` function, the sandbox can be escaped, potentially leading to remote code execution. The issue stems from a bug in the `let` implementation, where using `let` instead of `const` to declare a variable referencing `Map.prototype` results in `undefined`. This allows manipulation of the `Map.prototype.has` function. A proof-of-concept (PoC) demonstrates the ability to execute arbitrary commands, such as listing directory contents, by redefining `Map.prototype.has` to call `isFinite.constructor` with a malicious string.

n8n is a workflow automation platform. A flaw in the Python Code node allows authenticated users to bypass the Python sandbox and run code outside the intended security limits. The vulnerability allows for arbitrary code execution on the host system.

SandboxJS is a JavaScript sandboxing library with an issue where the ` lookupGetter ` function is not properly restricted. This can allow obtaining prototypes, potentially leading to sandbox escape and remote code execution. The issue affects versions prior to 0.8.27.

The issue arises from the failure to properly validate the props used by the RetrospectivePost custom post type in the Playbooks plugin. This allows an attacker to create a specially crafted post with maliciously crafted props, causing a denial of service (DoS) of the web app for all users.

The issue arises from the improper handling of posts with attachments that contain fields which cannot be converted to a string. This allows an attacker to cause the mobile application to crash by creating and sending such a post to a channel.

The issue allows an attacker to crash the mobile application via crafted malicious input. This is due to the failure to properly validate the style of proto supplied to an action's style in post.props.attachments.

The issue arises from the improper handling of posts with attachments containing fields that cannot be cast to a String. This allows an attacker to cause the webapp to crash by creating and sending such a post to a channel.

The issue arises from the failure to properly validate post properties, allowing a malicious authenticated user to cause a crash via a malicious post. This can be exploited by an authenticated user, indicating a need for proper validation mechanisms to prevent such crashes.

The issue arises from the failure to properly validate the style of proto supplied to an action's style in post.props.attachments. This allows an attacker to crash the frontend via crafted malicious input.

The issue arises from the failure to properly validate post properties, allowing a malicious authenticated user to cause a crash via a malicious post. This can be exploited by an authenticated user, indicating a need for proper access controls and validation mechanisms.

The issue is related to the improper validation of post properties, which allows a malicious authenticated user to cause a crash via a malicious post. This can be achieved through a public post, but specific details about the exploitation, such as API endpoints or vulnerable parameters, are not provided.

The issue arises from the failure to properly validate post properties, allowing a malicious authenticated user to cause a crash via a malicious post. This can be exploited by an authenticated user to disrupt the service.