Que fait Audit des serveurs MCP pour l'empoisonnement d'outils ?
Avis d'utilisation autorisée uniquement : L'audit des serveurs MCP peut se connecter et sonder les points de terminaison d'outils en direct. Scannez uniquement les serveurs dont vous êtes propriétaire ou que vous êtes autorisé à évaluer. Traitez les descriptions d'outils scannées comme des entrées non fiables — ne chargez pas un serveur MCP non audité dans un agent privilégié. Sonder des points de terminaison MCP tiers pour des faiblesses SSRF ou d'authentification sans autorisation peut être illégal.
Présentation
Le Model Context Protocol (MCP) permet aux agents IA de découvrir et d'appeler des outils externes annoncés par des serveurs MCP. Chaque outil expose un nom et une description en langage naturel que le LLM de l'agent lit avant de décider de l'appeler. Début 2025, Invariant Labs a révélé que ce champ de description est une surface d'attaque : un serveur malveillant peut intégrer des instructions cachées dans la description d'un outil (une attaque par empoisonnement d'outil, OWASP MCP03:2025), et un modèle capable les suivra silencieusement — exfiltration de fichiers, fuite de secrets, ou redirection d'appels d'outils — tout en renvoyant une réponse d'apparence normale à l'utilisateur. Étant donné que les descriptions d'outils sont chargées dans le contexte de l'agent, l'empoisonnement d'outil est effectivement une injection de prompt indirecte via la chaîne d'approvisionnement (MITRE ATLAS AML.T0010 ML Supply Chain Compromise).
Au-delà de l'empoisonnement, les serveurs MCP introduisent des risques d'infrastructure classiques : shadowing d'outils (un serveur malveillant remplace le comportement d'un outil de confiance), rug pulls (la description d'un outil change après approbation par l'utilisateur), flux toxiques (une combinaison d'outils permettant l'exfiltration de données), SSRF dans les outils qui récupèrent des URL côté serveur, et exposition non authentifiée de serveurs MCP liés à des interfaces réseau. Cette compétence audite les serveurs MCP de bout en bout à l'aide du mcp-scan d'Invariant Labs pour l'analyse statique et dynamique, ainsi que des vérifications manuelles pour le SSRF et l'authentification, et du hachage d'outils pour détecter les rug pulls.
Quand l'utiliser
- Avant d'ajouter un nouveau serveur MCP à une pile d'agents (Claude Desktop, Cursor, VS Code, Windsurf, agents personnalisés).
- Lors d'une revue de sécurité d'un serveur MCP développé en interne.
- Lors de la validation que des outils approuvés n'ont pas silencieusement changé (détection de rug pull).
- Comme barrière CI/CD qui scanne les configurations MCP et les définitions SKILL/outil à chaque modification.
- Lors de la réponse à incident lorsqu'un agent a pris des actions inattendues compatibles avec un outil empoisonné.
Prérequis
- Python 3.10+ et
uv(pouruvx), ou pip. - Le(s) fichier(s) de configuration MCP que vous souhaitez scanner (par ex.
~/.cursor/mcp.json,~/.vscode/mcp.json, configuration Claude Desktop). - Installer les outils :
# uv fournit uvx (exécuteur recommandé pour mcp-scan)
curl -LsSf https://astral.sh/uv/install.sh | sh # ou : pipx install uv
# mcp-scan (Invariant Labs) — pas d'installation globale nécessaire avec uvx
uvx mcp-scan@latest --help
# Pour le mode proxy runtime (extension séparée)
uvx --with "mcp-scan[proxy]" mcp-scan@latest proxy --help
# Aides au sondage manuel
pip install requests mcp
Objectifs
- Scannez statiquement tous les serveurs MCP installés pour détecter l'empoisonnement d'outils, le shadowing, les rug pulls et les flux toxiques.
- Inspectez les descriptions brutes d'outils/prompts/ressources pour détecter des instructions cachées ou obscurcies.
- Figez les hachages des outils pour détecter les changements de description post-approbation (défense anti-rug pull).
- Testez les outils de récupération d'URL pour la falsification de requête côté serveur (SSRF).
- Vérifiez que les serveurs MCP sont authentifiés et non exposés sur des interfaces non fiables.
- Appliquez éventuellement des garde-fous runtime avec le proxy mcp-scan.
Cartographie MITRE ATT&CK
| ID | Nom officiel | Pertinence |
|---|---|---|
| AML.T0010 | ML Supply Chain Compromise | Un serveur MCP tiers empoisonné est une compromission de la chaîne d'approvisionnement de l'agent |
| AML.T0051.001 | LLM Prompt Injection: Indirect | Les descriptions d'outils empoisonnées sont une injection indirecte dans le contexte de l'agent |
| AML.T0053 | LLM Plugin Compromise | Les outils MCP sont les plugins de l'agent ; l'empoisonnement les compromet |
| AML.T0057 | LLM Data Leakage | Charge utile courante d'un outil empoisonné : exfiltrer des fichiers/secrets |
Déroulement
1. Analyse statique des configurations MCP installées
mcp-scan découvre automatiquement les emplacements de configuration connus ; vous pouvez aussi passer un chemin explicitement.
# Scanner toutes les configurations MCP découvertes automatiquement
uvx mcp-scan@latest
# Scanner un fichier de configuration spécifique
uvx mcp-scan@latest ~/.vscode/mcp.json
# Émettre du JSON lisible par machine pour CI
uvx mcp-scan@latest --json ~/.cursor/mcp.json > mcp_scan_report.json
mcp-scan signale l'empoisonnement d'outils, le shadowing d'outils, l'escalade cross-origin, les rug pulls et les flux toxiques.
2. Inspecter les descriptions brutes d'outils
Affichez chaque description d'outil/prompt/ressource sans vérification, puis lisez-les pour détecter des instructions cachées, des blocs <important> ou du texte impératif destiné au modèle.
uvx mcp-scan@latest inspect ~/.cursor/mcp.json
Recherchez des signaux d'alarme : instructions à l'assistant ("ne dis pas à l'utilisateur", "lis ~/.ssh/id_rsa"), fausse documentation imbriquée, texte à largeur nulle/contrebande Unicode, ou directives pour appeler d'autres outils.
3. Figez les hachages des outils pour détecter les rug pulls
mcp-scan suit les hachages des descriptions d'outils afin qu'un changement silencieux ultérieur soit signalé. Exécutez des scans régulièrement ; un hachage différent sur un outil précédemment approuvé indique un rug pull.
# Réexécutez régulièrement ; mcp-scan signale les hachages d'outils modifiés depuis la dernière approbation
uvx mcp-scan@latest ~/.cursor/mcp.json
4. Énumérer les outils par programme et auditer les métadonnées
Connectez-vous au serveur avec le SDK MCP officiel et inspectez le schéma annoncé directement.
# enumerate_tools.py (exemple de serveur MCP stdio)
import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
async def main():
params = StdioServerParameters(command="node", args=["./suspect-mcp-server.js"])
async with stdio_client(params) as (read, write):
async with ClientSession(read, write) as session:
await session.initialize()
tools = await session.list_tools()
for t in tools.tools:
print(f"{t.name}: {len(t.description or '')} chars")
print((t.description or "")[:400])
asyncio.run(main())
5. Tester les outils de récupération d'URL pour le SSRF
Si un outil accepte une URL et la récupère côté serveur, essayez d'atteindre des cibles internes de métadonnées/loopback (uniquement sur les systèmes dont vous êtes propriétaire).
# ssrf_probe.py
import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
SSRF_TARGETS = [
"http://169.254.169.254/latest/meta-data/", # AWS IMDS
"http://127.0.0.1:22/", "http://localhost:6379/", "file:///etc/passwd",
]
async def main():
params = StdioServerParameters(command="node", args=["./suspect-mcp-server.js"])
async with stdio_client(params) as (r, w):
async with ClientSession(r, w) as s:
await s.initialize()
for url in SSRF_TARGETS:
res = await s.call_tool("fetch_url", {"url": url})
body = str(res.content)[:200]
print(f"[SSRF?] {url} -> {body}")
asyncio.run(main())
6. Vérifier l'authentification et l'exposition réseau
Vérifiez que les serveurs MCP distants (transport HTTP/SSE) nécessitent une authentification et ne sont pas liés à 0.0.0.0 sur des réseaux non fiables.
# Confirmer si un point de terminaison MCP SSE/HTTP répond sans informations d'identification
curl -s -i http://mcp-host:8000/sse | head -n 20
# Vérifier les interfaces d'écoute d'un serveur MCP exécuté localement
ss -tlnp | grep -E ':(8000|3000|6277)'
Un point de terminaison MCP qui renvoie des listes d'outils ou accepte tools/call sans authentification est une exposition non authentifiée — corrigez avec un jeton/OAuth et liez à localhost ou à une passerelle authentifiée.
7. Appliquer des garde-fous runtime (facultatif)
Pour une protection continue, acheminez le trafic MCP de l'agent via le proxy mcp-scan, qui vérifie les appels d'outils, les contraintes de flux de données, les PII et l'injection indirecte en temps réel.
uvx --with "mcp-scan[proxy]" mcp-scan@latest proxy
8. Rapporter les résultats
Documentez chaque résultat avec le serveur, l'outil, la preuve (la description empoisonnée / la réponse SSRF / la liste non authentifiée), la sévérité et la cartographie ATLAS. Recommandez la suppression ou le sandboxing des serveurs empoisonnés, l'ajout d'authentification, le hachage des outils approuvés et l'activation du proxy.
Outils et ressources
| Outil | Objectif | Source |
|---|---|---|
| mcp-scan | Scanner de sécurité MCP statique + runtime | https://github.com/invariantlabs-ai/mcp-scan |
| SDK Python MCP | Énumération / appels d'outils par programme | https://github.com/modelcontextprotocol/python-sdk |
| OWASP MCP Top 10 | Référence des risques MCP (MCP03 Tool Poisoning) | https://owasp.org/www-project-mcp-top-10/ |
| Blog Invariant Labs | Divulgation de l'empoisonnement d'outils | https://invariantlabs.ai/blog/introducing-mcp-scan |
| MITRE ATLAS | Taxonomie des techniques de menace IA | https://atlas.mitre.org/ |
Référence des menaces MCP
| Menace | Description | Détection |
|---|---|---|
| Empoisonnement d'outil | Instructions cachées dans la description de l'outil | scan mcp-scan / inspect |
| Shadowing d'outil | Un serveur malveillant remplace un outil de confiance | Vérifications cross-origin mcp-scan |
| Rug pull | Changement de description après approbation | Hachage d'outil mcp-scan (hash) |
| Flux toxique | Combinaison d'outils permettant l'exfiltration | Analyse de flux toxique mcp-scan |
| SSRF | Un outil de récupération d'URL atteint des cibles internes | ssrf_probe contre le serveur possédé |
| Exposition non authentifiée | Point de terminaison MCP sans authentification | curl/ss interface et vérification d'authentification |
Critères de validation
- Toutes les configurations MCP installées scannées statiquement avec mcp-scan
- Descriptions brutes d'outils/prompts/ressources inspectées pour des instructions cachées
- Hachages d'outils figés et détection de rug pull activée
- Outils énumérés par programme via le SDK MCP
- Outils de récupération d'URL testés pour SSRF contre des cibles possédées
- Authentification et exposition réseau des serveurs distants vérifiées
- Garde-fous proxy runtime évalués ou déployés là où approprié
- Résultats cartographiés vers MITRE ATLAS AML.T0010 et OWASP MCP03:2025
- Sévérité attribuée et correction documentée pour chaque résultat
- Nouveau scan planifié pour détecter les futurs rug pulls