iamops.dev
Argo sur X Flux RSS
FRFrançais

Labs Approfondissement · 35 minutes

Un receiver Shared Signals devant un serveur MCP : un événement CAEP coupe un agent

Un receiver SSF devant un serveur MCP, alimenté par le transmitter open source SSFgo : un événement CAEP session-revoked a coupé un appel en cours en 8 ms.

Deux captures de terminal de mon lab Shared Signals : un appel d’export coupé avec session revoked by the identity provider, et le journal de la passerelle avec l’événement et les réponses 401 qui ont suivi.
En brefJ’ai placé un receiver Shared Signals devant un serveur Model Context…
  • J’ai placé un receiver Shared Signals devant un serveur Model Context Protocol (MCP), alimenté par le transmitter open source SSFgo. Un événement session-revoked pour alice a coupé son export et refusé ses appels suivants, pendant que l’agent de bob continuait.
  • Entre l’appel admin et l’application de l’événement par la passerelle, il a fallu 8 ms en médiane sur dix essais, sur une seule machine. Un jeton émis dans la même seconde que la révocation a aussi été refusé, car iat est en secondes entières.
  • Les événements forgés, non signés, mal adressés et rejoués ont été refusés ou ignorés. L’événement rejoué a reçu 202 et n’a rien changé.
  • Couper une session d’agent plutôt que l’utilisateur demandait un subject complexe. Le profil d’interopérabilité du Continuous Access Evaluation Profile (CAEP) le refuse, et un stream abonné à alice en iss_sub ne l’a jamais reçu.
  • Non exécuté : un vrai fournisseur d’identité comme transmitter, OAuth (Open Authorization) pour l’interface de programmation (API) du stream, la livraison en poll, un stockage durable des révocations et un client MCP qui gère le 401.
Refaire ce lab 12 étapes

J’ai écrit ce lab pour que vous puissiez le refaire vous-même. Chaque étape contient les commandes à copier et la sortie que j’ai obtenue, et vous pouvez la cocher une fois faite. Les coches restent uniquement dans ce navigateur.

Aller aux étapes

Comment ça marche

Copie un prompt prêt à l’emploi pour Claude Code, Cursor, Codex ou tout autre agent de code. Pour les environnements de test uniquement.

Afficher le prompt
I want to run a hands-on lab from iamops.dev, and I would like your help to do it safely.

Lab: Un receiver Shared Signals devant un serveur MCP : un événement CAEP coupe un agent
Read the whole lab here (Markdown): https://iamops.dev/fr/ssf-caep-receiver-mcp-gateway.md

What the lab needs before the first step:
- Linux with Go 1.26.10 or newer (tested with 1.27.3), Python 3.13, openssl, curl and jq
- An empty folder for the lab; run every step from inside it

How I want you to work:
1. Read the lab from start to finish first (each step lists its own prerequisites). Then check that the prerequisites are in place and that the tool versions match what the lab expects. Tell me what is missing before you run anything.
2. Run one step at a time. Before each command, show it to me and say in a sentence what it does.
3. Ask me before anything that costs money, creates cloud resources, touches a real tenant or account, or deletes anything. Wait for my answer.
4. Use the placeholders from the lab. Never paste real secrets, tokens or production identities into a command, a file or this chat. If a value is needed, tell me where to set it myself.
5. After each step, compare the output with the expected output in the lab. If it does not match, stop and tell me what differs. Do not carry on or invent a fix without asking me.
6. At the end, report what passed, what failed and which cleanup you did. Then offer to tick the steps off for me. The lab page keeps ticks only in my browser, so if you cannot do that, list the steps I should tick.

iamops.dev tools to use on the way (they run in my browser; paste only the lab's own test values, never a real token or key):
- Step 5 (Get a token and read what the gateway checks): open iamops.dev JWT tool (https://iamops.dev/tools/jwt/). Look for: Paste the lab access token from alice.jwt. Check typ at+jwt, the aud that names the MCP endpoint, and the sid claim the gateway uses to revoke one session.
- Step 7 (Verify the SET the gateway received): open iamops.dev Shared Signals decoder (https://iamops.dev/tools/shared-signals/). Look for: Paste last-set.jwt. Check typ secevent+jwt, the session-revoked event type, the iss_sub subject and that there is no exp claim.

This lab is for test environments only. Do not run it against production, or against a tenant or account that holds real data or real users.

You may answer in my language.

Le 17 novembre 2026, le groupe de travail Shared Signals a fusionné une courte modification du CAEP Interoperability Profile : l’obligation de signer chaque événement en RS256 avec une clé de 2048 bits a disparu. La copie de travail porte la même date. Une seconde pull request, la #362, toujours ouverte, propose des formats de subject pour les agents et les workloads.

Les deux changements retombent sur le receiver. Sans algorithme fixé par le profil, c’est au receiver de décider ce qu’il accepte. Et quand le subject est un agent, le receiver est en général ce qui se trouve devant les outils de l’agent. J’en ai donc construit un : un receiver Shared Signals dans une petite passerelle devant un serveur MCP, alimenté par un transmitter open source, et j’ai cherché ses défauts.

Si Shared Signals est nouveau pour vous, j’ai écrit une explication courte et un article Knowledge sur le Shared Signals Framework (SSF), CAEP et Risk Incident Sharing and Coordination (RISC).

Ce que le lab construit#

  • Un fournisseur d’identité de lab sur le port 9443, qui signe les jetons d’accès pour le serveur MCP et embarque le transmitter SSFgo v0.4.2 (SSF 1.0, CAEP 1.0, livraison push des Security Event Tokens (SET) selon la Request for Comments (RFC) 8935).
  • Un serveur MCP sur le port 9000 avec deux outils : un list_orders rapide et un export_orders lent qui signale sa progression pendant 20 secondes.
  • Une passerelle sur le port 9444 qui vérifie chaque bearer token, relaie les requêtes MCP et reçoit les événements poussés sur /ssf/events.
  • Des agents construits sur le kit de développement logiciel (SDK) MCP Python 2.3.0, en révision MCP 2026-07-28.

La révision MCP compte ici. En 2026-07-28, une requête Hypertext Transfer Protocol (HTTP) est un POST autonome, sans poignée de main initialize ni Mcp-Session-Id. Il n’y a pas de session MCP à fermer. La seule session qui reste est celle du fournisseur d’identité, portée dans le jeton sous la forme sid. Quand un événement arrive, la passerelle a deux tâches : refuser désormais les jetons de cet utilisateur ou de cette session, et couper tout appel d’outil encore en cours.

Diagramme de séquence : un agent obtient un jeton auprès de l’IdP du lab et appelle export_orders via la passerelle, qui relaie au serveur MCP. L’IdP pousse un SET CAEP session-revoked pour alice ; la passerelle le vérifie, répond 202, coupe l’appel en cours avec l’erreur JSON-RPC -32001 et répond à l’appel suivant par 401 invalid_token.
Le flux tel que je l’ai exécuté. Le jeton porte sub et sid. L’événement désigne alice par émetteur et subject. La passerelle coupe ce qui tourne et refuse ce qui suit.

Mise en place#

Tout a tourné sur une machine Linux le 22 novembre 2026 : Go 1.27.3 pour le fournisseur d’identité, Python 3.13.5 avec le SDK MCP 2.3.0, PyJWT 2.15.1, httpx 0.28.1 et Starlette 1.10.0 pour le reste. SSF exige https pour l’émetteur et pour les endpoints de push, donc make-certs.sh crée une autorité de certification (CA) jetable et un certificat pour localhost. Trois jetons aléatoires du lab vont dans .env : un pour l’API du stream, un que le transmitter envoie avec chaque push, un pour l’action admin qui révoque un utilisateur.

Le fournisseur d’identité est un substitut. Il signe un jeton pour quiconque le demande, il ne dit donc rien de la connexion. Il montre la partie d’après : un seul émetteur pour le jeton d’accès et pour les événements, si bien que iss et sub dans le jeton forment la même paire que celle nommée par l’événement.

Par défaut, SSFgo refuse de pousser vers des adresses de loopback, pour se protéger d’un receiver qui enregistrerait une adresse web (URL) interne. Le lab remplace son client HTTP par un client qui fait confiance à la CA du lab. En production, je garderais le défaut et listerais explicitement les hôtes internes.

Le stream#

La passerelle est un receiver, elle commence donc par lire les métadonnées du transmitter. L’outil en ligne de commande de SSFgo, lancé comme le ferait un receiver, les a acceptées. J’ai ensuite créé un stream push qui ne demande que session-revoked, avec l’endpoint de push et la valeur bearer que le transmitter doit envoyer.

Terminal : ssf metadata accepte le transmitter, les métadonnées listent la livraison push et poll et default_subjects NONE, le stream est créé avec events_delivered session-revoked, et la configuration du stream renvoie l’en-tête d’autorisation du push en entier.
Métadonnées et stream. La configuration du stream revient avec l’en-tête d’autorisation du push en entier.

La dernière ligne m’a surpris. La réponse à la création renvoyait authorization_header avec le jeton de push complet. Quiconque peut lire la configuration du stream avec le jeton du receiver peut lire le secret auquel la passerelle se fie pour les événements entrants. Traitez le jeton de l’API du stream comme un secret de même valeur.

Le transmitter annonce default_subjects: NONE, la passerelle doit donc ajouter chaque subject pour lequel elle veut des événements. J’ai ajouté alice et bob comme subjects iss_sub et demandé un événement de vérification. Le transmitter a journalisé le push comme livré en 10 ms.

Terminal : l’ajout des subjects alice et bob renvoie HTTP 200, l’état du stream est enabled, verify renvoie 204, la passerelle journalise l’événement de vérification avec le state lab-check-1 et le transmitter un push livré en 10 ms.
Subjects et vérification. La valeur de state revient dans un événement signé, la passerelle sait donc que le chemin du push fonctionne de bout en bout.

Le jeton que vérifie la passerelle#

Le jeton d’accès est un JavaScript Object Notation (JSON) Web Token (JWT) avec typ at+jwt, l’URL /mcp de la passerelle comme audience et un sid. Je l’ai collé avec le JSON Web Key Set (JWKS) des jetons dans l’outil JWT d’iamops.dev, avec l’émetteur et l’audience attendus. Signature, émetteur et audience correspondaient.

Terminal : l’en-tête du jeton décodé avec alg RS256, kid at-1 et typ at+jwt, et le payload avec aud https://localhost:9444/mcp, client_id support-agent, iss, sid, sub alice et une durée de vie d’une heure.
Le jeton d’accès. sub et sid sont ce que la passerelle compare aux événements.
Outil JWT d’iamops.dev : le jeton et la clé collés sont floutés, signature valide en RS256 avec kid at-1, constats durée de vie 1h, non expiré, audience et émetteur conformes, et la table des claims avec sid et sub alice.
Le même jeton dans l’outil JWT d’iamops.dev. Le jeton et la clé collés sont floutés et l’empreinte de la clé est remplacée.

Couper les agents d’alice#

Trois agents tournaient en même temps : l’agent d’export d’alice sur l’outil lent, son agent de facturation qui appelait l’outil rapide toutes les deux secondes, et l’agent de support de bob qui faisait de même. Au bout de sept secondes, j’ai révoqué alice auprès du fournisseur d’identité.

Terminal : l’agent d’export affiche une progression de 5 à 35 pour cent puis refused avec MCPError session revoked by the identity provider, call cut. L’agent de facturation d’alice réussit quatre fois et est refusé après la révocation. L’agent de support de bob réussit à chaque fois.
La coupure. L’export s’est arrêté à 35 pour cent. L’agent de facturation d’alice a été refusé dès l’appel suivant. bob n’a pas été touché.

Le journal de la passerelle montre l’ordre. L’événement est arrivé à 10:39:50.971, l’export en cours a été coupé dans la même milliseconde, et chaque requête suivante avec un jeton d’alice a reçu 401. Le transmitter a journalisé un push, livré en 4 ms.

Terminal : lignes du journal de la passerelle avec les appels d’outils de bob et d’alice relayés, puis ssf session-revoked pour toutes les sessions d’alice avec un appel en cours coupé, cut in-flight export_orders, et 401 pour la session de facturation d’alice pendant que les appels de bob sont toujours relayés. Le journal de l’IdP montre un push livré en 4 ms.
Le journal de la passerelle. Un événement, un appel en cours coupé, puis 401 pour alice et relais pour bob.

Chaque tentative refusée apparaît deux fois dans le journal. Le client du SDK sonde d’abord avec server/discover puis, en cas d’échec, essaie l’ancienne poignée de main initialize. Les deux ont reçu 401. L’agent n’a affiché que “Server returned an error response” : le SDK n’a montré à mon code ni le 401 ni l’en-tête WWW-Authenticate.

Le SET sur le fil#

La passerelle a enregistré le dernier événement accepté. ssf verify de SSFgo l’a contrôlé avec les clés publiées du transmitter, l’émetteur et l’audience, comme le ferait un receiver. Le subject est iss_sub avec alice, et l’événement porte initiating_entity admin et la raison que j’avais saisie.

Terminal : ssf verify affiche verified true, l’en-tête avec alg RS256, typ secevent+jwt et kid ssf-set-1, sub_id iss_sub alice et l’événement session-revoked avec event_timestamp, initiating_entity admin et reason_admin Agent misuse reported.
L’événement. Un Security Event Token : typ secevent+jwt, sub_id à la place de sub, pas d’exp.

Le décodeur de SET Shared Signals d’iamops.dev a lu le même événement avec le JWKS du transmitter et vérifié la signature. Il nomme le type d’événement, explique le subject iss_sub et signale le claim txn ajouté par SSFgo.

Décodeur de SET Shared Signals d’iamops.dev : le SET et le JWKS collés sont floutés, le SET est bien formé pour SSF 1.0, la signature est vérifiée avec kid ssf-set-1, l’événement CAEP session revoked avec la raison Agent misuse reported, le subject iss_sub alice et les claims du SET avec les identifiants aléatoires remplacés.
Le même SET dans le décodeur d’iamops.dev. Valeurs collées floutées, identifiants aléatoires remplacés.

Événements forgés et rejoués#

attacks.py poste directement sur /ssf/events. Sans le jeton de push, ou avec le mauvais, la passerelle a répondu 401. Un corps JSON a reçu 400 invalid_request. Un événement signé avec ma propre clé mais avec le kid du transmitter a reçu 400 invalid_key, tout comme alg: none, car la passerelle n’accepte que RS256. Un typ JWT a été refusé. Le rejeu du dernier vrai événement a reçu 202, comme le prévoit RFC 8935 pour un événement déjà reçu, et n’a rien changé : la passerelle garde chaque jti appliqué.

Terminal : sept push avec les résultats 401, 401, 400 invalid_request, 400 invalid_key pour une clé étrangère, 400 invalid_key pour alg none, 400 invalid_request pour typ JWT, 202 pour le rejeu ; la liste des utilisateurs révoqués ne contient toujours qu’alice. Un événement pour carol, absente du stream, est émis mais pas poussé. Une nouvelle connexion d’alice fonctionne.
Mauvais événements. Six refusés, le rejeu accepté et ignoré. Un événement pour un subject absent du stream n’a jamais été poussé.

Deux autres résultats dans la même capture. Un événement pour carol, absente du stream, a été émis par le fournisseur d’identité mais jamais poussé. Et alice s’est reconnectée après la révocation et a obtenu un jeton qui fonctionnait. Une révocation de session termine des sessions, elle ne verrouille pas le compte. Si le compte doit rester bloqué, c’est au fournisseur d’identité de refuser la connexion, et l’événement à envoyer est un autre.

Je n’ai pas testé une mauvaise audience ou un mauvais émetteur sur un événement correctement signé. Il faudrait un second stream ou un second transmitter avec ses propres clés, et je n’ai lancé ni l’un ni l’autre.

À quelle vitesse, et le trou de la même seconde#

measure.py a appelé l’endpoint admin dix fois et interrogé la passerelle jusqu’à ce qu’elle ait appliqué chaque événement : 8, 8, 8, 8, 9, 7, 8, 7, 7 et 7 ms, soit une médiane de 8 ms. C’est une seule machine en loopback, on mesure donc le logiciel, pas un réseau.

Terminal : dix essais entre 7 et 9 ms avec une médiane de 8 ms ; puis un extrait de journal où le session-revoked pour alice est appliqué à 10:40:58.059, un jeton pour alice est émis dans la même seconde et la passerelle répond 401 pour cette nouvelle session.
Temps, et un effet de bord. Un jeton émis moins d’une seconde après la révocation, dans la même seconde, a été refusé.

L’effet de bord venait de ma propre règle. La passerelle refuse tout jeton d’un utilisateur révoqué dont iat est égal ou antérieur à l’heure de l’événement, et les deux sont en secondes entières. Le dernier essai de mesure a révoqué alice à 10:40:58.059. L’étape suivante l’a connectée à 10:40:58 et ce jeton a été refusé. Arrondir dans l’autre sens laisserait passer un jeton émis juste avant la révocation. J’ai gardé le côté strict et je ferais de même en production, avec une note pour le support.

Révoquer une session d’agent, pas l’utilisateur#

Révoquer alice a coupé tous ses agents. Souvent on veut moins : terminer la session de l’agent de facturation et laisser tourner ses autres agents. SSF a pour cela un subject complexe, avec un membre user et un membre session.

Le profil d’interopérabilité CAEP, tel que SSFgo l’applique, n’autorise que les subjects email et iss_sub : le transmitter a refusé l’événement avec HTTP 422. J’ai redémarré le fournisseur d’identité avec les règles simples de SSF 1.0 et CAEP 1.0, recréé le stream et abonné alice en iss_sub. L’événement de session a été émis et jamais poussé. Les règles de correspondance des subjects, section 8.1.3 de SSF 1.0, couvrent deux subjects simples ou deux complexes, et ne disent rien d’un mélange. SSFgo le lit ainsi : un subject simple ne correspond jamais à un subject complexe.

Terminal : la révocation avec un identifiant de session est refusée avec HTTP 422 car, sous le profil interop, les événements CAEP doivent utiliser un subject email ou iss_sub ; l’IdP redémarre avec le profil ssf, un nouveau stream est créé et alice ajoutée en iss_sub ; l’événement de session est émis mais le journal du transmitter ne montre aucun push et la passerelle a compté zéro événement session-revoked.
Deux façons de perdre un événement de session. Le profil le refuse, et un abonnement simple ne lui correspond pas.

La solution a été d’abonner un subject complexe avec seulement user. Les membres que l’abonnement omet valent joker, il correspond donc à toute session d’alice. Avec cela, l’événement est arrivé, la passerelle n’a révoqué que le sid de l’agent de facturation, et l’agent de support d’alice a continué à recevoir 200.

Diagramme de séquence : sous le profil interop, un subject complexe est refusé avec 422 ; après un redémarrage avec le profil simple, l’événement est émis mais pas poussé car il ne correspond pas à l’abonnement iss_sub ; après l’abonnement d’un subject complexe avec user alice, le SET arrive, la passerelle révoque un sid, l’agent de facturation reçoit 401 et l’agent de support 200.
Une session, trois tentatives. Seul l’abonnement complexe l’a livré.
Terminal : l’ajout d’un subject complexe avec user alice renvoie 200 ; deux agents d’alice tournent ; la révocation avec le sid de l’agent de facturation renvoie subject_format complex ; l’agent de facturation est refusé dès l’appel suivant tandis que l’agent de support réussit à chaque fois ; la passerelle journalise session-revoked pour une session et l’IdP un push livré en 7 ms.
Une session d’agent coupée. Même utilisateur, deux agents, un refusé.

Le décodeur montre le subject complexe en deux parties : alice en iss_sub et la session comme identifiant opaque.

Décodeur de SET Shared Signals d’iamops.dev avec un SET session-revoked dont le sub_id est complex, avec un membre user iss_sub alice et un membre session opaque portant l’identifiant de session ; signature vérifiée, valeurs collées floutées.
Un subject complexe dans le décodeur. user et session ensemble désignent une session d’agent.

Le 401 que voit l’agent#

Avec curl, la réponse est claire. Avant l’événement, l’appel renvoyait 200. Après, le même jeton a reçu 401 avec WWW-Authenticate: Bearer error="invalid_token", error_description="session revoked". Un agent qui lit cet en-tête sait qu’il doit se reconnecter plutôt que réessayer.

Terminal : un tools/call avec les en-têtes mcp-method et mcp-name renvoie 200 avec le résultat des commandes, la révocation de cette session renvoie subject_format complex, et le même appel renvoie ensuite 401 avec WWW-Authenticate Bearer error invalid_token, error_description session revoked.
Avant et après, sur le fil. La même requête, 200 puis 401.

La requête brute avait aussi besoin des en-têtes Mcp-Method et Mcp-Name et de deux clés dans _meta avant que le serveur 2026-07-28 l’accepte. Sans eux, le serveur répondait 400 avec une erreur JSON-RPC. Une passerelle peut lire le nom de l’outil dans l’en-tête, mais le serveur le compare quand même au corps.

Pièges#

  • La configuration du stream renvoie le secret du push. Protégez le jeton de l’API du stream autant que le jeton de push.
  • SSFgo refuse par défaut les push vers le loopback. Utile en production, une surprise dans un lab.
  • Le profil interop exige que la livraison en poll soit annoncée. Le transmitter a refusé de démarrer sous le profil tant que je n’avais pas listé RFC 8936 à côté du push.
  • Secondes entières des deux côtés. Une révocation et une nouvelle connexion dans la même seconde se télescopent. Choisissez un côté délibérément.
  • Dans ce lab, les révocations sont en mémoire. Un redémarrage les oublie, et un jeton déjà émis redeviendrait valide jusqu’à son expiration. Conservez-les au moins pendant la durée de vie du jeton d’accès, dans un stockage durable.
  • Un événement session-revoked ne verrouille pas le compte. alice s’est reconnectée peu après.

Ce que j’en ferais#

  1. Placer le receiver là où arrive chaque requête d’agent : la passerelle MCP, pas chaque outil.
  2. Mettre sid dans les jetons d’accès de vos agents et vérifier que les jetons et les événements ont le même émetteur, ou tenir une correspondance.
  3. Abonner les subjects nécessaires sous la forme que le transmitter enverra. Pour des événements par session, abonnez un subject complexe avec user.
  4. Fixer les algorithmes acceptés, maintenant que le profil ne le fait plus. RS256 uniquement, pas de none, clés tirées du jwks_uri du transmitter.
  5. Couper les appels d’outils en cours, pas seulement les nouveaux. Avec MCP 2026-07-28, il n’y a pas de session à fermer, la passerelle doit donc suivre ce qu’elle est en train de streamer.

Ce qui n’a pas été exécuté#

Le transmitter est SSFgo dans mon fournisseur d’identité de lab, pas un produit commercial. L’API du stream a utilisé un bearer statique, pas OAuth comme l’exige le profil interop. Je n’ai pas exécuté le poll, les mises à jour, la pause ou la suppression d’un stream, ni l’événement de changement d’identifiants, ni un événement bien signé avec une mauvaise audience ou un mauvais émetteur, ni un redémarrage de la passerelle (révocations en mémoire), ni la suite de conformité OpenID. Les clients MCP étaient des scripts sur le SDK, pas un produit d’agent, et aucun n’a réagi au 401. Il n’y a pas d’enregistrement pour ce lab.

Les images de terminal ont été générées à partir de la sortie enregistrée du 22 novembre 2026, heure Europe/Zurich. Les jetons, clés et certificats du lab étaient aléatoires, n’ont vécu qu’une heure sur une seule machine et ont été supprimés à la fin.

Refaire ce lab#

Tout ce qu’il faut pour exécuter ce lab sur une machine Linux en 35 minutes environ, sans compte : une CA jetable, un IdP basé sur SSFgo, un serveur MCP et une passerelle qui reçoit des événements CAEP. Ouvrez chaque étape, copiez les blocs et comparez votre résultat avec celui attendu.

Chaque valeur entre chevrons est un espace réservé pour votre environnement de test. Rien sur cette page n’est un identifiant ou un secret réel.

Définissez vos variables une seule fois

text · env.sh
# Paste into every terminal you use for this lab, from inside the lab folder. No account or real secret is needed.
export T="https://localhost:9443"   # lab IdP and SSF transmitter
export A="https://localhost:9444"   # gateway: SSF receiver in front of the MCP server
export C="--cacert certs/ca.pem"    # curl trusts the throwaway lab CA
[ -f .env ] && . ./.env             # the three random lab tokens, once step 3 wrote them
[ -d .venv ] && . .venv/bin/activate
Étape 1Créer la CA et compiler l’IdP

Objectif. Enregistrez make-certs.sh et le dossier idp, créez une CA jetable avec un certificat pour localhost, compilez l’IdP du lab sur SSFgo v0.4.2 et installez l’outil en ligne de commande ssf.

Prérequis

  • Linux avec Go 1.26.10 ou plus récent (testé avec 1.27.3), Python 3.13, openssl, curl et jq
  • Un dossier vide pour le lab ; lancez chaque étape depuis ce dossier
text · make-certs.sh
#!/usr/bin/env bash
# A throwaway lab CA and one certificate for localhost, valid 2 days.
set -euo pipefail
mkdir -p certs && cd certs
openssl req -x509 -newkey rsa:2048 -nodes -days 2 -subj "/CN=ssf-mcp lab CA" \
  -addext "basicConstraints=critical,CA:TRUE" -addext "keyUsage=critical,keyCertSign,cRLSign" \
  -keyout ca.key -out ca.pem 2>/dev/null
openssl req -newkey rsa:2048 -nodes -subj "/CN=localhost" \
  -keyout localhost.key -out localhost.csr 2>/dev/null
printf "subjectAltName=DNS:localhost,IP:127.0.0.1\nkeyUsage=critical,digitalSignature,keyEncipherment\nextendedKeyUsage=serverAuth\nauthorityKeyIdentifier=keyid\n" > san.ext
openssl x509 -req -in localhost.csr -CA ca.pem -CAkey ca.key -CAcreateserial \
  -days 2 -extfile san.ext -out localhost.pem 2>/dev/null
chmod 600 *.key
openssl x509 -in localhost.pem -noout -subject -ext subjectAltName
text · idp/go.mod
module ssfmcp/idp

go 1.26.10

require github.com/idfoundry/ssfgo v0.4.2
text · idp/main.go
// idp is a lab identity provider on https://localhost:9443. It does two jobs:
//   - signs short-lived access tokens for an MCP gateway (POST /token), and
//   - runs an SSFgo Transmitter (SSF 1.0, CAEP 1.0) that pushes
//     session-revoked events to the gateway (POST /admin/revoke).
// It signs a token for whoever asks: it stands in for a real sign-in.
package main

import (
	"context"
	"crypto"
	"crypto/rand"
	"crypto/rsa"
	"crypto/sha256"
	"crypto/tls"
	"crypto/x509"
	"encoding/base64"
	"encoding/json"
	"flag"
	"log"
	"log/slog"
	"math/big"
	"net/http"
	"os"
	"time"

	ssf "github.com/idfoundry/ssfgo"
	"github.com/idfoundry/ssfgo/caep"
	"github.com/idfoundry/ssfgo/caep/interop"
	"github.com/idfoundry/ssfgo/storage/memstore"
	"github.com/idfoundry/ssfgo/transmitter"
)

const issuer = "https://localhost:9443"

func b64(b []byte) string { return base64.RawURLEncoding.EncodeToString(b) }

func main() {
	profile := flag.String("profile", "interop", "interop (CAEP Interoperability Profile) or ssf (plain SSF 1.0 + CAEP 1.0)")
	flag.Parse()
	receiverToken, adminToken := os.Getenv("RECEIVER_TOKEN"), os.Getenv("ADMIN_TOKEN")
	if receiverToken == "" || adminToken == "" {
		log.Fatal("set RECEIVER_TOKEN and ADMIN_TOKEN")
	}
	audience := os.Getenv("GATEWAY_AUDIENCE") // the gateway's SET audience
	ctx := context.Background()

	setKey, _ := rsa.GenerateKey(rand.Reader, 2048) // signs SETs
	atKey, _ := rsa.GenerateKey(rand.Reader, 2048)  // signs access tokens

	cfg := transmitter.Config{
		Assurance:       ssf.AssuranceDevelopment,
		Limits:          transmitter.RecommendedLimits(),
		PushRetry:       transmitter.RecommendedPushRetry(),
		Issuer:          issuer,
		SigningKeys:     []transmitter.SigningKey{{Signer: setKey, Algorithm: ssf.RS256, KeyID: "ssf-set-1"}},
		EventsSupported: interop.EventTypes(),
		DeliveryMethods: []ssf.DeliveryMethod{ssf.DeliveryPush, ssf.DeliveryPoll},
		DefaultSubjects: ssf.DefaultSubjectsNone,
		Store:           memstore.NewStreamStore(),
		Authorize: func(_ context.Context, token string) (transmitter.Receiver, error) {
			if token != receiverToken {
				return transmitter.Receiver{}, transmitter.ErrInvalidToken
			}
			return transmitter.Receiver{ID: "mcp-gateway", Audience: []string{audience}, Access: transmitter.AccessManage}, nil
		},
		PermitEvent: transmitter.PermitAll,
		Hooks: transmitter.Hooks{Push: func(_ context.Context, i transmitter.PushInfo) {
			log.Printf("push attempt %d: %s in %v", i.Attempt, i.Outcome, i.Duration.Round(time.Millisecond))
		}},
		Logger: slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelWarn})),
	}
	if *profile == "interop" {
		if err := interop.ApplyTransmitter(&cfg); err != nil {
			log.Fatal(err)
		}
	}
	// SSFgo refuses to push to loopback by default (SSRF protection). This lab
	// pushes to https://localhost:9444, so it uses a client that trusts the lab CA.
	ca, err := os.ReadFile("certs/ca.pem")
	if err != nil {
		log.Fatal(err)
	}
	pool := x509.NewCertPool()
	pool.AppendCertsFromPEM(ca)
	cfg.HTTPClient = &http.Client{Timeout: 10 * time.Second, Transport: &http.Transport{TLSClientConfig: &tls.Config{RootCAs: pool}}}
	tx, err := transmitter.New(cfg)
	if err != nil {
		log.Fatal(err)
	}
	go func() { _ = tx.Run(ctx) }()

	mux := http.NewServeMux()
	mux.Handle("/", tx.Handler()) // SSF metadata, JWKS, streams, subjects, status, verify

	// Access tokens for the MCP gateway.
	atJWKS := map[string]any{"keys": []map[string]any{{
		"kty": "RSA", "kid": "at-1", "use": "sig", "alg": "RS256",
		"n": b64(atKey.N.Bytes()), "e": b64(big.NewInt(int64(atKey.E)).Bytes()),
	}}}
	mux.HandleFunc("GET /token-jwks", func(w http.ResponseWriter, _ *http.Request) {
		w.Header().Set("content-type", "application/json")
		_ = json.NewEncoder(w).Encode(atJWKS)
	})
	mux.HandleFunc("POST /token", func(w http.ResponseWriter, r *http.Request) {
		user, client := r.FormValue("user"), r.FormValue("client_id")
		if user == "" || client == "" {
			http.Error(w, `{"error":"invalid_request"}`, 400)
			return
		}
		now := time.Now()
		sid := "sid-" + b64(randBytes(6))
		claims := map[string]any{
			"iss": issuer, "sub": user, "aud": os.Getenv("MCP_RESOURCE"), "client_id": client,
			"sid": sid, "scope": "mcp:tools", "iat": now.Unix(), "exp": now.Add(time.Hour).Unix(),
			"jti": b64(randBytes(9)),
		}
		hdr, _ := json.Marshal(map[string]string{"alg": "RS256", "typ": "at+jwt", "kid": "at-1"})
		body, _ := json.Marshal(claims)
		in := b64(hdr) + "." + b64(body)
		sum := sha256.Sum256([]byte(in))
		sig, _ := rsa.SignPKCS1v15(rand.Reader, atKey, crypto.SHA256, sum[:])
		log.Printf("token issued: sub=%s client_id=%s sid=%s", user, client, sid)
		w.Header().Set("content-type", "application/json")
		_ = json.NewEncoder(w).Encode(map[string]any{"access_token": in + "." + b64(sig), "token_type": "Bearer", "expires_in": 3600, "sid": sid})
	})

	// Admin action: revoke a user's sessions (iss_sub subject) or one session
	// (complex subject: user + session).
	mux.HandleFunc("POST /admin/revoke", func(w http.ResponseWriter, r *http.Request) {
		if r.Header.Get("authorization") != "Bearer "+adminToken {
			http.Error(w, "unauthorized", 401)
			return
		}
		var in struct{ Sub, Sid, Reason string }
		_ = json.NewDecoder(r.Body).Decode(&in)
		user := ssf.IssSubSubject{Issuer: issuer, Subject: in.Sub}
		var subject ssf.Subject = user
		if in.Sid != "" {
			subject = ssf.ComplexSubject{User: user, Session: ssf.OpaqueSubject{ID: in.Sid}}
		}
		err := tx.Emit(r.Context(), subject, caep.SessionRevoked{Common: caep.Common{
			EventTimestamp:   ssf.NewNumericDate(time.Now()),
			InitiatingEntity: caep.InitiatedByAdmin,
			ReasonAdmin:      ssf.LocalizedText{"en": in.Reason},
		}})
		w.Header().Set("content-type", "application/json")
		if err != nil {
			log.Printf("emit refused: %v", err)
			w.WriteHeader(422)
			_ = json.NewEncoder(w).Encode(map[string]string{"emitted": "false", "error": err.Error()})
			return
		}
		log.Printf("emitted session-revoked: subject=%s sid=%q", in.Sub, in.Sid)
		_ = json.NewEncoder(w).Encode(map[string]string{"emitted": "true", "subject_format": string(subject.Format())})
	})

	log.Printf("idp on %s, profile=%s", issuer, *profile)
	srv := &http.Server{Addr: "127.0.0.1:9443", Handler: mux}
	log.Fatal(srv.ListenAndServeTLS("certs/localhost.pem", "certs/localhost.key"))
}

func randBytes(n int) []byte { b := make([]byte, n); _, _ = rand.Read(b); return b }
text · build.sh
chmod +x make-certs.sh
./make-certs.sh
cd idp && go mod tidy && go build -o ../idp-bin . && cd ..
grep ssfgo idp/go.mod
cd idp && go build -o ../ssf github.com/idfoundry/ssfgo/cmd/ssf && cd .. && ls idp-bin ssf

Résultat attendu

résultat
subject=CN=localhost
X509v3 Subject Alternative Name: 
    DNS:localhost, IP Address:127.0.0.1
require github.com/idfoundry/ssfgo v0.4.2
idp-bin
ssf
Étape 2Installer la partie Python

Objectif. Créez un venv avec des versions figées et enregistrez le serveur MCP, la passerelle qui sert aussi de receiver SSF, et l’agent de test.

Prérequis

  • L’étape précédente s’est terminée comme indiqué, dans le même terminal
text · venv.sh
python3 -m venv .venv && . .venv/bin/activate
pip install -q mcp==2.3.0 pyjwt==2.15.1 cryptography==50.0.2 httpx==0.28.1 starlette==1.10.0 uvicorn==0.54.0
pip list 2>/dev/null | grep -i -E "^(mcp|pyjwt|cryptography|httpx|starlette|uvicorn) "
text · mcp_server.py
"""A small MCP server on http://127.0.0.1:9000/mcp (loopback only).

It trusts the gateway in front of it: the gateway checks the token and
forwards the caller in X-Lab-User. Two tools: a quick read and a slow export
that reports progress for 20 seconds.
"""
import anyio
from mcp.server import MCPServer
from mcp.server.mcpserver import Context

mcp = MCPServer("orders")

@mcp.tool()
def list_orders(customer: str) -> dict:
    """List open orders for a customer."""
    return {"customer": customer, "open_orders": 2}

@mcp.tool()
async def export_orders(customer: str, ctx: Context) -> str:
    """Export a customer's order history (slow, 20 steps of one second)."""
    for step in range(1, 21):
        await ctx.report_progress(step, 20, f"exported {step * 5}%")
        await anyio.sleep(1)
    return f"export for {customer} done"

if __name__ == "__main__":
    mcp.run(transport="streamable-http", host="127.0.0.1", port=9000)
text · gateway.py
"""MCP gateway on https://localhost:9444: an SSF receiver in front of an MCP server.

/mcp        checks the bearer token (signature, iss, aud, exp) and the
            revocation state, then proxies to the MCP server on 127.0.0.1:9000.
/ssf/events receives pushed SETs (RFC 8935), checks them and applies
            CAEP session-revoked: refuse the user's (or one session's)
            tokens from now on and cut any tool call still streaming.
"""
import json, os, ssl, sys, time
import anyio, httpx, jwt, uvicorn
from starlette.applications import Starlette
from starlette.requests import Request
from starlette.responses import JSONResponse, Response, StreamingResponse
from starlette.routing import Route

IDP = "https://localhost:9443"
MCP_RESOURCE = os.environ["MCP_RESOURCE"]          # aud of access tokens
SET_AUDIENCE = os.environ["GATEWAY_AUDIENCE"]      # aud of SETs
PUSH_TOKEN = os.environ["PUSH_TOKEN"]              # what the transmitter must send
UPSTREAM = "http://127.0.0.1:9000/mcp"
CA = "certs/ca.pem"
SESSION_REVOKED = "https://schemas.openid.net/secevent/caep/event-type/session-revoked"
VERIFICATION = "https://schemas.openid.net/secevent/ssf/event-type/verification"

http = httpx.AsyncClient(verify=CA, timeout=None)
idp_meta = httpx.get(f"{IDP}/.well-known/ssf-configuration", verify=CA).json()
set_keys = jwt.PyJWKClient(idp_meta["jwks_uri"], ssl_context=ssl.create_default_context(cafile=CA))
at_keys = jwt.PyJWKClient(f"{IDP}/token-jwks", ssl_context=ssl.create_default_context(cafile=CA))

revoked_users: dict[str, float] = {}   # "iss|sub" -> revoked at (epoch seconds)
revoked_sids: set[str] = set()
seen_jti: set[str] = set()
applied = {"session_revoked": 0}
inflight: dict[str, dict] = {}          # request key -> {"user","sid","cut": anyio.Event, "id"}

def log(msg: str) -> None:
    print(time.strftime("%H:%M:%S") + f".{int(time.time() * 1000) % 1000:03d} {msg}", flush=True)

def unauthorized(desc: str) -> Response:
    return JSONResponse({"error": "invalid_token", "error_description": desc}, 401,
                        headers={"www-authenticate": f'Bearer error="invalid_token", error_description="{desc}"'})

# ---------- the MCP side ----------
async def mcp(request: Request) -> Response:
    auth = request.headers.get("authorization", "")
    if not auth.startswith("Bearer "):
        return unauthorized("no bearer token")
    token = auth[7:]
    try:
        key = at_keys.get_signing_key_from_jwt(token).key
        claims = jwt.decode(token, key, algorithms=["RS256"], audience=MCP_RESOURCE, issuer=IDP,
                            options={"require": ["exp", "iat", "sub", "sid"]})
    except Exception as e:
        log(f"mcp: refused token: {type(e).__name__}")
        return unauthorized(type(e).__name__)
    user, sid = f'{claims["iss"]}|{claims["sub"]}', claims["sid"]
    cutoff = revoked_users.get(user)
    if sid in revoked_sids or (cutoff is not None and claims["iat"] <= int(cutoff)):
        log(f"mcp: 401 for sub={claims['sub']} sid={sid}: session revoked")
        return unauthorized("session revoked")
    body = await request.body()
    try:
        msg = json.loads(body) if body else {}
    except ValueError:
        msg = {}
    method = msg.get("method", request.method)
    tool = (msg.get("params") or {}).get("name", "")
    log(f"mcp: {method} {tool} sub={claims['sub']} client={claims.get('client_id')} sid={sid} -> forward")
    headers = {k: v for k, v in request.headers.items()
               if k.lower() in ("content-type", "accept", "mcp-session-id", "mcp-protocol-version", "last-event-id")
               or k.lower().startswith("mcp-")}
    headers["x-lab-user"] = claims["sub"]
    upstream = await http.send(http.build_request(request.method, UPSTREAM, headers=headers, content=body), stream=True)
    key = f"{sid}:{msg.get('id')}:{time.time()}"
    entry = {"user": user, "sid": sid, "cut": anyio.Event(), "id": msg.get("id"), "tool": tool}
    inflight[key] = entry

    async def stream():
        try:
            async with anyio.create_task_group() as tg:
                async def watch():
                    await entry["cut"].wait()
                    tg.cancel_scope.cancel()
                tg.start_soon(watch)
                async for chunk in upstream.aiter_raw():
                    yield chunk
                tg.cancel_scope.cancel()
            if entry["cut"].is_set() and "text/event-stream" in upstream.headers.get("content-type", ""):
                err = {"jsonrpc": "2.0", "id": entry["id"],
                       "error": {"code": -32001, "message": "session revoked by the identity provider (CAEP), call cut"}}
                yield f"event: message\ndata: {json.dumps(err)}\n\n".encode()
                log(f"mcp: cut in-flight {tool} for sid={sid}")
        finally:
            inflight.pop(key, None)
            await upstream.aclose()

    passthrough = {k: v for k, v in upstream.headers.items()
                   if k.lower() in ("content-type", "mcp-session-id", "cache-control")}
    return StreamingResponse(stream(), status_code=upstream.status_code, headers=passthrough)

# ---------- the SSF receiver side ----------
def push_error(err: str, desc: str) -> Response:
    log(f"ssf: rejected SET: {err}: {desc}")
    return JSONResponse({"err": err, "description": desc}, 400)

async def ssf_events(request: Request) -> Response:
    if request.headers.get("authorization") != f"Bearer {PUSH_TOKEN}":
        log("ssf: 401, wrong or missing push authorization")
        return Response(status_code=401)
    if request.headers.get("content-type", "").split(";")[0].strip() != "application/secevent+jwt":
        return push_error("invalid_request", "content-type must be application/secevent+jwt")
    set_jwt = (await request.body()).decode().strip()
    try:
        header = jwt.get_unverified_header(set_jwt)
        if header.get("typ") != "secevent+jwt":
            return push_error("invalid_request", f"typ {header.get('typ')!r}")
        key = set_keys.get_signing_key_from_jwt(set_jwt).key
        claims = jwt.decode(set_jwt, key, algorithms=["RS256"], audience=SET_AUDIENCE, issuer=IDP,
                            options={"require": ["iat", "jti"], "verify_exp": False})
    except jwt.InvalidAudienceError as e:
        return push_error("invalid_audience", str(e))
    except jwt.InvalidIssuerError as e:
        return push_error("invalid_issuer", str(e))
    except (jwt.InvalidSignatureError, jwt.PyJWKClientError, jwt.InvalidAlgorithmError) as e:
        return push_error("invalid_key", f"{type(e).__name__}: {e}")
    except Exception as e:
        return push_error("invalid_request", f"{type(e).__name__}: {e}")
    if claims["jti"] in seen_jti:
        log(f"ssf: duplicate jti, already applied, 202 and nothing else")
        return Response(status_code=202)
    seen_jti.add(claims["jti"])
    with open("last-set.jwt", "w") as f:  # kept for the replay test and the SET decoder
        f.write(set_jwt)
    events = claims.get("events", {})
    sub_id = claims.get("sub_id", {})
    if VERIFICATION in events:
        log(f"ssf: verification event, state={events[VERIFICATION].get('state')}")
        return Response(status_code=202)
    if SESSION_REVOKED in events:
        ev = events[SESSION_REVOKED]
        when = float(ev.get("event_timestamp", time.time()))
        if sub_id.get("format") == "iss_sub":
            user = f'{sub_id["iss"]}|{sub_id["sub"]}'
            revoked_users[user] = max(revoked_users.get(user, 0), when)
            cut = [e for e in inflight.values() if e["user"] == user]
            scope = f"all sessions of sub={sub_id['sub']}"
        elif sub_id.get("format") == "complex" and (sub_id.get("session") or {}).get("format") == "opaque":
            sid = sub_id["session"]["id"]
            revoked_sids.add(sid)
            cut = [e for e in inflight.values() if e["sid"] == sid]
            scope = f"one session sid={sid}"
        else:
            log(f"ssf: session-revoked with a subject I cannot map: {sub_id.get('format')}")
            return Response(status_code=202)
        for e in cut:
            e["cut"].set()
        applied["session_revoked"] += 1
        log(f"ssf: session-revoked ({ev.get('reason_admin', {}).get('en')}) -> {scope}; "
            f"in-flight calls cut: {len(cut)}")
        return Response(status_code=202)
    log(f"ssf: event types {list(events)} ignored")
    return Response(status_code=202)

async def state(request: Request) -> Response:
    return JSONResponse({"applied": applied["session_revoked"], "revoked_users": revoked_users, "revoked_sids": sorted(revoked_sids),
                         "inflight": [{k: v for k, v in e.items() if k != "cut"} for e in inflight.values()]})

app = Starlette(routes=[Route("/mcp", mcp, methods=["GET", "POST", "DELETE"]),
                        Route("/ssf/events", ssf_events, methods=["POST"]),
                        Route("/debug/state", state)])

if __name__ == "__main__":
    log(f"gateway: SSF issuer {idp_meta['issuer']}, jwks {idp_meta['jwks_uri']}")
    uvicorn.run(app, host="127.0.0.1", port=9444, log_level="warning",
                ssl_certfile="certs/localhost.pem", ssl_keyfile="certs/localhost.key")
text · agent.py
"""A lab agent: gets a token from the IdP and calls MCP tools through the gateway.

usage: python agent.py USER CLIENT_ID [list|export] [repeat]
"""
import asyncio, sys, time
import httpx, httpx2
from mcp import Client
from mcp.client.streamable_http import streamable_http_client

IDP, GW, CA = "https://localhost:9443", "https://localhost:9444/mcp", "certs/ca.pem"

def ts() -> str:
    return time.strftime("%H:%M:%S")

async def main(user: str, client_id: str, mode: str, repeat: int) -> None:
    tok = httpx.post(f"{IDP}/token", data={"user": user, "client_id": client_id}, verify=CA).json()
    print(f"{ts()} {client_id}: token for {user}, sid={tok['sid']}", flush=True)
    headers = {"authorization": f"Bearer {tok['access_token']}"}
    for i in range(repeat):
        try:
            async with httpx2.AsyncClient(headers=headers, verify=CA, timeout=60) as hc:
                async with Client(streamable_http_client(GW, http_client=hc)) as c:
                    if mode == "export":
                        async def progress(p, total, message):
                            print(f"{ts()} {client_id}: progress {message}", flush=True)
                        r = await c.call_tool("export_orders", {"customer": "c-1001"}, progress_callback=progress)
                    else:
                        r = await c.call_tool("list_orders", {"customer": "c-1001"})
                    text = " ".join((r.content[0].text if r.content else str(r)).split())
                    print(f"{ts()} {client_id}: {'error' if r.is_error else 'ok'}: {text}", flush=True)
        except Exception as e:
            while getattr(e, "exceptions", None):
                e = e.exceptions[0]
            msg = f"{type(e).__name__}: {e}"
            print(f"{ts()} {client_id}: refused: {msg[:160]}", flush=True)
        await asyncio.sleep(2)

if __name__ == "__main__":
    a = sys.argv[1:]
    asyncio.run(main(a[0], a[1], a[2] if len(a) > 2 else "list", int(a[3]) if len(a) > 3 else 1))

Résultat attendu

résultat
cryptography              50.0.2
httpx                     0.28.1
mcp                       2.3.0
PyJWT                     2.15.1
starlette                 1.10.0
uvicorn                   0.54.0
Étape 3Créer les jetons du lab et tout démarrer

Objectif. Écrivez trois jetons aléatoires du lab dans .env, puis démarrez l’IdP avec le profil d’interopérabilité CAEP, le serveur MCP et la passerelle.

Prérequis

  • L’étape précédente s’est terminée comme indiqué, dans le même terminal
  • Ports 9000, 9443 et 9444 libres sur localhost
text · start.sh
#!/usr/bin/env bash
# Start the IdP (SSFgo transmitter), the MCP server and the gateway. Usage: ./start.sh [interop|ssf]
. ./.env
./idp-bin -profile "${1:-interop}" > idp.log 2>&1 &
python mcp_server.py > mcp.log 2>&1 &
sleep 2
python gateway.py > gw.log 2>&1 &
sleep 3
ss -ltnH | awk '{print $4}' | grep -E ":(9000|9443|9444)$" | sort
text · stop.sh
#!/usr/bin/env bash
pkill -f "[i]dp-bin"; pkill -f "[m]cp_server.py"; pkill -f "[g]ateway.py"; sleep 1
ss -ltnH | grep -c -E ":(9000|9443|9444) " || true
text · run.sh
chmod +x start.sh stop.sh
for v in RECEIVER_TOKEN PUSH_TOKEN ADMIN_TOKEN; do echo "export $v=$(openssl rand -hex 16)"; done > .env
echo "export MCP_RESOURCE=https://localhost:9444/mcp GATEWAY_AUDIENCE=https://localhost:9444" >> .env
chmod 600 .env && . ./.env && echo "tokens set: ${#RECEIVER_TOKEN} ${#PUSH_TOKEN} ${#ADMIN_TOKEN} characters"
./start.sh interop
cat idp.log gw.log

Résultat attendu

résultat
tokens set: 32 32 32 characters
127.0.0.1:9000
127.0.0.1:9443
127.0.0.1:9444
<date> <time> idp on https://localhost:9443, profile=interop
<time> gateway: SSF issuer https://localhost:9443, jwks https://localhost:9443/ssf/jwks.json
Étape 4Créer le stream et ajouter alice et bob

Objectif. Vérifiez les métadonnées SSF avec l’outil ssf, créez un stream push pour session-revoked, ajoutez deux utilisateurs comme subjects et demandez un événement de vérification. La réponse du stream renvoie le jeton de push en entier.

Prérequis

  • L’étape précédente s’est terminée comme indiqué, dans le même terminal
text · stream.sh
./ssf metadata -ca-file certs/ca.pem $T 2>&1 >/dev/null
curl -s $C $T/.well-known/ssf-configuration | jq -c "{issuer, jwks_uri, delivery_methods_supported, default_subjects}"
printf "{\"delivery\":{\"method\":\"urn:ietf:rfc:8935\",\"endpoint_url\":\"$A/ssf/events\",\"authorization_header\":\"Bearer $PUSH_TOKEN\"},\"events_requested\":[\"https://schemas.openid.net/secevent/caep/event-type/session-revoked\"]}" > stream-request.json
curl -s $C -X POST $T/ssf/stream -H "authorization: Bearer $RECEIVER_TOKEN" -H "content-type: application/json" -d @stream-request.json > stream.json
jq "del(.delivery.authorization_header, .events_supported)" stream.json
jq -r .delivery.authorization_header stream.json | sed -E "s/[0-9a-f]{32}/<the PUSH_TOKEN, in full>/"
SID=$(jq -r .stream_id stream.json)
for u in alice bob; do curl -s $C -X POST $T/ssf/subjects:add -H "authorization: Bearer $RECEIVER_TOKEN" -H "content-type: application/json" -d "{\"stream_id\":\"$SID\",\"subject\":{\"format\":\"iss_sub\",\"iss\":\"$T\",\"sub\":\"$u\"}}" -w "subjects:add $u -> HTTP %{http_code}\n"; done
curl -s $C "$T/ssf/status?stream_id=$SID" -H "authorization: Bearer $RECEIVER_TOKEN" | jq -c "{status}"
curl -s $C -X POST $T/ssf/verify -H "authorization: Bearer $RECEIVER_TOKEN" -H "content-type: application/json" -d "{\"stream_id\":\"$SID\",\"state\":\"lab-check-1\"}" -w "verify -> HTTP %{http_code}\n"
sleep 1; grep verification gw.log; grep push idp.log

Résultat attendu

résultat
accepted: the metadata names the issuer, its endpoints are https on trusted origins, and its signing keys were fetched
{"issuer":"https://localhost:9443","jwks_uri":"https://localhost:9443/ssf/jwks.json","delivery_methods_supported":["urn:ietf:rfc:8935","urn:ietf:rfc:8936"],"default_subjects":"NONE"}
{
  "stream_id": "<random-id>",
  "iss": "https://localhost:9443",
  "aud": "https://localhost:9444",
  "events_requested": [
    "https://schemas.openid.net/secevent/caep/event-type/session-revoked"
  ],
  "events_delivered": [
    "https://schemas.openid.net/secevent/caep/event-type/session-revoked"
  ],
  "delivery": {
    "method": "urn:ietf:rfc:8935",
    "endpoint_url": "https://localhost:9444/ssf/events"
  }
}
Bearer <the PUSH_TOKEN, in full>
subjects:add alice -> HTTP 200
subjects:add bob -> HTTP 200
{"status":"enabled"}
verify -> HTTP 204
<time> ssf: verification event, state=lab-check-1
<date> <time> push attempt 1: delivered in 10ms
Étape 5Obtenir un jeton et lire ce que vérifie la passerelle

Objectif. Demandez à l’IdP un jeton d’accès pour alice et décodez-le. La passerelle vérifie l’émetteur, l’audience, l’expiration et la signature, et a besoin du claim sid pour révoquer une seule session.

Prérequis

  • L’étape précédente s’est terminée comme indiqué, dans le même terminal
text · token.sh
curl -s $C -X POST $T/token -d user=alice -d client_id=support-agent | jq -r .access_token > alice.jwt
cut -d. -f1 alice.jwt | base64 -d 2>/dev/null; echo
cut -d. -f2 alice.jwt | tr "_-" "/+" | base64 -d 2>/dev/null | jq .

Résultat attendu

résultat
{"alg":"RS256","kid":"at-1","typ":"at+jwt"}
{
  "aud": "https://localhost:9444/mcp",
  "client_id": "support-agent",
  "exp": <unix time>,
  "iat": <unix time>,
  "iss": "https://localhost:9443",
  "jti": "<random>",
  "scope": "mcp:tools",
  "sid": "sid-<random>",
  "sub": "alice"
}
Étape 6Révoquer alice pendant que trois agents travaillent

Objectif. Lancez un export long et une recherche répétée pour alice, et une recherche pour bob, puis émettez session-revoked pour alice. L’export est coupé en plein flux, l’autre agent d’alice reçoit des 401, bob continue.

Prérequis

  • L’étape précédente s’est terminée comme indiqué, dans le même terminal
text · cut.sh
python agent.py alice export-agent export 1 > export-agent.log 2>&1 &
python agent.py alice billing-agent list 6 > billing-agent.log 2>&1 &
python agent.py bob support-agent list 6 > bob-agent.log 2>&1 &
sleep 7
curl -s $C -X POST $T/admin/revoke -H "authorization: Bearer $ADMIN_TOKEN" -d "{\"sub\":\"alice\",\"reason\":\"Agent misuse reported\"}"; echo
sleep 8
cat export-agent.log
cat billing-agent.log bob-agent.log
grep -E "10:39:(4[4-9]|5[0-4])" gw.log | grep -v -E "tools/list|server/discover" | cut -c1-120
grep "10:39:5" idp.log
curl -s $C $A/debug/state | jq -c "{revoked_users, inflight}"

Résultat attendu

résultat
{"emitted":"true","subject_format":"iss_sub"}

10:39:44 export-agent: token for alice, sid=sid-N0kqUoJ1
10:39:44 export-agent: progress exported 5%
10:39:45 export-agent: progress exported 10%
10:39:46 export-agent: progress exported 15%
10:39:47 export-agent: progress exported 20%
10:39:48 export-agent: progress exported 25%
10:39:49 export-agent: progress exported 30%
10:39:50 export-agent: progress exported 35%
10:39:50 export-agent: refused: MCPError: session revoked by the identity provider (CAEP), call cut
10:39:44 billing-agent: token for alice, sid=sid-4GpXzD_u
10:39:44 billing-agent: ok: { "customer": "c-1001", "open_orders": 2 }
10:39:50 billing-agent: ok: { "customer": "c-1001", "open_orders": 2 }
10:39:52 billing-agent: refused: MCPError: Server returned an error response
10:39:54 billing-agent: refused: MCPError: Server returned an error response
10:39:44 support-agent: token for bob, sid=sid-CVg8IkTk
10:39:44 support-agent: ok: { "customer": "c-1001", "open_orders": 2 }
10:39:50 support-agent: ok: { "customer": "c-1001", "open_orders": 2 }
10:39:52 support-agent: ok: { "customer": "c-1001", "open_orders": 2 }
10:39:54 support-agent: ok: { "customer": "c-1001", "open_orders": 2 }
10:39:44.406 mcp: tools/call list_orders sub=bob client=support-agent sid=sid-CVg8IkTk -> forward
10:39:44.407 mcp: tools/call export_orders sub=alice client=export-agent sid=sid-N0kqUoJ1 -> forward
10:39:44.408 mcp: tools/call list_orders sub=alice client=billing-agent sid=sid-4GpXzD_u -> forward
... (the same three calls every two seconds, shortened here)
10:39:50.971 ssf: session-revoked (Agent misuse reported) -> all sessions of sub=alice; in-flight calls cut: 1
10:39:50.971 mcp: cut in-flight export_orders for sid=sid-N0kqUoJ1
10:39:52.496 mcp: 401 for sub=alice sid=sid-4GpXzD_u: session revoked
10:39:52.498 mcp: 401 for sub=alice sid=sid-4GpXzD_u: session revoked
10:39:52.501 mcp: tools/call list_orders sub=bob client=support-agent sid=sid-CVg8IkTk -> forward
10:39:54.506 mcp: 401 for sub=alice sid=sid-4GpXzD_u: session revoked
10:39:54.508 mcp: 401 for sub=alice sid=sid-4GpXzD_u: session revoked
10:39:54.520 mcp: tools/call list_orders sub=bob client=support-agent sid=sid-CVg8IkTk -> forward
2026/11/22 10:39:50 emitted session-revoked: subject=alice sid=""
2026/11/22 10:39:50 push attempt 1: delivered in 4ms
{"revoked_users":{"https://localhost:9443|alice":1795340390.0},"inflight":[]}
Étape 7Vérifier le SET reçu par la passerelle

Objectif. Contrôlez le dernier Security Event Token reçu avec ssf verify : signature, typ secevent+jwt, émetteur et audience. Puis reconnectez alice pour voir que l’événement n’a pas bloqué son compte.

Prérequis

  • L’étape précédente s’est terminée comme indiqué, dans le même terminal
text · set.sh
./ssf verify -ca-file certs/ca.pem -issuer $T -audience $GATEWAY_AUDIENCE last-set.jwt 2>verify.txt | jq "{verified, header, sub_id: .claims.sub_id, events: .claims.events}"
cat verify.txt | sed -E "s/[0-9a-f]{32}/<jti>/"
python agent.py alice billing-agent list 1

Résultat attendu

résultat
{
  "verified": true,
  "header": {
    "alg": "RS256",
    "typ": "secevent+jwt",
    "kid": "ssf-set-1"
  },
  "sub_id": {
    "format": "iss_sub",
    "iss": "https://localhost:9443",
    "sub": "alice"
  },
  "events": {
    "https://schemas.openid.net/secevent/caep/event-type/session-revoked": {
      "event_timestamp": 1795340390,
      "initiating_entity": "admin",
      "reason_admin": {
        "en": "Agent misuse reported"
      }
    }
  }
}
verified: "<jti>" event https://schemas.openid.net/secevent/caep/event-type/session-revoked about iss_sub
10:40:35 billing-agent: token for alice, sid=sid-hlgqlwFF
10:40:35 billing-agent: ok: { "customer": "c-1001", "open_orders": 2 }
Étape 8Envoyer des événements forgés et rejoués

Objectif. Envoyez sept mauvais événements au receiver : bearer absent ou faux, mauvais content type, une clé étrangère, alg none, mauvais typ et un rejeu. Aucun ne doit modifier la liste des révocations. Puis révoquez carol, qui n’est pas dans le stream.

Prérequis

  • L’étape précédente s’est terminée comme indiqué, dans le même terminal
text · attacks.py
"""Push forged, malformed and replayed SETs straight at the gateway's /ssf/events."""
import json, os, time, uuid
import httpx, jwt
from cryptography.hazmat.primitives.asymmetric import rsa

URL, CA = "https://localhost:9444/ssf/events", "certs/ca.pem"
PUSH = {"authorization": f"Bearer {os.environ['PUSH_TOKEN']}", "content-type": "application/secevent+jwt"}
ISS, AUD = "https://localhost:9443", os.environ["GATEWAY_AUDIENCE"]
REVOKED = "https://schemas.openid.net/secevent/caep/event-type/session-revoked"

def set_claims(sub="bob", aud=AUD):
    return {"iss": ISS, "aud": aud, "iat": int(time.time()), "jti": uuid.uuid4().hex,
            "sub_id": {"format": "iss_sub", "iss": ISS, "sub": sub},
            "events": {REVOKED: {"event_timestamp": int(time.time()), "reason_admin": {"en": "forged"}}}}

def push(name, body, headers=PUSH):
    r = httpx.post(URL, content=body, headers=headers, verify=CA)
    print(f"{name:<44} -> {r.status_code} {r.text.strip()[:110]}")

attacker = rsa.generate_private_key(public_exponent=65537, key_size=2048)
hdr = {"typ": "secevent+jwt", "kid": "ssf-set-1"}  # the real kid, the wrong key

push("1. no push authorization", "x", {"content-type": "application/secevent+jwt"})
push("2. wrong push token", "x", {**PUSH, "authorization": "Bearer not-the-push-token"})
push("3. wrong content type (application/json)", "{}", {**PUSH, "content-type": "application/json"})
push("4. revoke bob, signed with an attacker key", jwt.encode(set_claims(), attacker, "RS256", headers=hdr))
unsigned = jwt.encode(set_claims(), None, "none", headers={"typ": "secevent+jwt", "kid": "ssf-set-1"})
push("5. revoke bob, alg none", unsigned)
push("6. revoke bob, typ JWT instead of secevent+jwt", jwt.encode(set_claims(), attacker, "RS256", headers={"kid": "ssf-set-1", "typ": "JWT"}))
push("7. replay the last real SET", open("last-set.jwt").read())
print("revoked users after the attacks:", json.dumps(httpx.get("https://localhost:9444/debug/state", verify=CA).json()["revoked_users"]))
text · attacks.sh
python attacks.py
curl -s $C -X POST $T/admin/revoke -H "authorization: Bearer $ADMIN_TOKEN" -d "{\"sub\":\"carol\",\"reason\":\"not on the stream\"}"; echo
sleep 2; tail -2 idp.log

Résultat attendu

résultat
1. no push authorization                     -> 401 
2. wrong push token                          -> 401 
3. wrong content type (application/json)     -> 400 {"err":"invalid_request","description":"content-type must be application/secevent+jwt"}
4. revoke bob, signed with an attacker key   -> 400 {"err":"invalid_key","description":"InvalidSignatureError: Signature verification failed"}
5. revoke bob, alg none                      -> 400 {"err":"invalid_key","description":"InvalidAlgorithmError: The specified alg value is not allowed"}
6. revoke bob, typ JWT instead of secevent+jwt -> 400 {"err":"invalid_request","description":"typ 'JWT'"}
7. replay the last real SET                  -> 202 
revoked users after the attacks: {"https://localhost:9443|alice": 1795340390.0}
{"emitted":"true","subject_format":"iss_sub"}

2026/11/22 10:40:37 emitted session-revoked: subject=carol sid=""
2026/11/22 10:40:46 emitted session-revoked: subject=carol sid=""
Étape 9Mesurer le délai de coupure

Objectif. Lancez dix révocations et chronométrez chacune, de l’appel admin jusqu’à son application par la passerelle. Puis regardez l’effet de bord : un jeton émis dans la même seconde qu’une révocation est refusé.

Prérequis

  • L’étape précédente s’est terminée comme indiqué, dans le même terminal
text · measure.py
"""Time from the admin revoke call at the IdP to the gateway having applied it, 10 runs."""
import os, statistics, time
import httpx
CA, ADMIN = "certs/ca.pem", os.environ["ADMIN_TOKEN"]
state = lambda: httpx.get("https://localhost:9444/debug/state", verify=CA).json()["applied"]
runs = []
for i in range(10):
    before = state()
    t0 = time.perf_counter()
    httpx.post("https://localhost:9443/admin/revoke", headers={"authorization": f"Bearer {ADMIN}"},
               json={"sub": "alice", "reason": f"timing run {i + 1}"}, verify=CA)
    while state() == before:
        time.sleep(0.002)
    runs.append((time.perf_counter() - t0) * 1000)
    time.sleep(0.3)
print("ms per run:", " ".join(f"{r:.0f}" for r in runs))
print(f"median {statistics.median(runs):.0f} ms, min {min(runs):.0f} ms, max {max(runs):.0f} ms")
text · timing.sh
python measure.py
python agent.py alice billing-agent list 1 | head -1 | grep -o "sid-.*" > billing.sid; cat billing.sid
grep -E "timing run 10|$(cat billing.sid)" gw.log | cut -c1-100
grep -E "10:40:58" idp.log | tail -2  # use the second of your own run 10

Résultat attendu

résultat
ms per run: 8 8 8 8 9 7 8 7 7 7
median 8 ms, min 7 ms, max 9 ms
# Started right after measure.py, the agent got its token in the same second as run 10 (head also prints a BrokenPipeError traceback here):
sid-Xh0iV7nQ
10:40:58.059 ssf: session-revoked (timing run 10) -> all sessions of sub=alice; in-flight calls cut:
10:40:58.877 mcp: 401 for sub=alice sid=sid-Xh0iV7nQ: session revoked
10:40:58.879 mcp: 401 for sub=alice sid=sid-Xh0iV7nQ: session revoked
2026/11/22 10:40:58 push attempt 1: delivered in 1ms
2026/11/22 10:40:58 token issued: sub=alice client_id=billing-agent sid=sid-Xh0iV7nQ
Étape 10Révoquer une session d’agent, pas l’utilisateur

Objectif. Le profil interop refuse un subject complexe avec une session : redémarrez l’IdP en SSF simple, abonnez un subject complexe pour alice et révoquez seulement la session de l’agent de facturation.

Prérequis

  • L’étape précédente s’est terminée comme indiqué, dans le même terminal
text · interop-refuses.sh
curl -s $C -X POST $T/admin/revoke -H "authorization: Bearer $ADMIN_TOKEN" -d "{\"sub\":\"alice\",\"sid\":\"$(cat billing.sid)\",\"reason\":\"one agent session\"}" -w "\nHTTP %{http_code}\n"
./stop.sh
./start.sh ssf
head -1 idp.log
curl -s $C -X POST $T/ssf/stream -H "authorization: Bearer $RECEIVER_TOKEN" -H "content-type: application/json" -d @stream-request.json > stream.json && SID=$(jq -r .stream_id stream.json) && echo "new stream created"
curl -s $C -X POST $T/ssf/subjects:add -H "authorization: Bearer $RECEIVER_TOKEN" -H "content-type: application/json" -d "{\"stream_id\":\"$SID\",\"subject\":{\"format\":\"iss_sub\",\"iss\":\"$T\",\"sub\":\"alice\"}}" -w "subjects:add alice -> HTTP %{http_code}\n"
text · one-session.sh
SID=$(jq -r .stream_id stream.json)
curl -s $C -X POST $T/ssf/subjects:add -H "authorization: Bearer $RECEIVER_TOKEN" -H "content-type: application/json" -d "{\"stream_id\":\"$SID\",\"subject\":{\"format\":\"complex\",\"user\":{\"format\":\"iss_sub\",\"iss\":\"$T\",\"sub\":\"alice\"}}}" -w "subjects:add complex {user: alice} -> HTTP %{http_code}\n"
python agent.py alice billing-agent list 5 > billing-agent.log 2>&1 &
python agent.py alice support-agent list 5 > support-agent.log 2>&1 &
sleep 3; BSID=$(head -1 billing-agent.log | grep -o "sid-.*"); echo "billing-agent sid: $BSID"
curl -s $C -X POST $T/admin/revoke -H "authorization: Bearer $ADMIN_TOKEN" -d "{\"sub\":\"alice\",\"sid\":\"$BSID\",\"reason\":\"one agent session\"}"; echo
sleep 7
cat billing-agent.log support-agent.log
grep -E "ssf:|401" gw.log | cut -c1-110
tail -1 idp.log

Résultat attendu

résultat
{"emitted":"false","error":"transmitter: emit: caep interop profile: §2.5: CAEP events must use an email or iss_sub subject, not \"complex\""}

HTTP 422
0
127.0.0.1:9000
127.0.0.1:9443
127.0.0.1:9444
<date> <time> idp on https://localhost:9443, profile=ssf
new stream created
subjects:add alice -> HTTP 200
subjects:add complex {user: alice} -> HTTP 200
billing-agent sid: sid-2IbmSe2p
{"emitted":"true","subject_format":"complex"}

10:42:11 billing-agent: token for alice, sid=sid-2IbmSe2p
10:42:11 billing-agent: ok: { "customer": "c-1001", "open_orders": 2 }
10:42:13 billing-agent: ok: { "customer": "c-1001", "open_orders": 2 }
10:42:15 billing-agent: refused: MCPError: Server returned an error response
10:42:11 support-agent: token for alice, sid=sid-p9pSH-uY
10:42:11 support-agent: ok: { "customer": "c-1001", "open_orders": 2 }
10:42:13 support-agent: ok: { "customer": "c-1001", "open_orders": 2 }
10:42:15 support-agent: ok: { "customer": "c-1001", "open_orders": 2 }
10:42:13.822 ssf: session-revoked (one agent session) -> one session sid=sid-2IbmSe2p; in-flight calls cut: 0
10:42:15.377 mcp: 401 for sub=alice sid=sid-2IbmSe2p: session revoked
10:42:15.379 mcp: 401 for sub=alice sid=sid-2IbmSe2p: session revoked
2026/11/22 10:42:13 push attempt 1: delivered in 7ms
Étape 11Voir le 401 sur le fil

Objectif. Appelez le endpoint MCP avec curl, révoquez cette session et rappelez. Le SDK de l’agent dit seulement que le serveur a renvoyé une erreur ; la réponse brute donne la raison dans WWW-Authenticate.

Prérequis

  • L’étape précédente s’est terminée comme indiqué, dans le même terminal
text · wire.sh
echo "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"tools/call\",\"params\":{\"name\":\"list_orders\",\"arguments\":{\"customer\":\"c-1001\"},\"_meta\":{\"io.modelcontextprotocol/protocolVersion\":\"2026-07-28\",\"io.modelcontextprotocol/clientCapabilities\":{}}}}" > call.json
call() { curl -s -i $C $A/mcp -H "authorization: Bearer $(jq -r .access_token tok.json)" -H "content-type: application/json" -H "accept: application/json, text/event-stream" -H "mcp-protocol-version: 2026-07-28" -H "mcp-method: tools/call" -H "mcp-name: list_orders" -d @call.json | grep -i -E "^HTTP|^www-authenticate|^\{" | cut -c1-120; }
curl -s $C -X POST $T/token -d user=alice -d client_id=curl-agent > tok.json; S=$(jq -r .sid tok.json); echo "sid: $S"
call
curl -s $C -X POST $T/admin/revoke -H "authorization: Bearer $ADMIN_TOKEN" -d "{\"sub\":\"alice\",\"sid\":\"$S\",\"reason\":\"wire check\"}"; echo; sleep 0.5
call

Résultat attendu

résultat
sid: sid-RmQBQsIP
HTTP/1.1 200 OK
{"jsonrpc":"2.0","id":1,"result":{"content":[{"text":"{\n  \"customer\": \"c-1001\",\n  \"open_orders\": 2\n}","type":"t
{"emitted":"true","subject_format":"complex"}

HTTP/1.1 401 Unauthorized
www-authenticate: Bearer error="invalid_token", error_description="session revoked"
{"error":"invalid_token","error_description":"session revoked"}
Étape 12Nettoyer

Objectif. Arrêtez les trois processus et supprimez les certificats, les jetons du lab, les logs et les binaires. Seuls les fichiers source restent.

Prérequis

  • Vous avez fini le lab
text · cleanup.sh
./stop.sh
rm -rf certs .env *.log *.json *.jwt billing.sid verify.txt idp-bin ssf
ls
deactivate; rm -rf .venv

Résultat attendu

résultat
0
agent.py
attacks.py
gateway.py
idp
make-certs.sh
mcp_server.py
measure.py
start.sh
stop.sh

Sources#

Discutez-en sur X ou LinkedIn

Suivre sur X

Les nouveaux articles par e-mail

Un e-mail par semaine avec les nouveaux articles et labs. Désinscription à tout moment.

Votre adresse est conservée chez Kit, le service qui envoie les e-mails. Détails

Articles et labs liés