/

CVE-2026-25895

Severity:

CRITICAL RISK

(9.8)

Path Traversal File Write in FUXA SCADA/HMI Server

CVE-2026-25895

Analyzed

Vulnerability type

Category:

Path Traversal / Arbitrary File Write

CWE:

CWE-22, CWE-306

Impact:

Arbitrary File Write leading to potential Remote Code Execution and system compromise

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

A path traversal flaw in FUXA, a web-based SCADA/HMI/dashboard platform, permits remote, unauthenticated attackers to write arbitrary files to arbitrary locations on the server filesystem.

When exposed over a network, this can turn routine HTTP requests into a powerful file-system primitive that risks full server compromise, configuration tampering, or disruption of industrial visualization and control workflows.

Affected context

The vulnerability affects FUXA deployments up to and including version 1.2.9 where the server exposes HTTP endpoints that handle file paths derived from client-supplied data.

It is relevant in environments where:

  • The FUXA web interface is reachable over a network (LAN, VPN, or internet).
  • The process has write access to sensitive directories (e.g., application folders, configuration directories, or system paths).
  • Path normalization and access control around file write operations are incomplete or missing.

Actual exploitability depends on OS-level permissions, deployment topology, and how FUXA is integrated with other services and automation components.

Exploit preconditions

  • Attack surface: Network-accessible FUXA HTTP interface.
  • Required access: None; the issue is exploitable without authentication according to the description.
  • Trigger point: An API or web endpoint that accepts user-controlled file paths or filenames and performs write operations on the host filesystem.
  • Why exploitation is possible:
  • The server trusts user-supplied path segments without sufficient sanitization or canonicalization.
  • Directory traversal tokens (such as parent-directory references) are not properly removed or constrained to an allowed base directory.
  • Authorization checks (CWE-306) do not gate access to potentially dangerous file write functionality, allowing unauthenticated use.

Why this happens

The core issue maps to CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal').

FUXA accepts file paths or names influenced by client input and uses them directly—or after insufficient validation—to construct filesystem paths for write operations.

Without strict enforcement of a safe base directory and robust normalization, attackers can inject traversal sequences to escape the intended storage area and target arbitrary locations.

The mention of CWE-306: Missing Authentication for Critical Function indicates that these file write capabilities are either exposed without authentication or insufficiently protected, turning what might have been a limited administrative feature into a powerful, unauthenticated primitive.

Potential impact

  • Creation or overwriting of application files that could enable remote code execution, depending on deployment and file types.
  • Tampering with SCADA/HMI project files, dashboards, and configuration data, potentially misleading operators or hiding process anomalies.
  • Disruption of service through corruption of critical configuration or application data, leading to denial of service.
  • Plant or process safety risks if altered HMI views or logic cause operators to misinterpret system state.
  • Plant network foothold for lateral movement by planting scripts, web shells, or backdoors where the server will execute them.

General mitigation guidance

Mitigation focuses on constraining file operations and hardening access control around them:

  • Enforce strict base directories:
  • Resolve and canonicalize all user-influenced paths.
  • Verify that the resulting absolute path stays within a predefined, application-owned directory.
  • Normalize and validate input paths:
  • Reject or sanitize path traversal markers (e.g., parent-directory segments) and absolute paths.
  • Use whitelist-based validation (allowed directories, file extensions, or resource identifiers) rather than blacklists.
  • Require strong authentication and authorization:
  • Treat file write endpoints as administrative functions.
  • Enforce authentication and role-based access to any API that can create or modify files.
  • Apply least privilege at the OS level:
  • Run the FUXA service under a dedicated account with minimal filesystem permissions, limited to directories it truly needs.
  • Restrict execute permissions in writable locations to reduce code execution risk.
  • Reduce exposure:
  • Limit external network access to the FUXA interface via VPNs, firewalls, or application gateways to narrow the attack surface.

How teams detect issues like this

Several complementary approaches can help discover and monitor this class of issue:

  • Static analysis and code review:
  • Search for file write APIs (e.g., fs.writeFile, open + write, createWriteStream) where paths are derived from request parameters, body fields, or query strings.
  • Flag patterns where input is concatenated into filesystem paths without canonicalization or base-directory checks.
  • Review routes or controllers handling file uploads, exports, backups, or project saves to ensure they enforce authentication and directory constraints.
  • Security testing and fuzzing:
  • Use web security scanners or custom scripts to inject traversal sequences in path-related parameters and monitor whether files can be created outside expected directories.
  • Perform authenticated and unauthenticated tests to confirm which endpoints expose file operations.
  • Runtime monitoring and logging:
  • Enable detailed logging of file write operations originating from the FUXA process, especially writes outside the intended data directories.
  • Set alerts for unusual file creations in configuration, executable, or webroot directories.
  • Policy and CI/CD enforcement:
  • Integrate secure coding checks and static analysis into CI pipelines so new file-handling code is automatically reviewed for path traversal patterns.
  • Use automated code review tools to enforce that any critical file operation must include path normalization and an authorization check.

Sources

SourceLink
github.comgithub.com/frangoteam/FUXA/commit/22c2192f5d9beef8a787c45eff3a14c24dbb5f96
github.comgithub.com/frangoteam/FUXA/releases/tag/v1.2.10
github.comgithub.com/frangoteam/FUXA/security/advisories/GHSA-88qh-cphv-996c

Frequently asked

questions

Yes. The description indicates that an unauthenticated, remote attacker can trigger the path traversal, so any network-accessible FUXA instance up to version 1.2.9 may be exposed.

No. This specific issue is described as unauthenticated, meaning that exploitation does not require prior login or user account access, as long as the attacker can reach the vulnerable endpoints.

Implement strict path canonicalization and base-directory enforcement for all file operations, reject traversal sequences outright, and ensure that any endpoint capable of writing files is gated by robust authentication and authorization. Combine this with least-privilege filesystem permissions to minimize damage if a flaw is missed.

Treat all path elements from clients as untrusted, design APIs around logical identifiers instead of raw filesystem paths, centralize file access routines that enforce security checks, require code review for any new file I/O, and continuously run static analysis and security testing focused on path traversal and arbitrary file write patterns.

Find out what's already
exploitable in your codebase.