iamops.dev
Argo en X Feed RSS
ESEspañol

Labs A fondo · 35 minutos

Un receiver de Shared Signals delante de un servidor MCP: un evento CAEP corta a un agente

Un receiver SSF ante un servidor MCP, con el transmitter de código abierto SSFgo: un evento CAEP session-revoked cortó una llamada en curso en 8 ms.

Dos capturas de terminal de mi lab de Shared Signals: una llamada de exportación cortada con session revoked by the identity provider, y el registro de la pasarela con el evento y las respuestas 401 que siguieron.
En resumenPuse un receiver de Shared Signals delante de un servidor Model Context…
  • Puse un receiver de Shared Signals delante de un servidor Model Context Protocol (MCP), alimentado por el transmitter de código abierto SSFgo. Un evento session-revoked para alice cortó su exportación y rechazó sus llamadas siguientes, mientras el agente de bob seguía.
  • Desde la llamada de administración hasta que la pasarela aplicó el evento pasaron 8 ms de mediana en diez ejecuciones en una sola máquina. También se rechazó un token emitido en el mismo segundo que la revocación, porque iat va en segundos enteros.
  • Los eventos falsificados, sin firmar, mal dirigidos y repetidos fueron rechazados o ignorados. El evento repetido recibió 202 y no cambió nada.
  • Cortar una sesión de un agente en lugar del usuario necesitaba un subject complejo. El perfil de interoperabilidad del Continuous Access Evaluation Profile (CAEP) lo rechaza, y un stream suscrito a alice como iss_sub nunca lo recibió.
  • No ejecutado: un proveedor de identidad real como transmitter, OAuth (Open Authorization) para la interfaz de programación (API) del stream, la entrega por poll, un almacén de revocaciones persistente y un cliente MCP que gestione el 401.
Repite este lab 12 pasos

Escribí este lab para que puedas repetirlo tú mismo. Cada paso tiene los comandos para copiar y la salida que obtuve yo, y puedes marcarlo como hecho. Las marcas se quedan solo en este navegador.

Ir a los pasos

Cómo funciona

Copia un prompt listo para Claude Code, Cursor, Codex o cualquier agente de código. Solo para entornos de prueba.

Mostrar el 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 de Shared Signals delante de un servidor MCP: un evento CAEP corta a un agente
Read the whole lab here (Markdown): https://iamops.dev/es/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.

El 17 de noviembre de 2026 el grupo de trabajo Shared Signals fusionó un cambio corto en el CAEP Interoperability Profile: desaparece la sección que exigía firmar cada evento con RS256 y una clave de 2048 bits. La copia de trabajo lleva la misma fecha. Una segunda pull request, la #362, todavía abierta, propone formatos de subject para agentes y workloads.

Los dos cambios recaen en el receiver. Si el perfil ya no fija el algoritmo, el receiver tiene que decidir qué acepta. Y cuando el subject es un agente, el receiver suele ser lo que está delante de las herramientas del agente. Así que construí uno: un receiver de Shared Signals dentro de una pequeña pasarela delante de un servidor MCP, alimentado por un transmitter de código abierto, e intenté hacerlo fallar.

Si Shared Signals es nuevo para ti, escribí una explicación breve y un artículo Knowledge más largo sobre Shared Signals Framework (SSF), CAEP y Risk Incident Sharing and Coordination (RISC).

Qué construye el lab#

  • Un proveedor de identidad de laboratorio en el puerto 9443 que firma tokens de acceso para el servidor MCP e incluye el transmitter SSFgo v0.4.2 (SSF 1.0, CAEP 1.0, entrega push de Security Event Tokens (SET) según la Request for Comments (RFC) 8935).
  • Un servidor MCP en el puerto 9000 con dos herramientas: un list_orders rápido y un export_orders lento que informa del progreso durante 20 segundos.
  • Una pasarela en el puerto 9444 que comprueba cada bearer token, reenvía las peticiones MCP y recibe los eventos enviados por push en /ssf/events.
  • Agentes construidos con el kit de desarrollo de software (SDK) de MCP para Python 2.3.0, con la revisión MCP 2026-07-28.

La revisión MCP importa aquí. En 2026-07-28 una petición por Hypertext Transfer Protocol (HTTP) es un POST autónomo, sin handshake initialize y sin Mcp-Session-Id. No hay una sesión MCP que cerrar. La única sesión que queda es la del proveedor de identidad, que viaja en el token como sid. Así que, cuando llega un evento, la pasarela tiene dos tareas: rechazar desde ese momento los tokens de ese usuario o de esa sesión, y cortar cualquier llamada a una herramienta que siga transmitiendo.

Diagrama de secuencia: un agente obtiene un token del IdP del lab y llama a export_orders a través de la pasarela, que reenvía al servidor MCP. El IdP envía un SET CAEP session-revoked para alice; la pasarela lo comprueba, responde 202, corta la llamada en curso con el error JSON-RPC -32001 y responde a la siguiente llamada con 401 invalid_token.
El flujo tal como lo ejecuté. El token lleva sub y sid. El evento nombra a alice por emisor y subject. La pasarela corta lo que está en marcha y rechaza lo que viene después.

Preparación#

Todo se ejecutó en una máquina Linux el 22 de noviembre de 2026: Go 1.27.3 para el proveedor de identidad, Python 3.13.5 con el SDK de MCP 2.3.0, PyJWT 2.15.1, httpx 0.28.1 y Starlette 1.10.0 para el resto. SSF exige https para el emisor y para los endpoints de push, así que make-certs.sh crea una autoridad de certificación (CA) desechable y un certificado para localhost. Tres tokens aleatorios del lab van a .env: uno que la pasarela usa para la API del stream, uno que el transmitter debe enviar con cada push y uno para la acción de administración que revoca a un usuario.

El proveedor de identidad es un sustituto. Firma un token para quien lo pida, así que no dice nada del inicio de sesión. Lo que muestra es la parte posterior: un único emisor para el token de acceso y para los eventos, de modo que iss y sub en el token son el mismo par que nombra el evento.

Por defecto SSFgo se niega a hacer push a direcciones de loopback, como protección frente a un receiver que registre una dirección web (URL) interna. El lab sustituye su cliente HTTP por uno que confía en la CA del lab. En producción mantendría el valor por defecto y listaría los hosts internos de forma explícita.

El stream#

La pasarela es un receiver, así que empieza leyendo los metadatos del transmitter. La herramienta de línea de comandos de SSFgo, ejecutada como lo haría un receiver, los aceptó. Luego creé un stream push que solo pide session-revoked, con el endpoint de push y el valor bearer que el transmitter debe enviar.

Terminal: ssf metadata acepta el transmitter, los metadatos indican entrega push y poll y default_subjects NONE, el stream se crea con events_delivered session-revoked y la configuración del stream devuelve la cabecera de autorización del push completa.
Metadatos y stream. La configuración del stream vuelve con la cabecera de autorización del push completa.

La última línea me sorprendió. La respuesta a la creación devolvía authorization_header con el token de push completo. Quien pueda leer la configuración del stream con el token del receiver puede leer el secreto en el que confía la pasarela para los eventos entrantes. Trata el token de la API del stream como un secreto del mismo peso.

El transmitter anuncia default_subjects: NONE, así que la pasarela tiene que añadir cada subject del que quiera eventos. Añadí a alice y a bob como subjects iss_sub y pedí un evento de verificación. El transmitter registró el push como entregado en 10 ms.

Terminal: añadir los subjects alice y bob devuelve HTTP 200, el estado del stream es enabled, verify devuelve 204, la pasarela registra el evento de verificación con el state lab-check-1 y el transmitter registra un push entregado en 10 ms.
Subjects y verificación. El valor de state vuelve dentro de un evento firmado, así que la pasarela sabe que la ruta del push funciona de extremo a extremo.

El token que comprueba la pasarela#

El token de acceso es un JavaScript Object Notation (JSON) Web Token (JWT) con typ at+jwt, la URL /mcp de la pasarela como audiencia y un sid. Lo pegué con el JSON Web Key Set (JWKS) de los tokens en la herramienta JWT de iamops.dev, con el emisor y la audiencia que espero. Firma, emisor y audiencia coincidían.

Terminal: la cabecera del token decodificada con alg RS256, kid at-1 y typ at+jwt, y el payload con aud https://localhost:9444/mcp, client_id support-agent, iss, sid, sub alice y una vida de una hora.
El token de acceso. sub y sid son lo que la pasarela compara con los eventos.
Herramienta JWT de iamops.dev: el token y la clave pegados están difuminados, firma válida con RS256 y kid at-1, hallazgos vida 1h, no caducado, audiencia y emisor coinciden, y la tabla de claims con sid y sub alice.
El mismo token en la herramienta JWT de iamops.dev. El token y la clave pegados están difuminados y la huella de la clave está sustituida.

Cortar a los agentes de alice#

Tres agentes funcionaban a la vez: el agente de exportación de alice con la herramienta lenta, su agente de facturación llamando a la herramienta rápida cada dos segundos y el agente de soporte de bob haciendo lo mismo. A los siete segundos revoqué a alice en el proveedor de identidad.

Terminal: el agente de exportación muestra el progreso del 5 al 35 por ciento y después refused con MCPError session revoked by the identity provider, call cut. El agente de facturación de alice tiene éxito cuatro veces y se rechaza tras la revocación. El agente de soporte de bob tiene éxito todas las veces.
El corte. La exportación se paró en el 35 por ciento. El agente de facturación de alice se rechazó desde la llamada siguiente. A bob no le afectó.

El registro de la pasarela muestra el orden. El evento llegó a las 10:39:50.971, la exportación en curso se cortó en el mismo milisegundo y cada petición posterior con un token de alice recibió 401. El transmitter registró un push, entregado en 4 ms.

Terminal: líneas del registro de la pasarela con llamadas de bob y alice reenviadas, luego ssf session-revoked para todas las sesiones de alice con una llamada en curso cortada, cut in-flight export_orders, y 401 para la sesión de facturación de alice mientras las llamadas de bob se siguen reenviando. El registro del IdP muestra un push entregado en 4 ms.
El registro de la pasarela. Un evento, una llamada en curso cortada, después 401 para alice y reenvío para bob.

Cada intento rechazado aparece dos veces en el registro. El cliente del SDK prueba primero con server/discover y, si falla, intenta el handshake initialize anterior. Los dos recibieron 401. El agente solo imprimió “Server returned an error response”: el SDK no le mostró a mi código ni el 401 ni la cabecera WWW-Authenticate.

El SET en el cable#

La pasarela guardó el último evento que aceptó. ssf verify de SSFgo lo comprobó con las claves publicadas del transmitter, el emisor y la audiencia, como haría un receiver. El subject es iss_sub con alice, y el evento lleva initiating_entity admin y el motivo que escribí.

Terminal: ssf verify imprime verified true, la cabecera con alg RS256, typ secevent+jwt y kid ssf-set-1, sub_id iss_sub alice y el evento session-revoked con event_timestamp, initiating_entity admin y reason_admin Agent misuse reported.
El evento. Un Security Event Token: typ secevent+jwt, sub_id en lugar de sub, sin exp.

El decodificador de SET de Shared Signals de iamops.dev leyó el mismo evento con el JWKS del transmitter y verificó la firma. Nombra el tipo de evento, explica el subject iss_sub y señala el claim txn que añadió SSFgo.

Decodificador de SET de Shared Signals de iamops.dev: el SET y el JWKS pegados están difuminados, el SET está bien formado para SSF 1.0, la firma se verifica con kid ssf-set-1, el evento CAEP session revoked con el motivo Agent misuse reported, el subject iss_sub alice y los claims del SET con los identificadores aleatorios sustituidos.
El mismo SET en el decodificador de iamops.dev. Valores pegados difuminados, identificadores aleatorios sustituidos.

Eventos falsificados y repetidos#

attacks.py envía directamente a /ssf/events. Sin el token de push, o con uno incorrecto, la pasarela respondió 401. Un cuerpo JSON recibió 400 invalid_request. Un evento firmado con una clave mía pero con el kid del transmitter recibió 400 invalid_key, igual que alg: none, porque la pasarela solo acepta RS256. Un typ JWT se rechazó. Repetir el último evento real recibió 202, como espera RFC 8935 para un evento que el receiver ya tiene, y no cambió nada: la pasarela guarda cada jti que ha aplicado.

Terminal: siete push con resultados 401, 401, 400 invalid_request, 400 invalid_key para una clave ajena, 400 invalid_key para alg none, 400 invalid_request para typ JWT, 202 para la repetición; la lista de usuarios revocados sigue teniendo solo a alice. Un evento para carol, que no está en el stream, se emite pero no se envía. Un nuevo inicio de sesión de alice funciona.
Eventos malos. Seis rechazados, la repetición aceptada e ignorada. Un evento para un subject que no está en el stream nunca se envió.

Dos resultados más en la misma captura. Un evento para carol, que no está en el stream, se emitió en el proveedor de identidad pero nunca se envió. Y alice volvió a iniciar sesión después de la revocación y obtuvo un token que funcionaba. Una revocación de sesión termina sesiones, no bloquea la cuenta. Si la cuenta debe quedar bloqueada, es el proveedor de identidad el que tiene que rechazar el inicio de sesión, y el evento que hay que enviar es otro.

No probé una audiencia o un emisor incorrectos con un evento bien firmado. Haría falta un segundo stream o un segundo transmitter con sus propias claves, y no ejecuté ninguno de los dos.

Cómo de rápido, y el hueco del mismo segundo#

measure.py llamó al endpoint de administración diez veces y consultó la pasarela hasta que había aplicado cada evento: 8, 8, 8, 8, 9, 7, 8, 7, 7 y 7 ms, una mediana de 8 ms. Es una sola máquina con loopback, así que mide el software, no una red.

Terminal: diez ejecuciones entre 7 y 9 ms con una mediana de 8 ms; después un extracto del registro en el que el session-revoked de alice se aplica a las 10:40:58.059, se emite un token para alice en el mismo segundo y la pasarela responde 401 para esa nueva sesión.
Tiempos, y un efecto secundario. Un token emitido menos de un segundo después de la revocación, en el mismo segundo, se rechazó.

El efecto secundario venía de mi propia regla. La pasarela rechaza todo token de un usuario revocado con iat igual o anterior a la hora del evento, y ambos van en segundos enteros. La última medición revocó a alice a las 10:40:58.059. El paso siguiente inició su sesión a las 10:40:58 y ese token se rechazó. Redondear hacia el otro lado dejaría pasar un token emitido justo antes de la revocación. Mantuve el lado estricto y haría lo mismo en producción, con una nota para el servicio de soporte.

Revocar una sesión de un agente, no al usuario#

Revocar a alice cortó a todos sus agentes. A menudo se quiere menos: terminar la sesión del agente de facturación y dejar funcionando sus otros agentes. SSF tiene para eso un subject complejo, con un miembro user y un miembro session.

El perfil de interoperabilidad CAEP, tal como lo aplica SSFgo, solo admite subjects email e iss_sub, así que el transmitter rechazó el evento con HTTP 422. Reinicié el proveedor de identidad con las reglas simples de SSF 1.0 y CAEP 1.0, volví a crear el stream y suscribí a alice como iss_sub. El evento de sesión se emitió y nunca se envió. Las reglas de coincidencia de subjects de la sección 8.1.3 de SSF 1.0 definen la coincidencia entre dos subjects simples y entre dos subjects complejos, y no dicen nada de una mezcla. SSFgo lo interpreta así: un subject simple nunca coincide con uno complejo.

Terminal: la revocación con un id de sesión se rechaza con HTTP 422 porque con el perfil interop los eventos CAEP deben usar un subject email o iss_sub; el IdP se reinicia con el perfil ssf, se crea un stream nuevo y se añade a alice como iss_sub; el evento de sesión se emite pero el registro del transmitter no muestra ningún push y la pasarela contó cero eventos session-revoked.
Dos formas de perder un evento de sesión. El perfil lo rechaza, y una suscripción simple no coincide con él.

La solución fue suscribir un subject complejo solo con user. Los miembros que la suscripción omite actúan como comodines, así que coincide con cualquier sesión de alice. Con eso el evento llegó, la pasarela revocó solo el sid del agente de facturación y el agente de soporte de alice siguió recibiendo 200.

Diagrama de secuencia: con el perfil interop un subject complejo se rechaza con 422; tras reiniciar con el perfil simple el evento se emite pero no se envía porque no coincide con la suscripción iss_sub; tras suscribir un subject complejo con user alice el SET llega, la pasarela revoca un sid, el agente de facturación recibe 401 y el agente de soporte 200.
Una sesión, tres intentos. Solo la suscripción compleja lo entregó.
Terminal: añadir un subject complejo con user alice devuelve 200; funcionan dos agentes de alice; la revocación con el sid del agente de facturación devuelve subject_format complex; el agente de facturación se rechaza desde la llamada siguiente mientras el de soporte tiene éxito todas las veces; la pasarela registra session-revoked para una sesión y el IdP un push entregado en 7 ms.
Una sesión de agente cortada. El mismo usuario, dos agentes, uno rechazado.

El decodificador muestra el subject complejo en dos partes: alice como iss_sub y la sesión como id opaque.

Decodificador de SET de Shared Signals de iamops.dev con un SET session-revoked cuyo sub_id es complex, con un miembro user iss_sub alice y un miembro session opaque con el id de sesión; firma verificada, valores pegados difuminados.
Un subject complejo en el decodificador. user y session juntos nombran una sesión de un agente.

El 401 que ve el agente#

Con curl la respuesta es clara. Antes del evento la llamada devolvió 200. Después, el mismo token recibió 401 con WWW-Authenticate: Bearer error="invalid_token", error_description="session revoked". Un agente que lea esa cabecera sabe que debe volver a iniciar sesión en lugar de reintentar.

Terminal: un tools/call con las cabeceras mcp-method y mcp-name devuelve 200 con el resultado de los pedidos, la revocación de esa sesión devuelve subject_format complex y la misma llamada devuelve después 401 con WWW-Authenticate Bearer error invalid_token, error_description session revoked.
Antes y después, en el cable. La misma petición, 200 y luego 401.

La petición en bruto necesitó también las cabeceras Mcp-Method y Mcp-Name y dos claves en _meta antes de que el servidor 2026-07-28 la aceptara. Sin ellas, el servidor respondió 400 con un error JSON-RPC. Una pasarela puede leer el nombre de la herramienta en la cabecera, pero el servidor lo compara igualmente con el cuerpo.

Trampas#

  • La configuración del stream devuelve el secreto del push. Protege el token de la API del stream tanto como el token de push.
  • SSFgo rechaza por defecto los push a loopback. Bien en producción, una sorpresa en un lab.
  • El perfil interop exige anunciar la entrega por poll. El transmitter se negó a arrancar con el perfil hasta que listé RFC 8936 junto al push.
  • Segundos enteros en ambos lados. Una revocación y un nuevo inicio de sesión en el mismo segundo chocan. Elige un lado a propósito.
  • En este lab las revocaciones viven en memoria. Un reinicio de la pasarela las olvida, y un token emitido antes de la revocación volvería a funcionar hasta caducar. Guárdalas al menos durante la vida del token de acceso, en un almacén que sobreviva a los reinicios.
  • Un evento session-revoked no bloquea la cuenta. alice volvió a entrar poco después.

Qué haría con esto#

  1. Poner el receiver donde llega cada petición de los agentes: la pasarela MCP, no cada herramienta.
  2. Incluir sid en los tokens de acceso de tus agentes y asegurarte de que el emisor de los tokens y el de los eventos sea el mismo, o mantener una correspondencia.
  3. Suscribir los subjects que necesitas en la forma en que los enviará el transmitter. Si quieres eventos por sesión, suscribe un subject complejo con user.
  4. Fijar los algoritmos que aceptas, ahora que el perfil ya no lo hace. Solo RS256, nada de none, claves del jwks_uri del transmitter.
  5. Cortar las llamadas a herramientas en curso, no solo las nuevas. Con MCP 2026-07-28 no hay sesión que cerrar, así que la pasarela tiene que seguir lo que está transmitiendo.

Qué no se ejecutó#

El transmitter es SSFgo dentro de mi propio proveedor de identidad de laboratorio, no un proveedor de identidad comercial. La API del stream usó un bearer token estático, no OAuth como exige el perfil interop. No ejecuté la entrega por poll, las actualizaciones, la pausa ni el borrado de un stream, ni el evento de cambio de credenciales. No probé un evento bien firmado con una audiencia o un emisor incorrectos. El almacén de revocaciones está en memoria y no probé un reinicio de la pasarela. No ejecuté la suite de conformidad de OpenID contra la pasarela. Los clientes MCP eran scripts sobre el SDK, no un producto de agente real, y ninguno reaccionó al 401 volviendo a iniciar sesión. No hay grabación de este lab.

Las imágenes de terminal se generaron a partir de la salida guardada de la ejecución del 22 de noviembre de 2026, hora Europe/Zurich. Los tokens, claves y certificados del lab eran aleatorios, estuvieron menos de una hora en una sola máquina y se borraron al final.

Repite este lab#

Todo lo necesario para ejecutar este lab en una máquina Linux en unos 35 minutos, sin cuentas: una CA desechable, un IdP basado en SSFgo, un servidor MCP y una pasarela que recibe eventos CAEP. Abre cada paso, copia los bloques y compara tu salida con la esperada.

Cada valor entre corchetes angulares es un marcador para tu entorno de prueba. Nada en esta página es un identificador o secreto real.

Define tus variables una sola vez

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
Paso 1Crea la CA y compila el IdP

Objetivo. Guarda make-certs.sh y la carpeta idp, crea una CA desechable con un certificado para localhost, compila el IdP del lab sobre SSFgo v0.4.2 e instala la herramienta de línea de comandos ssf.

Requisitos

  • Linux con Go 1.26.10 o posterior (probado con 1.27.3), Python 3.13, openssl, curl y jq
  • Una carpeta vacía para el lab; ejecuta cada paso desde ella
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

Salida esperada

salida
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
Paso 2Instala la parte en Python

Objetivo. Crea un venv con versiones fijas y guarda el servidor MCP, la pasarela que también es el receiver SSF, y el agente de prueba.

Requisitos

  • El paso anterior terminó como se muestra, en el mismo 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))

Salida esperada

salida
cryptography              50.0.2
httpx                     0.28.1
mcp                       2.3.0
PyJWT                     2.15.1
starlette                 1.10.0
uvicorn                   0.54.0
Paso 3Crea los tokens del lab y arráncalo todo

Objetivo. Escribe tres tokens aleatorios del lab en .env y arranca el IdP con el perfil de interoperabilidad CAEP, el servidor MCP y la pasarela.

Requisitos

  • El paso anterior terminó como se muestra, en el mismo terminal
  • Puertos 9000, 9443 y 9444 libres en 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

Salida esperada

salida
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
Paso 4Crea el stream y añade a alice y bob

Objetivo. Comprueba los metadatos SSF con la herramienta ssf, crea un stream push para session-revoked, añade dos usuarios como subjects y pide un evento de verificación. La respuesta del stream devuelve el token de push completo.

Requisitos

  • El paso anterior terminó como se muestra, en el mismo 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

Salida esperada

salida
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
Paso 5Obtén un token y lee lo que comprueba la pasarela

Objetivo. Pide al IdP un token de acceso para alice y decodifícalo. La pasarela comprueba emisor, audiencia, caducidad y firma, y necesita el claim sid para revocar una sola sesión.

Requisitos

  • El paso anterior terminó como se muestra, en el mismo 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 .

Salida esperada

salida
{"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"
}
Paso 6Revoca a alice mientras trabajan tres agentes

Objetivo. Lanza una exportación larga y una consulta repetida para alice y una consulta para bob, y emite session-revoked para alice. La exportación se corta a medias, el otro agente de alice recibe 401 y bob sigue trabajando.

Requisitos

  • El paso anterior terminó como se muestra, en el mismo 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}"

Salida esperada

salida
{"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":[]}
Paso 7Verifica el SET que recibió la pasarela

Objetivo. Comprueba el último Security Event Token recibido con ssf verify: firma, typ secevent+jwt, emisor y audiencia. Después vuelve a iniciar sesión con alice para ver que el evento no bloqueó su cuenta.

Requisitos

  • El paso anterior terminó como se muestra, en el mismo 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

Salida esperada

salida
{
  "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 }
Paso 8Envía eventos falsos y repetidos

Objetivo. Envía siete eventos malos al receiver: bearer ausente o erróneo, content type incorrecto, una clave ajena, alg none, typ incorrecto y una repetición. Ninguno debe cambiar la lista de revocaciones. Después revoca a carol, que no está en el stream.

Requisitos

  • El paso anterior terminó como se muestra, en el mismo 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

Salida esperada

salida
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=""
Paso 9Mide el tiempo de corte

Objetivo. Ejecuta diez revocaciones y mide cada una desde la llamada de administración hasta que la pasarela la aplica. Después mira el efecto secundario: un token emitido en el mismo segundo que una revocación se rechaza.

Requisitos

  • El paso anterior terminó como se muestra, en el mismo 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

Salida esperada

salida
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
Paso 10Revoca una sesión de un agente, no al usuario

Objetivo. El perfil interop rechaza un subject complejo con sesión, así que reinicia el IdP con SSF simple, suscribe un subject complejo para alice y revoca solo la sesión del agente de facturación.

Requisitos

  • El paso anterior terminó como se muestra, en el mismo 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

Salida esperada

salida
{"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
Paso 11Mira el 401 en el cable

Objetivo. Llama al endpoint MCP con curl, revoca esa sesión y vuelve a llamar. El SDK del agente solo dice que el servidor devolvió un error; la respuesta en bruto trae el motivo en WWW-Authenticate.

Requisitos

  • El paso anterior terminó como se muestra, en el mismo 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

Salida esperada

salida
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"}
Paso 12Limpieza

Objetivo. Detén los tres procesos y borra los certificados, los tokens del lab, los logs y los binarios. Solo quedan los archivos fuente.

Requisitos

  • Has terminado el 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

Salida esperada

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

Fuentes#

Coméntalo en X o LinkedIn

Seguir en X

Nuevos artículos por correo

Un correo a la semana con nuevos artículos y labs. Puedes darte de baja cuando quieras.

Tu dirección se guarda en Kit, el servicio que envía los correos. Detalles

Artículos y labs relacionados