Tutti gli articoli

Workload identity: SPIFFE, SPIRE, SVID e WIMSE, dalla tartaruga di fondo agli agenti AI

Per le persone abbiamo OAuth, OIDC, MFA, passkey. Per i servizi, i container, le pipeline e ora gli agenti AI, spesso ancora una API key in una variabile d'ambiente. Vediamo come SPIFFE, SPIRE e WIMSE danno a ogni workload un'identità crittografica, verificabile e a vita breve, senza nessun segreto iniziale da distribuire.

Pubblicato il 18 ottobre 2026 38 min di letturaWorkload IdentitySPIFFESPIREWIMSEDPoPMCPAI Agents
01

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

Invece di dare un segreto a un workload, lo si fa riconoscere. La tartaruga di fondo non è un segreto ma un fatto che la piattaforma può dimostrare: questo processo gira in questo pod, con questo service account, su questa VM che AWS ha firmato, su questo hardware con questo TPM. Dall'attestazione nasce un'identità a vita breve, rinnovata in automatico.
02

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à umanaWorkload identity
Chi si autenticaUna personaUn processo, container, funzione, job, agente
Come prova chi èQualcosa che sa, ha, è (password, passkey, MFA)Attestazione: proprietà verificate dalla piattaforma
Ciclo di vitaAnniSecondi, minuti, ore
NumerositàMigliaiaMilioni, e in crescita con gli agenti
Credenziale tipicaSessione + token OIDCX.509-SVID, JWT-SVID, WIT
StandardOAuth 2, OIDC, SAML, FIDO2SPIFFE, 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.

03

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.

Workload API · metodi principali
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.

04

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

Dentro uno SVIDInterattivo

campo del certificato

Subject Alt Name

spec: esattamente 1 URI SAN

Qui 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à.

Clicca su un campo. Le etichette «spec» indicano i vincoli imposti dalle specifiche X.509-SVID e JWT-SVID, oltre alle regole generali di X.509 e JWT.

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.

openssl x509 -in svid.pem -noout -text (estratto)
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/checkout

JWT-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 è:

  1. estrarre lo SPIFFE ID (URI SAN o sub) e da esso il trust domain;
  2. scegliere il bundle di quel trust domain (il proprio o uno federato), non un pool di CA indistinto;
  3. validare la catena X.509 o la firma JWT con quel bundle, più scadenza e, per i JWT, aud;
  4. autorizzare: lo SPIFFE ID è quello atteso, o appartiene a un insieme ammesso.
X.509-SVIDJWT-SVID
Dove sta lo SPIFFE IDURI SAN (uno solo)claim sub
Prova di possessoSì: la chiave firma l'handshake TLSNo: bearer token, chi lo ha lo usa
Rischio replayBassoAlto, mitigato da aud e TTL brevi
Attraversa proxy L7No, il TLS termina al proxySì, viaggia in un header
Uso tipicomTLS tra servizi, service meshAPI dietro gateway, federazione cloud via OIDC
Default TTL in SPIRE1 ora5 minuti

Regola pratica

X.509-SVID ogni volta che puoi, perché la prova di possesso è inclusa. JWT-SVID quando devi attraversare un proxy che termina TLS o parlare con un cloud provider via OIDC, con aud stretta e TTL di pochi minuti. Quando serve un token applicativo con prova di possesso, è il territorio di WIMSE.
05

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.

Componenti di SPIRESchema
SPIRE Serverspiffe://example.org · HA con datastore condivisoCA / KeyManagernode attestorUpstreamAuthorityregistration APIdatastore (SQL)bundle endpointentry: SPIFFE ID ← parent ID + selectormTLS (agent SVID)sync entry, firma CSRNodo AVM · bare metal · nodo k8sSPIRE Agentnode attestorworkload attestorcache SVIDcheckoutworkloadsupport-botworkloadWorkload API (Unix socket)Nodo BVM · bare metal · nodo k8sSPIRE Agentnode attestorworkload attestorcache SVIDpaymentsworkloadledgerworkloadWorkload API (Unix socket)
Il server firma e decide; l'agente osserva e consegna. Le linee tratteggiate sono il socket locale della Workload API, quelle piene l'mTLS tra agente e server.

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.

spire-server · entry a mano
# 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.

ClusterSPIFFEID
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"
06

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.

Node attestation con k8s_psatSequence
Kubeletnodo workerSPIRE AgentDaemonSetSPIRE Servercontrol planeK8s APIkube-apiserver1projected SA token (aud: spire-server)2genera chiave + CSR3AttestAgent(psat, CSR)4TokenReview5authenticated: true + pod, nodo6assegna SPIFFE ID, firma7agent SVID + trust bundle8sync: entry autorizzate
passo 1 / 8 · locale

1. La prova che la piattaforma dà all'agente

L'agente gira come DaemonSet. Il kubelet gli monta un Projected Service Account Token: un JWT firmato dal cluster, con audience dedicata, legato al pod e con scadenza breve. Non è un segreto che qualcuno ha copiato a mano: lo ha emesso la piattaforma.
sul filo
# /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": "…" }
  }
}
Clicca su una freccia o usa i pulsanti. Linee tratteggiate: comunicazione locale al nodo. Linee piene: rete. In accento: mTLS con SVID.

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.

PluginProvaDove
aws_iidInstance Identity Document firmato da AWSCloud AWS (EC2)
gcp_iitInstance Identity Token firmato da GoogleGCE
azure_msiToken della managed identity della VMAzure
k8s_psatProjected Service Account Token validato con TokenReviewQualunque Kubernetes
tpm_devidCertificato DevID del TPM + prova di possesso della chiaveBare metal, edge
x509popCertificato X.509 già presente sul nodo + prova di possessoData center con PKI esistente
join_tokenToken monouso generato dal serverLaboratori, 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.

07

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.

Workload attestation su KubernetesSequence
Workloadpod checkoutKernelLinuxSPIRE Agentstesso nodoKubelet:10250SPIRE Server1FetchX509SVID (Unix socket)2SO_PEERCRED3/proc/48213/cgroup4GET /pods5pod spec → selector6match con le entry7BatchNewX509SVID(CSR)8X.509-SVID (TTL 1h)9stream: SVID + chiave + bundle
passo 1 / 9 · locale

1. Il workload chiede «chi sono?»

Il workload apre la Workload API: gRPC su Unix domain socket, montato nel pod. Non presenta nessuna credenziale, ed è voluto: se dovesse presentarne una, avremmo di nuovo il problema del secret zero. Deve solo mettere l'header workload.spiffe.io: true, che impedisce a un SSRF di arrivare al socket tramite un proxy HTTP.
sul filo
SPIFFE_ENDPOINT_SOCKET=unix:///run/spire/sockets/agent.sock

:method  POST
:path    /SpiffeWorkloadAPI/FetchX509SVID
workload.spiffe.io: true
L'informazione scorre sempre dalla piattaforma verso l'agente, mai dal workload.

Prova tu: scegli le proprietà di un pod e guarda quali registration entry si applicano.

Selector e registration entryInterattivo

namespace

service account

immagine

selector scoperti dall'agente
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
spiffe://example.org/ns/payments/sa/checkoutno

k8s:ns:payments ∧ k8s:sa:checkout

servizio checkout

spiffe://example.org/ns/payments/sa/paymentsno

k8s:ns:payments ∧ k8s:sa:payments

servizio payments

spiffe://example.org/ns/ai/sa/support-botSVID

k8s:ns:ai ∧ k8s:sa:support-bot ∧ k8s:container-image:ghcr.io/acme/support-bot@sha256:4f1c

agente AI, solo con l'immagine firmata

spiffe://example.org/ns/ai/sandboxSVID

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.

Un'entry si applica se tutti i suoi selector sono tra quelli scoperti. Prova l'agente AI con la build non approvata: perde l'identità forte ma mantiene quella dell'entry larga.

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.

08

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.

checkout → payments in mTLSSequence
Agent nodo AcheckoutclientpaymentsserverAgent nodo B1SVID + bundle2SVID + bundle3ClientHello4Certificate(SVID payments) + CertReq5verifica catena + authz su ID6Certificate(SVID checkout) + Verify7policy: chi può chiamare /charge?8POST /v1/charge9SVID ruotata (≈ TTL/2)
passo 1 / 9 · locale

1. Identità del client

checkout ottiene dalla Workload API il suo X.509-SVID e il bundle del trust domain.
Autenticazione (catena verso il bundle) e autorizzazione (SPIFFE ID atteso) sono due controlli distinti, entrambi obbligatori.

In Go, con go-spiffe, tutto questo sono poche righe, rotazione inclusa:

client.go
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.

09

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.

Da JWT-SVID a credenziali AWSSequence
Workloadon-prem / k8sSPIRE AgentAWS STSOIDC Discoverydi SPIREAmazon S31FetchJWTSVID(aud: sts.amazonaws.com)2JWT-SVID (exp 5 min)3AssumeRoleWithWebIdentity4GET /.well-known/openid-configuration, /keys5verifica firma, aud, sub6credenziali temporanee7GetObject (SigV4)
passo 1 / 7 · locale

1. Un JWT per un destinatario preciso

Il workload chiede un JWT-SVID indicando l'audience. È obbligatoria: un JWT-SVID senza aud specifica sarebbe riutilizzabile ovunque.
Il workload può girare on-prem, in un altro cloud o in un cluster qualunque: conta solo che abbia un SPIFFE ID.

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.

10

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.

Federazione example.org ↔ partner.ioSequence
Workload Aexample.orgSPIRE Server Aexample.orgBundle endpoint Bpartner.ioWorkload Bpartner.io1federation relationship2GET bundle endpoint3SPIFFE bundle (JWKS)4bundle federato (via agent)5mTLS cross-domain6refresh ogni refresh_hint
passo 1 / 6 · locale

1. Si dichiara la relazione

L'amministratore di A configura il trust domain partner.io, l'URL del suo bundle endpoint e il profilo di autenticazione dell'endpoint. Il primo bundle si scambia out-of-band.
sul filo
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.

11

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 cnf del 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.
DomandaRisposta
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.

Utente → gateway → agente AI → toolSequence
UtenteAPI GatewayTxn Token ServiceAgente AIsupport-botTool APIrefunds1«rimborsa l'ordine 1182» + access token2token exchange → txn_token3Txn-Token (minuti)4richiesta + Txn-Token5WIT + firma WPT6POST /v1/refunds7verifica + policy8201 Created (txn 9705…)
passo 1 / 8 · rete

1. Una richiesta umana entra nel sistema

L'utente è autenticato con OAuth/OIDC e il suo access token arriva al gateway. Questo token è pensato per il perimetro: non va inoltrato così com'è dentro la catena di microservizi e agenti.
Tre identità diverse in gioco: l'utente (Txn-Token), il gateway e l'agente (workload identity), e la prova che la singola richiesta viene davvero dall'agente (WPT).
12

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.

token delegato (RFC 8693)
{
  "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.

13

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.

BearerDPoP (RFC 9449)mTLS-bound (RFC 8705)
Chi può usare il tokenChiunque lo possiedaChi firma proof con la chiave in cnf.jktChi presenta il certificato in cnf.x5t#S256
LivelloNessuna provaApplicativo (header HTTP)Trasporto (TLS)
Attraversa proxy che terminano TLSSìSìNo, salvo inoltro del certificato
Adatto aAmbienti chiusi, token brevissimiAgenti, SPA, mobile, catene con gatewayService-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

Ogni salto della catena deve avere scope uguale o minore del precedente, audience più specifica e durata più breve. Un sub-agente che ottenesse più privilegi dell'agente che lo ha creato sarebbe un'escalation, ed è esattamente quello che un prompt injection proverà a ottenere.
14

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.

Backend → agente → sub-agente → MCP proxy → MCP serverSequence
Backendapp dell'utenteAgentejkt_ASub-agentejkt_SAS / IdPMCP proxygatewayMCP servertoolFase 1 · creazione agente e chiaveFase 2 · grant di delega utente → agenteFase 3 · token dell'agente legato alla chiaveFase 4 · delega al sub-agenteFase 5 · chiamata MCP attraverso il proxyFase 6 · ritorno1crea agente (agent_id, task, policy)2genera chiave DPoP (non esportabile)3JWK pubblica (thumbprint jkt_A)4token exchange (subject=utente, actor=agente)5policy e consenso6grant JWT monouso (act.sub=agente)7grant (canale interno mTLS)8jwt-bearer (RFC 7523) + DPoP proof9client == act.sub, jti non riusato10access token DPoP (cnf.jkt=jkt_A)11task + token A (inutile senza chiave A)12genera chiave DPoP propria (jkt_S)13token exchange (subject=token A, scope ridotto)14may_act: A può delegare a S? scope ⊆ ?15token DPoP (act annidato, cnf.jkt=jkt_S)16POST /mcp tools/call + DPoP17verifica token + DPoP proof18policy: sub + catena act + tool19token exchange → resource=mcp-server20token interno (legato al cert del proxy)21tools/call su mTLS + token interno22autorizza sui dati dell'utente (sub)23result24audit log (sub, catena act, tool, esito)25result26esito task27esito per l'utente
passo 1 / 27 · rete

Fase 1 · creazione agente e chiave

1. Il backend avvia un agente

L'utente è già autenticato (OIDC, Authorization Code + PKCE) e il backend ha il suo access token con aud=backend. Quel token resta al backend: non viene consegnato all'agente. Il backend crea l'agente con un identificativo, il compito e la policy che lo limita.
Premessa: l'utente è già autenticato con OIDC (code + PKCE) e il backend ha il suo access token con aud=backend. Le bande grigie separano le fasi.

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:

policy del proxy (pseudocodice)
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, audit
15

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

Identità e autorizzazione per agenti AI: sequenza dei protocolliSchema
  1. 1

    Login utente (OIDC)

    utente

    Utente → app dell'agente AI · riceve il token utente

  2. 2

    Attestazione del nodo

    identità workload

    SPIRE Agent → SPIRE Server · metadati cloud, TPM, token K8s

  3. 3

    Attestazione del workload

    identità workload

    Agente AI → SPIRE Agent (Workload API) · pod, service account

  4. 4

    Emissione SVID (SPIFFE)

    identità workload

    spiffe://azienda.com/agente · X.509-SVID + JWT-SVID, rotazione

  5. 5

    Token exchange (RFC 8693) + DPoP

    autorizzazione OAuth

    Agente → Authorization Server · subject = utente, actor = JWT-SVID

  6. 6

    Chiamata allo strumento (DPoP, RFC 9449)

    autorizzazione OAuth

    Agente → MCP proxy → server MCP · cnf.jkt + proof DPoP fresca

  7. 7

    Delega a un sub-agente (WIMSE)

    identità workload

    Agente → sub-agente · mTLS con SVID, oppure WIT + WPT

  8. 8

    Accesso cross-dominio (identity chaining)

    autorizzazione OAuth

    Sub-agente → AS del partner · token exchange + JWT bearer grant

  9. 9

    Chiamata all'API del partner

    autorizzazione OAuth

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

Utente, agente, sub-agente e partner: end-to-endSequence
UtenteAgente AISPIRE AgentSPIRE ServerAuth ServeraziendaServer MCPSub-agenteAS partnerAPI partnerFase 1 · attestazione del nodoFase 2 · login utenteFase 3 · identità dell'agente (SPIFFE)Fase 4 · token exchange RFC 8693 + DPoPFase 5 · chiamata allo strumento (RFC 9449)Fase 6 · delega a sub-agente (WIMSE)Fase 7 · identity chaining cross-dominioFase 8 · accesso all'API del partner1node attestation (IID, TPM, PSAT)2SVID del nodo + entry3login OIDC (code + PKCE)4sessione, token utente5Workload API (socket Unix)6workload attestation7X.509-SVID + JWT-SVID8genera chiave DPoP, firma proof9token-exchange: subject=utente, actor=JWT-SVID10trust bundle (bundle endpoint)11verifica SVID, policy, DPoP12access token DPoP (act=agente)13Authorization: DPoP + proof (htm, htu, ath)14firma, cnf.jkt, jti, audience15risultato dello strumento16task + token delegato (mTLS o WIT+WPT)17Workload API: il proprio SVID18JWT-SVID del sub-agente19token exchange, audience=AS partner20JWT authorization grant (catena act)21jwt-bearer (RFC 7523) + DPoP22emittente fidato, mappa i claim23access token DPoP del partner24Authorization: DPoP + proof fresca25verifica DPoP e catena act26dati richiesti27risultato del sub-task28risposta finale
passo 1 / 28 · rete

Fase 1 · attestazione del nodo

1. Il nodo si fa riconoscere

Come nella sezione 6: la piattaforma prova l'identità della macchina.
Su schermi stretti il diagramma scorre in orizzontale. Clicca un passo per vederne i dettagli.
16

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.

17

In sintesi

  1. 1Il secret zero non si risolve nascondendo meglio i segreti, ma eliminandoli: l'identità nasce dall'attestazione della piattaforma.
  2. 2SPIFFE definisce il nome (SPIFFE ID), il documento (SVID), le chiavi di fiducia (bundle) e il modo per ottenerli (Workload API).
  3. 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.
  4. 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.
  5. 5Con OIDC Discovery e federazione la stessa identità apre cloud diversi e organizzazioni diverse, senza chiavi statiche.
  6. 6WIMSE e Transaction Token portano identità con prova di possesso e contesto della transazione attraverso proxy e catene di agenti AI.
  7. 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.
  8. 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.

GP

Lead | Solution Architect – CIAM & API Security

Fatto con da Gianni

© 2026 Tutti i diritti riservati

Costruito con Next.js & Tailwind CSS