NewApp Monitoring is liveSign up free
AgentbeamBeta
AI agent vulnerability · GitHub Copilot CLI

CVE-2026-29783: GitHub Copilot CLI Dangerous Shell Expansion Patterns Enable Arbitrary Code Execution

highCVSS 4.0 7.5GHSA-g8r9-g2v8-jv6f

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 --version

Every 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@latest

The 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:

  1. `${var@P}` — Prompt expansion: The @P parameter 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.
  1. `${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.
  1. `${!var}` — Indirect expansion: Dereferences an arbitrary variable name, which can be combined with other patterns to construct and execute commands dynamically.
  1. 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 variable a
  • ${b="$a(touch /tmp/pwned)"} expands $a to $, constructing the string $(touch /tmp/pwned) and assigning it to b
  • ${b@P} applies prompt expansion to b, 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:

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

  1. Upgrade GitHub Copilot CLI to 0.0.423 or later.
  2. Exercise caution when working in untrusted repositories or with untrusted MCP servers.
  3. 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

More GitHub Copilot CLI vulnerabilities

All GitHub Copilot CLI entries