Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSupply crafted string with double quote
-
DeliveryReaches PowerShell/Cmd wrapper
-
ExploitBreaks OS-level argument quoting
-
ExecutionShell executes injected command
-
ImpactArbitrary 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 |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
Affected Packages
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
AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
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.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
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
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.
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
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-87320
GHSA-wrvw-254r-wpmv
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB