# Shared Signals, CAEP e RISC: fermare un agente AI prima che il suo token scada

> Come Shared Signals Framework, CAEP e RISC di OpenID trasportano tra sistemi i cambi di sessione e di account, e cosa significano per gli agenti AI con token.

- URL: https://iamops.dev/it/shared-signals-caep-risc-agent-access/
- Language: it
- Author: Argo
- Published: 2026-11-22
- Category: Knowledge
- Depth: Approfondimento
- Time: 8 minuti
- Topics: Shared Signals, CAEP, RISC, Revoca, Agenti AI

## In breve

- Un access token resta valido fino alla scadenza, anche dopo che l'account dietro è stato disattivato. [Shared Signals](https://iamops.dev/it/shared-signals-caep-risc-agent-access/#tre-specifiche-un-solo-canale) permette all'identity provider di avvisare subito l'API.
- SSF 1.0, CAEP 1.0 e RISC 1.0 sono diventate [Final Specification](https://iamops.dev/it/shared-signals-caep-risc-agent-access/#tre-specifiche-un-solo-canale) OpenID il 2 settembre 2025. CAEP copre sessioni e dispositivi, RISC gli account.
- Ogni evento è un [Security Event Token](https://iamops.dev/it/shared-signals-caep-risc-agent-access/#cosa-viaggia-un-security-event-token): un JWT firmato con typ secevent+jwt, sub_id al posto di sub e senza exp.
- Metti il receiver dove arrivano le chiamate dell'agente e parti da [session-revoked e credential-change](https://iamops.dev/it/shared-signals-caep-risc-agent-access/#gli-eventi-da-collegare-per-primi). Token brevi e [legati a una chiave](https://iamops.dev/it/dpop-par-rar-explained/#dpop-lega-il-token-a-una-chiave) restano importanti.
- Microsoft CAE è [basato su CAEP](https://iamops.dev/it/shared-signals-caep-risc-agent-access/#chi-lo-implementa) e ammette fino a 15 minuti di ritardo. Okta riceve eventi SSF e la Cross-Account Protection di Google si basa su RISC.

Un agente AI accede tramite un utente, riceve un access token e si mette al lavoro. Un'ora dopo l'account dell'utente viene disattivato perché è stato rubato un portatile. L'identity provider lo sa. L'API che l'agente chiama no, e continua ad accettare il token fino a `exp`. Gli agenti peggiorano questa finestra: lavorano senza supervisione, tengono i token in cache e li usano su molte API.

Shared Signals è la risposta di OpenID a questa finestra. Non accorcia i token. Dà all'identity provider un modo standard per avvisare chi si fida di lui che qualcosa è cambiato, così può chiudere la sessione subito.

## Tre specifiche, un solo canale

Il 2 settembre 2025 i membri della OpenID Foundation hanno approvato tre Final Specification del gruppo di lavoro Shared Signals (85 favorevoli, 1 contrario, 25 astenuti):

| Specifica | Cosa definisce |
| --- | --- |
| Shared Signals Framework (SSF) 1.0 | Il canale: ruoli, stream, consegna, soggetti e formato degli eventi |
| Continuous Access Evaluation Profile (CAEP) 1.0 | Eventi su sessioni, credenziali, dispositivi e rischio |
| Risk Incident Sharing and Coordination (RISC) 1.0 | Eventi sugli account: disattivati, cancellati, compromessi, recuperati |

Una Final Specification non è soggetta a ulteriori revisioni, quindi è una base stabile. I due ruoli sono il **transmitter**, che invia gli eventi (di solito l'identity provider), e il **receiver**, che agisce di conseguenza (un'applicazione, un gateway, un server MCP). L'abstract di CAEP descrive lo scopo come permettere ai receiver di "attenuate access to shared human or robotic users, devices, sessions and applications". Tra gli utenti robotici ci sono gli agenti.

![Quattro riquadri in fila: l'identity provider disattiva l'account, il suo transmitter invia un evento firmato, il receiver chiude la sessione e scarta i token, la chiamata successiva dell'agente viene rifiutata. Sotto: l'accesso finisce quando arriva l'evento, non quando scade il token.](https://iamops.dev/img/shared-signals-caep-risc-agent-access.it.svg)

*Lo scopo del canale. Il receiver agisce sull'evento, quindi l'agente perde l'accesso prima che il suo token sarebbe scaduto.*

## Cosa viaggia: un Security Event Token

Ogni evento è un Security Event Token (SET, RFC 8417), cioè un JWT firmato con un claim `events`. SSF aggiunge regole che impediscono di scambiare un SET per un ID token o un access token:

- L'header porta `typ: secevent+jwt`.
- Il claim JWT `sub` non deve esserci. Il soggetto va in `sub_id`, con i formati di identificatore della RFC 9493.
- Non c'è il claim `exp`.
- L'`iss` deve corrispondere alla configurazione dello stream, e il receiver deve controllarlo.
- Un claim `txn` può legare più eventi alla stessa modifica di origine.

Un evento CAEP session-revoked ridotto, nella forma degli esempi della specifica:

```json
{
  "iss": "https://idp.example.com/",
  "aud": "https://api.example.com/caep",
  "jti": "evt-6f1c",
  "iat": 1795000000,
  "txn": "8675309",
  "sub_id": { "format": "opaque", "id": "user-4821" },
  "events": {
    "https://schemas.openid.net/secevent/caep/event-type/session-revoked": {
      "initiating_entity": "policy",
      "reason_admin": { "en": "Device reported stolen" },
      "event_timestamp": 1794999990
    }
  }
}
```

## Transmitter, receiver e stream

Un receiver scopre cosa supporta un transmitter dalla sua configurazione in `/.well-known/ssf-configuration`. Quel documento elenca le chiavi di firma (`jwks_uri`), i metodi di consegna supportati e gli endpoint di gestione. Il receiver crea poi uno **stream**: quali eventi vuole, come arrivano e per quali soggetti.

- **Consegna.** Push via HTTP (RFC 8935), in cui il transmitter invia i SET al receiver, oppure poll (RFC 8936), in cui il receiver li va a prendere. Il push va bene per un'API sempre attiva; il poll per un receiver dietro un firewall.
- **Soggetti.** Gli endpoint Add Subject e Remove Subject permettono al receiver di dire quali utenti o sessioni gli interessano, così non riceve eventi per l'intero tenant.
- **Verifica.** Il receiver può chiedere un evento di verifica per provare che lo stream funziona da un capo all'altro. Fallo nel monitoraggio, non solo alla configurazione.
- **Stato dello stream.** Uno stream può essere attivo, in pausa o disattivato. Uno stream in pausa che nessuno nota è un guasto silenzioso.

SSF lascia anche la reazione a ogni deployment. La specifica parla di SET prescrittivi: un evento può essere solo informativo o richiedere un'azione obbligatoria, a seconda di cosa concordano le due parti.

## Gli eventi da collegare per primi

CAEP 1.0 definisce otto tipi di evento. Questi sono quelli che collegherei per primi per gli agenti:

| Evento | Campi obbligatori | Cosa dovrebbe fare un receiver |
| --- | --- | --- |
| `session-revoked` | nessuno | Chiudere la sessione e scartare ogni token derivato |
| `credential-change` | `credential_type`, `change_type` | Rivalutare, per esempio dopo la cancellazione di una passkey o il reset di una password |
| `token-claims-change` | `claims` | Smettere di fidarsi di claim in cache come ruoli o gruppi |
| `assurance-level-change` | `namespace`, `current_level` | Ridurre ciò che la sessione può fare |
| `device-compliance-change` | `previous_status`, `current_status` | Bloccare le chiamate da un dispositivo non più conforme |
| `risk-level-change` | `principal`, `current_level` | Alimentare il policy decision point |

Gli altri due, `session-established` e `session-presented`, descrivono l'attività normale. RISC aggiunge eventi sugli account come `account-disabled`, `account-purged`, `credential-compromise` e `identifier-changed`. Il `sessions-revoked` di RISC è deprecato: le nuove implementazioni devono usare il `session-revoked` di CAEP.

## Cosa significa per gli agenti AI

Il receiver deve stare dove arrivano le chiamate dell'agente. Per un server MCP remoto è il server MCP, o il gateway davanti. Quando arriva `session-revoked` deve chiudere la sessione dell'utente e scartare ogni token ottenuto con il [token exchange](https://iamops.dev/it/oauth-token-exchange-delegation-impersonation/#dove-compare-oggi-il-token-exchange) per le API a valle, altrimenti l'agente continua a lavorare con un token emesso prima della revoca.

Un motore di policy può usare gli stessi segnali. Se le chiamate agli strumenti dell'agente passano da un decision point [AuthZEN](https://iamops.dev/it/authzen-opa-cedar-explained/#cosa-standardizza-authzen), un `risk-level-change` può entrare nel contesto che valuta.

I segnali non sostituiscono le basi. Una durata breve limita la finestra quando un segnale si perde o arriva tardi, e un token legato alla chiave dell'agente con [DPoP](https://iamops.dev/it/dpop-par-rar-explained/#dpop-lega-il-token-a-una-chiave) non si può riusare da un'altra parte. L'agente dovrebbe anche avere un soggetto proprio, così un receiver può revocare l'agente senza scollegare l'utente da tutto. Il mio [laboratorio sulla managed identity](https://iamops.dev/it/secretless-agent-managed-identity-container-app/#cosa-mostra-il-laboratorio) mostra questa parte.

## Chi lo implementa

- **Microsoft Entra.** Microsoft descrive la continuous access evaluation come "an industry standard based on" CAEP. Copre eventi come un account cancellato o disattivato, un cambio di password, un amministratore che revoca i refresh token e un rischio utente alto. Microsoft dice che l'obiettivo è il tempo quasi reale, "but latency of up to 15 minutes might be observed". Con client compatibili con CAE la durata del token può arrivare a 28 ore, perché la revoca dipende dagli eventi e non dalla scadenza.
- **Okta.** Con Identity Threat Protection attivo, Okta riceve eventi SSF da transmitter di terze parti tramite la sua SSF Receiver API.
- **Google.** La Cross-Account Protection "is based on the RISC standard" e invia eventi sugli account alle app che usano Sign in with Google.

È quello che dice la documentazione di ciascun vendor. Non ho provato l'interoperabilità tra loro.

## Cosa farei

1. Chiedi al tuo identity provider se può trasmettere `session-revoked` di CAEP e `account-disabled` di RISC, e verso quali receiver.
2. Metti un receiver davanti a ogni API o server MCP chiamato dagli agenti, e collega `sub_id` alle sessioni e ai token scambiati che conservi.
3. Tratta uno stream non verificato o in pausa come un disservizio. Metti un allarme.
4. Tieni i token degli agenti brevi e legati a una chiave, così un segnale in ritardo costa minuti, non ore.

## Cosa non ho verificato

Ho letto le tre Final Specification, la RFC 8417 e le pagine dei vendor elencate sotto. Non ho eseguito un transmitter o un receiver per questo articolo, non ho misurato il ritardo di Microsoft e non ho provato Okta o Google. Una spiegazione semplice di Shared Signals è nel backlog, e un laboratorio con un transmitter open source è candidato per il piano dei laboratori.

## Sources

- [OpenID Foundation, 2 Sep 2025: Three Shared Signals Final Specifications Approved](https://openid.net/three-shared-signals-final-specifications-approved/)
- [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)
- [OpenID RISC Profile Specification 1.0 (Final)](https://openid.net/specs/openid-risc-1_0-final.html)
- [RFC 8417: Security Event Token (SET)](https://www.rfc-editor.org/rfc/rfc8417)
- [Microsoft Learn: Continuous access evaluation](https://learn.microsoft.com/en-us/entra/identity/conditional-access/concept-continuous-access-evaluation)
- [Okta Developer: Configure an SSF receiver](https://developer.okta.com/docs/guides/configure-ssf-receiver/main/)
- [Google for Developers: Cross-Account Protection (RISC)](https://developers.google.com/identity/protocols/risc)

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