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

- URL: https://iamops.dev/es/ssf-caep-receiver-mcp-gateway/
- Language: es
- Author: Argo
- Published: 2026-11-22
- Category: Labs
- Depth: A fondo
- Time: 35 minutos
- Topics: Shared Signals, CAEP, MCP, Revocación, Agentes de IA

## En resumen

- Puse un receiver de [Shared Signals](https://iamops.dev/es/shared-signals-caep-explained/) 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](https://iamops.dev/es/ssf-caep-receiver-mcp-gateway/#cortar-a-los-agentes-de-alice), 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](https://iamops.dev/es/ssf-caep-receiver-mcp-gateway/#cómo-de-rápido-y-el-hueco-del-mismo-segundo) 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](https://iamops.dev/es/ssf-caep-receiver-mcp-gateway/#eventos-falsificados-y-repetidos). El evento repetido recibió 202 y no cambió nada.
- Cortar [una sesión de un agente en lugar del usuario](https://iamops.dev/es/ssf-caep-receiver-mcp-gateway/#revocar-una-sesión-de-un-agente-no-al-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](https://iamops.dev/es/ssf-caep-receiver-mcp-gateway/#qué-no-se-ejecutó): 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.

El 17 de noviembre de 2026 el grupo de trabajo Shared Signals fusionó [un cambio corto](https://github.com/openid/sharedsignals/pull/368) 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](https://openid.github.io/sharedsignals/openid-caep-interoperability-profile-1_0.html) lleva la misma fecha. Una segunda pull request, la [#362](https://github.com/openid/sharedsignals/pull/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](https://iamops.dev/es/shared-signals-caep-explained/) y un [artículo Knowledge más largo sobre Shared Signals Framework (SSF), CAEP y Risk Incident Sharing and Coordination (RISC)](https://iamops.dev/es/shared-signals-caep-risc-agent-access/).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

### Paso 1: Crea 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

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

**Salida esperada**

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

### Paso 2: Instala 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

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

**Salida esperada**

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

### Paso 3: Crea 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

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

**Salida esperada**

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

### Paso 4: Crea 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

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

**Salida esperada**

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

### Paso 5: Obté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

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

**Salida esperada**

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

### Paso 6: Revoca 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

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

**Salida esperada**

```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":[]}
```

### Paso 7: Verifica 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

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

**Salida esperada**

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

### Paso 8: Enví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

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

**Salida esperada**

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

### Paso 9: Mide 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

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

**Salida esperada**

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

### Paso 10: Revoca 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

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

**Salida esperada**

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

```

### Paso 11: Mira 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

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

**Salida esperada**

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

### Paso 12: Limpieza

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

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

**Salida esperada**

```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/)
