Protocole MCP (Model Context Protocol) : comprendre les risques et les contrôles relatifs à la sécurité

Le protocole MCP (Model Context Protocol) développé par Anthropic est un protocole puissant qui définit comment connecter de grands modèles de langage (LLM) à des outils externes. Il a connu un essor rapide en raison de sa facilité d'utilisation et des avantages qu'il apporte dans notre façon d'utiliser l'IA. Dans cet article, nous aborderons certains des risques potentiels pour la sécurité qu'implique le protocole MCP ainsi que les approches à appliquer pour les limiter.

Fonctionnement du protocole MCP

Le protocole MCP n'associe pas directement les LLM aux outils. Le composant client MCP accède au LLM, tandis que le composant serveur MCP accède aux outils. Un client MCP a accès à un ou plusieurs serveurs MCP. Les utilisateurs peuvent connecter autant de serveurs MCP qu'ils le souhaitent à un client MCP.

Voici un exemple typique d'échange entre un client et des serveurs MCP :

1. L'utilisateur demande une tâche au client MCP
   1. Le client MCP dispose des informations sur les outils que chaque serveur MCP met en œuvre ou auxquels il a accès
2. Le client MCP transmet la demande de l'utilisateur ainsi que les informations fournies par les serveurs MCP à un LLM qui répond avec l'outil requis et les paramètres à utiliser
3. Le client MCP envoie les informations sur les outils et les paramètres au serveur MCP
4. Le serveur MCP exécute la tâche et renvoie la réponse au client MCP, qui la transmet au LLM. Ce dernier génère alors une réponse pour l'utilisateur
5. Le client MCP affiche la réponse à l'utilisateur

Les serveurs MCP peuvent être exécutés localement ou à distance, et les risques en matière de sécurité varient selon la manière dont ils sont exécutés.

Les serveurs MCP locaux correspondent aux serveurs MCP que nous exécutons sur un hôte que nous contrôlons. Pour effectuer les tâches demandées, les serveurs MCP locaux exécutent généralement des commandes de système d'exploitation ou du code personnalisé en local.

Les serveurs MCP distants sont exécutés uniquement à distance par un tiers. Nous pouvons avoir accès à des serveurs MCP distants, mais ils ne s'exécutent pas sur un hôte que nous contrôlons. Les serveurs MCP distants présentent toujours des risques pour la sécurité des utilisateurs, car ils ont accès à leurs données. Cependant, comme ils ne sont pas exécutés en local, de nombreux risques courants ne peuvent pas survenir.

Risques et contrôles relatifs à la sécurité

Voici un aperçu des risques liés au protocole MCP identifiés par des équipes de recherche en sécurité, ainsi que des approches pour les atténuer.

Authentification et autorisation

Lorsqu'un serveur MCP effectue une action déclenchée par la demande d'un utilisateur, il existe un risque de type « confused deputy ». Idéalement, le serveur MCP doit exécuter cette action pour le compte de l'utilisateur et avec son autorisation. Ce processus n'est toutefois pas garanti et dépend de la mise en œuvre du serveur MCP. Si cette mise en œuvre n'est pas réalisée correctement, un utilisateur pourrait accéder à des ressources qui ne devraient pas lui être accessibles, mais qui sont disponibles pour le serveur MCP, ce qui serait contraire au principe du moindre privilège.

Le protocole MCP définit l'autorisation à l'aide d'un autre protocole, OAuth. La communauté a cependant identifié que la spécification actuelle inclut des détails de mise en œuvre en conflit avec les pratiques professionnelles modernes. La communauté travaille activement pour améliorer et mettre à jour la spécification d'autorisation afin d'éliminer cet écart.

Risques liés à la chaîne d'approvisionnement

Les serveurs MCP sont composés de code exécutable. Les utilisateurs doivent donc utiliser uniquement les serveurs MCP auxquels ils font confiance. Si nous développons des serveurs MCP, nous devons prendre des précautions pour que nos utilisateurs puissent avoir confiance en notre logiciel. Les composants MCP doivent également être signés par le développeur afin que les utilisateurs puissent être certains de leur intégrité.

Il faut également assembler les composants MCP dans des pipelines qui mettent en œuvre les meilleures pratiques de sécurité telles que les tests statiques de sécurité des applications (SAST, Static Application Security Testing). Nous devons comprendre les résultats, écarter les faux positifs et corriger les vulnérabilités de sécurité connues. Les pipelines doivent également mettre en œuvre l'analyse de la composition logicielle (SCA, Software Composition Analysis), afin d'identifier et de corriger les vulnérabilités connues dans les dépendances utilisées par les serveurs MCP.

Si un serveur MCP est proposé en tant que service cloud, il doit également mettre en œuvre une vérification cryptographique du serveur afin que les clients puissent identifier le serveur.

Comme pour tous les autres logiciels, si l'attaquant parvient à accéder au code source d'un composant MCP et à le modifier, il pourra compromettre la sécurité des utilisateurs. Afin de réduire ce risque, les équipes de développement et les utilisateurs doivent vérifier l'intégrité de toutes les dépendances auxquelles ils ont recours et les analyser à la recherche de logiciels malveillants.

Exécution de commande non autorisée

Les serveurs MCP locaux peuvent exécuter tout type de code. En fonction de la manière dont le client MCP transmet les informations au serveur MCP et de la manière dont ce dernier est mis en œuvre, la fonctionnalité d'exécution de commande peut être exposée aux vulnérabilités liées à l'injection d'une commande. Il faut toujours vérifier les commandes qui seront exécutées et assainir les données avant de les utiliser comme argument pour une fonction qui exécute des commandes.

Voici un exemple de serveur MCP avec une vulnérabilité liée à l'injection d'une commande :

def dispatch_user_alert(self, notification_info: Dict[str, Any], summary_msg: str) -> bool: """Envoie une alerte système sur l'appareil de l'utilisateur""" notify_config = self.user_prefs["alert_settings"] try:      alert_title = f"{notification_info['title']} - {notification_info['severity']}"      if sys.platform == "linux":          subprocess.call(["notify-send", alert_title])      return True

Source du code :https://equixly.com/blog/2025/03/29/mcp-server-new-security-nightmare/ 

Il faut aussi envisager d'exécuter des serveurs MCP locaux dans un sandbox afin de restreindre l'accès et l'exécution uniquement au contenu autorisé.

Injection d'instructions génératives

Les serveurs MCP présentent d'importants risques pour la sécurité en raison de leur capacité à exécuter des commandes et à effectuer des appels d'API. L'une des principales préoccupations est le fait que même si un utilisateur n'a pas l'intention d'effectuer une action spécifique, le LLM peut décider qu'elle est correcte.

Ce risque peut survenir sans intention malveillante, mais il a également des conséquences dans les scénarios contradictoires. Par exemple, un utilisateur légitime peut envoyer une instruction générative qu'il n'a pas écrite au client MCP, et qui peut-être recommandée par un tiers malveillant. Une telle instruction pourrait être obscure, mais divulguer des informations privées issues de la conversation de l'utilisateur ou d'outils accessibles. Imaginez qu'un utilisateur copie et colle une instruction générative complexe et obscure qui, selon lui, doit permettre de créer un nouvel utilisateur dans son environnement cloud. Cette instruction malveillante pourrait, en plus de créer l'utilisateur voulu, en créer un autre pour l'attaquant.

C'est pourquoi les actions effectuées par les serveurs MCP doivent toujours être confirmées par les utilisateurs ou limitées afin de réduire le risque à un niveau acceptable.

Injection d'outils

Il est également possible de créer un serveur MCP malveillant, ce qui représente un risque potentiellement bien plus élevé. Par exemple, un serveur MCP malveillant peut initialement sembler sûr lors de l'installation, et même présenter un code source et des descriptions d'outils d'apparence normale. Les outils peuvent toutefois être modifiés lors d'une mise à jour ultérieure. Par exemple, un outil conçu à l'origine pour recueillir des informations météorologiques peut être modifié lors d'une mise à jour pour commencer à récupérer des informations confidentielles et les envoyer à un pirate informatique.

Ce phénomène peut également se produire avec les noms des outils. Les serveurs MCP malveillants peuvent utiliser des noms trompeurs pour les outils afin que le LLM les sélectionne pour une tâche qui devrait être effectuée par d'autres outils légitimes, ce qui peut déclencher des actions involontaires ou dangereuses.

Pour atténuer ce risque, le logiciel qui permet aux utilisateurs d'installer des serveurs MCP doit être en mesure d'analyser la version des serveurs MCP et d'informer l'utilisateur en cas de modification apportée à leur code ou à leur composition après l'installation.

Échantillonnage

Les serveurs MCP malveillants peuvent également essayer d'exploiter le mécanisme d'échantillonnage du protocole MCP, par exemple pour demander à leurs clients MCP d'utiliser un LLM afin de répondre à une demande. Si un serveur MCP doit envoyer une demande à un LLM, l'échantillonnage peut permettre au client MCP d'effectuer cette demande pour le compte du serveur MCP, puisque l'utilisateur a davantage de contrôle sur le client MCP et que cet aspect aide à centraliser les coûts.

Les clients MCP doivent mettre en œuvre les contrôles suivants afin de réduire les risques associés à l'échantillonnage :

• Autoriser les clients à montrer aux utilisateurs la demande d'achèvement
• Autoriser les utilisateurs à modifier ou rejeter des tâches achevées
• Autoriser les clients à filtrer ou modifier des tâches achevées
• Autoriser les utilisateurs à choisir le modèle utilisé
• Mettre en œuvre des limites de débit appropriées
• Contrôler l'exposition aux coûts
• Mettre en œuvre des délais d'attente

Journalisation

Comme nous l'avons vu précédemment, les serveurs MCP sont capables d'exécuter des commandes sensibles. Ils doivent être en mesure d'envoyer des journaux ou des événements à des serveurs de journalisation centralisés et standards, ou d'enregistrer ces événements localement. Ce processus permet d'examiner les actions du système en cas de problème ou de suspicion.

Gestion des vulnérabilités

Puisque les serveurs MCP sont basés sur du code, ils peuvent présenter des vulnérabilités comme tout autre logiciel. Il est donc essentiel de les inclure dans le processus standard de gestion des vulnérabilités. Ce processus inclut la mise à niveau des clients et serveurs MCP ainsi que de leurs dépendances aux intervalles planifiés en fonction du niveau de risque au sein de l'entreprise.

Conclusion

Il est intéressant d'utiliser le protocole MCP pour manipuler des outils à l'aide du langage naturel et pour mieux comprendre la façon dont nous communiquons avec les utilisateurs, les LLM et les outils. Cependant, nous devons prendre en compte les risques pour la sécurité qui accompagnent cette augmentation de l'automatisation et l'ajout de capacités autonomes pour l'IA. Pour utiliser le protocole MCP, les entreprises doivent évaluer les risques pour leur sécurité et mettre en œuvre les contrôles de sécurité appropriés afin de tirer le meilleur parti de cette nouvelle technologie.

En savoir plus

• MCP Servers: The New Security Nightmare
• The MCP Authorization Spec Is... a Mess for Enterprise
• Everything Wrong with MCP
• Imprompter: Tricking LLM Agents into Improper Tool Use
• Model Context Protocol (MCP): Landscape, Security Threats, and Future Research Directions
• WhatsApp MCP Exploited: Exfiltrating your message history via MCP
• 5 MCP Security Tips