Loom approval rule code_interpreter misses ADK execute tools
A require_approval rule whose text is code_interpreter matches the Strands tool of that name and does not match ADK code_interpreter_execute_code or code_interpreter_execute_command. Empty rules, a star, and code_interpreter* still match both. The lab is the product matcher, not a shell. Container SUCCESS on v1.9.0. The same functions are in v1.10.3 and were not re-run in a container on that tag.
- Name
- Loom approval rule code_interpreter misses ADK execute tools
- Type
- 0-day analysis
- CVE
- n/a
- CVE Risk
- high
- Disclosure Status
- public
- Vendor
- Loom
- Affected
- Loom for AWS v1.9.0 (a3050669f5b4c83210a44ed4346f17e01641e82f), container lab, and the same matcher and tool names on v1.10.3 (cc10ab08573087fa12154f7c8181ffcd985fea88), source compare only. In-group invoke on an ADK agent with Code Interpreter enabled, and a require_approval rule written as the exact string code_interpreter.
- Published
- 16 Nov 2026
- Updated
- 16 Nov 2026
- Tags
- 0-day, loom, aws, cwe, cwe-862, approval
The rule names the other framework
I had the wrong bug for most of an afternoon: the ADK code interpreter was not skipping its approval predicate, it was answering to a different name.
Someone allowed to talk to an ADK agent can use that agent's code sandbox even when an operator saved an approval rule named code_interpreter and expected a person to approve the call first. That string is the tool name on Strands, the other framework Loom ships. The ADK tools that run code and commands have longer names, so the exact rule does not see them. A rule written code_interpreter*, a lone *, or an empty rule list still stops both. This is the sandbox the agent already had. It is not a shell on the Loom host, and I did not stand one up.
Notes and the loopback client are abraxas/loom-adk-ci-glob and loom-adk-ci-glob-Abraxas-Labs.py. I am @abraxas_null. The tree is awslabs/loom.
The container run was tag v1.9.0, commit a3050669f5b4c83210a44ed4346f17e01641e82f. I then read tag v1.10.3, commit cc10ab08573087fa12154f7c8181ffcd985fea88. _matches_tool is still fnmatch.fnmatch, and the ADK execute functions are still code_interpreter_execute_code and code_interpreter_execute_command. I did not bring the container back up on v1.10.3. The oracle is the v1.9.0 run. Line numbers below are v1.10.3, because that is the current tag and the functions did not move.
No CVE from me on this one. CWE-862. 7.1 High (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:H/A:N). The caller already holds in-group invoke, so privileges stay low. Scope is unchanged. Confidentiality stays low and integrity goes high because the missed gate is execute_code and execute_command inside the AgentCore sandbox, not a new host. Availability is none. The sandbox was already the product. The bug is that the approval rule did not wrap it.
The matcher
Strands registers one code tool. In agents/strands_agent/src/agent.py the enabled interpreter is appended as ci.code_interpreter. The name the policy sees is code_interpreter. Running code is an argument of that tool, not a second name. An operator who copies the name off a Strands agent writes code_interpreter and thinks the gate covers "the code interpreter."
ADK splits the same sandbox into six FunctionTools. build_tools defines code_interpreter_execute_code at line 97 and code_interpreter_execute_command at line 104, then write, read, list, and remove under the same prefix. The function name is the tool name. Nothing is registered as the bare string code_interpreter.
The ADK approval module is supposed to port the Strands rules. _matches_tool is the whole decision:
def _matches_tool(tool_name: str, rules: list[str]) -> bool:
if not rules:
return True
return any(fnmatch.fnmatch(tool_name, pattern) for pattern in rules)fnmatch is a glob, not a prefix. The pattern code_interpreter matches the tool code_interpreter and does not match code_interpreter_execute_code or code_interpreter_execute_command. An empty rule list returns true before fnmatch runs, so a blank list pauses everything. * matches both execute names. code_interpreter* matches both, and the Strands name. The exact string is the one that splits the frameworks.
find_matching_policy walks enabled loop_hook policies and feeds tool_match_rules to that function. For these FunctionTools the confirmation predicate does run. A star rule still pauses ADK code execution. The leftover is not "ADK never asks." It is "the name copied from Strands never selects the ADK execute tools."
The file tools sit on the same prefix, so an exact code_interpreter rule misses them too. The lab oracle is only the two execute names. I am not promoting the file tools to their own result, and none of this is a host shell.
What I tried first
I assumed this was the other ADK miss, the tool type that never awaits its confirmation predicate. It is not. These six tools are FunctionTools, and that class does call check_require_confirmation. A policy that matches the function name still pauses the call.
The ADK README uses the short names. A rule of execute_code or execute_command matches neither framework. That trap is not the oracle. The oracle is the name Strands actually registers. Same matcher, rules ["code_interpreter"]: the Strands name matches, and both ADK execute names do not.
I checked the wide patterns so I would not call a working glob broken. An empty list pauses every tool. * and code_interpreter* match the ADK execute names. An operator who wrote a glob is fine. An operator who wrote the exact Strands name is not, once that policy is on an ADK agent.
Bedrock Guardrails are a different feature. An empty per-invoke guardrail id keeps the baked guardrail. It does not turn the check off. I am not filing that as this bug. CVE-2026-103956, CVE-2026-103957, and CVE-2026-103958 are the old unauthenticated super-admin, OAuth token disclosure, and MCP/A2A request forgery, fixed on earlier tags. v1.10.1 stopped planting managed keys such as AGENT_CONFIG_JSON. That plant is closed.
The container does not invoke an agent. It loads the product ApprovalPolicyMatcher from the v1.9.0 tree and answers POST /match. Health checks the matcher id and the hashes of approval.py, code_interpreter.py, and the Strands agent.py. The oracle is match or no-match.
What an attacker can do
The caller already has in-group invoke on an ADK agent with Code Interpreter enabled. Someone saved a require_approval rule whose only pattern is the exact string code_interpreter.
| Method | Class of impact | Lab-proven or inferred |
|---|---|---|
Exact rule code_interpreter against the Strands tool name |
The gate fires. Control. | Lab-proven. strands-name-matches=yes |
Same rule against code_interpreter_execute_code |
Integrity inside the AgentCore sandbox: execute-code is not selected for approval. Not a host shell. | Lab-proven. adk-execute-code-matches=no |
Same rule against code_interpreter_execute_command |
Integrity inside that sandbox: execute-command is not selected for approval. Not a host shell. | Lab-proven. adk-execute-command-matches=no |
Rules *, empty list, or code_interpreter* against both ADK execute names |
The gate fires. | Lab-proven. star, empty, and code_interpreter* all match. |
Same exact rule against the four code_interpreter_* file tools |
Same glob miss, still the sandbox. | Inferred from fnmatch. Not in the oracle. |
A live invoke that reaches execute_code or execute_command with no pause |
The impact the score describes, on a real ADK runtime. | Inferred from the tool bodies. The lab did not start a session. |
What that caller does not get is a shell on the Loom process, a new AWS role, or a pause-skip when the rule is a glob that covers the ADK names.
What stays closed
| Surface | Why it is not this bug | Lab-proven or inferred |
|---|---|---|
| CVE-2026-103956, unauthenticated super-admin | Fixed earlier. This caller is already in group. | Not re-filed. |
| CVE-2026-103957, OAuth token disclosure | Fixed in v1.7.0. | Not re-filed. |
| CVE-2026-103958, MCP and A2A SSRF | Fixed in v1.7.0. | Not re-filed. |
| Bedrock Guardrails | Different feature. Empty per-invoke id keeps the baked guardrail. | Read on v1.10.3. Not this lab. |
AGENT_CONFIG_JSON and other managed config keys |
v1.10.1 rejects that plant. | Closed. Not this bug. |
Empty rules, *, code_interpreter* |
Still match the ADK execute names. | Lab-proven control. |
| Strands name under the exact rule | The gate still fires. | Lab-proven control. |
| Host shell outside the AgentCore sandbox | Not the tool, and not the lab. | Not claimed. |
The lab
Loopback only. The matcher container listened on 127.0.0.1:18750 for the v1.9.0 run. Product sources were mounted, not rewritten. I did not repeat that container on v1.10.3.
LAB_URL=http://127.0.0.1:18750 python loom-adk-ci-glob-Abraxas-Labs.pySUCCESS LOOM-190-ADK-CI-GLOB strands-name-matches=yes adk-execute-code-matches=no adk-execute-command-matches=no star-matches-adk=yes empty-matches-adk=yes glob-star-matches-adk=yes LOOM-190-ADK-CI-GLOB-WITNESSIf either ADK execute name had matched the exact rule, the run would have died as leftover-closed. If the Strands name had missed, it would have been a different bug. If the star, the empty list, or code_interpreter* had missed, I would have scored a wider gate. They matched.
The fix
Treat code_interpreter as the family, not as one string, on every framework that shares the policy document. Match that exact rule against the Strands name and against the six ADK function names, or register one tool name in both agents and keep execute-versus-command as an argument the way Strands already does. A policy save can refuse an exact rule that hits a tool on one framework and misses the same capability on the other.
Do not "fix" the empty-list branch by making it match nothing. Today an empty list pauses every tool. That is the safe direction. The hole is the exact name being narrower than the tools it was written to name.
I am @abraxas_null. Lab files: abraxas/loom-adk-ci-glob. Loom at cc10ab08573087fa12154f7c8181ffcd985fea88. The matcher is approval.py line 56. The ADK execute tools start at code_interpreter.py line 97.