<?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/de/</link>
    <description>Notizen aus der Praxis zu Identity and Access Management, KI-Agenten und DevOps: Erklärstücke, praktische Labs und News, mit Quellen.</description>
    <language>de</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/de/</link>
    </image>
    <atom:link href="https://iamops.dev/de/rss.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Downscoping beim Token Exchange für Agent-zu-Agent-Aufrufe erzwingen</title>
      <link>https://iamops.dev/de/enforce-downscoping-token-exchange-a2a/</link>
      <guid isPermaLink="true">https://iamops.dev/de/enforce-downscoping-token-exchange-a2a/</guid>
      <pubDate>Fri, 20 Nov 2026 08:00:00 GMT</pubDate>
      <dc:creator>Argo</dc:creator>
      <category>Labs</category>
      <category>Token Exchange</category>
      <category>Keycloak</category>
      <category>A2A</category>
      <category>RFC 8693</category>
      <category>KI-Agenten</category>
      <description>Keycloak-Labor für A2A-Agenten: Das Token, das B für C erhält, folgt den Scopes von B, nicht von A, ohne erzwungenes Downscoping. Lauf, Kontrolle, Abhilfe.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/de/enforce-downscoping-token-exchange-a2a.png?v=986e5733" alt="" /></p><p><strong>Kurz gesagt</strong></p>
<ul>
<li>Wenn Agent B für Agent A den Agenten C aufruft, tauscht B das Token von A gegen ein neues. In Keycloak 26.8.2 folgt der Scope dieses neuen Tokens den Scopes von B und nicht dem Token von A, solange Downscoping nicht erzwungen wird.</li>
<li>In meinem Lauf hatte A den Scope c.read, B hatte c.write als eigenen optionalen Scope, und der Austausch von B lieferte ein Token für A mit c.write. Agent C akzeptierte einen Schreibzugriff, den A nie erlaubt hatte.</li>
<li>Das ist B, das ein Recht nutzt, das es besitzt, kein Ausbruch. Ohne c.write bei B scheitert derselbe Austausch mit invalid_scope. Es ist eine Konfigurationslektion, keine Schwachstelle.</li>
<li>Eine Client-Policy mit dem Executor downscope-assertion-grant-enforcer beschränkt den Austausch auf die Scopes von A. Agent C sollte zusätzlich den act-Claim verlangen und den Scope pro Skill prüfen.</li>
<li>Ich habe nur Keycloak getestet. A2A 1.0.0 überlässt die Autorisierung der Implementierung, und die Agent Card hat kein Feld für Token Exchange.</li>
</ul>
<p>A2A 1.0.0 ist die aktuelle Version des Agent2Agent-Protokolls. Sie verlangt, dass ein Server jede Anfrage authentifiziert, und überlässt die Autorisierung der Implementierung. Was passiert, wenn Agent B den Agenten C im Auftrag von Agent A aufruft, regelt sie nicht. Dieser Teil ist gewöhnliches OAuth, und das übliche Werkzeug ist der Token Exchange (<a href="https://www.rfc-editor.org/rfc/rfc8693">RFC 8693</a>). Ich habe auf einem lokalen Keycloak eine kleine Kette gebaut und eine einzige Frage gestellt: Bleibt das Token, das B für C erhält, innerhalb dessen, was A übergeben hat?</p>
<p>Nein, außer man bittet Keycloak, es zu erzwingen. Um diese Einstellung geht es hier. Wenn Sie mein <a href="https://iamops.dev/de/keycloak-token-exchange-rfc-8693/">erstes Keycloak-Labor zum Token Exchange</a> gelesen haben: Dieses hier knüpft an die Falle „kein act-Claim“ an und ergänzt die Delegation.</p>
<h2>Was das Labor zeigt</h2>
<p>Drei Agenten und ein Autorisierungsserver, alle auf localhost.</p>
<ul>
<li><strong>A</strong> ist der Aufrufer. Es hält ein Token mit dem Scope <code>agent-b c.read</code>. Ein <code>may_act</code>-Claim in diesem Token nennt B als die Partei, die für A handeln darf.</li>
<li><strong>B</strong> ist ein Agent in der Mitte. Er empfängt den Aufruf von A und bittet dann Keycloak um ein Token für den Aufruf von C, mit dem Token von A als <code>subject_token</code> und seinem eigenen als <code>actor_token</code>.</li>
<li><strong>C</strong> ist ein kleiner Notizen-Agent mit einer Lese- und einer Schreib-Skill. Er akzeptiert nur delegierte Tokens und prüft den Scope pro Skill.</li>
</ul>
<table>
<thead>
<tr>
<th>Client</th>
<th>Rolle</th>
<th>Scopes, die er im Austausch anfordern kann</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>agent-a</code></td>
<td>Aufrufer, Service Account</td>
<td><code>agent-b</code> standardmäßig, <code>c.read</code> auf Anfrage</td>
</tr>
<tr>
<td><code>agent-b</code></td>
<td>Agent in der Mitte, führt den Austausch aus</td>
<td><code>c.read</code> und <code>c.write</code>, beide optional</td>
</tr>
<tr>
<td><code>agent-c</code></td>
<td>Notizen-Agent, nur Audience</td>
<td>keine</td>
</tr>
</tbody>
</table>
<figure class="b-fig"><img src="https://iamops.dev/media/enforce-downscoping-token-exchange-a2a/00-flow.webp" alt="Sequenzdiagramm: Agent A liest die Agent Card von B, holt ein Token von Keycloak, ruft B auf, und B tauscht es gegen ein delegiertes Token mit act-Claim, bevor es C aufruft." width="1800" height="766" loading="lazy" decoding="async"><figcaption><strong>Die Kette.</strong> Die Schritte 1 bis 4 sind der Aufruf von B durch A. Die Schritte 5 bis 7 zeigen, wie B das Token von A in ein delegiertes Token verwandelt. Die Schritte 8 bis 10 sind der Aufruf von C.</figcaption></figure>
<p>Jeder Agent veröffentlicht eine Agent Card unter <code>/.well-known/agent-card.json</code> mit einem <code>oauth2</code>-Sicherheitsschema und den Scopes pro Skill. Das Schema kann <code>clientCredentials</code> sagen und nichts, was dem Token Exchange näherkommt: Ein <code>OAuthFlows</code>-Objekt enthält genau einen Flow, und einen Austausch-Flow gibt es nicht. Deshalb steht es bei C im Beschreibungstext der Card, und ein Aufrufer muss ihn lesen.</p>
<h2>Aufbau</h2>
<p>Keycloak 26.8.2 aus dem Zip, Java 21, Entwicklungsmodus. Der Standard Token Exchange ist in 26.8 standardmäßig aktiv. Die Delegation, also die Claims <code>act</code> und <code>may_act</code>, nicht. Sie braucht zwei Preview-Funktionen.</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 gibt beim Start die aktivierten Preview-Funktionen aus. Ich habe die beiden zusammen aktiviert und nicht einzeln getestet. Ohne sie scheitert meine Kette: Keycloak lehnt in einem einfachen Austausch jedes Subject Token mit <code>may_act</code> ab, mit „Subject token with a delegation claim is not allowed for standard token exchange“.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/enforce-downscoping-token-exchange-a2a/01-features.webp" alt="Terminalausgabe: Keycloak 26.8.2 startet mit den aktivierten Preview-Funktionen parameterized-scopes und token-exchange-delegation, danach meldet das Realm-Skript realm a2a ready." width="1894" height="301" loading="lazy" decoding="async"><figcaption><strong>Funktionen und Realm.</strong> Keycloak 26.8.2 mit zwei aktiven Preview-Funktionen, danach das Realm-Skript.</figcaption></figure>
<p>Das Realm-Skript legt die drei Clients mit Service Accounts an, die Scopes <code>agent-b</code>, <code>c.read</code> und <code>c.write</code> (jeweils mit Audience-Mapper) und einen fest eingetragenen <code>may_act</code>-Mapper bei <code>agent-a</code>. Es schaltet außerdem Standard Token Exchange für <code>agent-b</code> ein und gibt <code>agent-b</code> die Scopes <code>c.read</code> und <code>c.write</code> als optionale Client Scopes. Merken Sie sich diesen letzten Punkt. Der ganze Beitrag hängt daran.</p>
<h2>Die Aufrufkette funktioniert</h2>
<p>A liest die Card von B, fordert bei Keycloak genau die Scopes an, die die Skill nennt, und sendet <code>message:send</code>. B tauscht das Token und ruft C auf. Das dekodierte delegierte Token behält A als <code>sub</code>, engt <code>aud</code> auf C ein, trägt nur <code>c.read</code> und ergänzt <code>act</code> für B.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/enforce-downscoping-token-exchange-a2a/02-chain.webp" alt="Terminalausgabe: Agent A liest die Agent Card von B, fordert die Scopes agent-b und c.read an und erhält von B eine 200-Antwort, die zwei bei C gespeicherte Notizen zusammenfasst." width="1894" height="263" loading="lazy" decoding="async"><figcaption><strong>Der legitime Weg.</strong> A bittet B, die Notizen zusammenzufassen. B tauscht das Token von A und liest sie bei C.</figcaption></figure>
<h2>Der Austausch, den A nie erlaubt hatte</h2>
<p>Jetzt fordert B <code>c.write</code> an. Das Token von A enthält kein <code>c.write</code>. Hier die Anfrage, mit Platzhaltern:</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 stellt das Token aus. <code>sub</code> ist A, <code>act</code> nennt B, <code>scope</code> ist <code>c.write</code>. C prüft Signatur, Audience, den <code>act</code>-Claim und den Scope, den seine Schreib-Skill verlangt, und fügt die Notiz hinzu.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/enforce-downscoping-token-exchange-a2a/03-stock.webp" alt="Terminalausgabe auf Standard-Keycloak: Agent B führt c.write unter seinen optionalen Scopes auf, das Token von A hat den Scope agent-b c.read, das Token, das B für Agent C erhält, hat den Scope c.write mit act agent-b, und C antwortet, dass die Notiz hinzugefügt wurde." width="1894" height="1218" loading="lazy" decoding="async"><figcaption><strong>Standard-Keycloak.</strong> Das Token von A sagt c.read. Das Token für C sagt c.write. C fügt die Notiz hinzu. Ids sind durch Platzhalter ersetzt.</figcaption></figure>
<p>Ich habe die ganze Abfolge viermal auf einem frischen Keycloak 26.8.2 ausgeführt, zweimal mit den Lab-Skripten und zweimal mit denen aus diesem Beitrag, und jedes Mal dasselbe Ergebnis erhalten.</p>
<h2>Die Kontrolle: B besitzt c.write</h2>
<p>Bevor ich das Eskalation nenne, habe ich geprüft, wessen Recht hier genutzt wird. In meinem Realm hat B <code>c.write</code> als eigenen optionalen Scope. Ich habe ihn dort eingetragen. B hat also nichts erhalten, was es nie hätte haben dürfen. Ich habe <code>c.write</code> aus den optionalen Scopes von B entfernt und denselben Austausch wiederholt.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/enforce-downscoping-token-exchange-a2a/04-control.webp" alt="Terminalausgabe des Kontrolllaufs: Nachdem c.write aus den optionalen Client Scopes von Agent B gelöscht wurde, wird derselbe Austausch mit invalid_scope abgelehnt, Invalid scopes: c.write." width="1894" height="225" loading="lazy" decoding="async"><figcaption><strong>Die Kontrolle.</strong> Ohne c.write bei B wird nichts ausgestellt. B bleibt innerhalb seiner eigenen Rechte.</figcaption></figure>
<p>Damit ist eines geklärt. B kann nicht über das hinausgehen, was es selbst besitzt, und es liegt kein Bug im Sinne einer Umgehung vor. Verloren geht etwas anderes: Der Scope des neuen Tokens wird durch den Scope-Vorrat von B begrenzt und nicht durch das Token von A. A hatte „lesen“ gesagt, und einen Schritt weiter bedeutete das nichts mehr. RFC 8693 überlässt das dem Server: <code>scope</code> ist „the desired scope of the requested security token“, und seine Werte sind „service specific“ (<a href="https://www.rfc-editor.org/rfc/rfc8693#section-2.1">Abschnitt 2.1</a>). Nichts verlangt, dass das Ergebnis eine Teilmenge des Subject Tokens ist.</p>
<p>Für Agenten ist das wichtig, weil C <code>sub</code> A und <code>act</code> B protokolliert. Wer das Log liest, sieht „A hat eine Notiz geschrieben“. A hat dem nie zugestimmt.</p>
<h2>Den Austausch mit der Downscope-Policy begrenzen</h2>
<p>Keycloak hat dafür einen Executor für Client-Policies: <code>downscope-assertion-grant-enforcer</code>. Er begrenzt die Scopes des neuen Tokens auf die, die schon im Subject Token stehen, und antwortet sonst mit <code>invalid_scope</code>. Er braucht keine Konfiguration. Ich habe ihn mit einer einzigen Policy auf alle Clients des Realms angewendet.</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>Mit <code>c.write</code> wieder bei B und aktiver Policy wird der Austausch abgelehnt. Der legitime Austausch mit <code>c.read</code> funktioniert weiterhin.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/enforce-downscoping-token-exchange-a2a/05-enforcer.webp" alt="Terminalausgabe bei aktiver Downscope-Policy: Der Austausch mit c.write wird abgelehnt, weil c.write nicht im ursprünglichen Access Token steht, und der Austausch mit c.read liefert weiterhin ein delegiertes Token, das C akzeptiert." width="1894" height="836" loading="lazy" decoding="async"><figcaption><strong>Mit der Policy.</strong> c.write wird abgelehnt, weil das Token von A es nicht trägt. c.read funktioniert weiterhin. C listet auch die Notiz aus dem Standardlauf auf.</figcaption></figure>
<p>Die letzte Zeile dieser Ausgabe ist die Notiz aus dem Standardlauf. Sie bleibt, bis Sie C neu starten.</p>
<h2>Was C zusätzlich prüfen sollte</h2>
<p>Die Policy lebt auf dem Autorisierungsserver. C sollte sich nicht allein darauf verlassen.</p>
<ul>
<li>Verlangen Sie den <code>act</code>-Claim und prüfen Sie <code>act.client_id</code> gegen die Agenten, die Sie erwarten. Mein C antwortet ohne ihn mit 403.</li>
<li>Prüfen Sie den Scope pro Skill. Mein C braucht <code>c.read</code> zum Lesen und <code>c.write</code> zum Schreiben.</li>
<li>Prüfen Sie <code>aud</code>. Ein Token für B wird von C mit 401 abgelehnt.</li>
<li>Behandeln Sie <code>may_act</code> nicht als Beweis. Als B das Token von C als Actor vorlegte, lehnte Keycloak mit einer Audience-Meldung ab. Ob es den Actor mit <code>may_act</code> vergleicht, habe ich nicht untersucht.</li>
</ul>
<h2>Stolperfallen</h2>
<ul>
<li><strong>Der Enforcer und ein Audience-Mapper auf Client-Ebene.</strong> In meinem ersten Aufbau lag die Audience von C in einem Mapper am Client B. Mit aktivem Enforcer scheiterte dann jeder Austausch mit „Requested audience not available: agent-c“. Der Umzug des Mappers auf die Scopes <code>c.read</code> und <code>c.write</code> löste es. Warum, weiß ich nicht. Testen Sie es in Ihrem eigenen Realm.</li>
<li><strong>Audience über Scopes hat einen Nebeneffekt.</strong> <code>c.read</code> trägt die Audience von C, daher hat das Token von A <code>aud</code> B und C. Was A daran hindert, es bei C zu nutzen, ist die <code>act</code>-Pflicht, nicht die Audience.</li>
<li><strong>Die Fehlermeldung beim falschen Actor ist vage.</strong> Der Client sieht <code>access_denied</code> und „Client is not within the token audience“. Das Keycloak-Ereignisprotokoll nennt den Actor.</li>
<li><strong><code>may_act</code> ist in meinem Realm fest eingetragen.</strong> In einem echten System sollte es aus einer Policy stammen und mit dem Token leben.</li>
</ul>
<h2>Was ich nicht ausgeführt habe</h2>
<p>Ich habe nur Keycloak 26.8.2 ausgeführt. Entra On-Behalf-Of, Okta und Auth0 habe ich nicht getestet und mache daher keine Aussage dazu, wie sie den Scope im Austausch begrenzen. Nur eine Delegationsstufe: keine verschachtelte <code>act</code>-Kette. Keine Tasks, kein Streaming, keine signierten Agent Cards, kein TLS und keine senderbeschränkten Tokens. Kein Nutzer in der Kette: Das Subject ist der Service Account von Agent A. Die Agenten sind meine eigenen Flask-Programme, und ihre Client Secrets sind statische Lab-Werte.</p>
<p><em>Die Terminalbilder wurden aus der gespeicherten Ausgabe der Läufe neu gezeichnet, mit durch Platzhalter ersetzten Ids. Nichts davon sind echte Zugangsdaten.</em></p>
<p>Zu den Standards dahinter siehe <a href="https://iamops.dev/de/id-jag-explained/">ID-JAG erklärt</a> und <a href="https://iamops.dev/de/mcp-server-no-token-passthrough/">warum ein MCP-Server Tokens nicht durchreichen darf</a>.</p>
]]></content:encoded>
    </item>
    <item>
      <title>Von GitHub Actions nach Azure mit Workload Identity Federation: welche Läufe ein Token bekommen, und warum</title>
      <link>https://iamops.dev/de/github-actions-azure-workload-identity-federation/</link>
      <guid isPermaLink="true">https://iamops.dev/de/github-actions-azure-workload-identity-federation/</guid>
      <pubDate>Fri, 20 Nov 2026 08:00:00 GMT</pubDate>
      <dc:creator>Argo</dc:creator>
      <category>Labs</category>
      <category>GitHub Actions</category>
      <category>OIDC</category>
      <category>Entra ID</category>
      <category>Workload-Identität</category>
      <category>Azure</category>
      <description>Lab: Ein GitHub-Workflow meldet sich ohne Secret bei Azure an. Ich zeige den sub von sechs Laufarten und welches Credential jede zulässt, auch Pull Requests.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/de/github-actions-azure-workload-identity-federation.png?v=986e5733" alt="" /></p><p><strong>Kurz gesagt</strong></p>
<ul>
<li>Ein GitHub-Workflow kann sich ohne Client Secret bei Azure anmelden: GitHub signiert ein kurzlebiges Token, und ein Federated Credential in Entra vertraut genau einem sub-Claim.</li>
<li>Neue Repositories senden einen unveränderlichen sub mit Owner- und Repository-ID. Legen Sie zuerst das Repository an, lesen Sie die IDs und schreiben Sie dann das Credential.</li>
<li>Mit nur einem Credential für main ging 1 von 6 Laufarten durch. Ein Credential für das Environment, eines für pull_request und zwei Wildcard-Expressions brachten 6 von 6.</li>
<li>pull_request und pull_request_target senden denselben sub. Ein pull_request-Credential vertraut also auch pull_request_target-Jobs, die mit Secrets laufen. Checken Sie dort nie den Head des Pull Requests aus.</li>
<li>Pull Requests aus Forks habe ich nicht getestet. Laut GitHub-Doku bekommen sie keine Schreibrechte, ich erwarte also kein Token, habe es aber nicht gesehen.</li>
</ul>
<p>Eine Deployment-Pipeline mit einem Client Secret darin ist ein Secret, das auf sein Leck wartet. GitHub Actions kann sich ohne Secret bei Azure anmelden: GitHub signiert für den Job ein kurzlebiges OIDC-Token, und Entra vertraut ihm über ein Federated Credential. Dieses Jahr hat sich zweierlei geändert. Seit dem 15. Juli 2026 bekommen neue Repositories einen <a href="https://github.blog/changelog/2026-04-23-immutable-subject-claims-for-github-actions-oidc-tokens/">unveränderlichen sub-Claim</a> mit Owner- und Repository-ID, und die Wildcard-Credentials von Entra sind noch in Preview. Beides habe ich in einem <a href="https://iamops.dev/de/workload-identity-news-immutable-sub-entra-wildcards-workos/">News-Beitrag</a> zusammengefasst. Dieses Lab ist der praktische Teil.</p>
<h2>Was dieses Lab zeigt</h2>
<p>Eine App-Registrierung mit Reader auf einer einzigen leeren Ressourcengruppe, ein privates Repository, nirgends ein Secret. Das Lab:</p>
<ol>
<li>Vertraut dem Branch main mit einem exakten Credential und sieht <code>azure/login</code> gelingen.</li>
<li>Pusht einen Feature-Branch, öffnet einen Pull Request und sieht beide mit AADSTS700213 abgelehnt.</li>
<li>Erlaubt <code>release/*</code> mit einer Claims-Matching-Expression.</li>
<li>Gibt den genauen <code>sub</code> von sechs Laufarten aus und legt dann die Credentials an, mit denen jede durchgeht.</li>
<li>Betrachtet Pull Requests aus Forks, nur anhand der Doku, weil ich sie nicht testen konnte.</li>
</ol>
<h2>Aufbau</h2>
<p>Verwenden Sie einen Tenant und ein Abonnement nur zum Testen und ein GitHub-Konto, das Ihnen gehört. Die App-Registrierung bekommt Reader auf eine leere Ressourcengruppe. Ein erfolgreicher Login beweist so die Federation und sonst nichts. Die drei IDs, die der Workflow braucht (Client, Tenant, Abonnement), sind keine Secrets und kommen in Repository-Variablen.</p>
<p>Legen Sie das Repository vor dem Credential an. Ein neues Repository sendet <code>repo:&lt;owner&gt;@&lt;owner-id&gt;/&lt;repo&gt;@&lt;repo-id&gt;:...</code>, und die beiden IDs kennen Sie erst, wenn das Repository existiert. Ein Subject nach alter Art, <code>repo:&lt;owner&gt;/&lt;repo&gt;:ref:refs/heads/main</code>, passt nicht mehr.</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>Der Lauf</h2>
<p><strong>main meldet sich an.</strong> Der Workflow gibt die Claims aus, die GitHub vorlegt, führt dann <code>azure/login</code> aus und listet die Ressourcengruppen. Mein erster Lauf scheiterte nach dem Login mit &quot;No subscriptions found&quot;, weil die Reader-Rolle noch nicht verteilt war. Eine Minute Warten hat es behoben.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/github-actions-azure-workload-identity-federation/01-main.webp" alt="Terminalausgabe: das Federated Credential gh-main mit exaktem Subject für den Branch main, dann ein Lauf auf main, der erfolgreich endet, denselben sub-Claim ausgibt, die Ressourcengruppe listet und die Anmeldung als Service Principal zeigt. IDs sind Platzhalter." width="1894" height="492" loading="lazy" decoding="async"><figcaption><strong>Der sub passt Zeichen für Zeichen.</strong> Das Credential ist die ganze Vertrauensbeziehung. Es gibt kein Secret anzulegen und nichts zu rotieren. IDs sind Platzhalter.</figcaption></figure>
<p><strong>Ein Feature-Branch und ein Pull Request werden abgelehnt.</strong> Gleicher Workflow, anderer <code>sub</code>. Entra antwortet mit AADSTS700213, und die Meldung nennt das empfangene Subject. Schneller lässt sich ein Credential nicht debuggen.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/github-actions-azure-workload-identity-federation/02-feature-refused.webp" alt="Terminalausgabe: ein Push auf feature-x und ein Pull Request enden beide mit Fehler AADSTS700213, kein passender Federated-Identity-Eintrag. Die vorgelegten Subjects enden auf ref:refs/heads/feature-x und pull_request. IDs sind Platzhalter." width="1894" height="454" loading="lazy" decoding="async"><figcaption><strong>Abgelehnt, und zwar absichtlich.</strong> Ein Tippfehler im Branch-Namen oder ein ungeprüfter Pull Request bekommt die Deployment-Identität nicht. IDs sind Platzhalter.</figcaption></figure>
<p><em><em>release/</em> mit einer Expression.</em>* Ein flexibles Federated Credential enthält statt eines Subjects eine <code>claimsMatchingExpression</code>. Für App-Registrierungen habe ich es mit <code>az rest</code> über den Graph-Beta-Endpunkt angelegt. Ich bin der Microsoft-Doku gefolgt und habe zusätzlich <code>repository_id</code> festgelegt:</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="Terminalausgabe: az rest legt das Credential gh-release mit einer Claims-Matching-Expression auf sub für release-Branches plus einer Prüfung von repository_id an, dann endet ein Push auf release/1 erfolgreich und gibt seinen sub aus. IDs sind Platzhalter." width="1894" height="492" loading="lazy" decoding="async"><figcaption><strong>Ein Credential für eine ganze Familie von Branches.</strong> Das Muster behält Owner- und Repository-ID, und repository_id wird separat geprüft. IDs sind Platzhalter.</figcaption></figure>
<h2>Vertiefte Prüfung: der sub jeder Laufart</h2>
<p>Ein Leser fragte, ob die Ablehnung eines Feature-Branches und eines Pull Requests ein Fehler ist. Ist sie nicht, und ich wollte es zeigen. Ein kleines Skript, <code>probe.sh</code>, holt bei GitHub ein Token, dekodiert den <code>sub</code>, bietet das Token Entra an und gibt eine Ergebniszeile aus. Der Workflow führt es bei einem Push auf main, einem Push auf einen Feature-Branch, <code>pull_request</code>, <code>pull_request_target</code>, einem Tag-Push und in einem zweiten Job mit Environment aus. Ich habe eine neue App und dasselbe private Repository verwendet.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/github-actions-azure-workload-identity-federation/04-subs-before.webp" alt="Terminalausgabe: eine Tabelle mit sechs Läufen und nur dem main-Credential. main geht durch. Die Läufe für Feature-Branch, Pull Request, pull_request_target, Tag und Environment scheitern mit AADSTS700213. Jede Zeile zeigt den sub nach dem Repository-Präfix." width="1894" height="416" loading="lazy" decoding="async"><figcaption><strong>1 von 6 geht durch.</strong> Der Teil nach den IDs ist für jede Laufart anders, und ein Credential für main passt nur auf main.</figcaption></figure>
<p>Dann habe ich vier Credentials hinzugefügt: ein exaktes für das Environment, ein exaktes für <code>pull_request</code> und zwei Expressions für <code>feature-*</code>-Branches und <code>v*</code>-Tags. Danach habe ich dieselben Läufe wiederholt.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/github-actions-azure-workload-identity-federation/05-subs-after.webp" alt="Terminalausgabe: die vier zusätzlichen Credentials mit Name und Muster, dann dieselbe Tabelle mit sechs Läufen, in der jede Zeile durchgeht. Der Platzhalter prefix steht für den Repository-Teil des sub mit Owner- und Repository-ID." width="1894" height="568" loading="lazy" decoding="async"><figcaption><strong>6 von 6 gehen durch.</strong> &lt;prefix&gt; steht für repo:&lt;owner&gt;@&lt;id&gt;/&lt;repo&gt;@&lt;id&gt;. Ein Credential enthält entweder ein exaktes Subject oder eine Expression, nie beides.</figcaption></figure>
<table>
<thead>
<tr>
<th>Lauf</th>
<th><code>sub</code> nach dem Repository-Präfix</th>
<th>Credential, mit dem er durchgeht</th>
<th>Nur main</th>
<th>Danach</th>
</tr>
</thead>
<tbody>
<tr>
<td>Push auf main</td>
<td><code>ref:refs/heads/main</code></td>
<td>Exaktes Subject</td>
<td>Durch</td>
<td>Durch</td>
</tr>
<tr>
<td>Push auf feature-probe</td>
<td><code>ref:refs/heads/feature-probe</code></td>
<td>Expression <code>...ref:refs/heads/feature-*</code></td>
<td>AADSTS700213</td>
<td>Durch</td>
</tr>
<tr>
<td><code>pull_request</code></td>
<td><code>pull_request</code></td>
<td>Exaktes Subject</td>
<td>AADSTS700213</td>
<td>Durch</td>
</tr>
<tr>
<td><code>pull_request_target</code></td>
<td><code>pull_request</code></td>
<td>Dasselbe <code>pull_request</code>-Credential</td>
<td>AADSTS700213</td>
<td>Durch</td>
</tr>
<tr>
<td>Tag v1</td>
<td><code>ref:refs/tags/v1</code></td>
<td>Expression <code>...ref:refs/tags/v*</code></td>
<td>AADSTS700213</td>
<td>Durch</td>
</tr>
<tr>
<td>Job mit Environment lab-b1-prod</td>
<td><code>environment:lab-b1-prod</code></td>
<td>Exaktes Subject</td>
<td>AADSTS700213</td>
<td>Durch</td>
</tr>
</tbody>
</table>
<p><strong>Ein Unterschied zur Microsoft-Doku.</strong> Die Expressions für <code>feature-*</code> und <code>v*</code> hatten nur eine Bedingung auf <code>sub</code>, ohne <code>repository_id</code>. Entra hat beide akzeptiert, und die Läufe gingen durch. Meine Muster enthielten Owner- und Repository-ID bereits, sie waren also trotzdem festgelegt. In einer späteren Prüfung am selben Tag akzeptierte Entra auch eine Expression für den gesamten Owner ohne <code>repository_id</code> oder <code>repository_owner_id</code>, und dieses Credential stellte einem anderen Repository desselben Owners ein Token aus. Laut Microsoft muss eine Expression für GitHub <code>sub</code> und <code>repository_id</code> oder <code>repository_owner_id</code> prüfen. Ich empfehle dennoch, <code>repository_id</code> in jede Expression aufzunehmen. Die Regel ist dokumentiert und die Funktion ist in Preview, ein Credential nur auf sub kann also später abgelehnt werden oder nicht mehr passen. Die ID-Prüfung hängt auch nicht davon ab, dass das Muster stimmt: Ein Wildcard für den gesamten Owner hat bereits einem anderen meiner Repositories ein Token ausgestellt, und der reine Namens-<code>sub</code> eines älteren Repositorys kann auf einen Namen passen, der Ihnen nicht mehr gehört.</p>
<h2>pull_request und pull_request_target teilen ein Subject</h2>
<p>Beide Ereignisse senden einen <code>sub</code>, der auf <code>pull_request</code> endet, egal welcher Branch. Ein <code>pull_request</code>-Credential in Entra vertraut also auch <code>pull_request_target</code>-Jobs. Diese laufen vom Basis-Branch, mit Secrets und mit OIDC-Token. Checkt ein solcher Workflow den Head des Pull Requests aus, führt der Autor des Pull Requests Code mit Ihrer Cloud-Identität aus. Mein Probe-Workflow nutzte den Standard-Checkout, der den Basis-Branch nimmt. Ändern Sie das nicht in einem Workflow, der ein Token bekommen kann.</p>
<p>Ein Job mit Environment ist die zweite Überraschung. Er sendet <code>environment:&lt;name&gt;</code> statt des Branches. Wer einen Deploy-Job in ein Environment verschiebt, bricht ein Credential, das für main geschrieben wurde.</p>
<h2>Pull Requests aus Forks: aus der Doku, nicht getestet</h2>
<p>Einen Pull Request aus einem Fork habe ich nicht getestet. Dafür braucht es ein zweites GitHub-Konto, und ich nutze keines, das nicht mir gehört. Was folgt, ist die GitHub-Doku und meine Lesart davon.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/github-actions-azure-workload-identity-federation/06-forks-docs.webp" alt="Terminalausgabe mit drei aus der GitHub-Doku zitierten Sätzen: Secrets werden nicht an Workflows aus Forks übergeben, das GITHUB_TOKEN hat in Pull Requests aus Forks nur Leserechte, und Schreibrechte werden für Pull-Request-Ereignisse außer pull_request_target aus einem Fork auf Lesen reduziert." width="1894" height="416" loading="lazy" decoding="async"><figcaption><strong>Nur Doku, kein Test.</strong> Die Zeilen sind direkt von den GitHub-Seiten ausgegeben, damit Sie den Wortlaut prüfen können.</figcaption></figure>
<p><code>id-token: write</code> ist ein Schreibrecht. Bei einem <code>pull_request</code> aus einem Fork wird es auf Lesen reduziert. Nach meiner Lesart bekommt der Job also gar kein OIDC-Token. <code>probe.sh</code> behandelt diesen Fall und würde &quot;no OIDC token was offered&quot; ausgeben. Gesehen habe ich es nicht. <code>pull_request_target</code> ist in dieser Doku die Ausnahme, und das ist die Falle von oben.</p>
<h2>Stolpersteine</h2>
<ul>
<li><strong>Lesen Sie den <code>sub</code> aus einem echten Lauf, bevor Sie ein Credential schreiben.</strong> Die Log-Zeile und die Meldung AADSTS700213 zeigen ihn beide.</li>
<li><strong>Warten Sie nach der Rollenzuweisung.</strong> Ohne Wartezeit klappte der Login, und der nächste Befehl scheiterte mit &quot;No subscriptions found&quot;.</li>
<li><strong>Expressions sind Preview und Graph Beta.</strong> Für App-Registrierungen habe ich <code>az rest</code> verwendet. Die Konzeptseite von Microsoft sagt, die CLI unterstütze sie noch nicht explizit, während <code>az identity federated-credential</code> (benutzerseitig zugewiesene verwaltete Identitäten) dafür Preview-Parameter auflistet.</li>
<li><strong>Alte Repositories behalten den reinen Namens-<code>sub</code></strong>, bis jemand umstellt. Schreiben Sie das Credential für das Format, das das Repository wirklich sendet.</li>
</ul>
<h2>Was das für die Sicherheit heißt</h2>
<ol>
<li>Nutzen Sie in der CI Federation statt eines Client Secrets. Es gibt nichts zu speichern, zu verlieren oder zu rotieren.</li>
<li>Nehmen Sie das engste passende Credential: exakt für main und für ein Environment, eine Expression nur für eine echte Familie von Refs.</li>
<li>Behalten Sie Owner- und Repository-ID in jedem Subject und Muster, und nehmen Sie <code>repository_id</code> in jede Expression auf.</li>
<li>Gehen Sie davon aus, dass ein <code>pull_request</code>-Credential auch <code>pull_request_target</code> vertraut. Checken Sie in einem Workflow, der ein Token bekommen kann, nie fremden Code aus.</li>
<li>Löschen Sie Credentials, deren Repository nicht mehr existiert. Mit dem alten Namensformat kann sich jemand anderes den Namen holen.</li>
</ol>
<h2>Aufräumen</h2>
<p>Ich habe die App-Registrierung gelöscht, was ihre Credentials entfernt, die Ressourcengruppe gelöscht, geprüft, dass beide weg sind, und das private Repository archiviert. Nach der vertieften Prüfung habe ich auch die zusätzliche App, den Branch, das Tag, den Pull Request, das Environment und die Variablen entfernt.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/github-actions-azure-workload-identity-federation/07-cleanup.webp" alt="Terminalausgabe: App-Registrierung und Ressourcengruppe werden gelöscht, az group exists gibt false aus, die Anzahl der Apps ist 0 und das Repository wird archiviert." width="1894" height="377" loading="lazy" decoding="async"><figcaption><strong>Nichts läuft weiter.</strong> Es wurde nie ein Secret angelegt, also gibt es nichts zu widerrufen.</figcaption></figure>
<h2>Was nicht ausgeführt wurde</h2>
<ul>
<li>Ein Pull Request aus einem Fork. Dieser Teil stützt sich auf die GitHub-Doku.</li>
<li>Ein bestehendes Repository, das auf das unveränderliche Format umgestellt wurde, und der Preview-Endpunkt von GitHub für das Subject-Präfix.</li>
<li>Eine Rolle, die deployen darf. Die App hatte nur Reader auf einer leeren Ressourcengruppe.</li>
<li>Eine Expression mit <code>repository_owner_id</code> oder <code>job_workflow_ref</code>.</li>
<li>Andere Clouds. GitHub dokumentiert AWS, Google Cloud und Vault, ich habe nur Azure getestet.</li>
</ul>
<p><em>Ausgeführt am 20. November 2026 mit der Azure CLI, der GitHub CLI und <code>azure/login@v2</code> auf einem von GitHub gehosteten Runner, in einem Test-Tenant und einem privaten Repository. Die Terminalbilder wurden aus der gespeicherten Ausgabe neu gezeichnet, Benutzer, IDs und Zeitstempel sind durch Platzhalter ersetzt.</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>Notizen zu IETF 127: ID-JAG, Workload-Grants und Transaction Tokens für die Delegation an Agenten</title>
      <link>https://iamops.dev/de/ietf-127-id-jag-workload-grants-transaction-tokens/</link>
      <guid isPermaLink="true">https://iamops.dev/de/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>Workload-Identität</category>
      <category>Transaction Tokens</category>
      <category>KI-Agenten</category>
      <category>Standards</category>
      <description>Meine Lesart der OAuth- und WIMSE-Sitzungen von IETF 127: ID-JAG, Workload Authorization Grant, Transaction Tokens und Akteure, mit den Draft-Revisionen.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/de/ietf-127-id-jag-workload-grants-transaction-tokens.png?v=986e5733" alt="" /></p><p><strong>Kurz gesagt</strong></p>
<ul>
<li>Auf der IETF 127 wurde die Delegation an Agenten in drei Fällen behandelt: ein Benutzer (ID-JAG), ein Workload, der für sich selbst handelt (Workload Authorization Grant, WAG), und eine laufende Transaktion (ein Transaction-Token-Grant).</li>
<li>ID-JAG steht bei Draft -06 und ist weiterhin ein Dokument der OAuth-Arbeitsgruppe. Just-in-Time-Provisionierung und Key Binding wandern in eigene Drafts, offen bleibt der Gateway in der Mitte.</li>
<li>WAG, das Transaction-Token-Profil, Transactional Access Tokens, das Actor Profile und die drei neuesten Delegations-Drafts sind individuelle Drafts. Nichts davon ist angenommen oder final.</li>
<li>Für eigene Entwürfe: jeden Agentenfluss nach dem Principal einordnen, das eingehende Token nie an den nächsten Hop weiterreichen und die Draft-Revision in jedes Design schreiben, das davon abhängt.</li>
</ul>
<p>Die IETF 127 fand diese Woche in San Francisco statt. Ich war nicht dabei. Ich habe die Folien, die Mitschriften der Freiwilligen und die aktuellen Drafts der OAuth- und WIMSE-Sitzungen gelesen und am 20. November 2026 Name und Revision jedes Drafts auf datatracker.ietf.org geprüft.</p>
<p>Die OAuth-Sitzung war am Mittwoch, dem 18. November. WIMSE traf sich am selben Abend (22:00 UTC), und die gemeinsame Sitzung von OAuth und WIMSE folgte am Donnerstag, dem 19. November. OAuth hat heute noch eine Sitzung, die beim Schreiben noch nicht stattgefunden hat. Ich zitiere die Mitschriften als Mitschriften. Sie sind keine Beschlüsse.</p>
<h2>Drei Grants für drei Arten von Principals</h2>
<p>In der gemeinsamen Sitzung schlug Justin Richer eine einfache Einteilung vor, festgehalten in den <a href="https://notes.ietf.org/notes-ietf-127-wimse">WIMSE-Notizen</a>: ID-JAG betrifft eine Person, WAG einen Workload und &quot;TAG&quot; eine laufende Transaktion. &quot;TAG&quot; ist ein Spitzname aus der Diskussion. Es ist weder ein Draft noch ein registrierter Name.</p>
<table>
<thead>
<tr>
<th>Fall</th>
<th>Draft, den ich geprüft habe</th>
<th>Stand</th>
</tr>
</thead>
<tbody>
<tr>
<td>Ein Benutzer</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>Dokument der OAuth-Arbeitsgruppe, veröffentlicht am 31. Okt. 2026</td>
</tr>
<tr>
<td>Ein Workload, der für sich selbst handelt</td>
<td><a href="https://datatracker.ietf.org/doc/draft-carleton-workload-authz-grant/">draft-carleton-workload-authz-grant-02</a> (WAG)</td>
<td>Individueller Draft, &quot;Informational&quot;, veröffentlicht am 2. Nov. 2026</td>
</tr>
<tr>
<td>Eine laufende Transaktion</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>Individueller Draft, veröffentlicht am 26. Okt. 2026</td>
</tr>
</tbody>
</table>
<p>ID-JAG und das Transaction-Token-Profil sind beide Profile von <a href="https://datatracker.ietf.org/doc/draft-ietf-oauth-identity-chaining/">Identity Chaining</a>. Dieser Draft steht bei -17, und der Datatracker zeigt ihn in der Warteschlange des RFC Editors mit dem Status &quot;blocked: Final Approval Pending&quot;. Die WIMSE-Notizen nennen ihn &quot;RFC 10092 (to be)&quot;. Der Datatracker zeigt noch keine RFC-Nummer, deshalb würde ich keine nennen.</p>
<figure class="b-fig"><img src="https://iamops.dev/img/ietf-127-id-jag-workload-grants-transaction-tokens.de.svg" alt="Drei Spalten, eine je Art von Principal. Ein Benutzer entspricht ID-JAG, einem Dokument der OAuth-Arbeitsgruppe. Ein Workload entspricht WAG, einem individuellen Entwurf. Eine Transaktion entspricht dem Txn-Token-Chaining-Profil, ebenfalls einem individuellen Entwurf. Alle drei führen zu einem Authorization Server, der ein Token mit der nächsten API als Audience ausstellt." width="1200" height="630" loading="lazy" decoding="async"><figcaption><strong>Drei Principals, drei Grants.</strong> Das ist meine eigene Zusammenfassung der Aufteilung, keine Grafik aus den Folien. Stand: 20. November 2026.</figcaption></figure>
<h2>ID-JAG bei Draft -06</h2>
<p>Die ID-JAG-Folien listen die Änderungen von -05 und -06 auf. Diese würde ich zuerst lesen:</p>
<ul>
<li>Ein schlüsselgebundenes ID-JAG kann die Client-Authentifizierung am Authorization Server der Ressource ersetzen.</li>
<li>Token Exchange ist auf eine einzige Audience beschränkt. Eine unbekannte Audience erhält <code>invalid_target</code>.</li>
<li>mTLS-Binding wurde ergänzt, und ein DPoP-gebundenes ID-JAG verlangt den Grant-Typ <code>jwt-dpop</code>.</li>
<li>Ein neuer Abschnitt Subject Identifier Mapping, Tenant-Prüfungen und ein Metadatenwert <code>id_jag_signing_alg_values_supported</code>.</li>
<li>Ein Abschnitt Privacy Considerations.</li>
</ul>
<p>Die <a href="https://datatracker.ietf.org/meeting/127/materials/slides-127-oauth-sessa-identity-assertion-jwt-authorization-grant-00">Folien</a> nennen auch, wer es implementiert. Auf der Liste stehen unter anderem Okta, Ping, Auth0, Descope, Keycloak, WorkOS und Oracle OCI IAM. Die Grundlagen habe ich in <a href="https://iamops.dev/de/id-jag-explained/">ID-JAG explained</a> beschrieben.</p>
<p>Aus der Implementierungserfahrung kamen drei Themen, und jedes landete woanders als im Kern-Draft:</p>
<ul>
<li><strong>Just-in-Time-Provisionierung</strong> (Issues #83 und #121). Empfohlen wird eine spätere Erweiterung. Eine App kann einen Benutzer jetzt zum ersten Mal über ein ID-JAG kennenlernen, und eigene Claims sind erlaubt, aber nicht zwingend interoperabel.</li>
<li><strong>Key Binding</strong> (Issue #103). Die Folien nennen die fehlenden Teile in <a href="https://datatracker.ietf.org/doc/draft-mcguinness-oauth-token-exchange-cnf/">draft-mcguinness-oauth-token-exchange-cnf</a> und <a href="https://datatracker.ietf.org/doc/draft-parecki-oauth-jwt-dpop-grant/">draft-parecki-oauth-jwt-dpop-grant</a> und fragen, ob das Key Binding in eine eigene Erweiterung gehört. In den Notizen sagte Hannes, das Auslagern in andere Dokumente lasse den Draft unfertig wirken. Aaron Parecki antwortete, die Provisionierung sei optional und das Binding gelte breiter als ID-JAG.</li>
<li><strong>Gateways und Proxys</strong> (Issue #114). Ein Gateway in der Mitte führt den Token Exchange aus, aber die Audience des ID-Tokens ist der Client, der das Gateway aufgerufen hat, und die Audience-Prüfung schlägt fehl. Die Folien schlagen vor, Topologien mit Vermittlern für außerhalb des Umfangs zu erklären, und verweisen auf <a href="https://datatracker.ietf.org/doc/draft-mcguinness-oauth-id-continuation-assertion/">draft-mcguinness-oauth-id-continuation-assertion</a> als Erweiterung.</li>
</ul>
<p>Die Autoren baten um Interim-Treffen zu Gateways und Key Binding. Die nächsten Schritte auf den Folien: die übrigen Issues in -07 einarbeiten oder ausdrücklich zurückstellen und danach den Working Group Last Call anfragen.</p>
<p>Meine Meinung: Der Kern-Grant wirkt stabil genug, um darauf aufzubauen. Ein Design mit einem Gateway in der Mitte würde ich noch nicht darauf stützen, denn genau diesen Fall haben die Autoren selbst ausgelagert.</p>
<h2>WAG: die Workload-Variante</h2>
<p>Der WAG-Draft beschreibt eine Plattform, deren Workload Identity Provider einen JWT-Grant nach <a href="https://www.rfc-editor.org/rfc/rfc7523">RFC 7523</a> signiert, der genau einen Workload benennt. Der Authorization Server eines Dritten wird einmalig so konfiguriert, dass er diesem Provider vertraut, und lehnt einen Workload nicht ab, nur weil er ihn noch nie gesehen hat. Der Draft nennt einen KI-Agenten als Ausgangsfall und erklärt den Zugriff im Namen eines Benutzers für außerhalb des Umfangs.</p>
<p>Er sagt auch klar, dass er ein früher, explorativer individueller Draft ist und kein Dokument der Arbeitsgruppe. In der WIMSE-Sitzung sagte Aaron Parecki, ID-JAG gehe im Kern um einen Benutzer, und ohne Benutzer sehe der Fall nach WAG aus. Jeff Lombardo sagte, er unterstütze die Annahme ausdrücklich. Karl McGuinness plädierte dafür, die Principal-Typen getrennt zu halten, statt den Empfänger den Typ aus Claims ableiten zu lassen. Die Notizen halten keinen Einwand gegen die Idee fest. Einen Aufruf zur Annahme halten sie ebenfalls nicht fest.</p>
<p>Auch die Client-Identität kam zur Sprache. Justin Richers Vortrag <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> nannte als Optionen dynamische Registrierung, eine Metadaten-URL (CIMD), eine Client-ID als JWT und eine SPIFFE-ID. Der Draft <a href="https://datatracker.ietf.org/doc/draft-ietf-oauth-spiffe-client-auth/">SPIFFE client authentication</a> steht bei -03 (2. November) und deckt nur den Token-Endpunkt ab.</p>
<p>Zwei weitere WIMSE-Punkte zählen, wenn Sie darauf aufbauen:</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>) hat den Nachweis in den <code>Authorization</code>-Header verlegt. Eine Anfrage hat nur einen solchen Header, ein WPT kann also nicht zusammen mit einem OAuth-Access-Token reisen. Flemming Andreasen nannte die Änderung unvereinbar mit der Architektur, und Jonathan Rosenberg wies darauf hin, dass ein Agent, der für einen Benutzer handelt, sowohl ein Access Token als auch die Authentifizierung des Agenten braucht. Der Chair verwies die Frage an die Mailingliste.</li>
<li><strong>WIMSE Architecture</strong> (<a href="https://datatracker.ietf.org/doc/draft-ietf-wimse-arch/">-09</a>) erschien am 17. November (UTC). Die Autoren halten sie für fertig, und die Chairs planen in den nächsten Wochen einen Working Group Last Call.</li>
</ul>
<p>In derselben Sitzung stellte Brian Campbell den Draft <a href="https://datatracker.ietf.org/doc/draft-ietf-wimse-aims/">AI Identity Management System</a> vor, mit der Formel &quot;OAuth in the front, WIMSE in the back&quot;. Laut Notizen definiert er kein neues Protokollverhalten.</p>
<h2>Transaction Tokens über eine Grenze hinweg</h2>
<p>Transaction Tokens bleiben innerhalb einer Trust Domain. <a href="https://datatracker.ietf.org/doc/draft-fletcher-oauth-txn-token-chaining-profile/">George Fletchers Profil</a> beschreibt, wie ein Workload sein Txn-Token beim eigenen Authorization Server gegen ein Txn-Token-JAG (<code>typ</code> gleich <code>txn-chain+jwt</code>) eintauscht und dieses beim Server eines Partners vorlegt. Laut <a href="https://datatracker.ietf.org/meeting/127/materials/slides-127-wimse-ietf-127-txn-token-chaining-profile-00">Folien</a> gilt der Grant höchstens 300 Sekunden, bevorzugt 60, die <code>jti</code> ist einmalig verwendbar, und die interne Aufrufkette verlässt die Grenze nie. Offen sind die Fragen, ob das Sender Constraining von SHOULD auf MUST angehoben werden soll und wie das Subject abgebildet wird.</p>
<p>Interessant war die Diskussion:</p>
<ul>
<li>Max Gerber fragte, warum ein neuer JAG-Typ nötig sei, wenn es ID-JAG und WAG gibt. Justin Richer und Pieter Kasselman antworteten, das Eingangsartefakt sei ein anderes und das JAG würde eine reduzierte Teilmenge seiner Claims tragen.</li>
<li>Mark Atwood sagte, das Entfernen interner Kennungen, bevor ein Token eine Grenze überquert, solle ein MUST sein. Antoine Fressancourt entgegnete, Kennungen müssten für das Audit trotzdem rekonstruierbar bleiben.</li>
<li>Arndt Schwenkschuster befürchtete, Transaction Tokens würden zu &quot;the new bearer AT&quot;, der gestohlen und eingetauscht werden kann. George Fletcher antwortete, sie seien orthogonal zur Client-Authentifizierung.</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>Die Notizen schließen mit breiter Zustimmung, dass die Arbeit eine echte Lücke füllt. Ein Hinweis zur Ordnung: Die Notizen verlinken einen älteren Namen, <code>draft-fletcher-transaction-token-chaining-profile</code>. Der Datatracker zeigt diesen Namen als ersetzt durch den oben verlinkten <code>oauth-txn</code>-Namen, den auch die Folien verwenden.</p>
<p><a href="https://datatracker.ietf.org/doc/draft-tulshi-oauth-transactional-access-tokens/">Transactional Access Tokens</a> (-01, datiert 18. November) gehen einen anderen Weg. Ein Txn-AT ist ein JWT-Access-Token nach <a href="https://www.rfc-editor.org/rfc/rfc9068">RFC 9068</a> mit Transaktionskennung und -kontext, für genau einen Resource Server, angefordert über Rich Authorization Requests. Die Lebensdauer soll laut Draft 300 Sekunden nicht überschreiten (SHOULD NOT). Ausgestellt werden kann es per Token Exchange, Refresh und Client Credentials, nicht direkt per Authorization Code. In der Sitzung sagte ein Teilnehmer namens George, man müsse das nicht standardisieren, und der Autor entgegnete, ein Standardweg sei wünschenswert. Justin Richer verwies die Diskussion an die Mailingliste.</p>
<h2>Wer der Akteur ist</h2>
<p>Das <a href="https://datatracker.ietf.org/doc/draft-mcguinness-oauth-actor-profile/">OAuth Actor Profile for Delegation</a> (-01, 9. Oktober) profiliert den <code>act</code>-Claim aus dem Token Exchange, verlangt Akteurskennungen mit Gültigkeitsbereich beim Issuer und klassifiziert Akteure mit <code>sub_profile</code>. Karl McGuinness' Zusammenfassung in den Notizen: Delegation explizit machen, und die Client-ID bleibt der Client. Zwei Personen sprachen sich für die Annahme aus. Ein anderer Teilnehmer sagte, es sei keine kurze Arbeit, und Justin Richer hielt es für vernünftig, vor der Annahme Klärung zu suchen. Die Notizen halten fest, dass die Chairs um ein Stimmungsbild baten, aber nicht, was der Raum antwortete.</p>
<p>Ein neuer individueller Draft geht einen Schritt weiter. <a href="https://datatracker.ietf.org/doc/draft-nandakumar-oauth-actor-bound-token-exchange/">Token Exchange with Actor-Bound Tokens</a> (-00, 16. November) lässt einen Orchestrator ein Token anfordern, das an den Schlüssel des Agenten gebunden ist, der die Arbeit erledigt. Der Akteur weist den Besitz dieses Schlüssels nach, das Token funktioniert also nur für diesen Agenten. Es ist ein individueller Draft.</p>
<h2>Drei weitere Drafts dieser Woche</h2>
<p>Alle drei sind individuelle -00-Drafts ohne Status in einer Arbeitsgruppe.</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.). Ein Security Event Token, das eine Delegation und alles, was daraus delegiert wurde, widerruft, mit Regeln, wie Agenten es die Kette hinunter weitergeben, auch über einen Shared-Signals-Stream. Token Status Lists bleiben der Statusmechanismus pro Token.</li>
<li><a href="https://datatracker.ietf.org/doc/draft-sweeney-oauth-brokered-authorization/">OAuth Brokered Authorization</a> (20. Nov.). Ein dauerhafter Broker ist der OAuth-Client der vorgelagerten Ressource. Jede kurzlebige Instanz erhält per Client Credentials ein senderbeschränktes Token (<a href="https://iamops.dev/de/tools/dpop/">DPoP</a> oder mTLS) für den Broker, mit einem <code>authorization_details</code>-Typ <code>brokered_access</code>. Eine Instanz hält nie ein 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.). Nur ein Client, der die Audience des Tokens vertritt, darf es eintauschen oder introspizieren. Die Verbindung kann aus lokaler Richtlinie kommen, aus einem <code>private_key_jwt</code>, das gegen die <code>jwks_uri</code> der Ressource geprüft wird, oder aus einem neuen Parameter <code>resource_clients</code> in den RFC-9728-Metadaten. Die Agenda für Freitag nennt einen früheren Draft desselben Autors, <code>draft-zehavi-oauth-audience-bound-token-exchange-00</code>. Wie sich beide zueinander verhalten, habe ich nicht geprüft.</li>
</ul>
<h2>Was ich damit machen würde</h2>
<p>Das ist meine Meinung, nicht die des Standards.</p>
<ul>
<li>Jeden Agentenfluss zuerst nach seinem Principal einordnen: Benutzer, Workload oder Transaktion. Die Drafts teilen sich genau entlang dieser Linie, Ihr Design lässt sich dann leichter abbilden.</li>
<li>Das eingehende Token nicht an den nächsten Hop weiterreichen. Es gegen eines tauschen, dessen Audience die nächste API ist. Dazu habe ich <a href="https://iamops.dev/de/mcp-server-no-token-passthrough/">MCP server, no token passthrough</a> und <a href="https://iamops.dev/de/entra-on-behalf-of-agent-middle-tier/">Entra on-behalf-of for an agent middle tier</a> geschrieben.</li>
<li>Den Gateway-Fall als ungeklärt behandeln, bis die Interims zu Issue #114 berichten.</li>
<li>Namen und Revision des Drafts ins Designdokument schreiben. Mehrere dieser Drafts haben innerhalb weniger Wochen Namen oder Nummer gewechselt.</li>
</ul>
<h2>Was ich nicht geprüft habe</h2>
<p>Ich habe keine Sitzung besucht und die Aufzeichnungen nicht vollständig angesehen. Verlinkt habe ich die Aufzeichnungen der <a href="https://www.youtube.com/watch?v=V0tRi789ngE">OAuth-Sitzung</a> und der <a href="https://www.youtube.com/watch?v=g-EubYQF1xk">WIMSE-Sitzung 1</a>. Eine Aufzeichnung der gemeinsamen Sitzung habe ich noch nicht gefunden, alles dazu stammt also aus den Notizen. Ich habe keinen dieser Drafts ausgeführt oder implementiert. Die Notizen wurden von Freiwilligen geschrieben und können Fehler enthalten. Die OAuth-Sitzung am Freitag, in der mehrere der Drafts oben vorkommen, hat noch nicht stattgefunden. Ich aktualisiere diesen Beitrag, wenn sich etwas Wesentliches ändert.</p>
]]></content:encoded>
    </item>
    <item>
      <title>Workload-Identity-News: unveränderlicher sub bei GitHub, Entra-Wildcards und Agent Auth von WorkOS</title>
      <link>https://iamops.dev/de/workload-identity-news-immutable-sub-entra-wildcards-workos/</link>
      <guid isPermaLink="true">https://iamops.dev/de/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>Workload-Identität</category>
      <category>WorkOS</category>
      <category>KI-Agenten</category>
      <description>Der OIDC-sub von GitHub enthält jetzt Owner- und Repo-ID, Entra-Wildcard-Anmeldeinformationen sind in der Preview, WorkOS hat Agent Auth veröffentlicht.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/de/workload-identity-news-immutable-sub-entra-wildcards-workos.png?v=986e5733" alt="" /></p><p><strong>Kurz gesagt</strong></p>
<ul>
<li>Seit dem 15. Juli 2026 enthalten GitHub-Actions-Tokens für neue Repositories die Owner-ID und die Repository-ID im sub-Claim. Ältere Repositories behalten das reine Namensformat, bis Sie es aktivieren, die Anmeldeinformation muss also zum Format passen, das das Repository tatsächlich ausgibt.</li>
<li>Entra-Wildcards sind noch in der Preview. Microsoft verlangt auch repository_id oder repository_owner_id. In meinem Lab akzeptierte Entra einen Ausdruck nur mit sub, und einer für den gesamten Owner stellte einem anderen Repository desselben Owners ein Token aus. Ich ergänze repository_id trotzdem.</li>
<li>WorkOS hat Agent-Identität (Agent Auth, Early Access, 2. Sep), Claude auto-connect für MCP Auth (Early Access, 3. Nov) und RFC-8693-Token-Exchange für Connect (10. Nov) veröffentlicht. Zur Föderation von Workloads eines anderen Ausstellers habe ich bei WorkOS nichts gefunden.</li>
<li>Was ich tun würde: dem unveränderlichen sub vertrauen, repository_id in jede Wildcard aufnehmen, Anmeldeinformationen für nicht mehr vorhandene Repositories löschen und alles mit echten Läufen belegen. Mein Lab macht das für GitHub Actions zu Azure.</li>
</ul>
<p>Ich habe die Primärseiten zu diesen Meldungen am 20. November 2026 gelesen: Changelog und Dokumentation von GitHub, Microsoft Learn und den WorkOS-Changelog. Die Daten unten sind die, die diese Seiten zeigen. Die ersten beiden Meldungen betreffen mein <a href="https://iamops.dev/de/github-actions-azure-workload-identity-federation/">Lab GitHub Actions zu Azure</a>, deshalb stelle ich sie zusammen.</p>
<h2>GitHub nimmt Owner- und Repo-ID in den sub-Claim auf</h2>
<p>Am 23. April 2026 hat GitHub <a href="https://github.blog/changelog/2026-04-23-immutable-subject-claims-for-github-actions-oidc-tokens/">unveränderliche Subject-Claims für Actions-OIDC-Tokens</a> angekündigt. Der Beitrag wurde am 10. Juni 2026 geändert: Das Trennzeichen zwischen einem Namen und seiner ID ist jetzt <code>@</code>, nicht mehr <code>-</code>. Wenn Sie ein Beispiel aus dem Text vom April übernommen haben, prüfen Sie es.</p>
<p>Die Regeln, aus der <a href="https://docs.github.com/en/actions/reference/security/oidc">OIDC-Referenz</a>:</p>
<ul>
<li>Repositories, die nach dem 15. Juli 2026 erstellt werden, erhalten den neuen Standard-<code>sub</code>. Umbenennungen und Transfers nach diesem Datum wechseln ebenfalls dorthin.</li>
<li>Ältere Repositories behalten das reine Namensformat, bis Sie es aktivieren. Das geht pro Organisation oder pro Repository, in den OIDC-Einstellungen oder per REST-API (<code>use_immutable_subject</code>).</li>
<li>GitHub Enterprise Server ist nicht enthalten.</li>
<li>Eine angepasste Claim-Vorlage kann die IDs nicht entfernen. Mit <code>include_claim_keys</code> bleiben <code>owner_id</code> und <code>repo_id</code> im <code>repo</code>-Segment.</li>
</ul>
<table>
<thead>
<tr>
<th>Format</th>
<th><code>sub</code> bei einem Push auf main</th>
</tr>
</thead>
<tbody>
<tr>
<td>Nur Namen</td>
<td><code>repo:octo-org/octo-repo:ref:refs/heads/main</code></td>
</tr>
<tr>
<td>Unveränderlich</td>
<td><code>repo:octo-org@123456/octo-repo@456789:ref:refs/heads/main</code></td>
</tr>
</tbody>
</table>
<p>Die Beispielwerte stammen aus der GitHub-Dokumentation. Der Grund steht im Changelog: Wird der Name eines Repositorys oder einer Organisation wiederverwendet, kann ein neuer Eigentümer Tokens mit demselben Subject ausstellen und Cloud-Ressourcen erreichen, die dem ursprünglichen noch vertrauen. Die IDs werden nie wiederverwendet, das alte Vertrauen geht also nicht über.</p>
<p>In meinem Lab habe ich ein neues privates Repository erstellt, und sein <code>sub</code> kam im neuen Format. Das ändert die Reihenfolge beim Einrichten. Ich erstelle zuerst das Repository, lese die beiden IDs über die API und lege erst dann die föderierte Anmeldeinformation an. Die GitHub-Dokumentation zeigt das unveränderliche Format für Trust-Policies von Azure, AWS, Google Cloud und HashiCorp Vault. Ich habe nur Azure getestet.</p>
<h2>Was Entra jetzt abgleichen kann</h2>
<p>Microsoft kennzeichnet <a href="https://learn.microsoft.com/en-us/entra/workload-id/workload-identities-flexible-federated-identity-credentials">flexible föderierte Anmeldeinformationen</a> weiterhin als Preview. Die Seite ist auf den 18. September 2026 datiert. Statt eines exakten <code>subject</code> trägt die Anmeldeinformation einen <code>claimsMatchingExpression</code> mit <code>languageVersion</code> 1, und <code>subject</code> muss null sein. Die Konzeptseite sagt, die Azure CLI unterstütze das noch nicht explizit, und zeigt <code>az rest</code> gegen Graph Beta. Das habe ich für eine App-Registrierung verwendet. Die CLI-Referenz von <code>az identity federated-credential</code> (benutzerseitig zugewiesene verwaltete Identitäten) listet allerdings die Parameter <code>--claims-matching-expression-*</code>, markiert als Preview.</p>
<table>
<thead>
<tr>
<th>Operator</th>
<th>Was er tut</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>eq</code></td>
<td>Exakter Vergleich eines Claims</td>
</tr>
<tr>
<td><code>matches</code></td>
<td>Wildcards: <code>*</code> für beliebig viele Zeichen, <code>?</code> für genau eines</td>
</tr>
<tr>
<td><code>and</code></td>
<td>Verknüpft Bedingungen auf mehreren Claims</td>
</tr>
</tbody>
</table>
<p>Für GitHub sagt die <a href="https://learn.microsoft.com/en-us/entra/workload-id/workload-identities-set-up-flexible-federated-identity-credential">Einrichtungsseite</a> von Microsoft, dass der Ausdruck <code>sub</code> und einen oder beide der Claims <code>repository_id</code> und <code>repository_owner_id</code> abgleichen muss. Das gilt unabhängig davon, ob <code>sub</code> namensbasiert, angepasst oder unveränderlich ist. <code>sub</code> und <code>job_workflow_ref</code> akzeptieren <code>eq</code> und <code>matches</code>. Die beiden ID-Claims akzeptieren nur <code>eq</code>. Der <a href="https://learn.microsoft.com/en-us/entra/workload-id/workload-identities-github-immutable-subjects">Migrationsleitfaden</a> von Microsoft nutzt dieses Beispiel:</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 hat außerdem eine <a href="https://learn.microsoft.com/en-us/entra/workload-id/workload-identities-github-immutable-subjects">Migrationsanleitung</a> veröffentlicht, datiert auf den 28. Juli 2026. Die Reihenfolge: eine Anmeldeinformation für das unveränderliche Subject neben der alten anlegen, unveränderliche Subjects in GitHub aktivieren, einen Lauf prüfen, dann die alte Anmeldeinformation löschen. Eine Begleitseite zu <a href="https://learn.microsoft.com/en-us/entra/workload-id/workload-identities-federated-credential-mutable-subjects">veränderlichen Subjects</a> beschreibt das Recycling von Subjects und fordert dazu auf, verwaiste Anmeldeinformationen zu löschen, also solche, deren Workload nicht mehr existiert.</p>
<p>Hier weicht mein eigener Lauf von der Dokumentation ab. Im <a href="https://iamops.dev/de/github-actions-azure-workload-identity-federation/">Lab</a> habe ich zwei Ausdrücke angelegt, die nur <code>sub</code> abglichen (<code>feature-*</code> und <code>v*</code>), ohne <code>repository_id</code>. Entra hat beide akzeptiert, und die passenden Läufe waren erfolgreich. Diese Muster enthielten die Owner- und Repository-ID, waren also trotzdem gebunden. In einer späteren Prüfung am selben Tag akzeptierte Entra auch eine Expression für den gesamten Owner ohne <code>repository_id</code> oder <code>repository_owner_id</code>, und dieses Credential stellte einem anderen Repository desselben Owners ein Token aus. Ich empfehle <code>repository_id</code> dennoch. Microsoft dokumentiert es als Pflicht und die Funktion ist in Preview, ein Ausdruck nur mit sub kann also später abgelehnt werden oder nicht mehr passen. Die ID-Prüfung hängt auch nicht davon ab, dass das Muster stimmt: Ein Wildcard für den gesamten Owner hat bereits einem anderen meiner Repositories ein Token ausgestellt, und der reine Namens-<code>sub</code> eines älteren Repositorys kann auf einen Namen passen, der Ihnen nicht mehr gehört.</p>
<h2>Wie ein Token auf zwei Anmeldeinformationen trifft</h2>
<figure class="b-fig"><img src="https://iamops.dev/img/workload-identity-news-immutable-sub-entra-wildcards-workos.de.svg" alt="Eine Matrix aus zwei föderierten Entra-Anmeldeinformationen und vier GitHub-Actions-Läufen. Die exakte Anmeldeinformation für main akzeptiert nur einen Push auf main. Die Wildcard-Anmeldeinformation für release/* mit repository_id-Prüfung akzeptiert nur einen Push auf release/1. Ein Feature-Branch und ein Pull Request passen zu keiner." width="1200" height="630" loading="lazy" decoding="async"><figcaption><strong>Welche sub-Werte jede Anmeldeinformation akzeptiert.</strong> Das ist meine eigene Zusammenfassung, aus dem Muster jeder Anmeldeinformation abgeleitet. Die IDs sind die Beispielwerte aus der GitHub-Dokumentation.</figcaption></figure>
<p>Der Kern des Bildes: Der Teil von <code>sub</code> nach den IDs ist der Lauf. Ein Push auf main, ein Push auf einen Release-Branch, ein Feature-Branch und ein Pull Request senden jeweils einen anderen Wert, und Entra vergleicht ihn mit der Anmeldeinformation. Die IDs in der Mitte verhindern, dass ein anderes Repository mit demselben Namen passt. Mein Lab führt jeden dieser Fälle aus und gibt für jeden den exakten <code>sub</code> aus.</p>
<h2>WorkOS: was ich gefunden habe</h2>
<p>Ich habe den <a href="https://workos.com/changelog">WorkOS-Changelog</a> geprüft, weil dort laufend Auth für Agenten und MCP erscheint. Dies sind die Einträge von August bis 20. November, die Agenten- oder Workload-Credentials betreffen:</p>
<table>
<thead>
<tr>
<th>Datum</th>
<th>Eintrag</th>
<th>Was WorkOS schreibt</th>
</tr>
</thead>
<tbody>
<tr>
<td>2. Sep 2026</td>
<td><a href="https://workos.com/changelog/agent-auth">Agent Auth</a></td>
<td>Early Access. Agenten erhalten Identitäten in AuthKit und bei jedem Lauf kurzlebige, eng begrenzte Tokens, delegiert für einen Benutzer oder autonom innerhalb einer Organisation. Sitzungen lassen sich sofort widerrufen.</td>
</tr>
<tr>
<td>4. Sep 2026</td>
<td><a href="https://workos.com/changelog/mcp-enterprise-managed-authorization-ema">MCP Enterprise-Managed Authorization (EMA)</a></td>
<td>MCP Auth unterstützt EMA, sodass ein MCP-Client nachgelagerte MCP-Server über den Identity Provider des Unternehmens erreichen kann, ohne Zustimmungsdialog pro App. Zugang auf Anfrage.</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>Early Access. Bei Organisationen, deren Identity Provider Cross App Access nicht unterstützt, stellt Claude die Identity Assertion (ID-JAG) aus, und MCP Auth tauscht sie gegen ein Access Token für Ihren MCP-Server.</td>
</tr>
<tr>
<td>10. Nov 2026</td>
<td><a href="https://workos.com/changelog/token-exchange-for-workos-connect">Token-Exchange für WorkOS Connect</a></td>
<td>RFC 8693. Eine First-Party-Connect-App kann ein Token gegen eines für eine andere registrierte Ressource tauschen, wichtige Claims übernehmen und die Scopes einengen.</td>
</tr>
</tbody>
</table>
<p>Die letzten beiden hängen mit Dingen zusammen, die ich schon geschrieben habe. Claude auto-connect ist der ID-JAG-Ablauf aus <a href="https://iamops.dev/de/id-jag-explained/">ID-JAG explained</a>, mit Claude als Aussteller. Der Token-Exchange ist das Muster, das mein <a href="https://iamops.dev/de/mcp-server-no-token-passthrough/">Lab zu MCP ohne Token-Passthrough</a> von Hand aufbaut.</p>
<p>Nichts davon ist Workload Identity Federation im Sinn von Entra, bei der man Tokens eines anderen Ausstellers vertraut. Dazu habe ich im WorkOS-Changelog keinen Eintrag gefunden, ebenso wenig zu Machine-to-Machine-Auth. Mit der GitHub-Geschichte verbindet diese Einträge der Gedanke an eine kurzlebige, enge Credential pro Lauf statt eines gespeicherten Schlüssels. Zwei weitere Agenten-Einträge, Agent Registration (4. August) und Agent Vault (17. November), betreffen die Anmeldung von Agenten bei AuthKit über das auth.md-Protokoll und angemeldete Browser-Sitzungen, ich habe sie daher weggelassen. Ich habe kein WorkOS-Produkt ausprobiert.</p>
<h2>Was ich tun würde</h2>
<p>Das ist meine Meinung, keine Richtlinie von Microsoft oder GitHub.</p>
<ul>
<li>Prüfen Sie bei einem neuen Repository jede Anmeldeinformation, die Sie nach älteren Beispielen geschrieben haben. Das Subject enthält jetzt IDs, und ein reines Namens-Subject passt nicht.</li>
<li>Folgen Sie bei einem alten Repository der Reihenfolge von Microsoft: unveränderliche Anmeldeinformation hinzufügen, aktivieren, einen Workflow laufen lassen, dann die alte Anmeldeinformation löschen.</li>
<li>Nehmen Sie <code>repository_id</code> in jeden Ausdruck auf, auch wenn das Muster die IDs enthält. In meinem Lab akzeptierte Entra Ausdrücke nur mit sub, und ein Ausdruck für den gesamten Owner stellte einem anderen Repository desselben Owners ein Token aus. Die Doku verlangt die ID-Prüfung weiterhin, und ich ergänze sie.</li>
<li>Listen Sie die föderierten Anmeldeinformationen Ihrer App-Registrierungen auf und löschen Sie die, deren Repository nicht mehr existiert.</li>
</ul>
<p>Das <a href="https://iamops.dev/de/github-actions-azure-workload-identity-federation/">Lab</a> zeigt das Scheitern, das aus dem exakten Abgleich folgt. Mit nur einer Anmeldeinformation für main bestand eine von sechs Laufarten. Es zeigt auch eine Falle: Eine Anmeldeinformation für <code>pull_request</code> vertraut auch <code>pull_request_target</code>-Läufen, und diese erhalten Secrets.</p>
<h2>Was ich nicht geprüft habe</h2>
<ul>
<li>Ich habe kein bestehendes Repository aktiviert und den Vorschau-Endpunkt von GitHub, der das neue Subject-Präfix zeigt, nicht aufgerufen.</li>
<li>Ich habe nur Azure getestet. AWS, Google Cloud und Vault stehen in der GitHub-Dokumentation, ich habe sie nicht ausgeführt.</li>
<li>Ich habe GitHub Enterprise Server nicht getestet, den GitHub ausschließt.</li>
<li>Ich habe die Einträge im WorkOS-Changelog gelesen, aber kein Produkt ausprobiert und die verlinkte Dokumentation nicht gelesen. Zwei Einträge sind Early Access.</li>
<li>Die Microsoft-Seiten zu flexiblen Anmeldeinformationen sagen weiterhin Preview. Ein Datum für die allgemeine Verfügbarkeit habe ich nicht gefunden, und ich rate keines.</li>
</ul>
]]></content:encoded>
    </item>
    <item>
      <title>ID-JAG erklärt: Wie KI-Agenten anwendungsübergreifenden Zugriff unter Unternehmenskontrolle erhalten</title>
      <link>https://iamops.dev/de/id-jag-explained/</link>
      <guid isPermaLink="true">https://iamops.dev/de/id-jag-explained/</guid>
      <pubDate>Thu, 19 Nov 2026 08:00:00 GMT</pubDate>
      <dc:creator>Argo</dc:creator>
      <category>Labs</category>
      <category>ID-JAG</category>
      <category>Cross App Access</category>
      <category>KI-Agenten</category>
      <category>OAuth</category>
      <category>Standards</category>
      <description>Wie ID-JAG und Cross App Access dem Identity Provider eines Unternehmens erlauben, den Zugriff von KI-Agenten auf andere Apps zu genehmigen. Mit Lab-Bildern.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/de/id-jag-explained.png?v=986e5733" alt="" /></p><p><strong>Kurz gesagt</strong></p>
<ul>
<li>ID-JAG ist ein vorgeschlagener IETF-Standard (Entwurf -06), mit dem der Identity Provider eines Unternehmens den Zugriff eines KI-Agenten auf eine andere App freigibt.</li>
<li>Der Identity Provider stellt eine kurzlebige signierte Assertion aus; die andere App prüft sie und stellt ein eigenes kurzlebiges Access Token aus.</li>
<li>Er ersetzt Einwilligungs-Pop-ups pro App und langlebige Schlüssel durch einen zentralen Ort für Richtlinien und Audit.</li>
<li>Es ist noch ein Entwurf: Key Binding und Just-in-Time-Provisionierung könnten in eigene Dokumente wandern, und mehrere Produkte setzen ihn bereits um.</li>
<li>Das Labor mit dem öffentlichen xaa.dev-Beispiel zeigt den Ablauf, mit geschwärzten Screenshots und einer Aufzeichnung.</li>
</ul>
<p>Viele KI-Agenten müssen im Auftrag eines Nutzers auf mehrere Unternehmensanwendungen zugreifen. Heute löst jede Verbindung meist eine eigene Einwilligungsabfrage aus oder stützt sich auf einen langlebigen Schlüssel in den Einstellungen des Agenten. Beides lässt sich für eine Organisation nur schwer einsehen und steuern.</p>
<p><strong>ID-JAG</strong> ist ein vorgeschlagener Standard, der diese Freigabe vom einzelnen Nutzer auf den Identity Provider der Organisation verlagert. Dieser Artikel erklärt, wie das funktioniert, wo die Spezifikation steht und was ein Lab-Durchlauf mit einer öffentlichen Beispielanwendung zeigt.</p>
<h2>Das Problem</h2>
<p>Mitarbeitende melden sich per <em>Single Sign-on</em> einmal mit einem Konto an. Das System dahinter ist der <em>Identity Provider</em> des Unternehmens, hier „Unternehmens-Anmeldung“ genannt.</p>
<p>Dann muss ein KI-Agent Aufgaben in einer Anwendung lesen, Dateien in einer zweiten und einen Kalender in einer dritten. Jede dieser Anwendungen betreibt einen eigenen Autorisierungsserver, der den Agenten nicht kennt. In der Praxis funktioniert jede Verbindung auf eine von zwei Arten:</p>
<ul>
<li><strong>Eine Einwilligungsabfrage</strong> pro Anwendung und Nutzer. Nutzer bestätigen oft, ohne zu lesen, und die Organisation hat keine zentrale Übersicht.</li>
<li><strong>Ein langlebiger Schlüssel</strong>, der in die Konfiguration des Agenten eingefügt wird. Er läuft nicht ab, und jeder, der ihn erlangt, kann ihn verwenden.</li>
</ul>
<p>Die Alternative ist eine zentrale Stelle, die für Nutzer und Agent bürgt, die Regeln der Organisation anwendet und Protokoll führt.</p>
<h2>Was ein ID-JAG leistet</h2>
<p>Der vollständige Name lautet <em>Identity Assertion JWT Authorization Grant</em>. Praktisch ist es eine <strong>kurzlebige, signierte Zusicherung</strong> der Unternehmens-Anmeldung. Sie besagt, dass die Organisation dieses Nutzers diesem Agenten erlaubt, bei jener Anwendung bestimmten Zugriff anzufordern.</p>
<p>Das darum herum gebaute Muster heißt informell <strong>Cross App Access (XAA)</strong>. Die Seite oauth.net dazu sagt, es „ersetzt den manuellen Genehmigungsschritt des Nutzers durch einen Token Exchange“.</p>
<p><img src="https://iamops.dev/img/id-jag-flow.de.svg" alt="Die fünf Schritte eines ID-JAG-Ablaufs, von der einmaligen Anmeldung bis zur Nutzung eines kurzlebigen Access Tokens durch den Agenten."></p>
<p>Der Ablauf in fünf Schritten:</p>
<ol>
<li>Der Nutzer meldet sich einmal wie gewohnt bei der Arbeit an.</li>
<li>Der Agent fordert bei der Unternehmens-Anmeldung eine Zusicherung für eine bestimmte Anwendung an.</li>
<li>Die Unternehmens-Anmeldung prüft ihre Richtlinie. Ist die Verbindung erlaubt, stellt sie den ID-JAG aus.</li>
<li>Der Agent legt den ID-JAG dem Autorisierungsserver der anderen Anwendung vor. Dieser prüft die Signatur, wendet <strong>seine eigenen</strong> Regeln an und stellt ein kurzlebiges Access Token aus.</li>
<li>Der Agent ruft die Anwendung mit diesem Token auf.</li>
</ol>
<p>Zwei Details sind wichtig. Die empfangende Anwendung entscheidet weiterhin selbst, was sie gewährt; der ID-JAG ist also kein Blankoscheck. Und weil die Unternehmens-Anmeldung in der Mitte steht, gibt es eine Stelle zum Festlegen der Richtlinien und eine zum Nachvollziehen, was geschehen ist.</p>
<p>Technisch verkettet das Verfahren zwei bestehende Standards: Token Exchange (<a href="https://iamops.dev/de/keycloak-token-exchange-rfc-8693/">RFC 8693</a>) und den JWT Bearer Grant (RFC 7523).</p>
<h2>Lab: der Ablauf im xaa.dev-Beispiel</h2>
<p>Der kostenlose <strong>xaa.dev</strong>-Playground des Entwicklerteams von Okta macht den Ablauf sichtbar. In einem Lab-Durchlauf am 7. November 2026 wurde die Beispielanwendung lokal in einer Testumgebung ausgeführt. Die App hat ein Panel „Behind the scenes“, das jede Stufe nach Abschluss markiert: Unternehmens-Anmeldung, ID-JAG, Access Token und die von der zweiten Anwendung abgerufene Checkliste. Zu keinem Zeitpunkt erschien eine Einwilligungsabfrage.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/xaa/dashboard.webp" alt="Die xaa.dev-Beispiel-App mit der Onboarding-Checkliste links und dem Panel Behind the scenes rechts, in dem alle vier Stufen als abgeschlossen angezeigt werden." width="1280" height="975" loading="lazy" decoding="async"><figcaption><strong>Überblick.</strong> Die Checkliste (links) wurde mit der Unternehmensidentität von der zweiten Anwendung abgerufen. Das Panel (rechts) listet die vier Stufen: Unternehmens-Anmeldung, ID-JAG, Access Token, Checkliste über MCP. Der Subject-Claim (sub) ist geschwärzt.</figcaption></figure>
<p><strong>Stufe 2: die Zusicherung.</strong> Nach der Unternehmens-Anmeldung tauscht das Beispiel das ID-Token des Nutzers gegen einen ID-JAG (RFC 8693). Das Aufklappen von Stufe 2 zeigt die dekodierte Zusicherung: Aussteller, Zielgruppe (den Autorisierungsserver der anderen Anwendung), angeforderte Ressource und Scope sowie Ausstellungs- und Ablaufzeit, die hier fünf Minuten auseinanderliegen. Kennungen, die auf eine Person oder einen Client verweisen, sind geschwärzt.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/xaa/id-jag.webp" alt="Aufgeklappte Stufe 2 im Panel Behind the scenes: der dekodierte ID-JAG mit sichtbaren Angaben zu Aussteller, Zielgruppe, Ressource, Ausstellungs- und Ablaufzeit und Scope; Kennungen sind durch schwarze Balken abgedeckt." width="1280" height="975" loading="lazy" decoding="async"><figcaption><strong>Stufe 2, der ID-JAG.</strong> Aussteller, Zielgruppe, Ressource, Gültigkeitsdauer und Scope sind sichtbar. Subject, Client und Token-Kennungen sind durch schwarze Balken abgedeckt, das kodierte Token wird nicht gezeigt.</figcaption></figure>
<p><strong>Stufen 3 und 4: das Access Token.</strong> Der Autorisierungsserver der anderen Anwendung prüft den ID-JAG (RFC 7523) und liefert ein Access Token mit begrenztem Scope zurück. Das Beispiel nutzt es anschließend, um die Checkliste über MCP abzurufen. Die Token-Claims zeigen, wer das Token ausgestellt hat, für welche Zielgruppe und mit welchem Scope.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/xaa/access-token.webp" alt="Aufgeklappter Abschnitt des Access Tokens; die Claims zeigen Aussteller, Zielgruppe und die Scopes todos.read und mcp.access, das kodierte Token und das Subject sind geschwärzt." width="1280" height="975" loading="lazy" decoding="async"><figcaption><strong>Stufen 3 und 4, das Access Token.</strong> Die Token-Claims (Aussteller, Zielgruppe, Scope) sind echt. Das kodierte Token und das Subject sind geschwärzt.</figcaption></figure>
<p>Ich habe den ganzen Ablauf auf dem öffentlichen xaa.dev-Playground aufgezeichnet, mit der Beispiel-App in einer lokalen Testumgebung und einem synthetischen Nutzer. Die Aufnahme beginnt auf der Anmeldeseite. So sehen Sie jeden Schritt passieren und danach seinen dekodierten Header und Payload. Hinzugefügt ist nur die Untertitelleiste oben. Die Aufnahme ist stumm und dauert etwa eine Minute 44 Sekunden.</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.de.vtt" srclang="de" label="Deutsch" default></video><figcaption id="vid-cap"><strong>Bildschirmaufzeichnung</strong> (1 Min. 44 s, ohne Ton, Untertitel verfügbar): Anmeldung beim IdP der Firma, danach jeder Schritt mit dekodiertem Header und Payload. Synthetischer Nutzer und kurzlebige Demo-Tokens aus dem öffentlichen Playground. Die kodierten Token-Strings sind fürs Layout gekürzt.</figcaption></figure>
<h3>Was Sie hier sehen</h3>
<ol>
<li><strong>0:08 Anmeldung beim IdP der Firma.</strong> Der Nutzer meldet sich auf idp.xaa.dev an, nicht in der Agent-App. Die App sieht nie ein Passwort, und beim IdP liegen MFA und Anmelderegeln. Der Playground nimmt beliebige sechs Ziffern als zweiten Faktor.</li>
<li><strong>0:30 Die Agent-App erhält ein ID-Token.</strong> Es belegt, wer sich angemeldet hat. Achte auf <code>iss</code> (der IdP), <code>aud</code> (die Client-ID der App) und <code>exp</code>, eine Stunde nach <code>iat</code>. Die App hat jetzt eine Identität der Organisation, aber noch keinen Zugriff auf die Todo-App.</li>
<li><strong>0:47 Der IdP tauscht es gegen ein ID-JAG (RFC 8693).</strong> Der Agent fragt eine Assertion für genau ein Ziel an. Der Header-Typ ist <code>oauth-id-jag+jwt</code>. Die Claims nennen in <code>aud</code> den Autorisierungsserver der Todo-App, dazu <code>resource</code>, <code>client_id</code> und <code>scope</code>. In einem echten Einsatz entscheidet hier die Policy des Administrators. Der Playground erlaubt es einfach.</li>
<li><strong>0:58 Das ID-JAG ist kurzlebig.</strong> <code>exp</code> liegt 300 Sekunden nach <code>iat</code>. Ein abgeflossenes ID-JAG ist nach fünf Minuten wertlos und funktioniert nur bei dem Server, der in <code>aud</code> steht.</li>
<li><strong>1:07 Der eigene Autorisierungsserver der Todo-App stellt das Access Token aus (RFC 7523).</strong> Der Agent legt ihm das ID-JAG vor. Der Server prüft die Signatur des IdP und wendet dann seine eigenen Regeln an. Im Token ist dieser Server <code>iss</code>, der MCP-Server <code>aud</code>, und es enthält nur den genehmigten <code>scope</code>. Der Nutzer wird im Namensraum der Todo-App identifiziert.</li>
<li><strong>1:30 Der Agent ruft die API auf.</strong> Mit dem Access Token liest er die Checkliste über MCP. Die linke Seite der Seite ist genau diese Antwort. Ein Einwilligungsdialog erschien zu keinem Zeitpunkt.</li>
</ol>
<p><em>Das Lab nutzt ein öffentliches Beispiel mit Wegwerfkonten und Beispieldaten. Die Screenshots wurden vor der Veröffentlichung auf die Anwendung zugeschnitten und geschwärzt. Die Aufzeichnung zeigt die dekodierten Demo-Tokens vollständig, weil sie aus dem öffentlichen Playground stammen, zu einem synthetischen Nutzer gehören und innerhalb einer Stunde ablaufen. Die kodierten Token-Strings sind fürs Layout gekürzt.</em></p>
<h2>Stand der Spezifikation</h2>
<p><strong>Es ist weiterhin ein Entwurf, kein fertiger Standard.</strong> Das Dokument heißt <em>draft-ietf-oauth-identity-assertion-authz-grant</em>, liegt inzwischen in Version <strong>-06</strong> vor und ist auf den 31. Oktober 2026 datiert. Es ist ein Dokument der IETF-Arbeitsgruppe OAuth, verfasst von Autoren von Okta und Ping Identity sowie einem unabhängigen Autor. Angestrebt ist ein Standards-Track-Dokument, doch Entwürfe können sich noch ändern.</p>
<p><strong>IETF 127, 18. November 2026.</strong> Die Autoren stellten den Entwurf in der OAuth-Sitzung vor. Die Folien nennen drei offene Themen:</p>
<ul>
<li><strong>Just-in-Time-Provisioning</strong>: wie eine Anwendung mit einem Nutzer umgeht, den sie noch nie gesehen hat, weil ihr erster Kontakt ein ID-JAG ist. Die Folien empfehlen, dies in einer künftigen Erweiterung zu behandeln.</li>
<li><strong>Key Binding</strong>: Tokens an einen kryptografischen Schlüssel zu binden, sodass ein gestohlenes Token wertlos ist. Die Folien fragen, ob es in eine eigene Erweiterung ausgelagert werden soll, und die Notizen halten eine Empfehlung für mehrere Folgeentwürfe fest. Ein Teilnehmer meinte, das Auslagern von Themen in andere Dokumente lasse den Entwurf unfertig wirken. Der Autor entgegnete, Provisioning sei optional und Key Binding gelte breiter als dieser Entwurf.</li>
<li><strong>Gateways und Proxys</strong>, die in KI-Umgebungen üblich sind, wenn ein Gateway zwischen Agent und Anwendungen sitzt. Das ist ein offenes Thema. Ein separater Entwurf ist vorgeschlagen, und laut den Notizen wünschen sich die Autoren zusätzliche („Interim“-)Treffen zu Gateways und Key Binding.</li>
</ul>
<p>Die Notizen halten diese Punkte als <strong>Empfehlungen</strong> fest. Eine endgültige Entscheidung findet sich darin nicht. Als nächste Schritte nennen die Folien, die verbleibenden Punkte zu sichten, jeweils in Version -07 zu lösen oder bewusst zurückzustellen, und dann einen Working Group Last Call zu beantragen.</p>
<h2>Implementierungen</h2>
<p>Mehrere Anbieter setzen ihn bereits um, obwohl der Entwurf nicht final ist. Laut der <a href="https://oauth.net/cross-app-access/">Implementierungsliste auf oauth.net</a>, geprüft am 19. November 2026:</p>
<ul>
<li><strong>Identity Provider, die ID-JAGs ausstellen</strong>, sind unter anderem Okta, Oracle OCI IAM, Ping, Gravitee, Descope, Keycloak (als „in progress“ markiert) und weitere.</li>
<li><strong>Autorisierungsserver, die sie akzeptieren</strong>, sind unter anderem Okta, Oracle OCI IAM, Ping, Gravitee, Auth0 (Early Access), Stytch und WorkOS AuthKit (Early Access).</li>
<li><strong>KI-Anwendungen und -Werkzeuge als Clients</strong> sind unter anderem Claude, OpenAI Codex CLI und Visual Studio Code (Preview).</li>
<li><strong>Anwendungen auf der Empfängerseite</strong> sind unter anderem Asana, Atlassian, Linear, Notion und Slack, teils in der Beta.</li>
</ul>
<p>Einige datierte Beispiele:</p>
<ul>
<li><strong>Oracle</strong>: Am 9. Oktober 2026 veröffentlichte Oracle den ID-JAG-Token-Exchange in OCI IAM.</li>
<li><strong>Gravitee</strong>: Access Management 4.13, angekündigt am 12. November 2026, kann beide Rollen übernehmen, also ID-JAGs ausstellen und akzeptieren.</li>
<li><strong>Okta</strong>: Am 13. November 2026 kündigte Okta die allgemeine Verfügbarkeit der Unterstützung für Identity Provider von Drittanbietern an und nennt Ping, Descope und Oracle als XAA-fähige Anbieter, mit deren Nutzern und Agenten es zusammenarbeiten kann.</li>
<li><strong>MCP</strong>: Das Model Context Protocol, eine verbreitete Methode, KI-Werkzeuge mit Anwendungen zu verbinden, hat eine Erweiterung „Enterprise-Managed Authorization“, die einen ID-JAG verwendet. Der Projektblog kündigte sie im Juni 2026 als stabil an.</li>
</ul>
<p>Microsoft Entra stand zum Zeitpunkt der Prüfung nicht auf der Liste von oauth.net.</p>
<h2>Unterschied zu Einwilligungsdialogen und On-Behalf-of</h2>
<table>
<thead>
<tr>
<th></th>
<th>Einwilligungsabfrage</th>
<th>On-Behalf-of (OBO)</th>
<th>ID-JAG / XAA</th>
</tr>
</thead>
<tbody>
<tr>
<td><strong>Wer genehmigt</strong></td>
<td>Der Nutzer, Anwendung für Anwendung</td>
<td>Die frühere Einwilligung des Nutzers, weitergereicht</td>
<td>Die Unternehmens-Anmeldung nach Regeln eines Administrators</td>
</tr>
<tr>
<td><strong>Was der Nutzer sieht</strong></td>
<td>Eine Abfrage pro Anwendung</td>
<td>Meist nichts nach der ersten Anmeldung</td>
<td>Nichts</td>
</tr>
<tr>
<td><strong>Wo es funktioniert</strong></td>
<td>Überall, wo OAuth funktioniert</td>
<td>Ein Dienst ruft einen anderen auf, innerhalb eines Identitätssystems</td>
<td>Zwischen Anwendungen und Organisationen mit jeweils eigenem Autorisierungsserver</td>
</tr>
<tr>
<td><strong>Zentrale Kontrolle</strong></td>
<td>Begrenzt</td>
<td>Teilweise</td>
<td>Zweck des Designs</td>
</tr>
</tbody>
</table>
<p><strong>Im Vergleich zu Einwilligungsdialogen:</strong> Eine Einwilligungsabfrage fragt den Nutzer jedes Mal. Ein ID-JAG wendet die Regeln der Organisation einmal an und setzt sie dann unauffällig durch.</p>
<p><strong>Im Vergleich zu <a href="https://iamops.dev/de/entra-on-behalf-of-agent-middle-tier/">On-Behalf-of</a>:</strong> Microsofts Dokumentation beschreibt OBO als eine Web-API, die die Identität eines Nutzers verwendet, um eine andere API aufzurufen, und Identität und Berechtigungen des Nutzers entlang der Kette weitergibt. Das geschieht innerhalb der Microsoft-Identitätsplattform. Der ID-JAG löst ein verwandtes Problem über Grenzen hinweg: Die beiden Anwendungen haben unterschiedliche Autorisierungsserver, und eine dritte Partei, die Unternehmens-Anmeldung, bürgt für den Nutzer. Aus Nutzersicht wirken beide ähnlich, das Vertrauen ist jedoch anders aufgebaut.</p>
<h2>Eine Überlegung</h2>
<p>Weniger Abfragen bedeuten mehr Komfort, aber auch weniger Momente, in denen eine Person die Anfrage prüft. Das ist eine Einschätzung, keine Aussage des Standards: Das Design hilft nur, wenn die Richtlinien der Organisation solide sind und regelmäßig überprüft werden. Der ID-JAG macht es <strong>möglich</strong>, Agentenzugriffe an einer Stelle zu sehen und zu steuern. Steuern muss weiterhin jemand.</p>
<p>Dieser Artikel wird aktualisiert, sobald der Entwurf auf den Working Group Last Call zugeht.</p>
]]></content:encoded>
    </item>
    <item>
      <title>US-Banken lassen Kunden für KI-Agenten Dritter haften</title>
      <link>https://iamops.dev/de/banks-ai-agents-customer-liability/</link>
      <guid isPermaLink="true">https://iamops.dev/de/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>KI-Agenten</category>
      <category>Banken</category>
      <category>Sicherheit</category>
      <category>Haftung</category>
      <description>Am 18. November 2026 berichtete TechCrunch, dass Citi, PNC und US-Banken Handlungen eines KI-Agenten Dritter dem Kunden zurechnen. Was die Bedingungen sagen.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/de/banks-ai-agents-customer-liability.png?v=986e5733" alt="" /></p><p><strong>Kurz gesagt</strong></p>
<ul>
<li>Am 18. November 2026 berichtete TechCrunch, dass Citi in jener Woche die Online User Agreement aktualisiert hat: Kunden, die einem KI-Agenten Dritter Zugang gewähren, haften für das, was der Agent tut, auch wenn das Werkzeug Anmeldedaten preisgibt oder gehackt wird.</li>
<li>Derselbe Bericht sagt, dass JPMorgan und Bank of America im Oktober 2026 ähnliche Regelungen ankündigten, PNC die Bedingungen am 18. November änderte und Citizens in derselben Woche Kunden anschrieb.</li>
<li>Die eigene Mitteilung von Wells Fargo sagt, dass eine aktualisierte Online Access Agreement am 24. November 2026 in Kraft tritt: ein KI-Werkzeug Dritter wird nicht von der Bank betrieben, und Anfragen können behandelt werden, als kämen sie von Ihnen.</li>
<li>Laut TechCrunch können KI-Agenten, die Citi selbst bereitstellt, ohne diese zusätzliche Haftung genutzt werden. Solange eine Bank Person und Agent nicht unterscheiden kann, gilt ein geteiltes Login als Sie.</li>
</ul>
<p>Am 18. November 2026 berichtete TechCrunch, dass mehrere große US-Banken ihre Bedingungen für Kunden aktualisiert haben, die einem KI-Agenten Dritter Zugang zu einem Konto geben. Die Änderung ist kein Verbot. Sie ist eine Aussage darüber, wer verantwortlich ist, wenn etwas schiefgeht.</p>
<h2>Was die Banken gesagt haben</h2>
<p>Citibank hat das Online User Agreement in der Woche des 18. November 2026 aktualisiert. Ein Sprecher von Citi sagte TechCrunch, Kunden, die KI-Agenten Dritter Zugang zum Konto gewähren, seien verantwortlich für Tätigkeiten, die über diese Agenten laufen. TechCrunch berichtete auch, dass Citis Aktualisierung weiter geht: Wenn das KI-Werkzeug die Anmeldedaten preisgibt oder gehackt wird, haftet der Kunde für das, was Angreifer danach mit dem Konto tun.</p>
<p>Derselbe Artikel sagt, dass JPMorgan und Bank of America im Oktober 2026 ähnliche Regelungen ankündigten, dass PNC die Bedingungen am 18. November änderte und dass Citizens in derselben Woche die Kunden anschrieb.</p>
<p>Wells Fargo hat eine eigene Kundenmitteilung veröffentlicht: ein aktualisiertes Online Access Agreement tritt am 24. November 2026 in Kraft. Die Bank sagt, wenn Sie ein KI-Werkzeug oder einen Agenten Dritter nutzen, um auf Ihre Konten zuzugreifen, wird das Werkzeug nicht von Wells Fargo betrieben, dass Anfragen über das Werkzeug behandelt werden können, als kämen sie direkt von Ihnen, und dass sie sich das Recht vorbehält, den Zugang bestimmter KI-Werkzeuge Dritter einzuschränken oder zu sperren.</p>
<p>Ich bin kein Anwalt, und dies ist keine Rechtsberatung. Einige dieser Bedingungen, auch die von Wells Fargo, lassen Raum für Schutz, den das Gesetz Ihnen bereits gibt. Die Richtung bleibt klar.</p>
<h2>Warum das jetzt geschieht</h2>
<p>Ein KI-Agent, der sich mit Benutzername und Passwort des Kunden anmeldet, sieht für die Bank wie der Kunde aus. Die Prüfspur, also der Nachweis, wer was getan hat, zeigt keinen eigenen Akteur. Deshalb kann eine Bank sagen, die Zahlung des Agenten, oder die Zahlung eines Angreifers nach einem durchgesickerten Login, sei von Ihnen autorisiert worden.</p>
<p>TechCrunch nennt einen nützlichen Gegensatz in Citis eigenen Bedingungen: KI-Agenten, die Citi selbst bereitstellt, können ohne diese zusätzliche Haftung genutzt werden. Die Bank zieht eine Linie zwischen Werkzeugen, die sie kontrolliert, und solchen, die sie nicht kontrolliert.</p>
<p>Das persönliche Finanzwerkzeug von Anthropic, das im selben Artikel erwähnt wird, wird als nur lesend beschrieben: es «kann Ihr Geld nicht bewegen, verwalten oder anlegen». Das verringert das Risiko, dass eine Zahlung abgeht. Es löst nicht den Fall, in dem ein Werkzeug, das ein Konto nur liest, trotzdem Anmeldedaten besitzt.</p>
<figure class="b-fig"><img src="https://iamops.dev/img/banks-ai-agents-customer-liability.de.svg" alt="Vier Schritte in einer Reihe: ein Kunde teilt Anmeldedaten mit einem KI-Agenten, der Agent handelt oder wird gehackt, die Bank sieht nur die Anmeldedaten des Kunden und behandelt die Handlung als die des Kunden. Ein geteiltes Login hinterlässt keine eigene Spur." width="1200" height="630" loading="lazy" decoding="async"><figcaption><strong>Was die Bank sehen kann.</strong> Sobald der Kunde Anmeldedaten teilt, hat die Bank keine eigene Spur für den Agenten. Eine Zahlung, oder ein Login nach einem Datenleck, kann aussehen, als handelte der Kunde allein.</figcaption></figure>
<h2>Was ich tun würde</h2>
<p>Geben Sie Anmeldedaten eines Bankkontos nicht an ein KI-Werkzeug Dritter weiter, es sei denn, Sie haben einen klaren Grund und verstehen die Bedingungen. Wenn ein Werkzeug diesen Zugang bereits hat, widerrufen Sie ihn beim Anbieter, ändern Sie das Passwort, falls das Werkzeug es hatte, und behalten Sie einen Nachweis.</p>
<p>Das bessere Muster auf Dauer ist ein benannter Agent mit einer engen, zeitlich begrenzten Berechtigung, die Sie abschalten können, ohne Ihr eigenes Passwort zu ändern. Banken und Anbieter beginnen, darüber zu sprechen, aber die am 18. November berichteten Bedingungen setzen noch ein geteiltes Login voraus. Solange die Bank eine Person nicht von einem Agenten unterscheiden kann, sind Sie der Agent.</p>
<p>Wenn Sie die technische Seite interessiert, wie ein Agent ein Token erhalten kann, ohne ein Passwort zu teilen, habe ich über <a href="https://iamops.dev/de/id-jag-explained/">ID-JAG</a> geschrieben. Am 17. November veröffentlichte Microsoft außerdem eine Laboranalyse zu <a href="https://iamops.dev/de/device-code-phishing-ai-agents/">Device-Code-Phishing gegen KI-Coding-Assistenten</a>.</p>
]]></content:encoded>
    </item>
    <item>
      <title>Device-Code-Phishing und KI-Agenten: Risiken und Gegenmaßnahmen</title>
      <link>https://iamops.dev/de/device-code-phishing-ai-agents/</link>
      <guid isPermaLink="true">https://iamops.dev/de/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>KI-Agenten</category>
      <category>Sicherheit</category>
      <description>Microsoft zeigte im Labor, wie ein bestätigter Device Code Angreifern die Kontrolle über einen KI-Coding-Assistenten gibt. Risiken und Gegenmaßnahmen.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/de/device-code-phishing-ai-agents.png?v=986e5733" alt="" /></p><p><strong>Kurz gesagt</strong></p>
<ul>
<li>Device-Code-Phishing bringt eine Person dazu, eine Anmeldung zu genehmigen, die ein Angreifer gestartet hat.</li>
<li>In einem kontrollierten Labortest zeigte Microsoft, dass ein einziger genehmigter Code einem Angreifer erlauben konnte, eine GitHub-Copilot-CLI-Sitzung zu steuern und, je nach Einstellungen, den Sitzungsverlauf in der Cloud und private Repositories zu erreichen.</li>
<li>Das sind Proof-of-Concept-Ergebnisse; Microsoft sagt, es habe sie in echten Angriffen nicht beobachtet, doch Device-Code-Phishing selbst ist ein wiederkehrender Weg zur Kontoübernahme.</li>
<li>Geben Sie einen Device Code nur ein, wenn Sie die Anfrage selbst gestartet haben.</li>
<li>Prüfen Sie die mit Ihren Konten verbundenen Apps und nutzen Sie die restriktivsten Einstellungen für Fernsteuerung und Sitzungsspeicherung, die Ihre KI-Werkzeuge erlauben.</li>
</ul>
<p>Device-Code-Anmeldung ist der Ablauf, bei dem ein Gerät ohne bequeme Tastatur einen kurzen Code anzeigt, den der Nutzer zur Authentifizierung auf einem zweiten Gerät eingibt. Smart-TVs nutzen ihn ebenso wie viele Kommandozeilenwerkzeuge von Entwicklern.</p>
<p>Am 17. November 2026 veröffentlichten die Sicherheitsforscher von Microsoft eine Analyse, wie derselbe Ablauf gegen KI-Coding-Assistenten eingesetzt werden kann.</p>
<h2>Das Angriffsmuster</h2>
<p>Beim <em>Device-Code-Phishing</em> startet der <strong>Angreifer</strong> die Anmeldung auf seinem eigenen Rechner, erhält einen Code und schickt ihn dem Opfer. Die Nachricht kann wie eine IT-Anfrage oder eine Lizenzprüfung aussehen. Das Opfer öffnet die echte Anmeldeseite, gibt den Code ein und bestätigt, womit es den Angreifer anmeldet.</p>
<p>Die Anmeldeseite ist legitim, deshalb funktioniert die Technik. In den Worten von Microsoft sagt die legitime Seite allein dem Nutzer nicht, wer die Anfrage gestartet hat.</p>
<figure class="b-fig"><img src="https://iamops.dev/img/device-code-phishing-ai-agents.de.svg" alt="Sequenzdiagramm mit drei Beteiligten: Angreifer, Person und echte Anmeldeseite. Der Angreifer fordert einen Device Code an und schickt der Person den User Code. Die Person gibt ihn auf der echten Seite ein und bestätigt, und die Abfrage des Angreifers erhält Tokens für das Konto der Person." width="1200" height="630" loading="lazy" decoding="async"><figcaption><strong>Der Ablauf aus Sicht des Angreifers.</strong> Die Schritte 1 und 4 laufen auf dem Rechner des Angreifers. Die Person macht nur Schritt 3, auf einer Seite, die wirklich zum Anmeldedienst gehört. Prüfen lässt sich daher nur der Code.</figcaption></figure>
<h2>Was Microsoft gezeigt hat</h2>
<p>Das Team führte einen <strong>kontrollierten Labortest</strong> durch, mit dem Kommandozeilenwerkzeug von GitHub Copilot als Beispiel. Mit einem einzigen bestätigten Code konnte es, je nach Kontoeinstellungen:</p>
<ul>
<li>eine aktive Sitzung des Assistenten aus der Ferne steuern und ihn Befehle auf dem Rechner der Person ausführen lassen,</li>
<li>irreführende Einträge in das Gedächtnis des Assistenten schreiben,</li>
<li>in der Cloud gespeicherte Sitzungsverläufe lesen,</li>
<li>auf private Code-Repositories zugreifen, die für das Konto sichtbar waren.</li>
</ul>
<p>Microsoft betont, dass es sich um Proof-of-Concept-Ergebnisse handelt und dass es diese vier Folgen in echten Angriffen nicht beobachtet hat. Device-Code-Phishing selbst ist eine andere Sache. Laut Microsoft ist es ein wiederkehrender Weg zur Kontoübernahme; das Unternehmen nennt frühere Kampagnen, darunter eine namens EvilTokens, deren Zerschlagung es im September 2026 unterstützt hat.</p>
<h2>Empfohlene Gegenmaßnahmen</h2>
<ul>
<li><strong>Geben Sie einen Device Code nur ein, wenn Sie ihn selbst angefordert haben</strong>, auf einem Bildschirm, den Sie selbst gestartet haben. Ein Code in einer Nachricht von jemand anderem ist ein Warnsignal, auch wenn die Seite echt ist.</li>
<li><strong>Prüfen Sie die mit Ihren Konten verbundenen Anwendungen</strong> und entfernen Sie unbekannte. Microsofts Hinweise nennen als Beispiel die GitHub-Einstellungen „authorized OAuth apps“.</li>
<li><strong>Nutzen Sie die restriktivsten Einstellungen</strong>, die Ihre KI-Werkzeuge für Fernsteuerung und Cloud-Speicherung von Sitzungen erlauben.</li>
</ul>
<p>Microsofts grundsätzlicher Punkt: Je mehr ein KI-Assistent erreichen kann, desto mehr ist eine einzelne durch Phishing erschlichene Freigabe wert.</p>
<p><em>Quelle: <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. November 2026</a>.</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>Device-Code-Phishing: ein Briefing für Führungskräfte nach Microsofts Labortest</title>
      <link>https://iamops.dev/de/device-code-phishing-briefing-for-managers/</link>
      <guid isPermaLink="true">https://iamops.dev/de/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>KI-Agenten</category>
      <category>Sicherheit</category>
      <description>Microsoft zeigte am 17. November 2026 im Labor, dass ein bestätigter Device Code einem Angreifer einen KI-Assistenten geben kann. Was Sie dem Team sagen.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/de/device-code-phishing-briefing-for-managers.png?v=986e5733" alt="" /></p><p><strong>Kurz gesagt</strong></p>
<ul>
<li>Am 17. November 2026 veröffentlichte Microsoft eine Laboranalyse zu Device-Code-Phishing gegen KI-Coding-Assistenten. Die Seite, die die Person sieht, ist echt; die Anfrage stammt vom Angreifer.</li>
<li>Im Labor erlaubte eine einzige bestätigte GitHub-Device-Code-Anfrage den Forschern, je nach Einstellungen eine Sitzung zu steuern, irreführende Speicher-Einträge zu schreiben, den Sitzungsverlauf in der Cloud zu lesen oder private Repositories zu erreichen.</li>
<li>Microsoft bezeichnet diese vier Ergebnisse als Proof of Concept und sagt, sie seien in echten Angriffen nicht beobachtet worden. Device-Code-Phishing selbst ist ein wiederkehrender Weg zur Kontoübernahme.</li>
<li>Geben Sie einen Device Code nur für eine Anmeldung ein, die Sie selbst gestartet haben. Prüfen Sie verbundene Anwendungen und schränken Sie ein, was der Assistent erreichen kann.</li>
</ul>
<p>Device-Code-Anmeldung ist der Ablauf, bei dem ein Gerät ohne bequeme Tastatur einen kurzen Code anzeigt und Sie diesen Code auf einem zweiten Gerät eingeben, um die Anmeldung zu bestätigen. Smart-TVs nutzen ihn. Viele Kommandozeilenwerkzeuge auch.</p>
<p>Am 17. November 2026 veröffentlichten die Sicherheitsforscher von Microsoft eine Analyse, wie derselbe Ablauf gegen KI-Coding-Assistenten eingesetzt werden kann. Ich habe bereits einen <a href="https://iamops.dev/de/device-code-phishing-ai-agents/">längeren Beitrag</a> zum technischen Detail geschrieben. Dies ist das kürzere Briefing, das ich einer Führungskraft geben würde.</p>
<h2>Was der Angriff wirklich ist</h2>
<p>Beim Device-Code-Phishing startet der Angreifer die Anmeldung auf seinem eigenen Rechner und erhält einen kurzen Code. Er schickt diesen Code an jemand anderen, oft verpackt als IT-Anfrage oder Lizenzprüfung. Die Person öffnet die echte Anmeldeseite, gibt den Code ein und bestätigt. Damit wird der Angreifer angemeldet.</p>
<p>Die Seite ist echt. Deshalb funktioniert der Trick. Microsofts Punkt ist, dass eine legitime Seite Ihnen nicht sagt, wer die Anfrage gestartet hat. Die Prüfseite von GitHub, so Microsoft, warnt davor, jemals einen Code zu verwenden, den jemand anderes geschickt hat.</p>
<figure class="b-fig"><img src="https://iamops.dev/img/device-code-phishing-briefing-for-managers.de.svg" alt="Drei Schritte in einer Reihe: jemand schickt Ihnen einen kurzen Code, Sie geben ihn auf einer echten Anmeldeseite ein, und die Person, die die Anfrage gestartet hat, ist angemeldet. Bestätigen Sie einen Code nur, wenn Sie die Anmeldung selbst gestartet haben." width="1200" height="630" loading="lazy" decoding="async"><figcaption><strong>Was die Person tatsächlich tut.</strong> Der einzige Schritt, den sie ausführt, ist die Eingabe eines kurzen Codes auf einer echten Anmeldeseite. Die Anfrage hinter diesem Code hat jemand anderes gestartet.</figcaption></figure>
<h2>Was Microsoft im Labor gezeigt hat</h2>
<p>Das Team verwendete das Kommandozeilenwerkzeug von GitHub Copilot als Beispiel. Die Technik ist nicht auf dieses Werkzeug beschränkt: Jeder öffentliche Client, der diesen Anmeldeablauf unterstützt, kann auf dieselbe Weise missbraucht werden, und der Angreifer wählt, welche Berechtigungen er anfordert. Ein öffentlicher Client ist eine Anwendung, die kein Geheimnis sicher aufbewahren kann, etwa ein Kommandozeilenwerkzeug oder ein Fernseher.</p>
<p>In einem kontrollierten Labortest bestätigte ein Testkonto eine GitHub-Device-Code-Anfrage, die die Forscher gestartet hatten. Mit dieser einen Bestätigung konnten sie, je nach Einstellungen des Kontos:</p>
<ul>
<li>eine aktive Sitzung des Assistenten aus der Ferne steuern und ihn Befehle auf dem Rechner der Person ausführen lassen,</li>
<li>irreführende Einträge in den Speicher des Assistenten schreiben,</li>
<li>den in der Cloud gespeicherten Sitzungsverlauf lesen,</li>
<li>private Code-Repositories erreichen, die für das Konto sichtbar sind.</li>
</ul>
<p>Microsoft stellt fest, dass dies Proof-of-Concept-Ergebnisse sind und dass es diese vier Ausgänge in echten Angriffen nicht beobachtet hat. Device-Code-Phishing selbst ist älter. Microsoft bezeichnet es als wiederkehrenden Weg zur Kontoübernahme und nennt frühere Kampagnen, darunter eine namens EvilTokens, an deren Unterbrechung Microsoft im September 2026 beteiligt war.</p>
<h2>Was ich einem Team sagen würde</h2>
<p>Geben Sie einen Device Code nur für eine Anmeldung ein, die Sie selbst gestartet haben, auf einem Bildschirm, den Sie geöffnet haben. Ein Code, der in einer Nachricht von jemand anderem ankommt, ist eine Warnung, auch wenn die Seite echt ist.</p>
<p>Prüfen Sie die mit Arbeitskonten verbundenen Anwendungen und entfernen Sie solche, die niemand erkennt. Microsoft verweist als Beispiel auf die GitHub-Einstellungen für autorisierte OAuth-Apps. OAuth-Apps sind die Anwendungen, denen eine Person die Nutzung eines Kontos erlaubt hat.</p>
<p>Für KI-Coding-Werkzeuge nutzen Sie die strengsten Einstellungen für Fernsteuerung, Sitzungsspeicher in der Cloud und Speicher, mit denen Sie arbeiten können. Eine Bestätigung ist nur so viel wert wie das, was der Assistent erreichen kann.</p>
<p>Microsoft beschreibt außerdem Erkennungen in Microsoft Defender für Phishing dieser Art per E-Mail oder Teams sowie eine Möglichkeit, eine verwaltete GitHub-Identität zu sperren. Das betrifft Sicherheitsteams. Die Gewohnheit, die ich von allen erwarte, ist die erste: Wenn Sie die Anmeldung nicht selbst gestartet haben, geben Sie den Code nicht ein.</p>
<p>Der <a href="https://iamops.dev/de/device-code-phishing-ai-agents/">längere Beitrag</a> enthält den Ablauf Schritt für Schritt und dieselbe Quelle.</p>
]]></content:encoded>
    </item>
    <item>
      <title>Microsoft-Entra-On-Behalf-of-Ablauf für die mittlere Schicht eines Agenten: Zertifikat statt Client Secrets</title>
      <link>https://iamops.dev/de/entra-on-behalf-of-agent-middle-tier/</link>
      <guid isPermaLink="true">https://iamops.dev/de/entra-on-behalf-of-agent-middle-tier/</guid>
      <pubDate>Sat, 14 Nov 2026 08:00:00 GMT</pubDate>
      <dc:creator>Argo</dc:creator>
      <category>Labs</category>
      <category>Entra ID</category>
      <category>On-behalf-of</category>
      <category>KI-Agenten</category>
      <category>OAuth</category>
      <category>Workload-Identität</category>
      <description>Labor im Testmandanten: Device Code, die Agenten-API tauscht das Token On-Behalf-of per Zertifikat ohne Secret, ein nicht genehmigter Scope scheitert.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/de/entra-on-behalf-of-agent-middle-tier.png?v=986e5733" alt="" /></p><p><strong>Kurz gesagt</strong></p>
<ul>
<li>Für Agenten, die APIs im Namen eines angemeldeten Nutzers aufrufen, lautet Entras aktuelle Antwort der On-Behalf-of-Ablauf (OBO); ID-JAG ist dort heute nur eine Bereitschaftsumfrage.</li>
<li>Die Middle API weist sich mit einer zertifikatsignierten Assertion aus und hält null Client Secrets.</li>
<li>Eine Anmeldung ergibt je Audience eigene Tokens: Der Nutzer bleibt gleich, die aufrufende Anwendung wechselt.</li>
<li>Ein Scope ohne Einwilligung scheitert mit AADSTS65001; entscheidend ist die Einwilligung am Service Principal.</li>
<li>OBO-Tokens behalten den ursprünglichen Client nicht, daher müssen Audits Anmeldeprotokolle verknüpfen.</li>
</ul>
<p>Am 14. November 2026 hat Microsoft einen Learn-Artikel veröffentlicht, der erstmals <a href="https://iamops.dev/de/id-jag-explained/">ID-JAG</a> neben Microsoft Entra Agent ID nennt und ein Interessenformular dafür öffnet. Das ist eine Bereitschaftsumfrage, keine ausgelieferte Funktion: Entra stellt ID-JAGs heute weder aus noch akzeptiert es sie. Für Agenten, die APIs für einen angemeldeten Nutzer aufrufen müssen, lautet Entras aktuelle Antwort der On-Behalf-of-Ablauf (OBO). Ich habe ihn in einem Wegwerf-Mandanten komplett durchgespielt und notiert, was jeder Schritt tut.</p>
<h2>Was das Labor zeigt</h2>
<p>Drei App-Registrierungen stehen für ein Agentensystem:</p>
<table>
<thead>
<tr>
<th>App</th>
<th>Rolle</th>
<th>Anmeldedaten</th>
</tr>
</thead>
<tbody>
<tr>
<td>Client</td>
<td>Oberfläche oder Kommandozeile des Agenten. Öffentlicher Client, Anmeldung per Device Code.</td>
<td>Keine</td>
</tr>
<tr>
<td>Agent Middle API</td>
<td>Das Backend des Agenten. Führt den OBO-Tausch aus.</td>
<td>Ein X.509-Zertifikat, <strong>null Client Secrets</strong></td>
</tr>
<tr>
<td>Resource API</td>
<td>Die nachgelagerte API. Stellt den delegierten Scope <code>Data.Read</code> bereit.</td>
<td>n. z.</td>
</tr>
</tbody>
</table>
<p>Der Nutzer meldet sich einmal am Client an. Der Client hält ein Token, dessen Audience nur die Middle API ist. Die Middle API tauscht es gegen ein Token für die Resource API und ein weiteres für Microsoft Graph und weist sich dabei mit einer zertifikatsignierten Assertion aus statt mit einem Secret.</p>
<h2>Einrichtung</h2>
<p>Verwenden Sie einen <strong>separaten Testmandanten</strong> (Entra ID Free genügt, Azure-Ressourcen sind nicht nötig). OBO-Tokens enthalten echte Nutzer-Claims, und ein Wegwerf-Mandant hält Experimente von Einwilligungen, Conditional Access und Audit-Logs der Produktion fern. Im Portal:</p>
<ol>
<li>Registrieren Sie die Resource API und stellen Sie einen delegierten Scope <code>Data.Read</code> bereit (Administratoren und Nutzer).</li>
<li>Registrieren Sie die Agent Middle API, stellen Sie <code>access_as_user</code> bereit und fügen Sie die delegierten Berechtigungen <code>Data.Read</code> und Microsoft Graph <code>User.Read</code> hinzu; erteilen Sie dann die Administratoreinwilligung.</li>
<li>Erzeugen Sie mit <code>openssl</code> einen 2048-Bit-RSA-Schlüssel und ein selbstsigniertes Zertifikat mit 60 Tagen Laufzeit, behalten Sie den privaten Schlüssel auf dem Rechner (Modus 0600) und laden Sie nur das öffentliche Zertifikat unter <em>Certificates &amp; secrets</em> hoch.</li>
<li>Registrieren Sie den Client als öffentlichen Client (Umleitung <code>http://localhost</code>, <em>Allow public client flows</em> an) mit Berechtigung für <code>access_as_user</code> und <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="Terminalausgabe von openssl mit Zertifikats-Subject und SHA-1-Fingerabdruck, der durch einen Platzhalter ersetzt ist." width="1894" height="301" loading="lazy" decoding="async"><figcaption><strong>Die Anmeldedaten.</strong> Ein selbstsigniertes Zertifikat ist die einzige Anmeldeinformation der Middle API. Der Fingerabdruck ist durch einen Platzhalter ersetzt; der private Schlüssel wird nie gezeigt.</figcaption></figure>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/11-no-secrets.webp" alt="Microsoft Entra Admin Center, Seite Certificates and secrets der Agent Middle API mit geöffnetem Reiter Client secrets, der null Client Secrets zeigt." width="1280" height="665" loading="lazy" decoding="async"><figcaption><strong>Keine Secrets.</strong> Der Reiter Client secrets zeigt 0. Ein Zertifikat beweist den Besitz eines Schlüssels, der nie übertragen wird; ein Secret ist eine wiederverwendbare Zeichenkette, die in Konfigurationen und Logs landet.</figcaption></figure>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/08-permissions.webp" alt="Microsoft Entra Admin Center, API permissions der Agent Middle API: User.Read für Microsoft Graph und Data.Read für die Resource API, beide delegiert und für das Verzeichnis erteilt." width="1280" height="665" loading="lazy" decoding="async"><figcaption><strong>Was die mittlere Schicht anfordern darf.</strong> Entra prüft diese delegierten Berechtigungen beim Tausch. Was nicht aufgeführt und freigegeben ist, lässt sich nachgelagert nicht erhalten.</figcaption></figure>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/17-consent.webp" alt="Microsoft Entra Admin Center, Enterprise applications, Permissions des Service Principals der Agent Middle API mit Administratoreinwilligung für User.Read und Data.Read." width="1280" height="665" loading="lazy" decoding="async"><figcaption><strong>Was sie tatsächlich bekam.</strong> App-Registrierungen zeigen, was eine App anfordert; die Berechtigungen des Service Principals zeigen, was ihr gewährt wurde. Governance-Werkzeuge sollten Letzteres lesen.</figcaption></figure>
<h2>Der Ablauf</h2>
<p><strong>Anmeldung per <a href="https://iamops.dev/de/device-code-phishing-ai-agents/">Device Code</a>.</strong> Der Client fordert beim v2.0-Endpunkt <code>devicecode</code> einen Code an. Die Anfrage enthält nur die ID des Clients und den Scope der Middle API, kein Secret. Der Nutzer gibt den Code auf einem zweiten Gerät ein, und Entra zeigt eine Prüfung „Anmeldung auf einem anderen Gerät genehmigen“, die App und Standort nennt; der Nutzer muss sie von Hand bestätigen.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/18-devicecode.webp" alt="Terminalausgabe der Geräteautorisierungsanfrage und ihrer Antwort, mit Mandant, Client-ID und Benutzercode als Platzhalter." width="1894" height="530" loading="lazy" decoding="async"><figcaption><strong>Geräteautorisierung.</strong> Kennungen und Benutzercode sind Platzhalter.</figcaption></figure>
<p><strong>Das Nutzer-Token.</strong> Nach der Genehmigung fragt der Client den Token-Endpunkt ab. Sein Token ist direkt gegen die Resource API oder Graph nutzlos, weil seine Audience die Middle API ist.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/24-user-token.webp" alt="Dekodierte Claims des Nutzer-Tokens: Die Audience ist die Middle API, appid ist der Client, der Scope ist access_as_user. Kennungen und Name des Nutzers sind durch Platzhalter ersetzt." width="1894" height="607" loading="lazy" decoding="async"><figcaption><strong>Das einzige Token des Clients.</strong> Audience: die Middle API. Anwendung: der Client. Scope: access_as_user.</figcaption></figure>
<p><strong>Der Tausch.</strong> Die Middle API baut eine Client-Assertion (ein RS256-JWT mit dem Fingerabdruck des Zertifikats in <code>x5t</code>; Aussteller und Subject sind ihre eigene Client-ID; Audience ist der Token-Endpunkt; zehn Minuten Lebensdauer), signiert sie mit dem privaten Schlüssel und sendet die OBO-Anfrage:</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="Dekodierte Claims des OBO-Tokens für die Resource API: Audience ist die Resource API, appid die Middle API, Scope Data.Read, gleiche Objekt-ID des Nutzers. Kennungen sind Platzhalter." width="1894" height="607" loading="lazy" decoding="async"><figcaption><strong>Token für die Resource API.</strong> Audience: die Resource API. Anwendung: die Middle API. Scope: Data.Read. Gleicher Nutzer.</figcaption></figure>
<p>Dieselbe Assertion mit dem Scope <code>https://graph.microsoft.com/User.Read</code> liefert ein Graph-Token, das das Labor einmal für <code>GET /v1.0/me</code> nutzt.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/26-obo-graph.webp" alt="Dekodierte Claims des OBO-Tokens für Microsoft Graph und die Antwort des Graph-Aufrufs me, mit Name und Prinzipalnamen des Nutzers als Platzhalter." width="1894" height="721" loading="lazy" decoding="async"><figcaption><strong>Token für Microsoft Graph, dann ein Aufruf von /me.</strong> Eine Anmeldung verzweigt sich in mehrere Tokens, die jeweils an eine Audience gebunden sind. Name und Prinzipalname des Nutzers sind Platzhalter.</figcaption></figure>
<p><strong>Die drei Tokens im Vergleich.</strong> Der Nutzer ändert sich nie. Die Audience folgt der aufgerufenen API, und <code>appid</code> wechselt vom Client zur 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="Tabelle nebeneinander mit Audience, appid, Scope, Objekt-ID und Mandanten-ID für das Nutzer-Token und die beiden OBO-Tokens. Kennungen sind Platzhalter." width="1894" height="416" loading="lazy" decoding="async"><figcaption><strong>Drei Tokens nebeneinander.</strong> Gleicher Nutzer und Mandant; bei jedem Schritt wechseln Audience und aufrufende Anwendung.</figcaption></figure>
<p><strong>Der Negativtest.</strong> Die Anforderung von <code>https://graph.microsoft.com/Mail.Read</code>, dem niemand zugestimmt hat, scheitert am Token-Dienst:</p>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/28-negative.webp" alt="Terminalausgabe eines Fehlers invalid_grant AADSTS65001: Nutzer oder Administrator hat der Nutzung der Anwendung nicht zugestimmt. Anwendungs-ID, Trace-ID und Correlation-ID sind Platzhalter." width="1894" height="416" loading="lazy" decoding="async"><figcaption><strong>AADSTS65001.</strong> Die Einwilligung wird zur Token-Zeit am Service Principal der mittleren Schicht geprüft. Für einen nicht interaktiven Agenten gibt es keinen Rückfall auf eine interaktive Abfrage.</figcaption></figure>
<h2>Stolperfallen</h2>
<ul>
<li><strong>Der ursprüngliche Client geht verloren.</strong> OBO-Tokens der Version 1 halten nur die letzte Anwendung fest (<code>appid</code>). Es gibt keinen <code>act</code>-Claim wie bei einer RFC-8693-Implementierung; ein Audit muss daher Anmelde-Logs verknüpfen, um die Kette zu rekonstruieren.</li>
<li><strong>Die eingehende Audience muss die Middle API sein.</strong> Ein Token für eine andere App wird abgelehnt, das ist der Schutz gegen den Confused Deputy.</li>
<li><strong>Device Code braucht „Allow public client flows“.</strong> Es ist auch der Ablauf, den Device-Code-Phishing ausnutzt. Der Bildschirm „Anmeldung auf einem anderen Gerät genehmigen“ ist Microsofts Gegenmaßnahme; schulen Sie Nutzer, „Das war ich nicht“ zu drücken, und beschränken Sie den Ablauf mit Conditional Access dort, wo Agenten ihn nicht brauchen.</li>
<li><strong>Entscheidend ist die Administratoreinwilligung am Service Principal</strong>, nicht das, was die Registrierung auflistet.</li>
</ul>
<h2>Sicherheitserkenntnisse</h2>
<ol>
<li>Verwenden Sie für die mittlere Schicht ein Zertifikat oder eine föderierte Anmeldeinformation. Kein Secret heißt: nichts Wiederverwendbares, das aus Konfiguration, CI-Variablen oder Logs abfließen kann.</li>
<li>Halten Sie die delegierten Scopes der mittleren Schicht minimal und prüfen Sie sie am Service Principal.</li>
<li>Lassen Sie den Client ohne Anmeldedaten. Er kann immer nur das Token des Nutzers für die Middle API halten, nie ein nachgelagertes Token.</li>
<li>Planen Sie die Audit-Verknüpfung (Nutzer, Agent, nachgelagerte Audience), denn OBO-Tokens behalten den ersten Schritt nicht.</li>
<li>Halten Sie fest, welche Berechtigung jeder Schritt nutzt (heute OBO; ID-JAG, sobald Entra es unterstützt) und wo die Einwilligung liegt, damit Zugriffsüberprüfungen die Berechtigungen von Service Principals sehen.</li>
</ol>
<h2>Was nicht ausgeführt wurde</h2>
<p>Nicht ausgeführt wurden Entra-Agent-ID-Blueprints und Agentenidentitäten (dasselbe Labor mit vererbbaren Berechtigungen). Die Conditional-Access-Richtlinie, die Device Code blockiert, wurde nicht getestet. Die Zusatzaufgaben (Einwilligung entfernen und den Tausch wiederholen, optionale Claims, v2-Tokens) wurden nicht ausgeführt. Die Portal-Screenshots sind auf den Seiteninhalt zugeschnitten: Browserleiste, Profilmenü und alle Kennungen von Mandant, Anwendungen und Nutzern sind entfernt. Für dieses Labor wird keine Aufzeichnung veröffentlicht.</p>
<p><em>Die Terminalbilder wurden aus der gespeicherten Ausgabe des Laufs erzeugt; Kennungen sind durch Platzhalter ersetzt. Die Portal-Screenshots zeigen nur den Seiteninhalt.</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>OAuth Token Exchange mit Keycloak (RFC 8693): Tokens für KI-Agenten und MCP-Server einschränken</title>
      <link>https://iamops.dev/de/keycloak-token-exchange-rfc-8693/</link>
      <guid isPermaLink="true">https://iamops.dev/de/keycloak-token-exchange-rfc-8693/</guid>
      <pubDate>Thu, 12 Nov 2026 08:00:00 GMT</pubDate>
      <dc:creator>Argo</dc:creator>
      <category>Labs</category>
      <category>Token Exchange</category>
      <category>Keycloak</category>
      <category>RFC 8693</category>
      <category>MCP</category>
      <category>KI-Agenten</category>
      <description>Keycloak-Labor: Ein MCP-Server tauscht das Nutzer-Token gegen ein engeres für eine nachgelagerte API; drei ungültige Tauschversuche werden abgelehnt.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/de/keycloak-token-exchange-rfc-8693.png?v=986e5733" alt="" /></p><p><strong>Kurz gesagt</strong></p>
<ul>
<li>Der Token Exchange nach RFC 8693 lässt einen MCP-Server das Nutzer-Token gegen ein engeres für genau eine nachgelagerte API tauschen.</li>
<li>In Keycloak wird er pro Client aktiviert, und die nachgelagerte Audience ist ein optionaler Scope.</li>
<li>Das getauschte Token behält den Nutzer als Subject, trägt nur die nachgelagerte Audience, lebt 300 Sekunden und enthält kein Refresh Token.</li>
<li>Drei ungültige Tauschversuche werden abgelehnt: ein Client ohne das Recht, eine Audience ohne Scope und die Anforderung eines Refresh Tokens.</li>
<li>In diesem Aufbau gibt es keinen act-Claim; der handelnde Client erscheint nur als Authorized Party.</li>
</ul>
<p>Am 12. November 2026 hat Amazon Cognito OAuth 2.0 Token Exchange (RFC 8693) eingeführt, wenige Tage nach WorkOS Connect. Entra bietet seit Jahren einen eigenen On-Behalf-of-Ablauf. Das Muster ist inzwischen bei den großen Identity-Providern verbreitet: Ein Dienst, der für einen Nutzer handelt, tauscht dessen Token gegen ein neues Token, das enger gefasst, an genau einen Empfänger (Audience) gebunden und kurzlebig ist, statt das ursprüngliche weiterzureichen. Ich habe es gegen ein lokales Keycloak laufen lassen und notiert, was der Server tat.</p>
<p>Dieses Labor führt das Muster auf einem Laptop mit Keycloak aus, einem quelloffenen Autorisierungsserver. So sieht man genau, was sich im Token ändert und was der Server ablehnt.</p>
<h2>Was das Labor zeigt</h2>
<p>Ein KI-Agent meldet den Nutzer an und hält ein Token für einen <a href="https://iamops.dev/de/mcp-server-no-token-passthrough/">MCP-Server</a>. Der MCP-Server muss für diesen Nutzer eine Zahlungs-API aufrufen, darf das Token des Agenten aber nicht weiterreichen. Stattdessen legt er es dem Autorisierungsserver vor und bittet um ein Token nur für die Zahlungs-API.</p>
<p>Das Labor verwendet drei Clients in einem Realm:</p>
<table>
<thead>
<tr>
<th>Client</th>
<th>Rolle</th>
<th>Darf Tokens tauschen?</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>agent</code></td>
<td>Erhält das Token des Nutzers (Password Grant, nur Labor-Abkürzung)</td>
<td>Nein</td>
</tr>
<tr>
<td><code>mcp-server</code></td>
<td>Tauscht das Token des Nutzers</td>
<td>Ja</td>
</tr>
<tr>
<td><code>payments-api</code></td>
<td>Nur eine Audience, die nachgelagerte API</td>
<td>Nein</td>
</tr>
</tbody>
</table>
<h2>Einrichtung</h2>
<p>Keycloak 26.8.2 lief aus der Zip-Distribution mit Java 21 im Entwicklungsmodus, nach frischem Entpacken. Der Entwicklungsmodus ist nur für Labore gedacht. Die Passwörter sind Wegwerfwerte; in diesem Beitrag erscheinen sie als <code>&lt;lab-password&gt;</code> und <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="Terminalausgabe des Einrichtungsskripts, das den Realm agentlab, einen Nutzer, drei Clients und zwei Client Scopes anlegt; die Kennungen sind durch Platzhalter in spitzen Klammern ersetzt." width="1894" height="492" loading="lazy" decoding="async"><figcaption><strong>Einrichtung.</strong> Das Skript legt den Realm, einen Testnutzer, die drei Clients und zwei Client Scopes an, die Audiences hinzufügen. Objekt-IDs sind durch Platzhalter ersetzt.</figcaption></figure>
<p>In der Admin-Konsole tragen zwei Einstellungen das Design. Nur <code>mcp-server</code> hat <strong>Standard Token Exchange</strong> aktiviert, und die nachgelagerte Audience ist ein <em>optionaler</em> Scope, wird also nur hinzugefügt, wenn der Tausch sie anfordert.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/keycloak-token-exchange-rfc-8693/05-exchange-toggle.webp" alt="Keycloak-Admin-Konsole, Capability-Konfiguration des Clients mcp-server, mit angehaktem Kontrollkästchen Standard Token Exchange." width="1600" height="960" loading="lazy" decoding="async"><figcaption><strong>Das Privileg.</strong> Standard Token Exchange ist nur beim Client mcp-server angehakt. Ein kompromittierter Agent-Client kann keine Tokens für andere APIs ausstellen.</figcaption></figure>
<figure class="b-fig"><img src="https://iamops.dev/media/keycloak-token-exchange-rfc-8693/06-client-scopes.webp" alt="Keycloak-Admin-Konsole, Client Scopes des Clients mcp-server, mit dem Scope aud-payments-api als Optional." width="1600" height="960" loading="lazy" decoding="async"><figcaption><strong>Die Audience.</strong> aud-payments-api ist für mcp-server optional, die nachgelagerte Audience muss also ausdrücklich angefordert werden.</figcaption></figure>
<h2>Der Ablauf</h2>
<p>Der Agent holt ein Nutzer-Token, dann tauscht der MCP-Server es. Die zentrale Anfrage ist ein einziger Aufruf des Token-Endpunkts:</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="Terminalausgabe mit dem Vergleich von dekodiertem Nutzer-Token und getauschtem Token. Die Audience wechselt von mcp-server und account zu payments-api, azp von agent zu mcp-server, expires_in ist 300, es gibt weder Refresh Token noch act-Claim." width="1894" height="1027" loading="lazy" decoding="async"><figcaption><strong>Vorher und nachher.</strong> Gleicher Nutzer, neue Audience (payments-api), neue autorisierte Partei (mcp-server), 300 Sekunden Lebensdauer, kein Refresh Token. Die Nutzerkennung ist durch einen Platzhalter ersetzt.</figcaption></figure>
<p>Vergleicht man die beiden Tokens: Das Subject bleibt gleich, die Audience ist jetzt nur noch die Zahlungs-API, die autorisierte Partei (<code>azp</code>) nennt den MCP-Server, die Lebensdauer beträgt 300 Sekunden und es kommt kein Refresh Token zurück. Es gibt <strong>keinen <code>act</code>-Claim</strong>: Die Delegationsunterstützung von Keycloak ist eine Vorschaufunktion, die standardmäßig ausgeschaltet ist; der Akteur erscheint also nur als <code>azp</code>.</p>
<h2>Absichtlich scheitern lassen</h2>
<p>Drei Tauschversuche müssen abgelehnt werden. Prüfen Sie dieselben drei bei jedem Identity-Provider, bevor Sie ihm die Delegation für Agenten anvertrauen.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/keycloak-token-exchange-rfc-8693/08-negative.webp" alt="Terminalausgabe von drei abgelehnten Tauschversuchen: ein Client ohne aktivierten Token Exchange, eine Audience, für die der MCP-Server keinen Scope hat, und die Anforderung eines Refresh Tokens; jeder liefert invalid_request." width="1894" height="874" loading="lazy" decoding="async"><figcaption><strong>Drei Ablehnungen.</strong> A: ein Client ohne das Tauschprivileg. B: eine Audience, für die der MCP-Server keinen Scope hat. C: ein Refresh Token. Alle liefern invalid_request. Client Secrets sind durch Platzhalter ersetzt.</figcaption></figure>
<h2>Stolperfallen</h2>
<ul>
<li><strong>Der Password Grant ist eine Abkürzung.</strong> Das Labor nutzt ihn nur, um schnell ein Nutzer-Token zu bekommen. RFC 9700 und OAuth 2.1 schließen ihn für echte Clients aus; verwenden Sie den Authorization-Code-Flow mit <a href="https://iamops.dev/de/tools/pkce/">PKCE</a>.</li>
<li><strong>Der <code>aud</code>-Claim kann mehr auflisten als erwartet.</strong> Bei der Introspektion des getauschten Tokens erschienen die Zahlungs-API und <code>account</code>. Verstehen Sie das, bevor Sie sich auf Audience-Prüfungen verlassen.</li>
<li><strong>Die Reihenfolge der Scopes schwankt</strong> von Lauf zu Lauf; vergleichen Sie Scope-Zeichenketten daher nicht wörtlich.</li>
<li><strong>Standardmäßig kein <code>act</code>-Claim.</strong> Braucht Ihr Audit den Akteur, planen Sie die Vorschaufunktion für Delegation ein oder verknüpfen Sie <code>azp</code> selbst in den Logs.</li>
</ul>
<h2>Sicherheitserkenntnisse</h2>
<ol>
<li>Token Exchange ist ein Privileg. Vergeben Sie es nur an den einen Client, der es braucht.</li>
<li>Machen Sie die nachgelagerte Audience explizit und optional, damit getauschte Tokens standardmäßig eng bleiben.</li>
<li>Geben Sie in einem Tausch nie Refresh Tokens aus. Der Server des Labors lehnt sie ab.</li>
<li>Ein Dienst sollte Tokens ablehnen, die nicht für ihn ausgestellt wurden, und pro nachgelagerter API tauschen, nie das Token des Nutzers weiterreichen.</li>
<li>Prüfen Sie, was Ihr Audit-Trail rekonstruieren kann. Erscheint der Akteur nur als <code>azp</code>, muss eine Logzeile Nutzer, Agent und nachgelagerte Audience verbinden.</li>
</ol>
<h2>Was nicht ausgeführt wurde</h2>
<p>Nicht ausgeführt wurden die Docker-Variante, die Zusatzaufgaben (Refresh Tokens im Standard-Tausch, Introspektion durch die nachgelagerte API) und die Vorschaufunktion für Delegation, die <code>act</code> hinzufügen würde. Das Labor verwendete nur Wegwerfkonten. Für dieses Labor wird keine Aufzeichnung veröffentlicht.</p>
<p><em>Die Terminalbilder wurden aus der gespeicherten Ausgabe des Laufs erzeugt; Kennungen und Geheimnisse sind durch Platzhalter ersetzt. Die Keycloak-Screenshots zeigen nur Testobjekte.</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>Einen MCP-Server mit OAuth schützen: Token-Passthrough ablehnen und pro nachgelagerter API tauschen</title>
      <link>https://iamops.dev/de/mcp-server-no-token-passthrough/</link>
      <guid isPermaLink="true">https://iamops.dev/de/mcp-server-no-token-passthrough/</guid>
      <pubDate>Wed, 11 Nov 2026 08:00:00 GMT</pubDate>
      <dc:creator>Argo</dc:creator>
      <category>Labs</category>
      <category>MCP</category>
      <category>OAuth</category>
      <category>Token Exchange</category>
      <category>Keycloak</category>
      <category>KI-Agenten</category>
      <description>Labor mit dem offiziellen MCP-Python-SDK und Keycloak: 401-Handshake, Audience-Prüfung, RFC-8693-Tausch für die Zahlungs-API und ein abgelehntes Passthrough.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/de/mcp-server-no-token-passthrough.png?v=986e5733" alt="" /></p><p><strong>Kurz gesagt</strong></p>
<ul>
<li>Ein MCP-Server ist ein OAuth-Resource-Server: Er antwortet mit 401 und Protected Resource Metadata, damit Clients den Authorization Server finden.</li>
<li>Er prüft jedes Bearer Token per Introspektion und lehnt eines ab, dessen Audience den MCP-Server selbst nicht enthält.</li>
<li>Für eine nachgelagerte API tauscht er das Token (RFC 8693), statt das Token des Aufrufers weiterzureichen.</li>
<li>Ein absichtliches Passthrough scheitert: Das getauschte Token für die Zahlungs-API ist für den MCP-Server inaktiv und liefert 401.</li>
<li>Protokolliere Nutzer, Agent-Client und nachgelagerte Audience in einer Zeile, damit Audits die Kette nachvollziehen können.</li>
</ul>
<p>Am 10. November 2026 hat WorkOS Token Exchange (RFC 8693) zu WorkOS Connect hinzugefügt, damit ein MCP-Server nachgelagerte APIs für einen Nutzer aufrufen kann, ohne dessen Token durchzureichen. Genau dieses Muster erwartet die MCP-Autorisierungsspezifikation. Ich habe es von Hand mit dem offiziellen Python-SDK nachgebaut, damit jede Regel sichtbar wird.</p>
<p>Es baut auf dem <a href="https://iamops.dev/de/keycloak-token-exchange-rfc-8693/">Keycloak-Token-Exchange-Labor</a> auf: gleicher Realm, gleiche drei Clients.</p>
<h2>Was das Labor zeigt</h2>
<p>Ein mit dem offiziellen Python-SDK (<code>mcp</code> 2.3.0) geschriebener MCP-Server arbeitet als OAuth-<em>Resource-Server</em> für einen Keycloak-Realm. Er tut vier Dinge:</p>
<ol>
<li>Er beantwortet eine Anfrage ohne Token mit <code>401</code> und einem Verweis auf seine Protected Resource Metadata (RFC 9728), sodass ein Client den Autorisierungsserver finden kann, ohne ihn fest einzutragen.</li>
<li>Er prüft jedes Bearer-Token per Introspektion bei Keycloak und lehnt Tokens ab, deren Audience den MCP-Server selbst nicht enthält.</li>
<li>Für ein Tool tauscht er das Token des Aufrufers gegen ein Token für die Zahlungs-API (RFC 8693), statt es weiterzureichen.</li>
<li>Er lehnt ein für die Zahlungs-API ausgestelltes Token ab, wenn jemand es dem MCP-Server vorlegt (ein Passthrough-Versuch).</li>
</ol>
<p>Der Verifier ist kurz. Die entscheidende Zeile ist die Audience-Prüfung:</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>Der Ablauf</h2>
<p>Legen Sie die SDK-Version fest: <code>mcp</code> 2.x hat <code>FastMCP</code> in <code>MCPServer</code> umbenannt, und SDKs ändern ihre Auth-Klassen zwischen Versionen. Der Server lauscht auf <code>127.0.0.1:8001</code>.</p>
<p><strong>Ohne Token.</strong> Die erste Anfrage ist der Discovery-Handshake, mit dem jeder MCP-Client beginnt: ein <code>401</code>, dessen <code>WWW-Authenticate</code>-Header eine <code>resource_metadata</code>-URL enthält, und ein Metadatendokument, das den Realm als Autorisierungsserver nennt.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/mcp-server-no-token-passthrough/03-no-token.webp" alt="Terminalausgabe: Eine Anfrage ohne Token liefert 401 Unauthorized mit einem www-authenticate-Header, der auf die Metadaten der geschützten Ressource verweist; das Metadatendokument nennt den Keycloak-Realm als Autorisierungsserver." width="1894" height="530" loading="lazy" decoding="async"><figcaption><strong>Der 401-Handshake.</strong> Der Client erfährt aus dem Metadatendokument, wo er ein Token bekommt, nicht aus einer Konfiguration.</figcaption></figure>
<p><strong>Mit Token.</strong> Ein kleines Skript holt ein Nutzer-Token für den Client <code>agent</code>, öffnet eine MCP-Sitzung und ruft beide Tools auf. <code>whoami</code> zeigt, dass der Server den Nutzer über den Agent-Client sieht; <code>downstream_token</code> zeigt, wie der Server das Token gegen eines tauscht, das auf die Zahlungs-API begrenzt ist.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/mcp-server-no-token-passthrough/04-call.webp" alt="Terminalausgabe der beiden Tool-Aufrufe: whoami liefert Subject, Agent-Client und Scopes; downstream_token liefert ein Token mit Audience payments-api und autorisierter Partei mcp-server. Das Subject ist durch einen Platzhalter ersetzt." width="1894" height="683" loading="lazy" decoding="async"><figcaption><strong>Zwei Tools.</strong> Das erste zeigt, wer aufgerufen hat. Das zweite zeigt das getauschte Token: Audience payments-api, autorisierte Partei mcp-server, gleiches Subject. Das Subject ist ein Platzhalter.</figcaption></figure>
<p>Derselbe Aufruf funktioniert über den MCP-Inspector-Kommandozeilenclient, den Standardweg, um nachzustellen, was ein MCP-Host tun würde. Legen Sie seine Version in Skripten fest; dieses Labor nutzte 2.15.0.</p>
<p><strong>Der Passthrough-Versuch.</strong> Erzeugen Sie ein frisches getauschtes Token, betrachten Sie es per Introspektion von beiden Seiten und legen Sie es dem MCP-Server vor.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/mcp-server-no-token-passthrough/06-passthrough.webp" alt="Terminalausgabe: Die Introspektion meldet das Token als aktiv für den Client payments-api und als inaktiv für den Client mcp-server; die Vorlage beim MCP-Server liefert 401." width="1894" height="492" loading="lazy" decoding="async"><figcaption><strong>Kein Passthrough.</strong> Keycloak meldet das Token nur dem Client als aktiv, für den es ausgestellt wurde. Der MCP-Server antwortet mit 401. Client Secrets sind Platzhalter.</figcaption></figure>
<h2>Stolperfallen</h2>
<ul>
<li><strong>Introspektion oder lokale Validierung?</strong> Das Labor nutzt Introspektion: sofortiger Widerruf, dafür ein Roundtrip zum Autorisierungsserver. Die Alternative ist lokale JWT-Validierung gegen die JWKS; notieren Sie, was Sie verlieren und gewinnen.</li>
<li><strong>Prüfen Sie die Audience, nicht nur die Signatur.</strong> Ein gültiges Token für eine andere API bleibt das falsche Token. Die Audience-Prüfung macht aus dem Passthrough ein <code>401</code>.</li>
<li><strong>Tokens leben in diesem Aufbau fünf Minuten</strong>; erzeugen Sie das Passthrough-Token also direkt vor dem Test.</li>
<li><strong>SDK-Drift.</strong> Klassennamen und Auth-Hooks haben sich zwischen Hauptversionen verschoben; testen Sie mit der Version, die Sie ausliefern.</li>
</ul>
<h2>Sicherheitserkenntnisse</h2>
<ol>
<li>Ein MCP-Server ist ein OAuth-Resource-Server. Er veröffentlicht Metadaten, validiert die Audience und lehnt alles ab, was nicht für ihn bestimmt ist.</li>
<li>Reichen Sie das Token des Aufrufers nie an eine nachgelagerte API weiter. Tauschen Sie es pro nachgelagerter Audience, enger gefasst und kurzlebig.</li>
<li>Lassen Sie den Autorisierungsserver entscheiden, wer ein Token als aktiv sieht. Ein Token, das nur beim vorgesehenen Empfänger funktioniert, begrenzt, was ein kompromittierter Zwischenschritt anrichten kann.</li>
<li>Protokollieren Sie eine Zeile, die Nutzer, Agent-Client und nachgelagerte Audience verbindet; das Token allein erzählt einem Auditor nicht die ganze Geschichte.</li>
</ol>
<h2>Was nicht ausgeführt wurde</h2>
<p>Der OAuth-Ablauf der MCP-Inspector-Weboberfläche wurde nicht ausgeführt (der Client <code>agent</code> des Labors erlaubt dafür eine localhost-Weiterleitung). Dynamische Client-Registrierung wurde nicht verwendet; der Client ist vorregistriert. Alles lief auf einem Rechner mit Wegwerfkonten. Für dieses Labor wird keine Aufzeichnung veröffentlicht.</p>
<p><em>Die Terminalbilder wurden aus der gespeicherten Ausgabe des Laufs erzeugt; Kennungen, Geheimnisse und Zeitstempel sind durch Platzhalter ersetzt.</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>Ein autonomer KI-Agent ohne Secrets auf Azure: eine API mit Managed Identity aus Container Apps aufrufen</title>
      <link>https://iamops.dev/de/secretless-agent-managed-identity-container-app/</link>
      <guid isPermaLink="true">https://iamops.dev/de/secretless-agent-managed-identity-container-app/</guid>
      <pubDate>Thu, 05 Nov 2026 08:00:00 GMT</pubDate>
      <dc:creator>Argo</dc:creator>
      <category>Labs</category>
      <category>Managed Identity</category>
      <category>Entra ID</category>
      <category>KI-Agenten</category>
      <category>Workload-Identität</category>
      <category>Azure</category>
      <description>Labor: Ein Container-App-Agent mit Managed Identity und ohne Secrets erhält eine enge App-Rolle, bekommt ein App-only-Token, und die API validiert es.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/de/secretless-agent-managed-identity-container-app.png?v=986e5733" alt="" /></p><p><strong>Kurz gesagt</strong></p>
<ul>
<li>Ein autonomer Agent ohne Secret hat nichts, was abfließen kann: eine Container App mit nutzerzugewiesener Managed Identity, ohne Client Secret, Zertifikat und Ingress.</li>
<li>Die Identität startet ohne Rollen; ist an der API die Zuweisung vorgeschrieben, wird die Token-Anfrage abgelehnt (AADSTS501051), bis eine enge App-Rolle vergeben ist.</li>
<li>Das App-only-Token enthält roles und kein scp, und die API prüft trotzdem Signatur, Audience, Aussteller und Rolle.</li>
<li>Tokens werden etwa 24 Stunden gecacht, das Entfernen einer Rolle ist also kein sofortiger Widerruf.</li>
<li>Behandle die Identität wie ein privilegiertes Konto: ein Verantwortlicher, ein Überprüfungsdatum und ein Alarm bei Rollenzuweisungen.</li>
</ul>
<p>Am 5. November 2026 beschrieb Microsoft Threat Intelligence Angreifer, die ein agentisches Offensiv-Framework nutzen, um öffentliche Repositories nach offengelegten Secrets zu durchsuchen und mit gültigen Anwendungsanmeldedaten anschließend als Workloads aufzutreten. Die defensive Lesart ist einfach: Ein autonomer Agent ohne Secret hat nichts, was abfließen kann. Ich habe einen solchen Agenten auf Azure gebaut und jede Aussage nachgeprüft.</p>
<h2>Was das Labor zeigt</h2>
<p>Ein kleiner Agent läuft als Azure Container App. Er hat keinen Nutzer, kein Client Secret und kein Zertifikat. Seine Identität ist eine <strong>nutzerzugewiesene Managed Identity</strong>, die ohne Rollen startet. Das Labor:</p>
<ol>
<li>Verbindet die Identität mit der App und beweist, dass der Container kein Secret enthält.</li>
<li>Lässt die nachgelagerte API (die <em>Resource API</em>, eine App-Registrierung) eine App-Rollen-Zuweisung verlangen.</li>
<li>Zeigt die abgelehnte Token-Anfrage und vergibt dann <strong>eine</strong> enge App-only-Rolle.</li>
<li>Liest das App-only-Token, das der Agent erhält, und prüft es so, wie es die API täte.</li>
</ol>
<h2>Einrichtung</h2>
<p>Verwenden Sie einen separaten Testmandanten und ein separates Abonnement. Der Agent läuft mit 0,25 vCPU und 0,5 GiB im Verbrauchstarif, ohne Ingress und ohne Log-Analytics-Arbeitsbereich. Die ersten 180.000 vCPU-Sekunden pro Monat sind kostenlos; diese Größe verbraucht sie in rund 200 Betriebsstunden. Löschen Sie die App also, wenn Sie fertig sind. Die Managed Identity und die App-Rolle sind kostenlos.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/01-context.webp" alt="Terminalausgabe: Die Azure CLI zeigt Abonnement und Mandant, die Managed Identity mit Client-ID und Principal-ID und null Rollenzuweisungen. Kennungen sind Platzhalter." width="1894" height="683" loading="lazy" decoding="async"><figcaption><strong>Bei null beginnen.</strong> Die Managed Identity hat keine Rollenzuweisungen, daher ist jede Berechtigung im Labor eine bewusste, sichtbare Vergabe. Kennungen sind Platzhalter.</figcaption></figure>
<p>Die App ist in YAML definiert. Das Image ist ein öffentliches, nur wegen seines Python genutzt, sodass keine Registry-Anmeldedaten nötig sind. Der Identity-Block verbindet die Managed Identity. Es gibt keinen <code>ingress</code>-Abschnitt, also kann niemand von außen aufrufen.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/03-app-definition.webp" alt="Terminalausgabe der App-Definition: Standort, ein nutzerzugewiesener Identity-Block, die Umgebungs-ID, ein öffentliches Container-Image, Ressourcen von 0,25 vCPU und 0,5 GiB und die Client-ID als Umgebungsvariable. IDs sind Platzhalter." width="1894" height="874" loading="lazy" decoding="async"><figcaption><strong>Nichts zu stehlen.</strong> Alles, was ein Angreifer dieser Definition entnehmen könnte, ist öffentlich: ein Image-Name, eine Client-ID und der Code. Abonnement- und Client-IDs sind Platzhalter.</figcaption></figure>
<h2>Der Ablauf</h2>
<p><strong>Der Container hält einen Identitätsendpunkt, kein Secret.</strong> Die Plattform injiziert <code>IDENTITY_ENDPOINT</code>, eine localhost-URL, und <code>IDENTITY_HEADER</code>, einen Wert pro Container (in der Ausgabe maskiert). Keine andere Variable sieht nach einem Secret aus, und es ist kein Secret-Volume eingebunden.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/05-secretless.webp" alt="Terminalausgabe aus dem Container: der Identitätsendpunkt auf localhost, der maskierte Identity-Header, die öffentliche Client-ID und keine Variablen namens secret, password, key oder certificate sowie keine eingebundenen Secret-Volumes." width="1894" height="454" loading="lazy" decoding="async"><figcaption><strong>Im Container.</strong> Der Header ist keine Anmeldeinformation für Entra. Er beweist dem lokalen Endpunkt nur, dass der Aufrufer in diesem Container sitzt, was SSRF-Tricks blockiert.</figcaption></figure>
<p><strong>Zuweisung an der API verlangen.</strong> Standardmäßig stellt Entra jedem Service Principal im Mandanten, der fragt, ein App-only-Token mit leerem <code>roles</code>-Claim aus. Setzt man <code>appRoleAssignmentRequired</code> am Service Principal der Resource API auf <code>true</code>, verweigert Entra jedem, der nicht zugewiesen ist, das Token:</p>
<pre><code class="language-bash">az ad sp update --id &lt;resource-sp-id&gt; --set appRoleAssignmentRequired=true
</code></pre>
<p><strong>Zwei Negativtests.</strong> Die Anfrage des Agenten nach einem Token für die Resource API wird vom Token-Dienst mit AADSTS501051 abgelehnt, und ein Graph-Token (Graph verlangt keine Zuweisung) enthält keine Rollen, sodass <code>GET /v1.0/users</code> mit <code>403</code> antwortet.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/07-refused.webp" alt="Terminalausgabe zweier Ablehnungen: HTTP 400 mit AADSTS501051, die Managed Identity sei keiner Rolle für die Resource API zugewiesen, und HTTP 403 Authorization_RequestDenied von Graph. IDs sind Platzhalter." width="1894" height="530" loading="lazy" decoding="async"><figcaption><strong>Zweimal abgelehnt.</strong> Die Ablehnung erfolgt, bevor die API aufgerufen wird, und nennt die Managed Identity, was sie bei einer Prüfung oder einem Vorfall leicht auffindbar macht. „Ein Token haben“ heißt nicht „Zugriff haben“.</figcaption></figure>
<p><strong>Eine enge Vergabe.</strong> Fügen Sie der Resource API eine reine App-only-Rolle <code>Data.Read.All</code> hinzu (erlaubter Mitgliedstyp: Anwendung) und weisen Sie sie der Managed Identity über Microsoft Graph zu. Das Admin Center kann einer Managed Identity keine App-Rolle zuweisen; das läuft über Graph, PowerShell oder die CLI.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/10-assign.webp" alt="Terminalausgabe zweier Graph-Aufrufe: Hinzufügen der App-Rolle Data.Read.All zur Resource API und Zuweisung an den Service Principal der Managed Identity. Objekt-IDs sind Platzhalter." width="1894" height="645" loading="lazy" decoding="async"><figcaption><strong>Die einzige Vergabe im Labor.</strong> Sie ist ein gewöhnliches Graph-Objekt, das ein Governance-Werkzeug oder ein Skript lesen kann.</figcaption></figure>
<p><strong>Das App-only-Token.</strong> Entra speichert Tokens von Managed Identities im Cache, der Container erhält also bis zu einen Tag lang weiter sein altes Token. Ein Neustart der Revision liefert ein frisches, das nun die Rolle enthält.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/13-token.webp" alt="Dekodierte Claims des App-only-Tokens nach einem Neustart der Revision: Die Audience ist die Resource API, Anwendung und Objekt-ID sind die Managed Identity, idtyp ist app, roles enthält Data.Read.All und es gibt keinen scope-Claim. Kennungen sind Platzhalter." width="1894" height="759" loading="lazy" decoding="async"><figcaption><strong>App-only-Token.</strong> Ein <code>roles</code>-Claim ohne <code>scp</code> ist, wie eine API einen App-only-Aufruf von einem delegierten unterscheidet. Es gibt keinen Nutzer; die eigenen Berechtigungen der Identität sind die einzige Grenze.</figcaption></figure>
<p><strong>Die API spielen.</strong> Das Token wandert vom Container in eine temporäre Datei mit Modus 0600 und wird am Ende vernichtet; es wird nie ausgegeben. Ein Validierungsskript prüft die RS256-Signatur gegen die Schlüssel des Mandanten, die Audience, den Aussteller und das Ablaufdatum und autorisiert dann jede Route anhand der Rolle.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/15-validate.webp" alt="Terminalausgabe der API-seitigen Prüfung: GET data liefert 200 für die Rolle Data.Read.All, POST data liefert 403 wegen der fehlenden Rolle Data.Write.All, und ein Token mit bearbeiteten Rollen liefert 401, weil die Signaturprüfung fehlschlägt." width="1894" height="339" loading="lazy" decoding="async"><figcaption><strong>Die API entscheidet trotzdem.</strong> Lesen ist erlaubt, Schreiben wird abgelehnt, und ein Token mit manipulierten Claims besteht die Signaturprüfung nicht.</figcaption></figure>
<h2>Stolperfallen</h2>
<ul>
<li><strong>Tokens werden etwa 24 Stunden gecacht.</strong> Die Rolle zu entfernen genügt für einen dringenden Widerruf nicht. Starten Sie den Workload neu oder stellen Sie ihn neu bereit, oder deaktivieren Sie die Identität.</li>
<li><strong><code>exec</code> hat ein Ratenlimit.</strong> Ohne <code>--replica</code> kann <code>az containerapp exec</code> ein gestopptes Replikat wählen, und Wiederholungen laufen in HTTP 429 mit zehn Minuten Wartezeit. Geben Sie das laufende Replikat an.</li>
<li><strong>„Assignment required“ ist ein Schalter, den man setzen muss.</strong> Ohne ihn sind „ein Token bekommen können“ und „autorisiert sein“ verschiedene Dinge, und jede API muss die Rollen selbst prüfen.</li>
<li><strong>Kostenlose Mandanten protokollieren weniger.</strong> Das Verzeichnis-Auditlog zeigt die Vergabe. Anmeldeprotokolle für Managed Identities brauchen Entra ID P1 oder P2 und sollten in Ihr SIEM exportiert werden.</li>
<li><strong>Löschen Sie die Rechenressource, wenn Sie fertig sind.</strong> Rechenleistung kostet Geld; Identität und Rolle tragen das Risiko und brauchen einen Verantwortlichen und ein Überprüfungsdatum wie jedes andere privilegierte Konto.</li>
</ul>
<h2>Sicherheitserkenntnisse</h2>
<ol>
<li>Ein Workload ohne Secret hat nichts, was abfließen kann. Bevorzugen Sie Managed Identities oder föderierte Anmeldeinformationen gegenüber Client Secrets.</li>
<li>Beginnen Sie ohne Rollen und fügen Sie eine Rolle im engsten Geltungsbereich hinzu. Benennen Sie App-only-Rollen <code>*.All</code>, damit Prüfer sehen, dass keine Nutzergrenze gilt.</li>
<li>Verlangen Sie die Zuweisung bei internen APIs, damit der Token-Dienst das erste Tor ist.</li>
<li>Validieren Sie Signatur, Audience, Aussteller und Rolle in der API. Entra entscheidet nur, wer ein Token bekommt.</li>
<li>Behandeln Sie Managed Identities mit App-Rollen wie privilegierte nicht-menschliche Konten: Verantwortlicher, Rezertifizierung, ein Alarm bei Rollenzuweisungen an Service Principals.</li>
</ol>
<h2>Was nicht ausgeführt wurde</h2>
<p>Das Labor hat weder einen Entra-Agent-ID-Blueprint noch eine Agentenidentität bereitgestellt, bei der ein Managed-Identity-Token die Anmeldeinformation des Blueprints wäre. Die Portal-Tour durch die entstandenen Objekte wurde aufgezeichnet, aber nicht veröffentlicht, weil Portalansichten Mandantenkennungen zeigen. Für dieses Labor wird keine Aufzeichnung veröffentlicht.</p>
<p><em>Die Terminalbilder wurden aus der gespeicherten Ausgabe des Laufs erzeugt; Kennungen, Geheimnisse und Zeitstempel sind durch Platzhalter ersetzt.</em></p>
]]></content:encoded>
    </item>
  </channel>
</rss>
