/

CVE-2026-23515

Severity:

CRITICAL RISK

(9.9)

OS Command Injection in Signal K Server set-system-time

CVE-2026-23515

Analyzed

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-78

Impact:

Remote Code Execution on Server Host

Severity:

CRITICAL RISK

(9.9)

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 command injection vulnerability in the Signal K Server set-system-time plugin allows crafted navigation.datetime values to be turned into unsafe shell commands on the host system.

Authenticated users with write permissions—and unauthenticated users when security is disabled—can exploit this to execute arbitrary commands on the Signal K server when the plugin is enabled.

Affected context

This vulnerability appears in Signal K Server deployments where:

  • The set-system-time plugin is installed and enabled, and
  • The server processes navigation.datetime updates received via WebSocket delta messages, and
  • Users (or devices) are granted write permissions to send such updates, or the instance is running with security disabled.

It typically affects installations on boats where Signal K Server manages or synchronizes system time and is connected to on-board networks or remote clients that can send Signal K delta messages.

Exploit preconditions

  • Attack surface: Signal K WebSocket interface (delta message handling for navigation.datetime).
  • Required access:
  • Authenticated access with write permissions to navigation data, or
  • Any network access, when Signal K security is disabled.
  • Trigger point: Sending a specially crafted WebSocket delta message containing a malicious navigation.datetime value while the set-system-time plugin is active.
  • Why exploitation is possible: The plugin builds shell commands by concatenating untrusted datetime values into command strings and invokes them on the host without adequate sanitization or proper API usage, enabling execution of attacker-controlled shell fragments.

Why this happens

The root cause is unsafe construction of operating system commands from untrusted input in the set-system-time plugin.

When navigation.datetime values are received via WebSocket delta messages, the plugin uses those values directly in a shell command string, relying on the shell to interpret and execute the command.

This pattern matches CWE-78: Improper Neutralization of Special Elements used in an OS Command, where input is embedded into a command line without strict validation, escaping, or the use of parameterized, non-shell-based APIs.

As a result, crafted values that include shell metacharacters or additional commands can break out of the intended command structure and run arbitrary code with the privileges of the Signal K Server process.

Potential impact

  • Execution of arbitrary commands on the Signal K host system.
  • Full compromise of the Signal K Server application and its configuration.
  • Lateral movement to other services and devices reachable from the compromised host.
  • Tampering with on-board navigation, time, and telemetry data, potentially impacting safety-critical systems that depend on accurate time.
  • Installation of persistent malware or backdoors on the vessel's central hub.
  • Exfiltration or destruction of stored logs and navigation records.

General mitigation guidance

Effective mitigation focuses on removing direct shell command composition from untrusted data paths and tightening access to time-setting functionality:

  • Replace shell-based time-setting calls with parameterized system APIs or libraries that accept structured time values instead of command strings.
  • If command-line tools must be used, invoke them without a shell (e.g., using exec-like APIs with argument arrays) and reject or strictly validate incoming datetime values against a rigid, whitelisted format.
  • Limit which components can update navigation.datetime by applying principle of least privilege to write permissions and plugin access.
  • Disable the set-system-time plugin where it is not strictly required, especially on Internet-exposed or shared networks.
  • Segregate the Signal K Server host using network segmentation and run the service with non-root, least-privilege accounts to narrow the blast radius if command execution occurs.

How teams detect issues like this

Detection of this class of issue and potential exploitation can be approached at multiple layers:

  • Static analysis and code review:
  • Search for patterns where untrusted input (e.g., WebSocket delta fields) are concatenated into strings passed to shell-executing functions.
  • Flag use of generic command execution APIs that invoke a shell (e.g., exec with string commands, child_process.exec, or similar) within plugin code handling navigation.datetime.
  • Enforce secure coding guidelines that prohibit string-based command construction from network-derived inputs.
  • Runtime and logging analysis:
  • Monitor application logs for unexpected or malformed navigation.datetime values or frequent time-change events.
  • Collect and inspect command execution logs, where available, for anomalous commands spawned by the Signal K Server process.
  • Configuration and policy checks:
  • Periodically audit enabled plugins, focusing on ones that call system utilities (e.g., time-setting tools).
  • Use automated configuration review tools or scripts to identify instances running with security disabled or overly permissive write access to navigation data.

Sources

SourceLink
github.comgithub.com/SignalK/set-system-time/commit/75b11eae2de528bf89ede3fb1f7ed057ddbb4d24
github.comgithub.com/SignalK/signalk-server/security/advisories/GHSA-p8gp-2w28-mhwg

Frequently asked

questions

Yes. Any client that can reach the Signal K Server WebSocket interface and send delta messages can potentially exploit this issue, provided it has write permissions or the server is configured with security disabled.

In secure configurations, exploitation generally requires an authenticated account with write permissions to send navigation.datetime updates.

However, if Signal K security is disabled, unauthenticated users with network access to the server can attempt to exploit the vulnerability.

The safest approach is to remove shell-based command construction entirely for time-setting and use structured system APIs or libraries that accept parsed datetime objects or discrete fields, never raw user-controlled strings.

Treat all network-derived data as untrusted, avoid passing it to shell interpreters, enforce strict input validation and whitelisting for fields like dates and times, and standardize on non-shell, parameterized system calls in plugin and extension development.

Find out what's already
exploitable in your codebase.