/

CVE-2026-25938

Severity:

CRITICAL RISK

(9.8)

Authentication Bypass in FUXA Node-RED Plugin

CVE-2026-25938

Analyzed

Vulnerability type

Category:

Authentication Bypass

CWE:

CWE-290, CWE-306

Impact:

Remote Code Execution on Server

Severity:

CRITICAL RISK

(9.8)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

An authentication bypass vulnerability in FUXA (versions 1.2.8 through 1.2.10) allows unauthenticated remote attackers to reach privileged Node-RED functionality and execute arbitrary code on the server when the Node-RED plugin is enabled.

The issue arises because authentication and access control checks can be circumvented, exposing a powerful automation and scripting environment without proper protection.

Affected context

The vulnerability affects FUXA deployments running versions 1.2.8 through 1.2.10 where:

  • The Node-RED plugin is installed and enabled
  • The FUXA instance is network-accessible to untrusted users (e.g., over the internet or a flat internal network)
  • The deployment relies on FUXA's authentication layer to protect access to Node-RED functionality

In this context, the authentication and/or session enforcement around Node-RED endpoints does not reliably prevent unauthorized access.

Exploit preconditions

  • Attack surface: HTTP(S) interface exposed by FUXA, specifically routes associated with the Node-RED plugin.
  • Required access: Network reachability to the FUXA server; no valid credentials are required due to the authentication bypass.
  • Trigger point: Crafted requests to Node-RED–related endpoints that should be protected by authentication but can be accessed or manipulated without proper verification.
  • Why exploitation is possible: The authentication mechanism (CWE-290) and/or enforcement of login requirements (CWE-306) is not correctly applied to the Node-RED plugin, allowing attackers to invoke capabilities that can result in code execution on the host.

Why this happens

The root cause lies in incomplete or improperly enforced authentication and authorization around the Node-RED plugin integration.

Certain routes or operations exposed by the plugin either skip authentication checks, rely on weak trust assumptions (e.g., assuming requests originate from an authenticated context), or incorrectly validate user state.

This maps to CWE-290: Authentication Bypass by Capture-replay, Modification, or Injection, as requests can appear authenticated without a valid session, and CWE-306: Missing Authentication for Critical Function, since high-impact actions—such as managing or executing Node-RED flows—are exposed without robust login enforcement.

Abstractly, the pattern is: a powerful administrative or scripting component is integrated into a web application but is not consistently wrapped with strong authentication and access control, effectively turning internal control surfaces into public attack surfaces.

Potential impact

  • Remote attackers can execute arbitrary code or commands on the FUXA server through exposed Node-RED functionality.
  • Complete takeover of the FUXA application, including modification of SCADA/HMI dashboards and automation logic.
  • Manipulation of industrial control logic that FUXA supervises, potentially affecting physical processes depending on deployment.
  • Lateral movement within the network by using the compromised server as a pivot point.
  • Theft or tampering of configuration data, process values, and operational logs.

General mitigation guidance

Effective mitigation focuses on restoring strict authentication boundaries around all powerful integrations and reducing the exposed attack surface.

Common defensive patterns include:

  • Ensuring all Node-RED and similar plugin endpoints are consistently protected by the same authentication and authorization layers as the core application.
  • Applying the principle of least privilege to plugin capabilities so that only explicitly authorized and authenticated roles can modify or execute flows.
  • Placing FUXA behind a dedicated access control layer (such as a reverse proxy or VPN) so that only trusted networks and users can reach the management interface.
  • Enforcing strong session management, including unforgeable tokens, CSRF protection where relevant, and strict server-side checks for every sensitive operation.
  • Hardening the deployment by isolating FUXA and Node-RED processes, limiting OS-level privileges, and restricting outbound network access from the service where practical.

How teams detect issues like this

Detection typically combines code-level analysis with operational monitoring:

  • Static analysis and code review: Look for routes or controllers related to Node-RED that omit authentication middleware or perform ad-hoc, inconsistent checks. Flag any direct access to Node-RED management or execution APIs without role verification.
  • Configuration and policy review: Verify that plugins and embedded services inherit global authentication policies. Identify exceptions where IP-based trust or unauthenticated access is allowed and validate the business justification.
  • Runtime monitoring: Inspect HTTP logs for unauthenticated requests invoking Node-RED endpoints or administrative actions (e.g., creating, editing, or deploying flows). Correlate such requests with authentication events.
  • Security testing: Use authenticated/unauthenticated differential testing to ensure that all critical operations fail in the absence of valid sessions. Automated scanners and integration tests can continually check that newly added routes remain protected.

Sources

SourceLink
github.comgithub.com/frangoteam/FUXA/commit/5e7679b09718534e4501a146fdfe093da29af336
github.comgithub.com/frangoteam/FUXA/releases/tag/v1.2.11
github.comgithub.com/frangoteam/FUXA/security/advisories/GHSA-v4p5-w6r3-2x4f

Frequently asked

questions

Yes. If the FUXA interface is reachable over the network and the Node-RED plugin is enabled on an affected version, an unauthenticated remote attacker can exploit the issue without prior access.

No. The weakness is an authentication bypass affecting critical Node-RED functionality, so exploitation does not require a valid username or password when the vulnerable configuration is present.

The most robust fix pattern is to ensure that all critical plugin operations are guarded by centralized, mandatory authentication and authorization checks. Every route that exposes scripting, configuration, or administrative control should use the same hardened access-control mechanisms as the core application, with no unauthenticated exceptions.

Prevention relies on designing integrations so that new components (like plugins or embedded tools) cannot bypass established security layers. This includes enforcing authentication middleware by default, maintaining an inventory of all sensitive endpoints, using security-focused code review for plugin integrations, and adding automated tests that verify critical actions are inaccessible without a valid, authorized session.

Find out what's already
exploitable in your codebase.