← Back to Feed CACHED · 2026-10-15 16:40:58 · CACHE_KEY CVE-2026-103572
CVE-2026-103572 · CWE-94 · Disclosed 2026-10-13

Visual Studio Copilot / SSMS Path-Validation Bypass to RCE via Indirect Prompt Injection

ASSESSED — NOISGATE
Vendor
—
—
—
Reassessed
—
—
—
Verdict: —
Do you agree?
01 · The Real Story

Your AI pair-programmer will betray you the moment it reads a booby-trapped file, like an intern who runs every shell command a stranger emails them

CVE-2026-103572 is a code-injection-to-RCE chain in Microsoft.VisualStudio.Copilot.Core.dll, the shared Copilot engine inside Visual Studio 2022 (17.14.0–17.14.41), Visual Studio 2026 (18.10.0–18.10.3), and SQL Server Management Studio with Copilot integration. The root cause is a path-validation bypass: Windows silently strips trailing dots from filenames (e.g., settings.json. → settings.json), but the Copilot sandboxing code compares literal strings, so a write to .mcp.json. or settings.visualstudio.json. bypasses the blocklist and overwrites the real protected file. Combined with indirect prompt injection — crafted instructions hidden in source files, comments, or external data that the AI model processes — an attacker can coerce Copilot into registering a malicious MCP server that the IDE auto-launches, or setting ripgrepPath to an arbitrary executable that fires on the next search. The result is full arbitrary command execution under the developer's or DBA's user context.

Microsoft rated this Important / HIGH (8.8), which is *approximately right on the technical axis* but slightly overstates the unconditional real-world risk. The CVSS vector AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H is technically accurate — it is network-deliverable, requires no privileges, and only needs a user to interact with Copilot after opening poisoned content. However, the chain requires Copilot to be actively enabled (not universal across the fleet) and depends on a probabilistic indirect prompt injection step whose success rate varies by model. The researcher (Johann Rehberger / wunderwuzzi) demonstrated high reliability against MAI-Code-1-Flash, but enterprises running different Copilot model backends may see different hit rates. Against the blast radius — developer workstations are supply-chain pivots with access to repos, CI/CD creds, and signing keys, while DBA workstations running SSMS have direct prod-database access — a modest downgrade to 8.0 is warranted, not a dramatic one.

"AI copilot turned Trojan horse: one poisoned repo file lets attackers own your dev and DBA workstations."
02 · The Attack Path

5 steps from start to impact.

STEP 01

Deliver poisoned content to target

Attacker plants indirect prompt injection payloads into a location Copilot will read: a cloned Git repository, a shared solution file, an opened SQL script, a code review comment, or data returned from an external API. The payload contains natural-language instructions (possibly obfuscated with Unicode or comment-embedded text) directing Copilot to modify its own configuration files. No authentication or network access to the target is needed — the delivery is passive, waiting for the developer or DBA to open the content.
Conditions required:
  • Attacker can contribute content the victim will open in VS or SSMS (public repo, shared project, pull request, data source)
Where this breaks in practice:
  • Victim must voluntarily open the specific file or project — no drive-by or auto-exec vector
  • Content may be reviewed before opening in security-conscious orgs
Detection/coverage: Source-code scanning tools (e.g., Semgrep, custom regex) can flag suspicious prompt injection patterns in comments and strings. GitHub Advanced Security secret scanning does not cover this pattern today.
STEP 02

Copilot ingests the malicious prompt

When the developer interacts with Copilot — asking a question, triggering autocomplete, or running an agent-mode action — the AI model processes the opened file context, including the embedded injection payload. The model (MAI-Code-1-Flash in the researcher's PoC) follows the injected instructions because it cannot reliably distinguish attacker instructions from legitimate context. The researcher noted this model has 'poor indirect prompt injection resilience,' making this step highly reliable against current default configurations.
Conditions required:
  • Copilot is enabled and licensed in the target IDE
  • User interacts with Copilot while the poisoned content is in context
Where this breaks in practice:
  • Not all VS/SSMS installations have Copilot enabled — enterprise rollout varies from 30–70% depending on licensing
  • If the user never invokes Copilot while the malicious file is open, the chain dies
  • Some Copilot model backends may be more resistant to prompt injection
Detection/coverage: No production-grade detection exists for indirect prompt injection at the IDE level. Microsoft's AI safety filters did not block the demonstrated payloads.
STEP 03

Bypass path validation with trailing-dot trick

Following the injected instructions, Copilot attempts to write to .mcp.json. (note trailing dot) or settings.visualstudio.json.. The Copilot sandbox validates the target filename against a blocklist of protected files, but the comparison is literal — .mcp.json. ≠ .mcp.json, so it passes. When the Win32 layer actually performs the file write, it strips the trailing dot, and the real protected file is overwritten. An additional bypass exists using path-traversal (..) components within the trusted Extensions directory. For SSMS specifically, the SSMS.isolation.ini file discloses the installation-ID needed to construct the full path to settings files.
Conditions required:
  • The Copilot engine is the unpatched version of Microsoft.VisualStudio.Copilot.Core.dll
  • Windows OS (trailing-dot normalization is Windows-specific)
Where this breaks in practice:
  • This is the deterministic part of the chain — once Copilot decides to write, the bypass is 100% reliable on unpatched versions
  • No defender friction at this step; the bug is binary present-or-not
Detection/coverage: File integrity monitoring (FIM) on .mcp.json and settings.visualstudio.json in the VS/SSMS config directories would catch unauthorized writes. Sysmon Event ID 11 (FileCreate) with appropriate filters can detect this.
STEP 04

Weaponize configuration for code execution

MCP Server vector (VS & SSMS): The overwritten .mcp.json registers a new MCP server entry pointing to an attacker-controlled command (e.g., cmd.exe /c <payload>). The attacker also modifies enabledMcpServers and removes the entry from disabledMcpServers. The IDE detects the configuration change and auto-launches the malicious MCP server process. ripgrep vector (VS only): The overwritten settings.visualstudio.json sets copilot.general.tools.ripgrepPath to an arbitrary executable (e.g., calc.exe in the PoC, or a staged implant). The next time Copilot triggers a search operation, the specified binary executes with the user's full privileges.
Conditions required:
  • Step 3 succeeded (protected config file overwritten)
  • For MCP vector: IDE processes the MCP configuration change
  • For ripgrep vector: user triggers a Copilot search action
Where this breaks in practice:
  • MCP auto-launch may trigger process-creation alerts in mature EDR deployments
  • The spawned process runs under the developer user context, which typically has broad access to repos, build systems, and internal services
Detection/coverage: EDR should flag unusual child processes of devenv.exe or ssms.exe (e.g., cmd.exe, powershell.exe, unexpected binaries). Process tree analysis is the primary detection layer. CrowdStrike, SentinelOne, and MDE all have detections for anomalous child-process chains from signed Microsoft binaries.
STEP 05

Post-exploitation: supply-chain or data-tier pivot

With arbitrary code execution on the developer or DBA workstation, the attacker harvests credentials (Git tokens, SSH keys, cloud API keys, database connection strings), exfiltrates source code, injects backdoors into CI/CD pipelines, or directly queries production databases via the SSMS session. On a DBA workstation, the existing authenticated SSMS session may provide immediate access to production SQL Server instances without additional credential theft. This is the blast-radius step where the impact scales from a single workstation to organizational scope.
Conditions required:
  • Step 4 succeeded (arbitrary code execution achieved)
  • Victim workstation has access to high-value resources (repos, CI/CD, databases)
Where this breaks in practice:
  • Network segmentation and PAM controls may limit lateral movement from the workstation
  • Database access may require additional MFA in mature environments
  • EDR behavioral detection may catch credential-harvesting tools
Detection/coverage: SIEM correlation of unusual data access patterns from developer/DBA workstations. Database activity monitoring (DAM) solutions flag anomalous query patterns from established SSMS sessions.
03 · Compensating Control

1
HIGH 8.0→LOW 3.0
SEVERITY REDUCED
Disable Copilot or restrict MCP server auto-launch in VS and SSMS — The most effective immediate mitigation. Set copilot.enable: false or disable the Copilot extension via Group Policy / VS admin deployment config. If Copilot is business-critical, at minimum disable MCP server auto-launch by clearing enabledMcpServers and setting MCP to require explicit user approval for new servers. This breaks step 2 of the attack chain entirely. Deploy within 30 days per the noisgate mitigation SLA for HIGH.
2
HIGH 8.0→MEDIUM 6.5
SEVERITY REDUCED
Deploy file integrity monitoring on Copilot config files — Configure FIM (Sysmon Event ID 11, or your EDR's file-write telemetry) to alert on writes to .mcp.json, settings.visualstudio.json, and settings.VisualStudio.json in VS/SSMS configuration directories. This catches step 3 of the attack chain (the path-validation bypass) in real time and enables rapid response even if the prompt injection succeeds. Deploy within 30 days per the noisgate mitigation SLA.
3
HIGH 8.0→MEDIUM 5.5
SEVERITY REDUCED
Harden EDR child-process policies for devenv.exe and ssms.exe — Create EDR rules that alert on or block unexpected child processes spawned by devenv.exe and ssms.exe — particularly cmd.exe, powershell.exe, bash.exe, and any unsigned binaries. This catches step 4 (the MCP server launch or ripgrep path hijack execution). Most enterprise EDR platforms (CrowdStrike, SentinelOne, MDE) support parent-process-based behavioral rules. Deploy within 30 days.
4
HIGH 8.0→IGNORE 0.0
SEVERITY REDUCED
Apply the vendor patch (VS 17.14.42 / 18.10.4) — The definitive fix. Microsoft's patch adds GetFullPath() normalization before the filename validation check, eliminating the trailing-dot and path-traversal bypasses. Apply within 180 days per the noisgate remediation SLA for HIGH, but aim for 30 days given the public PoC. Push via your VS update management channel (WSUS, ConfigMgr, Winget, or manual update).
What doesn't work
  • Network-level controls (WAF, NGFW, IDS) — This is a client-side attack triggered by opening local files. No network payload crosses the perimeter at exploitation time; the poisoned content arrives via normal channels (Git clone, file share, email attachment). Network inspection cannot see or block the prompt injection.
  • Application allowlisting / AppLocker for VS itself — Blocking VS or SSMS from running defeats the purpose. The malicious execution happens *through* the legitimate IDE process, not by replacing it. AppLocker would need to block specific child processes, which is covered by the EDR recommendation above.
  • Email security gateways — While the poisoned content *could* arrive via email, the attack vector is primarily code repositories and shared projects. Email gateways cannot inspect Git repos, PR comments, or solution files for indirect prompt injection payloads.
  • Copilot content filters alone — Microsoft's existing AI safety filters did not block the demonstrated payloads. Relying on model-level guardrails without the file-write validation fix leaves the trailing-dot bypass intact.
04 · Intelligence Metadata

The supporting signals.

In-the-wild exploitationNo confirmed exploitation as of 2026-10-16. Not listed in CISA KEV. No GreyNoise tags or active scanning campaigns observed. However, the attack is workstation-targeted via social engineering, not network-scannable — mass exploitation would not appear in network honeypots.
Proof-of-conceptPublic and detailed. Johann Rehberger (wunderwuzzi / Embrace The Red) published full technical writeup with two working attack chains (MCP server registration + ripgrep path hijack) on 2026-10-13, same day as patch release. Demonstrates both the trailing-dot bypass and indirect prompt injection against MAI-Code-1-Flash. No dedicated GitHub PoC repo identified yet, but the blog post is functionally a complete exploitation guide.
EPSS0.82% probability of exploitation in next 30 days (~44th percentile). Moderate — reflects the UI:R requirement and targeted delivery model. EPSS may underweight AI-agent attack surfaces given limited historical training data on this class.
CVSS vectorCVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H — Network-deliverable with no auth and low complexity, but requires user interaction (the key friction point). Scope is Unchanged (execution stays within the user context). Full CIA impact.
Affected versionsVisual Studio 2022 17.14.0 through 17.14.41 · Visual Studio 2026 18.10.0 through 18.10.3 · SQL Server Management Studio versions shipping the vulnerable Microsoft.VisualStudio.Copilot.Core.dll (any SSMS with Copilot/MCP support enabled).
Fixed versionsVS 2022: 17.14.42 (October 13, 2026 Patch Tuesday) · VS 2026: 18.10.4 · SSMS fix delivered through the shared DLL update. No distro backports apply — VS/SSMS are direct-from-Microsoft installs.
Disclosure timeline2026-08-04: reported to MSRC · 2026-08-07: expanded scope to include VS · 2026-09-16: Microsoft confirmed · 2026-10-11: $0 bounty (out-of-scope determination) · 2026-10-13: patch + public disclosure.
Reporting researcherJohann Rehberger (wunderwuzzi, [email protected]) via Embrace The Red. Rehberger is a prolific AI-security researcher with prior Copilot and prompt injection disclosures.
Scanning/exposureThis is a client-side vulnerability in developer tooling — not detectable via Shodan, Censys, or FOFA. Exposure is measured by enterprise VS/SSMS install base with Copilot enabled. Microsoft reports tens of millions of active VS users; Copilot adoption in enterprise varies but is accelerating rapidly.
Root cause fixMicrosoft added Path.GetFullPath() normalization before the filename validation check, stripping trailing dots and resolving relative path components (..) before comparing against the protected-file blocklist.

Sources.

  1. Embrace The Red — Full technical writeup by Johann Rehberger
  2. SecurityOnline — Public PoC disclosure coverage
  3. Microsoft Visual Studio 2022 17.14 Release Notes
  4. Strix AI — CVE-2026-103572 intelligence summary
  5. Offseq Radar — CVE-2026-103572 threat profile
  6. Rapid7 — Microsoft Visual Studio CVE-2026-103572
  7. Hive Security — Prompt Injection in 2026: From Research to Real CVEs
05 · The Call

Final Verdict
= UNCHANGED to HIGH (8.0/10)

Why this verdict

  • Copilot-enablement gate narrows the vulnerable population. The attack chain is inert on any VS or SSMS installation where Copilot is not enabled and actively used. Enterprise Copilot rollout varies between 30–70% of developer seats depending on licensing and policy. This materially reduces the fraction of the installed base that is reachable, justifying a ~0.5-point reduction from the vendor's 8.8.
  • Indirect prompt injection is probabilistic, not deterministic. The chain depends on the AI model following attacker instructions embedded in context. The researcher demonstrated high reliability against MAI-Code-1-Flash, but success is model-dependent, prompt-dependent, and context-dependent. This is not a guaranteed exploit step — it's closer to a 60–85% hit rate in realistic conditions, adding meaningful friction that CVSS doesn't capture. Another ~0.3-point reduction.
  • User interaction is mandatory and non-trivial. The victim must (1) open a poisoned file/repo in VS or SSMS, then (2) interact with Copilot while that content is in scope. This two-step requirement means the attack cannot be mass-sprayed like a network worm — it requires targeted social engineering or supply-chain positioning (e.g., trojanized open-source dependency, malicious PR).
  • Role multiplier: Developer workstations (supply-chain pivot) — KEEPS the floor at HIGH. Visual Studio's canonical deployment is developer workstations. ≥90% of VS installs sit on machines with access to source code repositories, CI/CD pipeline credentials, code-signing keys, and internal service tokens. A compromised developer workstation enables supply-chain attacks (backdoored builds, poisoned artifacts). The blast radius is supply-chain-scale, which sets the severity floor at HIGH regardless of friction.
  • Role multiplier: DBA workstations running SSMS (data-tier pivot) — reinforces HIGH floor. SSMS is THE tool database administrators use to manage production SQL Server instances. A compromised SSMS workstation likely has live authenticated sessions to production databases containing regulated data (PII, financial, health). The blast radius is mass data egress, reinforcing the HIGH floor.
  • Role multiplier: CI/CD build agents — lower probability but catastrophic outcome. Some organizations run VS build tooling on CI/CD build agents. If Copilot is enabled on these (unusual but possible), the blast radius extends to the entire software supply chain. This is an edge case (~1–5% of installs) but the outcome is fleet-scale, supporting the HIGH floor.

Why not higher?

CRITICAL would require the chain to be exploitable without user interaction or with near-certain reliability at fleet scale. The mandatory UI:R requirement (two-step: open content + invoke Copilot), the Copilot-enablement prerequisite, and the probabilistic nature of indirect prompt injection collectively prevent mass exploitation. There is no self-propagation mechanism, no network-spray vector, and no privilege escalation beyond the current user. The attack is fundamentally targeted, not wormable.

Why not lower?

The public PoC with detailed walkthrough dramatically lowers the attacker skill bar. Developer and DBA workstations are high-value targets by definition — they sit at the intersection of source code, build pipelines, credentials, and production data. The trailing-dot bypass is 100% reliable once the prompt injection succeeds, so the only real friction is the social engineering delivery and model compliance. Supply-chain attacks via developer tooling are among the highest-impact TTPs in the current threat landscape (SolarWinds, Codecov, XZ Utils). Downgrading below HIGH would dangerously underweight the blast radius.

06 · Verification

Crowdsourced verification payload.

Run this script on each developer/DBA workstation where Visual Studio or SSMS is installed. Execute in a standard PowerShell session (no elevation required). Example: powershell -ExecutionPolicy Bypass -File .\Check-CVE2026103572.ps1

noisgate-verify.ps1
POWERSHELLREAD-ONLYSAFE
#!/usr/bin/env pwsh
# Check-CVE2026103572.ps1
# Checks whether Visual Studio or SSMS installations are vulnerable to CVE-2026-103572
# (Copilot path-validation bypass via trailing-dot filenames)
# Exit codes: 1 = VULNERABLE, 0 = PATCHED, 2 = UNKNOWN

$vulnerable = $false
$found = $false

# Check Visual Studio 2022 (17.x) installations via vswhere
$vswhere = "${env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer\vswhere.exe"
if (Test-Path $vswhere) {
    $instances = & $vswhere -all -format json 2>$null | ConvertFrom-Json
    foreach ($inst in $instances) {
        $ver = [version]$inst.installationVersion
        $name = $inst.displayName
        $found = $true
        # VS 2022 17.14.x: vulnerable if < 17.14.42
        if ($ver.Major -eq 17 -and $ver.Minor -eq 14) {
            if ($ver.Build -lt 42) {
                Write-Host "[!] $name ($ver) - VULNERABLE" -ForegroundColor Red
                $vulnerable = $true
            } else {
                Write-Host "[+] $name ($ver) - PATCHED" -ForegroundColor Green
            }
        }
        # VS 2026 18.10.x: vulnerable if < 18.10.4
        elseif ($ver.Major -eq 18 -and $ver.Minor -eq 10) {
            if ($ver.Build -lt 4) {
                Write-Host "[!] $name ($ver) - VULNERABLE" -ForegroundColor Red
                $vulnerable = $true
            } else {
                Write-Host "[+] $name ($ver) - PATCHED" -ForegroundColor Green
            }
        }
        else {
            Write-Host "[?] $name ($ver) - version outside known affected range, verify manually" -ForegroundColor Yellow
        }
        # Also check the DLL directly if accessible
        $dllPath = Join-Path $inst.installationPath "Common7\IDE\Extensions\Microsoft\Copilot\Microsoft.VisualStudio.Copilot.Core.dll"
        if (Test-Path $dllPath) {
            $dllVer = (Get-Item $dllPath).VersionInfo.FileVersion
            Write-Host "    Copilot DLL version: $dllVer"
        } else {
            Write-Host "    Copilot DLL not found (Copilot may not be installed - not vulnerable if absent)"
        }
    }
} else {
    Write-Host "[i] vswhere.exe not found - Visual Studio Installer not present" -ForegroundColor Cyan
}

# Check SSMS installations via registry
$ssmsKeys = @(
    'HKLM:\SOFTWARE\Microsoft\Microsoft SQL Server Management Studio',
    'HKLM:\SOFTWARE\WOW6432Node\Microsoft\Microsoft SQL Server Management Studio'
)
foreach ($key in $ssmsKeys) {
    if (Test-Path $key) {
        Get-ChildItem $key -ErrorAction SilentlyContinue | ForEach-Object {
            $found = $true
            $ssmsVer = $_.PSChildName
            Write-Host "[i] SSMS installation detected: version key $ssmsVer" -ForegroundColor Cyan
            Write-Host "    Check for updated Copilot DLL in SSMS install directory manually."
            Write-Host "    If SSMS has Copilot/MCP integration enabled, treat as potentially VULNERABLE until patched."
        }
    }
}

if (-not $found) {
    Write-Host "UNKNOWN - No Visual Studio or SSMS installations detected" -ForegroundColor Yellow
    exit 2
}

if ($vulnerable) {
    Write-Host "`nVULNERABLE - One or more installations need patching for CVE-2026-103572" -ForegroundColor Red
    exit 1
} else {
    Write-Host "`nPATCHED - All detected installations appear to be at fixed versions" -ForegroundColor Green
    exit 0
}