Skip to content

"Please show your credentials": detecting filesystem capability laundering in MCP servers at scale

"My Credentials, Please": Detecting Filesystem Capability Laundering in MCP Servers at Scale

Paper Tracker· arXiv:2610.22301· Zeqian Huang, Mingyue Tang, Aonan Guan, Qiming Sun, Pengzhou HeUniversity of Illinois Urbana-Champaign; Santa Clara University; Auburn University at MontgomeryIndexed by this site · 2026-10-20· Originally publishedSelected AttacksSelectedAttention42

Quick read

Defenses

Based on the paper PDF (generated by Gemini); refer to the original

The authors propose the detection framework MCP-FSD to evaluate 21,097 MCP servers; dynamic three-case verification confirmed 150 instances with filesystem capability laundering vulnerabilities.

Threat modelThe victim system is a local stdio MCP server running as an independent subprocess, with user environment file permissions and approval prompts lacking per-tool path restrictions. The attacker influences parameters through untrusted input ingested by the agent, inducing benign tools to access out-of-contract host files and leak file content in responses. The attack assumes the agent issues the call under test and the server has permission to access the target; tampering with server code and breaking out of the OS sandbox are outside the model.

Questions
In local deployments, client approval of tool calls often grants the server process broad host file system permissions, causing attackers to induce benign tools to access sensitive host files beyond the declared contract and deployment scope, producing file system capability sanitization risk.
Methods
Proposes a two-stage framework, MCP-FSD: the static stage analyzes tool contracts through multi-layer filtering and infers each tool's minimal-privilege boundary based on startup configuration, schema, and code; the dynamic stage uses generated payloads to verify exploitability and isolation effectiveness through three-case replay: no-sandbox attack, sandbox benign, and sandbox attack.
Experiments and results
Among 21,097 servers from 9 registries, 16.4% of the 4,806 classified servers exhibited out-of-contract filesystem capability markers. Three-case dynamic verification confirmed 150 vulnerable instances, and responsible disclosure produced 13 security advisories, including 2 CVEs for the Anthropic Git MCP server.
Limitations and future work
Dynamic validation is limited by servers that can be successfully installed and run and by the selected runtime configuration; the accuracy of the inference boundary was not systematically quantified, and the focus was mainly on response content leakage, without systematic evaluation of unauthorized write modifications; it depends on the strength of the sandbox backend, and does not cover systematic chained vulnerability discovery across tool calls.
Experimental setupNine MCP registries catalog (pulsemcp, mcpservers, glamaai, mcpmarket, smithery, mcpgithub, mcpkit, clinebot)、Hand-labeled stratified benchmark for L2 and L3 et al. · Precision、Recall et al.
Benchmarks
Nine MCP registries catalog (pulsemcp, mcpservers, glamaai, mcpmarket, smithery, mcpgithub, mcpkit, clinebot)Hand-labeled stratified benchmark for L2 and L3Anthropic Git MCP ServerAnthropic Filesystem MCP Server
Metrics
PrecisionRecallF1Confirmed instances countShare of static emissions (%)Share of triaged (%)
AI summaryand selection rationaleResearchers propose filesystem capability laundering as a category of MCP server vulnerability, and design a detection framework MCP-FSD, dynamically confirming 150 instances capable of unauthorized reading of host files in a directory of 21,097 MCP servers. The framework filters through three layers: server category, tool contract and path validation, and among 4,806 reviewed servers found 787 (16.4%) non-file-type servers possessing filesystem capabilities. Dynamic verification uses three sets of tests to distinguish exploitability of unauthorized access from the effect of sandbox isolation; coordinated disclosure produced 13 security advisories, including two CVEs for the Anthropic Git MCP Server, respectively involving git_init not restricting the repository creation path and a path traversal staging issue in git_add, both of which have been fixed upstream.

Researchers propose filesystem capability laundering as a category of MCP server vulnerability, and design a detection framework MCP-FSD, dynamically confirming 150 instances capable of unauthorized reading of host files in a directory of 21,097 MCP servers. The framework filters through three layers: server category, tool contract and path validation, and among 4,806 reviewed servers found 787 (16.4%) non-file-type servers possessing filesystem capabilities. Dynamic verification uses three sets of tests to distinguish exploitability of unauthorized access from the effect of sandbox isolation; coordinated disclosure produced 13 security advisories, including two CVEs for the Anthropic Git MCP Server, respectively involving git_init not restricting the repository creation path and a path traversal staging issue in git_add, both of which have been fixed upstream.

Why it was selectedThe paper scans 21,097 MCP servers and confirms 150 instances of filesystem privilege escalation, discloses two CVEs in Git MCP Server, and can be used by deployers to check tool permission boundaries.

Related events and news

1 events · 1 news mentions

News that mentions this paper

Adversa AI 汇总 2026 年 11 月 MCP 安全资源

Paper analysis

6 questions; open one to read the full answer

  1. What problem does this paper attempt to solve?

    Local MCP servers have host environment file permissions after client approval, and attackers can induce benign tools through controlled parameters to read sensitive credentials across boundaries.

    This paper attempts to address the "filesystem capability laundering" security vulnerability in local Model Context Protocol (MCP) servers.

    • Problem scenario and importance: In a typical local stdio deployment, the client approval prompt permits execution based only on the declared tool parameters, while the underlying server runs as an independent subprocess with the user environment's file permissions, without per-tool path restrictions. An attacker can induce seemingly benign tool operations to read and exfiltrate sensitive files or credentials from the host machine.
    • Shortcomings of existing mechanisms: The authors state that the MCP specification delegates per-tool filesystem enforcement entirely to the individual server implementation or host environment; and operating system process isolation, without an explicit sandbox policy, cannot restrict access to the host filesystem. In addition, existing path validation is easily bypassed by missing prefix matching or symlink resolution flaws.
    • Core observation and three-layer gap: The authors decompose the capability laundering gap into three layers: L1 server category layer (non-filesystem servers often possess local persistence capabilities, leading to category mismatch), L2 tool contract layer (narrow tool operations reach files outside the intended scope), and L3 defense bypass layer (existing path checks are circumvented).
    • Threat model:
      • Attacker goal: Achieve filesystem disclosure; an attack is judged successful when an MCP response contains file content outside the tool's legitimate scope.
      • Attacker knowledge: Evaluation starts from the tool call, assuming the agent issues the call or sequence under test and the server has host permissions to access the target file; the paper does not assume the attacker knows the server's internal code implementation.
      • Attacker capability: Influence parameter values that drive side effects through untrusted input ingested by the agent, inducing tools to exercise capabilities beyond their contract; arbitrarily modifying server code and breaking out of the operating system sandbox are outside the model.
      • Victim system: Local stdio MCP servers launched as independent processes, lacking per-tool path restrictions.
    • Paper's solution: The authors propose the MCP-FSD (Filesystem Scope Detection) framework, combining static analysis filtering with dynamic three-case replay against inferred minimal-privilege boundaries, to achieve large-scale detection and isolation evaluation of filesystem capability laundering in MCP servers.
  2. What related research exists?

    Existing research focuses on describing code inconsistencies, the WASI sandbox, or macro-level threats; this paper connects the evidence chain by inferring each tool's policy and replaying three use cases dynamically on the native host.
    • MCP security and tool contract analysis:
      • DCIChecker (Shi et al., 2026) combines structured code extraction with prompt arbitration to detect inconsistencies between descriptions and code; the authors note that MCP-FSD focuses on filesystem side effects triggered by attacker-controlled parameters and tests against the policy inferred for each tool.
      • MCP-SandboxScan (Tan et al., 2026) uses WASM/WASI-based sandbox execution and output matching to detect external input leakage; the authors note that MCP-FSD combines static filtering with dynamic three-case replay on the native host runtime, capturing data flows of complex library calls.
      • MICRYSCOPE (Yan et al., 2025) and MCPGuard (Wang et al., 2025) respectively conduct cross-language taint analysis for cryptographic misuse in MCP servers, and a systematic review of scanning and runtime monitoring for MCP threats and defenses.
    • Filesystem vulnerabilities and access control detection:
      • PathSentinel (Lee et al., 2024) performs program analysis and exploit verification for Android filesystem attacks; the authors note that PathSentinel is based on pre-existing platform access control policies, whereas MCP-FSD directly infers minimal-privilege boundaries from non-standardized tool descriptions and deployment configurations.
      • Akhoundali et al. (2025) and UntrustIDE (Lin et al., 2024) respectively studied path traversal vulnerabilities in GitHub code repositories and security weaknesses in VS Code extensions.
      • The Claude Code security advisory (Anthropic, 2026) documented path traversal flaws in the agent framework itself, including prefix matching bypass and symlink following bypass.
    • Agent security and isolation mechanisms:
      • AgentHarm (Andriushchenko et al., 2025) and AgentDojo (Debenedetti et al., 2024) built environment benchmarks for evaluating harmful tool calls or dynamic prompt injection attacks and defenses in LLM agents.
      • Greshake et al. (2023) and InjecAgent (Zhan et al., 2024) studied the impact of indirect prompt injection on LLM applications and agents with integrated tools.
      • IsolateGPT (Wu et al., 2025) and nono (always-further, 2025) respectively proposed an execution isolation architecture for agent systems and a capability-control-based operating system sandbox runtime.
    • Baselines and test benchmarks:
      • In L3 rule coverage, the paper references known vulnerabilities of the official Anthropic Filesystem MCP Server (CVE-2025-53110 sibling directory prefix bypass, CVE-2025-53109 symlink boundary bypass); the evaluation constructed a catalog of 21,097 servers covering 9 registries, as well as manually annotated stratified benchmarks for L2 (300 tools) and L3 (297 detections).
    • Positioning relative to existing work:
      • The authors argue that description-code consistency, file-to-output flow, and authorization checks address different problems; MCP-FSD combines source candidates, inferred policies, and execution traces, directly connecting the evidence chain from declared operations, test access, to bytes returned in responses.
  3. How does the paper address this problem?

    Proposes a two-stage framework, MCP-FSD, which combines static multi-layer filtering with minimal-privilege boundary inference, and generates executable disclosure evidence through dynamic three-case replay.

    Overall, MCP-FSD (Filesystem Scope Detection) adopts a two-stage design: first, large-scale crawling and multi-layer static analysis are used to filter candidate tools; then, minimal-privilege boundaries for each tool are inferred based on multi-source signals; finally, dynamic three-case replay against that boundary generates executable disclosure evidence.

    Problem formalization and definition of capability laundering

    Under a fixed deployment context d (including server version, startup configuration, workspace, and initial state), the set of filesystem effects produced by calling tool t with parameters a is denoted E(t, a) ⊆ ℱ × {read, write}, where ℱ denotes filesystem targets resolved at access time. Collecting all parameter vectors 𝒜(t) that an attacker can control through ingested content, the set of all file effects they can reach is denoted Reach(t). The set of privileges legitimately granted by the contract and deployment context is denoted B(t; d). Tool t undergoes filesystem capability laundering if and only if the following holds: \text{Reach}(t) \not\subseteq B(t; d) This formula indicates that the actual filesystem effects of the tool implementation exceed the boundary legitimately granted by its contract and deployment. When there exists a parameter and file pair such that the content of an unauthorized read file appears verbatim in the tool response, that pair constitutes disclosure evidence.

    Static filtering and multi-layer filters (L1–L3)

    • Static analysis and SARIF records: MCP-FSD uses an LLM to identify tool registration, handler functions, and path parameters, checks whether parameters reach filesystem operations and whether they undergo validation, and records candidate results in SARIF format.
    • Five defect rules: Covering CWE-22 (path traversal) and CWE-59 (link resolution), including PT-001 missing validation, PT-002 prefix matching restriction, PT-003 URL traversal, PT-004 symlink TOCTOU, and PT-005 blacklist filtering.
    • Four MCP-specific screening filters (M1–M4):
      • M1: Rank SARIF detections flagged for MCP tools, prioritizing file content sinks and excluding write-only or shell operations;
      • M2: Inspect tool schemas to identify path-type parameters that reach sinks;
      • M3: Review response construction logic to exclude tools that only return derived metadata such as line counts or schema descriptors, ensuring responses may return file text;
      • M4: Filter for MCP servers that can run locally via stdio, excluding cloud-hosted services that cannot be reproduced.

    Minimal-privilege boundary inference algorithm

    • Four types of inference signals: Algorithm 1 combines four inputs: startup configuration L (working directory cwd, --root startup parameter, path environment variables), path fields S in the tool JSON schema, tool description text D, and path references R extracted from handler source code.
    • Policy drafting and expansion: First, a language model drafts a candidate glob policy P combining L, S, and D; then it checks source-visible path references Rstatic, and if not covered, expands the policy via Cover to include runtime dependencies (language runtime, library files, and system configuration paths).
    • Read/write permission splitting and fixture planning: SplitRWRO divides the policy into a read-write path set and a read-only path set based on each parameter's access pattern at the observation point. The fixture planner then places credential fixtures containing sensitive data outside all permitted scopes, and places benign marker files within the working directory scope.

    Payload generation and dynamic three-case verification protocol

    • Iterative payload generation: For path parameters in the schema, the language model seeds initialization based on known path traversal examples and continuously adjusts based on the schema, inferred boundary, and execution responses. For tools that accept structured input, the model wraps the target path into a format-compliant container file (such as glTF, DOCX, Terraform configuration, or PNG).
    • Three-case verification protocol:
      1. PoC 1 (no-sandbox attack): Execute the malicious payload on a host without a sandbox; success is judged if and only if the response contains the pre-planted credential content verbatim, confirming the vulnerability is exploitable on an unrestricted host;
      2. PoC 2 (sandbox benign): Execute a benign payload in an environment with the inferred sandbox policy applied, requiring normal success and no system interception events, verifying that the sandbox policy protects legitimate functionality;
      3. PoC 3 (sandbox attack): Replay the malicious payload from PoC 1 under the same sandbox policy, requiring that the response does not contain credential content and produces an explicit denial or no-leak response, testing whether the policy eliminates the exploit.
    • Decision criteria: Distinguish explicit isolation (exposing operating system denial events) from implicit silent isolation (empty or no-leak response). The evaluation records three parsed response traces and reproduction scripts for adjudication.
  4. What experiments did the paper conduct?

    On the annotation set, the classifier achieved an F1 of 0.978; dynamic verification confirmed 150 vulnerability instances, and responsible disclosure drove fixes for 2 CVEs including the Git server.

    Experimental setup

    • Evaluation corpus and filtering funnel: 21,097 entries were crawled from 9 registries (17,919 open-source servers); after excluding forks, archives, remotely hosted, and unavailable code, 7,222 local open-source servers were selected for startup measurement (of which 86.3% of Python and 72.7% of Node servers started successfully); the final triage snapshot was 4,806 servers.
    • Test subjects and environment: Static analysis was performed on the 4,292 successfully parsed servers, and dynamic three-case verification was performed on the selected candidate instances using nono v0.43.0 (based on the macOS Seatbelt sandbox).
    • Baseline and stratified annotation set: A manually stratified annotation sample of 300 candidates was used to evaluate the L2 tool-name classifier (300 tools) and the L3 defense-bypass classifier (297 detections, 3 excluded due to repository invalidity); the 2 known CVEs of the official Filesystem MCP Server (CVE-2025-53110 and CVE-2025-53109) were used as a reference for L3 static rule coverage.
    • Unit of analysis division: Four units are distinguished: server (4,806 classified entries), static detection (SARIF finding sites), dynamic instance (independent "tool-policy" pairs confirmed through three-case replay), and disclosure package (vulnerability reports submitted to vendors).
    • Decision and disclosure criteria: The primary disclosure criterion relies on exact credential marker matching (136 of the 150 confirmed instances relied on this, while the remaining 14 relied on trace features such as write side effects, response shape, or external CLI output).
    • Experimental repetition and model notes: Dynamic verification was performed in controlled installations with state reset between test cases; the paper does not report the number of repeated samplings of LLM prompts or model version details.

    Main results

    Swipe horizontally to read the table

    Evaluation level / classifierTotal samplesPositive (Pos.)Negative (Neg.)PrecisionRecallF1
    L2 tool-name (tool-name layer)300205950.9950.9710.983
    L3 defense-bypass (defense-bypass layer)2971421550.9530.9930.972
    Micro average5973472500.9770.9800.978
    Macro average597--0.9740.9820.978
    • Classifier accuracy: According to Table 1, the L2 tool-name classifier achieved a Precision of 0.995 and a Recall of 0.971 on 300 annotated tools (1 false positive, 6 false negatives); the L3 defense-bypass classifier achieved a Precision of 0.953 and a Recall of 0.993 on 297 annotated detections (7 false positives, 1 false negative).
    • Static detections and rule distribution: Among the 4,292 servers with results, static analysis flagged 2,818 servers (65.7%), producing 10,304 detections in total (Figure 4); of these, missing path validation (PT-001) accounted for 36.4%, while the four defense-bypass rules (PT-002 to PT-005) together accounted for 61.6%.
    • Dynamic confirmation and end-to-end verification: The authors state that three-case dynamic verification ultimately confirmed 150 vulnerability instances, of which 136 instances fully matched the pre-planted credential key in PoC 1 and were fully blocked by the sandbox in PoC 3.

    Ecosystem distribution and language/tool differences (RQ4)

    • What was measured: The language and rule distribution of static detections among the 2,818 flagged servers (Figure 5a, Figure 5b).
    • Experimental results: Node and Python accounted for the vast majority (at the sink layer, 54.3% Node, 42.6% Python, with other languages together accounting for less than 3.1%). Python accounted for 53.8% of the missing validation rule (PT-001), while Node accounted for 57%–63% of all bypass-type rules (PT-002 to PT-005). Detections were highly concentrated in codebases: the top 5% of repositories produced 18.7% of detections, and the top 25% of repositories produced 52.5% of detections (Gini coefficient ≈ 0.55).
    • Authors' interpretation: The authors argue that this distribution reflects structural flaws in the toolchain: the MCP TypeScript SDK lacks built-in path restriction primitives, making custom checks written by Node developers prone to errors; while Python servers often omit path validation entirely.

    Payload forms and structured input parsing (RQ5)

    • What was measured: The input formats of converged payloads among the 150 confirmed instances were classified (bare paths vs. format-valid containers).
    • Experimental results: Among the 150 confirmed instances, 144 (96.0%) could be triggered using bare traversal paths, while 6 (4.0%) required wrapping in a format-valid container (such as glTF, DOCX, Terraform configuration, etc.). Among the 38 instances that bypassed explicit source validation, bare paths accounted for 32 (84.2%) and structured containers accounted for 6 (15.8%).
    • Authors' interpretation: The authors note that tools that parse structured input will directly error at the parsing stage if they receive an unformatted traversal string, and a format-valid structured payload must be synthesized to reach the underlying filesystem call and expose the capability laundering path.

    Real-world case analysis and vulnerability disclosure (RQ3 & §5)

    • What was measured: Vulnerability analysis, three-case verification, and coordinated disclosure of real-world cases such as the Anthropic Git MCP Server.
    • Experimental results: 13 packages were disclosed, including two CVEs in the Anthropic Git MCP Server: CVE-2025-68143 (git_init did not restrict the repository creation path, allowing ~/.ssh to be turned into a repository and private keys to be leaked via diff; fixed in version 2025.9.25 by removing the tool) and CVE-2026-27735 (GitPython in git_add did not validate relative paths, allowing files outside the repository to be staged via ../ and leaked via diff; fixed in version 2026.1.14 by switching to invoking the Git CLI).
    • Authors' interpretation: The authors state that both vulnerabilities were exploited outside the legitimate workspace, and git_add was blocked by the sandbox in dynamic verification, returning an EPERM error, demonstrating that a minimal-privilege sandbox based on operating system process isolation can effectively protect against such out-of-contract risks.

    Other ablations and analyses

    • Static detection severity distribution: Among the 10,304 static detections, 61.8% were error level, 29.8% were warning level, and 8.4% were note level (§4.2).
    • Static rule category proportions: PT-001 missing validation accounted for 36.4%, PT-003 URL traversal 33.7%, PT-002 prefix matching 13.4%, PT-004 symlink 7.7%, PT-005 blacklist 6.8%, and long-tail rules 2.0% (Figure 4).
    • Language startup success rates: Among the 7,222 local open-source servers, the startup rate was 86.3% for Python, 72.7% for Node, 34.2% for C#/.NET, 23.5% for Go, and 11.9% for Rust (Figure 3b).
    • Disclosure basis distribution: Among the 13 disclosure packages, 11 were based on source mechanisms or configuration, and 2 were based on contract-implied scope boundaries (§4.4).
    • Non-credential disclosure verification methods: Among the 150 confirmed instances, 14 were adjudicated based on write side effects, response shape changes, or external CLI output (§4.3).
  5. What are some points that can be further explored?

    The authors note limitations such as dependence on runnable state, unquantified inferred boundaries, lack of write-destruction evaluation, and cross-tool chain mining; the paper does not report LLM versions or overhead details.

    Limitations and future directions noted by the authors

    • Dependence on runnable state and selected configuration: The authors note that the pipeline can only verify servers that can be installed and run, and dynamic results are conditioned on successful startup and the selected runtime configuration (§6.2).
    • Limited detection scope of dynamic verification: The authors note that dynamic verification may miss violations whose out-of-bounds effects never appear in responses, or that require runtime preconditions not reproduced by the test suite (§6.2).
    • Accuracy of inferred boundaries not measured: The authors note that the accuracy of the inferred boundaries themselves was not measured; overly strict policies would flag legitimate access, while overly permissive policies would miss vulnerabilities; future work needs to establish an expert-annotated benchmark to systematically quantify inference precision and recall (§6.2).
    • Unauthorized write operations not systematically covered: The authors note that although the effect model includes writes, the information-disclosure-oriented evaluation does not systematically measure unauthorized creation, modification, or deletion; evaluating such write operations requires filesystem state evidence (§6.2).
    • Cross-tool chained vulnerability mining not covered: The authors note that verification only covers selected tools and explicitly declared call sequences, and systematic automated discovery of cross-tool call chains was not implemented (§6.2).
    • Some stages depend on model judgment and model details are not fully reported: The authors note that stages such as category classification, rule classification, and policy drafting depend on LLM judgment and inherit the model's error patterns; systematic accuracy studies of these stages and complete reporting of model versions, prompts, and decoding settings are left for future work (§6.2).

    Experimental coverage

    • Ecosystem under test and corpus scale: Crawling covered 21,097 server entries across 9 registries, startup measurement covered 7,222 local open-source servers, the classification snapshot contained 4,806, static analysis covered 4,292, and dynamic three-case verification confirmed 150 instances.
    • Supported languages and distribution: In the post-measurement corpus, Node and Python accounted for 97%, and in sink-layer detections they accounted for 54.3% and 42.6% respectively, while other languages (Go, Rust, C#, etc.) together accounted for less than 3.1%.
    • Sandbox runtime environment: The dynamic verification test environment used nono v0.43.0 (Seatbelt sandbox) on macOS.
    • Manual annotation set scale: The static classification accuracy evaluation covered 300 tools for L2 and 297 detections for L3.
    • Unreported information: The paper does not report the specific LLM model versions, complete prompts, and decoding parameters used in the analysis stages, does not report the budget and specific number of queries for payload generation attempts, and does not report the specific time cost of each stage or inter-annotator agreement metrics.
  6. Summarize the main content of the paper

    The paper proposes a detection framework for filesystem capability laundering in local MCP servers, confirmed 150 vulnerable instances, and drove upstream patch fixes.

    This paper addresses the security risk caused by overly broad permissions of local service processes in the Model Context Protocol (MCP) ecosystem, and proposes a detection framework MCP-FSD that combines static analysis and dynamic validation.

    • Problem background: In the local stdio architecture, the client approval prompt only checks the declared parameters, while the underlying server runs with host user permissions; attackers can use untrusted input ingested by the agent to influence parameters, inducing benign tools to access sensitive files across boundaries, causing file system capability sanitization.
    • Core method: MCP-FSD builds a two-stage pipeline: first, static analysis identifies parameters and sinks, using four MCP-specific filters to screen candidates; then it infers the tool's minimum-privilege read/write scope from startup configuration, schema, and code; finally, using generated bare paths or structured payloads, it generates confirming evidence through three use-case replays: no-sandbox attack, sandbox benign, and sandbox attack.
    • Main findings:
      • Among 4,806 classified servers from 9 registries, 787 (16.4%) exhibited file system capability markers while lacking the FileSystem tag (Table 2);
      • Static analysis detected 10,304 defects on 2,818 flagged servers, of which missing path validation (PT-001) accounted for 36.4%, and the four categories of defense bypass rules together accounted for 61.6% (Figure 4);
      • The L2 tool-name classifier and L3 defense bypass classifier achieved Precision of 0.995 and 0.953 respectively on the manually labeled dataset (Table 1);
      • Dynamic three-use-case validation confirmed 150 vulnerable instances (96.0% used bare traversal paths, 4.0% required structured containers), of which 136 were verified through exact credential matching (§4.3, §4.6);
      • Responsible disclosure resulted in 13 security advisories, including two fixed CVEs in Anthropic's official Git MCP Server (CVE-2025-68143 and CVE-2026-27735).
    • Conclusion and implications: The authors believe that the widespread custom check defects in the ecosystem expose the lack of standard path restriction primitives in foundational libraries; relying only on client tool approval is insufficient to prevent capability overreach, and ecosystem-level registry screening combined with operating system process isolation must be combined to enforce each tool's minimum-privilege contract.
Read originalarxiv.org