Skip to main content

FUXA CVE-2026-43945

HIGH
Code Injection (CWE-94)
2026-05-26 https://github.com/frangoteam/FUXA GHSA-p69w-mmfv-xrfj
Share

Lifecycle Timeline

2
Source Code Evidence Fetched
May 27, 2026 - 00:02 vuln.today
Analysis Generated
May 27, 2026 - 00:02 vuln.today

DescriptionCVE.org

Pre-auth RCE in FUXA via Logic Bypass

Summary

A Critical vulnerability chain exists in FUXA (v.1.3.0-2706) that allows an unauthenticated remote attacker to achieve Full Remote Code Execution (RCE) as root. The exploit succeeds even when the platform is configured in its most secure state (Secure Mode Enabled and Node-RED Secure Auth Enabled).

Details The vulnerability is a Path Confusion flaw in the authentication middleware. The server uses a substring match on the full URL (including query parameters) to exclude certain paths from authentication.

Involved Logic:

JavaScript:

const url = req.originalUrl || req.url || req.path;
if (url.includes('/socket.io')) return next();
By appending ?x=/socket.io to any administrative request, the middleware is "tricked" into treating the request as a public WebSocket handshake, bypassing the secureEnabled and nodeRedAuthMode checks entirely.

Proof of Concept

A specially crafted request containing manipulated query parameters could bypass authentication checks on protected /nodered/* endpoints.

In configurations where Node-RED exposed privileged or command-execution capable nodes, this could lead to remote code execution within the container context.

Impact Access Level: Unauthenticated / Remote.

Privilege Level: Access to Node-RED administrative endpoints. Remote code execution may be possible depending on the Node-RED configuration and installed nodes.

CVSS 3.1 Score: High severity.

Description: An attacker can gain total control over the SCADA server, allowing them to intercept industrial data (MQTT/OPC-UA), manipulate PLC tags, or pivot into the internal OT network.

Root Cause & Remediation The root cause is the reliance on req.originalUrl for security-critical routing decisions.

The Fix: The developer must use req.path (which Express pre-parses to remove query strings) or a formal URL parser to ensure that the security check is performed only against the pathname.

JavaScript

// Secure approach
const pathname = req.path;
if (pathname.startsWith('/socket.io/')) return next();

This issue affects only setups where Node-RED is enabled.

AnalysisAI

Pre-authentication remote code execution affects FUXA, an open-source web-based SCADA/HMI platform, in versions >= 1.2.11 and < 1.3.1 (the advisory references build v1.3.0-2706). The flaw is a path-confusion authentication bypass: the login middleware performs a substring match against the full request URL (including the query string), so appending a benign-looking parameter such as ?x=/socket.io to any administrative request causes the server to treat it as a public WebSocket handshake and skip the secureEnabled and nodeRedAuthMode checks entirely. When Node-RED is enabled with command-capable nodes, this reaches the /nodered/* admin interface and yields code execution in the container context (advisory states 'as root'). The GitHub Security Advisory (GHSA-p69w-mmfv-xrfj) discloses the exact bypass payload, so publicly available exploit details exist; there is no CISA KEV listing and no public report of active exploitation at time of analysis.

Technical ContextAI

FUXA is a JavaScript/Node.js SCADA-HMI application (npm package @frangoteam/fuxa) that embeds Node-RED for flow-based automation logic and communicates with industrial systems over protocols such as MQTT and OPC-UA. The vulnerable code lives in the Express-based authentication middleware, which derives the request path with const url = req.originalUrl || req.url || req.path; and then calls url.includes('/socket.io') to whitelist the Socket.IO handshake from authentication. Because req.originalUrl retains the raw query string, the substring test matches attacker-controlled query content rather than the true pathname - a classic incorrect-comparison / path-confusion defect that the CVE maps to CWE-94 (Improper Control of Generation of Code / Code Injection), since the auth bypass ultimately enables injection of executable logic through Node-RED. The affected component is identified by CPE pkg:npm/@frangoteam_fuxa.

RemediationAI

Upgrade to the vendor-released patched version: FUXA 1.3.1, whose release notes explicitly list 'Security: authentication bypass in request routing logic (#2260)' along with a related authorization fix for /api/getTagValue (https://github.com/frangoteam/FUXA/releases/tag/v1.3.1). The upstream fix replaces the query-string-inclusive check with a pathname-only comparison (using req.path or a formal URL parser, e.g. req.path.startsWith('/socket.io/')). If immediate patching is not possible, the most effective compensating control is to disable the Node-RED integration, which removes the RCE path entirely (trade-off: loss of any automation flows that depend on Node-RED); additionally restrict network reachability of the FUXA server and its /nodered/* endpoints to trusted management hosts via firewall/reverse-proxy ACLs, and place the SCADA host on a segmented OT network so a successful bypass cannot pivot laterally. Review the advisory at https://github.com/frangoteam/FUXA/security/advisories/GHSA-p69w-mmfv-xrfj for the authoritative fix details.

Share

CVE-2026-43945 vulnerability details – vuln.today

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy