Menu
Mais Encore

Security musings

Model Context Protocol (MCP) : Ouvrir son système sans se faire pirater

Catégories

Tags

🔍 Licence d'Utilisation 🔍

Sauf mention contraire, le contenu de ce blog est sous licence CC BY-NC-ND 4.0.

© 2025 à 2042 Sébastien Gioria. Tous droits réservés.

Le Model Context Protocol (MCP), poussé par des acteurs comme Anthropic, promet de résoudre le problème de l’isolation des données des IA. L’idée est de créer un standard (comme l’USB-C pour les LLM) permettant à une IA de se “brancher” à votre Google Drive, votre Slack, ou votre système de fichiers local.

Cependant, d’un point de vue sécurité, installer un serveur MCP revient à ouvrir une API sur vos données personnelles. Si cette API est mal sécurisée, n’importe quelle IA (ou attaquant contrôlant l’IA) peut siphonner vos données.

Le Risque Structurel : Path Traversal et SSRF

Le modèle MCP repose sur une architecture Client (l’IA) / Serveur (la Source de données).

Exemple de compromission : Vous installez un serveur MCP local “Simple Filesystem” pour permettre à Claude d’analyser vos projets de code. Si ce serveur MCP est mal configuré et n’impose pas de “chroot” (confinement de dossier), une IA manipulée par un prompt malveillant pourrait demander : read_file(path: "../../../.ssh/id_rsa")

Si le serveur MCP obéit aveuglément, il renvoie votre clé privée à l’IA, qui peut ensuite l’afficher ou l’envoyer ailleurs. C’est une vulnérabilité classique de Path Traversal.

Analyse STRIDE

Menace (STRIDE) Détail technique & Impact
Spoofing Rogue Server : Un attaquant vous fait installer un serveur MCP tiers (via un npx ou pip install) qui prétend être un outil de productivité, mais qui est en réalité un spyware enregistrant toutes les requêtes de l’IA.
Tampering Data Manipulation : Man-in-the-Middle entre l’IA et le serveur MCP. L’attaquant modifie les données lues par l’IA pour fausser son raisonnement (ex: changer les apis a appeler avant que l’IA ne les utilise dans votre code.
Repudiation No Logging : La plupart des serveurs MCP actuels (“alpha stage”) n’ont pas de logs d’audit robustes. Impossible de savoir quel fichier a été accédé et quand.
Info Disclosure Le risque critique. Exposition accidentelle de fichiers sensibles (/etc/shadow, .bash_history) via une configuration trop permissive (root_dir: /).
Denial of Service Resource Locking : L’IA lance des milliers de lectures simultanées sur un fichier, le verrouillant pour les autres applications ou saturant les I/O disque.
Elevation of Privilege Exploitation d’une faille dans le code du serveur MCP (souvent écrit en Python/Nodejs) pour exécuter du code arbitraire sur la machine hôte hébergeant le serveur.

Guide de Durcissement (Hardening) pour MCP

Si vous devez utiliser des MCP, suivez ce protocole strict de 8 règles essentielles :

1. Principe du Moindre Privilège (Least Privilege)

Ne donnez jamais de droits d’écriture à un serveur MCP sauf nécessité absolue critique.

Configuration recommandée :

{
  "mcpServers": {
    "filesystem": {
      "command": "mcp-server-filesystem",
      "args": ["--readonly", "--path", "/Users/moi/dev/projet-x"]
    }
  }
}

Justification : Si l’IA doit modifier du code, elle doit vous proposer un diff que vous appliquez manuellement (via git apply ou review dans l’IDE), et non modifier le fichier directement. Cela maintient un contrôle humain sur toute modification du code source.

Exemple de refus : Si le serveur MCP tente une opération d’écriture en mode lecture seule, il doit retourner une erreur HTTP 403 ou une exception claire que l’IA comprend.

2. Whitelisting de Chemins (Path Confinement)

Ne lancez jamais un MCP sur votre dossier utilisateur racine (~) ou pire, sur /.

Mauvaises pratiques à éviter :

# ❌ DANGER : Accès à tout le système
mcp-server start --dir /

# ❌ DANGER : Accès à tous vos fichiers personnels
mcp-server start --dir /Users/moi

Bonne pratique :

# ✅ Confinement strict au projet
mcp-server start --dir /Users/moi/dev/projet-x

# ✅ Encore mieux : avec une jail explicite
mcp-server start --dir /Users/moi/dev/projet-x --jail --no-symlinks

Configuration avancée : Utilisez des options comme --no-symlinks pour empêcher les attaques par liens symboliques qui pourraient contourner le confinement du répertoire.

3. Validation et Audit des Serveurs Tiers

L’écosystème MCP est un “Far West” technologique. Des listes “Awesome MCP” fleurissent sur GitHub, mais toutes ne sont pas dignes de confiance.

Checklist avant installation :

  • ✅ Code Open Source : Le serveur est-il disponible sur GitHub/GitLab avec un historique de commits transparent ?
  • ✅ Maintenance active : Y a-t-il eu des commits dans les 3 derniers mois ?
  • ✅ Nombre de stars : Au moins 100+ stars indique une adoption communautaire
  • ✅ Audit de sécurité : Y a-t-il eu un audit externe ou un rapport de sécurité publié ?
  • ✅ Dépendances : Le serveur utilise-t-il des bibliothèques à jour sans CVE critiques ? (vérifiez avec npm audit ou safety check)

Règle d’or : N’utilisez que des serveurs dont le code est Open Source, audité, et maintenu par des organisations reconnues (Anthropic, Microsoft, Google) ou des développeurs réputés. Évitez absolument les implémentations obscures de développeurs isolés sans historique vérifiable.

4. Isolation Réseau Stricte (Network Segmentation)

Si votre serveur MCP écoute sur un port TCP (ex: 8080), l’exposition réseau doit être minimale.

Configuration sécurisée :

# ✅ Écoute uniquement sur localhost
mcp-server --bind 127.0.0.1:8080

# ❌ DANGER : Exposition sur toutes les interfaces
mcp-server --bind 0.0.0.0:8080

Risque réel : Si le serveur écoute sur 0.0.0.0, n’importe qui sur le même réseau Wi-Fi (café, coworking, conférence) pourrait :

  1. Scanner le port avec nmap
  2. Interroger votre serveur MCP
  3. Lire vos fichiers sensibles
  4. Exfiltrer des secrets

Protection supplémentaire en ajoutant votre pare-feu

5. Authentification et Autorisation (AuthN/AuthZ)

Ne présumez jamais que “parce que c’est local, c’est sûr”. Mettez en place une authentification.

Options d’implémentation :

{
  "mcpServers": {
    "filesystem": {
      "command": "mcp-server-filesystem",
      "args": ["--auth-token", "${MCP_SECRET_TOKEN}"],
      "env": {
        "MCP_SECRET_TOKEN": "généré-via-openssl-rand-hex-32"
      }
    }
  }
}

Stockage du token : Ne jamais hardcoder le token dans le code. Utilisez des variables d’environnement ou un gestionnaire de secrets (Keychain sur macOS, Secret Service sur Linux).

6. Surveillance et Alerting (Security Monitoring)

Mettez en place une détection d’anomalies pour identifier les comportements suspects.

Outils de monitoring recommandés :

Linux - Auditd :

# Installer auditd
sudo apt-get install auditd

# Surveiller les accès aux fichiers sensibles
sudo auditctl -w /home/user/.ssh/id_rsa -p r -k mcp_ssh_access
sudo auditctl -w /etc/shadow -p r -k mcp_shadow_access

# Voir les logs
sudo ausearch -k mcp_ssh_access

macOS - fswatch :

# Installer fswatch
brew install fswatch

# Surveiller les accès
fswatch -0 ~/.ssh | xargs -0 -n 1 echo "MCP Access détecté:"

Alerting centralisé :

# Envoyer les alertes vers Slack/Discord
curl -X POST -H 'Content-type: application/json' \
  --data '{"text":"⚠️ Accès MCP détecté sur fichier sensible"}' \
  $SLACK_WEBHOOK_URL

7. Chiffrement des Communications (TLS/mTLS)

Si votre MCP communique sur le réseau (même en local), chiffrez toujours les échanges.

Mutual TLS (mTLS) pour authentification bidirectionnelle : Exigez que le client (l’IA) présente également un certificat client pour prouver son identité.

8. Rotation et Révocation des Accès (Access Lifecycle)

Traitez les serveurs MCP comme des identités temporaires avec une durée de vie limitée.

Bonnes pratiques :

  • 🔄 Rotation hebdomadaire des tokens d’authentification
  • ⏱️ TTL (Time-To-Live) : Les sessions MCP expirent après 24h d’inactivité
  • 🚫 Révocation immédiate : Si un token fuit (commit Git accidentel), révocation et régénération en moins de 5 minutes

Automatisation de la rotation : Exemple de script bash pour rotation automatique :

#!/bin/bash
# Script de rotation automatique (à ajouter dans cron)
NEW_TOKEN=$(openssl rand -hex 32)
echo "MCP_SECRET_TOKEN=$NEW_TOKEN" > ~/.mcp_token
# Redémarrer le serveur MCP avec le nouveau token
systemctl restart mcp-server

Stockage sécurisé des tokens révoqués : Maintenez une liste de tokens révoqués (blacklist) pour éviter leur réutilisation même après expiration.

Conclusion

Le Model Context Protocol (MCP) est une avancée prometteuse pour intégrer les IA dans nos workflows. Cependant, il introduit de nouveaux risques de sécurité majeurs. En suivant des pratiques rigoureuses de durcissement et en restant vigilant quant aux implémentations utilisées, vous pouvez profiter des bénéfices de l’IA tout en protégeant vos données sensibles.

LinkedIn Reddit