/

CVE-2026-25752

Severity:

CRITICAL RISK

(9.1)

Missing Authorization / Access Control in FUXA SCADA/HMI

CVE-2026-25752

Analyzed

Vulnerability type

Category:

Missing Authorization / Access Control

CWE:

CWE-862

Impact:

Unauthorized Remote Manipulation of ICS/SCADA Tags and Drivers

Severity:

CRITICAL RISK

(9.1)

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

FUXA, a web-based SCADA/HMI dashboard, contains an authorization bypass where WebSocket endpoints fail to enforce role-based access control on device tag operations.

An unauthenticated remote attacker can modify arbitrary device tags or disable communication drivers, potentially enabling manipulation of connected industrial processes without valid credentials.

Affected context

This vulnerability appears in FUXA deployments where:

  • WebSocket interfaces are exposed from the FUXA server to clients (e.g., operator HMIs, browser-based dashboards)
  • Role-based access control is expected to restrict who can read/write device tags or manage communication drivers
  • Network access to the FUXA WebSocket endpoint is possible from untrusted or partially trusted networks (such as corporate LANs with mixed user populations or segmented OT/IT environments)

The issue concerns WebSocket message handling for device tag writes and driver control, where authorization checks are incomplete or absent for certain actions.

Exploit preconditions

  • Attack surface: FUXA WebSocket interface reachable over the network (typically HTTP(S) upgraded to WebSocket).
  • Required access: Network-level connectivity to the FUXA server; no prior authentication or valid user session is required if the endpoint is exposed.
  • Trigger point: Sending crafted WebSocket messages that invoke tag-write operations or driver control commands.
  • Why exploitation is possible: The server-side WebSocket handlers for these operations do not consistently enforce role-based access checks, allowing actions to be executed regardless of authentication state or assigned role.

Why this happens

The root cause aligns with CWE-862: Missing Authorization: the application exposes functionality that modifies sensitive resources (device tags and communication drivers) without enforcing proper authorization.

In FUXA, certain WebSocket message handlers appear to trust the presence of a connection or client-supplied parameters instead of validating a bound, authenticated user identity and checking that user's permissions against configured roles or ACLs.

This leads to a situation where security decisions are either skipped or misapplied for critical industrial control actions, breaking the intended role-based access control model.

Potential impact

  • Remote modification of arbitrary device tags, which may influence process setpoints, alarms, or status indicators.
  • Disabling or misconfiguring communication drivers, potentially cutting off monitoring or control of field devices.
  • Manipulation of physical processes via the HMI layer, including unsafe state changes if downstream protections are weak.
  • False readings on operator dashboards, causing operators to make incorrect decisions based on manipulated data.
  • Facilitation of broader attacks against ICS/SCADA environments by masking malicious activity or preparing equipment for physical damage.

General mitigation guidance

Effective mitigation centers on enforcing strict, server-side authorization for every state-changing operation exposed over WebSockets.

Defensive patterns include:

  • Requiring a validated, authenticated user session to be bound to each WebSocket connection and rejecting messages from unauthenticated clients.
  • Performing role- and permission checks server-side for each tag write, driver control action, and any other sensitive operation—never relying only on client-side UI restrictions.
  • Segregating high-risk operations (e.g., write access, driver enable/disable) behind elevated roles and, where feasible, additional approval or confirmation workflows.
  • Applying the principle of least privilege to application roles so that most accounts have read-only access and only tightly controlled roles can modify device tags or drivers.
  • Limiting network exposure of the FUXA interface through proper segmentation, firewalls, and VPNs so that only authorized operator networks can reach the WebSocket endpoints.

How teams detect issues like this

Detection strategies can focus on both code-level and operational indicators:

  • Static analysis and code review:
  • Search for WebSocket handlers or controllers that perform tag writes, driver control, or configuration changes, and verify that each path enforces server-side authorization checks.
  • Flag any use of WebSocket message processing that relies on client-supplied role or user identifiers without validating them against a server-side session or token.
  • Review role-based access control logic to ensure that all state-changing methods are gated by permission checks, not just HTTP endpoints.
  • Security testing and runtime monitoring:
  • Conduct manual or automated security testing to attempt tag modifications from unauthenticated or low-privilege contexts over WebSockets.
  • Monitor logs for unusual tag changes or driver disable events, especially from unknown IP ranges or user agents, and correlate them with authentication logs.
  • Policy enforcement:
  • Introduce development policies requiring explicit authorization annotations or middleware for all WebSocket handlers that touch critical ICS/SCADA functions.
  • Integrate automated review tools into CI/CD pipelines to detect missing authorization patterns.

Sources

SourceLink
github.comgithub.com/frangoteam/FUXA/releases/tag/v1.2.10
github.comgithub.com/frangoteam/FUXA/security/advisories/GHSA-ggxw-g3cp-mgf8

Frequently asked

questions

It can be, if the FUXA WebSocket interface is reachable from the internet or any untrusted network. Exploitability depends on network exposure and segmentation; in many ICS setups, the attack surface is limited to internal or connected networks.

No, the issue specifically involves missing authorization checks on certain WebSocket operations, allowing unauthenticated attackers with network access to perform actions that should require an authenticated, authorized user.

Implement centralized, server-side authorization for every state-changing WebSocket operation. Bind each WebSocket connection to an authenticated session or token, and verify that the associated user has explicit permission for each requested action, especially tag writes and driver control.

Establish a consistent access control architecture where all sensitive operations—HTTP or WebSocket—pass through standardized authentication and authorization layers, enforce least privilege role design, restrict network exposure of ICS interfaces, and include access control checks as part of regular code reviews, security testing, and CI/CD policy enforcement.

Find out what's already
exploitable in your codebase.