GHSA-p8gp-2w28-mhwg
CRITICALSignal K set-system-time plugin vulnerable to RCE - Command Injection
EPSS Exploitation Probability
EPSS (Exploit Prediction Scoring System) is a daily probability model maintained by FIRST.org. It estimates the likelihood a CVE will be exploited in production environments within the next 30 days, derived from real-world threat intelligence signals.
Blast Radius
Weekly download volume for affected packages — a proxy for how broadly this vulnerability is deployed.
@signalk/set-system-timenpmDescription
Summary
A Command Injection vulnerability allows authenticated users with write permissions to execute arbitrary shell commands on the Signal K server when the set-system-time plugin is enabled. Unauthenticated users can also exploit this vulnerability if security is disabled on the Signal K server. This occurs due to unsafe construction of shell commands when processing navigation.datetime values received via WebSocket delta messages.
Details
Product: Signal K set-system-time plugin
Repository: https://github.com/SignalK/set-system-time
File: index.js, lines 60-71
stream.onValue(function (datetime) {
var child
if (process.platform == 'win32') {
console.error("Set-system-time supports only linux-like os's")
} else {
if( ! plugin.useNetworkTime(options) ){
const useSudo = typeof options.sudo === 'undefined' || options.sudo
const setDate = `date --iso-8601 -u -s "${datetime}"` // ← VULNERABLE
const command = useSudo
? `if sudo -n date &> /dev/null ; then sudo ${setDate} ; else exit 3 ; fi`
: setDate
child = require('child_process').spawn('sh', ['-c', command]) // ← EXECUTES SHELL
The vulnerability has three components:
- Unsanitized Input: The
datetimevalue fromnavigation.datetimeSignal K path is directly interpolated into a shell command without validation - Shell Execution: The command is executed via
spawn('sh', ['-c', command]), which interprets shell metacharacters - Sudo Privileges: The plugin can execute with root privileges if
sudois misconfigured, instructions to limit passwordless sudo to the /bin/date binary helps mitigate this but RCE can still be achieved with the privileges of the user that installed it.
PoC
Exploitation Requirements
- Signal K server with security enabled, if disabled credentials not required
- Valid user credentials with
readwriteoradminpermissions - set-system-time plugin installed and enabled
- Signal K server installed on a Linux OS
- Passwordless sudo configured, official instructions will do this for the
datecommand which is enough to satisfy the if condition
"""
Run provided POC:
python3 poc.py --host signalkserver_IP -u username -p password
Payload: Creates /tmp/signalk-RCE.txt to prove code execution
"""
Impact
An attacker that has write privileges either through security on the Signal K server being disabled or valid credentials with read/write permissions can execute arbitrary commands on the server with the privileges of the SignalK process or root if sudo is misconfigured. This enables complete system compromise.
Recommendations
-
Replace shell-based execution with child_process.execFile() so user-controlled input is passed as arguments rather than interpreted by a shell.
-
Validate that navigation.datetime conforms to an expected ISO-8601 format to improve robustness.
Affected Packages
| Ecosystem | Package | Vulnerable range | Fix |
|---|---|---|---|
| 📦npm | @signalk/set-system-time | all versions | 1.5.0 |
Detection & mitigation playbook
Open-source dependencyDetect
Scan your dependency tree (package-lock.json, pnpm-lock.yaml, requirements.txt, go.sum, etc.) for @signalk/set-system-time. O3's reachability analysis confirms whether the vulnerable code path is actually invoked in your application, so you act on real exposure instead of every transitive match.
Fix
Update @signalk/set-system-time to 1.5.0 or later, then make sure no transitive (indirect) dependency still pins the vulnerable range — O3 confirms GHSA-p8gp-2w28-mhwg is resolved across your whole dependency graph.
Workarounds
If you can't upgrade right away: gate or disable the affected feature, validate untrusted input at the boundary, and avoid passing attacker-controlled data into the vulnerable path. O3's runtime protection blocks exploitation in production as an interim safeguard until the upgrade lands.
How O3 protects you
O3 pinpoints whether GHSA-p8gp-2w28-mhwg is reachable in your code and exactly where to fix it, then blocks exploitation in production at runtime until the patched version is deployed.
Tailored to GHSA-p8gp-2w28-mhwg. Runtime protection reduces exposure until a permanent patch is applied and verified — it complements patching, it doesn't replace it.
Frequently Asked Questions
Is GHSA-p8gp-2w28-mhwg in your dependencies?
O3 detects GHSA-p8gp-2w28-mhwg across npm dependencies and uses function-level reachability to confirm whether the vulnerable code path is actually reachable — not just present. No false positives.