Kurz gesagt
- Ich habe einen Shared-Signals-Receiver vor einen Model Context Protocol (MCP) Server gesetzt, gespeist vom Open-Source-Transmitter SSFgo. Ein Ereignis session-revoked für alice brach ihren Export ab und lehnte ihre nächsten Aufrufe ab, während bobs Agent weiterlief.
- Vom Admin-Aufruf bis zur Anwendung im Gateway vergingen im Median 8 ms über zehn Läufe auf einem Rechner. Auch ein Token aus derselben Sekunde wie der Widerruf wurde abgelehnt, weil iat ganze Sekunden hat.
- Gefälschte, unsignierte, falsch adressierte und wiederholte Ereignisse wurden abgelehnt oder ignoriert. Das wiederholte Ereignis bekam 202 und änderte nichts.
- Um eine Agentensitzung statt des Benutzers zu beenden, brauchte es ein komplexes Subject. Das Interoperabilitätsprofil des Continuous Access Evaluation Profile (CAEP) lehnt das ab, und ein Stream, der alice als iss_sub abonniert hatte, erhielt es nie.
- Nicht ausgeführt: ein echter Identity Provider als Transmitter, OAuth (Open Authorization) für die Programmierschnittstelle (API) des Streams, Poll-Zustellung, ein dauerhafter Widerrufsspeicher und ein MCP-Client, der den 401 behandelt.
Dieses Lab nachbauen
Dieses Lab habe ich so geschrieben, dass Sie es selbst nachbauen können. Jeder Schritt enthält die Befehle zum Kopieren und die Ausgabe, die ich bekommen habe, und Sie können ihn als erledigt abhaken. Die Haken bleiben nur in diesem Browser.
Kopiert einen fertigen Prompt für Claude Code, Cursor, Codex oder einen anderen Coding-Agenten. Nur für Testumgebungen.
Prompt anzeigen
I want to run a hands-on lab from iamops.dev, and I would like your help to do it safely. Lab: Ein Shared-Signals-Receiver vor einem MCP-Server: ein CAEP-Ereignis stoppt einen Agenten Read the whole lab here (Markdown): https://iamops.dev/de/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.
Am 17. November 2026 hat die Shared-Signals-Arbeitsgruppe eine kurze Änderung am CAEP Interoperability Profile übernommen: Der Abschnitt, der für jedes Ereignis eine Signatur mit RS256 und einem 2048-Bit-Schlüssel verlangte, ist weg. Die Arbeitskopie trägt dasselbe Datum. Ein zweiter, noch offener Pull Request, #362, schlägt Subject-Formate für Agenten und Workloads vor.
Beide Änderungen landen beim Receiver. Ohne festen Algorithmus im Profil muss der Receiver selbst entscheiden, was er annimmt. Und wenn das Subject ein Agent ist, sitzt der Receiver meist vor den Tools des Agenten. Also habe ich einen gebaut: einen Shared-Signals-Receiver in einem kleinen Gateway vor einem MCP-Server, gespeist von einem Open-Source-Transmitter, und habe versucht, ihn zu Fehlern zu bringen.
Falls Shared Signals neu für Sie ist: Es gibt eine kurze Erklärung und einen längeren Knowledge-Artikel zu Shared Signals Framework (SSF), CAEP und Risk Incident Sharing and Coordination (RISC).
Was das Lab aufbaut#
- Einen Lab-Identity-Provider auf Port 9443, der Access Tokens für den MCP-Server signiert und den Transmitter SSFgo v0.4.2 enthält (SSF 1.0, CAEP 1.0, Push-Zustellung von Security Event Tokens (SET) nach Request for Comments (RFC) 8935).
- Einen MCP-Server auf Port 9000 mit zwei Tools: einem schnellen
list_ordersund einem langsamenexport_orders, das 20 Sekunden lang Fortschritt meldet. - Ein Gateway auf Port 9444, das jedes Bearer-Token prüft, MCP-Anfragen weiterleitet und gepushte Ereignisse auf
/ssf/eventsempfängt. - Agenten auf Basis des MCP Python Software Development Kit (SDK) 2.3.0 mit der MCP-Revision 2026-07-28.
Die MCP-Revision spielt hier eine Rolle. In 2026-07-28 ist eine Anfrage über Hypertext Transfer Protocol (HTTP) ein eigenständiger POST ohne initialize-Handshake und ohne Mcp-Session-Id. Es gibt keine MCP-Sitzung, die man beenden könnte. Die einzige verbleibende Sitzung ist die beim Identity Provider, im Token als sid mitgeführt. Wenn ein Ereignis eintrifft, hat das Gateway deshalb zwei Aufgaben: ab sofort die Tokens dieses Benutzers oder dieser Sitzung ablehnen und jeden Tool-Aufruf abbrechen, der noch streamt.

Aufbau#
Alles lief am 22. November 2026 auf einem Linux-Rechner: Go 1.27.3 für den Identity Provider, Python 3.13.5 mit dem MCP SDK 2.3.0, PyJWT 2.15.1, httpx 0.28.1 und Starlette 1.10.0 für den Rest. SSF verlangt https für den Issuer und für Push-Endpunkte, deshalb erstellt make-certs.sh eine Wegwerf-Zertifizierungsstelle (CA) und ein Zertifikat für localhost. Drei zufällige Lab-Tokens kommen in .env: eines nutzt das Gateway für die Stream-API, eines muss der Transmitter bei jedem Push mitsenden, eines ist für die Admin-Aktion, die einen Benutzer widerruft.
Der Identity Provider ist ein Platzhalter. Er signiert jedem ein Token, der danach fragt, sagt also nichts über die Anmeldung aus. Er zeigt den Teil nach der Anmeldung: einen Issuer für Access Token und Ereignisse, sodass iss und sub im Token dasselbe Paar sind, das das Ereignis nennt.
SSFgo verweigert standardmäßig Pushes an Loopback-Adressen, als Schutz gegen einen Receiver, der eine interne Webadresse (URL) registriert. Das Lab ersetzt den HTTP-Client durch einen, der der Lab-CA vertraut. In Produktion würde ich den Standard behalten und interne Hosts ausdrücklich freigeben.
Der Stream#
Das Gateway ist ein Receiver und liest deshalb zuerst die Metadaten des Transmitters. Das Kommandozeilenwerkzeug von SSFgo, so ausgeführt wie ein Receiver es tun würde, hat sie akzeptiert. Dann habe ich einen Push-Stream angelegt, der nur session-revoked anfordert, mit dem Push-Endpunkt und dem Bearer-Wert, den der Transmitter mitsenden muss.

Die letzte Zeile hat mich überrascht. Die Antwort auf das Anlegen enthielt authorization_header mit dem kompletten Push-Token. Wer die Stream-Konfiguration mit dem Token des Receivers lesen kann, kann auch das Geheimnis lesen, dem das Gateway bei eingehenden Ereignissen vertraut. Behandeln Sie das Token der Stream-API als gleich wertvolles Geheimnis.
Der Transmitter meldet default_subjects: NONE, also muss das Gateway jedes Subject hinzufügen, für das es Ereignisse will. Ich habe alice und bob als iss_sub-Subjects hinzugefügt und ein Verifikationsereignis angefordert. Der Transmitter protokollierte den Push als in 10 ms zugestellt.

Das Token, das das Gateway prüft#
Das Access Token ist ein JavaScript Object Notation (JSON) Web Token (JWT) mit typ at+jwt, der /mcp-URL des Gateways als Audience und einem sid. Ich habe es mit dem Token-JWKS in das JWT-Tool von iamops.dev eingefügt, zusammen mit dem erwarteten Issuer und der erwarteten Audience. Signatur, Issuer und Audience passten.


alices Agenten abschneiden#
Drei Agenten liefen gleichzeitig: alices Export-Agent auf dem langsamen Tool, alices Abrechnungsagent, der das schnelle Tool alle zwei Sekunden aufrief, und bobs Support-Agent, der dasselbe tat. Nach sieben Sekunden habe ich alice beim Identity Provider widerrufen.

Das Gateway-Log zeigt die Reihenfolge. Das Ereignis kam um 10:39:50.971 an, der laufende Export wurde in derselben Millisekunde abgebrochen, und jede spätere Anfrage mit einem Token von alice bekam 401. Der Transmitter protokollierte einen Push, zugestellt in 4 ms.

Jeder abgelehnte Versuch steht zweimal im Log. Der Client des SDK fragt zuerst mit server/discover an und versucht bei einem Fehler den älteren initialize-Handshake. Beide bekamen 401. Der Agent gab nur “Server returned an error response” aus: Das SDK hat meinem Code weder den 401 noch den WWW-Authenticate-Header gezeigt.
Das SET auf der Leitung#
Das Gateway hat das zuletzt akzeptierte Ereignis gespeichert. ssf verify von SSFgo hat es gegen die veröffentlichten Schlüssel des Transmitters, den Issuer und die Audience geprüft, so wie ein Receiver es tun würde. Das Subject ist iss_sub mit alice, und das Ereignis trägt initiating_entity admin und den Grund, den ich eingegeben hatte.

Der Shared-Signals-SET-Decoder von iamops.dev hat dasselbe Ereignis mit dem JSON Web Key Set (JWKS) des Transmitters gelesen und die Signatur geprüft. Er nennt den Ereignistyp, erklärt das Subject iss_sub und weist auf den Claim txn hin, den SSFgo hinzugefügt hat.

Gefälschte und wiederholte Ereignisse#
attacks.py sendet direkt an /ssf/events. Ohne Push-Token oder mit dem falschen antwortete das Gateway mit 401. Ein JSON-Body bekam 400 invalid_request. Ein Ereignis, signiert mit meinem eigenen Schlüssel, aber mit der kid des Transmitters, bekam 400 invalid_key, ebenso alg: none, weil das Gateway nur RS256 annimmt. Ein typ JWT wurde abgelehnt. Die Wiederholung des letzten echten Ereignisses bekam 202, wie RFC 8935 es für ein bereits vorhandenes Ereignis vorsieht, und änderte nichts: Das Gateway merkt sich jede angewendete jti.

Zwei weitere Ergebnisse in derselben Aufnahme. Ein Ereignis für carol, die nicht im Stream ist, wurde beim Identity Provider erzeugt, aber nie gepusht. Und alice hat sich nach dem Widerruf erneut angemeldet und ein funktionierendes Token bekommen. Ein Sitzungswiderruf beendet Sitzungen, er sperrt nicht das Konto. Soll das Konto gesperrt bleiben, muss der Identity Provider die Anmeldung verweigern, und dafür gibt es ein anderes Ereignis.
Eine falsche Audience oder einen falschen Issuer bei korrekt signiertem Ereignis habe ich nicht getestet. Dafür bräuchte es einen zweiten Stream oder einen zweiten Transmitter mit eigenen Schlüsseln, und beides habe ich nicht ausgeführt.
Wie schnell, und die Lücke in derselben Sekunde#
measure.py hat den Admin-Endpunkt zehnmal aufgerufen und das Gateway abgefragt, bis es jedes Ereignis angewendet hatte: 8, 8, 8, 8, 9, 7, 8, 7, 7 und 7 ms, im Median 8 ms. Das ist ein Rechner über Loopback, gemessen wird also die Software, nicht ein Netzwerk.

Der Nebeneffekt kam aus meiner eigenen Regel. Das Gateway lehnt jedes Token eines widerrufenen Benutzers ab, dessen iat gleich oder vor dem Ereigniszeitpunkt liegt, und beide Werte sind ganze Sekunden. Der letzte Messlauf widerrief alice um 10:40:58.059. Der nächste Schritt meldete sie um 10:40:58 an, und dieses Token wurde abgelehnt. In die andere Richtung zu runden würde ein Token durchlassen, das kurz vor dem Widerruf ausgestellt wurde. Ich habe die strenge Seite behalten und würde das in Produktion auch tun, mit einem Hinweis für den Helpdesk.
Eine Agentensitzung widerrufen, nicht den Benutzer#
Der Widerruf von alice hat alle ihre Agenten abgeschnitten. Oft will man weniger: die Sitzung des Abrechnungsagenten beenden und ihre anderen Agenten weiterlaufen lassen. SSF hat dafür ein komplexes Subject mit den Mitgliedern user und session.
Das CAEP-Interoperabilitätsprofil, so wie SSFgo es anwendet, erlaubt nur Subjects vom Typ email und iss_sub, also lehnte der Transmitter das Ereignis mit HTTP 422 ab. Ich habe den Identity Provider mit den einfachen Regeln von SSF 1.0 und CAEP 1.0 neu gestartet, den Stream neu angelegt und alice als iss_sub abonniert. Das Sitzungsereignis wurde erzeugt und nie gepusht. Die Regeln zum Subject-Abgleich in Abschnitt 8.1.3 von SSF 1.0 definieren den Abgleich zwischen zwei einfachen und zwischen zwei komplexen Subjects und sagen nichts über eine Mischung. SSFgo liest das so: Ein einfaches Subject passt nie zu einem komplexen.

Die Lösung war, ein komplexes Subject nur mit user zu abonnieren. Mitglieder, die das Abonnement weglässt, gelten als Platzhalter, es passt also zu jeder Sitzung von alice. Damit kam das Ereignis an, das Gateway widerrief nur die sid des Abrechnungsagenten, und alices Support-Agent bekam weiter 200.


Der Decoder zeigt das komplexe Subject in zwei Teilen: alice als iss_sub und die Sitzung als opaque-ID.

Der 401, den der Agent sieht#
Mit curl ist die Antwort eindeutig. Vor dem Ereignis lieferte der Aufruf 200. Danach bekam dasselbe Token 401 mit WWW-Authenticate: Bearer error="invalid_token", error_description="session revoked". Ein Agent, der diesen Header liest, weiß, dass er sich neu anmelden muss, statt es erneut zu versuchen.

Die rohe Anfrage brauchte außerdem die Header Mcp-Method und Mcp-Name und zwei Schlüssel in _meta, bevor der Server mit 2026-07-28 sie annahm. Ohne sie antwortete der Server mit 400 und einem JSON-RPC-Fehler. Ein Gateway kann den Tool-Namen aus dem Header lesen, der Server gleicht ihn aber trotzdem mit dem Body ab.
Stolperfallen#
- Die Stream-Konfiguration gibt das Push-Geheimnis zurück. Schützen Sie das Token der Stream-API so gut wie das Push-Token.
- SSFgo verweigert standardmäßig Pushes an Loopback. In Produktion gut, im Lab eine Überraschung.
- Das Interop-Profil verlangt, dass Poll-Zustellung angeboten wird. Der Transmitter startete unter dem Profil erst, als ich RFC 8936 neben Push aufgeführt hatte.
- Ganze Sekunden auf beiden Seiten. Ein Widerruf und eine neue Anmeldung in derselben Sekunde kollidieren. Entscheiden Sie sich bewusst für eine Seite.
- Widerrufe liegen in diesem Lab im Speicher. Ein Neustart des Gateways vergisst sie, und ein vor dem Widerruf ausgestelltes Token würde bis zum Ablauf wieder funktionieren. Bewahren Sie sie mindestens für die Lebensdauer des Access Tokens auf, in einem Speicher, der Neustarts übersteht.
- Ein session-revoked-Ereignis sperrt das Konto nicht. alice hat sich kurz danach wieder angemeldet.
Was ich daraus machen würde#
- Den Receiver dort platzieren, wo jede Agentenanfrage ankommt: im MCP-Gateway, nicht in jedem Tool.
sidin die Access Tokens Ihrer Agenten aufnehmen und sicherstellen, dass Tokens und Ereignisse denselben Issuer haben, oder eine Zuordnung pflegen.- Die benötigten Subjects in der Form abonnieren, in der der Transmitter sie senden wird. Für Ereignisse pro Sitzung ein komplexes Subject mit
userabonnieren. - Die akzeptierten Algorithmen festlegen, jetzt, da das Profil es nicht mehr tut. Nur RS256, kein
none, Schlüssel aus demjwks_urides Transmitters. - Laufende Tool-Aufrufe abbrechen, nicht nur neue. Mit MCP 2026-07-28 gibt es keine Sitzung zum Schließen, das Gateway muss also mitverfolgen, was es gerade streamt.
Was nicht ausgeführt wurde#
Der Transmitter ist SSFgo in meinem eigenen Lab-Identity-Provider, kein kommerzieller Identity Provider. Die Stream-API nutzte ein statisches Bearer-Token, nicht OAuth, wie es das Interop-Profil verlangt. Poll-Zustellung, Stream-Updates, das Pausieren oder Löschen eines Streams und das Ereignis für geänderte Anmeldedaten habe ich nicht ausgeführt. Ein korrekt signiertes Ereignis mit falscher Audience oder falschem Issuer habe ich nicht getestet. Der Widerrufsspeicher liegt im Speicher, einen Neustart des Gateways habe ich nicht getestet. Die OpenID-Konformitätssuite lief nicht gegen das Gateway. Die MCP-Clients waren Skripte auf dem SDK, kein echtes Agentenprodukt, und keiner reagierte auf den 401 mit einer neuen Anmeldung. Für dieses Lab gibt es keine Aufzeichnung.
Die Terminalbilder wurden aus der gespeicherten Ausgabe des Laufs vom 22. November 2026 erzeugt, Zeit Europe/Zurich. Die Lab-Tokens, Schlüssel und Zertifikate waren zufällig, lagen weniger als eine Stunde auf einem Rechner und wurden am Ende gelöscht.
Dieses Lab nachbauen#
Alles, was Sie brauchen, um dieses Lab in etwa 35 Minuten auf einem Linux-Rechner ohne Konten auszuführen: eine Wegwerf-CA, ein IdP auf Basis von SSFgo, ein MCP-Server und ein Gateway, das CAEP-Ereignisse empfängt. Öffnen Sie jeden Schritt, kopieren Sie die Blöcke und vergleichen Sie Ihre Ausgabe mit der erwarteten.
Jeder Wert in spitzen Klammern ist ein Platzhalter für Ihre Testumgebung. Nichts auf dieser Seite ist eine echte Kennung oder ein echtes Geheimnis.
Variablen einmal setzen
# 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 0 von 12 Schritten erledigt
Schritt 1CA erstellen und den IdP bauen
Ziel. Speichern Sie make-certs.sh und den Ordner idp, erstellen Sie eine Wegwerf-CA mit einem Zertifikat für localhost, bauen Sie den Lab-IdP auf SSFgo v0.4.2 und installieren Sie das Kommandozeilenwerkzeug ssf.
Voraussetzungen
- Linux mit Go 1.26.10 oder neuer (getestet mit 1.27.3), Python 3.13, openssl, curl und jq
- Ein leerer Ordner für das Lab; führen Sie jeden Schritt darin aus
#!/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 module ssfmcp/idp
go 1.26.10
require github.com/idfoundry/ssfgo v0.4.2 // 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 } 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 Erwartete Ausgabe
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 Schritt 2Die Python-Seite installieren
Ziel. Legen Sie ein venv mit festen Versionen an und speichern Sie den MCP-Server, das Gateway, das zugleich SSF-Receiver ist, und den Testagenten.
Voraussetzungen
- Der vorige Schritt endete wie gezeigt, im selben Terminal
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) " """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) """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") """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)) Erwartete Ausgabe
cryptography 50.0.2
httpx 0.28.1
mcp 2.3.0
PyJWT 2.15.1
starlette 1.10.0
uvicorn 0.54.0 Schritt 3Lab-Tokens erzeugen und alles starten
Ziel. Schreiben Sie drei zufällige Lab-Tokens in .env und starten Sie dann den IdP mit dem CAEP-Interoperabilitätsprofil, den MCP-Server und das Gateway.
Voraussetzungen
- Der vorige Schritt endete wie gezeigt, im selben Terminal
- Ports 9000, 9443 und 9444 auf localhost frei
#!/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 #!/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 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 Erwartete Ausgabe
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 Schritt 4Stream anlegen und alice und bob hinzufügen
Ziel. Prüfen Sie die SSF-Metadaten mit dem Werkzeug ssf, legen Sie einen Push-Stream für session-revoked an, fügen Sie zwei Benutzer als Subjects hinzu und fordern Sie ein Verifikationsereignis an. Die Stream-Antwort gibt das Push-Token vollständig zurück.
Voraussetzungen
- Der vorige Schritt endete wie gezeigt, im selben Terminal
./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 Erwartete Ausgabe
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 Schritt 5Ein Token holen und lesen, was das Gateway prüft
Ziel. Fordern Sie beim IdP ein Access Token für alice an und dekodieren Sie es. Das Gateway prüft Issuer, Audience, Ablauf und Signatur und braucht den Claim sid, um eine einzelne Sitzung zu widerrufen.
Voraussetzungen
- Der vorige Schritt endete wie gezeigt, im selben Terminal
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 . Erwartete Ausgabe
{"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"
} Schritt 6alice widerrufen, während drei Agenten arbeiten
Ziel. Starten Sie einen langen Export und eine wiederholte Abfrage für alice sowie eine Abfrage für bob und senden Sie dann session-revoked für alice. Der Export bricht mitten im Stream ab, alices anderer Agent erhält 401, bob arbeitet weiter.
Voraussetzungen
- Der vorige Schritt endete wie gezeigt, im selben Terminal
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}" Erwartete Ausgabe
{"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":[]} Schritt 7Das empfangene SET prüfen
Ziel. Prüfen Sie das zuletzt empfangene Security Event Token mit ssf verify: Signatur, typ secevent+jwt, Issuer und Audience. Melden Sie alice danach erneut an, um zu sehen, dass das Ereignis das Konto nicht gesperrt hat.
Voraussetzungen
- Der vorige Schritt endete wie gezeigt, im selben Terminal
./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 Erwartete Ausgabe
{
"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 } Schritt 8Gefälschte und wiederholte Ereignisse senden
Ziel. Senden Sie sieben fehlerhafte Ereignisse an den Receiver: fehlendes oder falsches Bearer-Token, falscher Content-Type, ein fremder Schlüssel, alg none, falscher typ und eine Wiederholung. Keines darf die Widerrufsliste ändern. Widerrufen Sie danach carol, die nicht im Stream ist.
Voraussetzungen
- Der vorige Schritt endete wie gezeigt, im selben Terminal
"""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"])) 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 Erwartete Ausgabe
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="" Schritt 9Die Zeit bis zur Sperre messen
Ziel. Führen Sie zehn Widerrufe aus und messen Sie jeweils die Zeit vom Admin-Aufruf bis zur Anwendung im Gateway. Sehen Sie sich dann den Nebeneffekt an: Ein Token aus derselben Sekunde wie ein Widerruf wird abgelehnt.
Voraussetzungen
- Der vorige Schritt endete wie gezeigt, im selben Terminal
"""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") 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 Erwartete Ausgabe
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 Schritt 10Eine Agentensitzung widerrufen, nicht den Benutzer
Ziel. Das Interop-Profil lehnt ein komplexes Subject mit Sitzung ab. Starten Sie den IdP daher mit reinem SSF neu, abonnieren Sie ein komplexes Subject für alice und widerrufen Sie nur die Sitzung des Abrechnungsagenten.
Voraussetzungen
- Der vorige Schritt endete wie gezeigt, im selben Terminal
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" 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 Erwartete Ausgabe
{"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 Schritt 11Den 401 auf der Leitung sehen
Ziel. Rufen Sie den MCP-Endpunkt mit curl auf, widerrufen Sie diese eine Sitzung und rufen Sie erneut auf. Das Agenten-SDK meldet nur einen Serverfehler; die rohe Antwort enthält den Grund in WWW-Authenticate.
Voraussetzungen
- Der vorige Schritt endete wie gezeigt, im selben Terminal
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 Erwartete Ausgabe
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"} Schritt 12Aufräumen
Ziel. Beenden Sie die drei Prozesse und löschen Sie Zertifikate, Lab-Tokens, Logs und Binärdateien. Nur die Quelldateien bleiben.
Voraussetzungen
- Sie sind mit dem Lab fertig
./stop.sh
rm -rf certs .env *.log *.json *.jwt billing.sid verify.txt idp-bin ssf
ls
deactivate; rm -rf .venv Erwartete Ausgabe
0
agent.py
attacks.py
gateway.py
idp
make-certs.sh
mcp_server.py
measure.py
start.sh
stop.sh Quellen#
- openid/sharedsignals PR #368, Drop event signatures (merged 17 Nov 2026)
- CAEP Interoperability Profile 1.0, working copy dated 17 November 2026
- openid/sharedsignals PR #362, agent and workload as subject (open)
- OpenID Shared Signals Framework Specification 1.0 (Final)
- OpenID Continuous Access Evaluation Profile 1.0 (Final)
- RFC 8935: Push-Based Security Event Token Delivery Using HTTP
- RFC 8417: Security Event Token (SET)
- RFC 9493: Subject Identifiers for Security Event Tokens
- SSFgo, an SSF 1.0 transmitter and receiver for Go (v0.4.2)
- Model Context Protocol specification 2026-07-28: Transports
Dieser Beitrag als Markdown · RSS · JSON feed
Neue Beiträge per E-Mail
Eine E-Mail pro Woche mit neuen Beiträgen und Labs. Jederzeit abbestellbar.
Ihre Adresse wird bei Kit gespeichert, dem Dienst, der die E-Mails versendet. Details