Outils et protocoles d'action
Sécuriser les MCP utilisés par un agent IA
MCP simplifie l'exposition d'outils et de ressources à un agent. Il ne supprime ni la vérification du serveur et de l'outil, ni le contrôle des paramètres, ni l'autorisation de l'action, ni l'observation de son effet.
Donner un outil à un agent, c'est lui donner une capacité d'action.
Par Sécurité Agentique · Publié le
01
Ce qu'un agent voit lorsqu'il découvre un outil
Avec MCP, l'agent interroge un serveur, reçoit la liste de ses outils avec leur description et leur schéma, puis choisit lequel appeler et construit les arguments. Le choix repose en grande partie sur le texte de la description.
server: crm-tools tool: exportCRM description: "Exporte des opportunités vers une destination." inputSchema: fields: string[] filter: string destination: string
- Serveur
- Qui expose l'outil. Est-il approuvé, authentifié ?
- Outil
- Le nom que l'agent choisira.
- Description
- Lue par le modèle pour décider. Donnée interprétée, donc surface d'attaque.
- Schéma et paramètres
- Ce que l'agent peut remplir, et donc détourner.
- Réponse
- Revient dans le contexte de l'agent après l'appel.
Une description d'outil n'est pas de la documentation pour un humain : c'est une donnée que le modèle interprète pour décider de ses actions.
02
Les risques MCP
- Tool poisoning
- Une instruction glissée dans la description ou le schéma oriente l'agent. Voir tool poisoning.
- Serveur usurpé
- Un serveur se présente sous le nom d'un serveur approuvé.
- Description trompeuse
- L'outil fait plus, ou autre chose, que ce qu'il annonce.
- Paramètre détourné
- L'agent, influencé, remplit un argument avec une valeur non prévue : destination, filtre vide, tous les champs.
- Outil trop puissant
- Un outil générique (exécuter une requête, un script) couvre bien plus que la mission.
- Résultat malveillant
- La réponse de l'outil contient une instruction, comme un document RAG piégé (voir sécuriser le RAG).
- Serveur non approuvé
- Ajouté par un développeur ou un utilisateur hors de tout inventaire.
- Chaîne excessive
- Une succession de tool calls, chacun anodin, produit un effet que personne n'a validé.
- Outil qui encapsule une API
- L'outil appelle une API avec son propre token ; les contrôles de sécurisation des API restent nécessaires derrière lui.
03
Deux questions différentes
Question 1
Cet outil et cet appel présentent-ils un risque de sécurité ?
- Fonction ·
- inspection, agent security, runtime security
- Exemple technologique ·
- AccuKnox
Un outil sain peut être interdit : exportCRM est légitime, mais Hermes n'a pas à exporter pour un stagiaire.
Question 2
Hermes a-t-il le droit d'effectuer cette action ?
- Fonction ·
- autorisation (PEP + PDP)
- Exemple technologique ·
- Axiomatics
Une action normalement autorisée peut être bloquée : l'export quotidien vers Reporting est permis, mais la description de l'outil vient d'être modifiée pour ajouter une destination.
Les deux contrôles sont complémentaires. L'inspection ne connaît pas la mission de Hermes ni les droits d'Alice ; l'autorisation ne lit pas la description de l'outil pour y chercher une instruction cachée.
04
Architecture MCP avec défense en profondeur
Selon l'architecture, la couche d'inspection et le PEP peuvent être un même composant (une gateway MCP qui inspecte et consulte le PDP) ou des composants distincts. Le principe ne change pas : aucun appel n'atteint le serveur sans avoir été inspecté et autorisé, et aucune réponse ne revient à l'agent sans inspection. Le rôle exact du PEP et du PDP est détaillé dans autorisation fine des agents IA. Un cas de séparation des tâches entre deux outils MCP montre ce placement sur un processus d'achat.
05
Exemple : l'outil « Export CRM »
L'outil exportCRM accepte trois paramètres : fields, filter, destination.
Appel 1
- Agent
- Hermes
- Outil
- exportCRM
- fields
- id, amount, status
- destination
- reporting.corporate
✓ PERMIT
Appel 2
- Agent
- Hermes
- Outil
- exportCRM
- fields
- all (attribut modifié)
- destination
- external-storage.example (attribut modifié)
✕ DENY
Même outil, même agent. Les paramètres diffèrent, la décision aussi. Une allowlist d'outils seule aurait laissé passer les deux appels.
06
Contrôler plus que le nom de l'outil
Autoriser exportCRM sans regarder ses arguments revient à autoriser tous les exports possibles. Une politique utile peut porter sur :
- outil
- arguments
- ressource ciblée
- volume
- destination
- utilisateur à l'origine
- agent
- environnement
- moment
- finalité
Le même raisonnement s'applique aux outils capables d'exécuter des opérations métier — préparer un panier, confirmer une commande, modifier un prix — comme le montrent les scénarios retail d'agents capables d'agir sur des applications métier.
07
Moindre privilège pour les outils
Exposer à Hermes tous les outils disponibles « au cas où » élargit ce qu'un contenu injecté peut lui faire faire. Le moindre privilège s'applique à plusieurs niveaux :
- Allowlist d'outils
- Seuls les outils de la mission sont présentés au modèle.
- Capabilities ciblées
- Préférer exportOpportunitiesToReporting à runQuery.
- Actions limitées
- Lecture seule par défaut, écriture sur des objets précis.
- Identité dédiée
- Un compte par agent et par serveur, jamais un compte partagé.
- Tokens courts
- Durée et audience limitées pour réduire l'usage d'un token volé.
- Validation humaine
- Pour les effets irréversibles : paiement, suppression, envoi externe.
08
OAuth et délégation des jetons MCP
Un agent IA qui utilise un serveur MCP ne doit ni hériter automatiquement de tous les droits de son utilisateur, ni transporter le même jeton d'un service à l'autre. La question porte sur l'authentification, mais aussi sur au nom de qui l'agent agit, sur quelle ressource et avec quelles permissions.
Pour les transports HTTP, la spécification MCP Authorization s'appuie sur le projet OAuth 2.1, encore à l'état de draft IETF. Le client MCP joue le rôle de client OAuth ; le serveur MCP est une ressource protégée, qui publie ses métadonnées selon la RFC 9728 pour indiquer le serveur d'autorisation à utiliser.
Identité de l'agent et délégation utilisateur
- L'agent agit pour son propre compte
- Il utilise son identité technique, par exemple avec le flux OAuth Client Credentials. Les droits sont ceux du compte de l'agent, sans lien avec un utilisateur.
- L'agent agit au nom d'un utilisateur
- Il dispose d'un mandat autorisé (« on behalf of »), limité à la mission. La délégation ne doit pas lui conférer l'ensemble des privilèges de l'utilisateur.
Selon le cas, l'application cible voit l'utilisateur comme sujet (sub), le compte technique de l'agent, ou une représentation explicite de la délégation où l'agent figure comme acteur (act). La présence des deux identités dépend de l'architecture, du serveur d'autorisation et des capacités de l'application cible : ni MCP ni OAuth ne la garantissent automatiquement.
Audience du jeton : RFC 8707
La RFC 8707 définit le paramètre resource, qui désigne le destinataire du jeton. Le client MCP doit l'inclure dans ses demandes d'autorisation et de jeton. Le serveur MCP doit vérifier que le jeton reçu lui est destiné (audience), ainsi que son émetteur, sa validité, son expiration et ses permissions.
Présenté au serveur MCP
- Destinataire
- https://mcp.exemple.fr/crm
- aud du jeton
- https://mcp.exemple.fr/crm
- Signature
- valide
✓ PERMIT
Présenté à l'API métier
- Destinataire
- https://api.crm.exemple.fr (attribut modifié)
- aud du jeton
- https://mcp.exemple.fr/crm
- Signature
- valide
✕ DENY
Un jeton cryptographiquement valide peut être présenté au mauvais destinataire. L'API métier doit le refuser parce qu'il ne lui est pas destiné.
Réduction des scopes et moindre privilège
Le client MCP demande les scopes strictement nécessaires : lecture lorsque l'action n'exige pas d'écriture, puis une demande d'autorisation supplémentaire si des permissions additionnelles deviennent nécessaires. Un scope OAuth reste une permission grossière : crm.read peut ouvrir bien plus de données que la mission n'en requiert. Une autorisation au runtime restreint alors les outils appelables, les paramètres, les objets, les champs, les destinations et les volumes.
Échange de jetons : RFC 8693
OAuth 2.0 Token Exchange (RFC 8693) permet d'obtenir auprès du serveur d'autorisation un nouveau jeton adapté à la ressource cible. Le serveur MCP, ou un broker de confiance, demande ainsi un jeton distinct pour l'API aval, sans retransmettre le jeton entrant.
- subject_token
- Jeton représentant le sujet de la délégation, souvent l'utilisateur.
- actor_token
- Jeton pouvant représenter l'acteur qui exécute l'opération, ici l'agent ou le serveur MCP.
- audience / resource
- Indications sur la ressource destinataire du nouveau jeton.
- scope
- Permissions demandées pour ce nouveau jeton.
- act
- Claim pouvant décrire l'acteur dans le jeton de délégation émis.
La RFC 8693 n'est pas une obligation MCP. Sa prise en charge, comme celle des claims de délégation, doit être vérifiée auprès du fournisseur d'identité et de l'API cible.
Interdiction du token passthrough
La spécification MCP interdit explicitement au serveur MCP de transmettre à une API aval le jeton qu'il a reçu du client (voir les Security Considerations).
- Client MCP
- Serveur MCP
- API métier
- Client MCP
- jeton A (aud : serveur MCP)
- Serveur MCP
- jeton B (aud : API métier)
- API métier
Le jeton B est obtenu par un mécanisme d'autorisation approprié, par exemple la RFC 8693 lorsque l'infrastructure le permet. Le passthrough expose à la confusion d'audience, au contournement des contrôles du serveur MCP, à des privilèges excessifs, au problème du confused deputy et à une traçabilité insuffisante : l'API aval ne sait plus quel composant l'appelle réellement.
Exemple : un agent IA consulte un CRM
Un utilisateur demande à son agent une synthèse d'un dossier client.
- 01L'utilisateur autorise le client MCP à accéder au serveur MCP.
- 02Le client obtient un jeton destiné spécifiquement au serveur MCP (resource=https://mcp.exemple.fr/crm).
- 03Le serveur MCP vérifie le jeton, son audience et ses permissions.
- 04Une politique vérifie que l'utilisateur et l'agent sont autorisés à consulter ce dossier.
- 05Le serveur MCP obtient un second jeton destiné à l'API CRM, éventuellement via la RFC 8693.
- 06L'API CRM exécute l'opération dans le périmètre autorisé.
- 07Les journaux rattachent l'action à l'utilisateur, à l'agent et au contexte d'exécution.
L'API CRM ne voit pas nécessairement l'identité de l'agent : cela dépend du mécanisme de délégation et des informations portées par le jeton.
Checklist OAuth MCP
- 01Chaque serveur MCP valide l'audience des jetons reçus.
- 02Les clients utilisent le paramètre resource conformément à la RFC 8707.
- 03Les scopes respectent le principe du moindre privilège.
- 04Les identités de l'utilisateur et de l'agent restent attribuables.
- 05Les applications aval disposent de leurs propres jetons.
- 06Aucun token passthrough n'est autorisé.
- 07L'échange RFC 8693 est utilisé lorsqu'il est pertinent et supporté.
- 08Les actions sensibles font l'objet d'un contrôle d'autorisation au runtime.
- 09Les secrets et jetons ne sont jamais exposés au modèle, dans les prompts ou dans les journaux.
Recette locale de tests MCP : vérifier le refus avant l'effet
Avant de raccorder un agent IA à un serveur MCP de préproduction, une question doit recevoir une réponse vérifiable : un appel interdit est-il réellement bloqué avant d'atteindre l'outil ou la ressource ?
Un résultat DENY dans un moteur d'autorisation ne constitue pas, à lui seul, une preuve. Il faut aussi vérifier que le point d'application de la décision — le PEP — empêche effectivement l'exécution.
Voici une recette défensive reproductible sur des composants simulés. Aucun CRM, serveur MCP tiers ou environnement de production n'est sollicité.
1. Préparer un banc d'essai entièrement local
Scénario fictif : un agent de reporting doit exporter des opportunités CRM vers un outil interne de pilotage.
Le banc d'essai contient :
- Un agent fictif
agent_reporting, associé à une mission et à une identité de test. - Un serveur MCP simulé
crm_mock, sans connexion sortante. - Un outil
exportCRM, dont les paramètres sontfields,filteretdestination. - Une politique autorisant exclusivement les champs
id,amountetstatus, le filtreportfolio=Aet la destination logiquereporting_interne. - Un broker ou PEP simulé chargé de vérifier les appels avant de les transmettre.
- Un registre local comptabilisant les invocations acceptées et les effets simulés.
La définition approuvée de l'outil est conservée comme référence : nom, description, schémas d'entrée et de sortie, annotations et version lorsqu'elles existent.
Toutes les données, identités et destinations sont fictives. Aucun secret, jeton réel ou accès réseau n'est nécessaire. Le banc d'essai ne doit effectuer aucune connexion à un service externe.
2. Exécuter six tests défensifs
| Test | Action simulée | Résultat attendu |
|---|---|---|
| T01 — Appel autorisé | Appeler exportCRM avec les trois champs autorisés, le filtre portfolio=A et la destination reporting_interne. | PERMIT ; une invocation du mock et un seul effet simulé. |
| T02 — Outil interdit | Tenter d'appeler directement un outil non approuvé, même s'il n'apparaît pas dans tools/list. | DENY ; aucune invocation du mock. |
| T03 — Paramètres hors périmètre | Conserver exportCRM, mais demander tous les champs, un filtre élargi ou une destination différente. | DENY avant transmission ; aucun effet simulé. |
| T04 — Définition modifiée | Modifier localement la description ou le schéma d'un outil après son approbation. | Si le contrôle d'intégrité des définitions est activé, modification détectée et exécution suspendue jusqu'à nouvelle validation. |
| T05 — Audience ou scopes invalides | Simuler, pour un profil MCP HTTP protégé par OAuth, un jeton destiné à une autre ressource ou dépourvu du scope nécessaire. | Refus avant l'outil : 401 pour un jeton invalide, 403 pour des permissions insuffisantes. |
| T06 — Décision indisponible | Simuler une politique absente, un contexte d'identité indispensable manquant ou un PDP inaccessible. | Refus par défaut (fail closed) ; aucune invocation de l'outil protégé. |
Ces tests ne nécessitent pas de modèle de langage. Ils vérifient les contrôles déterministes entourant l'agent, indépendamment de la manière dont celui-ci choisit ses outils.
Attention au tool poisoning : le test T04 vérifie la détection d'une modification de définition. Il ne prouve pas qu'un modèle résisterait à toutes les instructions malveillantes. Cette dernière propriété nécessite des évaluations agentiques distinctes.
3. Vérifier la preuve du blocage
Pour chaque scénario, conserver dans un journal local :
- L'identifiant du scénario, de l'agent, de la mission et de l'outil.
- Les paramètres pertinents de la demande, avec minimisation des données.
- L'identifiant et la version de la politique évaluée.
- La décision
PERMITouDENYet son motif. - Le résultat de l'application par le PEP.
- Le nombre réel d'invocations du mock et d'effets simulés.
- Un identifiant de corrélation permettant de relier la demande à son résultat.
Critère décisif : pour chaque scénario interdit, la décision doit être un refus et les compteurs d'invocation et d'effet doivent rester à zéro.
Une trace indiquant DENY alors que l'outil a été invoqué révèle un défaut d'application de la politique.
Ne jamais enregistrer de secrets ou de jetons d'accès en clair pour constituer cette preuve.
4. Distinguer les tests CI des protections runtime
Ces scénarios peuvent servir de spécification pour des tests automatisés en CI : définition des outils, intégrité des schémas, paramètres acceptés, décisions d'autorisation et comportements en cas d'erreur.
En production, les mêmes restrictions doivent être appliquées sur le chemin effectif des appels. La validation effectuée avant le déploiement ne remplace pas le contrôle au moment de chaque invocation.
Cette recette locale ne démontre ni la résistance complète aux prompt injections, ni l'isolation réelle des processus, fichiers ou réseaux, ni la sécurité d'une intégration OAuth de production. Elle ne constitue pas une certification ou une garantie de conformité.
5. Aller plus loin
Explorer les décisions d'autorisation : la matrice de permissions dynamiques des agents IA propose des scénarios complémentaires, avec un simulateur local fondé sur des données fictives.
Valider une architecture réelle : découvrir l'accompagnement Ariovis pour la protection des agents IA, du cadrage des risques à l'intégration des contrôles et à la recette de sécurité.
Références techniques :
- Model Context Protocol — Tools, spécification du 28 juillet 2026
- Model Context Protocol — Authorization, spécification du 28 juillet 2026
- OWASP — MCP Security Cheat Sheet
Références consultées le 15 novembre 2026. Les recommandations OWASP sont des bonnes pratiques de sécurité, non des exigences réglementaires universelles.
09
Observer le runtime
Une décision légitime peut conduire à une activité anormale : l'outil est compromis, une dépendance est piégée, ou l'enchaînement d'appels dérive. L'autorisation porte sur la demande ; elle ne voit pas ce que fait ensuite le processus du serveur MCP.
- Multiplication d'appels
- Boucle ou balayage inhabituel.
- Processus inattendu
- Shell lancé par un serveur d'export.
- Accès fichiers
- Lecture de clés ou de fichiers système.
- Réseau inhabituel
- Connexion vers une destination inconnue.
- Tentative d'élévation
- Changement de privilèges, montage, capacités noyau.
La sécurité runtime observe et restreint ce comportement au niveau du workload ; l'autorisation décide des actions. Ensemble, elles couvrent la demande et son exécution ; les signaux qu'elles produisent servent à détecter un agent qui sort de son périmètre. Les autres chemins de Hermes sont décrits dans l'architecture complète.
FAQ
Questions fréquentes
MCP est-il sécurisé par défaut ?
MCP est un protocole : il standardise la façon dont un agent découvre et appelle des outils et des ressources. Il ne décide pas quels serveurs sont dignes de confiance, quels outils un agent doit voir ni quels paramètres sont acceptables. Ces contrôles relèvent de l'architecture qui entoure le protocole.
Qu'est-ce que le tool poisoning ?
L'insertion, dans la description, le schéma ou les métadonnées d'un outil, d'un contenu conçu pour influencer l'agent : instruction cachée, consigne d'appeler un autre outil, de transmettre un fichier ou d'ajouter un paramètre. L'agent lit la description pour choisir ses outils ; elle devient donc une entrée non fiable.
Comment sécuriser un serveur MCP ?
N'autoriser que des serveurs approuvés et identifiés, inspecter les descriptions et leurs changements, limiter les outils exposés, donner au serveur une identité et des tokens restreints à sa fonction, valider les arguments des appels, inspecter les résultats et observer le comportement du workload qui l'exécute.
Comment contrôler les outils visibles par un agent ?
Par une allowlist appliquée avant la présentation des outils au modèle : un tool broker ou une gateway MCP ne transmet à l'agent que les outils prévus pour sa mission. Cette sélection réduit les outils proposés au modèle, mais ne suffit pas à interdire un appel direct ou un chemin de contournement. Le broker ou le PEP doit réappliquer l'allowlist et les politiques d'autorisation au moment de chaque appel d'outil.
Peut-on appliquer du PBAC à MCP ?
Oui. Chaque tool call est une demande d'action : sujet (utilisateur et agent), action (l'outil), ressource et paramètres, contexte. Un PEP dans la gateway MCP ou le tool broker peut soumettre cette demande à un PDP et appliquer une politique PBAC ou ABAC.
Où placer un PEP avec MCP ?
Entre l'agent et les serveurs MCP : gateway MCP, proxy d'outils ou tool broker du framework d'agent. Pour les actions à effet métier, un second PEP peut rester devant l'API ou l'application ciblée par l'outil, au cas où le serveur MCP serait contourné.
Comment limiter les paramètres d'un tool call ?
En validant le schéma (types, valeurs admises) puis en soumettant les arguments significatifs à la politique : champs demandés, filtre, volume, destination. Une validation de schéma vérifie la forme ; seule une décision d'autorisation vérifie que la valeur est acceptable pour ce sujet et ce contexte.
Quelle différence entre MCP security et autorisation ?
La sécurité MCP qualifie le risque technique : serveur usurpé, description piégée, argument malveillant, résultat hostile, comportement anormal. L'autorisation décide si cet agent, pour cet utilisateur, peut effectuer cette action avec ces paramètres. Un outil sain peut être interdit ; une action autorisée peut être bloquée si l'outil est compromis.
Continuer l'exploration
- Autorisation fineQuelle action Hermes est-il réellement autorisé à exécuter ?
- Agent rogueComment détecter qu'Hermes explore ou agit hors de son mandat ?
- APIComment limiter précisément un appel pourtant réalisé avec un token valide ?
- Architecture complèteTous les chemins de Hermes et le contrôle qui s'applique à chacun.
Votre agent possède-t-il plus de pouvoir que sa mission ne l'exige ?
Nous pouvons cartographier ses données, outils, API et actions pour identifier les points de contrôle réellement utiles.