Scan Claude Code Skills Plugins MCP Security Risks
The short answer: treat Claude Code skills, plugins, hooks, and MCP servers as executable supply chain dependencies. Do not approve them as simple prompt packs.
That is the approval model security and platform teams need because a Claude Code plugin can include more than written instructions. Anthropic's plugin documentation says a plugin can bundle skills, agents, hooks, hook modules, and MCP servers, while a .mcp.json file can add MCP tools to a session. Anthropic Support also notes that plugins installed through claude.ai sync run on the user's computer, including skills, sub-agents, hooks, and MCP servers.
The practical implication is simple: scanning only the manifest or the skill text is not enough. You need to scan Claude Code skills plugins MCP security risks across the full bundle, then keep watching after approval.
Start with the coverage gap
Anthropic's enterprise skill and plugin scanning is useful, but it is not a complete security review. According to Anthropic Support, the scanner covers third-party uploaded skills and plugins plus bundled skills, but it does not cover existing installs, MCP servers, hooks, MCP-shared skills, API-uploaded skills, or organizations using CMEK, ZDR, or HIPAA configurations.
That gap matters because hooks and MCP servers are two of the most sensitive surfaces. Anthropic's hooks reference says command hooks execute shell commands with the user's full permissions and can access, change, or delete files available to that user account. Anthropic's MCP documentation says plugin-provided MCP servers start automatically when the plugin is enabled and behave like manually configured servers.
So the first policy rule should be explicit: official scanning is one input, not the approval decision. MCP servers and hooks need manual review, sandbox testing, and ongoing controls.
Related reading: Claude Code plugin security checklist.
Inventory every component before approval
A preinstall review should begin with an inventory, not a verdict. The reviewer should list every component the bundle ships or pulls at runtime:
.claude-plugin/plugin.jsonand other plugin metadata.mcp.jsonfiles and MCP server definitions- skills, commands, agents, and model-visible instructions
- hooks and hook modules, including event scope
- scripts, package manifests, lockfiles, and transitive installs
- hidden directories and hidden configuration files
- external URLs, update channels, package registries, and mutable Git refs
- OAuth scopes, local tokens, credential access, and network calls
This matches the direction in Anthropic's curated plugin review policy, which expects reviewers to inspect plugin manifests, MCP configuration, hooks, skills, agents, commands, scripts, hidden dot directories, examples, tests, and source files such as JavaScript, TypeScript, Python, shell, and Go files.
In practice, the risky pattern is rarely one file by itself. It is the combination. A plugin that reads files is different from a plugin that reads files and can make network calls. A GitHub MCP server with private repository access is different from one that can also write to public repositories. An email sender is different from an email sender that reads untrusted web content first.
Review capability combinations, not single tools
MCP review should be based on capability paths. The MCP project's security guidance places responsibility on operators to connect only trusted servers, review configurations, understand capabilities, and configure restrictions. Local MCP servers should be treated like installed software.
That means an allowlist of individual servers is not enough. Build an approval matrix around combinations such as:
- filesystem access plus network access
- private repository reader plus public repository writer
- email sender plus untrusted content reader
- browser or scraper plus credential-bearing APIs
- broad shell execution plus permission-skipping flags
- model-visible instructions plus host-side tool execution
OWASP's MCP Security Cheat Sheet highlights related threat categories, including tool poisoning, rug pulls, cross-server or tool shadowing, and local execution risks. The MCP skills extension specification adds another important warning: MCP-served skill content can instruct the model to execute host-side tools, so hosts should treat skill content as untrusted and should not honor permission-widening frontmatter without explicit approval.
Related reading: MCP security for AI agents.
Know the threats you are screening for
The review should be concrete enough to catch known classes of failure.
Tool poisoning. Invariant Labs described MCP tool poisoning as hidden, model-visible instructions that can exfiltrate sensitive data or override trusted-server behavior. This is not a normal dependency vulnerability where the dangerous code is always obvious to a package scanner. The harmful instruction can live in a description or tool response the model sees.
Untrusted content driving trusted tools. Invariant Labs demonstrated a GitHub MCP exploit in which malicious public issue content could hijack an agent connected to GitHub MCP and leak private repository data through an autonomously created pull request.
Malicious package updates. The Hacker News reported that a malicious postmark-mcp package version, 1.0.16, copied emails by adding a BCC line and was downloaded 1,643 times before deletion.
Command execution vulnerabilities. CVE-2025-6514 is described as a critical OS command injection issue in mcp-remote through untrusted MCP server authorization endpoint handling, with CVSS 9.6. The research brief flags this as a secondary CVE summary that should be verified against NVD or a vendor advisory before publication-grade vulnerability claims.
Unsafe coding-agent configuration. A 2026 arXiv preprint by Benjamin Kapner and coauthors studied 3,171 public repositories and reported that 16.0% of multi-component AI coding-agent setups had confirmed security defects, including unpinned MCP server installs and dangerous shell pre-approvals. Treat the paper as a useful signal, with the normal caveat that it is a preprint.
Use a preinstall checklist
A practical approval gate can be short, but it must cover the real attack surface.
1. Verify provenance
Check maintainer identity, release history, package registry ownership, source repository history, signed releases or provenance where available, and whether the install path depends on mutable references. Treat npx -y, uvx, install scripts, unpinned versions, and branch-based Git installs as review blockers until someone explains and pins them.
2. Inspect execution paths
Review scripts, hooks, hook modules, shell commands, package lifecycle scripts, and any code that runs during install, activation, session start, tool use, prompt submission, or stop events. For Claude Code hooks, check whether they run globally or only in specific projects, and which events they bind to, such as UserPromptSubmit, PreToolUse, PostToolUse, SessionStart, Stop, and SubagentStop.
3. Check permissions and grants
Review allowed-tools and permission grants for deceptive narrowness. Look closely at broad Bash, Bash(python:*), mcp__server__*, file-read plus network access, and permission-skipping flags. A narrow-looking grant can still become broad when paired with a shell, interpreter, or write-capable MCP server.
4. Review MCP configuration
Map each MCP server to its data sources, tools, authentication model, network behavior, and downstream systems. Anthropic warns that MCP servers can read or act on external systems directly, and that servers fetching external content can expose prompt-injection risk. For remote MCP OAuth, pin scopes with oauth.scopes, validate redirect and OAuth metadata, and avoid broad tokens.
5. Look for credential and data movement risks
Flag hardcoded credentials, plaintext tokens, broad filesystem access, unrestricted network calls, and any path that allows sensitive files to leave the host. Anthropic's enterprise skill guidance treats skill code execution, MCP server references, network calls, hardcoded credentials, broad filesystem access, and file-read plus network combinations as high-risk review items.
6. Require rollback
Every approval should have a rollback plan. Record the approved version, hashes where available, registry source, expected MCP tools, expected OAuth scopes, and the owner responsible for disabling or replacing the bundle if behavior changes.
Scanning should continue after approval
Preinstall review catches only what is visible at the time of review. MCP and plugin risk can change later through package updates, remote server behavior, changed tool definitions, OAuth scope drift, or new combinations with other approved tools.
For ongoing governance, platform teams should keep an approved registry or allowlist, pin versions and hashes where possible, run unfamiliar plugins inside sandboxed Claude Code sessions or devcontainers, and monitor for drift in runtime MCP tool definitions. Anthropic's Claude Security Plugin documentation says scans run under the user's session permissions and do not add isolation by themselves, so sandboxing has to come from the environment around the session.
Runtime controls should answer four questions:
- Did the installed bundle match the approved bundle?
- Did the MCP server expose the same tools reviewed at approval time?
- Did permissions, OAuth scopes, or network destinations change?
- Can the team disable the plugin, MCP server, or hook quickly if needed?
Community scanners such as MCP-Scan, MCPRadar, and MCPhound may help with parts of this process, but the research brief notes that their claims should be validated against known-bad samples before they become policy gates. Use them as inputs, not as the only control.
A workable approval standard
A good standard does not need to ban Claude Code extensions. It needs to make risk visible before a developer's laptop becomes the policy boundary.
Approve a Claude Code plugin, skill, hook, or MCP server only when the team has:
- inventoried the full bundle and runtime install path
- reviewed hooks, MCP servers, scripts, hidden files, and package dependencies
- mapped capability combinations across tools, data sources, and write targets
- pinned versions, scopes, and expected runtime tool definitions where possible
- tested unfamiliar bundles in a sandboxed environment
- documented ownership, monitoring, and rollback
The core rule is straightforward: if a bundle can instruct the model, execute code, read files, call APIs, or modify external systems, it belongs in the same review lane as other developer supply chain dependencies. Anthropic's scanner can help, but the approval decision has to cover the surfaces the scanner does not: MCP servers, hooks, runtime behavior, and dangerous capability combinations.