<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>iamops.dev</title>
    <link>https://iamops.dev/it/</link>
    <description>Appunti da professionista su identity and access management, agenti AI e DevOps: approfondimenti, laboratori pratici e notizie, con le fonti.</description>
    <language>it</language>
    <lastBuildDate>Fri, 20 Nov 2026 08:00:00 GMT</lastBuildDate>
    <generator>Astro</generator>
    <image>
      <url>https://iamops.dev/icons/icon-512.png</url>
      <title>iamops.dev</title>
      <link>https://iamops.dev/it/</link>
    </image>
    <atom:link href="https://iamops.dev/it/rss.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Imporre il downscoping nel token exchange per le chiamate tra agenti</title>
      <link>https://iamops.dev/it/enforce-downscoping-token-exchange-a2a/</link>
      <guid isPermaLink="true">https://iamops.dev/it/enforce-downscoping-token-exchange-a2a/</guid>
      <pubDate>Fri, 20 Nov 2026 08:00:00 GMT</pubDate>
      <dc:creator>Argo</dc:creator>
      <category>Lab</category>
      <category>Token Exchange</category>
      <category>Keycloak</category>
      <category>A2A</category>
      <category>RFC 8693</category>
      <category>Agenti AI</category>
      <description>Lab Keycloak per agenti A2A: il token che B ottiene per C segue gli scope di B, non quelli di A, se non imponi il downscoping. Prova, controllo, rimedio.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/it/enforce-downscoping-token-exchange-a2a.png?v=986e5733" alt="" /></p><p><strong>In breve</strong></p>
<ul>
<li>Quando l'agente B chiama l'agente C per conto dell'agente A, B scambia il token di A con uno nuovo. Su Keycloak 26.8.2 lo scope del nuovo token segue gli scope di B, non il token consegnato da A, a meno che si imponga il downscoping.</li>
<li>Nel mio test A aveva c.read, B aveva c.write come scope opzionale proprio, e lo scambio di B ha restituito un token per A con c.write. L'agente C ha accettato una scrittura che A non aveva mai concesso.</li>
<li>Non è B che esce dai propri limiti: usa un diritto che ha. Con c.write tolto a B lo stesso scambio fallisce con invalid_scope. È una lezione di configurazione, non una vulnerabilità.</li>
<li>Una client policy con l'executor downscope-assertion-grant-enforcer limita lo scambio agli scope di A. L'agente C dovrebbe anche richiedere il claim act e controllare lo scope per ogni skill.</li>
<li>Ho provato solo Keycloak. A2A 1.0.0 lascia l'autorizzazione all'implementazione e l'Agent Card non ha un campo per il token exchange.</li>
</ul>
<p>A2A 1.0.0 è la versione corrente del protocollo Agent2Agent. Dice che un server deve autenticare ogni richiesta e che l'autorizzazione spetta all'implementazione. Non dice cosa succede quando l'agente B chiama l'agente C per conto dell'agente A. Quella parte è OAuth semplice, e lo strumento abituale è il token exchange (<a href="https://www.rfc-editor.org/rfc/rfc8693">RFC 8693</a>). Ho costruito una piccola catena su un Keycloak locale e mi sono posto una sola domanda: il token che B ottiene per C resta dentro ciò che A ha consegnato?</p>
<p>No, a meno che si chieda a Keycloak di imporlo. Questo articolo parla di quell'impostazione. Se hai letto il <a href="https://iamops.dev/it/keycloak-token-exchange-rfc-8693/">primo lab sul token exchange con Keycloak</a>, questo riparte dal punto dell'insidia &quot;nessun claim act&quot; e aggiunge la delega.</p>
<h2>Cosa mostra questo lab</h2>
<p>Tre agenti e un server di autorizzazione, tutti su localhost.</p>
<ul>
<li><strong>A</strong> è il chiamante. Ha un token con scope <code>agent-b c.read</code>. Un claim <code>may_act</code> in quel token indica B come parte autorizzata ad agire per lui.</li>
<li><strong>B</strong> è un agente nel mezzo. Riceve la chiamata di A, poi chiede a Keycloak un token per chiamare C, usando il token di A come <code>subject_token</code> e il proprio come <code>actor_token</code>.</li>
<li><strong>C</strong> è un piccolo agente di note con una skill di lettura e una di scrittura. Accetta solo token delegati e controlla lo scope per ogni skill.</li>
</ul>
<table>
<thead>
<tr>
<th>Client</th>
<th>Ruolo</th>
<th>Scope che può chiedere in uno scambio</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>agent-a</code></td>
<td>Chiamante, service account</td>
<td><code>agent-b</code> di default, <code>c.read</code> se lo chiede</td>
</tr>
<tr>
<td><code>agent-b</code></td>
<td>Agente intermedio, esegue lo scambio</td>
<td><code>c.read</code> e <code>c.write</code>, entrambi opzionali</td>
</tr>
<tr>
<td><code>agent-c</code></td>
<td>Agente di note, solo audience</td>
<td>nessuno</td>
</tr>
</tbody>
</table>
<figure class="b-fig"><img src="https://iamops.dev/media/enforce-downscoping-token-exchange-a2a/00-flow.webp" alt="Diagramma di sequenza: l'agente A legge l'Agent Card di B, ottiene un token da Keycloak, chiama B, e B lo scambia con un token delegato con claim act prima di chiamare C." width="1800" height="766" loading="lazy" decoding="async"><figcaption><strong>La catena.</strong> I passi da 1 a 4 sono A che chiama B. I passi da 5 a 7 sono B che trasforma il token di A in un token delegato. I passi da 8 a 10 sono la chiamata a C.</figcaption></figure>
<p>Ogni agente pubblica una Agent Card in <code>/.well-known/agent-card.json</code> con uno schema di sicurezza <code>oauth2</code> e gli scope per skill. Lo schema può dire <code>clientCredentials</code> e nulla di più vicino al token exchange: un oggetto <code>OAuthFlows</code> contiene esattamente un flusso e non esiste un flusso di scambio. Per questo la card di C lo dice nel testo della descrizione, e chi chiama deve leggerlo.</p>
<h2>Configurazione</h2>
<p>Keycloak 26.8.2 dallo zip, Java 21, modalità sviluppo. Lo standard token exchange è attivo di default nella 26.8. La delega, cioè i claim <code>act</code> e <code>may_act</code>, no. Servono due funzioni in anteprima.</p>
<pre><code class="language-bash">&quot;$KC_HOME/bin/kc.sh&quot; start-dev --http-port 8080 --features=token-exchange-delegation,parameterized-scopes
</code></pre>
<p>Keycloak stampa all'avvio le funzioni in anteprima attivate. Le ho attivate insieme e non le ho provate una per una. Senza di esse la mia catena fallisce: Keycloak rifiuta in uno scambio semplice qualsiasi subject token che porti <code>may_act</code>, con &quot;Subject token with a delegation claim is not allowed for standard token exchange&quot;.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/enforce-downscoping-token-exchange-a2a/01-features.webp" alt="Output del terminale: Keycloak 26.8.2 si avvia con le funzioni in anteprima parameterized-scopes e token-exchange-delegation attive, poi lo script del realm segnala realm a2a ready." width="1894" height="301" loading="lazy" decoding="async"><figcaption><strong>Funzioni e realm.</strong> Keycloak 26.8.2 con due funzioni in anteprima attive, poi lo script del realm.</figcaption></figure>
<p>Lo script del realm crea i tre client con service account, gli scope <code>agent-b</code>, <code>c.read</code> e <code>c.write</code> (ciascuno con un audience mapper) e un mapper <code>may_act</code> fisso su <code>agent-a</code>. Attiva anche lo Standard Token Exchange per <code>agent-b</code> e dà a <code>agent-b</code> gli scope <code>c.read</code> e <code>c.write</code> come client scope opzionali. Ricorda quest'ultimo punto. Tutto l'articolo gira attorno a questo.</p>
<h2>La catena funziona</h2>
<p>A legge la card di B, chiede a Keycloak esattamente gli scope elencati dalla skill e invia <code>message:send</code>. B scambia il token e chiama C. Il token delegato decodificato mantiene A come <code>sub</code>, restringe <code>aud</code> a C, porta solo <code>c.read</code> e aggiunge <code>act</code> per B.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/enforce-downscoping-token-exchange-a2a/02-chain.webp" alt="Output del terminale: l'agente A legge l'Agent Card di B, chiede gli scope agent-b e c.read e riceve da B una risposta 200 che riassume due note custodite da C." width="1894" height="263" loading="lazy" decoding="async"><figcaption><strong>Il percorso legittimo.</strong> A chiede a B di riassumere le note. B scambia il token di A e le legge da C.</figcaption></figure>
<h2>Lo scambio che A non aveva concesso</h2>
<p>Ora B chiede <code>c.write</code>. Il token di A non ha <code>c.write</code>. Ecco la richiesta, con segnaposto:</p>
<pre><code class="language-bash">curl -s &quot;$KC_URL/realms/a2a/protocol/openid-connect/token&quot; \
  -d grant_type=urn:ietf:params:oauth:grant-type:token-exchange \
  -d client_id=agent-b -d &quot;client_secret=$AGENT_B_SECRET&quot; \
  -d subject_token=&quot;$A_TOKEN&quot; -d subject_token_type=urn:ietf:params:oauth:token-type:access_token \
  -d actor_token=&quot;$B_TOKEN&quot; -d actor_token_type=urn:ietf:params:oauth:token-type:access_token \
  -d audience=agent-c -d scope=c.write
</code></pre>
<p>Keycloak emette il token. <code>sub</code> è A, <code>act</code> indica B, <code>scope</code> è <code>c.write</code>. C controlla firma, audience, il claim <code>act</code> e lo scope richiesto dalla sua skill di scrittura, e aggiunge la nota.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/enforce-downscoping-token-exchange-a2a/03-stock.webp" alt="Output del terminale su Keycloak standard: l'agente B elenca c.write tra i suoi scope opzionali, il token di A ha scope agent-b c.read, il token ottenuto da B per l'agente C ha scope c.write con act agent-b e C risponde che la nota è stata aggiunta." width="1894" height="1218" loading="lazy" decoding="async"><figcaption><strong>Keycloak standard.</strong> Il token di A dice c.read. Il token per C dice c.write. C aggiunge la nota. Gli id sono sostituiti da segnaposto.</figcaption></figure>
<p>Ho eseguito l'intera sequenza quattro volte su un Keycloak 26.8.2 nuovo, due con gli script del lab e due con quelli di questo articolo, e il risultato è stato sempre lo stesso.</p>
<h2>Il controllo: B possiede c.write</h2>
<p>Prima di chiamarla escalation ho verificato di chi è il diritto usato. Nel mio realm B ha <code>c.write</code> come scope opzionale proprio. L'ho messo io. Quindi B non ha ottenuto qualcosa che non gli era mai stato permesso. Ho tolto <code>c.write</code> dagli scope opzionali di B e ho ripetuto lo stesso scambio.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/enforce-downscoping-token-exchange-a2a/04-control.webp" alt="Output del terminale della prova di controllo: dopo aver eliminato c.write dai client scope opzionali dell'agente B, lo stesso scambio è rifiutato con invalid_scope, Invalid scopes: c.write." width="1894" height="225" loading="lazy" decoding="async"><figcaption><strong>Il controllo.</strong> Senza c.write su B non viene emesso nulla. B resta dentro i propri diritti.</figcaption></figure>
<p>Questo chiarisce una cosa. B non può andare oltre ciò che possiede, e qui non c'è un bug nel senso di un aggiramento. Quello che è andato perso è altro: lo scope del nuovo token è limitato dall'insieme di scope di B e non dal token di A. A aveva detto &quot;lettura&quot;, e un passaggio dopo questo non significava più nulla. L'RFC 8693 lascia la scelta al server: <code>scope</code> è &quot;the desired scope of the requested security token&quot; e i suoi valori sono &quot;service specific&quot; (<a href="https://www.rfc-editor.org/rfc/rfc8693#section-2.1">sezione 2.1</a>). Nulla impone che il risultato sia un sottoinsieme del subject token.</p>
<p>Per gli agenti conta perché C registra <code>sub</code> A e <code>act</code> B. Chi legge il log vede &quot;A ha scritto una nota&quot;. A non aveva mai accettato.</p>
<h2>Limitare lo scambio con la policy di downscope</h2>
<p>Keycloak ha un executor per le client policy fatto apposta: <code>downscope-assertion-grant-enforcer</code>. Limita gli scope del nuovo token a quelli già presenti nel subject token e risponde <code>invalid_scope</code> negli altri casi. Non richiede configurazione. L'ho applicato a tutti i client del realm con una sola policy.</p>
<pre><code class="language-json">{&quot;profiles&quot;:[{&quot;name&quot;:&quot;downscope-only&quot;,&quot;description&quot;:&quot;exchange can narrow, never widen&quot;,
  &quot;executors&quot;:[{&quot;executor&quot;:&quot;downscope-assertion-grant-enforcer&quot;,&quot;configuration&quot;:{}}]}]}
</code></pre>
<p>Con <code>c.write</code> di nuovo su B e la policy attiva, lo scambio viene rifiutato. Lo scambio legittimo con <code>c.read</code> funziona ancora.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/enforce-downscoping-token-exchange-a2a/05-enforcer.webp" alt="Output del terminale con la policy di downscope attiva: lo scambio con c.write è rifiutato perché c.write non è presente nel token di accesso iniziale, mentre lo scambio con c.read restituisce ancora un token delegato che C accetta." width="1894" height="836" loading="lazy" decoding="async"><figcaption><strong>Con la policy.</strong> c.write è rifiutato perché il token di A non lo porta. c.read funziona ancora. C elenca anche la nota della prova standard.</figcaption></figure>
<p>L'ultima riga di quell'output è la nota aggiunta dalla prova standard. Resta finché non riavvii C.</p>
<h2>Cosa deve controllare anche C</h2>
<p>La policy vive sul server di autorizzazione. C non dovrebbe dipendere solo da quella.</p>
<ul>
<li>Richiedi il claim <code>act</code> e confronta <code>act.client_id</code> con gli agenti che ti aspetti. Il mio C risponde 403 senza.</li>
<li>Controlla lo scope per skill. Il mio C richiede <code>c.read</code> per leggere e <code>c.write</code> per scrivere.</li>
<li>Controlla <code>aud</code>. Un token per B viene rifiutato da C con 401.</li>
<li>Non trattare <code>may_act</code> come una prova. Quando B ha presentato il token di C come attore, Keycloak ha rifiutato con un messaggio sull'audience. Non ho verificato se confronti l'attore con <code>may_act</code>.</li>
</ul>
<h2>Insidie</h2>
<ul>
<li><strong>L'enforcer e un audience mapper a livello di client.</strong> Nella mia prima configurazione l'audience di C stava in un mapper sul client B. Con l'enforcer attivo ogni scambio falliva con &quot;Requested audience not available: agent-c&quot;. Spostare il mapper sugli scope <code>c.read</code> e <code>c.write</code> ha risolto. Non so perché. Provalo nel tuo realm.</li>
<li><strong>L'audience tramite scope ha un effetto collaterale.</strong> <code>c.read</code> porta l'audience di C, quindi il token di A ha <code>aud</code> B e C. Ciò che impedisce ad A di usarlo su C è il requisito <code>act</code>, non l'audience.</li>
<li><strong>L'errore sull'attore sbagliato è vago.</strong> Il client vede <code>access_denied</code> e &quot;Client is not within the token audience&quot;. Il log eventi di Keycloak nomina l'attore.</li>
<li><strong><code>may_act</code> è fisso nel mio realm.</strong> In un sistema reale dovrebbe derivare da una policy e vivere insieme al token.</li>
</ul>
<h2>Cosa non ho eseguito</h2>
<p>Ho eseguito solo Keycloak 26.8.2. Non ho provato Entra on-behalf-of, Okta né Auth0, quindi non dico nulla su come limitino lo scope in uno scambio. Un solo passaggio di delega: nessuna catena <code>act</code> annidata. Nessun task, streaming o Agent Card firmata, nessun TLS e nessun token vincolato al mittente. Nessun utente nella catena: il soggetto è il service account dell'agente A. Gli agenti sono miei programmi Flask e i loro client secret sono valori statici di laboratorio.</p>
<p><em>Le immagini del terminale sono state ricostruite dall'output salvato delle esecuzioni, con gli id sostituiti da segnaposto. Niente di quanto vedi è una credenziale reale.</em></p>
<p>Per gli standard alla base, vedi <a href="https://iamops.dev/it/id-jag-explained/">ID-JAG spiegato</a> e <a href="https://iamops.dev/it/mcp-server-no-token-passthrough/">perché un server MCP non deve inoltrare i token</a>.</p>
]]></content:encoded>
    </item>
    <item>
      <title>Da GitHub Actions ad Azure con la workload identity federation: quali run ricevono un token, e perché</title>
      <link>https://iamops.dev/it/github-actions-azure-workload-identity-federation/</link>
      <guid isPermaLink="true">https://iamops.dev/it/github-actions-azure-workload-identity-federation/</guid>
      <pubDate>Fri, 20 Nov 2026 08:00:00 GMT</pubDate>
      <dc:creator>Argo</dc:creator>
      <category>Lab</category>
      <category>GitHub Actions</category>
      <category>OIDC</category>
      <category>Entra ID</category>
      <category>Identità dei workload</category>
      <category>Azure</category>
      <description>Lab: un workflow GitHub accede ad Azure senza segreti. Stampo il sub di sei tipi di run e mostro quale credenziale fa passare ciascuno, pull request comprese.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/it/github-actions-azure-workload-identity-federation.png?v=986e5733" alt="" /></p><p><strong>In breve</strong></p>
<ul>
<li>Un workflow GitHub può accedere ad Azure senza client secret. GitHub firma un token di breve durata e una credenziale federata in Entra si fida di un solo claim sub esatto.</li>
<li>I repository nuovi inviano un sub immutabile con dentro gli ID di owner e repository. Crea prima il repository, leggi gli ID, poi scrivi la credenziale.</li>
<li>Con la sola credenziale per main è passato 1 tipo di run su 6. Una credenziale per l'environment, una per pull_request e due espressioni con wildcard hanno portato a 6 su 6.</li>
<li>pull_request e pull_request_target inviano lo stesso sub, quindi una credenziale pull_request si fida anche dei job pull_request_target, che girano con i segreti. Lì non fare mai checkout della head della PR.</li>
<li>Le pull request da fork non le ho provate. Secondo la documentazione GitHub non ricevono permessi di scrittura, quindi mi aspetto nessun token, ma non l'ho visto.</li>
</ul>
<p>Una pipeline di deploy con dentro un client secret è un segreto che aspetta di trapelare. GitHub Actions può accedere ad Azure senza: GitHub firma un token OIDC di breve durata per il job ed Entra se ne fida tramite una credenziale federata. Quest'anno sono cambiate due cose. Dal 15 luglio 2026 i repository nuovi ricevono un <a href="https://github.blog/changelog/2026-04-23-immutable-subject-claims-for-github-actions-oidc-tokens/">claim sub immutabile</a> con dentro gli ID di owner e repository, e le credenziali con wildcard di Entra sono ancora in preview. Ho raccolto entrambe le notizie in un <a href="https://iamops.dev/it/workload-identity-news-immutable-sub-entra-wildcards-workos/">articolo</a>. Questo lab è la parte pratica.</p>
<h2>Cosa mostra questo lab</h2>
<p>Una app registration con Reader su un solo resource group vuoto, un repository privato, nessun segreto da nessuna parte. Il lab:</p>
<ol>
<li>Si fida del branch main con una credenziale esatta e vede <code>azure/login</code> riuscire.</li>
<li>Fa push di un feature branch e apre una pull request, e li vede rifiutati entrambi con AADSTS700213.</li>
<li>Consente <code>release/*</code> con una claims-matching expression.</li>
<li>Stampa il <code>sub</code> esatto di sei tipi di run, poi aggiunge le credenziali che li fanno passare tutti.</li>
<li>Guarda le pull request da fork, solo dalla documentazione, perché non ho potuto provarle.</li>
</ol>
<h2>Preparazione</h2>
<p>Usa un tenant e una sottoscrizione usa e getta, e un account GitHub tuo. La app registration riceve Reader su un solo resource group vuoto, così un login riuscito prova la federazione e nient'altro. I tre ID che servono al workflow (client, tenant, sottoscrizione) non sono segreti e vanno nelle variabili del repository.</p>
<p>Crea il repository prima della credenziale. Un repository nuovo invia <code>repo:&lt;owner&gt;@&lt;owner-id&gt;/&lt;repo&gt;@&lt;repo-id&gt;:...</code>, e i due ID li conosci solo quando il repository esiste. Un subject scritto alla vecchia maniera, <code>repo:&lt;owner&gt;/&lt;repo&gt;:ref:refs/heads/main</code>, non corrisponde più.</p>
<pre><code class="language-json">{&quot;name&quot;: &quot;gh-main&quot;, &quot;issuer&quot;: &quot;https://token.actions.githubusercontent.com&quot;,
 &quot;subject&quot;: &quot;repo:&lt;github-user&gt;@&lt;owner-id&gt;/lab-b1-gh-wif@&lt;repo-id&gt;:ref:refs/heads/main&quot;,
 &quot;audiences&quot;: [&quot;api://AzureADTokenExchange&quot;]}
</code></pre>
<h2>L'esecuzione</h2>
<p><strong>main accede.</strong> Il workflow stampa i claim che GitHub presenta, poi esegue <code>azure/login</code> ed elenca i resource group. Il mio primo run è fallito dopo il login con &quot;No subscriptions found&quot;, perché il ruolo Reader non si era ancora propagato. Un minuto di attesa ha risolto.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/github-actions-azure-workload-identity-federation/01-main.webp" alt="Output di terminale: la credenziale federata gh-main con un subject esatto per il branch main, poi un run su main che termina con successo, stampa lo stesso claim sub, elenca il resource group e mostra l'accesso come service principal. Gli ID sono segnaposto." width="1894" height="492" loading="lazy" decoding="async"><figcaption><strong>Il sub corrisponde carattere per carattere.</strong> La credenziale è tutta la relazione di fiducia. Non c'è nessun segreto da creare né da ruotare. Gli ID sono segnaposto.</figcaption></figure>
<p><strong>Un feature branch e una pull request vengono rifiutati.</strong> Stesso workflow, <code>sub</code> diverso. Entra risponde AADSTS700213 e il messaggio riporta il subject ricevuto, che è il modo più rapido per correggere una credenziale.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/github-actions-azure-workload-identity-federation/02-feature-refused.webp" alt="Output di terminale: un push su feature-x e una pull request terminano entrambi con errore AADSTS700213, nessun record di identità federata corrispondente. I subject presentati finiscono con ref:refs/heads/feature-x e pull_request. Gli ID sono segnaposto." width="1894" height="454" loading="lazy" decoding="async"><figcaption><strong>Rifiutati, per costruzione.</strong> Un errore di battitura nel nome di un branch o una pull request non revisionata non ottengono l'identità di deploy. Gli ID sono segnaposto.</figcaption></figure>
<p><em><em>release/</em> con un'espressione.</em>* Una credenziale federata flessibile contiene una <code>claimsMatchingExpression</code> al posto del subject. Per le app registration l'ho creata con <code>az rest</code> sull'endpoint beta di Graph. Ho seguito la documentazione Microsoft e ho fissato anche <code>repository_id</code>:</p>
<pre><code class="language-text">claims['sub'] matches 'repo:&lt;github-user&gt;@&lt;owner-id&gt;/lab-b1-gh-wif@&lt;repo-id&gt;:ref:refs/heads/release/*' and claims['repository_id'] eq '&lt;repo-id&gt;'
</code></pre>
<figure class="b-fig"><img src="https://iamops.dev/media/github-actions-azure-workload-identity-federation/03-release-expression.webp" alt="Output di terminale: az rest crea la credenziale gh-release con una claims-matching expression sul sub per i branch release più un controllo su repository_id, poi un push su release/1 termina con successo e stampa il suo sub. Gli ID sono segnaposto." width="1894" height="492" loading="lazy" decoding="async"><figcaption><strong>Una credenziale per una famiglia di branch.</strong> Il pattern mantiene gli ID di owner e repository, e repository_id viene controllato a parte. Gli ID sono segnaposto.</figcaption></figure>
<h2>Verifica approfondita: il sub di ogni tipo di run</h2>
<p>Un lettore mi ha chiesto se il rifiuto di un feature branch e di una pull request sia un bug. Non lo è, e volevo dimostrarlo. Un piccolo script, <code>probe.sh</code>, chiede un token a GitHub, decodifica il <code>sub</code>, offre il token a Entra e stampa una riga di risultato. Il workflow lo esegue su un push a main, un push su un feature branch, <code>pull_request</code>, <code>pull_request_target</code>, un push di tag e un secondo job che usa un environment. Ho usato una nuova app e lo stesso repository privato.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/github-actions-azure-workload-identity-federation/04-subs-before.webp" alt="Output di terminale: una tabella di sei run con la sola credenziale per main. main passa. I run su feature branch, pull request, pull_request_target, tag ed environment falliscono con AADSTS700213. Ogni riga mostra il sub dopo il prefisso del repository." width="1894" height="416" loading="lazy" decoding="async"><figcaption><strong>Ne passa 1 su 6.</strong> La parte dopo gli ID cambia per ogni tipo di run, e una credenziale per main corrisponde solo a main.</figcaption></figure>
<p>Poi ho aggiunto quattro credenziali: una esatta per l'environment, una esatta per <code>pull_request</code> e due espressioni per i branch <code>feature-*</code> e i tag <code>v*</code>. Ho rilanciato gli stessi run.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/github-actions-azure-workload-identity-federation/05-subs-after.webp" alt="Output di terminale: le quattro credenziali aggiuntive elencate per nome e pattern, poi la stessa tabella di sei run in cui ogni riga passa. Il segnaposto prefix sta per la parte del sub con il repository e gli ID di owner e repository." width="1894" height="568" loading="lazy" decoding="async"><figcaption><strong>Passano 6 su 6.</strong> &lt;prefix&gt; sta per repo:&lt;owner&gt;@&lt;id&gt;/&lt;repo&gt;@&lt;id&gt;. Una credenziale contiene un subject esatto oppure un'espressione, mai entrambi.</figcaption></figure>
<table>
<thead>
<tr>
<th>Run</th>
<th><code>sub</code> dopo il prefisso del repository</th>
<th>Credenziale che lo fa passare</th>
<th>Solo main</th>
<th>Dopo</th>
</tr>
</thead>
<tbody>
<tr>
<td>Push su main</td>
<td><code>ref:refs/heads/main</code></td>
<td>Subject esatto</td>
<td>Passa</td>
<td>Passa</td>
</tr>
<tr>
<td>Push su feature-probe</td>
<td><code>ref:refs/heads/feature-probe</code></td>
<td>Espressione <code>...ref:refs/heads/feature-*</code></td>
<td>AADSTS700213</td>
<td>Passa</td>
</tr>
<tr>
<td><code>pull_request</code></td>
<td><code>pull_request</code></td>
<td>Subject esatto</td>
<td>AADSTS700213</td>
<td>Passa</td>
</tr>
<tr>
<td><code>pull_request_target</code></td>
<td><code>pull_request</code></td>
<td>La stessa credenziale <code>pull_request</code></td>
<td>AADSTS700213</td>
<td>Passa</td>
</tr>
<tr>
<td>Tag v1</td>
<td><code>ref:refs/tags/v1</code></td>
<td>Espressione <code>...ref:refs/tags/v*</code></td>
<td>AADSTS700213</td>
<td>Passa</td>
</tr>
<tr>
<td>Job con environment lab-b1-prod</td>
<td><code>environment:lab-b1-prod</code></td>
<td>Subject esatto</td>
<td>AADSTS700213</td>
<td>Passa</td>
</tr>
</tbody>
</table>
<p><strong>Una differenza rispetto alla documentazione Microsoft.</strong> Le espressioni <code>feature-*</code> e <code>v*</code> avevano solo una condizione sul <code>sub</code>, senza <code>repository_id</code>. Entra le ha accettate entrambe e i run sono passati. I miei pattern contenevano già gli ID di owner e repository, quindi erano vincolati comunque. In un controllo successivo, lo stesso giorno, Entra ha accettato anche un'espressione a livello di owner senza <code>repository_id</code> né <code>repository_owner_id</code>, e quella credenziale ha emesso un token a un altro repository dello stesso owner. Le pagine Microsoft dicono che un'espressione per GitHub deve verificare <code>sub</code> e <code>repository_id</code> o <code>repository_owner_id</code>. Consiglio lo stesso di aggiungere <code>repository_id</code> a ogni espressione. La regola è documentata e la funzione è in preview, quindi una credenziale solo sul sub potrebbe essere rifiutata o smettere di corrispondere più avanti. E il controllo sull'ID non dipende dallo scrivere bene il pattern: un wildcard a livello di owner ha già emesso un token a un altro dei miei repository, e il <code>sub</code> solo con i nomi di un repository più vecchio può corrispondere a un nome che non è più tuo.</p>
<h2>pull_request e pull_request_target condividono lo stesso subject</h2>
<p>Entrambi gli eventi inviano un <code>sub</code> che finisce con <code>pull_request</code>, qualunque sia il branch. Quindi una credenziale <code>pull_request</code> in Entra si fida anche dei job <code>pull_request_target</code>. Questi girano dal branch base, con i segreti e con un token OIDC. Se un workflow del genere fa checkout della head della pull request, l'autore della pull request esegue codice con la tua identità cloud. Il mio workflow di prova usava il checkout predefinito, che prende il branch base. Non cambiarlo in un workflow che può ottenere un token.</p>
<p>Un job che usa un environment è l'altra sorpresa. Invia <code>environment:&lt;name&gt;</code> al posto del branch. Spostare un job di deploy in un environment rompe una credenziale scritta per main.</p>
<h2>Pull request da fork: dalla documentazione, non provate</h2>
<p>Non ho provato una pull request da un fork. Serve un secondo account GitHub, e non ne uso uno che non sia mio. Quello che segue è la documentazione GitHub e la mia lettura.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/github-actions-azure-workload-identity-federation/06-forks-docs.webp" alt="Output di terminale con tre frasi citate dalla documentazione GitHub: i segreti non passano ai workflow avviati da fork, il GITHUB_TOKEN è in sola lettura nelle pull request da fork e i permessi di scrittura diventano lettura per gli eventi di pull request diversi da pull_request_target da un fork." width="1894" height="416" loading="lazy" decoding="async"><figcaption><strong>Solo documentazione, non un test.</strong> Le righe sono stampate direttamente dalle pagine GitHub, così puoi controllarne il testo.</figcaption></figure>
<p><code>id-token: write</code> è un permesso di scrittura. Per una <code>pull_request</code> da un fork viene ridotto a lettura, quindi secondo me il job non riceve alcun token OIDC. <code>probe.sh</code> gestisce questo caso e stamperebbe &quot;no OIDC token was offered&quot;. Non l'ho visto succedere. <code>pull_request_target</code> è l'eccezione in quella documentazione, ed è la trappola descritta sopra.</p>
<h2>Insidie</h2>
<ul>
<li><strong>Leggi il <code>sub</code> da un run reale prima di scrivere una credenziale.</strong> Lo mostrano sia la riga nel log sia il messaggio AADSTS700213.</li>
<li><strong>Aspetta dopo l'assegnazione del ruolo.</strong> Senza attesa il login funzionava e il comando successivo falliva con &quot;No subscriptions found&quot;.</li>
<li><strong>Le espressioni sono in preview e su Graph beta.</strong> Per le app registration ho usato <code>az rest</code>. La pagina concettuale di Microsoft dice che la CLI non le supporta ancora in modo esplicito, mentre <code>az identity federated-credential</code> (identità gestite assegnate dall'utente) elenca parametri in preview per farlo.</li>
<li><strong>I repository vecchi mantengono il <code>sub</code> solo con i nomi</strong> finché qualcuno non fa l'opt-in. Scrivi la credenziale per il formato che il repository invia davvero.</li>
</ul>
<h2>Cosa portarsi a casa sulla sicurezza</h2>
<ol>
<li>In CI usa la federazione al posto di un client secret. Non c'è niente da conservare, far trapelare o ruotare.</li>
<li>Usa la credenziale più stretta possibile: esatta per main e per un environment, un'espressione solo per una vera famiglia di ref.</li>
<li>Mantieni gli ID di owner e repository in ogni subject e pattern, e aggiungi <code>repository_id</code> a ogni espressione.</li>
<li>Considera che una credenziale <code>pull_request</code> si fida anche di <code>pull_request_target</code>. Mai fare checkout di codice non fidato in un workflow che può ottenere un token.</li>
<li>Elimina le credenziali il cui repository non esiste più. Con il vecchio formato solo con i nomi, qualcun altro può prendersi quel nome.</li>
</ol>
<h2>Pulizia</h2>
<p>Ho eliminato la app registration, che rimuove le sue credenziali, ho eliminato il resource group, ho verificato che non esistessero più e ho archiviato il repository privato. Dopo la verifica approfondita ho rimosso anche l'app aggiuntiva, il branch, il tag, la pull request, l'environment e le variabili.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/github-actions-azure-workload-identity-federation/07-cleanup.webp" alt="Output di terminale: la app registration e il resource group vengono eliminati, az group exists stampa false, il conteggio delle app è 0 e il repository viene archiviato." width="1894" height="377" loading="lazy" decoding="async"><figcaption><strong>Non resta niente in esecuzione.</strong> Non è mai stato creato alcun segreto, quindi non c'è niente da revocare.</figcaption></figure>
<h2>Cosa non è stato eseguito</h2>
<ul>
<li>Una pull request da un fork. Quella parte si basa sulla documentazione GitHub.</li>
<li>Un repository esistente passato al formato immutabile, e l'endpoint di anteprima di GitHub per il prefisso del subject.</li>
<li>Un ruolo che può fare deploy. L'app aveva solo Reader su un resource group vuoto.</li>
<li>Un'espressione con <code>repository_owner_id</code> o <code>job_workflow_ref</code>.</li>
<li>Altri cloud. GitHub documenta AWS, Google Cloud e Vault, io ho provato solo Azure.</li>
</ul>
<p><em>Eseguito il 20 novembre 2026 con l'Azure CLI, la GitHub CLI e <code>azure/login@v2</code> su un runner ospitato da GitHub, in un tenant usa e getta e in un repository privato. Le immagini di terminale sono state ridisegnate dall'output salvato, con utenti, ID e orari sostituiti da segnaposto.</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>Note da IETF 127: ID-JAG, grant per workload e transaction token per la delega agli agenti</title>
      <link>https://iamops.dev/it/ietf-127-id-jag-workload-grants-transaction-tokens/</link>
      <guid isPermaLink="true">https://iamops.dev/it/ietf-127-id-jag-workload-grants-transaction-tokens/</guid>
      <pubDate>Fri, 20 Nov 2026 08:00:00 GMT</pubDate>
      <dc:creator>Argo</dc:creator>
      <category>News</category>
      <category>IETF 127</category>
      <category>ID-JAG</category>
      <category>Identità dei workload</category>
      <category>Transaction Token</category>
      <category>Agenti AI</category>
      <category>Standard</category>
      <description>La mia lettura delle sessioni OAuth e WIMSE di IETF 127: ID-JAG, Workload Authorization Grant, transaction token e attori, con le revisioni dei draft.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/it/ietf-127-id-jag-workload-grants-transaction-tokens.png?v=986e5733" alt="" /></p><p><strong>In breve</strong></p>
<ul>
<li>A IETF 127 la delega agli agenti è stata trattata in tre casi: un utente (ID-JAG), un workload che agisce per sé (Workload Authorization Grant, WAG) e una transazione in corso (un grant per transaction token).</li>
<li>ID-JAG è al draft -06 ed è ancora un documento del working group OAuth. Il provisioning just-in-time e il key binding passano a draft separati, e i gateway nel mezzo restano il problema aperto.</li>
<li>WAG, il profilo dei transaction token, i Transactional Access Token, l'Actor Profile e i tre draft più recenti sulla delega sono draft individuali. Nulla di tutto questo è adottato o definitivo.</li>
<li>Per i propri progetti: classificare ogni flusso di agenti in base al principal, non inoltrare mai il token in ingresso al passo successivo e scrivere la revisione del draft in ogni progetto che ne dipende.</li>
</ul>
<p>IETF 127 si è svolto questa settimana a San Francisco. Non c'ero. Ho letto le slide, gli appunti presi dai volontari e i draft attuali delle sessioni OAuth e WIMSE, e il 20 novembre 2026 ho controllato nome e revisione di ogni draft su datatracker.ietf.org.</p>
<p>La sessione OAuth si è tenuta mercoledì 18 novembre. WIMSE si è riunito la sera stessa (22:00 UTC) e la sessione congiunta OAuth e WIMSE è seguita giovedì 19 novembre. Oggi OAuth ha un'ultima sessione, che mentre scrivo non c'è ancora stata. Cito gli appunti come appunti. Non sono decisioni.</p>
<h2>Tre grant per tre tipi di principal</h2>
<p>Nella sessione congiunta Justin Richer ha proposto una tassonomia semplice, riportata negli <a href="https://notes.ietf.org/notes-ietf-127-wimse">appunti WIMSE</a>: ID-JAG riguarda una persona, WAG un workload e &quot;TAG&quot; una transazione in corso. &quot;TAG&quot; è un soprannome nato nella discussione. Non è un draft e non è un nome registrato.</p>
<table>
<thead>
<tr>
<th>Caso</th>
<th>Draft che ho controllato</th>
<th>Stato</th>
</tr>
</thead>
<tbody>
<tr>
<td>Un utente</td>
<td><a href="https://datatracker.ietf.org/doc/draft-ietf-oauth-identity-assertion-authz-grant/">draft-ietf-oauth-identity-assertion-authz-grant-06</a> (ID-JAG)</td>
<td>Documento del working group OAuth, pubblicato il 31 ott 2026</td>
</tr>
<tr>
<td>Un workload che agisce per sé</td>
<td><a href="https://datatracker.ietf.org/doc/draft-carleton-workload-authz-grant/">draft-carleton-workload-authz-grant-02</a> (WAG)</td>
<td>Draft individuale, &quot;Informational&quot;, pubblicato il 2 nov 2026</td>
</tr>
<tr>
<td>Una transazione in corso</td>
<td><a href="https://datatracker.ietf.org/doc/draft-fletcher-oauth-txn-token-chaining-profile/">draft-fletcher-oauth-txn-token-chaining-profile-01</a></td>
<td>Draft individuale, pubblicato il 26 ott 2026</td>
</tr>
</tbody>
</table>
<p>ID-JAG e il profilo dei transaction token sono entrambi profili di <a href="https://datatracker.ietf.org/doc/draft-ietf-oauth-identity-chaining/">identity chaining</a>. Quel draft è al -17 e il datatracker lo mostra nella coda dell'RFC Editor, con lo stato &quot;blocked: Final Approval Pending&quot;. Gli appunti WIMSE lo chiamano &quot;RFC 10092 (to be)&quot;. Il datatracker non mostra ancora un numero RFC, quindi non lo citerei.</p>
<figure class="b-fig"><img src="https://iamops.dev/img/ietf-127-id-jag-workload-grants-transaction-tokens.it.svg" alt="Tre colonne, una per tipo di principal. Un utente corrisponde a ID-JAG, documento del working group OAuth. Un workload corrisponde a WAG, draft individuale. Una transazione corrisponde al profilo di chaining dei txn-token, draft individuale. Tutte e tre portano a un authorization server che emette un token con la API successiva come audience." width="1200" height="630" loading="lazy" decoding="async"><figcaption><strong>Tre principal, tre grant.</strong> È una mia sintesi della divisione, non una figura delle slide. Stato al 20 novembre 2026.</figcaption></figure>
<h2>ID-JAG al draft -06</h2>
<p>Le slide di ID-JAG elencano le modifiche di -05 e -06. Queste sono quelle che leggerei per prime:</p>
<ul>
<li>Un ID-JAG legato a una chiave può sostituire l'autenticazione del client presso l'authorization server della risorsa.</li>
<li>Il token exchange è limitato a una sola audience. Un'audience sconosciuta riceve <code>invalid_target</code>.</li>
<li>È stato aggiunto il binding mTLS, e un ID-JAG legato con <a href="https://iamops.dev/it/tools/dpop/">DPoP</a> richiede il tipo di grant <code>jwt-dpop</code>.</li>
<li>Una nuova sezione Subject Identifier Mapping, i controlli sul tenant e un valore di metadati <code>id_jag_signing_alg_values_supported</code>.</li>
<li>Una sezione Privacy Considerations.</li>
</ul>
<p>Le <a href="https://datatracker.ietf.org/meeting/127/materials/slides-127-oauth-sessa-identity-assertion-jwt-authorization-grant-00">slide</a> elencano anche chi lo implementa. Nell'elenco compaiono Okta, Ping, Auth0, Descope, Keycloak, WorkOS e Oracle OCI IAM. Per le basi ho scritto <a href="https://iamops.dev/it/id-jag-explained/">ID-JAG explained</a>.</p>
<p>Dall'esperienza di implementazione sono emersi tre temi, e ciascuno è finito altrove rispetto al draft principale:</p>
<ul>
<li><strong>Provisioning just-in-time</strong> (issue #83 e #121). La raccomandazione è un'estensione futura. Un'app può ora incontrare un utente per la prima volta tramite un ID-JAG, e i claim personalizzati sono permessi ma non necessariamente interoperabili.</li>
<li><strong>Key binding</strong> (issue #103). Le slide indicano i pezzi mancanti in <a href="https://datatracker.ietf.org/doc/draft-mcguinness-oauth-token-exchange-cnf/">draft-mcguinness-oauth-token-exchange-cnf</a> e <a href="https://datatracker.ietf.org/doc/draft-parecki-oauth-jwt-dpop-grant/">draft-parecki-oauth-jwt-dpop-grant</a> e chiedono se spostare il key binding in un'estensione propria. Negli appunti Hannes ha detto che rimandare ad altri documenti fa sembrare il draft incompleto. Aaron Parecki ha risposto che il provisioning è opzionale e che il binding vale più in generale di ID-JAG.</li>
<li><strong>Gateway e proxy</strong> (issue #114). Un gateway nel mezzo esegue il token exchange, ma l'audience dell'ID token è il client che ha chiamato il gateway, e il controllo sull'audience fallisce. Le slide propongono di dichiarare le topologie con intermediari fuori ambito e indicano <a href="https://datatracker.ietf.org/doc/draft-mcguinness-oauth-id-continuation-assertion/">draft-mcguinness-oauth-id-continuation-assertion</a> come estensione.</li>
</ul>
<p>Gli autori hanno chiesto riunioni interim su gateway e key binding. I prossimi passi sulle slide sono smistare le issue rimaste in -07 o in un rinvio esplicito, e poi chiedere il working group last call.</p>
<p>Il mio parere: il grant di base sembra abbastanza stabile per costruirci sopra. Non costruirei ancora un progetto con un gateway nel mezzo, perché è proprio il caso che gli autori hanno spostato fuori.</p>
<h2>WAG: la versione per i workload</h2>
<p>Il draft WAG descrive una piattaforma il cui workload identity provider firma un grant JWT secondo <a href="https://www.rfc-editor.org/rfc/rfc7523">RFC 7523</a> che nomina un solo workload. L'authorization server di una terza parte viene configurato una volta per fidarsi di quel provider e non rifiuta un workload solo perché non l'ha mai visto. Il draft dice che il caso motivante è un agente AI e che l'accesso per conto di un utente è fuori ambito.</p>
<p>Dice anche chiaramente di essere un draft individuale iniziale ed esplorativo, non un documento del working group. Nella sessione WIMSE Aaron Parecki ha detto che ID-JAG riguarda per natura un utente, e senza utente il caso somiglia a WAG. Jeff Lombardo si è detto molto favorevole all'adozione. Karl McGuinness ha sostenuto di tenere separati i tipi di principal invece di far dedurre al ricevente il tipo dai claim. Gli appunti non riportano obiezioni all'idea. Non riportano nemmeno una richiesta di adozione.</p>
<p>Anche l'identità del client è stata toccata. L'intervento di Justin Richer <a href="https://datatracker.ietf.org/meeting/127/materials/slides-127-wimse-sessb-the-future-of-client-id-00">The Future of Client ID</a> elencava le opzioni: registrazione dinamica, un URL di metadati (CIMD), un client ID come JWT e un SPIFFE ID. Il draft <a href="https://datatracker.ietf.org/doc/draft-ietf-oauth-spiffe-client-auth/">SPIFFE client authentication</a> è al -03 (2 novembre) e copre solo il token endpoint.</p>
<p>Altri due punti WIMSE contano se ci si costruisce sopra:</p>
<ul>
<li><strong>Workload Proof Token</strong> (<a href="https://datatracker.ietf.org/doc/draft-ietf-wimse-wpt/">draft-ietf-wimse-wpt-02</a>) ha spostato la prova nell'header <code>Authorization</code>. Una richiesta ha un solo header di questo tipo, quindi un WPT non può viaggiare insieme a un access token OAuth. Flemming Andreasen ha definito la modifica incoerente con l'architettura, e Jonathan Rosenberg ha osservato che un agente che agisce per un utente ha bisogno sia di un access token sia dell'autenticazione dell'agente. Il chair ha mandato la questione alla mailing list.</li>
<li><strong>WIMSE Architecture</strong> (<a href="https://datatracker.ietf.org/doc/draft-ietf-wimse-arch/">-09</a>) è uscita il 17 novembre (UTC). Gli autori la ritengono pronta e i chair prevedono un working group last call nelle prossime settimane.</li>
</ul>
<p>Nella stessa sessione Brian Campbell ha presentato il draft <a href="https://datatracker.ietf.org/doc/draft-ietf-wimse-aims/">AI Identity Management System</a>, con la formula &quot;OAuth in the front, WIMSE in the back&quot;. Gli appunti dicono che non definisce nessun nuovo comportamento di protocollo.</p>
<h2>Transaction token oltre il confine</h2>
<p>I Transaction Token restano dentro un solo trust domain. Il <a href="https://datatracker.ietf.org/doc/draft-fletcher-oauth-txn-token-chaining-profile/">profilo di George Fletcher</a> descrive come un workload scambia il proprio Txn-Token presso il proprio authorization server con un Txn-Token-JAG (<code>typ</code> pari a <code>txn-chain+jwt</code>) e lo presenta al server di un partner. Secondo le <a href="https://datatracker.ietf.org/meeting/127/materials/slides-127-wimse-ietf-127-txn-token-chaining-profile-00">slide</a> il grant dura al massimo 300 secondi, meglio 60, il <code>jti</code> è monouso e la catena di chiamate interna non attraversa mai il confine. Le domande aperte sono se il sender constraining debba passare da SHOULD a MUST e come mappare il subject.</p>
<p>La discussione è stata la parte interessante:</p>
<ul>
<li>Max Gerber ha chiesto perché serva un nuovo tipo di JAG quando esistono ID-JAG e WAG. Justin Richer e Pieter Kasselman hanno risposto che l'artefatto di partenza è diverso e che il JAG porterebbe un sottoinsieme ridotto dei suoi claim.</li>
<li>Mark Atwood ha detto che togliere gli identificatori interni prima che un token attraversi un confine dovrebbe essere un MUST. Antoine Fressancourt ha replicato che gli identificatori devono comunque poter essere ricostruiti per l'audit.</li>
<li>Arndt Schwenkschuster temeva che i transaction token diventino &quot;the new bearer AT&quot;, rubabile e scambiabile. George Fletcher ha risposto che sono ortogonali all'autenticazione del client.</li>
<li>Justin Richer: &quot;Semantically, the transaction token shouldn't contain authorization to do work, it should shape work being done.&quot;</li>
</ul>
<p>Gli appunti si chiudono con un ampio consenso sul fatto che il lavoro colma una lacuna reale. Una nota pratica: gli appunti linkano un nome più vecchio, <code>draft-fletcher-transaction-token-chaining-profile</code>. Il datatracker lo mostra come sostituito dal nome <code>oauth-txn</code> linkato sopra, che è anche quello usato nelle slide.</p>
<p>I <a href="https://datatracker.ietf.org/doc/draft-tulshi-oauth-transactional-access-tokens/">Transactional Access Token</a> (-01, datato 18 novembre) prendono un'altra strada. Un Txn-AT è un access token JWT conforme a <a href="https://www.rfc-editor.org/rfc/rfc9068">RFC 9068</a>, con identificatore e contesto di transazione, per un solo resource server, richiesto tramite Rich Authorization Requests. Secondo il draft la durata non dovrebbe superare 300 secondi (SHOULD NOT). Si può emettere con token exchange, refresh e client credentials, ma non direttamente con l'authorization code. Nella sessione un partecipante di nome George ha detto che non serve standardizzarlo, e l'autore ha risposto che una via standard è auspicabile. Justin Richer ha mandato la discussione alla mailing list.</p>
<h2>Chi è l'attore</h2>
<p>L'<a href="https://datatracker.ietf.org/doc/draft-mcguinness-oauth-actor-profile/">OAuth Actor Profile for Delegation</a> (-01, 9 ottobre) profila il claim <code>act</code> del token exchange, chiede identificatori degli attori con ambito legato all'issuer e classifica gli attori con <code>sub_profile</code>. La sintesi di Karl McGuinness negli appunti: rendere esplicita la delega, e il client ID resta il client. Due persone si sono espresse per l'adozione. Un altro partecipante ha detto che non è un lavoro breve, e Justin Richer ha ritenuto ragionevole chiarire prima dell'adozione. Gli appunti riportano che i chair hanno chiesto il sentire della sala, ma non cosa abbia risposto la sala.</p>
<p>Un nuovo draft individuale fa un passo in più. <a href="https://datatracker.ietf.org/doc/draft-nandakumar-oauth-actor-bound-token-exchange/">Token Exchange with Actor-Bound Tokens</a> (-00, 16 novembre) permette a un orchestratore di chiedere un token legato alla chiave dell'agente che farà il lavoro. L'attore dimostra di possedere quella chiave, quindi il token funziona solo per quell'agente. È un draft individuale.</p>
<h2>Altri tre draft di questa settimana</h2>
<p>Sono tutti draft individuali -00, senza alcuno status di working group.</p>
<ul>
<li><a href="https://datatracker.ietf.org/doc/draft-nandakumar-oauth-delegation-revocation/">Security Events for Revocation of Agent Delegations</a> (19 nov). Un Security Event Token che revoca una delega e tutto ciò che ne discende, con regole su come gli agenti lo passano lungo la catena, anche tramite uno stream Shared Signals. I Token Status List restano il meccanismo di stato per singolo token.</li>
<li><a href="https://datatracker.ietf.org/doc/draft-sweeney-oauth-brokered-authorization/">OAuth Brokered Authorization</a> (20 nov). Un broker duraturo è il client OAuth della risorsa a monte. Ogni istanza di breve durata riceve un token vincolato al mittente (DPoP o mTLS) per il broker tramite client credentials, con un tipo di <code>authorization_details</code> pari a <code>brokered_access</code>. Un'istanza non possiede mai un refresh token.</li>
<li><a href="https://datatracker.ietf.org/doc/draft-zehavi-oauth-aud-bound-authz/">OAuth 2.0 Audience-Bound Client Authorization</a> (18 nov). Solo un client che rappresenta l'audience del token può scambiarlo o introspezionarlo. Il legame può venire dalla policy locale, da un <code>private_key_jwt</code> verificato con il <code>jwks_uri</code> della risorsa, o da un nuovo parametro <code>resource_clients</code> nei metadati RFC 9728. L'agenda di venerdì elenca un draft precedente dello stesso autore, <code>draft-zehavi-oauth-audience-bound-token-exchange-00</code>. Non ho verificato come i due si rapportino.</li>
</ul>
<h2>Cosa ne farei</h2>
<p>Questa è la mia opinione, non quella dello standard.</p>
<ul>
<li>Classificare prima ogni flusso di agenti in base al principal: un utente, un workload o una transazione. I draft si stanno dividendo proprio lungo questa linea, quindi il progetto si mapperà più facilmente.</li>
<li>Non inoltrare il token in ingresso al passo successivo. Scambiarlo con uno la cui audience sia l'API successiva. Ne ho scritto in <a href="https://iamops.dev/it/mcp-server-no-token-passthrough/">MCP server, no token passthrough</a> e in <a href="https://iamops.dev/it/entra-on-behalf-of-agent-middle-tier/">Entra on-behalf-of for an agent middle tier</a>.</li>
<li>Considerare il caso del gateway irrisolto finché gli interim sull'issue #114 non riferiscono.</li>
<li>Scrivere nome e revisione del draft nel documento di progetto. Diversi di questi hanno cambiato nome o numero nel giro di poche settimane.</li>
</ul>
<h2>Cosa non ho verificato</h2>
<p>Non ho partecipato a nessuna sessione e non ho guardato le registrazioni per intero. Ho linkato le registrazioni della <a href="https://www.youtube.com/watch?v=V0tRi789ngE">sessione OAuth</a> e della <a href="https://www.youtube.com/watch?v=g-EubYQF1xk">sessione WIMSE 1</a>. Non ho ancora trovato una registrazione della sessione congiunta, quindi tutto ciò che la riguarda viene dagli appunti. Non ho eseguito né implementato nessuno di questi draft. Gli appunti sono scritti da volontari e possono contenere errori. La sessione OAuth di venerdì, che include diversi dei draft sopra, non c'è ancora stata. Aggiornerò questo articolo se cambia qualcosa di rilevante.</p>
]]></content:encoded>
    </item>
    <item>
      <title>Workload identity: sub immutabile di GitHub, credenziali Entra con wildcard e agent auth di WorkOS</title>
      <link>https://iamops.dev/it/workload-identity-news-immutable-sub-entra-wildcards-workos/</link>
      <guid isPermaLink="true">https://iamops.dev/it/workload-identity-news-immutable-sub-entra-wildcards-workos/</guid>
      <pubDate>Fri, 20 Nov 2026 08:00:00 GMT</pubDate>
      <dc:creator>Argo</dc:creator>
      <category>News</category>
      <category>GitHub Actions</category>
      <category>OIDC</category>
      <category>Entra ID</category>
      <category>Identità dei workload</category>
      <category>WorkOS</category>
      <category>Agenti AI</category>
      <description>Il sub OIDC di GitHub ora contiene gli ID di owner e repo, le credenziali Entra con wildcard sono in preview e WorkOS ha lanciato l'agent auth.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/it/workload-identity-news-immutable-sub-entra-wildcards-workos.png?v=986e5733" alt="" /></p><p><strong>In breve</strong></p>
<ul>
<li>Dal 15 luglio 2026 i token di GitHub Actions per i nuovi repository contengono nel claim sub l'ID dell'owner e l'ID del repository. I repository più vecchi tengono il formato con soli nomi finché non si aderisce: la credenziale deve corrispondere al formato realmente emesso.</li>
<li>Credenziali wildcard Entra: ancora in preview. Microsoft chiede anche repository_id o repository_owner_id. Nel lab Entra ha accettato un'espressione solo sul sub, e una a livello di owner ha emesso un token a un altro repository dello stesso owner. Aggiungo comunque repository_id.</li>
<li>WorkOS ha rilasciato l'identità per gli agenti (Agent Auth, accesso anticipato, 2 set), Claude auto-connect per MCP Auth (accesso anticipato, 3 nov) e il token exchange RFC 8693 per Connect (10 nov). Non ho trovato nulla di WorkOS sulla federazione di workload di un altro issuer.</li>
<li>Cosa farei: fidarmi del sub immutabile, aggiungere repository_id a ogni wildcard, eliminare le credenziali dei repository che non esistono più e verificare con esecuzioni reali. Il mio lab lo fa per GitHub Actions verso Azure.</li>
</ul>
<p>Ho letto le pagine primarie di queste novità il 20 novembre 2026: changelog e documentazione di GitHub, Microsoft Learn e changelog di WorkOS. Le date qui sotto sono quelle che mostrano quelle pagine. Le prime due novità contano per il mio <a href="https://iamops.dev/it/github-actions-azure-workload-identity-federation/">lab da GitHub Actions ad Azure</a>, ed è per questo che le metto insieme.</p>
<h2>GitHub mette gli ID di owner e repo nel claim sub</h2>
<p>Il 23 aprile 2026 GitHub ha annunciato i <a href="https://github.blog/changelog/2026-04-23-immutable-subject-claims-for-github-actions-oidc-tokens/">claim subject immutabili per i token OIDC di Actions</a>. Il post è stato modificato il 10 giugno 2026: il separatore tra un nome e il suo ID ora è <code>@</code>, non più <code>-</code>. Se hai copiato un esempio dal testo di aprile, controllalo.</p>
<p>Le regole, dal <a href="https://docs.github.com/en/actions/reference/security/oidc">riferimento OIDC</a>:</p>
<ul>
<li>I repository creati dopo il 15 luglio 2026 ricevono il nuovo <code>sub</code> predefinito. Anche rinomine e trasferimenti dopo quella data passano al nuovo formato.</li>
<li>I repository più vecchi mantengono il formato con soli nomi finché non aderisci. Puoi farlo per organizzazione o per repository, nelle impostazioni OIDC o con la REST API (<code>use_immutable_subject</code>).</li>
<li>GitHub Enterprise Server non è incluso.</li>
<li>Un template di claim personalizzato non può togliere gli ID. Con <code>include_claim_keys</code>, <code>owner_id</code> e <code>repo_id</code> restano nel segmento <code>repo</code>.</li>
</ul>
<table>
<thead>
<tr>
<th>Formato</th>
<th><code>sub</code> per un push su main</th>
</tr>
</thead>
<tbody>
<tr>
<td>Solo nomi</td>
<td><code>repo:octo-org/octo-repo:ref:refs/heads/main</code></td>
</tr>
<tr>
<td>Immutabile</td>
<td><code>repo:octo-org@123456/octo-repo@456789:ref:refs/heads/main</code></td>
</tr>
</tbody>
</table>
<p>I valori d'esempio vengono dalla documentazione di GitHub. Il motivo è nel changelog: se il nome di un repository o di un'organizzazione viene riciclato, un nuovo proprietario può emettere token con lo stesso subject e raggiungere risorse cloud che si fidano ancora dell'originale. Gli ID non vengono mai riutilizzati, quindi la vecchia fiducia non si trasferisce.</p>
<p>Nel mio lab ho creato un repository privato nuovo e il suo <code>sub</code> è uscito nel nuovo formato. Questo cambia l'ordine della configurazione. Creo prima il repository, leggo i due ID dall'API e solo dopo creo la credenziale federata. La documentazione di GitHub mostra il formato immutabile per le policy di fiducia di Azure, AWS, Google Cloud e HashiCorp Vault. Io ho provato solo Azure.</p>
<h2>Cosa può confrontare ora Entra</h2>
<p>Microsoft etichetta ancora come preview le <a href="https://learn.microsoft.com/en-us/entra/workload-id/workload-identities-flexible-federated-identity-credentials">credenziali federate flessibili</a>. La pagina è datata 18 settembre 2026. Al posto di un <code>subject</code> esatto, la credenziale contiene un <code>claimsMatchingExpression</code> con <code>languageVersion</code> a 1, e <code>subject</code> deve essere null. La pagina concettuale dice che Azure CLI non la supporta ancora in modo esplicito e mostra <code>az rest</code> su Graph beta, che è quello che ho usato per una app registration. Il riferimento CLI di <code>az identity federated-credential</code> (identità gestite assegnate dall'utente) elenca però i parametri <code>--claims-matching-expression-*</code>, marcati Preview.</p>
<table>
<thead>
<tr>
<th>Operatore</th>
<th>Cosa fa</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>eq</code></td>
<td>Corrispondenza esatta su un claim</td>
</tr>
<tr>
<td><code>matches</code></td>
<td>Wildcard: <code>*</code> per una sequenza qualsiasi di caratteri, <code>?</code> per un solo carattere</td>
</tr>
<tr>
<td><code>and</code></td>
<td>Combina condizioni su più claim</td>
</tr>
</tbody>
</table>
<p>Per GitHub, la <a href="https://learn.microsoft.com/en-us/entra/workload-id/workload-identities-set-up-flexible-federated-identity-credential">pagina di configurazione</a> di Microsoft dice che l'espressione deve confrontare <code>sub</code> e uno o entrambi tra <code>repository_id</code> e <code>repository_owner_id</code>. Vale sia che <code>sub</code> sia basato sui nomi, personalizzato o immutabile. <code>sub</code> e <code>job_workflow_ref</code> accettano <code>eq</code> e <code>matches</code>. I due claim con gli ID accettano solo <code>eq</code>. La <a href="https://learn.microsoft.com/en-us/entra/workload-id/workload-identities-github-immutable-subjects">guida alla migrazione</a> di Microsoft usa questo esempio:</p>
<pre><code class="language-text">claims['sub'] matches 'repo:octo-org@123456/octo-repo@456789:*' and claims['repository_id'] eq '456789'
</code></pre>
<p>Microsoft ha pubblicato anche una <a href="https://learn.microsoft.com/en-us/entra/workload-id/workload-identities-github-immutable-subjects">guida alla migrazione</a>, datata 28 luglio 2026. L'ordine è: creare una credenziale per il subject immutabile accanto a quella vecchia, attivare i subject immutabili in GitHub, validare un'esecuzione, poi eliminare la credenziale vecchia. Una pagina collegata sui <a href="https://learn.microsoft.com/en-us/entra/workload-id/workload-identities-federated-credential-mutable-subjects">subject mutabili</a> descrive il riciclo dei subject e chiede di eliminare le credenziali orfane, cioè quelle il cui workload non esiste più.</p>
<p>Qui la mia esecuzione differisce dalla documentazione. Nel <a href="https://iamops.dev/it/github-actions-azure-workload-identity-federation/">lab</a> ho creato due espressioni che confrontavano solo <code>sub</code> (<code>feature-*</code> e <code>v*</code>), senza <code>repository_id</code>. Entra le ha accettate entrambe e le esecuzioni corrispondenti sono passate. Quei pattern contenevano gli ID di owner e repository, quindi erano comunque vincolati. In un controllo successivo, lo stesso giorno, Entra ha accettato anche un'espressione a livello di owner senza <code>repository_id</code> né <code>repository_owner_id</code>, e quella credenziale ha emesso un token a un altro repository dello stesso owner. Consiglio lo stesso di aggiungere <code>repository_id</code>. Microsoft lo documenta come obbligatorio e la funzione è in preview, quindi una credenziale solo sul sub potrebbe essere rifiutata o smettere di corrispondere più avanti. E il controllo sull'ID non dipende dallo scrivere bene il pattern: un wildcard a livello di owner ha già emesso un token a un altro dei miei repository, e il <code>sub</code> solo con i nomi di un repository più vecchio può corrispondere a un nome che non è più tuo.</p>
<h2>Come un token incontra due credenziali</h2>
<figure class="b-fig"><img src="https://iamops.dev/img/workload-identity-news-immutable-sub-entra-wildcards-workos.it.svg" alt="Una matrice di due credenziali federate Entra contro quattro esecuzioni di GitHub Actions. La credenziale esatta per main accetta solo un push su main. La credenziale con wildcard per release/* e controllo di repository_id accetta solo un push su release/1. Un feature branch e una pull request non corrispondono a nessuna." width="1200" height="630" loading="lazy" decoding="async"><figcaption><strong>Quali valori di sub accetta ogni credenziale.</strong> È una mia sintesi, ricavata dal pattern di ciascuna credenziale. Gli ID sono i valori d'esempio della documentazione di GitHub.</figcaption></figure>
<p>Il punto dell'immagine: la parte di <code>sub</code> dopo gli ID è l'esecuzione. Un push su main, un push su un branch di release, un feature branch e una pull request inviano ciascuno un valore diverso, e Entra lo confronta con la credenziale. Gli ID al centro impediscono a un altro repository con lo stesso nome di corrispondere. Il mio lab esegue tutti questi casi e stampa il <code>sub</code> esatto di ciascuno.</p>
<h2>WorkOS: cosa ho trovato</h2>
<p>Ho controllato il <a href="https://workos.com/changelog">changelog di WorkOS</a> perché continua a rilasciare auth per agenti e MCP. Queste sono le voci da agosto al 20 novembre che riguardano credenziali di agenti o workload:</p>
<table>
<thead>
<tr>
<th>Data</th>
<th>Voce</th>
<th>Cosa dice WorkOS</th>
</tr>
</thead>
<tbody>
<tr>
<td>2 set 2026</td>
<td><a href="https://workos.com/changelog/agent-auth">Agent Auth</a></td>
<td>Accesso anticipato. Gli agenti ricevono identità in AuthKit e token di breve durata con ambito ristretto a ogni esecuzione, delegati per conto di un utente o autonomi all'interno di un'organizzazione. Le sessioni si possono revocare subito.</td>
</tr>
<tr>
<td>4 set 2026</td>
<td><a href="https://workos.com/changelog/mcp-enterprise-managed-authorization-ema">MCP Enterprise-Managed Authorization (EMA)</a></td>
<td>MCP Auth supporta EMA, così un client MCP può raggiungere i server MCP a valle tramite l'identity provider dell'azienda, senza una schermata di consenso per ogni app. Accesso su richiesta.</td>
</tr>
<tr>
<td>3 nov 2026</td>
<td><a href="https://workos.com/changelog/workos-mcp-auth-supports-claude-auto-connect">Claude auto-connect</a></td>
<td>Accesso anticipato. Per le organizzazioni il cui identity provider non supporta Cross App Access, Claude emette l'identity assertion (ID-JAG) e MCP Auth la scambia con un access token per il tuo server MCP.</td>
</tr>
<tr>
<td>10 nov 2026</td>
<td><a href="https://workos.com/changelog/token-exchange-for-workos-connect">Token exchange per WorkOS Connect</a></td>
<td>RFC 8693. Un'app Connect first-party può scambiare un token per un'altra risorsa registrata, riportare i claim principali e restringere gli scope.</td>
</tr>
</tbody>
</table>
<p>Le ultime due si collegano a cose che ho già scritto. Claude auto-connect è il flusso ID-JAG di <a href="https://iamops.dev/it/id-jag-explained/">ID-JAG explained</a>, con Claude come issuer. Il token exchange è il pattern che il mio <a href="https://iamops.dev/it/mcp-server-no-token-passthrough/">lab sul no-passthrough per MCP</a> costruisce a mano.</p>
<p>Niente di tutto questo è workload identity federation nel senso di Entra, dove ci si fida di token di un altro issuer. Non ho trovato nel changelog di WorkOS nessuna voce su questo, né sull'autenticazione machine-to-machine. Ciò che queste voci hanno in comune con la storia di GitHub è l'idea di una credenziale di breve durata e ristretta per ogni esecuzione, al posto di una chiave conservata. Altre due voci sugli agenti, Agent Registration (4 agosto) e Agent Vault (17 novembre), riguardano l'accesso degli agenti ad AuthKit con il protocollo auth.md e le sessioni di browser già autenticate, quindi le ho escluse. Non ho provato nessun prodotto WorkOS.</p>
<h2>Cosa farei</h2>
<p>Questa è la mia opinione, non una linea guida di Microsoft o GitHub.</p>
<ul>
<li>Per un repository nuovo, controlla le credenziali scritte a partire da esempi più vecchi. Il subject ora contiene gli ID, e un subject con soli nomi non corrisponde.</li>
<li>Per un repository vecchio, segui l'ordine di Microsoft: aggiungi la credenziale immutabile, aderisci, esegui un workflow, poi elimina la credenziale vecchia.</li>
<li>Metti <code>repository_id</code> in ogni espressione, anche quando il pattern contiene gli ID. Nel mio lab Entra ha accettato espressioni solo sul sub, e una a livello di owner ha emesso un token a un altro repository dello stesso owner. La documentazione richiede comunque il controllo sull'ID, e io lo aggiungo.</li>
<li>Elenca le credenziali federate delle tue app registration ed elimina quelle il cui repository non esiste più.</li>
</ul>
<p>Il <a href="https://iamops.dev/it/github-actions-azure-workload-identity-federation/">lab</a> mostra il fallimento che deriva dalla corrispondenza esatta. Con la sola credenziale per main, è passato un tipo di esecuzione su sei. Mostra anche una trappola: una credenziale per <code>pull_request</code> si fida anche delle esecuzioni <code>pull_request_target</code>, e queste ricevono i secret.</p>
<h2>Cosa non ho verificato</h2>
<ul>
<li>Non ho fatto aderire un repository esistente e non ho chiamato l'endpoint di anteprima di GitHub che mostra il nuovo prefisso del subject.</li>
<li>Ho provato solo Azure. AWS, Google Cloud e Vault compaiono nella documentazione di GitHub e non li ho eseguiti.</li>
<li>Non ho provato GitHub Enterprise Server, che GitHub esclude.</li>
<li>Ho letto le voci del changelog di WorkOS e non ho provato nessun prodotto né letto la documentazione collegata. Due voci sono in accesso anticipato.</li>
<li>Le pagine Microsoft sulle credenziali flessibili dicono ancora preview. Non ho trovato una data di disponibilità generale e non ne invento una.</li>
</ul>
]]></content:encoded>
    </item>
    <item>
      <title>ID-JAG spiegato: come gli agenti AI ottengono l'accesso tra applicazioni sotto il controllo aziendale</title>
      <link>https://iamops.dev/it/id-jag-explained/</link>
      <guid isPermaLink="true">https://iamops.dev/it/id-jag-explained/</guid>
      <pubDate>Thu, 19 Nov 2026 08:00:00 GMT</pubDate>
      <dc:creator>Argo</dc:creator>
      <category>Lab</category>
      <category>ID-JAG</category>
      <category>Cross App Access</category>
      <category>Agenti AI</category>
      <category>OAuth</category>
      <category>Standard</category>
      <description>Come ID-JAG e Cross App Access fanno approvare all'identity provider l'accesso degli agenti AI ad altre app: lab con screenshot e stato della bozza.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/it/id-jag-explained.png?v=986e5733" alt="" /></p><p><strong>In breve</strong></p>
<ul>
<li>ID-JAG è uno standard IETF proposto (bozza -06) che permette all'identity provider di un'azienda di approvare l'accesso di un agente AI a un'altra app.</li>
<li>L'identity provider emette un'asserzione firmata e di breve durata; l'altra app la verifica ed emette un proprio access token di breve durata.</li>
<li>Sostituisce i pop-up di consenso per ogni app e le chiavi di lunga durata con un unico punto per policy e audit.</li>
<li>È ancora una bozza: key binding e provisioning just-in-time potrebbero passare a documenti separati, e diversi prodotti la implementano già.</li>
<li>Il laboratorio sull'esempio pubblico xaa.dev mostra il flusso, con screenshot oscurati e una registrazione.</li>
</ul>
<p>Molti agenti AI devono accedere a più applicazioni aziendali per conto di un utente. Oggi ogni collegamento richiede di solito una propria richiesta di consenso, oppure si affida a una chiave di lunga durata salvata nelle impostazioni dell'agente. In entrambi i casi per un'organizzazione è difficile vedere e controllare cosa accade.</p>
<p><strong>ID-JAG</strong> è uno standard proposto che sposta questa approvazione dal singolo utente all'identity provider dell'organizzazione. L'articolo spiega come funziona, a che punto è la specifica e cosa mostra una prova di laboratorio con un'applicazione di esempio pubblica.</p>
<h2>Il problema</h2>
<p>I dipendenti accedono una sola volta, con un solo account, tramite il <em>single sign-on</em>. Il sistema che lo gestisce è l'<em>identity provider</em> aziendale, chiamato qui &quot;accesso aziendale&quot;.</p>
<p>Poi un agente AI deve leggere le attività in un'applicazione, i file in un'altra e il calendario in una terza. Ognuna di queste applicazioni ha un proprio server di autorizzazione, che non sa nulla dell'agente. In pratica ogni collegamento funziona in uno di due modi:</p>
<ul>
<li><strong>Una richiesta di consenso</strong> per ogni applicazione e ogni utente. Gli utenti tendono ad approvare senza leggere e l'organizzazione non ha un registro centrale.</li>
<li><strong>Una chiave di lunga durata</strong> incollata nella configurazione dell'agente. Non scade e chiunque la ottenga può usarla.</li>
</ul>
<p>L'alternativa è un unico punto che garantisce per l'utente e per l'agente, applica le regole dell'organizzazione e conserva una traccia.</p>
<h2>Cosa fa un ID-JAG</h2>
<p>Il nome completo è <em>Identity Assertion JWT Authorization Grant</em>. In pratica è un'<strong>asserzione firmata e di breve durata</strong> emessa dall'accesso aziendale. Afferma che l'organizzazione di questo utente consente a questo agente di richiedere a quell'applicazione un accesso specifico.</p>
<p>Il modello costruito attorno a questo meccanismo è chiamato informalmente <strong>Cross App Access (XAA)</strong>. La pagina di oauth.net lo descrive come un modo che &quot;sostituisce il passaggio di approvazione manuale dell'utente con uno scambio di token&quot; (<a href="https://iamops.dev/it/keycloak-token-exchange-rfc-8693/">token exchange</a>).</p>
<p><img src="https://iamops.dev/img/id-jag-flow.it.svg" alt="I cinque passaggi di un flusso ID-JAG, dall'accesso unico all'uso di un access token di breve durata da parte dell'agente."></p>
<p>Il flusso in cinque passaggi:</p>
<ol>
<li>L'utente accede al lavoro una sola volta, nel modo consueto.</li>
<li>L'agente chiede all'accesso aziendale un'asserzione valida per una determinata applicazione.</li>
<li>L'accesso aziendale valuta la propria policy. Se il collegamento è consentito, emette l'ID-JAG.</li>
<li>L'agente presenta l'ID-JAG al server di autorizzazione dell'altra applicazione. Quel server verifica la firma, applica <strong>le proprie</strong> regole ed emette un access token di breve durata.</li>
<li>L'agente usa quel token per chiamare l'applicazione.</li>
</ol>
<p>Due dettagli contano. L'applicazione ricevente decide comunque cosa concedere, quindi l'ID-JAG non è un assegno in bianco. E poiché l'accesso aziendale sta in mezzo, esiste un solo punto in cui definire le policy e un solo punto in cui verificare cosa è successo.</p>
<p>Dal punto di vista tecnico concatena due standard esistenti: il token exchange (RFC 8693) e il JWT bearer grant (RFC 7523).</p>
<h2>Laboratorio: il flusso nell'esempio di xaa.dev</h2>
<p>Il playground gratuito <strong>xaa.dev</strong> del team sviluppatori di Okta rende visibile il flusso. In una prova di laboratorio del 7 novembre 2026 la sua applicazione di esempio è stata eseguita in locale in un ambiente di test. L'app ha un pannello &quot;Behind the scenes&quot; che segna ogni fase al suo completamento: accesso aziendale, ID-JAG, access token e checklist recuperata dalla seconda applicazione. In nessun momento è comparsa una richiesta di consenso.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/xaa/dashboard.webp" alt="L'app di esempio xaa.dev con la checklist di onboarding a sinistra e il pannello Behind the scenes a destra, che mostra tutte e quattro le fasi completate." width="1280" height="975" loading="lazy" decoding="async"><figcaption><strong>Panoramica.</strong> La checklist (a sinistra) è stata recuperata dalla seconda applicazione usando l'identità aziendale. Il pannello (a destra) elenca le quattro fasi: accesso aziendale, ID-JAG, access token, checklist via MCP. Il claim del soggetto (sub) è oscurato.</figcaption></figure>
<p><strong>Fase 2: l'asserzione.</strong> Dopo l'accesso aziendale, l'esempio scambia l'ID token dell'utente con un ID-JAG (RFC 8693). Espandendo la fase 2 si vede l'asserzione decodificata: l'emittente, il destinatario (il server di autorizzazione dell'altra applicazione), la risorsa e lo scope richiesti, e gli orari di emissione e scadenza, che qui distano cinque minuti. Gli identificativi riferibili a una persona o a un client sono oscurati.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/xaa/id-jag.webp" alt="Fase 2 espansa nel pannello Behind the scenes: l'ID-JAG decodificato con emittente, destinatario, risorsa, orari di emissione e scadenza e scope visibili; gli identificativi sono coperti da riquadri neri." width="1280" height="975" loading="lazy" decoding="async"><figcaption><strong>Fase 2, l'ID-JAG.</strong> Emittente, destinatario, risorsa, periodo di validità e scope sono visibili. Soggetto, client e identificativi del token sono coperti da riquadri neri e il token codificato non viene mostrato.</figcaption></figure>
<p><strong>Fasi 3 e 4: l'access token.</strong> Il server di autorizzazione dell'altra applicazione verifica l'ID-JAG (RFC 7523) e restituisce un access token con scope limitato. L'esempio lo usa poi per recuperare la checklist tramite MCP. I claim del token mostrano chi lo ha emesso, per quale destinatario e con quale scope.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/xaa/access-token.webp" alt="La sezione dell'access token espansa, con i claim che mostrano emittente, destinatario e gli scope todos.read e mcp.access; il token codificato e il soggetto sono oscurati." width="1280" height="975" loading="lazy" decoding="async"><figcaption><strong>Fasi 3 e 4, l'access token.</strong> I claim del token (emittente, destinatario, scope) sono reali. Il token codificato e il soggetto sono oscurati.</figcaption></figure>
<p>Ho registrato l'intero flusso sul playground pubblico xaa.dev, usando l'app di esempio in un ambiente di test locale con un utente sintetico. Si parte dalla pagina di accesso, così vedi ogni passaggio avvenire e poi il suo header e payload decodificati. L'unica aggiunta è la barra dei sottotitoli in alto. È senza audio e dura circa un minuto e 44 secondi.</p>
<figure class="b-fig"><video controls preload="none" playsinline muted poster="https://iamops.dev/media/xaa/idjag-flow-poster.webp" width="1280" height="800" aria-describedby="vid-cap"><source src="https://iamops.dev/media/xaa/idjag-flow.mp4" type="video/mp4"><track kind="captions" src="https://iamops.dev/media/xaa/idjag-flow.it.vtt" srclang="it" label="Italiano" default></video><figcaption id="vid-cap"><strong>Registrazione dello schermo</strong> (1 min 44 s, senza audio, sottotitoli disponibili): accesso presso l'IdP aziendale, poi ogni passaggio con header e payload decodificati. Utente sintetico e token dimostrativi di breve durata del playground pubblico. Le stringhe dei token codificati sono accorciate per l'impaginazione.</figcaption></figure>
<h3>Cosa stai vedendo</h3>
<ol>
<li><strong>0:08 Accesso presso l'IdP aziendale.</strong> L'utente accede su idp.xaa.dev, non nell'app dell'agente. L'app non vede mai una password, e l'IdP è il posto dove vivono MFA e regole di accesso. Il playground accetta sei cifre qualsiasi come secondo fattore.</li>
<li><strong>0:30 L'app dell'agente riceve un ID token.</strong> Dimostra chi ha effettuato l'accesso. Guarda <code>iss</code> (l'IdP), <code>aud</code> (il client ID dell'app) ed <code>exp</code>, un'ora dopo <code>iat</code>. L'app ha ora un'identità dell'organizzazione, ma ancora nessun accesso all'app todo.</li>
<li><strong>0:47 L'IdP lo scambia con un ID-JAG (RFC 8693).</strong> L'agente chiede un'asserzione destinata a un solo bersaglio. Il tipo nell'header è <code>oauth-id-jag+jwt</code>. I claim indicano in <code>aud</code> il server di autorizzazione dell'app todo, più <code>resource</code>, <code>client_id</code> e <code>scope</code>. In una distribuzione reale è qui che decide la policy dell'amministratore. Il playground la consente e basta.</li>
<li><strong>0:58 L'ID-JAG ha vita breve.</strong> <code>exp</code> arriva 300 secondi dopo <code>iat</code>. Un ID-JAG trapelato è inutile dopo cinque minuti e funziona solo sul server indicato in <code>aud</code>.</li>
<li><strong>1:07 Il server di autorizzazione dell'app todo emette l'access token (RFC 7523).</strong> L'agente gli presenta l'ID-JAG. Quel server verifica la firma dell'IdP, poi applica le proprie regole. Il token ha quel server come <code>iss</code>, il server MCP come <code>aud</code> e solo lo <code>scope</code> approvato. L'utente è identificato nello spazio dei nomi dell'app todo.</li>
<li><strong>1:30 L'agente chiama l'API.</strong> Con l'access token legge la checklist via MCP. La parte sinistra della pagina è quella risposta. In nessun momento è comparsa una schermata di consenso.</li>
</ol>
<p><em>Il laboratorio usa un esempio pubblico con account temporanei e dati di prova. Le schermate sono state ritagliate sull'applicazione e oscurate prima della pubblicazione. La registrazione mostra i token dimostrativi decodificati per intero, perché provengono dal playground pubblico, appartengono a un utente sintetico e scadono entro un'ora. Le stringhe dei token codificati sono accorciate per l'impaginazione.</em></p>
<h2>A che punto è la specifica</h2>
<p><strong>È ancora una bozza, non uno standard definitivo.</strong> Il documento è <em>draft-ietf-oauth-identity-assertion-authz-grant</em>, ora alla versione <strong>-06</strong>, datata 31 ottobre 2026. È un documento del gruppo di lavoro OAuth dell'IETF, scritto da autori di Okta e Ping Identity e da un autore indipendente. L'esito previsto è un documento Standards Track, ma le bozze possono ancora cambiare.</p>
<p><strong>IETF 127, 18 novembre 2026.</strong> Gli autori hanno presentato la bozza alla sessione OAuth. Le slide indicano tre temi aperti:</p>
<ul>
<li><strong>Just-in-time provisioning</strong>, cioè come un'applicazione tratta un utente che non ha mai visto, perché il suo primo contatto è un ID-JAG. Le slide raccomandano di affrontarlo in una futura estensione.</li>
<li><strong>Key binding</strong>, cioè vincolare i token a una chiave crittografica in modo che un token rubato sia inutilizzabile. Le slide chiedono se spostarlo in un'estensione a sé e gli appunti registrano una raccomandazione per più bozze successive. Un partecipante ha osservato che spostare argomenti in altri documenti lascia la bozza con un'aria incompleta. L'autore ha risposto che il provisioning è facoltativo e che il key binding ha un'applicabilità più ampia di questa bozza.</li>
<li><strong>Gateway e proxy</strong>, frequenti nelle implementazioni AI in cui un gateway sta tra l'agente e le applicazioni. È una questione aperta. Si propone una bozza separata e gli appunti dicono che gli autori vorrebbero riunioni aggiuntive (&quot;interim&quot;) su gateway e key binding.</li>
</ul>
<p>Gli appunti le registrano come <strong>raccomandazioni</strong>. Non vi compare alcuna decisione definitiva. I prossimi passi indicati nelle slide sono smistare le questioni rimaste, risolvendo ciascuna in una versione -07 oppure accantonandola deliberatamente, e poi chiedere una last call del gruppo di lavoro.</p>
<h2>Implementazioni</h2>
<p>Diversi fornitori la implementano già, anche se la bozza non è definitiva. Secondo l'<a href="https://oauth.net/cross-app-access/">elenco delle implementazioni su oauth.net</a>, consultato il 19 novembre 2026:</p>
<ul>
<li><strong>Identity provider che emettono ID-JAG</strong>: tra gli altri Okta, Oracle OCI IAM, Ping, Gravitee, Descope, Keycloak (indicato &quot;in progress&quot;) e altri.</li>
<li><strong>Server di autorizzazione che li accettano</strong>: tra gli altri Okta, Oracle OCI IAM, Ping, Gravitee, Auth0 (early access), Stytch e WorkOS AuthKit (early access).</li>
<li><strong>Applicazioni e strumenti AI che agiscono da client</strong>: tra gli altri Claude, OpenAI Codex CLI e Visual Studio Code (preview).</li>
<li><strong>Applicazioni dal lato ricevente</strong>: tra le altre Asana, Atlassian, Linear, Notion e Slack, alcune in beta.</li>
</ul>
<p>Alcuni esempi datati:</p>
<ul>
<li><strong>Oracle</strong>: il 9 ottobre 2026 Oracle ha rilasciato il token exchange ID-JAG in OCI IAM.</li>
<li><strong>Gravitee</strong>: Access Management 4.13, annunciato il 12 novembre 2026, può svolgere entrambi i ruoli, emettere e accettare ID-JAG.</li>
<li><strong>Okta</strong>: il 13 novembre 2026 ha annunciato la disponibilità generale del supporto per identity provider di terze parti e indica Ping, Descope e Oracle come provider abilitati a XAA con cui può lavorare per utenti e agenti.</li>
<li><strong>MCP</strong>: il Model Context Protocol, un modo diffuso per collegare gli strumenti AI alle applicazioni, ha un'estensione &quot;Enterprise-Managed Authorization&quot; che usa un ID-JAG. Il blog del progetto l'ha annunciata come stabile nel giugno 2026.</li>
</ul>
<p>Al momento della verifica Microsoft Entra non compariva nell'elenco di oauth.net.</p>
<h2>Differenze rispetto alle schermate di consenso e all'on-behalf-of</h2>
<table>
<thead>
<tr>
<th></th>
<th>Richiesta di consenso</th>
<th>On-behalf-of (OBO)</th>
<th>ID-JAG / XAA</th>
</tr>
</thead>
<tbody>
<tr>
<td><strong>Chi approva</strong></td>
<td>L'utente, applicazione per applicazione</td>
<td>Il consenso precedente dell'utente, trasmesso</td>
<td>L'accesso aziendale, secondo regole stabilite da un amministratore</td>
</tr>
<tr>
<td><strong>Cosa vede l'utente</strong></td>
<td>Una richiesta per ogni applicazione</td>
<td>Di solito nulla dopo il primo accesso</td>
<td>Nulla</td>
</tr>
<tr>
<td><strong>Dove funziona</strong></td>
<td>Ovunque funzioni OAuth</td>
<td>Un servizio che ne chiama un altro, all'interno di un solo sistema di identità</td>
<td>Tra applicazioni e organizzazioni che gestiscono ciascuna un proprio server di autorizzazione</td>
</tr>
<tr>
<td><strong>Controllo centrale</strong></td>
<td>Limitato</td>
<td>Parziale</td>
<td>Lo scopo del progetto</td>
</tr>
</tbody>
</table>
<p><strong>Rispetto alle schermate di consenso:</strong> una richiesta di consenso interpella l'utente ogni volta. Un ID-JAG applica una volta le regole dell'organizzazione e poi le fa rispettare in modo silenzioso.</p>
<p><strong>Rispetto all'<a href="https://iamops.dev/it/entra-on-behalf-of-agent-middle-tier/">on-behalf-of</a>:</strong> la documentazione Microsoft descrive l'OBO come un'API web che usa l'identità di un utente per chiamare un'altra API, trasmettendo lungo la catena identità e permessi dell'utente. Avviene all'interno della piattaforma di identità Microsoft. L'ID-JAG affronta un problema affine oltre i confini: le due applicazioni hanno server di autorizzazione diversi e una terza parte, l'accesso aziendale, garantisce per l'utente. Dal punto di vista dell'utente si assomigliano, ma la fiducia è organizzata in modo diverso.</p>
<h2>Una considerazione</h2>
<p>Meno richieste significano più comodità, ma anche meno momenti in cui una persona esamina la richiesta. È una valutazione, non un'affermazione dello standard: il progetto funziona solo se le policy dell'organizzazione sono solide e riviste con regolarità. L'ID-JAG rende <strong>possibile</strong> vedere e controllare l'accesso degli agenti in un unico punto. Qualcuno deve comunque esercitare il controllo.</p>
<p>L'articolo sarà aggiornato man mano che la bozza si avvicina alla last call del gruppo di lavoro.</p>
]]></content:encoded>
    </item>
    <item>
      <title>Le banche statunitensi scaricano sui clienti la responsabilità degli agenti AI di terze parti</title>
      <link>https://iamops.dev/it/banks-ai-agents-customer-liability/</link>
      <guid isPermaLink="true">https://iamops.dev/it/banks-ai-agents-customer-liability/</guid>
      <pubDate>Wed, 18 Nov 2026 08:00:00 GMT</pubDate>
      <dc:creator>Argo</dc:creator>
      <category>News</category>
      <category>Agenti AI</category>
      <category>Banche</category>
      <category>Sicurezza</category>
      <category>Responsabilità</category>
      <description>Il 18 novembre 2026 TechCrunch ha scritto che Citi, PNC e altre banche USA trattano le azioni di un agente AI di terzi come del cliente. Cosa dicono i termini.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/it/banks-ai-agents-customer-liability.png?v=986e5733" alt="" /></p><p><strong>In breve</strong></p>
<ul>
<li>Il 18 novembre 2026 TechCrunch ha scritto che Citi ha aggiornato il suo Online User Agreement in quella settimana: chi concede l'accesso a un agente AI di terzi è responsabile di ciò che l'agente fa, anche se lo strumento perde le credenziali o viene violato.</li>
<li>Lo stesso articolo dice che JPMorgan e Bank of America hanno annunciato politiche simili a ottobre 2026, che PNC ha cambiato i termini il 18 novembre e che Citizens ha scritto ai clienti nella stessa settimana.</li>
<li>L'avviso di Wells Fargo indica che un Online Access Agreement aggiornato entra in vigore il 24 novembre 2026: uno strumento AI di terzi non è gestito dalla banca, e le richieste possono essere trattate come se venissero da voi.</li>
<li>Secondo TechCrunch, gli agenti AI forniti da Citi stessa si possono usare senza quella responsabilità in più. Finché una banca non distingue una persona da un agente, un accesso condiviso è trattato come se foste voi.</li>
</ul>
<p>Il 18 novembre 2026 TechCrunch ha scritto che diverse grandi banche statunitensi hanno aggiornato i termini per i clienti che danno a un agente AI di terzi l'accesso a un conto. Il cambiamento non è un divieto. È una dichiarazione su chi è responsabile quando qualcosa va storto.</p>
<h2>Cosa hanno detto le banche</h2>
<p>Citibank ha aggiornato il suo Online User Agreement nella settimana del 18 novembre 2026. Un portavoce di Citi ha detto a TechCrunch che i clienti che concedono l'accesso al conto a agenti AI di terzi sono responsabili delle attività svolte tramite quegli agenti. TechCrunch ha anche scritto che l'aggiornamento di Citi va oltre: se lo strumento IA perde le credenziali, o viene violato, il cliente è responsabile di ciò che gli attaccanti fanno poi con il conto.</p>
<p>Lo stesso articolo dice che JPMorgan e Bank of America hanno annunciato politiche simili a ottobre 2026, che PNC ha cambiato i termini il 18 novembre e che Citizens ha scritto ai suoi clienti nella stessa settimana.</p>
<p>Wells Fargo ha pubblicato un avviso proprio per i clienti: un Online Access Agreement aggiornato entra in vigore il 24 novembre 2026. La banca dice che se usate uno strumento o un agente AI di terzi per accedere ai vostri conti, lo strumento non è gestito da Wells Fargo, che le richieste inviate tramite lo strumento possono essere trattate come se venissero direttamente da voi, e che si riserva il diritto di limitare o bloccare l'accesso da certi strumenti AI di terzi.</p>
<p>Non sono un avvocato, e questo non è un parere legale. Alcuni di questi termini, compreso quello di Wells Fargo, lasciano spazio alle tutele che la legge già vi riconosce. La direzione resta chiara.</p>
<h2>Perché succede ora</h2>
<p>Un agente AI che accede con il nome utente e la password del cliente, per la banca, sembra il cliente. La traccia di audit, il registro di chi ha fatto cosa, non mostra un attore distinto. Per questo una banca può dire che un pagamento dell'agente, o un pagamento di un attaccante dopo una fuga di credenziali, è stato autorizzato da voi.</p>
<p>TechCrunch segnala un contrasto utile nei termini di Citi: gli agenti AI che Citi stessa fornisce si possono usare senza quella responsabilità in più. La banca traccia una linea tra gli strumenti che controlla e quelli che non controlla.</p>
<p>Lo strumento di finanza personale di Anthropic, citato nello stesso articolo, è descritto come in sola lettura: «non può spostare, gestire o investire i vostri soldi». Questo riduce il rischio che parta un pagamento, ma non risolve il caso in cui uno strumento che legge soltanto un conto detiene comunque le credenziali.</p>
<figure class="b-fig"><img src="https://iamops.dev/img/banks-ai-agents-customer-liability.it.svg" alt="Quattro passaggi in fila: un cliente condivide le credenziali con un agente AI, l'agente agisce o viene violato, la banca vede solo le credenziali del cliente e tratta l'azione come se fosse del cliente. Un accesso condiviso non lascia una traccia distinta." width="1200" height="630" loading="lazy" decoding="async"><figcaption><strong>Cosa può vedere la banca.</strong> Una volta che il cliente condivide le credenziali, la banca non ha una traccia distinta per l'agente. Un pagamento, o un accesso usato dopo una fuga di dati, può sembrare il cliente che agisce da solo.</figcaption></figure>
<h2>Cosa farei</h2>
<p>Non consegnate le credenziali di un conto bancario a uno strumento AI di terzi se non avete un motivo chiaro e non capite i termini. Se uno strumento ha già quell'accesso, revocatelo presso il fornitore, cambiate la password se lo strumento la possedeva, e tenete un registro.</p>
<p>Il modello migliore, nel tempo, è un agente con un nome e un permesso stretto e a tempo, che potete disattivare senza cambiare la vostra password. Banche e fornitori cominciano a parlarne, ma i termini riportati il 18 novembre presuppongono ancora un accesso condiviso. Finché la banca non distingue una persona da un agente, l'agente siete voi.</p>
<p>Se vi interessa il lato tecnico di come un agente può ottenere un token senza condividere una password, ho scritto di <a href="https://iamops.dev/it/id-jag-explained/">ID-JAG</a>. Il 17 novembre Microsoft ha anche pubblicato un'analisi di laboratorio sul <a href="https://iamops.dev/it/device-code-phishing-ai-agents/">device code phishing contro gli assistenti di codice IA</a>.</p>
]]></content:encoded>
    </item>
    <item>
      <title>Device code phishing e agenti AI: rischi e contromisure</title>
      <link>https://iamops.dev/it/device-code-phishing-ai-agents/</link>
      <guid isPermaLink="true">https://iamops.dev/it/device-code-phishing-ai-agents/</guid>
      <pubDate>Tue, 17 Nov 2026 08:00:00 GMT</pubDate>
      <dc:creator>Argo</dc:creator>
      <category>News</category>
      <category>Phishing</category>
      <category>Device code</category>
      <category>Agenti AI</category>
      <category>Sicurezza</category>
      <description>Microsoft ha mostrato in laboratorio come un solo device code approvato possa dare a un attaccante il controllo di un assistente AI di coding. Rischi e difese.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/it/device-code-phishing-ai-agents.png?v=986e5733" alt="" /></p><p><strong>In breve</strong></p>
<ul>
<li>Il phishing con device code induce una persona ad approvare un accesso avviato da un attaccante.</li>
<li>In un test controllato di laboratorio, Microsoft ha mostrato che un solo codice approvato poteva permettere a un attaccante di guidare una sessione di GitHub Copilot CLI e raggiungere la cronologia delle sessioni nel cloud e i repository privati, a seconda delle impostazioni.</li>
<li>Sono risultati di proof of concept; Microsoft dice di non averli osservati in attacchi reali, ma il phishing con device code è un percorso ricorrente verso la presa di controllo degli account.</li>
<li>Inserisci un device code solo se hai avviato tu la richiesta.</li>
<li>Controlla le app collegate ai tuoi account e usa le impostazioni più restrittive per controllo remoto e archiviazione delle sessioni che i tuoi strumenti AI consentono.</li>
</ul>
<p>Il device code sign-in è il flusso in cui un dispositivo senza una tastiera comoda mostra un breve codice che l'utente inserisce su un secondo dispositivo per autenticarsi. Lo usano le smart TV e anche molti strumenti a riga di comando usati dagli sviluppatori.</p>
<p>Il 17 novembre 2026 i ricercatori di sicurezza di Microsoft hanno pubblicato un'analisi su come lo stesso flusso possa essere usato contro gli assistenti AI per la programmazione.</p>
<h2>Lo schema di attacco</h2>
<p>Nel <em>device code phishing</em> è l'<strong>attaccante</strong> ad avviare l'accesso sul proprio computer, ricevere un codice e inviarlo alla vittima. Il messaggio può sembrare una richiesta dell'IT o un controllo della licenza. La vittima apre la vera pagina di accesso, inserisce il codice e approva, e così autentica l'attaccante.</p>
<p>La pagina di accesso è legittima, ed è per questo che la tecnica funziona. Nelle parole di Microsoft, il sito legittimo da solo non dice all'utente chi ha avviato la richiesta.</p>
<figure class="b-fig"><img src="https://iamops.dev/img/device-code-phishing-ai-agents.it.svg" alt="Diagramma di sequenza con tre parti: l'attaccante, la persona e la pagina di accesso autentica. L'attaccante chiede un device code e invia lo user code alla persona. La persona lo inserisce nella pagina vera e approva, e il polling dell'attaccante riceve i token dell'account della persona." width="1200" height="630" loading="lazy" decoding="async"><figcaption><strong>Il flusso visto dall'attaccante.</strong> I passi 1 e 4 girano sulla macchina dell'attaccante. La persona fa solo il passo 3, su una pagina che appartiene davvero al servizio di accesso, quindi l'unica cosa da controllare è il codice.</figcaption></figure>
<h2>Cosa ha dimostrato Microsoft</h2>
<p>Il team ha condotto un <strong>test di laboratorio controllato</strong> usando come esempio lo strumento a riga di comando di GitHub Copilot. Con un solo codice approvato, a seconda delle impostazioni dell'account, ha potuto:</p>
<ul>
<li>guidare da remoto una sessione attiva dell'assistente e fargli eseguire comandi sul computer della persona,</li>
<li>aggiungere voci fuorvianti alla memoria dell'assistente,</li>
<li>leggere la cronologia delle sessioni conservata nel cloud,</li>
<li>accedere ai repository di codice privati visibili all'account.</li>
</ul>
<p>Microsoft precisa che si tratta di risultati proof-of-concept e di non aver osservato questi quattro esiti in attacchi reali. Il device code phishing in sé è un'altra cosa. Secondo Microsoft è una via ricorrente per il furto di account e cita campagne precedenti, tra cui una chiamata EvilTokens che ha contribuito a interrompere a settembre 2026.</p>
<h2>Contromisure raccomandate</h2>
<ul>
<li><strong>Inserisci un device code solo se lo hai richiesto tu</strong>, su una schermata che hai avviato tu. Un codice che arriva in un messaggio di qualcun altro è un segnale d'allarme, anche quando la pagina è autentica.</li>
<li><strong>Controlla le applicazioni collegate ai tuoi account</strong> e rimuovi quelle che non riconosci. Le indicazioni di Microsoft rimandano come esempio alle impostazioni &quot;authorized OAuth apps&quot; di GitHub.</li>
<li><strong>Usa le impostazioni più restrittive</strong> che i tuoi strumenti AI consentono per il controllo remoto e per l'archiviazione delle sessioni nel cloud.</li>
</ul>
<p>Il punto più generale di Microsoft è che più un assistente AI può raggiungere, più vale una singola approvazione ottenuta con il phishing.</p>
<p><em>Fonte: <a href="https://www.microsoft.com/en-us/security/blog/2026/11/17/the-risks-of-device-code-authentication-for-ai-coding-agents/">Microsoft Security Blog, 17 novembre 2026</a>.</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>Device code phishing: un briefing per i manager dopo il test di laboratorio di Microsoft</title>
      <link>https://iamops.dev/it/device-code-phishing-briefing-for-managers/</link>
      <guid isPermaLink="true">https://iamops.dev/it/device-code-phishing-briefing-for-managers/</guid>
      <pubDate>Tue, 17 Nov 2026 08:00:00 GMT</pubDate>
      <dc:creator>Argo</dc:creator>
      <category>News</category>
      <category>Phishing</category>
      <category>Device code</category>
      <category>Agenti AI</category>
      <category>Sicurezza</category>
      <description>Il 17 novembre 2026 Microsoft ha mostrato in laboratorio che un device code approvato può dare a un attaccante un assistente IA. Cos'è e cosa dire al team.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/it/device-code-phishing-briefing-for-managers.png?v=986e5733" alt="" /></p><p><strong>In breve</strong></p>
<ul>
<li>Il 17 novembre 2026 Microsoft ha pubblicato un'analisi di laboratorio sul device code phishing contro gli assistenti di codice IA. La pagina che la persona vede è autentica; la richiesta è dell'attaccante.</li>
<li>In laboratorio, una sola richiesta GitHub con device code approvata ha permesso ai ricercatori di guidare una sessione, scrivere una memoria fuorviante, leggere la cronologia nel cloud o raggiungere repository privati, a seconda delle impostazioni.</li>
<li>Microsoft dice che quei quattro esiti sono una prova di concetto e non sono stati osservati in attacchi reali. Il device code phishing in sé è una via ricorrente per prendere il controllo di un account.</li>
<li>Inserite un device code solo per un accesso che avete avviato voi. Controllate le applicazioni collegate e limitate ciò che l'assistente può raggiungere.</li>
</ul>
<p>L'accesso con device code è il flusso in cui un dispositivo senza una tastiera comoda mostra un codice breve, e voi lo inserite su un altro dispositivo per approvare l'accesso. Lo usano i televisori connessi. Lo usano anche molti strumenti a riga di comando.</p>
<p>Il 17 novembre 2026 i ricercatori di sicurezza di Microsoft hanno pubblicato un'analisi su come lo stesso flusso può essere rivolto contro gli assistenti di codice basati sull'IA. Ho già scritto un <a href="https://iamops.dev/it/device-code-phishing-ai-agents/">articolo più lungo</a> sul dettaglio tecnico. Questa è la nota più breve che darei a un manager.</p>
<h2>Che cos'è davvero l'attacco</h2>
<p>Nel device code phishing è l'attaccante che avvia l'accesso sul proprio computer e riceve un codice breve. Lo invia a qualcun altro, spesso mascherato da richiesta dell'IT o da controllo di licenza. La persona apre la pagina di accesso autentica, inserisce il codice e approva. Così l'attaccante risulta collegato.</p>
<p>La pagina è vera. Per questo il trucco funziona. Il punto di Microsoft è che un sito legittimo non vi dice chi ha avviato la richiesta. La pagina di verifica di GitHub, nota Microsoft, avverte di non usare mai un codice inviato da qualcun altro.</p>
<figure class="b-fig"><img src="https://iamops.dev/img/device-code-phishing-briefing-for-managers.it.svg" alt="Tre passaggi in fila: qualcuno vi invia un codice breve, lo inserite su una pagina di accesso autentica e la persona che ha avviato la richiesta risulta collegata. Approvate un codice solo se avete avviato voi l'accesso." width="1200" height="630" loading="lazy" decoding="async"><figcaption><strong>Cosa fa davvero la persona.</strong> L'unico passaggio che compie è inserire un codice breve su una pagina di accesso autentica. La richiesta dietro quel codice l'ha avviata qualcun altro.</figcaption></figure>
<h2>Cosa ha mostrato Microsoft in laboratorio</h2>
<p>Il team ha usato lo strumento a riga di comando di GitHub Copilot come esempio. La tecnica non è limitata a quello strumento: qualsiasi client pubblico che supporta questo flusso di accesso può essere abusato allo stesso modo, e l'attaccante sceglie quali autorizzazioni chiedere. Un client pubblico è un'applicazione che non può conservare un segreto, come uno strumento a riga di comando o un televisore.</p>
<p>In un test di laboratorio controllato, un account di prova ha approvato una richiesta GitHub con device code avviata dai ricercatori. Con quella sola approvazione, a seconda delle impostazioni dell'account, hanno potuto:</p>
<ul>
<li>guidare da remoto una sessione attiva dell'assistente e fargli eseguire comandi sul computer della persona,</li>
<li>aggiungere voci fuorvianti alla memoria dell'assistente,</li>
<li>leggere la cronologia delle sessioni conservata nel cloud,</li>
<li>raggiungere repository di codice privati visibili all'account.</li>
</ul>
<p>Microsoft afferma che si tratta di risultati di prova di concetto, e di non aver osservato quei quattro esiti in attacchi reali. Il device code phishing in sé è più vecchio. Microsoft lo definisce una via ricorrente per prendere il controllo di un account, e cita campagne precedenti, tra cui una chiamata EvilTokens che ha contribuito a interrompere a settembre 2026.</p>
<h2>Cosa direi a un team</h2>
<p>Inserite un device code solo per un accesso che avete avviato voi, su una schermata che avete aperto. Un codice che arriva in un messaggio da qualcun altro è un segnale di allarme, anche quando la pagina è autentica.</p>
<p>Controllate le applicazioni collegate agli account di lavoro e togliete quelle che nessuno riconosce. Microsoft indica, come esempio, le impostazioni di GitHub per le app OAuth autorizzate. Le app OAuth sono le applicazioni che una persona ha permesso di usare un account.</p>
<p>Per gli strumenti di codice IA, usate le impostazioni più strette che potete accettare per il controllo remoto, l'archivio delle sessioni nel cloud e la memoria. Un'approvazione vale solo quanto ciò che l'assistente può raggiungere.</p>
<p>Microsoft descrive anche rilevamenti in Microsoft Defender per questo tipo di phishing arrivato per e-mail o su Teams, e un modo per sospendere un'identità GitHub gestita. Quelli sono per i team di sicurezza. L'abitudine che chiederei a tutti è la prima: se non avete avviato voi l'accesso, non inserite il codice.</p>
<p>L'<a href="https://iamops.dev/it/device-code-phishing-ai-agents/">articolo più lungo</a> ha il passo dopo passo del flusso e la stessa fonte.</p>
]]></content:encoded>
    </item>
    <item>
      <title>Flusso on-behalf-of di Microsoft Entra per il tier intermedio di un agente: certificato, senza client secret</title>
      <link>https://iamops.dev/it/entra-on-behalf-of-agent-middle-tier/</link>
      <guid isPermaLink="true">https://iamops.dev/it/entra-on-behalf-of-agent-middle-tier/</guid>
      <pubDate>Sat, 14 Nov 2026 08:00:00 GMT</pubDate>
      <dc:creator>Argo</dc:creator>
      <category>Lab</category>
      <category>Entra ID</category>
      <category>On-behalf-of</category>
      <category>Agenti AI</category>
      <category>OAuth</category>
      <category>Identità dei workload</category>
      <description>Lab in un tenant di prova: device code, l'API dell'agente scambia il token on-behalf-of con un certificato, senza segreti; uno scope non consentito fallisce.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/it/entra-on-behalf-of-agent-middle-tier.png?v=986e5733" alt="" /></p><p><strong>In breve</strong></p>
<ul>
<li>Per gli agenti che chiamano API per conto di un utente connesso, la risposta attuale di Entra è il flusso on-behalf-of (OBO); ID-JAG per ora è solo un sondaggio di interesse.</li>
<li>La middle API si dimostra con un'asserzione firmata con certificato e non ha alcun client secret.</li>
<li>Un solo accesso produce token separati per ogni audience: l'utente resta lo stesso e cambia l'applicazione chiamante.</li>
<li>Uno scope senza consenso fallisce con AADSTS65001; conta il consenso sul service principal.</li>
<li>I token OBO non conservano il client originale, quindi gli audit devono incrociare i log di accesso.</li>
</ul>
<p>Il 14 novembre 2026 Microsoft ha aggiunto un articolo di Learn che per la prima volta nomina <a href="https://iamops.dev/it/id-jag-explained/">ID-JAG</a> accanto a Microsoft Entra Agent ID e apre un modulo di interesse. È un sondaggio di prontezza, non una funzione rilasciata: oggi Entra non emette né accetta ID-JAG. Per gli agenti che devono chiamare API per conto di un utente connesso, la risposta attuale di Entra è il flusso on-behalf-of (OBO). L'ho eseguito dall'inizio alla fine in un tenant usa e getta e ho annotato cosa fa ogni passaggio.</p>
<h2>Cosa mostra il laboratorio</h2>
<p>Tre registrazioni di app rappresentano un sistema di agenti:</p>
<table>
<thead>
<tr>
<th>App</th>
<th>Ruolo</th>
<th>Credenziale</th>
</tr>
</thead>
<tbody>
<tr>
<td>Client</td>
<td>L'interfaccia o la riga di comando dell'agente. Client pubblico, accesso con device code.</td>
<td>Nessuna</td>
</tr>
<tr>
<td>Agent Middle API</td>
<td>Il back end dell'agente. Esegue lo scambio OBO.</td>
<td>Un certificato X.509, <strong>zero client secret</strong></td>
</tr>
<tr>
<td>Resource API</td>
<td>L'API a valle. Espone lo scope delegato <code>Data.Read</code>.</td>
<td>n/d</td>
</tr>
</tbody>
</table>
<p>L'utente accede una sola volta al Client. Il Client detiene un token la cui audience è solo la middle API. La middle API lo scambia con un token per la Resource API e con un altro per Microsoft Graph, dimostrando chi è con un'asserzione firmata con certificato invece che con un segreto.</p>
<h2>Configurazione</h2>
<p>Usate un <strong>tenant di prova separato</strong> (Entra ID Free basta, non servono risorse Azure). I token OBO contengono claim reali dell'utente, e un tenant usa e getta tiene gli esperimenti lontani da consenso, Conditional Access e log di audit di produzione. Nel portale:</p>
<ol>
<li>Registrate la Resource API ed esponete uno scope delegato <code>Data.Read</code> (amministratori e utenti).</li>
<li>Registrate l'Agent Middle API, esponete <code>access_as_user</code> e aggiungete i permessi delegati <code>Data.Read</code> e Microsoft Graph <code>User.Read</code>, poi concedete il consenso amministratore.</li>
<li>Generate una chiave RSA a 2048 bit e un certificato autofirmato di 60 giorni con <code>openssl</code>, tenete la chiave privata sulla macchina (modalità 0600) e caricate solo il certificato pubblico in <em>Certificates &amp; secrets</em>.</li>
<li>Registrate il Client come client pubblico (redirect <code>http://localhost</code>, <em>Allow public client flows</em> attivo) con il permesso per <code>access_as_user</code> e <code>User.Read</code>.</li>
</ol>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/09-certificate.webp" alt="Output del terminale di openssl con soggetto del certificato e impronta SHA-1, sostituita da un segnaposto." width="1894" height="301" loading="lazy" decoding="async"><figcaption><strong>La credenziale.</strong> Un certificato autofirmato è l'unica credenziale della middle API. L'impronta è sostituita da un segnaposto; la chiave privata non viene mai mostrata.</figcaption></figure>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/11-no-secrets.webp" alt="Interfaccia di amministrazione di Microsoft Entra, pagina Certificates and secrets dell'Agent Middle API con la scheda Client secrets aperta, che mostra zero client secret." width="1280" height="665" loading="lazy" decoding="async"><figcaption><strong>Nessun segreto.</strong> La scheda Client secrets mostra 0. Un certificato dimostra il possesso di una chiave che non viaggia mai; un segreto è una stringa riutilizzabile che finisce in configurazioni e log.</figcaption></figure>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/08-permissions.webp" alt="Interfaccia di amministrazione di Microsoft Entra, API permissions dell'Agent Middle API: User.Read per Microsoft Graph e Data.Read per la Resource API, entrambi delegati e concessi per la directory." width="1280" height="665" loading="lazy" decoding="async"><figcaption><strong>Cosa può chiedere il livello intermedio.</strong> Entra verifica questi permessi delegati al momento dello scambio. Ciò che non è elencato e consentito non si può ottenere a valle.</figcaption></figure>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/17-consent.webp" alt="Interfaccia di amministrazione di Microsoft Entra, Enterprise applications, Permissions del service principal dell'Agent Middle API, con il consenso amministratore per User.Read e Data.Read." width="1280" height="665" loading="lazy" decoding="async"><figcaption><strong>Cosa ha ottenuto davvero.</strong> Le registrazioni mostrano ciò che un'app chiede; i permessi del service principal mostrano ciò che le è stato dato. Gli strumenti di governance dovrebbero leggere i secondi.</figcaption></figure>
<h2>L'esecuzione</h2>
<p><strong>Accesso con <a href="https://iamops.dev/it/device-code-phishing-ai-agents/">device code</a>.</strong> Il Client chiede un codice all'endpoint <code>devicecode</code> v2.0. La richiesta contiene solo l'ID del Client e lo scope della middle API, nessun segreto. L'utente inserisce il codice su un secondo dispositivo ed Entra mostra un controllo «approva l'accesso su un altro dispositivo» che indica app e posizione; l'utente deve approvarlo a mano.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/18-devicecode.webp" alt="Output del terminale della richiesta di autorizzazione del dispositivo e della risposta, con tenant, ID del client e codice utente sostituiti da segnaposto." width="1894" height="530" loading="lazy" decoding="async"><figcaption><strong>Autorizzazione del dispositivo.</strong> Identificatori e codice utente sono segnaposto.</figcaption></figure>
<p><strong>Il token utente.</strong> Dopo l'approvazione il Client interroga l'endpoint dei token. Il suo token è inutilizzabile direttamente contro la Resource API o Graph, perché la sua audience è la middle API.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/24-user-token.webp" alt="Claim decodificati del token utente: l'audience è la middle API, appid è il Client, lo scope è access_as_user. Identificatori e nome dell'utente sono sostituiti da segnaposto." width="1894" height="607" loading="lazy" decoding="async"><figcaption><strong>L'unico token che il Client possiede.</strong> Audience: la middle API. Applicazione: il Client. Scope: access_as_user.</figcaption></figure>
<p><strong>Lo scambio.</strong> La middle API costruisce un'asserzione del client (un JWT RS256 con l'impronta del certificato in <code>x5t</code>; emittente e soggetto sono il suo client ID; audience è l'endpoint dei token; dieci minuti di validità), la firma con la chiave privata e invia la richiesta OBO:</p>
<pre><code class="language-text">POST https://login.microsoftonline.com/&lt;tenant-id&gt;/oauth2/v2.0/token
  grant_type=urn:ietf:params:oauth:grant-type:jwt-bearer
  client_id=&lt;middle-api-id&gt;
  client_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearer
  client_assertion=&lt;RS256 JWT with x5t in the header&gt;
  assertion=&lt;the user token&gt;
  scope=api://&lt;resource-api-id&gt;/Data.Read
  requested_token_use=on_behalf_of
</code></pre>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/25-obo-resource.webp" alt="Claim decodificati del token OBO per la Resource API: audience è la Resource API, appid è la middle API, scope Data.Read, stesso object ID dell'utente. Gli identificatori sono segnaposto." width="1894" height="607" loading="lazy" decoding="async"><figcaption><strong>Token per la Resource API.</strong> Audience: la Resource API. Applicazione: la middle API. Scope: Data.Read. Stesso utente.</figcaption></figure>
<p>La stessa asserzione con scope <code>https://graph.microsoft.com/User.Read</code> restituisce un token per Graph, che il laboratorio usa una volta per <code>GET /v1.0/me</code>.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/26-obo-graph.webp" alt="Claim decodificati del token OBO per Microsoft Graph e risposta della chiamata Graph me, con nome e nome principale dell'utente sostituiti da segnaposto." width="1894" height="721" loading="lazy" decoding="async"><figcaption><strong>Token per Microsoft Graph, poi una chiamata a /me.</strong> Un solo accesso si ramifica in più token legati a un'audience. Nome e nome principale dell'utente sono segnaposto.</figcaption></figure>
<p><strong>Confronto dei tre token.</strong> L'utente non cambia mai. L'audience segue l'API chiamata e <code>appid</code> passa dal Client alla middle API.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/27-claims-compare.webp" alt="Tabella affiancata di audience, appid, scope, object ID e tenant ID per il token utente e i due token OBO. Gli identificatori sono segnaposto." width="1894" height="416" loading="lazy" decoding="async"><figcaption><strong>Tre token a confronto.</strong> Stesso utente e stesso tenant; a ogni passaggio cambiano l'audience e l'applicazione chiamante.</figcaption></figure>
<p><strong>Il test negativo.</strong> Chiedere <code>https://graph.microsoft.com/Mail.Read</code>, a cui nessuno ha dato il consenso, fallisce nel servizio dei token:</p>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/28-negative.webp" alt="Output del terminale di un errore invalid_grant AADSTS65001: l'utente o l'amministratore non ha dato il consenso all'uso dell'applicazione. ID applicazione, trace ID e correlation ID sono segnaposto." width="1894" height="416" loading="lazy" decoding="async"><figcaption><strong>AADSTS65001.</strong> Il consenso viene verificato al momento del token sul service principal del livello intermedio. Per un agente non interattivo non c'è ripiego su una richiesta interattiva.</figcaption></figure>
<h2>Insidie</h2>
<ul>
<li><strong>Il client originale si perde.</strong> I token OBO v1 registrano solo l'ultima applicazione (<code>appid</code>). Non c'è un claim <code>act</code> come in un'implementazione RFC 8693, quindi per ricostruire la catena l'audit deve collegare i log di accesso.</li>
<li><strong>L'audience in ingresso deve essere la middle API.</strong> Un token destinato a un'altra app viene rifiutato: è la protezione contro il confused deputy.</li>
<li><strong>Il device code richiede «Allow public client flows».</strong> È anche il flusso sfruttato dal device code phishing. La schermata «approva l'accesso su un altro dispositivo» è la contromisura di Microsoft; insegnate agli utenti a premere «Non sono stato io» e limitate il flusso con il Conditional Access dove gli agenti non ne hanno bisogno.</li>
<li><strong>Conta il consenso amministratore sul service principal</strong>, non ciò che elenca la registrazione.</li>
</ul>
<h2>Indicazioni di sicurezza</h2>
<ol>
<li>Usate un certificato o una credenziale federata per il livello intermedio. Nessun segreto significa nulla di riutilizzabile da far trapelare da configurazioni, variabili di CI o log.</li>
<li>Tenete minimi gli scope delegati del livello intermedio e rivedeteli sul service principal.</li>
<li>Lasciate il Client senza credenziali. Potrà sempre e solo detenere il token dell'utente per la middle API, mai un token a valle.</li>
<li>Pianificate il collegamento per l'audit (utente, agente, audience a valle), perché i token OBO non conservano il primo passaggio.</li>
<li>Annotate quale concessione usa ogni passaggio (OBO oggi; ID-JAG quando Entra lo supporterà) e dove risiede il consenso, così le revisioni degli accessi vedono le concessioni dei service principal.</li>
</ol>
<h2>Cosa non è stato eseguito</h2>
<p>Non sono stati eseguiti i blueprint e le identità di agente di Entra Agent ID (lo stesso laboratorio con permessi ereditabili). Non è stata testata la policy di Conditional Access che blocca il device code. Le attività aggiuntive (rimuovere il consenso e ripetere lo scambio, claim opzionali, token v2) non sono state eseguite. Gli screenshot del portale sono ritagliati sul contenuto della pagina: barra del browser, menu del profilo e tutti gli identificatori di tenant, applicazioni e utenti sono rimossi. Per questo laboratorio non viene pubblicata alcuna registrazione.</p>
<p><em>Le immagini del terminale sono state generate dall'output salvato dell'esecuzione, con gli identificatori sostituiti da segnaposto. Gli screenshot del portale mostrano solo il contenuto della pagina.</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>OAuth token exchange con Keycloak (RFC 8693): restringere i token per agenti AI e server MCP</title>
      <link>https://iamops.dev/it/keycloak-token-exchange-rfc-8693/</link>
      <guid isPermaLink="true">https://iamops.dev/it/keycloak-token-exchange-rfc-8693/</guid>
      <pubDate>Thu, 12 Nov 2026 08:00:00 GMT</pubDate>
      <dc:creator>Argo</dc:creator>
      <category>Lab</category>
      <category>Token Exchange</category>
      <category>Keycloak</category>
      <category>RFC 8693</category>
      <category>MCP</category>
      <category>Agenti AI</category>
      <description>Laboratorio con Keycloak: un server MCP scambia il token dell'utente con uno più ristretto per un'API a valle, poi tre scambi non validi vengono rifiutati.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/it/keycloak-token-exchange-rfc-8693.png?v=986e5733" alt="" /></p><p><strong>In breve</strong></p>
<ul>
<li>Lo scambio di token RFC 8693 permette a un server MCP di sostituire il token dell'utente con uno più ristretto, destinato a una sola API a valle.</li>
<li>In Keycloak si abilita per singolo client, e l'audience a valle è uno scope facoltativo.</li>
<li>Il token scambiato mantiene l'utente come soggetto, ha solo l'audience a valle, dura 300 secondi e non include un refresh token.</li>
<li>Tre scambi non validi vengono rifiutati: un client senza il privilegio, un'audience senza scope e la richiesta di un refresh token.</li>
<li>In questa configurazione non c'è il claim act, quindi il client che agisce compare solo come authorized party.</li>
</ul>
<p>Il 12 novembre 2026 Amazon Cognito ha aggiunto OAuth 2.0 Token Exchange (RFC 8693), pochi giorni dopo WorkOS Connect. Entra ha il proprio flusso on-behalf-of da anni. Lo schema è ormai comune ai principali identity provider: un servizio che agisce per conto di un utente scambia il token dell'utente con un nuovo token più ristretto, legato a un solo destinatario (audience) e di breve durata, invece di inoltrare l'originale. L'ho provato su un Keycloak locale e ho annotato cosa ha fatto il server.</p>
<p>Questo laboratorio esegue lo schema su un portatile con Keycloak, un server di autorizzazione open source, così si vede esattamente cosa cambia dentro il token e cosa il server rifiuta.</p>
<h2>Cosa mostra il laboratorio</h2>
<p>Un agente AI fa accedere l'utente e ottiene un token per un <a href="https://iamops.dev/it/mcp-server-no-token-passthrough/">server MCP</a>. Il server MCP deve chiamare per quell'utente un'API di pagamenti, ma non deve inoltrare il token dell'agente. Lo presenta invece al server di autorizzazione e chiede un token valido solo per l'API di pagamenti.</p>
<p>Il laboratorio usa tre client in un realm:</p>
<table>
<thead>
<tr>
<th>Client</th>
<th>Ruolo</th>
<th>Può scambiare token?</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>agent</code></td>
<td>Ottiene il token dell'utente (password grant, solo scorciatoia da laboratorio)</td>
<td>No</td>
</tr>
<tr>
<td><code>mcp-server</code></td>
<td>Scambia il token dell'utente</td>
<td>Sì</td>
</tr>
<tr>
<td><code>payments-api</code></td>
<td>Solo un'audience, l'API a valle</td>
<td>No</td>
</tr>
</tbody>
</table>
<h2>Configurazione</h2>
<p>Keycloak 26.8.2 è stato eseguito dalla distribuzione zip con Java 21, in modalità sviluppo e da un'estrazione pulita. La modalità sviluppo serve solo per i laboratori. Le password sono valori usa e getta; in questo articolo compaiono come <code>&lt;lab-password&gt;</code> e <code>&lt;client-secret&gt;</code>.</p>
<pre><code class="language-bash">export KC_BOOTSTRAP_ADMIN_USERNAME=admin KC_BOOTSTRAP_ADMIN_PASSWORD=&lt;lab-password&gt;
keycloak-26.8.2/bin/kc.sh start-dev --http-port 8080
./kc-lab.sh   # creates realm agentlab, user alice, the three clients and two audience scopes
</code></pre>
<figure class="b-fig"><img src="https://iamops.dev/media/keycloak-token-exchange-rfc-8693/03-setup.webp" alt="Output del terminale dello script di configurazione che crea il realm agentlab, un utente, tre client e due client scope, con gli identificatori sostituiti da segnaposto tra parentesi angolari." width="1894" height="492" loading="lazy" decoding="async"><figcaption><strong>Configurazione.</strong> Lo script crea il realm, un utente di prova, i tre client e due client scope che aggiungono le audience. Gli ID degli oggetti sono sostituiti da segnaposto.</figcaption></figure>
<p>Nella console di amministrazione due impostazioni reggono il progetto. Solo <code>mcp-server</code> ha attivo <strong>Standard Token Exchange</strong>, e l'audience a valle è uno scope <em>opzionale</em>, quindi viene aggiunta solo quando lo scambio la richiede.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/keycloak-token-exchange-rfc-8693/05-exchange-toggle.webp" alt="Console di amministrazione di Keycloak, configurazione delle capacità del client mcp-server, con la casella Standard Token Exchange selezionata." width="1600" height="960" loading="lazy" decoding="async"><figcaption><strong>Il privilegio.</strong> Standard Token Exchange è attivo solo sul client mcp-server. Un client agente compromesso non può emettere token per altre API.</figcaption></figure>
<figure class="b-fig"><img src="https://iamops.dev/media/keycloak-token-exchange-rfc-8693/06-client-scopes.webp" alt="Console di amministrazione di Keycloak, client scope del client mcp-server, con lo scope aud-payments-api indicato come Optional." width="1600" height="960" loading="lazy" decoding="async"><figcaption><strong>L'audience.</strong> aud-payments-api è opzionale per mcp-server, quindi l'audience a valle va richiesta esplicitamente.</figcaption></figure>
<h2>L'esecuzione</h2>
<p>L'agente ottiene un token utente, poi il server MCP lo scambia. La richiesta centrale è una sola chiamata all'endpoint dei token:</p>
<pre><code class="language-bash">curl -s -u mcp-server:&lt;client-secret&gt; \
  -d grant_type=urn:ietf:params:oauth:grant-type:token-exchange \
  -d subject_token=&quot;$USER_AT&quot; \
  -d subject_token_type=urn:ietf:params:oauth:token-type:access_token \
  -d requested_token_type=urn:ietf:params:oauth:token-type:access_token \
  -d audience=payments-api -d scope=aud-payments-api &quot;$TOKEN_URL&quot;
</code></pre>
<figure class="b-fig"><img src="https://iamops.dev/media/keycloak-token-exchange-rfc-8693/07-exchange.webp" alt="Output del terminale che confronta il token utente decodificato e il token scambiato. L'audience passa da mcp-server e account a payments-api, azp passa da agent a mcp-server, expires_in è 300 e non ci sono né refresh token né claim act." width="1894" height="1027" loading="lazy" decoding="async"><figcaption><strong>Prima e dopo.</strong> Stesso utente, nuova audience (payments-api), nuova parte autorizzata (mcp-server), 300 secondi di validità, nessun refresh token. L'identificatore dell'utente è sostituito da un segnaposto.</figcaption></figure>
<p>Confrontando i due token: il soggetto è invariato, l'audience è ora solo l'API di pagamenti, la parte autorizzata (<code>azp</code>) indica il server MCP, la durata è di 300 secondi e non viene restituito alcun refresh token. <strong>Non c'è il claim <code>act</code></strong>: il supporto di Keycloak alla delega è una funzione in anteprima, disattivata per impostazione predefinita, quindi l'attore compare solo come <code>azp</code>.</p>
<h2>Farlo fallire di proposito</h2>
<p>Tre scambi devono essere rifiutati. Verificate gli stessi tre in qualsiasi identity provider prima di affidargli la delega per gli agenti.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/keycloak-token-exchange-rfc-8693/08-negative.webp" alt="Output del terminale di tre scambi rifiutati: un client senza token exchange abilitato, un'audience per cui il server MCP non ha scope e la richiesta di un refresh token; ognuno restituisce invalid_request." width="1894" height="874" loading="lazy" decoding="async"><figcaption><strong>Tre rifiuti.</strong> A: un client senza il privilegio di scambio. B: un'audience per cui il server MCP non ha scope. C: un refresh token. Tutti restituiscono invalid_request. I client secret sono sostituiti da segnaposto.</figcaption></figure>
<h2>Insidie</h2>
<ul>
<li><strong>Il password grant è una scorciatoia.</strong> Il laboratorio lo usa solo per ottenere in fretta un token utente. RFC 9700 e OAuth 2.1 lo escludono per i client reali; usate l'authorization code flow con <a href="https://iamops.dev/it/tools/pkce/">PKCE</a>.</li>
<li><strong>Il claim <code>aud</code> può elencare più del previsto.</strong> Introspezionando il token scambiato sono comparsi l'API di pagamenti e <code>account</code>. Capitelo prima di fare affidamento sui controlli di audience.</li>
<li><strong>L'ordine degli scope varia</strong> da un'esecuzione all'altra, quindi non confrontate le stringhe alla lettera.</li>
<li><strong>Nessun claim <code>act</code> di default.</strong> Se l'audit richiede l'attore, pianificate la funzione di delega in anteprima oppure ricostruite voi il collegamento tramite <code>azp</code> nei log.</li>
</ul>
<h2>Indicazioni di sicurezza</h2>
<ol>
<li>Il token exchange è un privilegio. Concedetelo al solo client che ne ha bisogno.</li>
<li>Rendete l'audience a valle esplicita e opzionale, così i token scambiati restano ristretti per impostazione predefinita.</li>
<li>Non rilasciate mai refresh token in uno scambio. Il server del laboratorio li rifiuta.</li>
<li>Un servizio deve rifiutare i token non emessi per lui e scambiare per ogni API a valle, senza mai inoltrare il token dell'utente.</li>
<li>Verificate cosa può ricostruire la vostra traccia di audit. Se l'attore compare solo come <code>azp</code>, serve una riga di log che colleghi utente, agente e audience a valle.</li>
</ol>
<h2>Cosa non è stato eseguito</h2>
<p>Non sono state eseguite la variante Docker, le attività aggiuntive (refresh token nello scambio standard, introspezione da parte dell'API a valle) e la funzione di delega in anteprima che aggiungerebbe <code>act</code>. Il laboratorio ha usato solo account usa e getta. Per questo laboratorio non viene pubblicata alcuna registrazione.</p>
<p><em>Le immagini del terminale sono state generate dall'output salvato dell'esecuzione, con identificatori e segreti sostituiti da segnaposto. Gli screenshot della console Keycloak mostrano solo oggetti di prova.</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>Proteggere un server MCP con OAuth: rifiutare il token passthrough e scambiare per ogni API a valle</title>
      <link>https://iamops.dev/it/mcp-server-no-token-passthrough/</link>
      <guid isPermaLink="true">https://iamops.dev/it/mcp-server-no-token-passthrough/</guid>
      <pubDate>Wed, 11 Nov 2026 08:00:00 GMT</pubDate>
      <dc:creator>Argo</dc:creator>
      <category>Lab</category>
      <category>MCP</category>
      <category>OAuth</category>
      <category>Token Exchange</category>
      <category>Keycloak</category>
      <category>Agenti AI</category>
      <description>Laboratorio con l'SDK Python di MCP e Keycloak: handshake 401, controllo dell'audience, scambio RFC 8693 per l'API di pagamenti e passthrough rifiutato.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/it/mcp-server-no-token-passthrough.png?v=986e5733" alt="" /></p><p><strong>In breve</strong></p>
<ul>
<li>Un server MCP è un resource server OAuth: risponde 401 con i Protected Resource Metadata così i client trovano l'authorization server.</li>
<li>Verifica con introspezione ogni bearer token e rifiuta quelli la cui audience non include il server MCP stesso.</li>
<li>Per un'API a valle scambia il token (RFC 8693) invece di inoltrare il token del chiamante.</li>
<li>Un passthrough deliberato fallisce: il token per l'API dei pagamenti risulta inattivo per il server MCP, che risponde 401.</li>
<li>Registra utente, client dell'agente e audience a valle in una sola riga, così gli audit possono seguire la catena.</li>
</ul>
<p>Il 10 novembre 2026 WorkOS ha aggiunto il token exchange (RFC 8693) a WorkOS Connect, così che un server MCP possa chiamare API a valle per conto di un utente senza inoltrarne il token. È lo schema che la specifica di autorizzazione MCP si aspetta. L'ho costruito a mano con l'SDK Python ufficiale, così ogni regola si vede all'opera.</p>
<p>Si basa sul <a href="https://iamops.dev/it/keycloak-token-exchange-rfc-8693/">laboratorio di token exchange con Keycloak</a>: stesso realm, stessi tre client.</p>
<h2>Cosa mostra il laboratorio</h2>
<p>Un server MCP scritto con l'SDK Python ufficiale (<code>mcp</code> 2.3.0) fa da <em>resource server</em> OAuth per un realm Keycloak. Fa quattro cose:</p>
<ol>
<li>Risponde a una richiesta senza token con <code>401</code> e un rimando ai propri Protected Resource Metadata (RFC 9728), così un client trova il server di autorizzazione senza averlo nella configurazione.</li>
<li>Controlla ogni bearer token per introspezione presso Keycloak e rifiuta i token la cui audience non include il server MCP stesso.</li>
<li>Per uno strumento, scambia il token del chiamante con un token destinato all'API di pagamenti (RFC 8693) invece di inoltrarlo.</li>
<li>Rifiuta un token emesso per l'API di pagamenti quando qualcuno lo presenta al server MCP (un tentativo di passthrough).</li>
</ol>
<p>Il verificatore è breve. La riga decisiva è il controllo dell'audience:</p>
<pre><code class="language-python">data = introspect(token)            # RFC 7662, as the mcp-server client
aud = data.get(&quot;aud&quot;, [])
aud = [aud] if isinstance(aud, str) else aud
if not data.get(&quot;active&quot;) or &quot;mcp-server&quot; not in aud:
    return None                     # inactive, or minted for another API: no passthrough
</code></pre>
<h2>L'esecuzione</h2>
<p>Fissate la versione dell'SDK: <code>mcp</code> 2.x ha rinominato <code>FastMCP</code> in <code>MCPServer</code> e gli SDK cambiano le classi di autenticazione tra una versione e l'altra. Il server ascolta su <code>127.0.0.1:8001</code>.</p>
<p><strong>Senza token.</strong> La prima richiesta è l'handshake di scoperta con cui parte ogni client MCP: un <code>401</code> il cui header <code>WWW-Authenticate</code> contiene un URL <code>resource_metadata</code>, e un documento di metadati che indica il realm come server di autorizzazione.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/mcp-server-no-token-passthrough/03-no-token.webp" alt="Output del terminale: una richiesta senza token restituisce 401 Unauthorized con un header www-authenticate che rimanda ai metadati della risorsa protetta; il documento dei metadati indica il realm Keycloak come server di autorizzazione." width="1894" height="530" loading="lazy" decoding="async"><figcaption><strong>L'handshake 401.</strong> Il client scopre dove ottenere un token dal documento dei metadati, non dalla configurazione.</figcaption></figure>
<p><strong>Con un token.</strong> Un piccolo script ottiene un token utente per il client <code>agent</code>, apre una sessione MCP e chiama entrambi gli strumenti. <code>whoami</code> mostra che il server vede l'utente attraverso il client agente; <code>downstream_token</code> mostra il server che scambia il token con uno limitato all'API di pagamenti.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/mcp-server-no-token-passthrough/04-call.webp" alt="Output del terminale delle due chiamate: whoami restituisce soggetto, client agente e scope; downstream_token restituisce un token con audience payments-api e parte autorizzata mcp-server. Il soggetto è sostituito da un segnaposto." width="1894" height="683" loading="lazy" decoding="async"><figcaption><strong>Due strumenti.</strong> Il primo mostra chi ha chiamato. Il secondo mostra il token scambiato: audience payments-api, parte autorizzata mcp-server, stesso soggetto. Il soggetto è un segnaposto.</figcaption></figure>
<p>La stessa chiamata funziona con il client a riga di comando MCP Inspector, il modo standard per riprodurre ciò che farebbe qualsiasi host MCP. Fissate la sua versione negli script; questo laboratorio ha usato la 2.15.0.</p>
<p><strong>Il tentativo di passthrough.</strong> Create un nuovo token scambiato, guardatelo in introspezione da entrambi i lati e presentatelo al server MCP.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/mcp-server-no-token-passthrough/06-passthrough.webp" alt="Output del terminale: l'introspezione indica il token come attivo per il client payments-api e inattivo per il client mcp-server; presentarlo al server MCP restituisce 401." width="1894" height="492" loading="lazy" decoding="async"><figcaption><strong>Nessun passthrough.</strong> Keycloak segnala il token come attivo solo al client per cui è stato emesso. Il server MCP risponde 401. I client secret sono segnaposto.</figcaption></figure>
<h2>Insidie</h2>
<ul>
<li><strong>Introspezione o validazione locale?</strong> Il laboratorio usa l'introspezione, che dà revoca immediata al prezzo di una richiesta al server di autorizzazione. L'alternativa è la validazione locale del JWT con le chiavi JWKS; annotate cosa si perde e cosa si guadagna.</li>
<li><strong>Controllate l'audience, non solo la firma.</strong> Un token valido per un'altra API resta il token sbagliato. È il controllo dell'audience a trasformare il passthrough in un <code>401</code>.</li>
<li><strong>I token durano cinque minuti</strong> in questa configurazione, quindi generate il token per il passthrough subito prima del test.</li>
<li><strong>Deriva degli SDK.</strong> Nomi delle classi e hook di autenticazione sono cambiati tra le versioni principali; provate con la versione che distribuite.</li>
</ul>
<h2>Indicazioni di sicurezza</h2>
<ol>
<li>Un server MCP è un resource server OAuth. Pubblica i metadati, valida l'audience e rifiuta tutto ciò che non è destinato a lui.</li>
<li>Non inoltrate mai il token del chiamante a un'API a valle. Scambiatelo per ogni audience a valle, più ristretto e di breve durata.</li>
<li>Lasciate che sia il server di autorizzazione a decidere chi vede un token come attivo. Un token che funziona solo per il destinatario previsto limita ciò che può fare un passaggio compromesso.</li>
<li>Registrate una riga di log che colleghi utente, client agente e audience a valle; il solo token non racconta a un auditor l'intera storia.</li>
</ol>
<h2>Cosa non è stato eseguito</h2>
<p>Il flusso OAuth dell'interfaccia web di MCP Inspector non è stato eseguito (il client <code>agent</code> del laboratorio ammette per questo un redirect su localhost). Non è stata usata la registrazione dinamica dei client; il client è preregistrato. Tutto è stato eseguito su una sola macchina con account usa e getta. Per questo laboratorio non viene pubblicata alcuna registrazione.</p>
<p><em>Le immagini del terminale sono state generate dall'output salvato dell'esecuzione, con identificatori, segreti e timestamp sostituiti da segnaposto.</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>Un agente AI autonomo senza segreti su Azure: chiamare un'API con una managed identity da Container Apps</title>
      <link>https://iamops.dev/it/secretless-agent-managed-identity-container-app/</link>
      <guid isPermaLink="true">https://iamops.dev/it/secretless-agent-managed-identity-container-app/</guid>
      <pubDate>Thu, 05 Nov 2026 08:00:00 GMT</pubDate>
      <dc:creator>Argo</dc:creator>
      <category>Lab</category>
      <category>Managed identity</category>
      <category>Entra ID</category>
      <category>Agenti AI</category>
      <category>Identità dei workload</category>
      <category>Azure</category>
      <description>Laboratorio: un agente Container Apps con managed identity e senza segreti riceve un solo ruolo ristretto, ottiene un token app-only e l'API lo convalida.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/it/secretless-agent-managed-identity-container-app.png?v=986e5733" alt="" /></p><p><strong>In breve</strong></p>
<ul>
<li>Un agente autonomo che non possiede segreti non ha nulla da far trapelare: una Container App con managed identity assegnata dall'utente, senza client secret, certificato né ingress.</li>
<li>L'identità parte senza ruoli; con l'assegnazione obbligatoria sull'API, la richiesta di token viene rifiutata (AADSTS501051) finché non viene concesso un solo ruolo ristretto.</li>
<li>Il token app-only contiene roles e non scp, e l'API convalida comunque firma, audience, emittente e ruolo.</li>
<li>I token restano in cache per circa 24 ore, quindi rimuovere un ruolo non è una revoca immediata.</li>
<li>Tratta l'identità come un account privilegiato: un responsabile, una data di revisione e un avviso sulle assegnazioni di ruolo.</li>
</ul>
<p>Il 5 novembre 2026 Microsoft Threat Intelligence ha descritto autori di attacchi che usano un framework offensivo basato su agenti per cercare segreti esposti in repository pubblici e poi usare credenziali applicative valide per accedere come carichi di lavoro. La lettura difensiva è semplice: un agente autonomo che non possiede alcun segreto non ha nulla da far trapelare. Ne ho costruito uno su Azure e ho verificato ogni affermazione.</p>
<h2>Cosa mostra il laboratorio</h2>
<p>Un piccolo agente gira come Azure Container App. Non ha utente, né client secret, né certificato. La sua identità è una <strong>managed identity assegnata dall'utente</strong> che parte senza ruoli. Il laboratorio poi:</p>
<ol>
<li>Collega l'identità all'app e dimostra che il container non contiene alcun segreto.</li>
<li>Fa richiedere all'API a valle (la <em>Resource API</em>, una registrazione di app) un'assegnazione di ruolo applicativo.</li>
<li>Mostra la richiesta di token rifiutata, poi concede <strong>un solo</strong> ruolo app-only ristretto.</li>
<li>Legge il token app-only che l'agente ottiene e lo verifica come farebbe l'API.</li>
</ol>
<h2>Configurazione</h2>
<p>Usate un tenant e una sottoscrizione di prova separati. L'agente gira con 0,25 vCPU e 0,5 GiB sul piano Consumption, senza ingress e senza workspace Log Analytics. I primi 180.000 vCPU-secondi al mese sono gratuiti, che questa dimensione esaurisce in circa 200 ore di esecuzione: eliminate l'app quando avete finito. La managed identity e il ruolo applicativo sono gratuiti.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/01-context.webp" alt="Output del terminale: l'Azure CLI mostra sottoscrizione e tenant, la managed identity con client ID e principal ID e zero assegnazioni di ruolo. Gli identificatori sono segnaposto." width="1894" height="683" loading="lazy" decoding="async"><figcaption><strong>Si parte da zero.</strong> La managed identity non ha assegnazioni di ruolo, quindi ogni permesso del laboratorio è una concessione deliberata e visibile. Gli identificatori sono segnaposto.</figcaption></figure>
<p>L'app è definita in YAML. L'immagine è pubblica e serve solo per il suo Python, quindi non occorre alcuna credenziale di registry. Il blocco identity collega la managed identity. Non c'è una sezione <code>ingress</code>, quindi nessuno può chiamare dall'esterno.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/03-app-definition.webp" alt="Output del terminale della definizione dell'app: posizione, blocco identity assegnato dall'utente, ID dell'ambiente, immagine pubblica del container, risorse di 0,25 vCPU e 0,5 GiB e client ID come variabile d'ambiente. Gli ID sono segnaposto." width="1894" height="874" loading="lazy" decoding="async"><figcaption><strong>Niente da rubare.</strong> Tutto ciò che un attaccante potrebbe prendere da questa definizione è pubblico: il nome di un'immagine, un client ID e il codice. Gli ID di sottoscrizione e di client sono segnaposto.</figcaption></figure>
<h2>L'esecuzione</h2>
<p><strong>Il container ha un endpoint di identità, non un segreto.</strong> La piattaforma inietta <code>IDENTITY_ENDPOINT</code>, un URL su localhost, e <code>IDENTITY_HEADER</code>, un valore per container (mascherato nell'output). Nessun'altra variabile somiglia a un segreto e non è montato alcun volume di segreti.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/05-secretless.webp" alt="Output del terminale dall'interno del container: l'endpoint di identità su localhost, l'header di identità mascherato, il client ID pubblico e nessuna variabile chiamata secret, password, key o certificate né volumi di segreti montati." width="1894" height="454" loading="lazy" decoding="async"><figcaption><strong>Dentro il container.</strong> L'header non è una credenziale per Entra. Dimostra solo all'endpoint locale che il chiamante si trova in questo container, il che blocca i trucchi SSRF.</figcaption></figure>
<p><strong>Richiedere l'assegnazione sull'API.</strong> Per impostazione predefinita Entra emette un token app-only a qualsiasi service principal del tenant che lo chieda, con un claim <code>roles</code> vuoto. Impostare <code>appRoleAssignmentRequired</code> a <code>true</code> sul service principal della Resource API fa sì che Entra rifiuti chi non è assegnato:</p>
<pre><code class="language-bash">az ad sp update --id &lt;resource-sp-id&gt; --set appRoleAssignmentRequired=true
</code></pre>
<p><strong>Due test negativi.</strong> La richiesta dell'agente di un token per la Resource API viene rifiutata dal servizio dei token con AADSTS501051, e un token per Graph (Graph non richiede l'assegnazione) non contiene ruoli, quindi <code>GET /v1.0/users</code> restituisce <code>403</code>.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/07-refused.webp" alt="Output del terminale di due rifiuti: HTTP 400 con AADSTS501051 che indica che la managed identity non è assegnata a un ruolo per la Resource API e HTTP 403 Authorization_RequestDenied da Graph. Gli ID sono segnaposto." width="1894" height="530" loading="lazy" decoding="async"><figcaption><strong>Rifiutato due volte.</strong> Il rifiuto avviene prima che l'API venga chiamata e nomina la managed identity, il che lo rende facile da individuare in una revisione o in un incidente. «Avere un token» non significa «avere accesso».</figcaption></figure>
<p><strong>Una concessione ristretta.</strong> Aggiungete alla Resource API un ruolo applicativo solo app-only <code>Data.Read.All</code> (tipo di membro consentito: applicazione) e assegnatelo alla managed identity tramite Microsoft Graph. L'interfaccia di amministrazione non può assegnare un ruolo applicativo a una managed identity, quindi si passa da Graph, PowerShell o dalla CLI.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/10-assign.webp" alt="Output del terminale di due chiamate Graph: aggiunta del ruolo applicativo Data.Read.All alla Resource API e assegnazione al service principal della managed identity. Gli ID degli oggetti sono segnaposto." width="1894" height="645" loading="lazy" decoding="async"><figcaption><strong>L'unica concessione del laboratorio.</strong> È un normale oggetto Graph che uno strumento di governance o uno script può leggere.</figcaption></figure>
<p><strong>Il token app-only.</strong> Entra mette in cache i token delle managed identity, quindi il container continua a ricevere il vecchio token fino a un giorno. Riavviando la revisione se ne ottiene uno nuovo, che ora contiene il ruolo.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/13-token.webp" alt="Claim decodificati del token app-only dopo il riavvio della revisione: l'audience è la Resource API, applicazione e object ID sono la managed identity, idtyp è app, roles contiene Data.Read.All e non c'è il claim scope. Gli identificatori sono segnaposto." width="1894" height="759" loading="lazy" decoding="async"><figcaption><strong>Token app-only.</strong> Un claim <code>roles</code> senza <code>scp</code> è il modo in cui un'API distingue una chiamata app-only da una delegata. Non c'è alcun utente; gli unici limiti sono le concessioni dell'identità.</figcaption></figure>
<p><strong>Fare la parte dell'API.</strong> Il token passa dal container a un file temporaneo con modalità 0600 e viene distrutto alla fine; non viene mai stampato. Uno script di convalida verifica la firma RS256 con le chiavi del tenant, l'audience, l'emittente e la scadenza, poi autorizza ogni route in base al ruolo.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/15-validate.webp" alt="Output del terminale del controllo lato API: GET data restituisce 200 per il ruolo Data.Read.All, POST data restituisce 403 per il ruolo Data.Write.All mancante e un token con ruoli modificati restituisce 401 perché la verifica della firma fallisce." width="1894" height="339" loading="lazy" decoding="async"><figcaption><strong>L'API decide comunque.</strong> La lettura è consentita, la scrittura è rifiutata e un token con claim modificati non supera la verifica della firma.</figcaption></figure>
<h2>Insidie</h2>
<ul>
<li><strong>I token restano in cache per circa 24 ore.</strong> Rimuovere il ruolo non basta per una revoca urgente. Riavviate o ridistribuite il carico di lavoro, oppure disabilitate l'identità.</li>
<li><strong><code>exec</code> ha un limite di frequenza.</strong> Senza <code>--replica</code>, <code>az containerapp exec</code> può scegliere una replica ferma e i tentativi successivi incontrano HTTP 429 con attesa di dieci minuti. Indicate la replica in esecuzione.</li>
<li><strong>«Assignment required» è un interruttore da attivare.</strong> Senza di esso «poter ottenere un token» e «essere autorizzati» sono cose diverse, e ogni API deve controllare i ruoli da sé.</li>
<li><strong>I tenant gratuiti registrano meno.</strong> Il log di audit della directory mostra la concessione. I log di accesso delle managed identity richiedono Entra ID P1 o P2 e vanno esportati nel SIEM.</li>
<li><strong>Eliminate il calcolo quando avete finito.</strong> Il calcolo costa denaro; identità e ruolo portano il rischio e richiedono un responsabile e una data di revisione come qualsiasi altro account privilegiato.</li>
</ul>
<h2>Indicazioni di sicurezza</h2>
<ol>
<li>Un carico di lavoro senza segreti non ha nulla da far trapelare. Preferite managed identity o credenziali federate ai client secret.</li>
<li>Partite senza ruoli e aggiungete un ruolo con l'ambito più stretto. Chiamate i ruoli app-only <code>*.All</code> perché chi revisiona veda che non c'è alcun confine utente.</li>
<li>Richiedete l'assegnazione sulle API interne, così il servizio dei token è il primo cancello.</li>
<li>Convalidate firma, audience, emittente e ruolo nell'API. Entra decide solo chi ottiene un token.</li>
<li>Trattate le managed identity che detengono ruoli applicativi come account non umani privilegiati: responsabile, certificazione, un avviso sulle assegnazioni di ruolo ai service principal.</li>
</ol>
<h2>Cosa non è stato eseguito</h2>
<p>Il laboratorio non ha distribuito un blueprint e un'identità di agente di Entra Agent ID, dove un token di managed identity sarebbe la credenziale del blueprint. Il tour del portale sugli oggetti risultanti è stato registrato ma non viene pubblicato, perché le viste del portale mostrano identificatori del tenant. Per questo laboratorio non viene pubblicata alcuna registrazione.</p>
<p><em>Le immagini del terminale sono state generate dall'output salvato dell'esecuzione, con identificatori, segreti e timestamp sostituiti da segnaposto.</em></p>
]]></content:encoded>
    </item>
  </channel>
</rss>
