CVE-2025-55346: Dynamic Function Constructor RCE Flaw

CVE-2025-55346 Overview

CVE-2025-55346 is a critical JavaScript injection vulnerability that enables remote code execution through unsafe handling of user-controlled input in a dynamic Function constructor. Attackers can exploit this flaw by sending a simple POST request to execute arbitrary unsandboxed JavaScript code in the context of the host system, potentially leading to complete system compromise.

Critical Impact

This vulnerability allows unauthenticated network attackers to achieve remote code execution by injecting malicious JavaScript through a POST request, with no user interaction required.

Affected Products

• Flowise AI workflow automation platform (specific versions to be confirmed via vendor advisory)

Discovery Timeline

• August 14, 2025 - CVE-2025-55346 published to NVD
• August 14, 2025 - Last updated in NVD database

Technical Details for CVE-2025-55346

Vulnerability Analysis

This vulnerability falls under CWE-94 (Improper Control of Generation of Code), commonly known as code injection. The flaw exists because user-supplied input is passed directly to a dynamic JavaScript Function constructor without proper sanitization or validation. When attackers craft malicious payloads and submit them via POST requests, the application dynamically generates and executes JavaScript code containing the attacker's payload. Because this execution occurs outside of any sandbox environment, the malicious code runs with the full privileges of the host process, enabling attackers to read sensitive files, execute system commands, establish reverse shells, or pivot to other systems on the network.

Root Cause

The root cause stems from the unsafe use of JavaScript's Function() constructor with user-controlled input. The Function() constructor in JavaScript creates a new function from a string of code at runtime. When user input flows into this constructor without proper sanitization, attackers can inject arbitrary JavaScript that gets compiled and executed. Unlike sandboxed evaluation methods, functions created this way have access to the global scope and can interact with the underlying system through Node.js APIs.

Attack Vector

The attack is initiated remotely over the network. An attacker sends a crafted POST request containing malicious JavaScript code embedded in the request payload. The vulnerable application parses this input and passes it to the dynamic Function constructor, which compiles and executes the attacker's code. The attack requires no authentication and no user interaction, making it trivially exploitable by any network attacker who can reach the vulnerable endpoint.

The vulnerability manifests through the unsafe dynamic code generation pattern where user input flows directly into the Function constructor. For detailed technical analysis and proof-of-concept information, refer to the JFrog Vulnerability Analysis.

Detection Methods for CVE-2025-55346

Indicators of Compromise

• Unusual POST requests to Flowise API endpoints containing JavaScript code patterns such as require(), child_process, or eval()
• Unexpected outbound network connections from the Flowise server process
• Creation of new files or processes spawned by the Node.js application
• Presence of reverse shell commands or suspicious subprocess activity in application logs

Detection Strategies

• Implement web application firewall (WAF) rules to detect and block POST requests containing JavaScript code injection patterns
• Monitor for HTTP requests with payloads containing Node.js-specific dangerous functions like require('child_process') or process.binding()
• Deploy endpoint detection and response (EDR) solutions to identify anomalous process creation from the Node.js runtime
• Analyze network traffic for suspicious outbound connections originating from the Flowise server

Monitoring Recommendations

• Enable detailed request logging on web servers and reverse proxies fronting Flowise deployments
• Configure SIEM rules to alert on POST requests containing JavaScript injection signatures
• Monitor the Node.js process for unexpected child processes or system calls
• Track file system changes in the Flowise application directory for signs of webshell deployment

How to Mitigate CVE-2025-55346

Immediate Actions Required

• Restrict network access to the Flowise application to trusted IP addresses only
• Place the application behind a WAF configured to block code injection attempts
• Monitor application logs for signs of exploitation attempts
• Consider temporarily disabling the vulnerable functionality if possible until a patch is applied

Patch Information

Consult the JFrog Vulnerability Analysis for the latest patch availability and remediation guidance. Upgrade to a patched version of Flowise as soon as one becomes available.

Workarounds

• Deploy network-level access controls to limit who can reach the vulnerable endpoint
• Implement a reverse proxy with request inspection to filter out malicious payloads
• Run the Flowise application in a containerized environment with restricted capabilities and network policies
• If feasible, disable or remove the functionality that processes dynamic code execution until patched

# Example: Restrict access to Flowise using iptables
iptables -A INPUT -p tcp --dport 3000 -s 10.0.0.0/8 -j ACCEPT
iptables -A INPUT -p tcp --dport 3000 -j DROP