Sept questions à se poser avant de lancer un serveur MCP local
Une liste de contrôle pour l’isolation des serveurs MCP locaux, testée sur le serveur GitHub : tokens à durée de vie courte, réseau scellé, liste d’autorisation des sorties et listes d’outils fixés.
Sources: the seven questions i ask before running a local mcp server — part 2
Installer un serveur MCP local signifie généralement coller un extrait dans un fichier de configuration :
{
"mcpServers": {
"some-tool": { "command": "npx", "args": ["-y", "some-mcp-server"] }
}
}
Cela fait trois lignes de code, sans aucune étape d’évaluation, sans dialogue de permissions et sans étape d’installation à laquelle quiconque pense réellement. Il vaut la peine de s’arrêter pour comprendre ce que font ces lignes. Un serveur MCP local n’est pas un service : il n’a ni port, ni mécanisme de connexion, ni limites. C’est un programme que l’agent lance, qui s’exécute en tant qu’utilisateur actuel et a accès aux fichiers et à l’environnement de cet utilisateur. Les demandes de permissions affichées par l’agent décrivent ce que fait l’agent, tandis que le programme derrière une requête d’outil dispose déjà de pleins pouvoirs sur la machine.
Une meilleure pratique consiste à se poser sept questions avant d’installer, et à laisser les réponses déterminer la configuration.
Les sept questions
- Fonctionne-t-il localement ? Les serveurs MCP distants se trouvent sur l’ordinateur d’un tiers et ne peuvent pas être isolés, ce qui rend le reste de la liste sans importance. Parfois, il s’agit d’une décision plutôt que d’une évidence, et choisir soigneusement entre une solution distante et une solution locale peut faire disparaître les six autres questions.
- A-t-il besoin de identifiants ? Soit aucun, soit un identifiant spécifique qui peut être indiqué.
- Où se connecte-t-il ? Soit à une courte liste d’hôtes fixes, soit à n’importe quelle URL.
- Quels fichiers a-t-il besoin ? Un seul espace de travail, tout, ou rien.
- A-t-il besoin d’autre chose de la part de l’hôte ? Une session bureau, un socket, un navigateur.
- Fonctionne-t-il avec du code qu’il télécharge ? Si oui, ce code doit être verrouillé.
Les questions un à six peuvent être répondues à partir de la documentation du serveur lui-même en environ dix minutes, sans avoir à chercher ailleurs. Seule la septième question dispose d’une mesure concrète : une seule requête tools/list après l’installation, et le nombre d’outils obtenu dépasse souvent les attentes.
Exemple concret : le serveur GitHub
| Question | Réponse pour le serveur GitHub |
|---|---|
| Fonctionne-t-il localement ? | Oui, et il est déjà fourni sous forme d’image de conteneur |
| Credenciales | Elles sont nécessaires, car les dépôts privés ne peuvent pas être lus anonymement |
| Se connecte à | Un seul hôte, api.github.com |
| Fichiers | Aucun élément en dehors de la clé. Le travail s’effectue via l’API, donc il n’y a ni clone ni fichier de vérification sur le disque |
| Autres exigences du hôte | Rien |
| Récupération du code en temps de exécution | Non |
| Lista des outils | Possibilité de la réduire via --toolsets et --exclude-tools |
En résumé, les réponses décrivent la configuration : une seule identifiante, aucune dossier monté, une seule destination et une lista d’outils qui doit être affinée.
L’identifiante représente la partie la plus difficile, car elle ne peut pas être supprimée du schéma. Si un agent ouvre des demandes de pull, il doit disposer d’accès en écriture. On contourne ce problème en utilisant plutôt une application GitHub qu’un token d’accès personnel :
{
"mcpServers": {
"github": {
"command": "docker",
"args": [
"run",
"--rm",
"-i",
"--network",
"mcp-egress-github",
"--read-only",
"--tmpfs",
"/tmp",
"--cap-drop",
"ALL",
"--security-opt",
"no-new-privileges",
"--user",
"10001:10001",
"--log-driver",
"journald",
"-e",
"HTTPS_PROXY=http://mcp-egress-proxy:3128",
"-e",
"HTTP_PROXY=http://mcp-egress-proxy:3128",
"-v",
"/home/<user>/.config/mcp-gh/<app>.private-key.pem:/key.pem:ro",
"ghcr.io/github/github-mcp-server@sha256:508a0857ec762b1ab1cece29193345b501fab1dd9d1228a7b617062954cecac6",
"stdio",
"--app-id",
"NNNNNNN",
"--app-installation-id",
"NNNNNNNNN",
"--app-private-key-path",
"/key.pem",
"--toolsets",
"context,issues,pull_requests,repos",
"--exclude-tools",
"create_repository,fork_repository,get_teams,get_team_members,list_repository_collaborators"
]
}
}
}
Les couches entourant cette clé d’accès
- Tokens à courte durée de vie. Une application GitHub génère des tokens qui expirent rapidement.
- Montages en lecture seule. La clé de signature est montée en lecture seule et appartient au UID auquel le conteneur est associé, et non à l’utilisateur. Elle ne se trouve pas dans
~/.ssh, où elle ne serait ni une clé SSH ni lisible par l’utilisateur. - Conteneurs sans privilèges. Le daemon Docker fonctionne en mode sans root, le processus utilise un utilisateur non root et aucune capacité n’est accordée.
- Un répertoire, quatre permissions.
contents,issuesetpull_requestspermettent l’écriture,metadatapermet la lecture, et chaque token généré possède exactement ces permissions. - Un réseau scellé. Il n’y a pas de route directe vers l’extérieur, donc un proxy est le seul chemin possible.
- Une liste blanche d’égrenage. Tout ce qui est créé à l’intérieur du conteneur ne peut être envoyé qu’à
api.github.com. - Ensembles d’outils fixés, puis outils exclus.
--toolsetsretient des groupes entiers, tandis que--exclude-toolssupprime tout ce qui reste au sein des groupes conservés.
Les deux derniers points reçoivent peu d’attention. Réduire la liste des outils représente le niveau de privilèges le plus bas qui permette encore un accès en écriture. La liste blanche protège plus que simplement les fichiers locaux, car elle limite l’endroit où des identifiants volés peuvent être utilisés.
Cette affirmation mérite d’être vérifiée. Avec --toolsets context,issues,pull_requests,repos, le serveur met à disposition 42 outils. Cinq d’entre eux ne peuvent pas être utilisés avec ces permissions. Après l’ajout de --exclude-tools, il reste 37 outils, dont 15 permettent d’écrire. Comme --toolsets sélectionne des groupes entiers, repos inclut automatiquement create_repository et fork_repository, que le jeton puisse ou non les utiliser. 37 n’est pas un petit nombre, mais c’est une valeur honnête, et c’est ainsi que se manifeste le principe du moindre privilège lorsque un agent doit réellement pousser une branche.
Pourquoi la liste d’autorisation n’est pas excessive
Au début, la liste des autorisations semble excessive, jusqu’à ce qu’on se demande ce qu’elle empêche. Personne ne peut forcer le conteneur à contacter attacker.com ; par conséquent, un jeton créé à l’intérieur n’a nulle part hostile où aller. Le journal du proxy enregistre les deux résultats pour chaque tentative :
10.123.2.3 TCP_TUNNEL/200 CONNECT api.github.com:443 HIER_DIRECT/140.82.121.6
10.123.2.3 TCP_DENIED/403 CONNECT example.com:443 HIER_NONE/-
Le flag -e HTTPS_PROXY n’est pas ce qui impose cette règle. Linux ne dispose d’aucune notion intégrée de proxy, ni de commutateur au niveau du noyau ni de mécanisme de hook dans libc. Cette variable n’est qu’un texte dans l’environnement, et chaque client HTTP décide s’il doit la respecter. Le module net/http de Go la respecte, ce qui signifie que ce serveur en particulier n’a pas besoin de mesures supplémentaires. Le fetch intégré à Node ne la respecte pas, ce qui veut dire qu’un serveur Node ignorerait complètement cette configuration. La protection réside dans la topologie du réseau : en l’absence de route sortante, un client qui ignore cette variable ne se connecte pas directement, il génère simplement une erreur. Sur un réseau disposant d’une route, cette même négligence provoquerait une fuite de trafic sans aucun avertissement.
Vérification selon la liste OWASP MCP Top 10
La correspondance de cette configuration avec la liste OWASP MCP Top 10 qualifie chaque risque comme traité, résiduel et géré, non traité, ou non applicable à un serveur stdio local, avec des notes indiquant ce qui reste en suspens.
Qu’est-ce qui reste en dehors du périmètre
Aucun environnement isolé n’est jamais complet. Trois sujets se trouvent complètement en dehors de cette configuration : les serveurs MCP distants, les serveurs qui récupèrent des URL arbitraires, ainsi que le modèle lui-même.
Au-delà de ce point, le problème n’est plus une étiquette oubliée. Tous ces contrôles s’appliquent par conteneur, sont rédigés manuellement et doivent être dupliqués pour chaque serveur ajouté. Trois serveurs nécessitent trois listes d’autorisation et trois chaînes de paramètres d’outil, et aucun composant ne surveille la session dans son ensemble.
Ce qui fait défaut, c’est un gateway placé entre l’agent et ses serveurs. Un gateway peut supprimer complètement un outil de list_tools et examiner à nouveau chaque appel avant de le transmettre, de sorte que la liste des outils est mise à jour à chaque session, et non pour chaque fichier de configuration. Il ne peut toujours pas observer le comportement d’un serveur en cours d’exécution : fichiers ouverts, hôtes contactés, identifiants lus. Un serveur compromis n’a pas besoin d’appel d’outil pour envoyer des clés ailleurs. Un gateway ajoute une couche supplémentaire sans supprimer aucune des couches existantes.
Règles applicables à tout serveur local
Les réponses ci-dessus concernent GitHub. Les règles qu’elles définissent s’appliquent à tout serveur local que l’on s’apprête à intégrer dans une configuration :
- Préférez des identifiants qui expirent. Une application GitHub est préférable à un jeton d’accès personnel. Le conteneur conserve une clé de signature et génère un jeton frais à chaque utilisation, ce dernier expirant automatiquement sans attendre qu’on le révoque.
- Restreignez les permissions par domaine, pas seulement les identifiants. Un seul répertoire avec quatre permissions, chaque jeton ne contenant que celles-ci.
- Sécurisez le réseau. Comme il n’y a pas de route prédéfinie, le proxy n’est pas une configuration que le serveur peut refuser, contrairement à
-e HTTPS_PROXYqui n’est qu’une demande. - Créez une liste blanche des destinations. Un seul hôte,
api.github.com. Un identifiant volé dans ce conteneur ne peut pas être utilisé ailleurs, et toute tentative est enregistrée dans les journaux dans tous les cas.
--user 10001, retirez les capacités avec --cap-drop ALL, ajoutez --security-opt no-new-privileges et montez le système de fichiers en mode --read-only en utilisant un tmpfs pour les fichiers temporaires./key.pem:ro, sans espace de travail. L’association de $HOME à un conteneur ne constitue pas un encadrement sécurisé.--toolsets exclut certains groupes et --exclude-tools élimine ce qui reste, ramenant ainsi le nombre d’outils sur ce serveur de 42 à 37, dont 15 restent capables d’écrire.latest, ainsi que les étiquettes de version, car une étiquette peut être modifiée. Les deux images utilisées dans cette configuration, y compris le proxy, emploient @sha256:… afin de s’assurer qu’elles ne changent pas.Aucune règle unique ne détermine s’un dommage se produit. Un document contaminé peut encore inciter l’agent à effectuer une appel d’outil. Chaque règle limite la portée de la propagation d’une attaque, mais aucune ne verrouille le déclencheur. Un environnement sandbox régule où un programme peut communiquer, jamais ce qu’il dit.
La liste des autorisations montre les limites. Elle vérifie que le trafic se dirige vers api.github.com mais ne révèle rien au sujet du contenu. contents: write permet à l’agent de pousser une branche, tout en autorisant également une instruction injectée à valider un fichier. Les noms de branches, les messages de commit et les titres des issues semblent corrects individuellement, mais combinés, ils peuvent faire entrer n’importe quoi dans un répertoire que d’autres peuvent lire. Tout filtre suffisamment permissif pour que l’agent fonctionne laisse les données sortir, car le travail lui-même consiste en des lectures et des écritures sur GitHub.
Considérez donc tout ceci comme la couche de départ, et non la ligne d’arrivée, et mettez-la en place en premier. Le coût se compose de sept questions, d’environ dix minutes de lecture et d’une seule appel à tools/list. En retour, on obtient une configuration qui peut être protégée, alors qu’auparavant trois lignes étaient simplement collées sans réflexion.
Lectures complémentaires
- Sécuriser les outils MCP permettant l’écriture : sept couches de protection au-delà du jeton — Pourquoi un jeton MCP ne suffit pas à autoriser les écritures ultérieures, ainsi que les sept couches de contrôle, la séparation des identifiants, l’approbation des requêtes précises et les règles de tentative répétée qui permettent de le faire.
- Notes pratiques : Microsoft a construit le serveur MCP Playwright. Puis il vous a dit de le faire — Guide pas à pas des Notes pratiques : Microsoft a construit le serveur MCP Playwright. Puis il vous a dit de le faire : contrats, vérifications et emplacements de code prêts à l’emploi pour les équipes souhaitant utiliser ce modèle.