CVE-2026-29783: GitHub Copilot CLI Dangerous Shell Expansion Patterns Enable Arbitrary Code Execution
GitHub Copilot CLI before 0.0.423 can be tricked into running hidden commands through bash parameter expansion. Its shell safety check labels a command such as echo as read-only, while ${var@P} and related patterns execute embedded code. An attacker who can steer the agent's commands, for example by prompt injection, gets code execution. Fixed in @github/copilot 0.0.423.
Published Mar 6, 2026 · Updated Mar 13, 2026 · Analysis Oct 31, 2026
What an attacker can do
Copilot CLI sorts shell commands into read-only (runs without a prompt) and write-capable (needs approval). The classifier missed bash features that embed code inside arguments of harmless commands. The advisory lists four: the ${var@P} prompt-expansion operator, assignment forms ${var=value} and ${var:=value}, indirect expansion ${!var}, and command or process substitution nested inside ${...}.
The proof of concept looks like a plain echo: echo ${a="$"}${b="$a(touch /tmp/pwned)"}${b@P}. The first two expansions build the string $(touch /tmp/pwned), and @P evaluates it. The classifier saw only echo.
The attacker needs to influence the command text the agent sends to the shell tool. Sources include a README, code comment or issue body in a repository, a malicious MCP server response, or obfuscated user instructions. The user has to run the agent on that content (UI:A). The result is code execution on the developer workstation even in modes that ask before writes. That allows data exfiltration and file changes.
Who is affected
The npm package @github/copilot (GitHub Copilot CLI), versions <= 0.0.422, that is, anything before 0.0.423. Check the installed version:
npm ls -g @github/copilot
copilot --versionEvery permission mode is affected, because the flaw is in how commands are classified.
@github/copilot
- Ecosystem
- npm
- Affected
- <= 0.0.422
- Fixed in
- 0.0.423
- Check
npm ls @github/copilot
How to fix it
Upgrade to @github/copilot 0.0.423 or later.
npm install -g @github/copilot@latestThe fix has three layers. The safety assessment now parses ${...} nodes and downgrades commands with @P, =, :=, ! or nested substitutions from read-only to write-capable. Such commands are also blocked outright at the tool layer, even with --yolo or autopilot. The shell tool's system prompt tells the model to refuse them. Until you upgrade, avoid untrusted repositories and untrusted MCP servers, and review commands with complex parameter expansion.
How to tell if you were hit
Search shell history, agent transcripts and audit logs for commands containing @P, ${...=, ${...:=, ${!, or $( and <( inside ${...}. Look for echo or similar read-only commands that created files such as /tmp/pwned. Review repositories and MCP responses the agent read for hidden instruction text. Beam records agent shell commands, and its rules can flag risky ones, so obfuscated expansion patterns in a Copilot CLI session show up there.
Original advisory
From the GitHub Advisory Database (CC BY 4.0).
Summary
A security vulnerability has been identified in GitHub Copilot CLI's shell tool that could allow arbitrary code execution through crafted bash parameter expansion patterns. An attacker who can influence the commands executed by the agent (e.g., via prompt injection through repository files, MCP server responses, or user instructions) can exploit bash parameter transformation operators to execute hidden commands, bypassing the safety assessment that classifies commands as "read-only."
Details
The vulnerability stems from how the CLI's shell safety assessment evaluates commands before execution. The safety layer parses and classifies shell commands as either read-only (safe) or write-capable (requires user approval). However, several bash parameter expansion features can embed executable code within arguments to otherwise read-only commands, causing them to appear safe while actually performing arbitrary operations.
The specific dangerous patterns are:
- `${var@P}` — Prompt expansion: The
@Pparameter transformation operator evaluates its value as a prompt string, which interprets embedded command substitutions. This allows hidden command execution inside what appears to be a simple variable reference.
- `${var=value}` / `${var:=value}` — Assignment side-effects: These forms assign values to variables as a side-effect of expansion. When chained with
@P, an attacker can progressively build up a command substitution string across multiple expansions.
- `${!var}` — Indirect expansion: Dereferences an arbitrary variable name, which can be combined with other patterns to construct and execute commands dynamically.
- Nested `$(cmd)` or `<(cmd)` inside `${...}` expansions: Command substitution or process substitution embedded within parameter expansion default values (e.g.,
${HOME:-$(whoami)}) executes the nested command.
Proof of Concept
The following command appears to run a harmless echo, but actually executes touch /tmp/pwned through chained parameter expansion:
echo ${a="$"}${b="$a(touch /tmp/pwned)"}${b@P}How it works:
${a="$"}assigns the literal$character to variablea${b="$a(touch /tmp/pwned)"}expands$ato$, constructing the string$(touch /tmp/pwned)and assigning it tob${b@P}applies prompt expansion tob, which evaluates the embedded$(touch /tmp/pwned)command substitution
Prior to the fix, the safety assessment would classify echo as a read-only command and allow execution without user confirmation — even in modes that normally require approval for write operations.
Impact
An attacker who can influence command text sent to the shell tool — for example, through:
- Prompt injection via malicious repository content (README files, code comments, issue bodies)
- Compromised or malicious MCP server responses
- Crafted user instructions containing obfuscated commands
— could achieve arbitrary code execution on the user's workstation. This is possible even in permission modes that require user approval for write operations, since the commands can appear to be using only read-only utilities to ultimately trigger write operations.
Successful exploitation could lead to data exfiltration, file modification, or further system compromise.
Affected Versions
- GitHub Copilot CLI versions prior to 0.0.423
Remediation and Mitigation
Fix
The fix adds three layers of defense:
- Parse-time detection: The shell safety assessment analyzes
${...}expansion nodes within bash commands, detecting dangerous operators (@P,=,:=,!) and nested command/process substitutions. Commands containing these patterns are downgraded from read-only to write-capable, ensuring they require user approval.
- Unconditional blocking: Commands with dangerous expansion patterns are unconditionally blocked at the tool execution layer — regardless of permission mode (including
--yolo/ autopilot). This prevents exploitation even when all commands are auto-approved.
- System prompt hardening: The bash shell tool's system prompt now includes explicit instructions for the LLM to refuse executing commands with these patterns, providing a defense-in-depth layer.
User Actions
- Upgrade GitHub Copilot CLI to 0.0.423 or later.
- Exercise caution when working in untrusted repositories or with untrusted MCP servers.
- Review any shell commands suggested by the agent that contain complex parameter expansion patterns.
Questions
- Is Copilot CLI 0.0.422 affected by CVE-2026-29783?
Yes. Versions up to and including 0.0.422 are affected. Upgrade to 0.0.423 or later.
- Does approval mode protect me?
Not on affected versions. The command was classified read-only, so no approval prompt appeared. After the fix, commands with the dangerous patterns are blocked even with --yolo.
- How does an attacker get the command into the agent?
By prompt injection through repository files such as READMEs, code comments or issue bodies, through a malicious MCP server response, or through crafted user instructions.
- Is it exploited in the wild?
No source we read reports exploitation, and it is not in CISA's KEV catalog. The advisory includes a working proof of concept.
References
How this page is made: the data panel comes from the GitHub Advisory Database, CISA’s KEV catalog, the NVD and FIRST EPSS, and updates twice a day. The analysis is written by an AI model from the sources listed above and checked by automated rules before it is published. Check versions against the vendor's advisory before you act. Methodology
