/

CVE-2026-53451

Severity:

CRITICAL RISK

(9.8)

Path Traversal (CWE-22) in Ground Station Snapshots

CVE-2026-53451

Deferred

Vulnerability type

Category:

Path Traversal and Arbitrary File Write

CWE:

CWE-22, CWE-73, CWE-94

Impact:

Arbitrary File Write, Code Execution, and Denial of Service

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

Ground Station versions before 0.4.13 contain an unauthenticated arbitrary file-write vulnerability in the snapshot-saving Socket.IO command. By controlling the snapshot name, an attacker may write data outside the intended snapshot directory and chain that access with logging configuration controls to achieve service-level code execution or cause persistent service disruption.

Affected context

The vulnerability occurs in deployments that expose the unauthenticated snapshot-saving and application-configuration operations. It becomes risky when attacker-controlled snapshot names are passed to filesystem path construction without restricting them to the intended storage directory, and when written files can later be selected as logging configuration during service restart. The affected behavior is present in Ground Station releases before 0.4.13.

Exploit preconditions

  • Attack surface: Unauthenticated Socket.IO commands and application configuration endpoints
  • Required access: Network access to the exposed Ground Station service; no prior authentication is required
  • Trigger point: Snapshot creation, application configuration update, and service restart
  • Why exploitation is possible: User-controlled path components can escape the snapshot directory, while the resulting file may be consumed as trusted logging configuration containing executable factory behavior

Why this happens

The primary flaw is path traversal caused by using attacker-controlled path input in filesystem path construction without canonicalization and confinement checks. This maps to CWE-22: Improper Limitation of a Pathname to a Restricted Directory, with related CWE-73: External Control of File Name or Path because an external input influences the destination path. The impact is amplified when a newly written file is later parsed as trusted configuration and passed to a callable factory, creating a code-execution path consistent with CWE-94: Improper Control of Generation of Code. The insecure pattern is trusting filenames and configuration sources across security boundaries without enforcing allowed locations, formats, or callable types.

Potential impact

  • An attacker may overwrite or create files outside the intended snapshot directory.
  • Malicious content could be loaded as application or logging configuration.
  • The service may execute attacker-controlled code with its available privileges.
  • Sensitive files may be corrupted or operational data may be poisoned.
  • The application could enter a persistent crash or restart loop.
  • The host or surrounding environment could be exposed to lateral movement, depending on service permissions.

General mitigation guidance

Mitigation generally focuses on enforcing a strict storage boundary and separating user-generated artifacts from executable or configuration content.

Common defensive patterns include:

  • Derive destination filenames from server-generated identifiers rather than client-provided paths.
  • Canonicalize candidate paths and verify that they remain beneath a dedicated, non-sensitive storage directory.
  • Reject absolute paths, traversal components, unexpected separators, and ambiguous encodings.
  • Apply strict size, format, and content validation to decoded snapshot data.
  • Prevent user-writable files from being accepted as logging or application configuration.
  • Use safe configuration parsing with an allowlist of supported fields and non-callable value types.
  • Restrict configuration changes and service-restart operations behind authentication and authorization.
  • Run the service with least privilege and isolate writable directories from executable code and sensitive files.
  • Use read-only mounts and filesystem policy controls where practical.

How teams detect issues like this

High-level detection can combine code analysis, runtime monitoring, and policy enforcement:

  • Use static analysis rules for os.path.join or equivalent path APIs fed by request, Socket.IO, or configuration values.
  • Review code for missing canonicalization, base-directory checks, and rejection of absolute or parent-directory components.
  • Flag writes of decoded, uploaded, or user-named data to locations that may be loaded as configuration.
  • Inspect uses of dynamic logging configuration, callable factories, and configuration reload or restart flows.
  • Monitor filesystem events for unexpected writes outside approved data directories.
  • Alert on unauthenticated configuration changes, restart requests, and service processes spawning unexpected child processes.
  • Enforce application policies requiring authentication for administrative operations and restricting writable paths.
  • Automated security review tools may help identify path-construction and unsafe configuration-loading patterns.

Sources

SourceLink
github.comgithub.com/sgoudelis/ground-station/commit/5649905f1021155933463a54a76030924adffb9d
github.comgithub.com/sgoudelis/ground-station/releases/tag/v0.4.13
github.comgithub.com/sgoudelis/ground-station/security/advisories/GHSA-q35x-w3h6-36w8

Frequently asked

questions

Yes, when the affected unauthenticated Socket.IO operations are reachable over the network. Exploitation does not inherently require a preexisting account.

The attacker needs network access to the Ground Station service and the ability to invoke the exposed snapshot, configuration, and restart operations. The exact scope depends on deployment exposure and any external access controls.

Constrain all generated file paths to a dedicated storage directory, use server-generated names, prevent user-writable files from becoming configuration, and restrict administrative operations with authentication and authorization.

Treat filenames and configuration locations as untrusted input, enforce canonical path and schema validation, prohibit dynamic callable configuration from untrusted sources, apply least privilege, and monitor filesystem and service-control activity.

Find out what's already
exploitable in your codebase.