Skip to main content

CliInvoke.Specializations CVE-2026-100368

| EUVDEUVD-2026-87320 HIGH
OS Command Injection (CWE-78)
2026-09-25 GitHub_M GHSA-wrvw-254r-wpmv
8.4
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Supply crafted string with double quote
  2. Delivery
    Reaches PowerShell/Cmd wrapper
  3. Exploit
    Breaks OS-level argument quoting
  4. Execution
    Shell executes injected command
  5. Impact
    Arbitrary code with host privileges

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 an application that (1) depends on a vulnerable version of CliInvoke.Specializations (2.2.0-2.8.4, 2.9.0-2.9.3, 2.10.0-2.10.4, 3.0.0-alpha.1-alpha.4, 3.0.0-alpha.8-alpha.10, or AlastairLundy.CliInvoke.Specializations 1.0.0-rc.1-1.6.1.1), (2) uses specifically the PowerShell (pwsh -Command) or Cmd (cmd /c) specialized wrappers rather than direct process invocation, and (3) passes attacker-influenced data as the target path or arguments. The concrete injection primitive is a double quote in untrusted input that breaks OS-level quoting of the single ProcessStartInfo.Arguments string. Limiting factors: the flaw is a library dependency (AV:L), so it is only reachable if untrusted input flows into these wrappers; no complete workaround exists, but rejecting/removing double quotes (plus shell metacharacters in versions 2.2.0-2.9.2 and 3.0.0-alpha.1-alpha.4) or bypassing the wrappers mitigates it.

Impact

This is a CWE-78 OS command injection in the PowerShell/Cmd wrapper classes of the CliInvoke.Specializations .NET library, rated CVSS 8.4 by the reporter (GitHub_M) with vector AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H. The AV:L (local) axis is the key nuance: the flaw lives inside a library, so 'exploitation' means untrusted data reaching an application that uses the vulnerable wrapper - the real attack vector inherits the consuming app's exposure, which could effectively be network-facing if the host app passes remote input to pwsh -Command or cmd /c. The technical impact is genuinely high (arbitrary command execution with the host process's privileges → full C/I/A), which justifies the elevated score. However, tempering signals: no EPSS score, no CISA KEV listing, and no public exploit code are present in the input - no public exploit identified at time of analysis. There is no evidence of active exploitation, and exploitability is entirely contingent on a downstream application both using these wrappers AND feeding them attacker-controllable strings containing a double quote. This is a real, patch-worthy defect for anyone shipping this dependency, but its aggregate real-world risk is bounded by the library's niche footprint and the dependency on how consumers wire untrusted input, rather than being a broadly automatable internet-facing threat.

Exploit ScenarioDerived

An application built on CliInvoke.Specializations passes a user-supplied file path or argument (e.g. from a web form or CLI parameter) into the PowerShell or Cmd wrapper. The attacker includes a double quote to break OS-level quoting - for example a path like foo" & malicious-command &" - causing the shell to run an additional attacker-chosen command with the host process's privileges. No public exploit code is identified, but the technique is straightforward given the disclosed root cause (single ProcessStartInfo.Arguments string).

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

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

Alert me

AnalysisAIv1 – Sep 25, 2026

OS command injection in the PowerShell and Cmd wrapper classes of the CliInvoke.Specializations .NET library (and its predecessor package AlastairLundy.CliInvoke.Specializations) lets a double quote embedded in caller-controlled target paths or arguments break OS-level quoting of the single ProcessStartInfo.Arguments string, causing pwsh -Command or cmd /c to execute an additional command with the host process's privileges. Affected builds are CliInvoke.Specializations 2.2.0 through 2.8.4, 2.9.0 through 2.9.3, 2.10.0 through 2.10.4, and 3.0.0-alpha.1 through alpha.4 plus 3.0.0-alpha.8 through alpha.10, as well as AlastairLundy.CliInvoke.Specializations 1.0.0-rc.1 through 1.6.1.1; an application is only reachable if it consumes one of these vulnerable versions, uses the specialized shell wrappers rather than direct process invocation, and routes attacker-influenced data into the target or arguments. Rated CVSS 8.4 (AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) by reporter GitHub_M; no public exploit identified at time of analysis and the issue is not listed in CISA KEV.

RemediationAI

Vendor-released patches: upgrade CliInvoke.Specializations to 2.8.5, 2.9.4, 2.10.5, or 3.0.0-beta.1 (depending on the release line you track), or upgrade AlastairLundy.CliInvoke.Specializations to 2.0.2 - see the GitHub security advisory GHSA-wrvw-254r-wpmv at https://github.com/alastairlundy/CliInvoke/security/advisories/GHSA-wrvw-254r-wpmv for the full fix matrix. There is no complete workaround, so patching is strongly preferred; where an upgrade is blocked, the following compensating controls reduce but do not eliminate exposure: reject or strip double-quote characters from any target path or argument before it reaches the wrappers (this alone closes the injection primitive in patched-behavior terms), and for the versions that are additionally sensitive to shell metacharacters - CliInvoke.Specializations 2.2.0 through 2.9.2 and 3.0.0-alpha.1 through 3.0.0-alpha.4 - also reject shell metacharacters (for example &, |, ;, <, >, ^, %). The most robust application-side mitigation with no input-path ambiguity is to bypass the PowerShell and Cmd specialized wrappers entirely and invoke target processes directly (for example via ProcessStartInfo.ArgumentList or equivalent argument-vector APIs) whenever untrusted input is involved; the trade-off is additional code changes and re-validation of any behavior that depended on shell features such as built-in cmdlets, environment expansion, or piping. Note that input filtering must be applied consistently at every call site, since a single unfiltered path or argument is sufficient to reintroduce the flaw.

Affected VersionsENISA

CliInvoke.Specializations 1.0.0-rc.1, ≤ 1.6.1.1
CliInvoke.Specializations 2.9.0, ≤ 2.9.3
CliInvoke.Specializations 3.0.0-alpha.8, ≤ 3.0.0-alpha.10
CliInvoke.Specializations 2.2.0, ≤ 2.8.4
CliInvoke.Specializations 3.0.0-alpha.1, ≤ 3.0.0-alpha.4
CliInvoke.Specializations 2.10.0, ≤ 2.10.4

Affected Packages

nuget alastairlundy.cliinvoke.specializations fix: 2.0.2
nuget cliinvoke.specializations fix: 2.8.5, 2.9.4, 2.10.5, 3.0.0-beta.1
euvd cliinvoke_specializations_1_0_0_rc_1 no fix
euvd cliinvoke_specializations_3_0_0_alpha_1 no fix
euvd cliinvoke_specializations_3_0_0_alpha_8 no fix

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 5 packages in nuget, 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 command-injection class arising here from string-concatenation of shell commands rather than argument-vector separation. CliInvoke is a .NET library for invoking command-line programs, and its CliInvoke.Specializations companion packages provide convenience wrappers around shells - specifically pwsh -Command for PowerShell and cmd /c for Windows Command Prompt. Instead of using ProcessStartInfo.ArgumentList (which preserves discrete argument boundaries and lets the .NET runtime perform correct OS-level escaping), the vulnerable wrappers build a single ProcessStartInfo.Arguments string that concatenates the caller-supplied target and arguments. Because the shell re-parses that string, a double quote in untrusted input terminates the intended quoted region and allows an attacker to append an additional command that runs with the privileges of the hosting process. The CPE reference (cpe:2.3:a:alastairlundy:cliinvoke.specializations) confirms the affected vendor/product namespace, and the library nature of the defect is reflected in the CVSS AV:L metric - exploitation requires a vulnerable consuming application in which untrusted data reaches these wrappers, not a directly network-reachable service. The condition for a successful injection is narrow and concrete: a double quote in the target path or an argument; in versions 2.2.0 through 2.9.2 and 3.0.0-alpha.1 through 3.0.0-alpha.4, other shell metacharacters are also sufficient.

Know when Cliinvoke Specializations 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 (GitHub_M) PRIMARY 8.4 HIGH
AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 8.4 HIGH

Library-level flaw so AV:L; injection needs only a double quote in untrusted input (AC:L, PR:N, UI:N); arbitrary command execution at host privilege yields C:H/I:H/A:H, no scope change.

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Local
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

DescriptionCVE.org

CliInvoke is a .NET library for invoking command-line programs, and its CliInvoke.Specializations packages provide specialized wrappers for shells such as PowerShell and Windows Command Prompt. CliInvoke.Specializations versions 2.2.0 through 2.8.4, 2.9.0 through 2.9.3, 2.10.0 through 2.10.4, 3.0.0-alpha.1 through 3.0.0-alpha.4, and 3.0.0-alpha.8 through 3.0.0-alpha.10, as well as AlastairLundy.CliInvoke.Specializations versions 1.0.0-rc.1 through 1.6.1.1, contain an OS command injection vulnerability in their PowerShell and Cmd wrappers. The wrappers pass a caller-controlled target and arguments to pwsh -Command or cmd /c using a single ProcessStartInfo.Arguments string, allowing a double quote in untrusted input to break operating-system-level quoting and cause the shell to execute an additional command with the host process's privileges. The vulnerability is patched in CliInvoke.Specializations versions 2.8.5, 2.9.4, 2.10.5, and 3.0.0-beta.1, and in AlastairLundy.CliInvoke.Specializations version 2.0.2. No complete workaround is available; users unable to upgrade should reject or remove double quotes from target paths and arguments, additionally reject shell metacharacters in versions 2.2.0 through 2.9.2 and 3.0.0-alpha.1 through 3.0.0-alpha.4, or bypass the PowerShell and Cmd wrappers and invoke target processes directly when handling untrusted input.

Technical POC Analysis

CWE-78 (Improper Neutralization of Special Elements used in an OS Command).

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Latest POC

1 public PoC link from github

Sign in to open the public PoC links collected for this CVE.

Executive ViewAI

Why It Matters

The CliInvoke.Specializations .NET library and its predecessor package, AlastairLundy.CliInvoke.Specializations, contain an OS command injection flaw in their PowerShell and Cmd wrappers that can let an attacker execute commands with the hosting application's privileges when attacker-influenced paths or arguments reach those wrappers. Applications using affected versions and routing untrusted data into these specialized shell wrappers are exposed, creating potential confidentiality, integrity, and availability risk for the business processes they support. Leadership should care because a successful exploit could compromise the host process and any downstream systems or data it can reach, while no public exploit identified at time of analysis.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations include avoiding vulnerable PowerShell and Cmd wrapper classes, replacing them with direct ProcessStartInfo or vetted invocation methods, strictly validating, escaping, or sanitizing caller-controlled target paths and arguments (especially double quotes), using allowlists, running host processes with least privilege, restricting local access to affected applications, and monitoring for unexpected pwsh -Command or cmd /c execution.

Threat Intelligence Overview

EPSS Score
0.6%
Top 54% exploitable
Prevalence
Low
niche independent open-source .NET process-invocation library, limited production footprint
Threat Intel
1
1 source
Data Quality
5 sources
Confidence: Medium
EUVD NVD CVE.org EPSS Vulnrichment GHSA GitHub

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 Yes
EPSS 0.6%
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
Scheduled
Exploitation
None
System Exposure· derived
Small
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

63
Low Medium High Critical
KEV: 0
EPSS: +1
CVSS: +42
PoC: +20
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