Aller au contenu
English

Limites des identifiants

  • Leçon 19
  • 50 min
  • Module 6 : Protéger les outils et le contrôle de l'utilisateur

Où nous en sommes

Dans les deux leçons précédentes, nous avons traité le texte externe comme non fiable et placé une personne entre le modèle et son effet. Mais les jetons et les clés eux-mêmes peuvent encore ouvrir les mauvaises portes. Dans cette leçon, nous vérifions qui détient quelle clé : le serveur refuse les jetons créés pour un autre service, l'application reçoit seulement les portées nécessaires, et la clé du modèle reste avec l'hôte. Nous commençons par les cartes-clés d'un hôtel.

Lue depuis YouTube. Rien ne se charge depuis YouTube avant que vous appuyiez sur lecture. Confidentialité

Ce que vous saurez faire

Un jeton ou une clé ressemble à une clé de porte. Cette leçon vérifie qui détient quelle clé, et quelles portes chaque clé ouvre. Vous verrez le serveur refuser un jeton créé pour un autre service. Vous donnerez à l’application seulement les portées nécessaires. Vous empêcherez aussi l’hôte de transmettre la clé du modèle au serveur.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 50 minutes

Ce que vous devez savoir

Votre projet

  • ~/projects/support-mcp après la dernière leçon : python -m pytest -q affiche 84 passed (84 tests réussis).
  • La clé du fournisseur d’identité d’exercice du module 5, dans .idp/. Si elle manque, exécutez python -m idp init.
  • Trois terminaux dans le dossier du projet, chacun avec l’environnement virtuel activé. Les ports 8000 et 8400 doivent être libres.

Un hôtel donne une carte-clé à chaque client. Elle ouvre une seule chambre, pendant les nuits payées, dans cet hôtel seulement. Le personnel d’entretien a une autre carte : plusieurs chambres, pendant les heures de travail seulement. Personne ne reçoit la clé passe-partout pour une tâche ordinaire.

Trois habitudes briseraient ces limites. Un client prête sa carte à un chauffeur de taxi. La réception distribue des clés passe-partout parce que c’est plus simple. Le voiturier conduit à l’endroit indiqué sur une note laissée sur le siège. Chaque habitude donne à quelqu’un une clé, ou une destination, dont son travail n’a pas besoin.

MCP présente les mêmes trois habitudes, avec des jetons et des clés plutôt que des cartes-clés. Elles se nomment transmission directe des jetons, identifiants trop permissifs et destinations sortantes sans restriction. Un identifiant est tout élément qui prouve votre identité auprès d’un service : jeton d’accès, clé d’API ou mot de passe.

Imaginez une version future de support-mcp. Les billets ne sont plus dans son propre fichier SQLite, mais derrière l’API de billets de Larkfield, celle du cours d’authentification. La conception rapide : le serveur prend le jeton d’accès de la personne dans la requête. Il transmet ensuite ce même jeton à l’API de billets.

C’est la transmission directe des jetons. Elle semble sans danger, puisque la personne peut lire ses billets. Mais réfléchissez à ce qu’elle exige et aux limites qu’elle brise :

  • Pour que le jeton fonctionne auprès des deux services, les deux doivent l’accepter. Son audience est donc incorrecte pour l’un, ou aucun ne la vérifie.
  • Les journaux de l’API de billets montrent le jeton de Sam, pas le serveur MCP. Personne ne peut déterminer quelle application a agi.
  • Un jeton volé ouvre maintenant deux portes plutôt qu’une.
  • Le serveur MCP devient un mandataire confus : un programme qui prête son accès à quiconque détient un jeton. Il ne vérifie pas que le jeton lui était destiné.

La spécification MCP l’interdit. Ses bonnes pratiques de sécurité précisent : les serveurs MCP « NE DOIVENT PAS accepter de jetons qui n’ont pas été explicitement émis pour le serveur MCP ». Ils ne doivent pas non plus transmettre le jeton d’un client.

L’audience (aud) d’un jeton désigne le seul service qui peut l’accepter, comme vous l’avez appris dans Ce que signifie un jeton. support-mcp vérifie que l’audience est sa propre URL canonique, http://127.0.0.1:8000/mcp. Un jeton créé pour un autre service reçoit une réponse HTTP 401. Si le serveur a un jour besoin de l’API de billets, il utilise son propre identifiant. Celui-ci a l’audience ticket-api et ses propres portées limitées. Chaque étape a son propre jeton.

Deux panneaux. À gauche, en pointillés rouges : transmission directe des jetons, interdite par la spécification. L'hôte envoie le jeton A de Sam au serveur MCP, qui transmet ce même jeton A à l'API de billets. Notes : l'API de billets voit le jeton de Sam, pas le serveur; ses journaux nomment donc le mauvais appelant. Le jeton A doit fonctionner auprès des deux services; son audience est donc incorrecte pour l'un ou les deux. Un jeton A volé ouvre les deux portes. Le serveur devient un mandataire confus : il prête sa position à quiconque détient le jeton. À droite, en vert : support-mcp, une audience par étape. L'hôte envoie le jeton de Sam avec aud http://127.0.0.1:8000/mcp à support-mcp. Celui-ci vérifie l'audience et lit ses propres données avec knowledge.py. Une flèche en pointillés vers l'API de billets, s'il en avait une : son propre identifiant. Une note : dans l'enregistrement, un jeton avec aud ticket-api envoyé à support-mcp reçoit HTTP 401. Le journal du serveur indique token_refused, raison wrong_audience. Le jeton ne quitte jamais le serveur.
Transmission directe des jetons ou une audience par étape. support-mcp accepte seulement les jetons créés pour lui et ne les transmet jamais.
Description textuelle du diagramme

Transmission directe des jetons (interdite) : l’hôte envoie le jeton A de Sam au serveur MCP. Le serveur transmet ce même jeton A à l’API de billets. L’API de billets voit Sam, pas le serveur. Le jeton A doit fonctionner auprès des deux services; la vérification de l’audience manque donc quelque part. Un jeton volé ouvre les deux portes, et le serveur devient un mandataire confus.

support-mcp, une audience par étape : l’hôte envoie le jeton de Sam, avec l’audience http://127.0.0.1:8000/mcp. Le serveur la vérifie et lit ses propres données. S’il appelait un jour l’API de billets, il utiliserait son propre identifiant. Dans l’enregistrement : un jeton avec l’audience ticket-api reçoit HTTP 401. Le serveur consigne token_refused (jeton refusé), wrong_audience (audience incorrecte).

Vous pouvez le voir dans votre projet. Le fournisseur d’exercice peut signer un jeton pour n’importe quelle audience avec --audience, un raccourci réservé aux exercices.

  1. Dans le terminal 1, démarrez le fournisseur d’identité :

    Fenêtre de terminal
    python -m idp

    Il n’affiche rien et continue de fonctionner.

  2. Dans le terminal 2, démarrez le serveur avec Streamable HTTP :

    Fenêtre de terminal
    python -m support_mcp --http

    Il affiche StreamableHTTP session manager started (gestionnaire de sessions Streamable HTTP démarré). Ses lignes de journal apparaissent dans ce terminal.

  3. Dans le terminal 3, créez le jeton normal de Sam et lisez ses revendications. La deuxième commande décode le jeton sans le vérifier, seulement pour vous montrer son contenu :

    Fenêtre de terminal
    TOKEN=$(python -m idp token --user usr-sam)
    python -c "import jwt,sys,json; print(json.dumps(jwt.decode(sys.argv[1], options={'verify_signature': False}), indent=1))" "$TOKEN"
    {
    "iss": "http://127.0.0.1:8400",
    "sub": "usr-sam",
    "aud": "http://127.0.0.1:8000/mcp",
    …
    "client_id": "support-host",
    "scope": "knowledge:read tickets:read"
    }

    L’audience est l’URL du serveur MCP. Les portées permettent de lire, pas de proposer.

  4. Créez un jeton pour un autre service, l’API de billets, et envoyez-le au serveur MCP :

    Fenêtre de terminal
    TOKEN=$(python -m idp token --user usr-sam --audience ticket-api)
    curl -i -X POST http://127.0.0.1:8000/mcp -H "Authorization: Bearer $TOKEN" -H "X-Support-Tenant: larkfield" -H "Accept: application/json, text/event-stream" -H "Content-Type: application/json" -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
    HTTP/1.1 401 Unauthorized
    www-authenticate: Bearer error="invalid_token", error_description="Authentication required", resource_metadata="http://127.0.0.1:8000/.well-known/oauth-protected-resource/mcp"
    {"error": "invalid_token", "error_description": "Authentication required"}

    La signature est valide, l’émetteur est correct et le jeton n’a pas expiré. Seule l’audience est incorrecte. L’équipe du cours n’a pas testé cette ligne curl dans PowerShell. Utilisez-y curl.exe et faites attention aux guillemets du JSON.

  5. Regardez le terminal 2. Le serveur a consigné la raison, que la réponse ne révèle pas :

    {"ts": "…", "event": "token_refused", "reason": "wrong_audience", "ms": 0.3}

L’absence de jeton donne la même réponse 401. L’appelant apprend seulement « non accepté ici »; la raison reste dans le journal du serveur. Les tests vérifient cinq autres jetons incorrects : expiré, autre émetteur, autre clé, algorithme none et texte aléatoire. Tous reçoivent 401.

Deuxième problème : plus de portées que nécessaire

Section intitulée « Deuxième problème : plus de portées que nécessaire »

Dans le module 5, l’équipe du cours a exécuté pour la première fois le client OAuth de la trousse SDK contre le serveur. L’hôte avait seulement besoin de lire. Le fournisseur offrait trois portées : knowledge:read, tickets:read et refunds:propose. Les métadonnées de ressource du serveur n’en indiquaient aucune. Voici la requête d’autorisation construite par la trousse SDK, tirée de l’enregistrement :

GET /authorize?response_type=code&client_id=client-…&…&code_challenge_method=S256
&resource=http%3A%2F%2F127.0.0.1%3A<port>%2Fmcp
&scope=knowledge%3Aread+tickets%3Aread+refunds%3Apropose

La trousse SDK a demandé toutes les portées, y compris celle d’écriture. La spécification indique au client de prendre les portées fournies par le serveur. Il les prend dans la réponse 401, sinon dans scopes_supported, dans les métadonnées de ressource. Quand le serveur n’en nomme aucune, le client ne devrait envoyer aucune portée. La version 2.3.0 de la trousse SDK va plus loin et prend la liste du serveur d’autorisation. La leçon Intégration d’OAuth l’a montré. Une application de lecture aurait donc détenu un jeton permettant de proposer des remboursements. Si ce jeton avait fuité, il aurait permis plus que le travail prévu.

L’idée : le moindre privilège, annoncé par le serveur

Section intitulée « L’idée : le moindre privilège, annoncé par le serveur »

Le moindre privilège signifie que chaque identifiant donne seulement les droits nécessaires à son travail. Pour les portées OAuth, le serveur aide : ses métadonnées de ressource protégée indiquent les portées nécessaires à un client normal. Les recommandations de sécurité de la spécification nomment une erreur courante : « publier toutes les portées possibles dans scopes_supported ».

support-mcp annonce maintenant seulement les deux portées de lecture. La trousse SDK les demande, et chaque jeton doit porter les deux. Un jeton qui en porte moins reçoit HTTP 403 avant la lecture de tout message MCP. La portée d’écriture est accordée séparément, à la personne et à la tâche qui en ont besoin.

Deux rangées. Avant la correction, en rouge : les métadonnées de ressource n'ont pas de scopes_supported. La trousse SDK utilise plutôt la liste du fournisseur, les trois portées. Elle demande knowledge:read tickets:read refunds:propose. Une application de lecture détient la portée d'écriture. Après la correction, en vert : les métadonnées de ressource indiquent scopes_supported knowledge:read tickets:read. La trousse SDK demande seulement ces deux portées. Le jeton porte knowledge:read tickets:read. propose_refund reçoit -32003 insufficient_scope. Une note en dessous : la portée d'écriture est accordée séparément, à la personne et à la tâche qui en ont besoin, avec python -m idp token --user usr-sam --scope knowledge:read tickets:read refunds:propose.
Le constat de ce cours sur les portées. Quand le serveur annonce seulement les portées de lecture, la trousse SDK n'en demande pas davantage.
Description textuelle du diagramme

Avant la correction : les métadonnées de ressource n’avaient pas de scopes_supported. La trousse SDK utilisait plutôt la liste du fournisseur et demandait les trois portées. Une application de lecture détenait la portée d’écriture.

Après la correction : les métadonnées indiquent knowledge:read et tickets:read. La trousse SDK demande ces deux portées. Le jeton porte ces deux portées, et propose_refund est refusé avec −32003 insufficient_scope (portée insuffisante).

La portée d’écriture est accordée séparément : python -m idp token --user usr-sam --scope "knowledge:read tickets:read refunds:propose".

Vérifiez chaque partie dans le terminal 3, avec les deux serveurs toujours en marche :

  1. Lisez les métadonnées de ressource du serveur :

    Fenêtre de terminal
    curl http://127.0.0.1:8000/.well-known/oauth-protected-resource/mcp
    {"resource":"http://127.0.0.1:8000/mcp","authorization_servers":["http://127.0.0.1:8400"],"scopes_supported":["knowledge:read","tickets:read"],"bearer_methods_supported":["header"]}
  2. Envoyez un jeton avec une seule portée de lecture :

    Fenêtre de terminal
    TOKEN=$(python -m idp token --user usr-sam --scope "knowledge:read")
    curl -i -X POST http://127.0.0.1:8000/mcp -H "Authorization: Bearer $TOKEN" -H "X-Support-Tenant: larkfield" -H "Accept: application/json, text/event-stream" -H "Content-Type: application/json" -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
    HTTP/1.1 403 Forbidden
    www-authenticate: Bearer error="insufficient_scope", error_description="Required scope: tickets:read", resource_metadata="http://127.0.0.1:8000/.well-known/oauth-protected-resource/mcp"

    403, pas 401 : le jeton est valide, mais ses droits sont insuffisants pour ce serveur.

  3. Demandez un remboursement avec un jeton de lecture normal, puis tapez y :

    Fenêtre de terminal
    TOKEN=$(python -m idp token --user usr-sam)
    python -m host "Ticket T-30002: propose a refund of 25 dollars" --http http://127.0.0.1:8000/mcp --token "$TOKEN" --tenant larkfield
    [person] said yes {"decision": "approved"}
    [server] protocol error -32003: insufficient_scope: this needs the scope refunds:propose {"code": -32003}
  4. Créez un jeton avec la portée d’écriture, puis demandez de nouveau avec y :

    Fenêtre de terminal
    TOKEN=$(python -m idp token --user usr-sam --scope "knowledge:read tickets:read refunds:propose")
    python -m host "Ticket T-30002: propose a refund of 25 dollars" --http http://127.0.0.1:8000/mcp --token "$TOKEN" --tenant larkfield
    [server] result: 397 characters {"ms": 4.3, "clipped": false}
    …
    Refund proposal OP-0001: pending_approval.

    Même le jeton d’écriture permet seulement de proposer. Grace décide toujours. Votre identifiant d’opération peut dépasser OP-0001 : les propositions de la dernière leçon sont toujours dans .support/state.db.

  5. Arrêtez le serveur et le fournisseur : appuyez sur Ctrl+C dans les terminaux 2 et 1.

Troisième problème : l’hôte transmet sa clé au serveur

Section intitulée « Troisième problème : l’hôte transmet sa clé au serveur »

L’hôte détient son propre secret : avec un vrai modèle, MODEL_API_KEY. Le serveur n’en a pas besoin. Pourtant, dans l’état actuel du projet, le serveur peut le lire. L’hôte démarre le serveur stdio avec tout son environnement :

host/app.py (part, before)
env = {**os.environ, "SUPPORT_USER": user, "SUPPORT_TENANT": tenant, "PYTHONUNBUFFERED": "1"}

L’équipe du cours l’a montré avec une clé d’exercice, practice-not-a-real-key. Elle a démarré un processus enfant exactement comme la trousse SDK démarre le serveur, avec le même environnement. Elle lui a ensuite demandé ce qu’il avait reçu :

14 variables: HOME, LC_CTYPE, LOGNAME, MODEL_API_KEY, MODEL_BASE_URL, MODEL_NAME, PATH, PYTHONPATH, PYTHONUNBUFFERED, SHELL, SUPPORT_TENANT, SUPPORT_USER, TERM, USER
MODEL_API_KEY readable by the server: True

support-mcp ne la lit pas. Mais beaucoup de serveurs exécutent du code écrit par d’autres personnes. Un serveur qui consigne son environnement, ou une dépendance malveillante, peut maintenant divulguer la clé qui paie votre modèle. Le module 4 a signalé cette ligne dans Intégration du client; vous la corrigez ici.

La correction est une liste d’autorisation de paramètres : l’hôte transmet seulement ce dont le serveur a besoin. La trousse SDK ajoute ensuite elle-même quelques variables sûres, comme PATH et HOME.

host/app.py (part, after)
SERVER_SETTINGS = ("SUPPORT_SCOPES", "SUPPORT_STATE", "SUPPORT_WRITES", "SUPPORT_SLOW_SECONDS")
def server_params(user: str, tenant: str, scopes: str | None = None) -> StdioServerParameters:
env = {k: os.environ[k] for k in SERVER_SETTINGS if k in os.environ}
env |= {"SUPPORT_USER": user, "SUPPORT_TENANT": tenant, "PYTHONUNBUFFERED": "1"}
...
  1. Avec une valeur d’exercice dans MODEL_API_KEY, affichez ce que l’hôte transmet au serveur actuellement :

    Fenêtre de terminal
    MODEL_API_KEY=practice-not-a-real-key python -c "from host import app; print(sorted(app.server_params('usr-sam', 'larkfield').env))"

    La liste contient toutes les variables de votre interpréteur de commandes, dont MODEL_API_KEY. Votre liste est plus longue que celle de l’équipe du cours, car un interpréteur normal contient plus de variables.

  2. Copiez les deux fichiers de cette leçon :

    Fenêtre de terminal
    S=../nextia-learning-labs/C28/snapshots/end-of-m06
    cp "$S/host/app.py" host/
    cp "$S/tests/test_credentials.py" tests/
  3. Exécutez de nouveau la commande de l’étape 1 :

    ['PYTHONUNBUFFERED', 'SUPPORT_TENANT', 'SUPPORT_USER']

    Le processus enfant de l’équipe du cours affichait maintenant 10 variables (10 variables). Il affichait aussi MODEL_API_KEY readable by the server: False (MODEL_API_KEY lisible par le serveur : faux).

  4. Exécutez les tests. Attendez-vous à 86 passed (86 tests réussis) : les deux tests de test_credentials.py sont nouveaux. L’un démarre un processus enfant comme le fait la trousse SDK et vérifie qu’il ne peut pas lire la clé.

  5. Sous Windows, supprimez la valeur d’exercice : Remove-Item Env:MODEL_API_KEY.

Quatrième problème : des requêtes vers n’importe où

Section intitulée « Quatrième problème : des requêtes vers n’importe où »

La dernière limite concerne la destination des requêtes. Un billet peut contenir une adresse Web. Un argument d’outil peut aussi en contenir une. Si le système récupère une URL parce qu’un texte la nomme, un attaquant choisit la destination. Une note placée à cette fin peut ainsi atteindre des services internes, comme l’adresse des métadonnées d’un nuage. La leçon Restreindre les capacités appelait cela SSRF, la falsification de requêtes côté serveur.

Pour MCP, les recommandations de sécurité de la spécification ajoutent un cas facile à manquer. Pendant la découverte OAuth, un client suit les URL fournies par le serveur. Ce sont le lien resource_metadata d’une réponse 401, la liste authorization_servers et les points de terminaison du fournisseur. Un serveur malveillant peut les diriger vers des adresses internes. Connectez-vous donc seulement aux serveurs que vous avez choisis. Un client exécuté sur un serveur devrait bloquer les adresses privées et utiliser HTTPS.

Regardez où support-mcp et son hôte envoient des requêtes. Une recherche des appels réseau dans le code en trouve trois, chacun vers une adresse provenant de la configuration :

L'hôte, python -m host, envoie des requêtes à deux endroits, tous deux configurés : l'API du modèle à MODEL_BASE_URL et support-mcp à l'URL --http. support-mcp envoie des requêtes à un endroit configuré : les clés du fournisseur à OIDC_JWKS_URL. Un encadré rouge en pointillés : jamais une destination : une URL dans un billet ou un texte de politique; une URL dans un argument d'outil écrit par le modèle; le iss d'un jeton, qui est vérifié, jamais récupéré; une URL nommée par la réponse 401 ou les métadonnées d'un serveur inconnu, le risque SSRF du client. Une note : chaque partie envoie des requêtes seulement aux adresses de sa propre configuration. Un texte lu par le modèle, ou un jeton, ne choisit jamais la destination d'une requête.
Toutes les requêtes sortantes du projet du cours, et les destinations qu'aucun texte ou jeton ne peut choisir.
Description textuelle du diagramme
  • L’hôte envoie des requêtes à l’API du modèle (MODEL_BASE_URL) et au serveur MCP (l’URL --http). Les deux proviennent de sa configuration.
  • support-mcp envoie un seul type de requête : il récupère les clés publiques du fournisseur depuis OIDC_JWKS_URL, aussi dans la configuration.
  • Jamais une destination : une URL dans un billet, un texte de politique ou un argument d’outil. Jamais le iss d’un jeton (vérifié, jamais récupéré), ni une URL dans la réponse 401 ou les métadonnées d’un serveur inconnu.

L’émetteur du jeton est un bon exemple. support-mcp ne lit pas iss pour ensuite y récupérer des clés. Il récupère les clés depuis sa propre URL configurée et compare iss avec son propre émetteur configuré. Un jeton provenant de http://evil.example échoue à la vérification; le test test_bad_tokens_get_401[other_issuer] le prouve. Si le serveur récupérait les clés auprès de l’émetteur du jeton, n’importe quel attaquant pourrait signer ses propres jetons.

Utilisez toujours les quatre. Elles font partie de la conception, ce ne sont pas des fonctionnalités supplémentaires.

  • Les vérifications d’audience coûtent un paramètre, MCP_RESOURCE_URL, qui doit correspondre à l’URL utilisée par les clients. Sinon, tous les jetons valides échouent. Un serveur derrière un mandataire demande une attention particulière ici.
  • Aucune transmission de jeton signifie que le serveur a besoin de son propre identifiant pour chaque service derrière lui. Chaque identifiant a sa propre rotation. Cela demande plus de configuration, mais permet de savoir qui a fait quoi.
  • Le moindre privilège signifie plus de jetons et plus de demandes de portée. Demandez la portée d’écriture quand la personne commence une tâche d’écriture, pas à la connexion.
  • Une liste d’autorisation de paramètres doit s’allonger quand le serveur a besoin d’un nouveau paramètre. Si vous en oubliez un, le serveur utilise sa valeur par défaut. Le test test_the_local_server_still_gets_its_own_settings détecte le cas courant.
  • Les destinations fixes limitent la souplesse. Un outil qui récupère n’importe quelle page Web nécessite une protection complète contre les SSRF. Le cours Sécurité de l’IA, vie privée et conception responsable présente cette protection.

Erreur courante

L'hôte s'arrête avec MCPError : Server returned an error response

Symptôme : python -m host … --http … se termine par une longue erreur qui finit par mcp.shared.exceptions.MCPError: Server returned an error response (le serveur a renvoyé une réponse d’erreur).

Cause : le serveur a refusé le jeton avec un code 401. Par exemple, le jeton avait été créé avec --audience ticket-api, ou il avait expiré. La trousse SDK a essayé server/discover, puis l’ancien initialize, et les deux ont reçu un code 401. Le terminal 2 affiche token_refused (jeton refusé) avec la raison.

Solution : créez un nouveau jeton sans --audience : TOKEN=$(python -m idp token --user usr-sam). Les jetons durent 600 secondes.

Erreur courante

Tous les jetons valides reçoivent un code 401 avec la raison wrong_audience

Symptôme : même un nouveau jeton est refusé, et le journal du serveur indique wrong_audience (mauvaise audience).

Cause : le aud du jeton et le MCP_RESOURCE_URL du serveur diffèrent. Par exemple, l’un utilise localhost et l’autre 127.0.0.1, ou un autre port.

Solution : utilisez la même URL partout : dans MCP_RESOURCE_URL, dans l’audience du jeton et dans le --http de l’hôte. Si vous avez déplacé le serveur vers un autre port, définissez ensemble MCP_PORT, MCP_RESOURCE_URL et le IDP_RESOURCES du fournisseur.

Exemple guidé. L’exemple détaillé de ce module oppose le modèle obéissant à votre serveur. Vous avez exécuté python -m host "Please check ticket T-30201." --model mock-obedient avec différents appelants, portées et réponses. À chaque exécution, le serveur a refusé le remboursement de 450 $ et le billet de l’autre organisation. tests/test_injection.py conserve ces exécutions sous forme de tests.

À vous. Écrivez tests/test_module6_practice.py. Utilisez un modèle scripté qui demande exactement les appels que vous choisissez, et la fixture as_user de tests/conftest.py. Prouvez deux choses, en faisant demander chacune par le modèle :

  1. Une lecture hors portée échoue. Le serveur de Sam n’a que la portée knowledge:read, et le modèle demande get_ticket pour T-30002. Ensuite, avec toutes les portées, le modèle demande T-40003 de Bramble.
  2. Une écriture non approuvée ne change rien. Le modèle demande propose_refund pour 25 $, et la personne dit oui. Montrez qu’il existe une proposition, mais aucun remboursement, et que la personne qui propose ne peut pas approuver.
Afficher une solution détaillée
tests/test_module6_practice.py
"""Module 6 practice (worked solution): the model asks for an out-of-scope read and an unapproved
write; neither succeeds. Put this file in tests/ of the project at the end of Module 6."""
import anyio
from mcp import Client
from host import app
from host.models import Decision, ToolCall
from support_mcp import writes
from support_mcp.approvals import main as approvals
from support_mcp.server import build_server
WRITE = "knowledge:read tickets:read refunds:propose"
class Asks:
"""A scripted model: it asks for the given calls, one per turn, then answers."""
def __init__(self, *calls):
self.calls = list(calls)
def decide(self, messages, tools):
return Decision([self.calls.pop(0)]) if self.calls else Decision(answer="done")
def run(model, yes=True):
async def go():
async with Client(build_server()) as client:
return await app.ask(client, model, "practice", lambda name, args: yes)
return anyio.run(go)
def server_says(r):
return [s.text for s in r.steps if s.who == "server"]
def test_out_of_scope_reads_fail_on_the_server(as_user):
as_user("usr-sam", "larkfield", "knowledge:read") # no tickets:read in the scopes
r = run(Asks(ToolCall("c1", "get_ticket", {"ticket_id": "T-30002"})))
assert server_says(r) == ["protocol error -32003: insufficient_scope: this needs the scope tickets:read"]
as_user("usr-sam", "larkfield", WRITE) # every scope, but the ticket is Bramble's
r = run(Asks(ToolCall("c1", "get_ticket", {"ticket_id": "T-40003"})))
assert "not_found: there is no ticket T-40003 in this organization" in server_says(r)[0]
def test_an_unapproved_write_changes_nothing(as_user, capsys):
as_user("usr-sam", "larkfield", WRITE)
r = run(Asks(ToolCall("c1", "propose_refund", {"ticket_id": "T-30002", "amount": "25", "reason": "Charged twice"})))
assert server_says(r)[0].startswith("result:") # recorded as a proposal, nothing more
assert [p["status"] for p in writes.pending()] == ["pending_approval"]
assert writes.refunds() == []
assert approvals(["approve", "OP-0001", "--user", "usr-sam"]) == 1 # the proposer is staff, not an owner
assert "only an owner of larkfield can decide" in capsys.readouterr().err
assert writes.refunds() == []
def test_a_write_over_the_limit_is_not_even_proposed(as_user):
as_user("usr-sam", "larkfield", WRITE)
r = run(Asks(ToolCall("c1", "propose_refund", {"ticket_id": "T-30002", "amount": "450", "reason": "x" * 3})))
assert "over_limit" in server_says(r)[0]
assert writes.pending() == [] and writes.refunds() == []

python -m pytest -q tests/test_module6_practice.py affiche 3 passed (3 tests réussis), et la suite complète affiche 89 passed (89 tests réussis). Chaque test envoie la requête du modèle par le véritable hôte et le véritable serveur. Les refus viennent donc du code du serveur. Le troisième test est un ajout : il montre une écriture que le serveur refuse avant qu’une personne la voie.

Votre fichier peut être différent. Vérifiez trois choses. Le modèle demande chaque opération; vous n’appelez pas le serveur en contournant l’hôte. Chaque test vérifie le refus du serveur et l’état après l’opération : aucune proposition ou aucun remboursement. Et aucun test ne modifie le serveur pour réussir.

Vérifiez votre compréhension

Un collègue propose que support-mcp transmette le jeton d'accès de la personne à l'API de billets, puisqu'elle peut déjà lire ses billets. Nommez deux problèmes et la conception qui remplace cette approche.

Afficher la réponse

N’importe lesquels de ces deux problèmes. Le jeton aurait besoin d’une audience acceptée par les deux services. Au moins un des services ne vérifierait donc pas l’audience. Les journaux de l’API de billets montreraient la personne, pas le serveur MCP. Personne ne pourrait donc savoir quelle application a agi. Un jeton volé donnerait accès aux deux services. Et le serveur MCP devient un intermédiaire trompé qui prête son accès à toute personne détenant un jeton. La spécification MCP l’interdit : les serveurs ne doivent pas accepter de jetons qui n’ont pas été émis pour eux. La solution de remplacement utilise une audience par étape. support-mcp accepte uniquement les jetons pour http://127.0.0.1:8000/mcp. Pour l’API de billets, il utilise son propre identifiant, avec l’audience ticket-api et des portées restreintes.

Vérifiez votre compréhension

Prédisez : vous retirez required_scopes des AuthSettings du serveur et exécutez python -m scripts.oauth_login. Quelles portées la trousse SDK demande-t-elle, et pourquoi est-ce un problème?

Afficher la réponse

Les métadonnées de la ressource ne présentent plus scopes_supported, et la réponse 401 ne nomme aucune portée. Selon la spécification, aucune portée ne serait alors envoyée. Mais la trousse SDK 2.3.0 utilise plutôt la liste du serveur d’autorisation : knowledge:read tickets:read refunds:propose. Le cours a enregistré exactement ce comportement avant la correction. Une application de lecture détient alors un jeton qui peut proposer des remboursements. S’il fuit, les dommages dépassent les besoins de la tâche. Quand les portées de lecture sont annoncées, la trousse SDK demande uniquement ces deux portées.

Vérifiez votre compréhension

Vérification pratique : montrez que le serveur stdio ne peut pas lire MODEL_API_KEY après cette leçon. Nommez le test qui maintient cette protection.

Afficher la réponse

Avec une valeur d’exercice définie, python -c "from host import app; print(sorted(app.server_params('usr-sam', 'larkfield').env))" affiche ['PYTHONUNBUFFERED', 'SUPPORT_TENANT', 'SUPPORT_USER']. Avant la modification, la liste contenait tout l’environnement de l’interpréteur de commandes, y compris MODEL_API_KEY. Le test est test_the_local_server_never_gets_the_model_key dans tests/test_credentials.py. Il démarre un processus enfant avec l’environnement créé par la trousse SDK et vérifie que MODEL_API_KEY n’y figure pas.

Vérifiez votre compréhension

Vérification de fin de module : prouvez qu'une lecture hors portée et une écriture simulée non approuvée échouent, même si le modèle les demande. Fournissez les preuves pour chacune.

Afficher la réponse

Une réponse complète contient des preuves de vos propres exécutions pour les deux opérations.

  1. Lecture hors portée. Le modèle la demande, et le serveur la refuse. Exemples : get_ticket avec seulement knowledge:read donne −32003 insufficient_scope: this needs the scope tickets:read (portée insuffisante : la portée tickets:read est nécessaire). get_ticket pour T-40003 sur une connexion Larkfield donne not_found … in this organization (introuvable dans cette organisation). Par HTTP, un jeton avec seulement knowledge:read reçoit un code 403 insufficient_scope (portée insuffisante). Dans le tableau des tentatives, les 6 lectures du billet de l’autre organisation échouent avec not_found (introuvable).
  2. Écriture non approuvée. Le modèle obéissant demande un remboursement de 450 $, et la personne dit oui : over_limit (limite dépassée), et approvals list est vide. Ou une proposition de 25 $ est enregistrée comme OP-0001 pending_approval (en attente d’approbation), approvals refunds est vide, et approve … --user usr-sam est refusé. Le tableau des tentatives se termine par « Refunds recorded : 0 » (remboursements enregistrés : 0).

Chaque preuve nomme la vérification qui a refusé l’opération : portée, organisation, rôle, limite ou approbation, toutes à l’extérieur du modèle. Des tests comme votre fichier d’exercice ou tests/test_injection.py rendent les preuves reproductibles. Démontré exige les deux opérations, avec les sorties de vos exécutions et le nom de la vérification décisive. Uniquement le parcours réussi, ou un refus par l’hôte seul (« la personne a refusé »), est partiellement démontré. L’hôte n’est pas un contrôle côté serveur.

Récapitulatif

  • Aucune transmission de jeton : support-mcp accepte uniquement les jetons dont l’audience est sa propre URL. Il ne transmet jamais le jeton d’un client. Un jeton pour ticket-api reçoit un code 401; le journal indique wrong_audience.
  • Moindre privilège : le serveur annonce uniquement les portées de lecture, donc la trousse SDK n’en demande pas davantage. La portée d’écriture est accordée séparément.
  • Chaque partie détient uniquement ses propres secrets : l’hôte transmet maintenant au serveur une liste d’autorisation de paramètres, jamais la clé du modèle.
  • Destinations fixes : chaque requête va à une adresse configurée. Aucun billet, argument, jeton ou serveur inconnu ne choisit cette adresse.

Récapitulatif du module. Vous avez traité chaque texte qui atteint le modèle comme des données non fiables. Vous avez observé un modèle obéissant construit échouer face aux vérifications du serveur. Vous avez ajouté l’unique écriture sous forme de proposition, avec des barrières côté serveur et l’approbation d’une deuxième personne. Ensuite, vous avez fermé les limites des identifiants : audience, portées, clé du modèle et destinations sortantes. Votre projet correspond à l’instantané end-of-m06 : 86 passed (86 tests réussis).

Ensuite, vous fixerez les promesses du serveur dans un contrat et les testerez avec plus d’un client.

Leçon suivante : Tests de contrat et de compatibilité