Skip to content
Back to search

ramparts

MCP & SKILL scanner that scans any mcp server or skills for indirect attack vectors and security or configuration vulnerabilities. Aligned with OWASP SKILL Top 10 and OWASP MCP Top 10 threats & vulnerabilities.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/highflame-ai/ramparts with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/highflame-ai/ramparts'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/highflame-ai--ramparts/badge.svg)](/listings/highflame-ai--ramparts)

HTML

<a href="/listings/highflame-ai--ramparts"><img src="/api/listings/highflame-ai--ramparts/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

**Installation**

cargo install ramparts

Ramparts has two top-level scan surfaces. Pick whichever (or both) match what you're securing.

1. Scan MCP servers

# A specific MCP server (HTTP)
ramparts scan https://api.githubcopilot.com/mcp/ --auth-headers "Authorization: Bearer $TOKEN"

# stdio / subprocess MCP servers
ramparts scan "stdio:npx:mcp-server-commands"
ramparts scan "stdio:python3:/path/to/mcp_server.py"

# Auto-discover and scan every MCP server in your IDE configs
# (Cursor, Windsurf, VS Code, Claude Desktop, Claude Code, Cline)
ramparts scan-config

# Generate a detailed markdown report (scan_YYYYMMDD_HHMMSS.md)
ramparts scan-config --report

# Or walk a checked-in configs-only repo (great for CI)
ramparts scan-config --root ./ide-configs

2. Scan AI agent skills

# A single skill file or every *.md skill under a directory
ramparts skills scan ./.claude/commands

# An agentskills.io bundle directory — picks up SKILL.md +
# walks sibling scripts/ and references/ through YARA
ramparts skills scan ./my-skill-bundle

# Auto-discover skills across every supported ecosystem at the user
# and workspace level (.claude/, .cursor/, .codex/, .windsurf/,
# .gemini/, .openai/, ~/.skills/, probe-gated ./skills/).
# Add extra roots without rebuilding via RAMPARTS_SKILL_ROOTS=path1,path2.
ramparts skills scan-config

# SARIF output for code-scanning ingestion
ramparts skills scan ./.claude/commands --format sarif > skills.sarif

**Skill formats supported out of the box:**

- **Claude Code custom slash commands** — flat `.md` files under `.claude/commands/` (per-user and per-workspace) - **[agentskills.io](https://github.com/agentskills/agentskills) bundles** — `<name>/SKILL.md` directories with optional sibling `scripts/` (`.py` / `.sh` / `.bash` / `.zsh` / `.js` / `.mjs` / `.cjs` / `.ts` / `.rb` / `.pl` / `.ps1`), `references/` (`.md`), and `assets/`. Bundle mode also validates the spec's `name:` field against the parent directory name, the 1–64 char `[a-z0-9-]` rule, and surfaces name-vs-directory mismatches as HIGH-severity deception findings (`AgentskillsNameMismatch`). - **Cursor / OpenAI Codex / Windsurf / Gemini** skill repos that ship the same markdown + YAML frontmatter shape — supported via shared frontmatter fields and the per-ecosystem dotdir discovery roots.

> **💡 Did you know you can start Ramparts as a server?** Run `ramparts server` to get a REST API for continuous monitoring and CI/CD integration. See 📚 **[Ramparts Server Mode](docs/api.md)**

Run as an MCP server (stdio)

ramparts mcp-stdio

When publishing to Docker MCP Toolkit, configure the container command to `ramparts mcp-stdio` so the toolkit connects via stdio. Use `MCP-Dockerfile` to make this the default.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 241 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <div align="center">
  2. # Ramparts: security scanner for MCP servers and AI agent skills
  3. <img src="assets/ramparts.png" alt="Ramparts Banner" width="250" />
  4. *A fast, lightweight security scanner for the agent stack — Model Context Protocol (MCP) servers AND AI agent skills (Claude Code commands, [agentskills.io](https://github.com/agentskills/agentskills) bundles, Cursor / Codex / Windsurf / Gemini equivalents) — with built-in vulnerability detection.*
  5. [![Crates.io](https://img.shields.io/crates/v/ramparts)](https://crates.io/crates/ramparts)
  6. [![GitHub stars](https://img.shields.io/github/stars/highflame-ai/ramparts?style=social)](https://github.com/highflame-ai/ramparts)
  7. [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE)
  8. [![Rust](https://img.shields.io/badge/rust-1.70+-blue.svg)](https://www.rust-lang.org/)
  9. [![Tests](https://img.shields.io/github/actions/workflow/status/highflame-ai/ramparts/pr-check.yml?label=tests)](https://github.com/highflame-ai/ramparts/actions)
  10. [![Clippy](https://img.shields.io/github/actions/workflow/status/highflame-ai/ramparts/pr-check.yml?label=lint)](https://github.com/highflame-ai/ramparts/actions)
  11. [![Release](https://img.shields.io/github/release/highflame-ai/ramparts)](https://github.com/highflame-ai/ramparts/releases)
  12. </div>
  13. ## Overview
  14. **Ramparts** scans the two surfaces an AI agent trusts most: the **MCP servers** it talks to over the network, and the **skill files** it loads from disk and executes by name. Both deliver untrusted instructions and tool grants into the agent's loop; ramparts applies the same security pipeline (YARA, LLM analysis, OWASP MCP Top 10 tagging) to both.
  15. - **MCP scanning** covers the [Model Context Protocol](https://modelcontextprotocol.io) — the open standard that lets AI assistants connect to databases, file systems, and APIs via tool-calling. Ramparts discovers a server's tools/resources/prompts and audits them for prompt injection, tool poisoning, secret leakage, path traversal, command injection, cross-origin escalation, supply-chain CVEs (via OSV.dev), and more.
  16. - **Skill scanning** covers the markdown/YAML files an agent loads as named capabilities — Claude Code custom slash commands, Cursor / Codex / Windsurf / Gemini equivalents, and **first-class support for [agentskills.io](https://github.com/agentskills/agentskills) bundles** (`<name>/SKILL.md` directories with sibling `scripts/`, `references/`, `assets/`). Each skill body becomes a synthetic MCP prompt that runs through the same analyzers; bundled scripts get scanned through YARA, name-vs-directory mismatches surface as HIGH-severity deception findings, and the agentskills.io name/charset rules are validated.
  17. Ramparts is under active development. Read our [launch blog](https://www.getjavelin.com/blogs/ramparts-mcp-scan).
  18. ### The Security Challenge
  19. The MCP-and-skills attack surface is broad. MCP servers expose file systems, databases, APIs, and system commands — turning into attack vectors via tool poisoning, command injection, and data exfiltration without proper analysis. Agent skills carry the same risk profile (untrusted instructions an agent may follow) plus their own twists: skill-file `allowed-tools` grants that hand out unrestricted `Bash`, sensitive `@<path>` references that inline credentials into prompt context, name collisions that let one skill shadow another in the agent's router, and bundled scripts that ship arbitrary executable code. 📚 **[Security Features & Attack Vectors](docs/security-features.md)** documents every detector ramparts ships with — across both MCP and skill scanning.
  20. ### What Ramparts Does
  21. Ramparts provides **security scanning** of the MCP-and-skill ecosystem by:
  22. 1. **MCP server discovery & analysis** — scans MCP endpoints for tools/resources/prompts; multi-transport (HTTP, SSE, stdio, subprocess) with intelligent fallback and session management
  23. 2. **Skill scanning** — same threat model applied to agent skill files on disk (Claude Code commands, agentskills.io bundles incl. bundled `scripts/` + `references/`, Cursor / Codex / Windsurf / Gemini variants)
  24. 3. **Static analysis (YARA)** — 40 pre-scan rules across both surfaces: 10 skill-targeted rules (prompt-injection variants, credential harvesting, tool-chaining exfil, system manipulation, authority abuse, covert exfiltration) plus malware-IOC rules adapted from [NVIDIA SkillSpector](https://github.com/NVIDIA/SkillSpector) (cryptominers, reverse shells / C2 / info-stealers, webshells, offensive hack tools)
  25. 4. **Evasion-resistant rescan** — every YARA rule is also run over a normalized view (invisible/zero-width chars stripped, NFKC homoglyph folding) and iteratively base64/hex-decoded views, so a keyword split by zero-width characters, spelled in fullwidth homoglyphs, or hidden in an encoded blob still matches
  26. 5. **LLM-powered analysis** — sophisticated semantic issues no static rule can spot (tool descriptions that lie about behavior, sneaky permission requests, etc.)
  27. 6. **Cross-origin analysis** — detects tools spanning multiple domains, a context-hijacking / injection vector
  28. 7. **Supply-chain coverage** — queries OSV.dev for known CVEs in npx/uvx-launched stdio MCP servers and in exactly-pinned dependencies declared by skill bundles (`requirements.txt`, `package.json`)
  29. 8. **Rug-pull / drift detection** — content-fingerprints MCP server configs, individual tool definitions, and skill files against a stored baseline; flags any post-approval swap (`MCPConfigChanged` / `MCPToolChanged` / `SkillContentChanged`)
  30. 9. **Structural skill heuristics** — overbroad `allowed-tools` grants, vague/generic triggers, sensitive `@<path>` references, embedded base64/hex payloads, skill-name collisions, agent identity/memory-file writes, undeclared network egress (manifest-vs-script mismatch), external-reference inventory, unsafe-YAML-deserialization tags, brand impersonation, JSON prototype pollution, and an explicit incomplete-coverage finding when files are skipped
  31. 10. **agentskills.io spec validation** — directory-vs-`name:` mismatch (deception), spec name-rule violations, unknown frontmatter fields
  32. 11. **OWASP taxonomy tagging** — every finding mapped to the versioned **OWASP MCP Top 10**; skill-surface findings additionally carry **OWASP Agentic Skills Top 10** (`AST01`–`AST10`) tags. Visible in terminal, JSON, SARIF, and markdown report output
  33. 12. **Multiple output formats** — terminal, JSON, **SARIF 2.1.0** (for GitHub Advanced Security / GitLab / Azure DevOps), and a detailed markdown report
  34. >
  35. > **💡 Jump directly to detailed Rampart features?**
  36. > [**📚 Detailed Features**](docs/features.md)
  37. ## Who Ramparts is For
  38. - **MCP users** — scan third-party MCP servers before connecting; validate local servers before production
  39. - **MCP developers** — ensure your tools/resources/prompts don't expose vulnerabilities to AI agents
  40. - **Skill authors** — validate agentskills.io bundles against the spec before publishing; catch overbroad tool grants and sensitive-file references in your `.claude/commands/` or bundled `scripts/`
  41. - **Agent operators** — scan the skills your team has authored or installed; check that no bundle has been swapped under a deceptive directory name; surface findings in your existing SARIF/code-scanning workflow
  42. ## Use Cases
  43. - **Security audits** — full assessment of an MCP server's posture or a skill repo's safety
  44. - **Development** — fast feedback loop while building MCP servers or authoring skills
  45. - **CI/CD integration** — gate PRs that add skills or change MCP server configs (SARIF flows directly into GitHub code-scanning, GitLab, Azure DevOps)
  46. - **Compliance** — meet AI-agent deployment security requirements with OWASP MCP Top 10-tagged evidence
  47. > **💡 Caution**: Ramparts analyzes static metadata, configurations, and skill files. For comprehensive security, combine with runtime MCP guardrails and adopt a layered security approach. The MCP+skills threat landscape is rapidly evolving, and ramparts is not perfect — inaccuracies are inevitable.
  48. ## Quick Start
  49. **Installation**
  50. ```bash
  51. cargo install ramparts
  52. ```
  53. Ramparts has two top-level scan surfaces. Pick whichever (or both) match what
  54. you're securing.
  55. ### 1. Scan MCP servers
  56. ```bash
  57. # A specific MCP server (HTTP)
  58. ramparts scan https://api.githubcopilot.com/mcp/ --auth-headers "Authorization: Bearer $TOKEN"
  59. # stdio / subprocess MCP servers
  60. ramparts scan "stdio:npx:mcp-server-commands"
  61. ramparts scan "stdio:python3:/path/to/mcp_server.py"
  62. # Auto-discover and scan every MCP server in your IDE configs
  63. # (Cursor, Windsurf, VS Code, Claude Desktop, Claude Code, Cline)
  64. ramparts scan-config
  65. # Generate a detailed markdown report (scan_YYYYMMDD_HHMMSS.md)
  66. ramparts scan-config --report
  67. # Or walk a checked-in configs-only repo (great for CI)
  68. ramparts scan-config --root ./ide-configs
  69. ```
  70. ### 2. Scan AI agent skills
  71. ```bash
  72. # A single skill file or every *.md skill under a directory
  73. ramparts skills scan ./.claude/commands
  74. # An agentskills.io bundle directory — picks up SKILL.md +
  75. # walks sibling scripts/ and references/ through YARA
  76. ramparts skills scan ./my-skill-bundle
  77. # Auto-discover skills across every supported ecosystem at the user
  78. # and workspace level (.claude/, .cursor/, .codex/, .windsurf/,
  79. # .gemini/, .openai/, ~/.skills/, probe-gated ./skills/).
  80. # Add extra roots without rebuilding via RAMPARTS_SKILL_ROOTS=path1,path2.
  81. ramparts skills scan-config
  82. # SARIF output for code-scanning ingestion
  83. ramparts skills scan ./.claude/commands --format sarif > skills.sarif
  84. ```
  85. **Skill formats supported out of the box:**
  86. - **Claude Code custom slash commands** — flat `.md` files under
  87. `.claude/commands/` (per-user and per-workspace)
  88. - **[agentskills.io](https://github.com/agentskills/agentskills) bundles** —
  89. `<name>/SKILL.md` directories with optional sibling `scripts/` (`.py` / `.sh`
  90. / `.bash` / `.zsh` / `.js` / `.mjs` / `.cjs` / `.ts` / `.rb` / `.pl` / `.ps1`),
  91. `references/` (`.md`), and `assets/`. Bundle mode also validates the spec's
  92. `name:` field against the parent directory name, the 1–64 char
  93. `[a-z0-9-]` rule, and surfaces name-vs-directory mismatches as
  94. HIGH-severity deception findings (`AgentskillsNameMismatch`).
  95. - **Cursor / OpenAI Codex / Windsurf / Gemini** skill repos that ship the same
  96. markdown + YAML frontmatter shape — supported via shared frontmatter fields
  97. and the per-ecosystem dotdir discovery roots.
  98. > **💡 Did you know you can start Ramparts as a server?** Run `ramparts server` to get a REST API for continuous monitoring and CI/CD integration. See 📚 **[Ramparts Server Mode](docs/api.md)**
  99. ### Run as an MCP server (stdio)
  100. ```bash
  101. ramparts mcp-stdio
  102. ```
  103. When publishing to Docker MCP Toolkit, configure the container command to `ramparts mcp-stdio` so the toolkit connects via stdio. Use `MCP-Dockerfile` to make this the default.
  104. ## Example Output
  105. **Single server scan:**
  106. ```bash
  107. ramparts scan https://api.githubcopilot.com/mcp/ --auth-headers "Authorization: Bearer $TOKEN"
  108. ```
  109. ```
  110. RAMPARTS
  111. MCP Security Scanner
  112. Version: 0.7.0
  113. Current Time: 2025-08-04 07:32:19 UTC
  114. Git Commit: 9d0c37c
  115. 🌐 GitHub Copilot MCP Server
  116. ✅ All tools passed security checks
  117. └── push_files ✅ passed
  118. └── create_or_update_file ⚠️ 2 warnings
  119. │ └── 🟠 HIGH (LLM): Tool allowing directory traversal attacks
  120. │ └── 🟠 HIGH (YARA): EnvironmentVariableLeakage
  121. └── get_secret_scanning_alert ⚠️ 1 warning
  122. │ └── 🟠 HIGH (YARA): EnvironmentVariableLeakage
  123. Summary:
  124. • Tools scanned: 83
  125. • Security issues: 3 findings
  126. ```
  127. **IDE configuration scan:**
  128. ```bash
  129. ramparts scan-config --report
  130. ```
  131. ```
  132. 🔍 Found 3 IDE config files:
  133. ✓ vscode IDE: /Users/user/.vscode/mcp.json
  134. ✓ claude IDE: /Users/user/Library/Application Support/Claude/claude_desktop_config.json
  135. ✓ cursor IDE: /Users/user/.cursor/mcp.json
  136. 📁 vscode IDE config: /Users/user/.vscode/mcp.json (2 servers)
  137. └─ github-copilot [HTTP]: https://api.githubcopilot.com/mcp/
  138. └─ local-tools [STDIO]: stdio:python[local-mcp-server]
  139. 🌍 MCP Servers Security Scan Summary
  140. ────────────────────────────────────────────────────────────
  141. 📊 Scan Summary:
  142. • Servers: 2 total (2 ✅ successful, 0 ❌ failed)
  143. • Resources: 81 tools, 0 resources, 2 prompts
  144. • Security: ✅ All servers passed security checks
  145. 📄 Detailed report generated: scan_20250804_073225.md
  146. ```
  147. **Skill scan (agentskills.io bundle):**
  148. ```bash
  149. ramparts skills scan ./my-skill
  150. ```
  151. ```
  152. Path: ./my-skill
  153. ❌ 1 skill scanned, 4 findings (2 CRITICAL, 2 HIGH) · 0.6s
  154. ⚠️ evil-skill (4 findings)
  155. source: ./my-skill/SKILL.md
  156. [HIGH] SecretsLeakage in scripts/exfil.py [OWASP: MCP06, MCP09]
  157. Detects potential exposure of sensitive information like API keys, passwords, and tokens
  158. [CRITICAL] SSHKeyExposure in scripts/exfil.py [OWASP: MCP06]
  159. Detects SSH keys, authorized_keys files, and SSH configuration access
  160. [CRITICAL] SSHKeyExposure in references/api.md [OWASP: MCP06]
  161. Detects SSH keys, authorized_keys files, and SSH configuration access
  162. [HIGH] AgentskillsNameMismatch [OWASP: MCP02]
  163. SKILL.md declares `name: evil-skill` but its parent directory is `my-skill/`.
  164. agentskills.io requires the name to match the parent directory; the mismatch may
  165. indicate a deceptively-named bundle.
  166. ```
  167. (`AgentskillsNameMismatch` is from agentskills.io spec validation; the
  168. `SecretsLeakage` / `SSHKeyExposure` rows are bundled-script YARA findings —
  169. ramparts walked `scripts/exfil.py` and `references/api.md` automatically.)
  170. ## Contributing
  171. We welcome contributions to Ramparts. If you have suggestions, bug reports, or feature requests, please open an issue on our GitHub repository.
  172. ## Documentation
  173. - 📖 **[CLI Reference](docs/cli.md)** — All commands (scan, scan-config, skills scan, skills scan-config, replay, server, mcp-stdio), options, and usage examples
  174. - 🛡️ **[Security Features & Attack Vectors](docs/security-features.md)** — Every detector ramparts ships with, across MCP + skill scanning
  175. - ⚙️ **[Configuration Reference](docs/configuration.md)** — Complete config file documentation + skill discovery root config
  176. - 🔍 **[Troubleshooting Guide](docs/troubleshooting.md)** — Solutions to common issues
  177. - 📚 **[Detailed Features](docs/features.md)** — How each capability works under the hood
  178. ## Additional Resources
  179. - [Need Support?](https://github.com/highflame-ai/ramparts/issues)
  180. - [MCP Protocol Documentation](https://modelcontextprotocol.io/)
  181. // Examples folder was removed to reduce branch diff; see configuration docs instead.
  182. - [Configuration Guide](docs/configuration.md)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.