/

CVE-2026-28286

Severity:

HIGH RISK

(8.5)

Path Manipulation / External Control of File Path

CVE-2026-28286

Analyzed

Vulnerability type

Category:

Path Manipulation / External Control of File Path

CWE:

CWE-73

Impact:

Unauthorized File and Directory Creation in Sensitive System Paths

Severity:

HIGH RISK

(8.5)

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

ZimaOS 1.5.2-beta3 exposes an API that allows clients to create files and folders in arbitrary system paths without proper server-side validation.

By bypassing frontend UI restrictions and calling the API directly with crafted paths like /etc or /usr, an attacker could create entries in sensitive system directories, enabling unauthorized configuration changes or system compromise.

Affected context

This vulnerability affects ZimaOS deployments (both Zima devices and x86-64 systems with UEFI) running version 1.5.2-beta3 where:

  • The web/API interface is exposed to users or services that can authenticate or otherwise invoke file-management endpoints.
  • Backend APIs accept client-supplied filesystem paths for file or directory creation.
  • Access control and path validation are enforced primarily in the frontend, with insufficient validation on the server side.

The issue is most critical on systems where the ZimaOS service runs with elevated privileges that allow writes into system directories such as /etc, /usr, or other internal OS paths.

Exploit preconditions

  • Attack surface: ZimaOS HTTP(S) API endpoints responsible for file and directory management.
  • Required access: Ability to send requests to the ZimaOS API (often via network or local access), with at least the level of authentication expected for normal users of the UI.
  • Trigger point: Invoking the file/directory creation API with a crafted filesystem path pointing to a sensitive directory (e.g., /etc, /usr, or other OS-managed locations).
  • Why exploitation is possible: The backend API trusts the path provided by the client and enforces path restrictions primarily in the frontend/UI; it lacks robust server-side validation and canonicalization to prevent writes outside intended application-controlled locations.

Why this happens

The underlying bug class is external control of file path, where user-controllable values are used directly as filesystem paths on the server.

In ZimaOS 1.5.2-beta3, the backend API responsible for creating files and directories accepts a target path parameter and relies on the UI to constrain where users can write.

Because the server does not independently enforce allowed base directories or normalize and validate paths, any client capable of calling the API can direct file creation into system-controlled areas.

This matches CWE-73, where the software permits external input to dictate file paths without applying strict, server-side controls, leading to unauthorized file operations in sensitive locations.

Potential impact

  • Creation of malicious configuration files under /etc that may influence system or service behavior.
  • Placement of files in executable or service directories that could be leveraged for privilege escalation or persistence, depending on system configuration.
  • Disruption of system services by overwriting or shadowing expected configuration or runtime directories.
  • Facilitation of other attacks (e.g., log poisoning, tricking maintenance scripts, or misconfiguring daemons) by introducing attacker-controlled files into trusted paths.
  • Degradation of system integrity and reliability by cluttering critical directories with unauthorized entries.

General mitigation guidance

Effective mitigation focuses on server-side path control and principle of least privilege:

  • Enforce path restrictions in the backend: restrict all file/directory creation APIs to a small set of predefined base directories owned by the application, rejecting any attempt to operate outside these roots.
  • Normalize and validate paths on the server by resolving relative components and symbolic links, then verifying that the resolved path stays within approved directories before performing filesystem operations.
  • Adopt an allowlist approach for file operations: instead of checking for disallowed locations, define specifically permitted storage areas and deny everything else.
  • Run the ZimaOS service under a dedicated, non-privileged account that does not have write access to core system directories, reducing impact even if path validation fails.
  • Separate configuration and application data paths from system directories, and use filesystem permissions and mount options (e.g., read-only for critical paths where feasible) to make unintended writes harder.
  • Treat UI restrictions as advisory only; ensure that all security checks and authorization decisions are implemented in the backend service.

How teams detect issues like this

Detection typically combines code-level analysis with runtime monitoring:

  • Static analysis and code review:
  • Search for filesystem APIs (e.g., file/directory creation functions) that accept or construct paths using request parameters or other untrusted input.
  • Verify that each such operation is preceded by robust server-side path validation and checks against allowed base directories.
  • Flag patterns where the backend relies on UI-side flags or front-end logic for access control or path constraints.
  • Policy and configuration checks:
  • Enforce coding standards requiring use of centralized helper functions for filesystem access that encapsulate path normalization and boundary checks.
  • Require design reviews for any feature that exposes generic file-management capabilities over network APIs.
  • Runtime logging and monitoring:
  • Log all write operations outside designated application directories and alert on attempts targeting system paths like /etc, /usr, /bin, or /lib.
  • Use host-based intrusion detection or audit frameworks to detect unusual file creations by the ZimaOS service account in protected locations.
  • Automated security scanning tools can help identify externally controlled path usage and missing validation during development and continuous integration.

Sources

SourceLink
github.comgithub.com/IceWhaleTech/ZimaOS/security/advisories/GHSA-65mg-9gw5-vr7g

Frequently asked

questions

It can be, if the ZimaOS API is reachable over the network and an attacker can authenticate or otherwise send crafted requests to the file-management endpoints. The vulnerability is triggered via API calls rather than the UI, so any remote access path to those endpoints is relevant.

Typically, a user needs the same or similar level of access that a normal ZimaOS UI user has, but instead of using the UI, they interact directly with the API. If the API is exposed without strict authentication or is shared among multiple tenants, the risk increases significantly.

Implement strict server-side path validation and confinement. All file and directory creation operations should resolve the requested path, ensure it resides under an approved application-controlled directory, and reject any request that targets or escapes toward system locations. This should be enforced in backend code, independent of client-side restrictions.

Treat all client-supplied paths as untrusted, avoid exposing generic filesystem primitives over APIs, and encapsulate file operations behind well-defined, validated abstractions. Combine this with least-privilege service accounts, secure defaults for storage locations, and automated checks in code review and CI pipelines to catch externally controlled path usage early.

Find out what's already
exploitable in your codebase.