Il problema della tartaruga di fondo
C'è un vecchio aneddoto: un tale sostiene che la Terra poggia sul dorso di una tartaruga. «E la tartaruga su cosa poggia?» «Su un'altra tartaruga.» «E quella?» «Sono tartarughe fino in fondo.» La sicurezza dei servizi ha esattamente questa forma, e nella community SPIFFE si parla per questo del problema della tartaruga di fondo.
Il servizio checkout deve parlare con il database. Gli diamo una password, ma va protetta: la mettiamo in un secret manager. Per leggere dal secret manager, però, checkout deve autenticarsi, quindi gli serve un'altra credenziale. E quella dove la mettiamo? In un file cifrato, la cui chiave sta… Ogni soluzione sposta il problema di un livello. Alla base c'è sempre un secret zero: una credenziale iniziale distribuita fuori banda, spesso a mano, spesso a vita lunga, spesso copiata in troppi posti.
Per anni la risposta è stata la rete: «se la chiamata arriva dalla subnet 10.0.3.0/24, è il backend». Ma in un cluster Kubernetes gli IP cambiano a ogni deploy, nel cloud i servizi parlano attraverso NAT e load balancer, tra cloud e on-prem le subnet non significano niente. L'indirizzo di rete dice dove si trova un processo, non chi è. È la premessa del modello zero trust: nessuna fiducia implicita per posizione, ogni richiesta autenticata e autorizzata sull'identità.
L'idea chiave
Cos'è una workload identity
Un workload è un software in esecuzione con uno scopo preciso: un microservizio, un batch, una funzione serverless, un job di CI, un agente AI. Può avere molte istanze (repliche) che condividono la stessa identità logica. Una workload identity è tre cose insieme: un nome univoco e stabile, un documento verificabile che lega quel nome a una chiave, e un emittente di cui chi verifica si fida.
| Identità umana | Workload identity | |
|---|---|---|
| Chi si autentica | Una persona | Un processo, container, funzione, job, agente |
| Come prova chi è | Qualcosa che sa, ha, è (password, passkey, MFA) | Attestazione: proprietà verificate dalla piattaforma |
| Ciclo di vita | Anni | Secondi, minuti, ore |
| Numerosità | Migliaia | Milioni, e in crescita con gli agenti |
| Credenziale tipica | Sessione + token OIDC | X.509-SVID, JWT-SVID, WIT |
| Standard | OAuth 2, OIDC, SAML, FIDO2 | SPIFFE, WIMSE, OAuth token exchange, Txn-Token |
Nell'Identity and Access Management dell'era dell'AI questa distinzione diventa centrale. Le identità non umane superano già di gran lunga quelle umane, e un agente AI è una categoria nuova di workload: autonomo, non deterministico, che decide quali strumenti chiamare e agisce per conto di una persona. Ha bisogno di un'identità forte quanto quella di un microservizio, più un modo per portarsi dietro, in modo verificabile, il contesto di chi gli ha affidato il compito. Ci torniamo dalla sezione 11 alla 15.
SPIFFE: lo standard
SPIFFE (Secure Production Identity Framework For Everyone) è un insieme di specifiche, progetto graduated della CNCF. Non è un software: definisce cosa è un'identità di workload e come un workload la ottiene. I concetti sono cinque.
SPIFFE ID
Un URI che nomina il workload: spiffe://example.org/ns/payments/sa/checkout. La parte host è il trust domain (minuscole, cifre, ., -, _), il path è libero e gerarchico. Niente porta, query, fragment o userinfo. Il path dovrebbe descrivere cosa è il workload, non dove gira: meglio /ns/payments/sa/checkout che /node/ip-10-0-3-17.
Trust domain
Il confine di fiducia: tutto ciò che è firmato dalle chiavi di un trust domain appartiene a quel dominio. Tipicamente uno per organizzazione o per ambiente (prod.acme.com, staging.acme.com). Domini diversi possono fidarsi a vicenda con la federazione.
SVID
Lo SPIFFE Verifiable Identity Document: il documento che prova l'identità. Due formati, X.509-SVID e JWT-SVID. Li vediamo nel dettaglio nella prossima sezione.
Trust bundle
L'insieme delle chiavi pubbliche (CA X.509 e chiavi JWT) di un trust domain, che servono a verificare le SVID. Il formato SPIFFE bundle è un JWK Set con qualche campo in più. Un bundle è pubblico: distribuirlo non è un problema, sostituirlo con uno falso sì.
Workload API
L'interfaccia locale da cui il workload ottiene SVID e bundle: gRPC su Unix domain socket (o named pipe su Windows), indicato dalla variabile SPIFFE_ENDPOINT_SOCKET. Il punto geniale è che la chiamata è non autenticata: il workload non presenta nulla, è chi implementa l'API a capire chi è il chiamante osservandolo dall'esterno. Così il secret zero sparisce.
service SpiffeWorkloadAPI {
rpc FetchX509SVID(X509SVIDRequest) returns (stream X509SVIDResponse);
rpc FetchX509Bundles(X509BundlesRequest) returns (stream X509BundlesResponse);
rpc FetchJWTSVID(JWTSVIDRequest) returns (JWTSVIDResponse);
rpc FetchJWTBundles(JWTBundlesRequest) returns (stream JWTBundlesResponse);
rpc ValidateJWTSVID(ValidateJWTSVIDRequest) returns (ValidateJWTSVIDResponse);
}Nota gli stream: le risposte X.509 e i bundle non sono una tantum. Il workload resta in ascolto e riceve SVID e bundle nuovi quando ruotano. È questo che rende praticabili certificati di un'ora.
Gli SVID, campo per campo
Uno SVID è il passaporto del workload: lega lo SPIFFE ID a una chiave crittografica, ed è firmato dall'autorità del trust domain. La specifica non inventa formati nuovi: riusa X.509 e JWT, che ogni linguaggio e ogni stack TLS sanno già trattare, ma li vincola con regole precise. Sono proprio quelle regole a fare la differenza tra un certificato qualunque e un'identità.
campo del certificato
Subject Alt Name
spec: esattamente 1 URI SANQui vive l'identità. Una X.509-SVID contiene esattamente un URI SAN, ed è lo SPIFFE ID. Possono esserci SAN DNS in più (per compatibilità), ma non sono l'identità.
X.509-SVID
È un certificato X.509 in cui lo SPIFFE ID sta nell'estensione Subject Alternative Name, come URI, ed è l'unico URI SAN. Il Subject e il Common Name non hanno valore di identità. Un leaf SVID ha CA:FALSE e digitalSignature; i certificati di firma (CA o intermedie) hanno invece CA:TRUE e keyCertSign, e possono anche loro portare uno SPIFFE ID (senza path) che identifica il trust domain. La chiave privata è parte integrante: chi presenta l'SVID in un handshake TLS dimostra di possederla.
Certificate:
Data:
Version: 3 (0x2)
Issuer: C=IT, O=Acme, CN=SPIRE intermediate
Validity
Not Before: Oct 18 10:00:00 2026 GMT
Not After : Oct 18 11:00:00 2026 GMT
Subject: C=US, O=SPIRE, x500UniqueIdentifier=4b9a…
Subject Public Key Info:
Public Key Algorithm: id-ecPublicKey (P-256)
X509v3 extensions:
X509v3 Key Usage: critical
Digital Signature, Key Encipherment, Key Agreement
X509v3 Extended Key Usage:
TLS Web Server Authentication, TLS Web Client Authentication
X509v3 Basic Constraints: critical
CA:FALSE
X509v3 Subject Alternative Name:
URI:spiffe://example.org/ns/payments/sa/checkoutJWT-SVID
È un JWS compatto firmato con algoritmo asimmetrico, con lo SPIFFE ID in sub, aud e exp obbligatori e kid nell'header per scegliere la chiave del bundle. È un bearer token: chi lo possiede lo può usare. Per questo è il formato più debole dei due, ed esiste per una ragione pratica: attraversa i proxy L7 che terminano TLS e parla con sistemi che conoscono OIDC ma non SPIFFE.
Verificare uno SVID
Verificare non vuol dire solo «firma valida». La procedura corretta è:
- estrarre lo SPIFFE ID (URI SAN o
sub) e da esso il trust domain; - scegliere il bundle di quel trust domain (il proprio o uno federato), non un pool di CA indistinto;
- validare la catena X.509 o la firma JWT con quel bundle, più scadenza e, per i JWT,
aud; - autorizzare: lo SPIFFE ID è quello atteso, o appartiene a un insieme ammesso.
| X.509-SVID | JWT-SVID | |
|---|---|---|
| Dove sta lo SPIFFE ID | URI SAN (uno solo) | claim sub |
| Prova di possesso | Sì: la chiave firma l'handshake TLS | No: bearer token, chi lo ha lo usa |
| Rischio replay | Basso | Alto, mitigato da aud e TTL brevi |
| Attraversa proxy L7 | No, il TLS termina al proxy | Sì, viaggia in un header |
| Uso tipico | mTLS tra servizi, service mesh | API dietro gateway, federazione cloud via OIDC |
| Default TTL in SPIRE | 1 ora | 5 minuti |
Regola pratica
aud stretta e TTL di pochi minuti. Quando serve un token applicativo con prova di possesso, è il territorio di WIMSE.SPIRE: l'implementazione di riferimento
SPIRE (SPIFFE Runtime Environment) è l'implementazione di riferimento delle specifiche, anch'essa graduated CNCF. Due componenti: un server, che è l'autorità del trust domain, e un agente su ogni nodo, che espone la Workload API ai processi locali. Quasi tutto è un plugin.
Sul server: il KeyManager custodisce le chiavi di firma (su disco, in memoria, o in AWS KMS / GCP KMS / Azure Key Vault); l'UpstreamAuthority opzionale fa firmare la CA di SPIRE da una PKI esistente (Vault, AWS Private CA, cert-manager, un altro SPIRE); i node attestor verificano i nodi; il datastore SQL conserva entry e nodi attestati. Sull'agente: node attestor (lato prova), workload attestor (k8s, unix, docker, systemd, windows) e la cache delle SVID.
Registration entry
Il cuore del modello è la registration entry: «il workload che sta sotto questo parent e presenta questi selector riceve questo SPIFFE ID». Il parent è l'identità di un agente o di un gruppo di nodi (node alias), così una entry vale solo sui nodi giusti.
# alias: tutti gli agenti del cluster prod spire-server entry create -node \ -spiffeID spiffe://example.org/k8s-cluster/prod \ -selector k8s_psat:cluster:prod # workload: checkout, ovunque giri nel cluster prod spire-server entry create \ -parentID spiffe://example.org/k8s-cluster/prod \ -spiffeID spiffe://example.org/ns/payments/sa/checkout \ -selector k8s:ns:payments \ -selector k8s:sa:checkout \ -x509SVIDTTL 3600 -jwtSVIDTTL 300
In Kubernetes raramente si creano entry a mano: lo SPIRE Controller Manager le genera dai pod tramite una risorsa ClusterSPIFFEID con un template.
apiVersion: spire.spiffe.io/v1alpha1
kind: ClusterSPIFFEID
metadata:
name: by-service-account
spec:
spiffeIDTemplate: "spiffe://{{ .TrustDomain }}/ns/{{ .PodMeta.Namespace }}/sa/{{ .PodSpec.ServiceAccountName }}"
podSelector:
matchLabels:
spiffe.io/spire-managed-identity: "true"Node attestation: la prima tartaruga
Prima che un agente possa servire identità, il server deve fidarsi dell'agente. La node attestation risponde alla domanda «questa macchina è davvero quella che dice di essere?» usando una prova che solo la piattaforma può produrre. Ecco il flusso su Kubernetes con il plugin k8s_psat.
1. La prova che la piattaforma dà all'agente
# /var/run/secrets/tokens/spire-agent (decodificato)
{
"iss": "https://kubernetes.default.svc",
"aud": ["spire-server"],
"sub": "system:serviceaccount:spire:spire-agent",
"exp": 1760800000,
"kubernetes.io": {
"namespace": "spire",
"pod": { "name": "spire-agent-7xk2q", "uid": "…" },
"node": { "name": "ip-10-0-3-17", "uid": "…" }
}
}Lo schema è identico per ogni piattaforma, cambia solo la prova. Su EC2 è l'Instance Identity Document firmato da AWS (il server verifica la firma e, opzionalmente, interroga le API AWS per ricavare tag, security group, ruolo IAM). Su hardware fisico è un certificato DevID nel TPM, con una sfida che dimostra il possesso della chiave non esportabile.
| Plugin | Prova | Dove |
|---|---|---|
| aws_iid | Instance Identity Document firmato da AWS | Cloud AWS (EC2) |
| gcp_iit | Instance Identity Token firmato da Google | GCE |
| azure_msi | Token della managed identity della VM | Azure |
| k8s_psat | Projected Service Account Token validato con TokenReview | Qualunque Kubernetes |
| tpm_devid | Certificato DevID del TPM + prova di possesso della chiave | Bare metal, edge |
| x509pop | Certificato X.509 già presente sul nodo + prova di possesso | Data center con PKI esistente |
| join_token | Token monouso generato dal server | Laboratori, casi limite |
Alcuni plugin sono trust on first use: la prova si può usare una volta sola (il server ricorda l'Instance ID già attestato), così un documento rubato non permette di clonare il nodo. join_token è l'eccezione che conferma la regola: è un secret zero a tutti gli effetti, utile quando la piattaforma non offre niente di meglio.
Workload attestation: dal processo all'identità
Ora l'agente è fidato. Quando un processo si collega al socket, l'agente deve capire chi è senza chiedergli niente. La workload attestation combina ciò che dice il kernel con ciò che dice l'orchestratore.
1. Il workload chiede «chi sono?»
workload.spiffe.io: true, che impedisce a un SSRF di arrivare al socket tramite un proxy HTTP.SPIFFE_ENDPOINT_SOCKET=unix:///run/spire/sockets/agent.sock :method POST :path /SpiffeWorkloadAPI/FetchX509SVID workload.spiffe.io: true
Prova tu: scegli le proprietà di un pod e guarda quali registration entry si applicano.
namespace
service account
immagine
k8s:ns:ai k8s:sa:support-bot k8s:container-image:ghcr.io/acme/support-bot@sha256:4f1c k8s:node-name:ip-10-0-3-17 unix:uid:1000
k8s:ns:payments ∧ k8s:sa:checkout
servizio checkout
k8s:ns:payments ∧ k8s:sa:payments
servizio payments
k8s:ns:ai ∧ k8s:sa:support-bot ∧ k8s:container-image:ghcr.io/acme/support-bot@sha256:4f1c
agente AI, solo con l'immagine firmata
k8s:ns:ai
entry larga: qualunque pod in ns ai
Il workload riceve 2 SVID. Nota l'entry con un solo selector: chiunque riesca a creare un pod in quel namespace la ottiene.
Due dettagli che contano in produzione. Primo: l'attestazione avviene sul PID, e i PID si riciclano; un'implementazione seria deve verificare che il processo osservato sia ancora lo stesso che ha aperto la connessione. Secondo: se il kubelet non risponde, l'agente non inventa nulla, non restituisce SVID. Una workload identity fallisce sempre chiusa.
Usare le X.509-SVID: mTLS tra servizi
L'uso principe delle X.509-SVID è l'mutual TLS: entrambe le parti presentano un certificato, entrambe verificano l'altra, e l'autorizzazione si basa sullo SPIFFE ID invece che sull'IP.
1. Identità del client
In Go, con go-spiffe, tutto questo sono poche righe, rotazione inclusa:
import (
"github.com/spiffe/go-spiffe/v2/spiffeid"
"github.com/spiffe/go-spiffe/v2/spiffetls/tlsconfig"
"github.com/spiffe/go-spiffe/v2/workloadapi"
)
// Si collega a SPIFFE_ENDPOINT_SOCKET e resta aggiornato sulle rotazioni.
source, err := workloadapi.NewX509Source(ctx)
if err != nil { return err }
defer source.Close()
serverID := spiffeid.RequireFromString("spiffe://example.org/ns/payments/sa/payments")
tlsCfg := tlsconfig.MTLSClientConfig(source, source, tlsconfig.AuthorizeID(serverID))
client := &http.Client{Transport: &http.Transport{TLSClientConfig: tlsCfg}}
resp, err := client.Post("https://payments:8443/v1/charge", "application/json", body)Se non vuoi toccare il codice, il lavoro lo fa un proxy: Envoy riceve SVID e bundle da SPIRE tramite SDS (Secret Discovery Service, l'agente SPIRE lo implementa direttamente) e applica l'mTLS al posto dell'applicazione. Le service mesh come Istio e Linkerd usano identità nel formato SPIFFE (spiffe://cluster.local/ns/…/sa/…), e Istio può delegare l'emissione a SPIRE quando serve un'attestazione più forte o identità condivise tra mesh e workload fuori dal cluster.
JWT-SVID e federazione con il cloud
Un caso d'uso che da solo giustifica SPIRE: eliminare le access key statiche dei cloud provider. AWS, GCP e Azure accettano token OIDC esterni (web identity federation). Il SPIRE OIDC Discovery Provider espone le chiavi JWT del trust domain con un documento /.well-known/openid-configuration, e il cloud lo tratta come un normale identity provider.
1. Un JWT per un destinatario preciso
La condizione sul sub nella trust policy è essenziale: senza, qualunque workload del trust domain potrebbe assumere il ruolo. È lo stesso errore, ricorrente, delle federazioni OIDC con GitHub Actions configurate senza vincolare repository e branch.
Federazione tra trust domain e topologie
Due organizzazioni, o due ambienti separati della stessa, possono far comunicare i propri workload senza condividere una CA. La SPIFFE Federation definisce come pubblicare e scaricare i bundle: ogni trust domain espone un bundle endpoint, gli altri lo interrogano periodicamente.
1. Si dichiara la relazione
spire-server federation create \ -trustDomain partner.io \ -bundleEndpointURL https://spire.partner.io:8443 \ -bundleEndpointProfile https_spiffe \ -endpointSpiffeID spiffe://partner.io/spire/server \ -trustDomainBundlePath partner.io.bundle.json
Topologie di deployment
Singolo server in HA: più istanze del server con datastore SQL condiviso, il caso tipico per un cluster o una region. Nested: server «figli» per cluster o data center, che usano un server «padre» come UpstreamAuthority; un unico trust domain, ma ogni sito resta operativo anche se perde il collegamento con la radice. Federato: trust domain separati, per confini amministrativi, regolatori o di raggio d'azione di una compromissione. Il criterio pratico: un trust domain è un confine di sicurezza, non organizzativo, quindi conviene crearne di nuovi solo quando c'è un motivo di isolamento reale.
WIMSE: identità di workload tra sistemi diversi
SPIFFE risolve bene l'identità all'interno di un'infrastruttura. I sistemi reali però sono fatti di molti pezzi eterogenei: gateway che terminano TLS, code di messaggi, servizi SaaS, cloud diversi, e catene di chiamate in cui serve sapere non solo chi chiama ora, ma per conto di chi e dentro quale transazione. All'IETF il working group WIMSE (Workload Identity in Multi-System Environments) lavora proprio su questo, riusando SPIFFE e OAuth invece di sostituirli.
Workload Identity Token e Workload Proof Token
Il protocollo service-to-service di WIMSE (ancora in bozza, i dettagli possono cambiare) introduce due JWT. Il WIT è l'identità del workload, emessa dal suo trust domain, con dentro una chiave pubblica nel claim cnf: assomiglia a un JWT-SVID, ma legato a una chiave. Il WPT è una prova di possesso firmata dal workload per una singola richiesta, legata al destinatario e agli altri token presenti. Insieme danno a livello applicativo quello che l'mTLS dà a livello di trasporto, e sopravvivono ai proxy. In alternativa al WPT, la bozza prevede HTTP Message Signatures (RFC 9421).
Transaction Token
I Transaction Token (bozza del working group OAuth) risolvono un altro problema: propagare in modo immutabile il contesto della richiesta originale lungo la catena di servizi. All'ingresso, l'access token esterno viene scambiato (RFC 8693, token exchange) con un Txn-Token a vita brevissima, valido solo dentro il trust domain, che contiene chi è l'utente, lo scope e i parametri della transazione. Ogni servizio a valle lo inoltra e lo verifica, nessuno lo può allargare.
Perché non bastano token exchange e DPoP?
Il token exchange (RFC 8693) risponde a cosa può fare questo software per conto dell'utente: è autorizzazione e passa sempre dall'authorization server. DPoP (RFC 9449, sezione 13) risponde a chi presenta il token è lo stesso che l'ha ricevuto, legandolo a una chiave. Ma quella chiave il client se la genera da solo: DPoP prova il possesso, non dice chi è il client. E per ottenere il token, il client si deve autenticare all'AS: con un client_secret, cioè di nuovo il secret zero, oppure con un'identità di workload. OAuth dà per scontato che il client abbia un'identità; SPIFFE e WIMSE sono il modo di dargliela.
WIMSE aggiunge poi alcune cose che OAuth da solo non copre:
- autenticazione tra workload senza AS in mezzo: per le chiamate interne, tra agenti o asincrone, non serve un token exchange a ogni salto, con la latenza e il punto di guasto unico che comporta;
- possesso legato a un'identità attestata: la chiave nel
cnfdel WIT appartiene a un workload verificato, non a chiunque abbia chiesto un token; - una sola prova per più token: il WPT firma insieme WIT, access token e Txn-Token (
wth,ath,tth), così nessun token si può staccare da una richiesta e riusare in un'altra; - attraversa i proxy: dove l'mTLS si ferma al primo componente che termina TLS;
- interoperabilità tra sistemi: Kubernetes, VM, funzioni cloud e SaaS hanno formati di identità diversi, e WIMSE lavora su identificatori, architettura e scambio di credenziali tra domini.
| Domanda | Risposta |
|---|---|
| Chi è l'utente? | OIDC |
| Chi è questo software, davvero? | SPIFFE (attestazione) / WIMSE (WIT) |
| Cosa può fare per l'utente? | OAuth + token exchange |
| Chi presenta il token è il legittimo detentore? | DPoP, oppure WPT o mTLS |
| In quale transazione sta agendo? | Transaction Token |
In pratica: in un solo dominio, con ogni chiamata che passa dall'AS e servizi interni in mTLS con le SVID, token exchange, DPoP e SPIFFE coprono quasi tutto. WIMSE diventa utile con proxy L7 nel mezzo, molti hop interni da non far passare dall'AS, più trust domain o piattaforme eterogenee. Ed è ancora in bozza: oggi è più una direzione di architettura che uno standard da mettere in produzione.
1. Una richiesta umana entra nel sistema
Agenti AI come workload
Un agente AI è il caso più esigente di workload identity. Gira a lungo, decide da solo quali strumenti chiamare, può essere manipolato dai dati che legge (prompt injection) e agisce quasi sempre per conto di una persona. Il modello che emerge mette insieme i pezzi visti finora: SPIFFE per sapere quale agente è, OAuth e Transaction Token per sapere per chi agisce e entro quali limiti, WIMSE per dimostrarlo a ogni salto.
Ogni agente è un workload con un SPIFFE ID
Non una API key condivisa nel file .env. L'identità si ottiene per attestazione (namespace, service account, digest dell'immagine) e scade da sola.
L'identità dell'agente non basta
Un agente agisce quasi sempre per conto di qualcuno. Serve portare il contesto utente (Txn-Token o token exchange con act) separato dall'identità dell'agente: «chi esegue» e «per chi».
Privilegio per tool, non per agente
Ogni tool (MCP server, API interna) verifica l'identità dell'agente e lo scope della transazione. Un prompt injection può cambiare cosa l'agente prova a fare, non cosa gli è permesso.
Catene di delega esplicite
Agente che chiama agente che chiama tool: ogni salto deve essere visibile (act annidati, req_wl, log con txn). Senza, l'audit si ferma al primo hop.
Vita breve, ovunque
SVID di un'ora, JWT di minuti, Txn-Token per la durata di una richiesta. Un agente che gira per giorni rinnova l'identità, non la conserva.
Per la delega, RFC 8693 prevede il claim act (actor): un token che dice «il soggetto è l'utente, chi agisce è l'agente», e che si può annidare per rappresentare catene di agenti. Il soggetto dell'actor può essere proprio lo SPIFFE ID dell'agente, così identità umana e identità di workload si incontrano in un unico token verificabile.
{
"iss": "https://as.example.org",
"sub": "user:8f3a…",
"aud": "https://refunds.example.org",
"scope": "refund:order",
"act": {
"sub": "spiffe://example.org/ns/ai/sa/support-bot",
"act": { "sub": "spiffe://example.org/ns/ai/sa/orchestrator" }
},
"exp": 1760800300
}Lo stesso vale per i protocolli degli agenti: la specifica di autorizzazione di MCP si basa su OAuth 2.1, e un MCP server interno è a tutti gli effetti un resource server. Dare all'agente un SPIFFE ID e far autenticare il client OAuth con quello (per esempio con un JWT-SVID come client assertion, o in mTLS) elimina l'ultimo client_secret statico della catena.
DPoP e deleghe tra agenti
Un agente riceve e passa token di continuo: al sub-agente, al gateway, ai tool. Se quei token sono bearer, chiunque li veda in un log, in una memoria condivisa o in un prompt li può usare. La soluzione è legare ogni token a una chiave che non lascia mai il runtime di chi lo deve usare: è quello che fa DPoP (Demonstrating Proof of Possession, RFC 9449).
Con DPoP il client genera una coppia di chiavi e a ogni richiesta allega un piccolo JWT firmato, la proof, nell'header DPoP. La proof contiene la chiave pubblica, metodo e URL della richiesta (htm, htu), un timestamp, un jti unico e, verso le API, l'hash del token (ath). L'authorization server mette nel token il thumbprint della chiave, cnf.jkt; il resource server controlla che la proof sia firmata proprio con quella chiave. Il token si presenta come Authorization: DPoP …, non più Bearer.
| Bearer | DPoP (RFC 9449) | mTLS-bound (RFC 8705) | |
|---|---|---|---|
| Chi può usare il token | Chiunque lo possieda | Chi firma proof con la chiave in cnf.jkt | Chi presenta il certificato in cnf.x5t#S256 |
| Livello | Nessuna prova | Applicativo (header HTTP) | Trasporto (TLS) |
| Attraversa proxy che terminano TLS | Sì | Sì | No, salvo inoltro del certificato |
| Adatto a | Ambienti chiusi, token brevissimi | Agenti, SPA, mobile, catene con gateway | Service-to-service dentro la rete |
Delega in tre mosse
Il modello di delega che useremo nel prossimo diagramma combina tre RFC. Con il token exchange (RFC 8693) il backend trasforma il token dell'utente in un grant di delega che nomina l'agente come attore. Con il JWT bearer grant (RFC 7523) l'agente riscatta quel grant e ottiene un access token DPoP legato alla propria chiave. Quando l'agente delega a un sub-agente, quest'ultimo fa un nuovo token exchange: ottiene un token con la propria chiave, uno scope ridotto e la catena act allungata di un anello.
Due claim reggono la catena. may_act dice in anticipo chi potrà agire per conto del soggetto: se il sub-agente non è elencato, lo scambio fallisce. act registra chi sta agendo, annidando gli attori precedenti. Per la RFC 8693 le decisioni di accesso si basano sul soggetto e sull'attore corrente; gli attori annidati sono informazioni per audit e per policy di catena («accetta solo catene che partono da un agente approvato»).
La delega può solo restringere
Caso d'uso: MCP proxy come gateway di sicurezza
Il Model Context Protocol standardizza il modo in cui un agente scopre e chiama strumenti: messaggi JSON-RPC 2.0 (tools/list, tools/call) su trasporto Streamable HTTP. La sua specifica di autorizzazione tratta il server MCP come un resource server OAuth 2.1: il client usa i resource indicator (RFC 8707), il server pubblica i Protected Resource Metadata (RFC 9728) e, soprattutto, non deve accettare token non emessi per sé né inoltrarli a valle (niente token passthrough, per evitare il confused deputy).
In un'azienda con decine di server MCP, ripetere tutti i controlli in ognuno non scala. Il pattern che emerge è un MCP proxy davanti ai server: un gateway che termina le richieste degli agenti, verifica identità e possesso, applica le policy per tool, scambia il token con uno interno e inoltra. I server MCP restano semplici e vedono solo traffico già autorizzato, da un solo chiamante fidato.
Fase 1 · creazione agente e chiave
1. Il backend avvia un agente
Cosa fa il proxy
Autenticazione e possesso
Firma del token, iss, aud = proxy, exp, poi la proof DPoP: thumbprint uguale a cnf.jkt, htm/htu della richiesta, ath, jti mai visto, iat recente.
Autorizzazione per tool
La policy guarda utente, catena act, metodo JSON-RPC, nome del tool e argomenti. «research può chiamare crm_search, non crm_delete». Deny by default.
Niente token passthrough
Il token esterno ha aud = proxy e muore lì. A valle va un token nuovo con aud = MCP server, ottenuto per token exchange e legato al certificato del proxy.
Catalogo dei tool e dei server
Il proxy espone solo MCP server approvati e versioni note delle descrizioni dei tool: un server che cambia di nascosto le istruzioni di un tool (tool poisoning) viene bloccato.
Ispezione delle risposte
Il risultato di un tool è input non fidato per il modello. Il proxy può mascherare dati sensibili e segnalare contenuti che somigliano a istruzioni (prompt injection indiretta).
Audit, quote, kill switch
Un solo punto con log strutturati (sub, catena act, tool, esito, txn), rate limit per agente e la possibilità di revocare un agente o un tool in un colpo solo.
Il proxy è a sua volta un workload: ha un SPIFFE ID, parla con l'AS e con i server MCP in mTLS con la sua X.509-SVID, e il token interno che ottiene è legato a quel certificato. Una policy di esempio, scritta in modo dichiarativo:
rule "research-legge-crm":
when token.aud == "https://proxy.example.org/mcp"
and token.act.sub == "subagent-research"
and token.act.act.sub in approved_agents # la catena parte da un agente noto
and "crm.read" in token.scope
and rpc.method == "tools/call"
and rpc.params.name in ["crm_search", "crm_get_ticket"]
then exchange(resource = "https://mcp-crm.internal") and forward
default: deny, auditIl quadro completo: da SPIRE al partner
Mettiamo insieme tutti i pezzi. In un sistema reale le identità sono tre e ogni protocollo ne gestisce una: OIDC per l'utente, SPIFFE e WIMSE per il software, OAuth (token exchange, DPoP, identity chaining) per ciò che il software può fare per conto dell'utente.
- 1
Login utente (OIDC)
utenteUtente → app dell'agente AI · riceve il token utente
- 2
Attestazione del nodo
identità workloadSPIRE Agent → SPIRE Server · metadati cloud, TPM, token K8s
- 3
Attestazione del workload
identità workloadAgente AI → SPIRE Agent (Workload API) · pod, service account
- 4
Emissione SVID (SPIFFE)
identità workloadspiffe://azienda.com/agente · X.509-SVID + JWT-SVID, rotazione
- 5
Token exchange (RFC 8693) + DPoP
autorizzazione OAuthAgente → Authorization Server · subject = utente, actor = JWT-SVID
- 6
Chiamata allo strumento (DPoP, RFC 9449)
autorizzazione OAuthAgente → MCP proxy → server MCP · cnf.jkt + proof DPoP fresca
- 7
Delega a un sub-agente (WIMSE)
identità workloadAgente → sub-agente · mTLS con SVID, oppure WIT + WPT
- 8
Accesso cross-dominio (identity chaining)
autorizzazione OAuthSub-agente → AS del partner · token exchange + JWT bearer grant
- 9
Chiamata all'API del partner
autorizzazione OAuthSub-agente → API partner · token DPoP con catena act (utente → agenti)
La differenza rispetto al diagramma precedente è che qui l'agente non usa un client_secret né un identificativo assegnato dal backend: si presenta all'AS con il proprio JWT-SVID come actor_token. L'AS lo verifica con il trust bundle di SPIRE. E quando serve uscire dal proprio dominio, il sub-agente usa l'identity chaining (bozza IETF «OAuth Identity and Authorization Chaining Across Domains»): un token exchange presso il proprio AS per ottenere un JWT authorization grant destinato all'AS del partner, poi un JWT bearer grant presso quest'ultimo.
Fase 1 · attestazione del nodo
1. Il nodo si fa riconoscere
Threat model e buone pratiche
Conviene chiedersi cosa succede quando ogni pezzo viene compromesso. Ecco i punti che contano di più quando si porta SPIRE in produzione.
Nodo compromesso
L'attaccante ottiene le SVID dei workload autorizzati su quel nodo, non di altri: le entry sono legate al parent. Il raggio d'azione è il nodo. Dimensiona di conseguenza: niente workload critici e non critici sullo stesso nodo se il rischio è diverso.
Server compromesso
È la radice del trust domain: chi controlla il server conia qualsiasi identità. Chiavi della CA in KMS o HSM (KeyManager), UpstreamAuthority verso la PKI aziendale, accesso amministrativo minimo, audit della registration API.
Selector troppo deboli
Un'entry con solo k8s:ns:x dà l'identità a chiunque possa creare pod in quel namespace. Combina namespace e service account, e per i workload sensibili il digest dell'immagine.
SSRF verso la Workload API
Il socket non chiede credenziali. L'header obbligatorio workload.spiffe.io impedisce che una richiesta HTTP forgiata tramite un proxy arrivi al socket. Non montare il socket in pod che non ne hanno bisogno.
JWT-SVID riusato
Un servizio che riceve un JWT-SVID può presentarlo a un terzo. Difesa: aud specifica e controllata sempre, TTL di minuti, X.509 o WPT quando serve la prova di possesso.
Validazione fatta a mano
Confrontare il Common Name, accettare più URI SAN, dimenticare CA:FALSE: errori classici. Usa le librerie SPIFFE o un proxy (Envoy) e autorizza sempre sullo SPIFFE ID esatto o sul trust domain, mai «certificato valido = ok».
Operatività
SPIRE diventa infrastruttura critica: se il server è giù a lungo, le SVID scadono e i servizi smettono di parlarsi. Server in HA, TTL della CA e delle SVID scelti in modo che gli agenti sopravvivano a un'interruzione del server (l'agente continua a servire la cache finché le SVID sono valide), metriche su rotazioni e attestazioni fallite, orologi sincronizzati. Introducilo per gradi: prima l'identità e l'osservabilità (chi parla con chi), poi l'mTLS in modalità permissiva, infine l'enforcement.
In sintesi
- 1Il secret zero non si risolve nascondendo meglio i segreti, ma eliminandoli: l'identità nasce dall'attestazione della piattaforma.
- 2SPIFFE definisce il nome (SPIFFE ID), il documento (SVID), le chiavi di fiducia (bundle) e il modo per ottenerli (Workload API).
- 3Gli SVID sono X.509 o JWT con regole strette: un solo URI SAN, CA:FALSE, aud obbligatoria, vita breve. X.509 quando puoi, JWT quando devi.
- 4SPIRE attesta prima il nodo, poi il workload, firma SVID a vita breve e le ruota da sola. Le registration entry legano selector e SPIFFE ID.
- 5Con OIDC Discovery e federazione la stessa identità apre cloud diversi e organizzazioni diverse, senza chiavi statiche.
- 6WIMSE e Transaction Token portano identità con prova di possesso e contesto della transazione attraverso proxy e catene di agenti AI.
- 7Per gli agenti: token exchange per delegare, DPoP per legare ogni token a una chiave, catena act per sapere chi agisce, scope che si restringe a ogni salto.
- 8Un MCP proxy centralizza verifica, policy per tool, token exchange verso i server interni e audit; identity chaining porta la stessa catena fuori dal dominio.
Per approfondire: le specifiche SPIFFE (SPIFFE ID, X.509-SVID, JWT-SVID, Trust Domain and Bundle, Workload API, Federation), la documentazione di SPIRE, le bozze IETF del working group WIMSE (architettura e protocollo service-to-service), la bozza OAuth Transaction Tokens, RFC 8693 (Token Exchange), RFC 9449 (DPoP), RFC 7523 (JWT bearer grant), RFC 8705 (mTLS certificate-bound token), RFC 8707 (Resource Indicators), RFC 9728 (Protected Resource Metadata), la bozza OAuth Identity and Authorization Chaining Across Domains e la specifica di autorizzazione di MCP.