# 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.

- URL: https://iamops.dev/fr/ssf-caep-receiver-mcp-gateway/
- Language: fr
- Author: Argo
- Published: 2026-11-22
- Category: Labs
- Depth: Approfondissement
- Time: 35 minutes
- Topics: Shared Signals, CAEP, MCP, Révocation, Agents IA

## En bref

- J’ai placé un receiver [Shared Signals](https://iamops.dev/fr/shared-signals-caep-explained/) 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](https://iamops.dev/fr/ssf-caep-receiver-mcp-gateway/#couper-les-agents-dalice), 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](https://iamops.dev/fr/ssf-caep-receiver-mcp-gateway/#à-quelle-vitesse-et-le-trou-de-la-même-seconde) 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](https://iamops.dev/fr/ssf-caep-receiver-mcp-gateway/#événements-forgés-et-rejoués). L’événement rejoué a reçu 202 et n’a rien changé.
- Couper [une session d’agent plutôt que l’utilisateur](https://iamops.dev/fr/ssf-caep-receiver-mcp-gateway/#révoquer-une-session-dagent-pas-lutilisateur) 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é](https://iamops.dev/fr/ssf-caep-receiver-mcp-gateway/#ce-qui-na-pas-été-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.

Le 17 novembre 2026, le groupe de travail Shared Signals a fusionné [une courte modification](https://github.com/openid/sharedsignals/pull/368) 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](https://openid.github.io/sharedsignals/openid-caep-interoperability-profile-1_0.html) porte la même date. Une seconde pull request, la [#362](https://github.com/openid/sharedsignals/pull/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](https://iamops.dev/fr/shared-signals-caep-explained/) et un [article Knowledge sur le Shared Signals Framework (SSF), CAEP et Risk Incident Sharing and Coordination (RISC)](https://iamops.dev/fr/shared-signals-caep-risc-agent-access/).

## 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](https://github.com/idfoundry/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.](https://iamops.dev/media/ssf-caep-receiver-mcp-gateway/00-flow.webp)

*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.](https://iamops.dev/media/ssf-caep-receiver-mcp-gateway/01-stream.webp)

*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.](https://iamops.dev/media/ssf-caep-receiver-mcp-gateway/01b-subscribe.webp)

*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](https://iamops.dev/tools/jwt/), 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.](https://iamops.dev/media/ssf-caep-receiver-mcp-gateway/02-token.webp)

*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.](https://iamops.dev/media/ssf-caep-receiver-mcp-gateway/tool-jwt.webp)

*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.](https://iamops.dev/media/ssf-caep-receiver-mcp-gateway/03-cut.webp)

*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.](https://iamops.dev/media/ssf-caep-receiver-mcp-gateway/04-gateway-log.webp)

*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.](https://iamops.dev/media/ssf-caep-receiver-mcp-gateway/05-set-verify.webp)

*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](https://iamops.dev/tools/shared-signals/) 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.](https://iamops.dev/media/ssf-caep-receiver-mcp-gateway/tool-ssf.webp)

*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.](https://iamops.dev/media/ssf-caep-receiver-mcp-gateway/06-attacks.webp)

*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.](https://iamops.dev/media/ssf-caep-receiver-mcp-gateway/07-timing.webp)

*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.](https://iamops.dev/media/ssf-caep-receiver-mcp-gateway/08-interop-profile.webp)

*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.](https://iamops.dev/media/ssf-caep-receiver-mcp-gateway/00b-one-session-flow.webp)

*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.](https://iamops.dev/media/ssf-caep-receiver-mcp-gateway/09-one-session.webp)

*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.](https://iamops.dev/media/ssf-caep-receiver-mcp-gateway/tool-ssf-complex.webp)

*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.](https://iamops.dev/media/ssf-caep-receiver-mcp-gateway/10-wire.webp)

*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** `env.sh` (text)

```text
# 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 1: Cré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

`make-certs.sh` (text)

```text
#!/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
```

`idp/go.mod` (text)

```text
module ssfmcp/idp

go 1.26.10

require github.com/idfoundry/ssfgo v0.4.2
```

`idp/main.go` (text)

```text
// 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 }

```

`build.sh` (text)

```text
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**

```text
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 2: Installer 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

`venv.sh` (text)

```text
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) "
```

`mcp_server.py` (text)

```text
"""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)
```

`gateway.py` (text)

```text
"""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")
```

`agent.py` (text)

```text
"""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**

```text
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 3: Cré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

`start.sh` (text)

```text
#!/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
```

`stop.sh` (text)

```text
#!/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
```

`run.sh` (text)

```text
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**

```text
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 4: Cré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

`stream.sh` (text)

```text
./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**

```text
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 5: Obtenir 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

`token.sh` (text)

```text
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**

```text
{"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 6: Ré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

`cut.sh` (text)

```text
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**

```text
{"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 7: Vé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

`set.sh` (text)

```text
./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**

```text
{
  "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 8: Envoyer 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

`attacks.py` (text)

```text
"""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"]))
```

`attacks.sh` (text)

```text
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**

```text
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 9: Mesurer 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

`measure.py` (text)

```text
"""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")
```

`timing.sh` (text)

```text
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**

```text
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 10: Ré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

`interop-refuses.sh` (text)

```text
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"
```

`one-session.sh` (text)

```text
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**

```text
{"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 11: Voir 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

`wire.sh` (text)

```text
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**

```text
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 12: Nettoyer

**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

`cleanup.sh` (text)

```text
./stop.sh
rm -rf certs .env *.log *.json *.jwt billing.sid verify.txt idp-bin ssf
ls
deactivate; rm -rf .venv
```

**Résultat attendu**

```text
0
agent.py
attacks.py
gateway.py
idp
make-certs.sh
mcp_server.py
measure.py
start.sh
stop.sh
```


## Sources

- [openid/sharedsignals PR #368, Drop event signatures (merged 17 Nov 2026)](https://github.com/openid/sharedsignals/pull/368)
- [CAEP Interoperability Profile 1.0, working copy dated 17 November 2026](https://openid.github.io/sharedsignals/openid-caep-interoperability-profile-1_0.html)
- [openid/sharedsignals PR #362, agent and workload as subject (open)](https://github.com/openid/sharedsignals/pull/362)
- [OpenID Shared Signals Framework Specification 1.0 (Final)](https://openid.net/specs/openid-sharedsignals-framework-1_0-final.html)
- [OpenID Continuous Access Evaluation Profile 1.0 (Final)](https://openid.net/specs/openid-caep-1_0-final.html)
- [RFC 8935: Push-Based Security Event Token Delivery Using HTTP](https://www.rfc-editor.org/rfc/rfc8935)
- [RFC 8417: Security Event Token (SET)](https://www.rfc-editor.org/rfc/rfc8417)
- [RFC 9493: Subject Identifiers for Security Event Tokens](https://www.rfc-editor.org/rfc/rfc9493)
- [SSFgo, an SSF 1.0 transmitter and receiver for Go (v0.4.2)](https://github.com/idfoundry/ssfgo)
- [Model Context Protocol specification 2026-07-28: Transports](https://modelcontextprotocol.io/specification/2026-07-28/basic/transports)

Discuss: [X](https://x.com/iamopsdev) | [LinkedIn](https://www.linkedin.com/company/iamops-dev/)
