Skip to main content

systeminformation CVE-2025-68154

HIGH
OS Command Injection (CWE-78)
2025-12-16 security-advisories@github.com
8.1
CVSS 3.1 · Vendor: github
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Identify Windows Node.js app exposing fsSize() drive input
  2. Delivery
    Craft drive value with PowerShell metacharacters
  3. Exploit
    Submit via API request
  4. Execution
    Unsanitized concatenation into Get-WmiObject command
  5. Persist
    PowerShell executes injected command in Node process
  6. Impact
    Arbitrary command execution on host

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization OS command sanitization, avoid shell exec
MITRE ATT&CK

2 techniques across 1 tactic: Execution

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Two concrete preconditions must both hold: (1) the Node.js process runs on Windows (win32) - the vulnerable branch uses PowerShell Get-WmiObject Win32_logicaldisk and does not exist on Linux/macOS/BSD; and (2) the host application passes attacker-controlled input into the optional drive parameter of si.fsSize(), for example a web/API endpoint that reports disk info for a user-named volume. What limits exploitation: applications that call fsSize() with no argument or with a hardcoded/internal drive value are NOT vulnerable, and non-Windows deployments are NOT vulnerable. No authentication is required at the library level (PR:N), but the dependency on application data flow is precisely why CVSS assigns AC:H.

Impact

Signals conflict on how easily this is exploited. The CVSS base score is 8.1 (High) with AV:N/PR:N/UI:N, but the decisive metric is AC:H - and the GHSA advisory is explicit that AC:H reflects the hard precondition: the host application must plumb attacker-controlled input into the optional drive argument of fsSize(), AND the process must be running on Windows. The vulnerability is inert on Linux/macOS/BSD and inert on any app that passes a fixed/internal drive value (the overwhelmingly common usage). So the 8.1 overstates typical real-world exposure: it is a genuine code-level command-injection flaw but a conditional, deployment-dependent one rather than a blanket remote-unauth RCE. Exploitation status is 'publicly available exploit code exists' (the GHSA advisory ships a PoC) - but there is NO CISA KEV listing and NO EPSS score in the provided data, so there is no evidence of active exploitation; treat PoC availability and active exploitation as distinct signals. No SSVC decision data was provided. Priority is real for the narrow population of Windows Node.js services that expose disk/filesystem lookups with user-supplied drive names; for everyone else this is a low-urgency dependency-hygiene update.

Exploit ScenarioDerived

A Node.js web app running on Windows exposes an API that reports disk usage and passes a user-supplied drive/volume name straight into si.fsSize(drive). An unauthenticated attacker submits a drive value containing PowerShell metacharacters (e.g. terminating the Get-WmiObject pipeline and appending their own command), which is concatenated unsanitized and executed by powerShell() in the Node.js process context, yielding arbitrary command execution. A public PoC exists in the GHSA advisory, but the attack only works where the application actually forwards user input to this parameter on a Windows host.

This Week Schedule remediation this week. Why: HIGH severity + EPSS > 10%.
Patch available 13.0% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Sep 30, 2026

OS command injection in the systeminformation Node.js library on Windows allows arbitrary PowerShell command execution when attacker-controlled input reaches the optional drive parameter of the fsSize() function. Versions prior to 5.27.14 are affected, but exploitability is conditional: the Node.js process must be running on Windows (win32) and the host application must actually forward user-supplied drive or volume values into fsSize() - applications that call the function with no argument or with hardcoded values, and all non-Windows deployments, are not vulnerable. Publicly available exploit code exists (published alongside advisory GHSA-wphj-fx3q-84ch), though no confirmed active exploitation (CISA KEV) has been reported at time of analysis; the CVSS base score is 8.1 with AC:H precisely because the attack hinges on application data flow rather than a trivially reachable endpoint. Unauthenticated at the library level (PR:N), remote delivery is possible when the vulnerable function is reachable through a web or API surface.

RemediationAI

Upgrade the systeminformation dependency to version 5.27.14 or later, which the vendor states fixes the issue by adding parameter checking (see https://github.com/sebhildebrandt/systeminformation/security/advisories/GHSA-wphj-fx3q-84ch and the patch commit https://github.com/sebhildebrandt/systeminformation/commit/c52f9fd07fef42d2d8e8c66f75b42178da701c68). If an immediate upgrade is not feasible, the most effective compensating control is to stop passing untrusted data into fsSize(): call it with no argument (or with a hardcoded internal drive value) and filter/annotate results in your own code, which fully removes the injection primitive at the cost of losing the server-side drive filter. If the parameter must be exposed, strictly allowlist the input before the call - accept only a single drive letter pattern such as /^[A-Za-z]:\\?$/ or an exact match against the set of volume captions previously enumerated on the host - and reject anything containing shell metacharacters (;, &, |, $, backticks, quotes, newlines); the trade-off is that legitimate user-supplied volume labels with unusual characters will be refused. Because the vulnerable branch is Windows-only, running the affected service on Linux or macOS eliminates the exposure entirely, and wrapping or forking the package to apply util.sanitizeShellString() to the drive parameter is a viable stopgap. Regardless of the route chosen, treat any host running the pre-5.27.14 library on Windows with user-influenced drive input as potentially compromised and review process execution logs for unexpected PowerShell child processes.

Affected Packages

npm systeminformation fix: 5.27.14

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in npm

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

The systeminformation package (CPE cpe:2.3:a:systeminformation:systeminformation:*:*:*:*:*:node.js:*:*) is a widely used Node.js System and OS information library that shells out to native OS utilities. The vulnerable Windows branch of lib/filesystem.js (~line 197) builds a PowerShell command with Get-WmiObject Win32_logicaldisk | select Access,Caption,FileSystem,FreeSpace,Size, and whenever the optional drive argument is supplied it appends | where -property Caption -eq + drive via string concatenation before calling util.powerShell(), which ultimately uses child_process.exec. Because the value is interpolated directly into the shell command without neutralization, characters such as ;, &, |, $, and backticks are interpreted by PowerShell, giving a textbook CWE-78 OS Command Injection root cause class. This is inconsistent with the rest of the codebase, where sibling functions such as services(), processLoad(), networkStats(), and dockerContainerStats() all pass their user-influenced parameters through util.sanitizeShellString() (lib/util.js), which strips shell metacharacters; fsSize() omitted that call. The assessed vector CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H reflects that no authentication is required at the library level and impact on confidentiality, integrity, and availability is high (full command execution in the Node.js process context), while AC:H captures the hard prerequisite that the embedding application must route attacker-controlled input into the drive parameter. The patch applies parameter checking and was released in version 5.27.14.

Know when Systeminformation gets its next vulnerability

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (github) PRIMARY 8.1 HIGH
AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 8.1 HIGH

AC:H because exploitation requires the app to route user input to fsSize() on Windows; AV:N/PR:N since no auth is needed at library level; full C/I/A from arbitrary command execution in the Node process.

3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H
4.0 AV:N/AC:H/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Red Hat 8.1 HIGH

Primary rating from Vendor (github).

CVSS VectorVendor: github

Attack Vector
Network
Attack Complexity
High
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

DescriptionCVE.org

systeminformation is a System and OS information library for node.js. In versions prior to 5.27.14, the fsSize() function in systeminformation is vulnerable to OS command injection on Windows systems. The optional drive parameter is directly concatenated into a PowerShell command without sanitization, allowing arbitrary command execution when user-controlled input reaches this function. The actual exploitability depends on how applications use this function. If an application does not pass user-controlled input to fsSize(), it is not vulnerable. Version 5.27.14 contains a patch.

Executive ViewAI

Why It Matters

The systeminformation Node.js library, used widely for system and disk monitoring, is affected by an OS command injection flaw in versions prior to 5.27.14 that can allow arbitrary PowerShell command execution on Windows hosts when an application forwards user-controlled drive or volume values into the fsSize() function. Exposure is conditional and affects only Windows deployments with that specific data flow, but where it applies an attacker gains code execution under the hosting application's identity, which may be a privileged service account. Leadership should care because this library is frequently pulled in transitively by monitoring, management, and internal tooling, so affected services may not appear in a direct dependency review.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
13.0%
Top 4% exploitable
Prevalence
High
systeminformation is a hugely popular Node.js npm library, tens of millions of weekly downloads
Exploit
POC
Public exploit code exists
Data Quality
3 sources
Confidence: Low

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity HIGH
CISA KEV No
Public POC Yes
EPSS 13.0%
Patch available Yes
Active threat Yes
Deciding rule
HIGH severity + EPSS > 10%
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
Poc
System Exposure· derived
Open
Automatable· derived
No
Human Impact
High

Priority Score

73
Low Medium High Critical
KEV: 0
EPSS: +13
CVSS: +40
PoC: +20
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

OS command injection occurs when an application passes unsanitized user input directly into system shell commands.

Affected Products (CPE)CVE.org

cpe:2.3:a:systeminformation:systeminformation:*:*:*:*:*:node.js:*:*

Vendor StatusVendor

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy