More screenshots
Works with the AI Agents you already use
MCP Security Auditor
Audit MCP servers for security risks and get a scored, prioritized production-readiness report.
$14.99
MCP Security Auditor
Example session with this skill installed
Audit this MCP server for production security risks.
The server exposes these tools
-
run_command(command)
Executes the supplied command on the host operating system. -
read_file(path)
Reads a file from the server filesystem. -
fetch_url(url)
Fetches content from any URL supplied by the caller. -
get_customer(id)
Retrieves customer information from a shared database.
The server runs with a production service account. I don't see any per-tool authorization checks in the code. Please perform a complete MCP security audit, identify the most serious risks, calculate a 0–100 security score, provide remediation steps, and tell me whether this server is ready for production.
- Read your context and instructions
- Compiled the mcp security auditor
MCP Security Audit
Executive Summary
Overall Risk: CRITICAL
Security Score: 0/100
Production Readiness: 🔴 NOT READY
The reviewed MCP server exposes several high-impact capabilities without visible authorization boundaries or sufficient restrictions. The most serious issue is arbitrary operating-system command execution through run_command(command), which can provide complete control of the server with the privileges of the production service account.
Additional risks include unrestricted filesystem access, unrestricted outbound URL fetching, and insufficient evidence of per-user authorization for customer data.
Immediate remediation is recommended before production deployment.
Attack-Surface Summary
| Tool | Capability | Primary Risk |
|---|---|---|
run_command | OS command execution | Arbitrary code execution |
read_file | Filesystem access | Sensitive file disclosure |
fetch_url | Outbound HTTP | SSRF/internal network access |
get_customer | Customer database access | Authorization/data exposure |
Critical Findings
[MCP-001] Arbitrary Command Execution
- Severity: CRITICAL
- Confidence: CONFIRMED
- Category: Command execution
- Affected component:
run_command - Evidence: The tool accepts a caller-controlled command and executes it on the host.
- Risk: A caller may execute arbitrary operating-system commands with the privileges available to the MCP server.
- Attack path: MCP client →
run_command→ shell/OS → server resources.
Recommended fix: Remove arbitrary shell execution. Replace it with narrowly scoped, allowlisted operations that expose only the required functionality.
Verification: In an isolated test environment, attempt representative disallowed commands and confirm that arbitrary execution is impossible.
- Priority: Immediate
High Findings
[MCP-002] Unrestricted Filesystem Access
- Severity: HIGH
- Confidence: CONFIRMED
- Category: Filesystem security
- Affected component:
read_file - Evidence: The tool accepts a filesystem path without a demonstrated allowlist or sandbox.
Risk: Sensitive application files, configuration files, credentials, or other host data could potentially be disclosed.
Recommended fix: Restrict access to an application-owned directory, canonicalize paths, reject traversal, and apply filesystem permissions or sandboxing.
Verification: Test normal paths, absolute paths, parent-directory traversal, encoded traversal, and symlink cases.
[MCP-003] Unrestricted Outbound URL Fetching
- Severity: HIGH
- Confidence: CONFIRMED
- Category: SSRF/network security
- Affected component:
fetch_url - Evidence: Arbitrary URLs are accepted from the caller.
Risk: The server may be abused to access internal services or other network destinations that should not be reachable.
Recommended fix: Apply destination allowlists, safe URL parsing, redirect restrictions, network egress controls, and appropriate timeouts.
- Verification: In a controlled environment, verify that unauthorized private/internal destinations are rejected.
[MCP-004] Missing Demonstrated Per-User Authorization
- Severity: HIGH
- Confidence: LIKELY
- Category: Authorization
- Affected component:
get_customer - Evidence: The supplied description states that per-tool authorization checks are not visible.
- Risk: One caller may potentially retrieve customer information belonging to another user or tenant.
Recommended fix: Enforce authorization server-side for every customer-data operation and derive identity from a trusted authentication mechanism rather than caller-supplied identifiers.
- Verification: Test authorized and unauthorized customer/tenant combinations.
Priority Remediation Plan
1. Remove unrestricted command execution
This is the highest-risk capability and should be eliminated or replaced with tightly scoped operations.
2. Establish server-side authorization
Every privileged tool should enforce authorization independently of client claims.
3. Restrict filesystem access
Implement an explicit filesystem boundary and reject traversal or symlink escapes.
4. Restrict outbound networking
Prevent arbitrary destinations and apply network-level egress controls.
5. Reduce production-service privileges
The MCP server should operate with the minimum permissions required for its intended functions.
Verification Plan
After remediation
- Test every privileged tool with an unauthorized identity.
- Test filesystem traversal and symlink escape attempts.
- Test blocked internal/private network destinations.
- Verify arbitrary shell commands cannot be executed.
- Test cross-tenant customer-data access.
- Confirm credentials are not returned through tool output or logs.
- Re-run the complete MCP security audit.
Production Decision
🔴 NOT READY FOR PRODUCTION
The unrestricted command execution capability alone represents a critical production risk. The server should not be deployed until the critical issue and authorization/network/filesystem risks have been remediated and independently verified.
Next action: Remediate the critical and high-priority findings, then perform a complete verification audit.
Connects securely to your tools. The creator never sees your data.
About this skill
MCP Security Auditor performs a structured security review of Model Context Protocol servers and integrations. It analyzes exposed tools, authorization, least privilege, input validation, injection risks, filesystem and network access, data exposure, dependencies, transport security, logging, deployment, and abuse resistance.
The skill produces an evidence-based 0–100 security score, severity-ranked findings, realistic attack paths, practical remediation steps, verification guidance, and a clear production-readiness decision.
Designed for developers and AI-agent builders who want to identify security weaknesses before deploying an MCP server to production.
This is an AI-assisted security review workflow and does not replace professional penetration testing, formal certification, or dedicated security scanning.
Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Security.
- This is a document-based review, not a live test. It analyzes the code, configs, and descriptions you give it — it does not connect to or run your MCP server, and it never executes code against a live system.
- Not a substitute for a penetration test or formal certification. Use this as a fast, structured first-pass review. For compliance sign-off (SOC 2, PCI-DSS, etc.) or a legally defensible security assessment, you still need a qualified security professional.
- No live vulnerability database. Dependency findings are based on what's visible in your manifests and lockfiles, not real-time CVE intelligence. It won't invent a vulnerability that isn't there — but it also won't catch a newly disclosed one that a live scanner would.
- Only as thorough as what you provide. Redacted code, missing configs, or partial context get explicitly flagged as evidence gaps rather than guessed at — so an incomplete submission means an incomplete audit, clearly labeled as such.
- No exploit attempts, ever. Even when a finding looks exploitable, it recommends how to verify it safely rather than trying it — it will not run disallowed commands or probe your live infrastructure.
- The security score is this tool's own scale, not an industry standard. It's a 0–100 prioritization aid based on a fixed formula — it is not CVSS and isn't meant to be compared directly against other tools' scores.
Report only — no auto-fix. You get a structured findings report with recommended fixes; it doesn't patch code, open 7. tickets, or integrate with your existing workflow.
How to use
- 1
Connect your agent to the Agensi MCP
Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup
- 2
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads this skill and uses it on your task. It always asks before buying a skill.
Reviews
No reviews yet
Be one of the first to try it. Every listed skill goes through the trust checks below.
Security scanned
Checked by our 8-point scan before listing
Fresh listing
Recently published to Agensi
Money-back guarantee
Doesn't do what its page promises? You get your money back.
Trust & safety
Security scan
Security scan passed 2 months ago
- Software
- 001 MCP002 MCP
Permissions
No special permissions declared or detected