Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessPlace archive with crafted name in watched directory
-
ExploitDecompress executor renders name into shell command string
-
Executionshelljs exec() evaluates $() / metacharacters
-
ImpactExecute arbitrary commands as Runnerty 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 the attacker to control the file NAME of an archive that the decompress executor processes - specifically a name containing $() command substitution or unquoted shell metacharacters passed to compress_file, which reaches shelljs exec() via the vulnerable render() template. The deployment must be running @runnerty/executor-decompress at or below 3.1.1 and must route attacker-nameable files (e.g. from a watched/ingested directory or upload workflow) into the decompress task. Limiting factors: the attacker needs the ability to name files in the watched directory (reflected as PR:L), no user interaction is needed, and impact is bounded to the Runnerty process privilege level; if files only arrive via trusted local processes the network attack vector does not realistically apply. |
| Impact | This is a genuine, actionable OS command injection (CWE-78) rather than an inflated high score, but its practicality hinges on one access precondition. The vendor CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H) rates it 8.7 (High) with full confidentiality, integrity and availability loss on the vulnerable system and no scope change. The source-code evidence strongly confirms the flaw: the vulnerable index.js builds shell command strings via a dynamic Function-based render() and runs them through shelljs exec(), so a filename containing $() or shell metacharacters executes with Runnerty process privileges; the fix (PR #7) replaces string templates with execFile() and explicit ARGS arrays, eliminating the shell. The PR:L rating is the key limiter - the attacker must be able to control the NAME of a file placed into a directory the decompress executor processes, so this is not a drive-by remote exploit against an exposed service. No EPSS score, KEV listing, or public POC is present in the input, so there is no public exploit identified at time of analysis and no evidence of active exploitation; the discovery by VulnCheck and the merged patch indicate a credible, well-characterized issue. Note the AV:N rating depends on how files reach the watched directory (e.g. a network upload path); if files only arrive via local processes this is effectively local - verify the deployment's ingestion path. |
| Exploit ScenarioDerived | An application using @runnerty/executor-decompress (≤3.1.1) watches a directory and auto-decompresses uploaded archives. An attacker who can influence the uploaded file's name submits an archive named like |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 14, 2026
OS command injection in Runnerty's @runnerty/executor-decompress package (all versions through 3.1.1) lets an attacker who can control the name of an archive file processed by a compress_file/decompress task execute arbitrary shell commands with the privileges of the Runnerty process. The package builds shell command strings from templates that interpolate the archive filename and then hands them to shelljs exec(), so a filename containing $() command substitution or unquoted shell metacharacters - for example one dropped into a watched or ingested directory - is interpreted by the shell instead of being treated as a literal path. Exploitation requires low-privileged access sufficient to name files in that directory (PR:L) and no user interaction; impact to confidentiality, integrity, and availability is high but is bounded to the Runnerty process's privilege level, and no public exploit code or confirmed active exploitation was identified at time of analysis.
RemediationAI
The vendor fix is the code change in PR https://github.com/runnerty/executor-decompress/pull/7, which replaces the shell-string SCRIPT templates and shelljs exec() calls with argument-array ARGS definitions executed via child_process.execFile; because this is an upstream PR/commit rather than a tagged release, a released patched version cannot be independently confirmed, so consumers should upgrade to the first published version containing that merge (track the repository/release notes for the exact version) or apply the PR/commit to a pinned fork until a release is available. Do not attempt to patch by escaping filenames alone - the durable fix is eliminating the shell, as the upstream change does. If immediate upgrade is not possible, apply compensating controls with their trade-offs: restrict write and rename permissions on any watched/ingested directory so only trusted processes (not unauthenticated or low-privileged users) can choose filenames, since that is the precondition for exploitation and may break legitimate user-driven upload workflows; validate and normalize incoming filenames against a strict allowlist (e.g. reject $, (, ), `, ;, |, &, spaces and newlines before the file reaches the executor), accepting that some legitimate archive names will be refused; run the Runnerty process under a dedicated low-privilege OS account with no access to secrets or broader filesystem paths, which limits but does not eliminate the post-exploitation impact since commands still run as that account; and, if the executor is not required, remove or disable @runnerty/executor-decompress from the Runnerty installation, at the cost of losing automated decompression functionality. Monitoring for unexpected child processes spawned by Runnerty and reviewing the advisory link above for further vendor guidance is also advisable. Note that no public exploit code or confirmed in-the-wild exploitation is known at time of analysis, so prioritization should be based on whether attacker-nameable files reach this executor.
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 vulnerability is a classic OS command injection (CWE-78) rooted in unsafe string interpolation. In the affected code (see index.js lines 26 and 106 in the 1a625bb commit), each supported archive type (tar, tar.gz/tgz, zip, bzip2, rar, 7z, gzip) is implemented as a SCRIPT template string such as 'mkdir -p ${dir} && tar -C ${dir} ${verbose} -xvf "${fileName}"'. The executor's render() helper builds a JavaScript function via new Function and template literals to substitute fileName, dir, and basename into that string, and the resulting command is executed with shelljs exec(), which runs it through a shell. Because the filename is interpolated into a shell command line rather than passed as an argv element, characters like $(), backticks, semicolons, or pipes in the filename are evaluated by the shell. The upstream fix (PR #7) removes render() and shell.exec() entirely, replacing the SCRIPT strings with ARGS functions that return argument arrays and invoking child_process.execFile with the extracted base name, so filenames can never be interpreted as shell syntax. The CPE cpe:2.3:a:runnerty:@runnerty/executor-decompress:*:*:*:*:*:*:*:* reflects that the flaw is version-agnostic across all releases up to and including 3.1.1.
Know when Runnerty Executor Decompress 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:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Attacker needs the ability to supply a crafted filename to a watched directory (PR:L), no interaction (UI:N), and command execution yields full host impact with no scope change (C/I/A:H, S:U).
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
@runnerty/executor-decompress through 3.1.1 contains an OS command injection vulnerability that allows attackers to execute commands by supplying crafted archive file names to compress_file. Attackers who can name a file dropped into a watched directory can inject $() substitutions or unquoted shell metacharacters into shelljs exec() calls, running commands with Runnerty process privileges.
Executive ViewAI
Runnerty's @runnerty/executor-decompress package, all versions through 3.1.1, contains a high-severity OS command injection flaw that lets a low-privileged user with file-naming access to an ingested directory execute arbitrary commands under the Runnerty process account, potentially disrupting automation and exposing or altering data processed by that service. Because Runnerty may run within build, deployment, or operational pipelines, affected organizations should prioritize remediation even though no public exploit identified at time of analysis. A vendor patch is available.
Apply vendor patch.
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-101269
GHSA-2v4p-6p6r-gr94
NVD
CVE.org
EPSS
Exploit-DB