Description

Ground Station is a browser-based suite for satellite tracking, SDR reception, hardware control, and telemetry decoding. Prior to version 0.4.13, the unauthenticated save-waterfall-snapshot Socket.IO command passes attacker-controlled snapshotName input from backend/handlers/entities/sdr.py to backend/server/snapshots.py, where os.path.join permits an absolute path or parent-directory traversal and writes attacker-controlled base64-decoded bytes outside backend/data/snapshots. An attacker can write a logging YAML file containing a logging.config.dictConfig callable factory, use the unauthenticated update-app-config operation to set log_config to that file, and invoke restart_service. During restart, backend/common/logger.py passes the YAML through resolve_log_config_path(), yaml.safe_load(), and logging.config.dictConfig(), which executes the factory with service privileges and can also cause a persistent crash loop. This issue is fixed in version 0.4.13.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "9.8",
  "pubDate": "2026-08-19T15:17:10.120Z",
  "pubdate": "2026-08-19T15:17:10.120Z",
  "executiveSummary": "A critical security vulnerability exists in the Ground Station browser-based suite prior to version 0.4.13, enabling unauthenticated remote code execution and persistent denial of service. The vulnerability stems from an insecure file write mechanism within the Socket.IO command handler combined with insecure configuration loading and service management functions. Specifically, the unauthenticated save-waterfall-snapshot command permits path traversal via attacker-controlled input, allowing files to be written outside the intended data directory. An unauthenticated attacker can exploit this flaw to write a malicious logging configuration YAML file containing a Python callable factory, update the application configuration to reference this file via the update-app-config operation, and trigger a service restart using the restart_service command. Upon restart, the application processes the crafted YAML file via logging.config.dictConfig(), resulting in arbitrary code execution with the privileges of the running service. This flaw poses a severe risk to satellite tracking, software-defined radio (SDR) reception, and hardware control infrastructures, allowing complete system compromise by unauthenticated network-adjacent or remote actors without prerequisite privileges.",
  "technicalDetails": "The vulnerability involves multiple chained components within the Ground Station backend prior to version 0.4.13. The primary entry point is an unauthenticated Socket.IO command handler for saving waterfall snapshots located in backend/handlers/entities/sdr.py. This handler passes an attacker-controlled snapshotName parameter to backend/server/snapshots.py. Within snapshots.py, the use of os.path.join fails to properly sanitize the input, permitting absolute paths or parent-directory traversal sequences such as dot-dot-slash. As a result, the application writes base64-decoded bytes provided by the attacker to arbitrary locations outside the designated backend/data/snapshots directory.\nThe exploitation chain leverages this arbitrary file write capability to achieve remote code execution through the application's logging configuration subsystem. An attacker crafts a payload consisting of a logging YAML file that incorporates a logging.config.dictConfig callable factory. Using the unauthenticated update-app-config operation, the attacker modifies the application configuration to point the log_config setting to the newly written malicious YAML file. Subsequently, the attacker invokes the restart_service operation.\nDuring the service restart sequence, the module backend/common/logger.py handles the configuration loading process. It passes the attacker-controlled YAML file through resolve_log_config_path(), performs yaml.safe_load(), and finally invokes logging.config.dictConfig(). This execution path causes the embedded callable factory to execute within the context of the running service, granting the attacker code execution capabilities with the underlying service privileges. Furthermore, an improperly formatted or malicious YAML structure can cause a persistent crash loop, inducing a denial of service state. The vulnerability requires no authentication or special privileges, exposing the application to unauthenticated remote exploitation over the network wherever the Socket.IO interface is reachable."
}