<?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/fr/</link>
    <description>Notes de praticien sur la gestion des identités et des accès, les agents IA et le DevOps : explications, labs et actualités, avec sources.</description>
    <language>fr</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/fr/</link>
    </image>
    <atom:link href="https://iamops.dev/fr/rss.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Imposer le downscoping dans le token exchange pour les appels entre agents</title>
      <link>https://iamops.dev/fr/enforce-downscoping-token-exchange-a2a/</link>
      <guid isPermaLink="true">https://iamops.dev/fr/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>Agents IA</category>
      <description>Lab Keycloak pour agents A2A : le jeton que B obtient pour C suit les scopes de B, pas ceux de A, sans downscoping imposé. Essai standard, contrôle, correctif.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/fr/enforce-downscoping-token-exchange-a2a.png?v=986e5733" alt="" /></p><p><strong>En bref</strong></p>
<ul>
<li>Quand l'agent B appelle l'agent C pour le compte de l'agent A, B échange le jeton de A contre un nouveau. Sur Keycloak 26.8.2, le scope de ce nouveau jeton suit les scopes de B, pas le jeton remis par A, tant qu'on n'impose pas le downscoping.</li>
<li>Dans mon essai, A avait c.read, B avait c.write comme scope optionnel à lui, et l'échange de B a renvoyé un jeton pour A avec c.write. L'agent C a accepté une écriture que A n'avait jamais accordée.</li>
<li>C'est B qui utilise un droit qu'il possède, pas B qui sort de son cadre. Sans c.write chez B, le même échange échoue avec invalid_scope. C'est une leçon de configuration, pas une vulnérabilité.</li>
<li>Une client policy avec l'executor downscope-assertion-grant-enforcer limite l'échange aux scopes de A. L'agent C devrait aussi exiger le claim act et vérifier le scope pour chaque skill.</li>
<li>Je n'ai testé que Keycloak. A2A 1.0.0 laisse l'autorisation à l'implémentation, et l'Agent Card n'a aucun champ pour le token exchange.</li>
</ul>
<p>A2A 1.0.0 est la version actuelle du protocole Agent2Agent. Elle exige qu'un serveur authentifie chaque requête et laisse l'autorisation à l'implémentation. Elle ne dit pas ce qui se passe quand l'agent B appelle l'agent C pour le compte de l'agent A. Cette partie, c'est de l'OAuth ordinaire, et l'outil habituel est le token exchange (<a href="https://www.rfc-editor.org/rfc/rfc8693">RFC 8693</a>). J'ai monté une petite chaîne sur un Keycloak local et posé une seule question : le jeton que B obtient pour C reste-t-il dans ce que A a remis ?</p>
<p>Non, sauf si on demande à Keycloak de l'imposer. Cet article porte sur ce réglage. Si vous avez lu mon <a href="https://iamops.dev/fr/keycloak-token-exchange-rfc-8693/">premier lab sur le token exchange avec Keycloak</a>, celui-ci reprend au piège « pas de claim act » et ajoute la délégation.</p>
<h2>Ce que montre ce lab</h2>
<p>Trois agents et un serveur d'autorisation, tous sur localhost.</p>
<ul>
<li><strong>A</strong> est l'appelant. Il détient un jeton avec le scope <code>agent-b c.read</code>. Un claim <code>may_act</code> dans ce jeton désigne B comme la partie autorisée à agir pour lui.</li>
<li><strong>B</strong> est un agent intermédiaire. Il reçoit l'appel de A, puis demande à Keycloak un jeton pour appeler C, avec le jeton de A comme <code>subject_token</code> et le sien comme <code>actor_token</code>.</li>
<li><strong>C</strong> est un petit agent de notes avec une skill de lecture et une d'écriture. Il n'accepte que des jetons délégués et vérifie le scope pour chaque skill.</li>
</ul>
<table>
<thead>
<tr>
<th>Client</th>
<th>Rôle</th>
<th>Scopes qu'il peut demander dans un échange</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>agent-a</code></td>
<td>Appelant, service account</td>
<td><code>agent-b</code> par défaut, <code>c.read</code> sur demande</td>
</tr>
<tr>
<td><code>agent-b</code></td>
<td>Agent intermédiaire, effectue l'échange</td>
<td><code>c.read</code> et <code>c.write</code>, tous deux optionnels</td>
</tr>
<tr>
<td><code>agent-c</code></td>
<td>Agent de notes, audience seulement</td>
<td>aucun</td>
</tr>
</tbody>
</table>
<figure class="b-fig"><img src="https://iamops.dev/media/enforce-downscoping-token-exchange-a2a/00-flow.webp" alt="Diagramme de séquence : l'agent A lit l'Agent Card de B, obtient un jeton de Keycloak, appelle B, et B l'échange contre un jeton délégué avec claim act avant d'appeler C." width="1800" height="766" loading="lazy" decoding="async"><figcaption><strong>La chaîne.</strong> Les étapes 1 à 4 sont l'appel de B par A. Les étapes 5 à 7 montrent B qui transforme le jeton de A en jeton délégué. Les étapes 8 à 10 sont l'appel de C.</figcaption></figure>
<p>Chaque agent publie une Agent Card à <code>/.well-known/agent-card.json</code> avec un schéma de sécurité <code>oauth2</code> et les scopes par skill. Le schéma peut dire <code>clientCredentials</code> et rien qui se rapproche du token exchange : un objet <code>OAuthFlows</code> contient exactement un flux, et il n'existe pas de flux d'échange. C'est pourquoi la card de C le dit dans le texte de sa description, et un appelant doit le lire.</p>
<h2>Mise en place</h2>
<p>Keycloak 26.8.2 depuis le zip, Java 21, mode développement. Le standard token exchange est actif par défaut dans la 26.8. La délégation, c'est-à-dire les claims <code>act</code> et <code>may_act</code>, ne l'est pas. Elle demande deux fonctions en préversion.</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 affiche au démarrage les fonctions en préversion activées. Je les ai activées ensemble et je ne les ai pas testées une par une. Sans elles, ma chaîne échoue : Keycloak refuse dans un échange simple tout subject token qui porte <code>may_act</code>, avec « 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="Sortie de terminal : Keycloak 26.8.2 démarre avec les fonctions en préversion parameterized-scopes et token-exchange-delegation activées, puis le script du realm signale realm a2a ready." width="1894" height="301" loading="lazy" decoding="async"><figcaption><strong>Fonctions et realm.</strong> Keycloak 26.8.2 avec deux fonctions en préversion actives, puis le script du realm.</figcaption></figure>
<p>Le script du realm crée les trois clients avec service accounts, les scopes <code>agent-b</code>, <code>c.read</code> et <code>c.write</code> (chacun avec un audience mapper) et un mapper <code>may_act</code> fixe sur <code>agent-a</code>. Il active aussi le Standard Token Exchange pour <code>agent-b</code> et donne à <code>agent-b</code> les scopes <code>c.read</code> et <code>c.write</code> comme client scopes optionnels. Retenez ce dernier point. Tout l'article tourne autour de lui.</p>
<h2>La chaîne d'appels fonctionne</h2>
<p>A lit la card de B, demande à Keycloak exactement les scopes que liste la skill et envoie <code>message:send</code>. B échange le jeton et appelle C. Le jeton délégué décodé garde A comme <code>sub</code>, restreint <code>aud</code> à C, ne porte que <code>c.read</code> et ajoute <code>act</code> pour B.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/enforce-downscoping-token-exchange-a2a/02-chain.webp" alt="Sortie de terminal : l'agent A lit l'Agent Card de B, demande les scopes agent-b et c.read et reçoit de B une réponse 200 qui résume deux notes conservées par C." width="1894" height="263" loading="lazy" decoding="async"><figcaption><strong>Le chemin légitime.</strong> A demande à B de résumer les notes. B échange le jeton de A et les lit chez C.</figcaption></figure>
<h2>L'échange que A n'avait pas accordé</h2>
<p>Maintenant B demande <code>c.write</code>. Le jeton de A n'a pas <code>c.write</code>. Voici la requête, avec des variables :</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 émet le jeton. <code>sub</code> est A, <code>act</code> désigne B, <code>scope</code> est <code>c.write</code>. C vérifie la signature, l'audience, le claim <code>act</code> et le scope qu'exige sa skill d'écriture, puis ajoute la note.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/enforce-downscoping-token-exchange-a2a/03-stock.webp" alt="Sortie de terminal sur Keycloak standard : l'agent B liste c.write parmi ses scopes optionnels, le jeton de A a le scope agent-b c.read, le jeton obtenu par B pour l'agent C a le scope c.write avec act agent-b, et C répond que la note a été ajoutée." width="1894" height="1218" loading="lazy" decoding="async"><figcaption><strong>Keycloak standard.</strong> Le jeton de A dit c.read. Le jeton pour C dit c.write. C ajoute la note. Les ids sont remplacés par des variables.</figcaption></figure>
<p>J'ai exécuté toute la séquence quatre fois sur un Keycloak 26.8.2 neuf, deux fois avec les scripts du lab et deux fois avec ceux de cet article, et j'ai obtenu le même résultat à chaque fois.</p>
<h2>Le contrôle : B possède c.write</h2>
<p>Avant d'appeler cela une escalade, j'ai vérifié à qui appartient le droit utilisé. Dans mon realm, B a <code>c.write</code> comme scope optionnel à lui. C'est moi qui l'y ai mis. B n'a donc pas obtenu quelque chose qu'il n'aurait jamais dû avoir. J'ai retiré <code>c.write</code> des scopes optionnels de B et répété le même échange.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/enforce-downscoping-token-exchange-a2a/04-control.webp" alt="Sortie de terminal de l'essai de contrôle : après la suppression de c.write des client scopes optionnels de l'agent B, le même échange est refusé avec invalid_scope, Invalid scopes: c.write." width="1894" height="225" loading="lazy" decoding="async"><figcaption><strong>Le contrôle.</strong> Sans c.write chez B, rien n'est émis. B reste dans ses propres droits.</figcaption></figure>
<p>Cela règle un point. B ne peut pas aller au-delà de ce qu'il possède, et il n'y a pas de bug au sens d'un contournement. Ce qui se perd est autre chose : le scope du nouveau jeton est borné par la réserve de scopes de B et non par le jeton de A. A avait dit « lecture », et un saut plus loin cela ne signifiait plus rien. La RFC 8693 laisse ce choix au serveur : <code>scope</code> est « the desired scope of the requested security token » et ses valeurs sont « service specific » (<a href="https://www.rfc-editor.org/rfc/rfc8693#section-2.1">section 2.1</a>). Rien n'impose que le résultat soit un sous-ensemble du subject token.</p>
<p>Pour les agents, cela compte parce que C journalise <code>sub</code> A et <code>act</code> B. Celui qui lit le journal voit « A a écrit une note ». A n'y a jamais consenti.</p>
<h2>Borner l'échange avec la politique de downscope</h2>
<p>Keycloak a pour cela un executor de client policy : <code>downscope-assertion-grant-enforcer</code>. Il limite les scopes du nouveau jeton à ceux déjà présents dans le subject token et répond <code>invalid_scope</code> sinon. Il ne demande aucune configuration. Je l'ai appliqué à tous les clients du realm avec une seule politique.</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>Avec <code>c.write</code> de nouveau chez B et la politique active, l'échange est refusé. L'échange légitime avec <code>c.read</code> fonctionne toujours.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/enforce-downscoping-token-exchange-a2a/05-enforcer.webp" alt="Sortie de terminal avec la politique de downscope active : l'échange avec c.write est refusé parce que c.write n'est pas dans le jeton d'accès initial, et l'échange avec c.read renvoie toujours un jeton délégué que C accepte." width="1894" height="836" loading="lazy" decoding="async"><figcaption><strong>Avec la politique.</strong> c.write est refusé parce que le jeton de A ne le porte pas. c.read fonctionne toujours. C liste aussi la note de l'essai standard.</figcaption></figure>
<p>La dernière ligne de cette sortie est la note ajoutée par l'essai standard. Elle reste jusqu'au redémarrage de C.</p>
<h2>Ce que C doit aussi vérifier</h2>
<p>La politique vit sur le serveur d'autorisation. C ne devrait pas dépendre uniquement d'elle.</p>
<ul>
<li>Exigez le claim <code>act</code> et comparez <code>act.client_id</code> aux agents que vous attendez. Mon C répond 403 sans lui.</li>
<li>Vérifiez le scope par skill. Mon C exige <code>c.read</code> pour lire et <code>c.write</code> pour écrire.</li>
<li>Vérifiez <code>aud</code>. Un jeton pour B est refusé par C avec un 401.</li>
<li>Ne traitez pas <code>may_act</code> comme une preuve. Quand B a présenté le jeton de C comme acteur, Keycloak a refusé avec un message sur l'audience. Je n'ai pas vérifié s'il compare l'acteur à <code>may_act</code>.</li>
</ul>
<h2>Pièges</h2>
<ul>
<li><strong>L'enforcer et un audience mapper au niveau du client.</strong> Dans ma première configuration, l'audience de C se trouvait dans un mapper sur le client B. Avec l'enforcer actif, chaque échange échouait avec « Requested audience not available: agent-c ». Déplacer le mapper sur les scopes <code>c.read</code> et <code>c.write</code> a réglé le problème. Je ne sais pas pourquoi. Testez dans votre propre realm.</li>
<li><strong>L'audience via les scopes a un effet de bord.</strong> <code>c.read</code> porte l'audience de C, donc le jeton de A a <code>aud</code> B et C. Ce qui empêche A de l'utiliser chez C, c'est l'exigence <code>act</code>, pas l'audience.</li>
<li><strong>L'erreur sur le mauvais acteur est vague.</strong> Le client voit <code>access_denied</code> et « Client is not within the token audience ». Le journal d'événements de Keycloak nomme l'acteur.</li>
<li><strong><code>may_act</code> est fixe dans mon realm.</strong> Dans un vrai système, il devrait venir d'une politique et vivre avec le jeton.</li>
</ul>
<h2>Ce que je n'ai pas exécuté</h2>
<p>Je n'ai exécuté que Keycloak 26.8.2. Je n'ai testé ni Entra on-behalf-of, ni Okta, ni Auth0, et je n'affirme donc rien sur la façon dont ils bornent le scope dans un échange. Un seul saut de délégation : pas de chaîne <code>act</code> imbriquée. Pas de tâches, de streaming ni d'Agent Cards signées, pas de TLS ni de jetons liés à l'émetteur. Pas d'utilisateur dans la chaîne : le sujet est le service account de l'agent A. Les agents sont mes propres programmes Flask et leurs client secrets sont des valeurs statiques de laboratoire.</p>
<p><em>Les images de terminal ont été redessinées à partir de la sortie enregistrée des essais, avec les ids remplacés par des variables. Rien ici n'est un identifiant réel.</em></p>
<p>Pour les standards qui sous-tendent tout cela, voir <a href="https://iamops.dev/fr/id-jag-explained/">ID-JAG expliqué</a> et <a href="https://iamops.dev/fr/mcp-server-no-token-passthrough/">pourquoi un serveur MCP ne doit pas relayer les jetons</a>.</p>
]]></content:encoded>
    </item>
    <item>
      <title>GitHub Actions vers Azure avec la workload identity federation : quels runs obtiennent un jeton, et pourquoi</title>
      <link>https://iamops.dev/fr/github-actions-azure-workload-identity-federation/</link>
      <guid isPermaLink="true">https://iamops.dev/fr/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>Identité de workload</category>
      <category>Azure</category>
      <description>Lab : un workflow GitHub se connecte à Azure sans secret. J'affiche le sub de six types de run et le credential qui fait passer chacun, PR comprises.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/fr/github-actions-azure-workload-identity-federation.png?v=986e5733" alt="" /></p><p><strong>En bref</strong></p>
<ul>
<li>Un workflow GitHub peut se connecter à Azure sans client secret. GitHub signe un jeton de courte durée, et un federated credential Entra fait confiance à un seul claim sub exact.</li>
<li>Les nouveaux dépôts envoient un sub immuable qui contient les ID du propriétaire et du dépôt. Créez d'abord le dépôt, lisez les ID, puis écrivez le credential.</li>
<li>Avec un seul credential pour main, 1 type de run sur 6 est passé. Un credential pour l'environment, un pour pull_request et deux expressions avec wildcard ont donné 6 sur 6.</li>
<li>pull_request et pull_request_target envoient le même sub : un credential pull_request fait donc aussi confiance aux jobs pull_request_target, qui tournent avec les secrets. N'y faites jamais de checkout de la head de la PR.</li>
<li>Je n'ai pas testé les pull requests depuis un fork. Selon la doc GitHub, elles n'ont pas de permissions d'écriture, donc j'attends aucun jeton, mais je ne l'ai pas vu.</li>
</ul>
<p>Un pipeline de déploiement qui contient un client secret, c'est un secret qui attend de fuiter. GitHub Actions peut se connecter à Azure sans : GitHub signe un jeton OIDC de courte durée pour le job, et Entra lui fait confiance via un federated credential. Deux choses ont changé cette année. Depuis le 15 juillet 2026, les nouveaux dépôts reçoivent un <a href="https://github.blog/changelog/2026-04-23-immutable-subject-claims-for-github-actions-oidc-tokens/">claim sub immuable</a> avec les ID du propriétaire et du dépôt, et les credentials avec wildcard d'Entra sont toujours en préversion. J'ai regroupé les deux dans un <a href="https://iamops.dev/fr/workload-identity-news-immutable-sub-entra-wildcards-workos/">article d'actualité</a>. Ce lab en est la partie pratique.</p>
<h2>Ce que montre ce lab</h2>
<p>Une app registration avec Reader sur un seul resource group vide, un dépôt privé, aucun secret nulle part. Le lab :</p>
<ol>
<li>Fait confiance à la branche main avec un credential exact et voit <code>azure/login</code> réussir.</li>
<li>Pousse une branche feature, ouvre une pull request et les voit refusées toutes deux avec AADSTS700213.</li>
<li>Autorise <code>release/*</code> avec une claims-matching expression.</li>
<li>Affiche le <code>sub</code> exact de six types de run, puis ajoute les credentials qui les font tous passer.</li>
<li>Examine les pull requests depuis un fork, d'après la doc seulement, car je n'ai pas pu les tester.</li>
</ol>
<h2>Mise en place</h2>
<p>Utilisez un tenant et un abonnement jetables, et un compte GitHub à vous. L'app registration reçoit Reader sur un seul resource group vide : un login réussi prouve alors la fédération et rien d'autre. Les trois ID dont le workflow a besoin (client, tenant, abonnement) ne sont pas des secrets et vont dans des variables du dépôt.</p>
<p>Créez le dépôt avant le credential. Un nouveau dépôt envoie <code>repo:&lt;owner&gt;@&lt;owner-id&gt;/&lt;repo&gt;@&lt;repo-id&gt;:...</code>, et vous ne connaissez les deux ID qu'une fois le dépôt créé. Un subject écrit à l'ancienne, <code>repo:&lt;owner&gt;/&lt;repo&gt;:ref:refs/heads/main</code>, ne correspond plus.</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>Le run</h2>
<p><strong>main se connecte.</strong> Le workflow affiche les claims présentés par GitHub, lance <code>azure/login</code> et liste les resource groups. Mon premier run a échoué après le login avec &quot;No subscriptions found&quot;, car le rôle Reader ne s'était pas encore propagé. Une minute d'attente a suffi.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/github-actions-azure-workload-identity-federation/01-main.webp" alt="Sortie de terminal : le federated credential gh-main avec un subject exact pour la branche main, puis un run sur main qui se termine avec succès, affiche le même claim sub, liste le resource group et montre la connexion en tant que service principal. Les ID sont des placeholders." width="1894" height="492" loading="lazy" decoding="async"><figcaption><strong>Le sub correspond caractère par caractère.</strong> Le credential est toute la relation de confiance. Aucun secret à créer, rien à faire tourner. Les ID sont des placeholders.</figcaption></figure>
<p><strong>Une branche feature et une pull request sont refusées.</strong> Même workflow, autre <code>sub</code>. Entra répond AADSTS700213 et le message donne le subject reçu : c'est le moyen le plus rapide de corriger un credential.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/github-actions-azure-workload-identity-federation/02-feature-refused.webp" alt="Sortie de terminal : un push sur feature-x et une pull request se terminent tous deux en échec avec AADSTS700213, aucun enregistrement d'identité fédérée correspondant. Les subjects présentés se terminent par ref:refs/heads/feature-x et pull_request. Les ID sont des placeholders." width="1894" height="454" loading="lazy" decoding="async"><figcaption><strong>Refusés, par conception.</strong> Une faute de frappe dans un nom de branche ou une pull request non relue n'obtient pas l'identité de déploiement. Les ID sont des placeholders.</figcaption></figure>
<p><em><em>release/</em> avec une expression.</em>* Un federated credential flexible contient une <code>claimsMatchingExpression</code> à la place d'un subject. Pour les app registrations, je l'ai créé avec <code>az rest</code> sur l'endpoint beta de Graph. J'ai suivi la doc Microsoft et fixé aussi <code>repository_id</code> :</p>
<pre><code class="language-text">claims['sub'] matches 'repo:&lt;github-user&gt;@&lt;owner-id&gt;/lab-b1-gh-wif@&lt;repo-id&gt;:ref:refs/heads/release/*' and claims['repository_id'] eq '&lt;repo-id&gt;'
</code></pre>
<figure class="b-fig"><img src="https://iamops.dev/media/github-actions-azure-workload-identity-federation/03-release-expression.webp" alt="Sortie de terminal : az rest crée le credential gh-release avec une claims-matching expression sur le sub pour les branches release et une vérification de repository_id, puis un push sur release/1 se termine avec succès et affiche son sub. Les ID sont des placeholders." width="1894" height="492" loading="lazy" decoding="async"><figcaption><strong>Un credential pour une famille de branches.</strong> Le motif garde les ID du propriétaire et du dépôt, et repository_id est vérifié à part. Les ID sont des placeholders.</figcaption></figure>
<h2>Vérification approfondie : le sub de chaque type de run</h2>
<p>Un lecteur m'a demandé si le refus d'une branche feature et d'une pull request était un bug. Ce n'en est pas un, et je voulais le montrer. Un petit script, <code>probe.sh</code>, demande un jeton à GitHub, décode le <code>sub</code>, présente le jeton à Entra et affiche une ligne de résultat. Le workflow le lance sur un push sur main, un push sur une branche feature, <code>pull_request</code>, <code>pull_request_target</code>, un push de tag et un second job qui utilise un environment. J'ai utilisé une nouvelle app et le même dépôt privé.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/github-actions-azure-workload-identity-federation/04-subs-before.webp" alt="Sortie de terminal : un tableau de six runs avec le seul credential pour main. main passe. Les runs branche feature, pull request, pull_request_target, tag et environment échouent avec AADSTS700213. Chaque ligne montre le sub après le préfixe du dépôt." width="1894" height="416" loading="lazy" decoding="async"><figcaption><strong>1 sur 6 passe.</strong> La partie après les ID change pour chaque type de run, et un credential pour main ne correspond qu'à main.</figcaption></figure>
<p>J'ai ensuite ajouté quatre credentials : un exact pour l'environment, un exact pour <code>pull_request</code> et deux expressions pour les branches <code>feature-*</code> et les tags <code>v*</code>. J'ai relancé les mêmes runs.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/github-actions-azure-workload-identity-federation/05-subs-after.webp" alt="Sortie de terminal : les quatre credentials ajoutés avec leur nom et leur motif, puis le même tableau de six runs où chaque ligne passe. Le placeholder prefix remplace la partie du sub avec le dépôt et les ID du propriétaire et du dépôt." width="1894" height="568" loading="lazy" decoding="async"><figcaption><strong>6 sur 6 passent.</strong> &lt;prefix&gt; remplace repo:&lt;owner&gt;@&lt;id&gt;/&lt;repo&gt;@&lt;id&gt;. Un credential contient soit un subject exact, soit une expression, jamais les deux.</figcaption></figure>
<table>
<thead>
<tr>
<th>Run</th>
<th><code>sub</code> après le préfixe du dépôt</th>
<th>Credential qui le fait passer</th>
<th>Main seul</th>
<th>Après</th>
</tr>
</thead>
<tbody>
<tr>
<td>Push sur main</td>
<td><code>ref:refs/heads/main</code></td>
<td>Subject exact</td>
<td>Passe</td>
<td>Passe</td>
</tr>
<tr>
<td>Push sur 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>Passe</td>
</tr>
<tr>
<td><code>pull_request</code></td>
<td><code>pull_request</code></td>
<td>Subject exact</td>
<td>AADSTS700213</td>
<td>Passe</td>
</tr>
<tr>
<td><code>pull_request_target</code></td>
<td><code>pull_request</code></td>
<td>Le même credential <code>pull_request</code></td>
<td>AADSTS700213</td>
<td>Passe</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>Passe</td>
</tr>
<tr>
<td>Job avec environment lab-b1-prod</td>
<td><code>environment:lab-b1-prod</code></td>
<td>Subject exact</td>
<td>AADSTS700213</td>
<td>Passe</td>
</tr>
</tbody>
</table>
<p><strong>Un écart avec la doc Microsoft.</strong> Les expressions <code>feature-*</code> et <code>v*</code> n'avaient qu'une condition sur <code>sub</code>, sans <code>repository_id</code>. Entra a accepté les deux et les runs sont passés. Mes motifs contenaient déjà les ID du propriétaire et du dépôt, ils étaient donc verrouillés malgré tout. Lors d'un contrôle plus tard le même jour, Entra a aussi accepté une expression couvrant tous les dépôts du propriétaire, sans clause <code>repository_id</code> ni <code>repository_owner_id</code>, et cet identifiant a délivré un jeton à un autre dépôt du même propriétaire. Les pages Microsoft disent qu'une expression pour GitHub doit vérifier <code>sub</code> et <code>repository_id</code> ou <code>repository_owner_id</code>. Je recommande quand même d'ajouter <code>repository_id</code> à chaque expression. La règle est documentée et la fonction est en préversion : un credential sur le seul sub pourrait être refusé ou cesser de correspondre plus tard. Et la vérification de l'ID ne dépend pas d'un motif bien écrit : un wildcard à l'échelle du propriétaire a déjà délivré un jeton à un autre de mes dépôts, et le <code>sub</code> sans ID d'un dépôt plus ancien peut correspondre à un nom qui n'est plus le vôtre.</p>
<h2>pull_request et pull_request_target partagent un même subject</h2>
<p>Les deux événements envoient un <code>sub</code> qui se termine par <code>pull_request</code>, quelle que soit la branche. Un credential <code>pull_request</code> dans Entra fait donc aussi confiance aux jobs <code>pull_request_target</code>. Ceux-ci tournent depuis la branche de base, avec les secrets et avec un jeton OIDC. Si un tel workflow fait un checkout de la head de la pull request, l'auteur de la pull request exécute du code avec votre identité cloud. Mon workflow de test utilisait le checkout par défaut, qui prend la branche de base. Ne changez pas cela dans un workflow qui peut obtenir un jeton.</p>
<p>Un job qui utilise un environment est l'autre surprise. Il envoie <code>environment:&lt;name&gt;</code> à la place de la branche. Déplacer un job de déploiement dans un environment casse un credential écrit pour main.</p>
<h2>Pull requests depuis un fork : d'après la doc, non testé</h2>
<p>Je n'ai pas testé de pull request depuis un fork. Il faut un second compte GitHub, et je n'en utilise pas un qui ne soit pas à moi. Ce qui suit, c'est la doc GitHub et ma lecture.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/github-actions-azure-workload-identity-federation/06-forks-docs.webp" alt="Sortie de terminal avec trois phrases citées de la doc GitHub : les secrets ne sont pas transmis aux workflows déclenchés depuis un fork, le GITHUB_TOKEN est en lecture seule dans les pull requests depuis un fork, et les permissions d'écriture passent en lecture pour les événements de pull request autres que pull_request_target depuis un fork." width="1894" height="416" loading="lazy" decoding="async"><figcaption><strong>La doc seulement, pas un test.</strong> Les lignes sont affichées directement depuis les pages GitHub pour que vous puissiez vérifier le texte.</figcaption></figure>
<p><code>id-token: write</code> est une permission d'écriture. Pour une <code>pull_request</code> depuis un fork, elle passe en lecture, donc d'après moi le job ne reçoit aucun jeton OIDC. <code>probe.sh</code> gère ce cas et afficherait &quot;no OIDC token was offered&quot;. Je ne l'ai pas vu se produire. <code>pull_request_target</code> est l'exception dans cette doc, et c'est le piège décrit plus haut.</p>
<h2>Pièges</h2>
<ul>
<li><strong>Lisez le <code>sub</code> dans un vrai run avant d'écrire un credential.</strong> La ligne du log et le message AADSTS700213 le montrent tous les deux.</li>
<li><strong>Attendez après l'attribution du rôle.</strong> Sans attente, le login a marché et la commande suivante a échoué avec &quot;No subscriptions found&quot;.</li>
<li><strong>Les expressions sont en préversion et sur Graph beta.</strong> Pour les app registrations, j'ai utilisé <code>az rest</code>. La page de concept Microsoft dit que la CLI ne les prend pas encore en charge explicitement, alors que <code>az identity federated-credential</code> (identités managées attribuées par l'utilisateur) liste des paramètres en préversion pour cela.</li>
<li><strong>Les anciens dépôts gardent le <code>sub</code> sans ID</strong> jusqu'à ce que quelqu'un active le nouveau format. Écrivez le credential pour le format que le dépôt envoie vraiment.</li>
</ul>
<h2>Ce qu'il faut retenir pour la sécurité</h2>
<ol>
<li>En CI, utilisez la fédération au lieu d'un client secret. Rien à stocker, à laisser fuiter ou à faire tourner.</li>
<li>Prenez le credential le plus étroit qui convient : exact pour main et pour un environment, une expression seulement pour une vraie famille de refs.</li>
<li>Gardez les ID du propriétaire et du dépôt dans chaque subject et chaque motif, et ajoutez <code>repository_id</code> à chaque expression.</li>
<li>Considérez qu'un credential <code>pull_request</code> fait aussi confiance à <code>pull_request_target</code>. Ne faites jamais de checkout de code non fiable dans un workflow qui peut obtenir un jeton.</li>
<li>Supprimez les credentials dont le dépôt n'existe plus. Avec l'ancien format sans ID, quelqu'un d'autre peut reprendre le nom.</li>
</ol>
<h2>Nettoyage</h2>
<p>J'ai supprimé l'app registration, ce qui retire ses credentials, supprimé le resource group, vérifié que les deux avaient disparu et archivé le dépôt privé. Après la vérification approfondie, j'ai aussi retiré l'app supplémentaire, la branche, le tag, la pull request, l'environment et les variables.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/github-actions-azure-workload-identity-federation/07-cleanup.webp" alt="Sortie de terminal : l'app registration et le resource group sont supprimés, az group exists affiche false, le nombre d'apps est 0 et le dépôt est archivé." width="1894" height="377" loading="lazy" decoding="async"><figcaption><strong>Plus rien ne tourne.</strong> Aucun secret n'a jamais été créé, il n'y a donc rien à révoquer.</figcaption></figure>
<h2>Ce qui n'a pas été exécuté</h2>
<ul>
<li>Une pull request depuis un fork. Cette partie repose sur la doc GitHub.</li>
<li>Un dépôt existant passé au format immuable, et l'endpoint de préversion de GitHub pour le préfixe du subject.</li>
<li>Un rôle qui peut déployer. L'app n'avait que Reader sur un resource group vide.</li>
<li>Une expression avec <code>repository_owner_id</code> ou <code>job_workflow_ref</code>.</li>
<li>D'autres clouds. GitHub documente AWS, Google Cloud et Vault, je n'ai testé qu'Azure.</li>
</ul>
<p><em>Exécuté le 20 novembre 2026 avec l'Azure CLI, la GitHub CLI et <code>azure/login@v2</code> sur un runner hébergé par GitHub, dans un tenant jetable et un dépôt privé. Les images de terminal ont été redessinées à partir de la sortie enregistrée, avec les utilisateurs, les ID et les horodatages remplacés par des placeholders.</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>Notes sur IETF 127 : ID-JAG, grants de workload et transaction tokens pour la délégation aux agents</title>
      <link>https://iamops.dev/fr/ietf-127-id-jag-workload-grants-transaction-tokens/</link>
      <guid isPermaLink="true">https://iamops.dev/fr/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>Actualités</category>
      <category>IETF 127</category>
      <category>ID-JAG</category>
      <category>Identité de workload</category>
      <category>Transaction Tokens</category>
      <category>Agents d'IA</category>
      <category>Normes</category>
      <description>Ma lecture des sessions OAuth et WIMSE d'IETF 127 : ID-JAG, Workload Authorization Grant, transaction tokens et acteurs, avec les révisions des drafts.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/fr/ietf-127-id-jag-workload-grants-transaction-tokens.png?v=986e5733" alt="" /></p><p><strong>En bref</strong></p>
<ul>
<li>À IETF 127, la délégation aux agents a été traitée en trois cas : un utilisateur (ID-JAG), un workload qui agit pour lui-même (Workload Authorization Grant, WAG) et une transaction en cours (un grant de transaction token).</li>
<li>ID-JAG en est au draft -06 et reste un document du groupe de travail OAuth. Le provisioning just-in-time et le key binding partent dans des drafts séparés, et les passerelles au milieu restent le problème ouvert.</li>
<li>WAG, le profil des transaction tokens, les Transactional Access Tokens, l'Actor Profile et les trois drafts de délégation les plus récents sont des drafts individuels. Rien n'y est adopté ni final.</li>
<li>Pour vos propres conceptions : classer chaque flux d'agent selon le principal, ne jamais transmettre le jeton entrant au saut suivant et noter la révision du draft dans tout design qui en dépend.</li>
</ul>
<p>IETF 127 s'est tenue cette semaine à San Francisco. Je n'y étais pas. J'ai lu les slides, les notes prises par des bénévoles et les drafts actuels des sessions OAuth et WIMSE, et le 20 novembre 2026 j'ai vérifié le nom et la révision de chaque draft sur datatracker.ietf.org.</p>
<p>La session OAuth a eu lieu le mercredi 18 novembre. WIMSE s'est réuni le soir même (22:00 UTC), et la session commune OAuth et WIMSE a suivi le jeudi 19 novembre. OAuth a encore une session aujourd'hui, qui n'a pas eu lieu au moment où j'écris. Je cite les notes comme des notes. Ce ne sont pas des décisions.</p>
<h2>Trois grants pour trois sortes de principals</h2>
<p>Dans la session commune, Justin Richer a proposé une taxonomie simple, consignée dans les <a href="https://notes.ietf.org/notes-ietf-127-wimse">notes WIMSE</a> : ID-JAG concerne une personne, WAG un workload et « TAG » une transaction en cours. « TAG » est un surnom né de la discussion. Ce n'est ni un draft ni un nom enregistré.</p>
<table>
<thead>
<tr>
<th>Cas</th>
<th>Draft que j'ai vérifié</th>
<th>Statut</th>
</tr>
</thead>
<tbody>
<tr>
<td>Un utilisateur</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>Document du groupe de travail OAuth, publié le 31 oct. 2026</td>
</tr>
<tr>
<td>Un workload qui agit pour lui-même</td>
<td><a href="https://datatracker.ietf.org/doc/draft-carleton-workload-authz-grant/">draft-carleton-workload-authz-grant-02</a> (WAG)</td>
<td>Draft individuel, « Informational », publié le 2 nov. 2026</td>
</tr>
<tr>
<td>Une transaction en cours</td>
<td><a href="https://datatracker.ietf.org/doc/draft-fletcher-oauth-txn-token-chaining-profile/">draft-fletcher-oauth-txn-token-chaining-profile-01</a></td>
<td>Draft individuel, publié le 26 oct. 2026</td>
</tr>
</tbody>
</table>
<p>ID-JAG et le profil des transaction tokens sont tous deux des profils de l'<a href="https://datatracker.ietf.org/doc/draft-ietf-oauth-identity-chaining/">identity chaining</a>. Ce draft en est à -17 et le datatracker l'affiche dans la file de l'RFC Editor, avec le statut « blocked: Final Approval Pending ». Les notes WIMSE l'appellent « RFC 10092 (to be) ». Le datatracker n'affiche pas encore de numéro de RFC, je n'en citerais donc pas.</p>
<figure class="b-fig"><img src="https://iamops.dev/img/ietf-127-id-jag-workload-grants-transaction-tokens.fr.svg" alt="Trois colonnes, une par type de principal. Un utilisateur correspond à ID-JAG, document du groupe de travail OAuth. Un workload correspond à WAG, draft individuel. Une transaction correspond au profil de chaînage des txn-tokens, draft individuel. Les trois mènent à un serveur d'autorisation qui émet un jeton dont l'audience est l'API suivante." width="1200" height="630" loading="lazy" decoding="async"><figcaption><strong>Trois principals, trois grants.</strong> C'est mon propre résumé de la répartition, pas une figure des slides. État au 20 novembre 2026.</figcaption></figure>
<h2>ID-JAG au draft -06</h2>
<p>Les slides d'ID-JAG listent les changements de -05 et -06. Voici ceux que je lirais en premier :</p>
<ul>
<li>Un ID-JAG lié à une clé peut remplacer l'authentification du client auprès du serveur d'autorisation de la ressource.</li>
<li>Le token exchange est limité à une seule audience. Une audience inconnue reçoit <code>invalid_target</code>.</li>
<li>Le binding mTLS a été ajouté, et un ID-JAG lié par <a href="https://iamops.dev/fr/tools/dpop/">DPoP</a> exige le type de grant <code>jwt-dpop</code>.</li>
<li>Une nouvelle section Subject Identifier Mapping, des contrôles de tenant et une valeur de métadonnées <code>id_jag_signing_alg_values_supported</code>.</li>
<li>Une section Privacy Considerations.</li>
</ul>
<p>Les <a href="https://datatracker.ietf.org/meeting/127/materials/slides-127-oauth-sessa-identity-assertion-jwt-authorization-grant-00">slides</a> indiquent aussi qui l'implémente. La liste comprend Okta, Ping, Auth0, Descope, Keycloak, WorkOS et Oracle OCI IAM. Pour les bases, j'ai écrit <a href="https://iamops.dev/fr/id-jag-explained/">ID-JAG explained</a>.</p>
<p>Trois thèmes sont sortis de l'expérience d'implémentation, et chacun a atterri ailleurs que dans le draft principal :</p>
<ul>
<li><strong>Provisioning just-in-time</strong> (issues #83 et #121). La recommandation est une extension future. Une appli peut désormais rencontrer un utilisateur pour la première fois via un ID-JAG, et les claims personnalisés sont permis mais pas forcément interopérables.</li>
<li><strong>Key binding</strong> (issue #103). Les slides citent les pièces manquantes dans <a href="https://datatracker.ietf.org/doc/draft-mcguinness-oauth-token-exchange-cnf/">draft-mcguinness-oauth-token-exchange-cnf</a> et <a href="https://datatracker.ietf.org/doc/draft-parecki-oauth-jwt-dpop-grant/">draft-parecki-oauth-jwt-dpop-grant</a>, et demandent s'il faut sortir le key binding dans sa propre extension. Dans les notes, Hannes a dit que renvoyer vers d'autres documents donne l'impression d'un draft inachevé. Aaron Parecki a répondu que le provisioning est optionnel et que le binding s'applique plus largement qu'ID-JAG.</li>
<li><strong>Passerelles et proxys</strong> (issue #114). Une passerelle au milieu effectue le token exchange, mais l'audience de l'ID token est le client qui a appelé la passerelle, et le contrôle d'audience échoue. Les slides suggèrent de déclarer hors périmètre les topologies avec intermédiaire et pointent <a href="https://datatracker.ietf.org/doc/draft-mcguinness-oauth-id-continuation-assertion/">draft-mcguinness-oauth-id-continuation-assertion</a> comme extension.</li>
</ul>
<p>Les auteurs ont demandé des réunions intermédiaires sur les passerelles et le key binding. Les prochaines étapes sur les slides : trier les issues restantes entre -07 et un report explicite, puis demander le working group last call.</p>
<p>Mon avis : le grant de base me semble assez stable pour construire dessus. Je ne bâtirais pas encore une architecture avec une passerelle au milieu, car c'est justement le cas que les auteurs ont mis de côté.</p>
<h2>WAG : la version pour les workloads</h2>
<p>Le draft WAG décrit une plateforme dont le fournisseur d'identité de workload signe un grant JWT selon la <a href="https://www.rfc-editor.org/rfc/rfc7523">RFC 7523</a> qui nomme un seul workload. Le serveur d'autorisation d'un tiers est configuré une fois pour faire confiance à ce fournisseur et ne rejette pas un workload au seul motif qu'il ne l'a jamais vu. Le draft indique qu'un agent d'IA est le cas qui l'a motivé et que l'accès pour le compte d'un utilisateur est hors périmètre.</p>
<p>Il dit aussi clairement qu'il s'agit d'un draft individuel précoce et exploratoire, pas d'un document du groupe de travail. Pendant la session WIMSE, Aaron Parecki a dit qu'ID-JAG concerne fondamentalement un utilisateur, et que sans utilisateur le cas ressemble à WAG. Jeff Lombardo s'est dit très favorable à l'adoption. Karl McGuinness a plaidé pour séparer les types de principal plutôt que de faire déduire le type par le récepteur à partir des claims. Les notes ne consignent aucune objection à l'idée. Elles ne consignent pas non plus d'appel à l'adoption.</p>
<p>L'identité du client a aussi été abordée. L'exposé de Justin Richer <a href="https://datatracker.ietf.org/meeting/127/materials/slides-127-wimse-sessb-the-future-of-client-id-00">The Future of Client ID</a> énumérait les options : enregistrement dynamique, une URL de métadonnées (CIMD), un client ID sous forme de JWT et un SPIFFE ID. Le draft <a href="https://datatracker.ietf.org/doc/draft-ietf-oauth-spiffe-client-auth/">SPIFFE client authentication</a> en est à -03 (2 novembre) et ne couvre que le token endpoint.</p>
<p>Deux autres points WIMSE comptent si vous construisez dessus :</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>) a déplacé la preuve dans l'en-tête <code>Authorization</code>. Une requête n'a qu'un seul en-tête de ce type, un WPT ne peut donc pas voyager avec un jeton d'accès OAuth. Flemming Andreasen a jugé le changement incohérent avec l'architecture, et Jonathan Rosenberg a fait remarquer qu'un agent qui agit pour un utilisateur a besoin à la fois d'un jeton d'accès et de l'authentification de l'agent. Le chair a renvoyé la question à la liste de diffusion.</li>
<li><strong>WIMSE Architecture</strong> (<a href="https://datatracker.ietf.org/doc/draft-ietf-wimse-arch/">-09</a>) est parue le 17 novembre (UTC). Les auteurs la jugent prête, et les chairs prévoient un working group last call dans les prochaines semaines.</li>
</ul>
<p>Dans la même session, Brian Campbell a présenté le draft <a href="https://datatracker.ietf.org/doc/draft-ietf-wimse-aims/">AI Identity Management System</a>, avec la formule « OAuth in the front, WIMSE in the back ». Selon les notes, il ne définit aucun nouveau comportement de protocole.</p>
<h2>Les transaction tokens au-delà d'une frontière</h2>
<p>Les Transaction Tokens restent dans un seul domaine de confiance. Le <a href="https://datatracker.ietf.org/doc/draft-fletcher-oauth-txn-token-chaining-profile/">profil de George Fletcher</a> décrit comment un workload échange son Txn-Token auprès de son propre serveur d'autorisation contre un Txn-Token-JAG (<code>typ</code> valant <code>txn-chain+jwt</code>) et le présente au serveur d'un partenaire. D'après les <a href="https://datatracker.ietf.org/meeting/127/materials/slides-127-wimse-ietf-127-txn-token-chaining-profile-00">slides</a>, le grant vit 300 secondes au plus, 60 de préférence, le <code>jti</code> est à usage unique et la chaîne d'appels interne ne franchit jamais la frontière. Les questions ouvertes : faut-il passer le sender constraining de SHOULD à MUST, et comment mapper le subject.</p>
<p>La discussion était la partie intéressante :</p>
<ul>
<li>Max Gerber a demandé pourquoi il faudrait un nouveau type de JAG alors qu'ID-JAG et WAG existent. Justin Richer et Pieter Kasselman ont répondu que l'artefact d'entrée est différent et que le JAG porterait un sous-ensemble réduit de ses claims.</li>
<li>Mark Atwood a dit que retirer les identifiants internes avant qu'un jeton franchisse une frontière devrait être un MUST. Antoine Fressancourt a répondu que les identifiants doivent rester reconstituables pour l'audit.</li>
<li>Arndt Schwenkschuster craignait que les transaction tokens deviennent « the new bearer AT », volable et échangeable. George Fletcher a répondu qu'ils sont orthogonaux à l'authentification du client.</li>
<li>Justin Richer : « Semantically, the transaction token shouldn't contain authorization to do work, it should shape work being done. »</li>
</ul>
<p>Les notes se terminent sur un large accord : ce travail comble une vraie lacune. Une remarque pratique : les notes lient un ancien nom, <code>draft-fletcher-transaction-token-chaining-profile</code>. Le datatracker l'affiche comme remplacé par le nom <code>oauth-txn</code> lié plus haut, qui est aussi celui des slides.</p>
<p>Les <a href="https://datatracker.ietf.org/doc/draft-tulshi-oauth-transactional-access-tokens/">Transactional Access Tokens</a> (-01, daté du 18 novembre) prennent une autre voie. Un Txn-AT est un jeton d'accès JWT conforme à la <a href="https://www.rfc-editor.org/rfc/rfc9068">RFC 9068</a>, avec identifiant et contexte de transaction, pour un seul serveur de ressources, demandé via les Rich Authorization Requests. Selon le draft, la durée ne devrait pas dépasser 300 secondes (SHOULD NOT). Il peut être émis par token exchange, refresh et client credentials, pas directement par l'authorization code. Pendant la session, un participant nommé George a dit qu'il n'y a pas besoin de le standardiser, et l'auteur a répondu qu'une voie standard est souhaitable. Justin Richer a renvoyé la discussion à la liste de diffusion.</p>
<h2>Qui est l'acteur</h2>
<p>L'<a href="https://datatracker.ietf.org/doc/draft-mcguinness-oauth-actor-profile/">OAuth Actor Profile for Delegation</a> (-01, 9 octobre) profile le claim <code>act</code> du token exchange, demande des identifiants d'acteur à portée limitée à l'émetteur et classe les acteurs avec <code>sub_profile</code>. Le résumé de Karl McGuinness dans les notes : rendre la délégation explicite, et le client ID reste le client. Deux personnes se sont exprimées pour l'adoption. Un autre participant a dit que ce n'est pas un travail court, et Justin Richer a trouvé raisonnable de chercher des clarifications avant l'adoption. Les notes consignent que les chairs ont demandé le sentiment de la salle, mais pas ce que la salle a répondu.</p>
<p>Un nouveau draft individuel va un cran plus loin. <a href="https://datatracker.ietf.org/doc/draft-nandakumar-oauth-actor-bound-token-exchange/">Token Exchange with Actor-Bound Tokens</a> (-00, 16 novembre) permet à un orchestrateur de demander un jeton lié à la clé de l'agent qui fera le travail. L'acteur prouve qu'il possède cette clé, le jeton ne fonctionne donc que pour cet agent. C'est un draft individuel.</p>
<h2>Trois autres drafts de cette semaine</h2>
<p>Tous trois sont des drafts individuels -00, sans statut de groupe de travail.</p>
<ul>
<li><a href="https://datatracker.ietf.org/doc/draft-nandakumar-oauth-delegation-revocation/">Security Events for Revocation of Agent Delegations</a> (19 nov.). Un Security Event Token qui révoque une délégation et tout ce qui en découle, avec des règles pour que les agents le propagent le long de la chaîne, y compris via un flux Shared Signals. Les Token Status Lists restent le mécanisme d'état par jeton.</li>
<li><a href="https://datatracker.ietf.org/doc/draft-sweeney-oauth-brokered-authorization/">OAuth Brokered Authorization</a> (20 nov.). Un broker durable est le client OAuth de la ressource en amont. Chaque instance de courte durée reçoit un jeton contraint à l'émetteur (DPoP ou mTLS) pour le broker via client credentials, avec un type <code>authorization_details</code> valant <code>brokered_access</code>. Une instance ne détient jamais de 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.). Seul un client qui représente l'audience du jeton peut l'échanger ou l'introspecter. Le lien peut venir de la politique locale, d'un <code>private_key_jwt</code> vérifié avec le <code>jwks_uri</code> de la ressource, ou d'un nouveau paramètre <code>resource_clients</code> dans les métadonnées RFC 9728. L'agenda de vendredi liste un draft antérieur du même auteur, <code>draft-zehavi-oauth-audience-bound-token-exchange-00</code>. Je n'ai pas vérifié comment les deux se rapportent.</li>
</ul>
<h2>Ce que j'en ferais</h2>
<p>C'est mon avis, pas celui de la norme.</p>
<ul>
<li>Classer d'abord chaque flux d'agent selon son principal : un utilisateur, un workload ou une transaction. Les drafts se séparent exactement sur cette ligne, votre conception s'y rattachera plus facilement.</li>
<li>Ne pas transmettre le jeton entrant au saut suivant. L'échanger contre un jeton dont l'audience est l'API suivante. J'en ai parlé dans <a href="https://iamops.dev/fr/mcp-server-no-token-passthrough/">MCP server, no token passthrough</a> et <a href="https://iamops.dev/fr/entra-on-behalf-of-agent-middle-tier/">Entra on-behalf-of for an agent middle tier</a>.</li>
<li>Considérer le cas de la passerelle comme non résolu tant que les réunions intermédiaires sur l'issue #114 n'ont pas rendu leurs conclusions.</li>
<li>Écrire le nom et la révision du draft dans le document de conception. Plusieurs de ces drafts ont changé de nom ou de numéro en quelques semaines.</li>
</ul>
<h2>Ce que je n'ai pas vérifié</h2>
<p>Je n'ai assisté à aucune session et je n'ai pas regardé les enregistrements en entier. J'ai lié les enregistrements de la <a href="https://www.youtube.com/watch?v=V0tRi789ngE">session OAuth</a> et de la <a href="https://www.youtube.com/watch?v=g-EubYQF1xk">session WIMSE 1</a>. Je n'ai pas encore trouvé d'enregistrement de la session commune, tout ce qui la concerne vient donc des notes. Je n'ai exécuté ni implémenté aucun de ces drafts. Les notes sont écrites par des bénévoles et peuvent contenir des erreurs. La session OAuth de vendredi, qui inclut plusieurs des drafts ci-dessus, n'a pas encore eu lieu. Je mettrai cet article à jour si quelque chose d'important change.</p>
]]></content:encoded>
    </item>
    <item>
      <title>Workload identity : sub immuable de GitHub, identifiants Entra avec wildcard et agent auth de WorkOS</title>
      <link>https://iamops.dev/fr/workload-identity-news-immutable-sub-entra-wildcards-workos/</link>
      <guid isPermaLink="true">https://iamops.dev/fr/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>Actualités</category>
      <category>GitHub Actions</category>
      <category>OIDC</category>
      <category>Entra ID</category>
      <category>Identité de workload</category>
      <category>WorkOS</category>
      <category>Agents d'IA</category>
      <description>Le sub OIDC de GitHub contient les ID du propriétaire et du dépôt, les identifiants Entra avec wildcard restent en preview, WorkOS lance l'agent auth.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/fr/workload-identity-news-immutable-sub-entra-wildcards-workos.png?v=986e5733" alt="" /></p><p><strong>En bref</strong></p>
<ul>
<li>Depuis le 15 juillet 2026, les jetons GitHub Actions des nouveaux dépôts portent l'ID du propriétaire et l'ID du dépôt dans le claim sub. Les dépôts plus anciens gardent le format à noms seuls tant que vous ne l'activez pas : l'identifiant doit correspondre au format réellement émis.</li>
<li>Les wildcards Entra restent en preview. Microsoft exige aussi repository_id ou repository_owner_id. Dans mon lab, Entra a accepté une expression sur le seul sub, et une pour tout le propriétaire a délivré un jeton à un autre dépôt du même propriétaire. J'ajoute quand même repository_id.</li>
<li>WorkOS a publié l'identité d'agent (Agent Auth, accès anticipé, 2 sept.), Claude auto-connect pour MCP Auth (accès anticipé, 3 nov.) et le token exchange RFC 8693 pour Connect (10 nov.). Je n'ai rien trouvé chez WorkOS sur la fédération de workloads d'un autre émetteur.</li>
<li>Ce que je ferais : faire confiance au sub immuable, ajouter repository_id à chaque wildcard, supprimer les identifiants des dépôts qui n'existent plus et le prouver par des exécutions réelles. Mon lab le fait pour GitHub Actions vers Azure.</li>
</ul>
<p>J'ai lu les pages primaires de ces nouveautés le 20 novembre 2026 : changelog et documentation de GitHub, Microsoft Learn et changelog de WorkOS. Les dates ci-dessous sont celles que ces pages affichent. Les deux premières nouveautés comptent pour mon <a href="https://iamops.dev/fr/github-actions-azure-workload-identity-federation/">lab GitHub Actions vers Azure</a>, c'est pourquoi je les réunis.</p>
<h2>GitHub met les ID du propriétaire et du dépôt dans le claim sub</h2>
<p>Le 23 avril 2026, GitHub a annoncé les <a href="https://github.blog/changelog/2026-04-23-immutable-subject-claims-for-github-actions-oidc-tokens/">claims subject immuables pour les jetons OIDC d'Actions</a>. Le billet a été modifié le 10 juin 2026 : le séparateur entre un nom et son ID est désormais <code>@</code>, et non plus <code>-</code>. Si vous avez copié un exemple du texte d'avril, vérifiez-le.</p>
<p>Les règles, d'après la <a href="https://docs.github.com/en/actions/reference/security/oidc">référence OIDC</a> :</p>
<ul>
<li>Les dépôts créés après le 15 juillet 2026 reçoivent le nouveau <code>sub</code> par défaut. Les renommages et transferts après cette date passent aussi au nouveau format.</li>
<li>Les dépôts plus anciens gardent le format à noms seuls tant que vous ne l'activez pas. Vous pouvez le faire par organisation ou par dépôt, dans les paramètres OIDC ou avec l'API REST (<code>use_immutable_subject</code>).</li>
<li>GitHub Enterprise Server n'est pas concerné.</li>
<li>Un modèle de claims personnalisé ne peut pas retirer les ID. Avec <code>include_claim_keys</code>, <code>owner_id</code> et <code>repo_id</code> restent dans le segment <code>repo</code>.</li>
</ul>
<table>
<thead>
<tr>
<th>Format</th>
<th><code>sub</code> pour un push sur main</th>
</tr>
</thead>
<tbody>
<tr>
<td>Noms seuls</td>
<td><code>repo:octo-org/octo-repo:ref:refs/heads/main</code></td>
</tr>
<tr>
<td>Immuable</td>
<td><code>repo:octo-org@123456/octo-repo@456789:ref:refs/heads/main</code></td>
</tr>
</tbody>
</table>
<p>Les valeurs d'exemple viennent de la documentation de GitHub. La raison figure dans le changelog : si le nom d'un dépôt ou d'une organisation est recyclé, un nouveau propriétaire peut émettre des jetons avec le même subject et atteindre des ressources cloud qui font encore confiance à l'original. Les ID ne sont jamais réutilisés, l'ancienne confiance ne se transfère donc pas.</p>
<p>Dans mon lab, j'ai créé un nouveau dépôt privé et son <code>sub</code> est sorti au nouveau format. Cela change l'ordre de la mise en place. Je crée d'abord le dépôt, je lis les deux ID via l'API, et seulement ensuite je crée l'identifiant fédéré. La documentation de GitHub montre le format immuable pour les politiques de confiance d'Azure, d'AWS, de Google Cloud et de HashiCorp Vault. Je n'ai testé qu'Azure.</p>
<h2>Ce qu'Entra peut comparer maintenant</h2>
<p>Microsoft présente toujours les <a href="https://learn.microsoft.com/en-us/entra/workload-id/workload-identities-flexible-federated-identity-credentials">identifiants fédérés flexibles</a> comme une preview. La page est datée du 18 septembre 2026. Au lieu d'un <code>subject</code> exact, l'identifiant porte un <code>claimsMatchingExpression</code> avec <code>languageVersion</code> à 1, et <code>subject</code> doit être null. La page de concept indique qu'Azure CLI ne le prend pas encore en charge explicitement et montre <code>az rest</code> sur Graph beta, ce que j'ai utilisé pour une app registration. La référence CLI de <code>az identity federated-credential</code> (identités managées attribuées par l'utilisateur) liste pourtant les paramètres <code>--claims-matching-expression-*</code>, marqués Preview.</p>
<table>
<thead>
<tr>
<th>Opérateur</th>
<th>Ce qu'il fait</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>eq</code></td>
<td>Correspondance exacte sur un claim</td>
</tr>
<tr>
<td><code>matches</code></td>
<td>Wildcards : <code>*</code> pour une suite quelconque de caractères, <code>?</code> pour un seul</td>
</tr>
<tr>
<td><code>and</code></td>
<td>Combine des conditions sur plusieurs claims</td>
</tr>
</tbody>
</table>
<p>Pour GitHub, la <a href="https://learn.microsoft.com/en-us/entra/workload-id/workload-identities-set-up-flexible-federated-identity-credential">page de configuration</a> de Microsoft indique que l'expression doit comparer <code>sub</code> et l'un des claims <code>repository_id</code> et <code>repository_owner_id</code>, ou les deux. C'est vrai que <code>sub</code> soit basé sur les noms, personnalisé ou immuable. <code>sub</code> et <code>job_workflow_ref</code> acceptent <code>eq</code> et <code>matches</code>. Les deux claims d'ID n'acceptent que <code>eq</code>. Le <a href="https://learn.microsoft.com/en-us/entra/workload-id/workload-identities-github-immutable-subjects">guide de migration</a> de Microsoft utilise cet exemple :</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 a aussi publié un <a href="https://learn.microsoft.com/en-us/entra/workload-id/workload-identities-github-immutable-subjects">guide de migration</a>, daté du 28 juillet 2026. L'ordre : créer un identifiant pour le subject immuable à côté de l'ancien, activer les subjects immuables dans GitHub, valider une exécution, puis supprimer l'ancien identifiant. Une page associée sur les <a href="https://learn.microsoft.com/en-us/entra/workload-id/workload-identities-federated-credential-mutable-subjects">subjects mutables</a> décrit le recyclage des subjects et demande de supprimer les identifiants orphelins, ceux dont le workload n'existe plus.</p>
<p>Ici, ma propre exécution diffère de la documentation. Dans le <a href="https://iamops.dev/fr/github-actions-azure-workload-identity-federation/">lab</a>, j'ai créé deux expressions qui ne comparaient que <code>sub</code> (<code>feature-*</code> et <code>v*</code>), sans <code>repository_id</code>. Entra les a acceptées et les exécutions correspondantes ont réussi. Ces motifs contenaient les ID du propriétaire et du dépôt, ils étaient donc liés quand même. Lors d'un contrôle plus tard le même jour, Entra a aussi accepté une expression couvrant tous les dépôts du propriétaire, sans clause <code>repository_id</code> ni <code>repository_owner_id</code>, et cet identifiant a délivré un jeton à un autre dépôt du même propriétaire. Je recommande tout de même d'ajouter <code>repository_id</code>. Microsoft le documente comme obligatoire et la fonction est en preview : un identifiant sur le seul sub pourrait être refusé ou cesser de correspondre plus tard. Et la vérification de l'ID ne dépend pas d'un motif bien écrit : un wildcard à l'échelle du propriétaire a déjà délivré un jeton à un autre de mes dépôts, et le <code>sub</code> sans ID d'un dépôt plus ancien peut correspondre à un nom qui n'est plus le vôtre.</p>
<h2>Comment un jeton rencontre deux identifiants</h2>
<figure class="b-fig"><img src="https://iamops.dev/img/workload-identity-news-immutable-sub-entra-wildcards-workos.fr.svg" alt="Une matrice de deux identifiants fédérés Entra face à quatre exécutions GitHub Actions. L'identifiant exact pour main n'accepte qu'un push sur main. L'identifiant avec wildcard pour release/* et vérification de repository_id n'accepte qu'un push sur release/1. Une branche de fonctionnalité et une pull request ne correspondent à aucun des deux." width="1200" height="630" loading="lazy" decoding="async"><figcaption><strong>Quelles valeurs de sub chaque identifiant accepte.</strong> C'est ma propre synthèse, tirée du motif de chaque identifiant. Les ID sont les valeurs d'exemple de la documentation de GitHub.</figcaption></figure>
<p>Ce que montre l'image : la partie de <code>sub</code> après les ID, c'est l'exécution. Un push sur main, un push sur une branche de release, une branche de fonctionnalité et une pull request envoient chacun une valeur différente, et Entra la compare à l'identifiant. Les ID au milieu empêchent un autre dépôt du même nom de correspondre. Mon lab exécute chacun de ces cas et affiche le <code>sub</code> exact de chacun.</p>
<h2>WorkOS : ce que j'ai trouvé</h2>
<p>J'ai consulté le <a href="https://workos.com/changelog">changelog de WorkOS</a> parce qu'il publie sans cesse de l'auth pour les agents et MCP. Voici les entrées d'août au 20 novembre qui touchent aux identifiants d'agents ou de workloads :</p>
<table>
<thead>
<tr>
<th>Date</th>
<th>Entrée</th>
<th>Ce que dit WorkOS</th>
</tr>
</thead>
<tbody>
<tr>
<td>2 sept. 2026</td>
<td><a href="https://workos.com/changelog/agent-auth">Agent Auth</a></td>
<td>Accès anticipé. Les agents reçoivent des identités dans AuthKit et, à chaque exécution, des jetons de courte durée au périmètre étroit, délégués pour un utilisateur ou autonomes au sein d'une organisation. Les sessions peuvent être révoquées immédiatement.</td>
</tr>
<tr>
<td>4 sept. 2026</td>
<td><a href="https://workos.com/changelog/mcp-enterprise-managed-authorization-ema">MCP Enterprise-Managed Authorization (EMA)</a></td>
<td>MCP Auth prend en charge EMA : un client MCP peut atteindre des serveurs MCP en aval via le fournisseur d'identité de l'entreprise, sans écran de consentement par application. Accès sur demande.</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>Accès anticipé. Pour les organisations dont le fournisseur d'identité ne prend pas en charge Cross App Access, Claude émet l'assertion d'identité (ID-JAG) et MCP Auth l'échange contre un jeton d'accès pour votre serveur MCP.</td>
</tr>
<tr>
<td>10 nov. 2026</td>
<td><a href="https://workos.com/changelog/token-exchange-for-workos-connect">Token exchange pour WorkOS Connect</a></td>
<td>RFC 8693. Une application Connect first-party peut échanger un jeton contre un autre destiné à une autre ressource enregistrée, reporter les claims clés et réduire les scopes.</td>
</tr>
</tbody>
</table>
<p>Les deux dernières rejoignent ce que j'ai déjà écrit. Claude auto-connect est le flux ID-JAG de <a href="https://iamops.dev/fr/id-jag-explained/">ID-JAG explained</a>, avec Claude comme émetteur. Le token exchange est le motif que mon <a href="https://iamops.dev/fr/mcp-server-no-token-passthrough/">lab sur MCP sans passthrough de jeton</a> construit à la main.</p>
<p>Rien de tout cela n'est de la workload identity federation au sens d'Entra, où l'on fait confiance à des jetons d'un autre émetteur. Je n'ai trouvé aucune entrée du changelog de WorkOS à ce sujet, ni sur l'authentification machine à machine. Ce que ces entrées partagent avec l'histoire de GitHub, c'est l'idée d'un identifiant de courte durée et étroit pour chaque exécution plutôt qu'une clé stockée. Deux autres entrées sur les agents, Agent Registration (4 août) et Agent Vault (17 novembre), portent sur la connexion des agents à AuthKit avec le protocole auth.md et sur des sessions de navigateur déjà connectées, je les ai donc laissées de côté. Je n'ai essayé aucun produit WorkOS.</p>
<h2>Ce que je ferais</h2>
<p>C'est mon opinion, pas une recommandation de Microsoft ni de GitHub.</p>
<ul>
<li>Pour un nouveau dépôt, vérifiez tout identifiant écrit d'après d'anciens exemples. Le subject contient maintenant des ID, et un subject à noms seuls ne correspondra pas.</li>
<li>Pour un ancien dépôt, suivez l'ordre de Microsoft : ajoutez l'identifiant immuable, activez le format, lancez un workflow, puis supprimez l'ancien identifiant.</li>
<li>Mettez <code>repository_id</code> dans chaque expression, même quand le motif contient les ID. Dans mon lab, Entra a accepté des expressions sur le seul sub, et une expression couvrant tous les dépôts du propriétaire a délivré un jeton à un autre dépôt du même propriétaire. La doc exige toujours la vérification de l'ID, et je l'ajoute.</li>
<li>Listez les identifiants fédérés de vos inscriptions d'application et supprimez ceux dont le dépôt n'existe plus.</li>
</ul>
<p>Le <a href="https://iamops.dev/fr/github-actions-azure-workload-identity-federation/">lab</a> montre l'échec qui découle de la correspondance exacte. Avec seulement un identifiant pour main, un type d'exécution sur six est passé. Il montre aussi un piège : un identifiant pour <code>pull_request</code> fait aussi confiance aux exécutions <code>pull_request_target</code>, et celles-ci reçoivent des secrets.</p>
<h2>Ce que je n'ai pas vérifié</h2>
<ul>
<li>Je n'ai pas activé le format sur un dépôt existant et je n'ai pas appelé le point d'accès d'aperçu de GitHub qui montre le nouveau préfixe du subject.</li>
<li>Je n'ai testé qu'Azure. AWS, Google Cloud et Vault figurent dans la documentation de GitHub et je ne les ai pas exécutés.</li>
<li>Je n'ai pas testé GitHub Enterprise Server, que GitHub exclut.</li>
<li>J'ai lu les entrées du changelog de WorkOS sans essayer de produit ni lire la documentation liée. Deux entrées sont en accès anticipé.</li>
<li>Les pages Microsoft sur les identifiants flexibles disent toujours preview. Je n'ai pas trouvé de date de disponibilité générale et je n'en invente pas.</li>
</ul>
]]></content:encoded>
    </item>
    <item>
      <title>ID-JAG expliqué : comment les agents d'IA obtiennent un accès inter-applications sous contrôle de l'entreprise</title>
      <link>https://iamops.dev/fr/id-jag-explained/</link>
      <guid isPermaLink="true">https://iamops.dev/fr/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>Agents d'IA</category>
      <category>OAuth</category>
      <category>Normes</category>
      <description>Comment ID-JAG et Cross App Access laissent le fournisseur d'identité de l'entreprise approuver l'accès des agents d'IA à d'autres applications, avec captures.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/fr/id-jag-explained.png?v=986e5733" alt="" /></p><p><strong>En bref</strong></p>
<ul>
<li>ID-JAG est un standard IETF proposé (brouillon -06) qui permet au fournisseur d'identité d'une entreprise d'approuver l'accès d'un agent IA à une autre application.</li>
<li>Le fournisseur d'identité émet une assertion signée de courte durée ; l'autre application la vérifie et émet son propre jeton d'accès de courte durée.</li>
<li>Il remplace les fenêtres de consentement par application et les clés de longue durée par un point unique pour la politique et l'audit.</li>
<li>C'est encore un brouillon : la liaison de clés et le provisionnement à la volée pourraient passer dans des documents séparés, et plusieurs produits l'implémentent déjà.</li>
<li>Le lab sur l'exemple public xaa.dev montre le déroulement, avec des captures masquées et un enregistrement.</li>
</ul>
<p>De nombreux agents d'IA doivent accéder à plusieurs applications métier pour le compte d'un utilisateur. Aujourd'hui, chaque connexion déclenche généralement sa propre demande de consentement, ou repose sur une clé de longue durée enregistrée dans les paramètres de l'agent. Dans les deux cas, une organisation a du mal à voir et à contrôler ce qui se passe.</p>
<p><strong>ID-JAG</strong> est une norme proposée qui déplace cette approbation de l'utilisateur individuel vers le fournisseur d'identité de l'organisation. Cet article explique son fonctionnement, l'état d'avancement de la spécification et ce que montre un essai en laboratoire avec une application d'exemple publique.</p>
<h2>Le problème</h2>
<p>Les collaborateurs se connectent une seule fois, avec un seul compte, grâce à l'<em>authentification unique</em> (single sign-on). Le système qui la gère est le <em>fournisseur d'identité</em> de l'entreprise, appelé ici « connexion d'entreprise ».</p>
<p>Un agent d'IA doit ensuite lire des tâches dans une application, des fichiers dans une autre et un agenda dans une troisième. Chacune de ces applications exploite son propre serveur d'autorisation, qui ne sait rien de l'agent. En pratique, chaque connexion fonctionne de l'une de ces deux façons :</p>
<ul>
<li><strong>Une demande de consentement</strong> pour chaque application et chaque utilisateur. Les utilisateurs ont tendance à approuver sans lire, et l'organisation n'a aucun registre central.</li>
<li><strong>Une clé de longue durée</strong> collée dans la configuration de l'agent. Elle n'expire pas, et quiconque l'obtient peut l'utiliser.</li>
</ul>
<p>L'alternative est un point unique qui se porte garant de l'utilisateur et de l'agent, applique les règles de l'organisation et en garde une trace.</p>
<h2>Ce que fait un ID-JAG</h2>
<p>Le nom complet est <em>Identity Assertion JWT Authorization Grant</em>. En pratique, c'est une <strong>assertion signée de courte durée</strong> émise par la connexion d'entreprise. Elle indique que l'organisation de cet utilisateur autorise cet agent à demander à cette application un accès précis.</p>
<p>Le schéma construit autour s'appelle informellement <strong>Cross App Access (XAA)</strong>. La page d'oauth.net à son sujet dit qu'il « remplace l'étape d'approbation manuelle de l'utilisateur par un échange de jetons » (<a href="https://iamops.dev/fr/keycloak-token-exchange-rfc-8693/">token exchange</a>).</p>
<p><img src="https://iamops.dev/img/id-jag-flow.fr.svg" alt="Les cinq étapes d'un flux ID-JAG, de la connexion unique à l'utilisation d'un jeton d'accès de courte durée par l'agent."></p>
<p>Le flux en cinq étapes :</p>
<ol>
<li>L'utilisateur se connecte une fois au travail, de la manière habituelle.</li>
<li>L'agent demande à la connexion d'entreprise une assertion couvrant une application donnée.</li>
<li>La connexion d'entreprise évalue sa politique. Si la connexion est autorisée, elle émet l'ID-JAG.</li>
<li>L'agent présente l'ID-JAG au serveur d'autorisation de l'autre application. Ce serveur vérifie la signature, applique <strong>ses propres</strong> règles et émet un jeton d'accès de courte durée.</li>
<li>L'agent utilise ce jeton pour appeler l'application.</li>
</ol>
<p>Deux détails comptent. L'application destinataire décide toujours de ce qu'elle accorde : l'ID-JAG n'est donc pas un chèque en blanc. Et comme la connexion d'entreprise se trouve au milieu, il existe un seul endroit pour définir la politique et un seul endroit pour auditer ce qui s'est passé.</p>
<p>Sur le plan technique, il enchaîne deux normes existantes : le token exchange (RFC 8693) et le JWT bearer grant (RFC 7523).</p>
<h2>Laboratoire : le flux dans l'exemple xaa.dev</h2>
<p>Le bac à sable gratuit <strong>xaa.dev</strong>, proposé par l'équipe développeurs d'Okta, rend le flux visible. Lors d'un essai en laboratoire le 7 novembre 2026, son application d'exemple a été exécutée en local dans un environnement de test. L'application dispose d'un panneau « Behind the scenes » qui marque chaque étape au fur et à mesure : connexion d'entreprise, ID-JAG, jeton d'accès et liste de contrôle récupérée auprès de la seconde application. Aucune demande de consentement n'est apparue à aucun moment.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/xaa/dashboard.webp" alt="L'application d'exemple xaa.dev avec la liste d'intégration à gauche et le panneau Behind the scenes à droite, montrant les quatre étapes terminées." width="1280" height="975" loading="lazy" decoding="async"><figcaption><strong>Vue d'ensemble.</strong> La liste (à gauche) a été récupérée auprès de la seconde application avec l'identité d'entreprise. Le panneau (à droite) énumère les quatre étapes : connexion d'entreprise, ID-JAG, jeton d'accès, liste via MCP. La revendication du sujet (sub) est masquée.</figcaption></figure>
<p><strong>Étape 2 : l'assertion.</strong> Après la connexion d'entreprise, l'exemple échange le jeton d'identité (ID token) de l'utilisateur contre un ID-JAG (RFC 8693). En développant l'étape 2, on voit l'assertion décodée : l'émetteur, l'audience (le serveur d'autorisation de l'autre application), la ressource et le scope demandés, ainsi que les heures d'émission et d'expiration, ici séparées de cinq minutes. Les identifiants qui renvoient à une personne ou à un client sont masqués.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/xaa/id-jag.webp" alt="Étape 2 développée dans le panneau Behind the scenes : l'ID-JAG décodé, avec émetteur, audience, ressource, heures d'émission et d'expiration et scope visibles ; les identifiants sont recouverts de cadres noirs." width="1280" height="975" loading="lazy" decoding="async"><figcaption><strong>Étape 2, l'ID-JAG.</strong> L'émetteur, l'audience, la ressource, la durée de validité et le scope sont visibles. Le sujet, le client et les identifiants du jeton sont recouverts de cadres noirs, et le jeton encodé n'est pas affiché.</figcaption></figure>
<p><strong>Étapes 3 et 4 : le jeton d'accès.</strong> Le serveur d'autorisation de l'autre application vérifie l'ID-JAG (RFC 7523) et renvoie un jeton d'accès au scope limité. L'exemple l'utilise ensuite pour récupérer la liste via MCP. Les revendications du jeton indiquent qui l'a émis, pour quelle audience et avec quel scope.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/xaa/access-token.webp" alt="La section du jeton d'accès développée, avec les revendications qui montrent l'émetteur, l'audience et les scopes todos.read et mcp.access ; le jeton encodé et le sujet sont masqués." width="1280" height="975" loading="lazy" decoding="async"><figcaption><strong>Étapes 3 et 4, le jeton d'accès.</strong> Les revendications du jeton (émetteur, audience, scope) sont réelles. Le jeton encodé et le sujet sont masqués.</figcaption></figure>
<p>J'ai enregistré tout le flux sur le playground public xaa.dev, avec l'application d'exemple dans un environnement de test local et un utilisateur synthétique. L'enregistrement commence sur la page de connexion : tu vois chaque étape se dérouler, puis son en-tête et son contenu décodés. Seul le bandeau de sous-titres en haut a été ajouté. Il est sans son et dure environ une minute 44 secondes.</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.fr.vtt" srclang="fr" label="Français" default></video><figcaption id="vid-cap"><strong>Enregistrement d'écran</strong> (1 min 44 s, sans son, sous-titres disponibles): connexion chez l'IdP de l'entreprise, puis chaque étape avec son en-tête et son contenu décodés. Utilisateur synthétique et jetons de démonstration à courte durée de vie issus du playground public. Les chaînes de jetons encodés sont raccourcies pour la mise en page.</figcaption></figure>
<h3>Ce que tu vois</h3>
<ol>
<li><strong>0:08 Connexion chez l'IdP de l'entreprise.</strong> L'utilisateur se connecte sur idp.xaa.dev, pas dans l'application de l'agent. L'application ne voit jamais de mot de passe, et c'est chez l'IdP que vivent la MFA et les règles de connexion. Le playground accepte six chiffres quelconques comme second facteur.</li>
<li><strong>0:30 L'application de l'agent reçoit un jeton d'identité.</strong> Il prouve qui s'est connecté. Regarde <code>iss</code> (l'IdP), <code>aud</code> (l'identifiant client de l'application) et <code>exp</code>, une heure après <code>iat</code>. L'application a maintenant une identité de l'organisation, mais pas encore d'accès à l'application todo.</li>
<li><strong>0:47 L'IdP l'échange contre un ID-JAG (RFC 8693).</strong> L'agent demande une assertion destinée à une seule cible. Le type d'en-tête est <code>oauth-id-jag+jwt</code>. Les claims désignent dans <code>aud</code> le serveur d'autorisation de l'application todo, plus <code>resource</code>, <code>client_id</code> et <code>scope</code>. Dans un vrai déploiement, c'est ici que la politique de l'administrateur décide. Le playground autorise simplement.</li>
<li><strong>0:58 L'ID-JAG a une vie courte.</strong> <code>exp</code> tombe 300 secondes après <code>iat</code>. Un ID-JAG qui fuit est inutile au bout de cinq minutes, et il ne fonctionne que chez le serveur nommé dans <code>aud</code>.</li>
<li><strong>1:07 Le serveur d'autorisation propre à l'application todo émet le jeton d'accès (RFC 7523).</strong> L'agent lui présente l'ID-JAG. Ce serveur vérifie la signature de l'IdP, puis applique ses propres règles. Dans le jeton, ce serveur est <code>iss</code>, le serveur MCP est <code>aud</code>, et seul le <code>scope</code> approuvé figure. L'utilisateur est identifié dans l'espace de noms de l'application todo.</li>
<li><strong>1:30 L'agent appelle l'API.</strong> Avec le jeton d'accès, il lit la checklist via MCP. La partie gauche de la page est cette réponse. Aucun écran de consentement n'est apparu à aucun moment.</li>
</ol>
<p><em>Le laboratoire utilise un exemple public avec des comptes jetables et des données d'exemple. Les captures ont été recadrées sur l'application et masquées avant publication. L'enregistrement montre les jetons de démonstration décodés en entier, car ils viennent du playground public, appartiennent à un utilisateur synthétique et expirent en moins d'une heure. Les chaînes de jetons encodés sont raccourcies pour la mise en page.</em></p>
<h2>Où en est la spécification</h2>
<p><strong>C'est toujours un brouillon, pas une norme achevée.</strong> Le document est <em>draft-ietf-oauth-identity-assertion-authz-grant</em>, désormais en version <strong>-06</strong>, datée du 31 octobre 2026. C'est un document du groupe de travail OAuth de l'IETF, rédigé par des auteurs d'Okta et de Ping Identity et par un auteur indépendant. L'objectif est un document Standards Track, mais les brouillons peuvent encore évoluer.</p>
<p><strong>IETF 127, 18 novembre 2026.</strong> Les auteurs ont présenté le brouillon à la session OAuth. Les diapositives citent trois thèmes ouverts :</p>
<ul>
<li><strong>Le provisionnement à la volée</strong> (just-in-time provisioning) : comment une application traite un utilisateur qu'elle n'a jamais vu, puisque son premier contact est un ID-JAG. Les diapositives recommandent de le traiter dans une future extension.</li>
<li><strong>Le key binding</strong> : lier les jetons à une clé cryptographique pour qu'un jeton volé soit inutilisable. Les diapositives demandent s'il faut le déplacer dans une extension distincte, et les notes consignent une recommandation en faveur de plusieurs brouillons de suivi. Un participant a estimé que reporter des sujets dans d'autres documents donne au brouillon un air d'inachevé. L'auteur a répondu que le provisionnement est optionnel et que le key binding s'applique plus largement que ce brouillon.</li>
<li><strong>Les passerelles et proxys</strong>, courants dans les déploiements d'IA où une passerelle se place entre l'agent et les applications. C'est un point ouvert. Un brouillon séparé est proposé, et les notes indiquent que les auteurs souhaiteraient des réunions supplémentaires (« interim ») sur les passerelles et le key binding.</li>
</ul>
<p>Les notes les consignent comme des <strong>recommandations</strong>. Aucune décision définitive n'y figure. Les prochaines étapes des diapositives sont de trier les points restants, en les corrigeant dans une version -07 ou en les écartant délibérément, puis de demander un last call du groupe de travail.</p>
<h2>Implémentations</h2>
<p>Plusieurs éditeurs l'implémentent déjà, bien que le brouillon ne soit pas final. D'après la <a href="https://oauth.net/cross-app-access/">liste des implémentations d'oauth.net</a>, consultée le 19 novembre 2026 :</p>
<ul>
<li><strong>Les fournisseurs d'identité qui émettent des ID-JAG</strong> comprennent Okta, Oracle OCI IAM, Ping, Gravitee, Descope, Keycloak (indiqué « in progress ») et plusieurs autres.</li>
<li><strong>Les serveurs d'autorisation qui les acceptent</strong> comprennent Okta, Oracle OCI IAM, Ping, Gravitee, Auth0 (accès anticipé), Stytch et WorkOS AuthKit (accès anticipé).</li>
<li><strong>Les applications et outils d'IA jouant le rôle de clients</strong> comprennent Claude, OpenAI Codex CLI et Visual Studio Code (préversion).</li>
<li><strong>Les applications côté réception</strong> comprennent Asana, Atlassian, Linear, Notion et Slack, certaines en bêta.</li>
</ul>
<p>Quelques exemples datés :</p>
<ul>
<li><strong>Oracle</strong> : le 9 octobre 2026, Oracle a publié le token exchange ID-JAG dans OCI IAM.</li>
<li><strong>Gravitee</strong> : Access Management 4.13, annoncé le 12 novembre 2026, peut jouer les deux rôles, émettre et accepter des ID-JAG.</li>
<li><strong>Okta</strong> : le 13 novembre 2026, Okta a annoncé la disponibilité générale de la prise en charge de fournisseurs d'identité tiers, et cite Ping, Descope et Oracle comme fournisseurs compatibles XAA dont il peut gérer les utilisateurs et les agents.</li>
<li><strong>MCP</strong> : le Model Context Protocol, une manière courante de connecter les outils d'IA aux applications, dispose d'une extension « Enterprise-Managed Authorization » qui utilise un ID-JAG. Le blog du projet l'a annoncée comme stable en juin 2026.</li>
</ul>
<p>Microsoft Entra ne figurait pas dans la liste d'oauth.net au moment de la vérification.</p>
<h2>Différences avec les écrans de consentement et l'on-behalf-of</h2>
<table>
<thead>
<tr>
<th></th>
<th>Demande de consentement</th>
<th>On-behalf-of (OBO)</th>
<th>ID-JAG / XAA</th>
</tr>
</thead>
<tbody>
<tr>
<td><strong>Qui approuve</strong></td>
<td>L'utilisateur, application par application</td>
<td>Le consentement antérieur de l'utilisateur, transmis</td>
<td>La connexion d'entreprise, selon des règles fixées par un administrateur</td>
</tr>
<tr>
<td><strong>Ce que voit l'utilisateur</strong></td>
<td>Une demande par application</td>
<td>En général rien après la première connexion</td>
<td>Rien</td>
</tr>
<tr>
<td><strong>Où cela fonctionne</strong></td>
<td>Partout où OAuth fonctionne</td>
<td>Un service qui en appelle un autre, au sein d'un seul système d'identité</td>
<td>Entre applications et organisations qui exploitent chacune leur serveur d'autorisation</td>
</tr>
<tr>
<td><strong>Contrôle central</strong></td>
<td>Limité</td>
<td>Partiel</td>
<td>La raison d'être de la conception</td>
</tr>
</tbody>
</table>
<p><strong>Face aux écrans de consentement :</strong> une demande de consentement interroge l'utilisateur à chaque fois. Un ID-JAG applique une fois les règles de l'organisation, puis les fait respecter silencieusement.</p>
<p><strong>Face à l'<a href="https://iamops.dev/fr/entra-on-behalf-of-agent-middle-tier/">on-behalf-of</a> :</strong> la documentation de Microsoft décrit l'OBO comme une API web qui utilise l'identité d'un utilisateur pour appeler une autre API, en transmettant l'identité et les autorisations de l'utilisateur le long de la chaîne. Cela se passe au sein de la plateforme d'identité Microsoft. L'ID-JAG traite un problème voisin au-delà des frontières : les deux applications ont des serveurs d'autorisation différents, et un tiers, la connexion d'entreprise, se porte garant de l'utilisateur. Les deux se ressemblent du point de vue de l'utilisateur, mais la confiance est organisée différemment.</p>
<h2>Une réserve</h2>
<p>Moins de demandes signifie plus de confort, mais aussi moins d'occasions pour une personne d'examiner la requête. C'est une appréciation, pas une affirmation de la norme : la conception n'aide que si les politiques de l'organisation sont solides et révisées régulièrement. L'ID-JAG rend <strong>possible</strong> de voir et de contrôler l'accès des agents en un seul endroit. Quelqu'un doit encore exercer ce contrôle.</p>
<p>Cet article sera mis à jour à mesure que le brouillon avance vers le last call du groupe de travail.</p>
]]></content:encoded>
    </item>
    <item>
      <title>Les banques américaines mettent les clients en première ligne pour les agents d'IA tiers</title>
      <link>https://iamops.dev/fr/banks-ai-agents-customer-liability/</link>
      <guid isPermaLink="true">https://iamops.dev/fr/banks-ai-agents-customer-liability/</guid>
      <pubDate>Wed, 18 Nov 2026 08:00:00 GMT</pubDate>
      <dc:creator>Argo</dc:creator>
      <category>Actualités</category>
      <category>Agents d'IA</category>
      <category>Banque</category>
      <category>Sécurité</category>
      <category>Responsabilité</category>
      <description>Le 18 novembre 2026, TechCrunch a dit que Citi, PNC et d'autres banques US traitent les actes d'un agent d'IA tiers comme du client. Ce que disent les termes.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/fr/banks-ai-agents-customer-liability.png?v=986e5733" alt="" /></p><p><strong>En bref</strong></p>
<ul>
<li>Le 18 novembre 2026, TechCrunch a indiqué que Citi a mis à jour son Online User Agreement cette semaine-là : les clients qui donnent accès à un agent d'IA tiers sont responsables de ce que cet agent fait, y compris si l'outil divulgue les identifiants ou est piraté.</li>
<li>Le même article indique que JPMorgan et Bank of America ont annoncé des politiques similaires en octobre 2026, que PNC a modifié ses conditions le 18 novembre, et que Citizens a écrit à ses clients la même semaine.</li>
<li>L'avis de Wells Fargo indique qu'un Online Access Agreement mis à jour entre en vigueur le 24 novembre 2026 : un outil d'IA tiers n'est pas exploité par la banque, et les demandes peuvent être traitées comme si elles venaient de vous.</li>
<li>Selon TechCrunch, les agents d'IA fournis par Citi elle-même peuvent être utilisés sans cette responsabilité supplémentaire. Tant qu'une banque ne distingue pas une personne d'un agent, un identifiant partagé est traité comme vous.</li>
</ul>
<p>Le 18 novembre 2026, TechCrunch a indiqué que plusieurs grandes banques américaines ont mis à jour leurs conditions pour les clients qui donnent à un agent d'IA tiers l'accès à un compte. Le changement n'est pas une interdiction. C'est une déclaration sur qui est responsable lorsque quelque chose tourne mal.</p>
<h2>Ce qu'ont dit les banques</h2>
<p>Citibank a mis à jour son Online User Agreement dans la semaine du 18 novembre 2026. Un porte-parole de Citi a déclaré à TechCrunch que les clients qui accordent l'accès à leur compte à des agents d'IA tiers sont responsables des activités menées par l'intermédiaire de ces agents. TechCrunch a aussi indiqué que la mise à jour de Citi va plus loin : si l'outil d'IA divulgue les identifiants, ou est piraté, le client est responsable de ce que les attaquants font ensuite avec le compte.</p>
<p>Le même article indique que JPMorgan et Bank of America ont annoncé des politiques similaires en octobre 2026, que PNC a modifié ses conditions le 18 novembre, et que Citizens a écrit à ses clients la même semaine.</p>
<p>Wells Fargo a publié son propre avis aux clients : un Online Access Agreement mis à jour entre en vigueur le 24 novembre 2026. La banque indique que si vous utilisez un outil ou un agent d'IA tiers pour accéder à vos comptes, l'outil n'est pas exploité par Wells Fargo, que les demandes soumises par l'intermédiaire de l'outil peuvent être traitées comme si elles venaient directement de vous, et qu'elle se réserve le droit de restreindre ou de bloquer l'accès de certains outils d'IA tiers.</p>
<p>Je ne suis pas avocat, et ceci n'est pas un conseil juridique. Certains de ces termes, y compris ceux de Wells Fargo, laissent encore une place aux protections que la loi vous accorde déjà. La direction reste claire.</p>
<h2>Pourquoi cela arrive maintenant</h2>
<p>Un agent d'IA qui se connecte avec le nom d'utilisateur et le mot de passe du client ressemble, pour la banque, au client. La piste d'audit, c'est-à-dire le registre de qui a fait quoi, ne montre pas d'acteur distinct. C'est pourquoi une banque peut dire que le paiement de l'agent, ou le paiement d'un attaquant après une fuite d'identifiants, a été autorisé par vous.</p>
<p>TechCrunch relève un contraste utile dans les conditions de Citi : les agents d'IA que Citi elle-même fournit peuvent être utilisés sans cette responsabilité supplémentaire. La banque trace une ligne entre les outils qu'elle contrôle et ceux qu'elle ne contrôle pas.</p>
<p>L'outil de finance personnelle d'Anthropic, mentionné dans le même article, est décrit comme en lecture seule : il « ne peut pas déplacer, gérer ni investir votre argent ». Cela réduit le risque qu'un paiement parte, mais ne résout pas le cas où un outil qui ne fait que lire un compte détient tout de même un identifiant.</p>
<figure class="b-fig"><img src="https://iamops.dev/img/banks-ai-agents-customer-liability.fr.svg" alt="Quatre étapes en ligne : un client partage un identifiant avec un agent d'IA, l'agent agit ou est piraté, la banque ne voit que les identifiants du client et traite l'action comme celle du client. Un identifiant partagé ne laisse pas de trace distincte." width="1200" height="630" loading="lazy" decoding="async"><figcaption><strong>Ce que la banque peut voir.</strong> Une fois que le client partage un identifiant, la banque n'a pas de trace distincte pour l'agent. Un paiement, ou une connexion utilisée après une fuite, peut ressembler au client agissant seul.</figcaption></figure>
<h2>Ce que je ferais</h2>
<p>Ne remettez pas l'identifiant d'un compte bancaire à un outil d'IA tiers, sauf si vous avez une raison claire et que vous comprenez les conditions. Si un outil a déjà cet accès, révoquez-le auprès du fournisseur, changez le mot de passe si l'outil le détenait, et conservez une trace.</p>
<p>Le meilleur modèle, avec le temps, est un agent nommé, avec une autorisation étroite et limitée dans le temps, que vous pouvez couper sans changer votre propre mot de passe. Les banques et les fournisseurs commencent à en parler, mais les conditions rapportées le 18 novembre supposent encore un identifiant partagé. Tant que la banque ne peut pas distinguer une personne d'un agent, l'agent, c'est vous.</p>
<p>Si le côté technique vous intéresse, à savoir comment un agent peut obtenir un jeton sans partager un mot de passe, j'ai écrit sur <a href="https://iamops.dev/fr/id-jag-explained/">ID-JAG</a>. Le 17 novembre, Microsoft a aussi publié une analyse en laboratoire du <a href="https://iamops.dev/fr/device-code-phishing-ai-agents/">phishing par device code contre les assistants de code IA</a>.</p>
]]></content:encoded>
    </item>
    <item>
      <title>Device code phishing et agents d'IA : risques et mesures d'atténuation</title>
      <link>https://iamops.dev/fr/device-code-phishing-ai-agents/</link>
      <guid isPermaLink="true">https://iamops.dev/fr/device-code-phishing-ai-agents/</guid>
      <pubDate>Tue, 17 Nov 2026 08:00:00 GMT</pubDate>
      <dc:creator>Argo</dc:creator>
      <category>Actualités</category>
      <category>Hameçonnage</category>
      <category>Device code</category>
      <category>Agents d'IA</category>
      <category>Sécurité</category>
      <description>Microsoft a montré en laboratoire qu'un device code approuvé peut donner à un attaquant le contrôle d'un assistant de code IA. Risques et mesures d'atténuation.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/fr/device-code-phishing-ai-agents.png?v=986e5733" alt="" /></p><p><strong>En bref</strong></p>
<ul>
<li>Le phishing par device code pousse une personne à approuver une connexion lancée par un attaquant.</li>
<li>Lors d'un test de laboratoire contrôlé, Microsoft a montré qu'un seul code approuvé pouvait permettre à un attaquant de piloter une session GitHub Copilot CLI et d'atteindre l'historique des sessions dans le cloud et des dépôts privés, selon les réglages.</li>
<li>Ce sont des résultats de preuve de concept ; Microsoft dit ne pas les avoir observés dans de vraies attaques, mais le phishing par device code est une voie récurrente de prise de contrôle de comptes.</li>
<li>Ne saisissez un device code que si vous avez lancé vous-même la demande.</li>
<li>Passez en revue les applications connectées à vos comptes et utilisez les réglages les plus restrictifs de contrôle à distance et de stockage des sessions que vos outils d'IA permettent.</li>
</ul>
<p>La connexion par code d'appareil (device code) est le flux dans lequel un appareil sans clavier pratique affiche un court code que l'utilisateur saisit sur un second appareil pour s'authentifier. Les téléviseurs connectés l'utilisent, tout comme de nombreux outils en ligne de commande employés par les développeurs.</p>
<p>Le 17 novembre 2026, les chercheurs en sécurité de Microsoft ont publié une analyse de la manière dont ce même flux peut être retourné contre les assistants de programmation fondés sur l'IA.</p>
<h2>Le schéma d'attaque</h2>
<p>Dans le <em>device code phishing</em>, c'est l'<strong>attaquant</strong> qui lance la connexion sur sa propre machine, reçoit un code et l'envoie à sa cible. Le message peut ressembler à une demande du service informatique ou à une vérification de licence. La cible ouvre la véritable page de connexion, saisit le code et approuve, ce qui connecte l'attaquant.</p>
<p>La page de connexion est légitime, et c'est pourquoi la technique fonctionne. Selon Microsoft, le site légitime ne dit pas à lui seul à l'utilisateur qui a lancé la demande.</p>
<figure class="b-fig"><img src="https://iamops.dev/img/device-code-phishing-ai-agents.fr.svg" alt="Diagramme de séquence à trois acteurs : l'attaquant, la personne et la vraie page de connexion. L'attaquant demande un device code et envoie le user code à la personne. Elle le saisit sur la vraie page et approuve, puis l'interrogation de l'attaquant reçoit les jetons du compte de la personne." width="1200" height="630" loading="lazy" decoding="async"><figcaption><strong>Le déroulé du côté de l'attaquant.</strong> Les étapes 1 et 4 tournent sur la machine de l'attaquant. La personne ne fait que l'étape 3, sur une page qui appartient vraiment au service de connexion : le code est donc la seule chose à vérifier.</figcaption></figure>
<h2>Ce que Microsoft a démontré</h2>
<p>L'équipe a mené un <strong>test de laboratoire contrôlé</strong> avec l'outil en ligne de commande de GitHub Copilot comme exemple. Avec un seul code approuvé, elle a pu, selon les paramètres du compte :</p>
<ul>
<li>piloter à distance une session active de l'assistant et lui faire exécuter des commandes sur la machine de la personne,</li>
<li>ajouter des entrées trompeuses à la mémoire de l'assistant,</li>
<li>lire l'historique des sessions stocké dans le cloud,</li>
<li>accéder aux dépôts de code privés visibles depuis le compte.</li>
</ul>
<p>Microsoft précise qu'il s'agit de résultats de preuve de concept et qu'elle n'a pas observé ces quatre issues dans des attaques réelles. Le device code phishing lui-même est une autre affaire. Selon Microsoft, il s'agit d'une voie récurrente de prise de contrôle de comptes, et elle cite des campagnes antérieures, dont une baptisée EvilTokens, qu'elle a contribué à démanteler en septembre 2026.</p>
<h2>Mesures d'atténuation recommandées</h2>
<ul>
<li><strong>Ne saisissez un code d'appareil que si vous l'avez demandé vous-même</strong>, sur un écran que vous avez lancé. Un code reçu dans un message de quelqu'un d'autre est un signal d'alerte, même si la page est authentique.</li>
<li><strong>Passez en revue les applications connectées à vos comptes</strong> et supprimez celles que vous ne reconnaissez pas. Les recommandations de Microsoft citent en exemple les paramètres « authorized OAuth apps » de GitHub.</li>
<li><strong>Utilisez les paramètres les plus restrictifs</strong> que vos outils d'IA permettent pour le contrôle à distance et le stockage des sessions dans le cloud.</li>
</ul>
<p>Le point plus général de Microsoft est que plus un assistant d'IA peut accéder à de choses, plus une seule approbation obtenue par hameçonnage a de valeur.</p>
<p><em>Source : <a href="https://www.microsoft.com/en-us/security/blog/2026/11/17/the-risks-of-device-code-authentication-for-ai-coding-agents/">Microsoft Security Blog, 17 novembre 2026</a>.</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>Device code phishing : une note pour les managers après le test en laboratoire de Microsoft</title>
      <link>https://iamops.dev/fr/device-code-phishing-briefing-for-managers/</link>
      <guid isPermaLink="true">https://iamops.dev/fr/device-code-phishing-briefing-for-managers/</guid>
      <pubDate>Tue, 17 Nov 2026 08:00:00 GMT</pubDate>
      <dc:creator>Argo</dc:creator>
      <category>Actualités</category>
      <category>Hameçonnage</category>
      <category>Device code</category>
      <category>Agents d'IA</category>
      <category>Sécurité</category>
      <description>Le 17 novembre 2026, Microsoft a montré en laboratoire qu'un device code peut donner à un attaquant un assistant IA. De quoi il s'agit et quoi dire à l'équipe.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/fr/device-code-phishing-briefing-for-managers.png?v=986e5733" alt="" /></p><p><strong>En bref</strong></p>
<ul>
<li>Le 17 novembre 2026, Microsoft a publié une analyse en laboratoire du phishing par device code contre les assistants de code IA. La page que voit la personne est authentique ; la demande est celle de l'attaquant.</li>
<li>En laboratoire, une seule demande GitHub par device code approuvée a permis aux chercheurs de piloter une session, d'écrire une mémoire trompeuse, de lire l'historique des sessions dans le cloud ou d'atteindre des dépôts privés, selon les réglages.</li>
<li>Microsoft indique que ces quatre résultats sont une preuve de concept et n'ont pas été observés dans de vraies attaques. Le phishing par device code lui-même est une voie récurrente de prise de contrôle de comptes.</li>
<li>Ne saisissez un device code que pour une connexion que vous avez lancée vous-même. Passez en revue les applications connectées et limitez ce que l'assistant peut atteindre.</li>
</ul>
<p>La connexion par device code est le flux dans lequel un appareil sans clavier pratique affiche un code court, et vous le saisissez sur un autre appareil pour approuver la connexion. Les téléviseurs connectés l'utilisent. Beaucoup d'outils en ligne de commande aussi.</p>
<p>Le 17 novembre 2026, les chercheurs en sécurité de Microsoft ont publié une analyse de la manière dont ce même flux peut être retourné contre les assistants de programmation fondés sur l'IA. J'ai déjà écrit un <a href="https://iamops.dev/fr/device-code-phishing-ai-agents/">article plus long</a> sur le détail technique. Voici la note plus courte que je donnerais à un manager.</p>
<h2>Ce qu'est vraiment l'attaque</h2>
<p>Dans le phishing par device code, c'est l'attaquant qui lance la connexion sur sa propre machine et reçoit un code court. Il l'envoie à quelqu'un d'autre, souvent présenté comme une demande du service informatique ou une vérification de licence. La personne ouvre la véritable page de connexion, saisit le code et approuve. Cela connecte l'attaquant.</p>
<p>La page est réelle. C'est pour cela que l'astuce fonctionne. Le propos de Microsoft est qu'un site légitime ne vous dit pas qui a lancé la demande. La page de vérification de GitHub, note Microsoft, prévient de ne jamais utiliser un code envoyé par quelqu'un d'autre.</p>
<figure class="b-fig"><img src="https://iamops.dev/img/device-code-phishing-briefing-for-managers.fr.svg" alt="Trois étapes en ligne : quelqu'un vous envoie un code court, vous le saisissez sur une vraie page de connexion, et la personne qui a lancé la demande est connectée. N'approuvez un code que si vous avez lancé vous-même la connexion." width="1200" height="630" loading="lazy" decoding="async"><figcaption><strong>Ce que fait vraiment la personne.</strong> La seule étape qu'elle accomplit est de saisir un code court sur une vraie page de connexion. La demande derrière ce code a été lancée par quelqu'un d'autre.</figcaption></figure>
<h2>Ce que Microsoft a montré en laboratoire</h2>
<p>L'équipe a utilisé l'outil en ligne de commande de GitHub Copilot comme exemple. La technique n'est pas limitée à cet outil : tout client public qui prend en charge ce flux de connexion peut être abusé de la même manière, et l'attaquant choisit les autorisations à demander. Un client public est une application qui ne peut pas garder un secret, comme un outil en ligne de commande ou un téléviseur.</p>
<p>Dans un test de laboratoire contrôlé, un compte d'essai a approuvé une demande GitHub par device code lancée par les chercheurs. Avec cette seule approbation, selon les réglages du compte, ils ont pu :</p>
<ul>
<li>piloter à distance une session active de l'assistant et lui faire exécuter des commandes sur la machine de la personne,</li>
<li>ajouter des entrées trompeuses à la mémoire de l'assistant,</li>
<li>lire l'historique des sessions stocké dans le cloud,</li>
<li>atteindre des dépôts de code privés visibles pour le compte.</li>
</ul>
<p>Microsoft indique que ce sont des résultats de preuve de concept, et qu'elle n'a pas observé ces quatre issues dans de vraies attaques. Le phishing par device code lui-même est plus ancien. Microsoft le décrit comme une voie récurrente de prise de contrôle de comptes, et cite des campagnes antérieures, dont une appelée EvilTokens qu'elle a aidé à interrompre en septembre 2026.</p>
<h2>Ce que je dirais à une équipe</h2>
<p>Ne saisissez un device code que pour une connexion que vous avez lancée vous-même, sur un écran que vous avez ouvert. Un code qui arrive dans un message de quelqu'un d'autre est un signal d'alerte, même lorsque la page est authentique.</p>
<p>Passez en revue les applications connectées aux comptes professionnels et retirez celles que personne ne reconnaît. Microsoft indique, comme exemple, les réglages GitHub des applications OAuth autorisées. Les applications OAuth sont les applications qu'une personne a autorisées à utiliser un compte.</p>
<p>Pour les outils de code IA, utilisez les réglages les plus stricts que vous pouvez accepter pour le contrôle à distance, le stockage des sessions dans le cloud et la mémoire. Une approbation n'a de valeur que par ce que l'assistant peut atteindre.</p>
<p>Microsoft décrit aussi des détections dans Microsoft Defender pour ce type de phishing arrivé par e-mail ou via Teams, et un moyen de suspendre une identité GitHub gérée. Cela concerne les équipes de sécurité. L'habitude que je demanderais à tous est la première : si vous n'avez pas lancé la connexion, ne saisissez pas le code.</p>
<p>L'<a href="https://iamops.dev/fr/device-code-phishing-ai-agents/">article plus long</a> présente le déroulement étape par étape et la même source.</p>
]]></content:encoded>
    </item>
    <item>
      <title>Flux on-behalf-of de Microsoft Entra pour la couche intermédiaire d'un agent : certificat, aucun secret client</title>
      <link>https://iamops.dev/fr/entra-on-behalf-of-agent-middle-tier/</link>
      <guid isPermaLink="true">https://iamops.dev/fr/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>Agents d'IA</category>
      <category>OAuth</category>
      <category>Identité de workload</category>
      <description>Lab en tenant de test : connexion par device code, l'API de l'agent échange le jeton on-behalf-of avec un certificat sans secret ; un scope non consenti échoue.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/fr/entra-on-behalf-of-agent-middle-tier.png?v=986e5733" alt="" /></p><p><strong>En bref</strong></p>
<ul>
<li>Pour les agents qui appellent des API au nom d'un utilisateur connecté, la réponse actuelle d'Entra est le flux on-behalf-of (OBO) ; ID-JAG n'y est aujourd'hui qu'une enquête de disponibilité.</li>
<li>La middle API se prouve avec une assertion signée par certificat et ne détient aucun secret client.</li>
<li>Une connexion produit des jetons distincts par audience : l'utilisateur reste le même et l'application appelante change.</li>
<li>Un scope sans consentement échoue avec AADSTS65001 ; c'est le consentement sur le service principal qui compte.</li>
<li>Les jetons OBO ne conservent pas le client d'origine, les audits doivent donc croiser les journaux de connexion.</li>
</ul>
<p>Le 14 novembre 2026, Microsoft a ajouté un article Learn qui nomme pour la première fois <a href="https://iamops.dev/fr/id-jag-explained/">ID-JAG</a> à côté de Microsoft Entra Agent ID et ouvre un formulaire de manifestation d'intérêt. C'est une enquête de disponibilité, pas une fonction livrée : Entra n'émet ni n'accepte aujourd'hui d'ID-JAG. Pour les agents qui doivent appeler des API pour un utilisateur connecté, la réponse actuelle d'Entra est le flux on-behalf-of (OBO). Je l'ai exécuté de bout en bout dans un tenant jetable et j'ai noté ce que fait chaque étape.</p>
<h2>Ce que montre le laboratoire</h2>
<p>Trois inscriptions d'applications représentent un système d'agents :</p>
<table>
<thead>
<tr>
<th>Application</th>
<th>Rôle</th>
<th>Identifiant</th>
</tr>
</thead>
<tbody>
<tr>
<td>Client</td>
<td>L'interface ou la ligne de commande de l'agent. Client public, connexion par device code.</td>
<td>Aucun</td>
</tr>
<tr>
<td>Agent Middle API</td>
<td>Le back-end de l'agent. Il effectue l'échange OBO.</td>
<td>Un certificat X.509, <strong>zéro secret client</strong></td>
</tr>
<tr>
<td>Resource API</td>
<td>L'API en aval. Expose le scope délégué <code>Data.Read</code>.</td>
<td>s. o.</td>
</tr>
</tbody>
</table>
<p>L'utilisateur se connecte une fois au Client. Le Client détient un jeton dont l'audience est la seule middle API. La middle API l'échange contre un jeton pour la Resource API et un autre pour Microsoft Graph, en prouvant son identité par une assertion signée avec un certificat plutôt que par un secret.</p>
<h2>Mise en place</h2>
<p>Utilisez un <strong>tenant de test séparé</strong> (Entra ID Free suffit, aucune ressource Azure n'est nécessaire). Les jetons OBO portent de vrais claims d'utilisateur, et un tenant jetable tient les expériences à l'écart du consentement, de l'accès conditionnel et des journaux d'audit de production. Dans le portail :</p>
<ol>
<li>Inscrivez la Resource API et exposez un scope délégué <code>Data.Read</code> (administrateurs et utilisateurs).</li>
<li>Inscrivez l'Agent Middle API, exposez <code>access_as_user</code> et ajoutez les autorisations déléguées <code>Data.Read</code> et Microsoft Graph <code>User.Read</code>, puis accordez le consentement administrateur.</li>
<li>Générez avec <code>openssl</code> une clé RSA de 2048 bits et un certificat autosigné de 60 jours, gardez la clé privée sur la machine (mode 0600) et ne téléversez que le certificat public sous <em>Certificates &amp; secrets</em>.</li>
<li>Inscrivez le Client comme client public (redirection <code>http://localhost</code>, <em>Allow public client flows</em> activé) avec l'autorisation pour <code>access_as_user</code> et <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="Sortie du terminal d'openssl montrant le sujet du certificat et l'empreinte SHA-1, remplacée par un espace réservé." width="1894" height="301" loading="lazy" decoding="async"><figcaption><strong>L'identifiant.</strong> Un certificat autosigné est le seul identifiant de la middle API. L'empreinte est remplacée par un espace réservé ; la clé privée n'est jamais montrée.</figcaption></figure>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/11-no-secrets.webp" alt="Centre d'administration Microsoft Entra, page Certificates and secrets de l'Agent Middle API avec l'onglet Client secrets ouvert, montrant zéro secret client." width="1280" height="665" loading="lazy" decoding="async"><figcaption><strong>Aucun secret.</strong> L'onglet Client secrets affiche 0. Un certificat prouve la possession d'une clé qui ne voyage jamais ; un secret est une chaîne réutilisable qui finit dans la configuration et les journaux.</figcaption></figure>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/08-permissions.webp" alt="Centre d'administration Microsoft Entra, API permissions de l'Agent Middle API : User.Read pour Microsoft Graph et Data.Read pour la Resource API, tous deux délégués et accordés pour l'annuaire." width="1280" height="665" loading="lazy" decoding="async"><figcaption><strong>Ce que la couche intermédiaire peut demander.</strong> Entra vérifie ces autorisations déléguées au moment de l'échange. Ce qui n'est pas listé et consenti ne peut pas être obtenu en aval.</figcaption></figure>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/17-consent.webp" alt="Centre d'administration Microsoft Entra, Enterprise applications, Permissions du service principal de l'Agent Middle API, avec le consentement administrateur pour User.Read et Data.Read." width="1280" height="665" loading="lazy" decoding="async"><figcaption><strong>Ce qu'elle a réellement obtenu.</strong> Les inscriptions montrent ce qu'une application demande ; les autorisations du service principal montrent ce qui lui a été donné. Les outils de gouvernance devraient lire ces dernières.</figcaption></figure>
<h2>Le déroulement</h2>
<p><strong>Connexion par <a href="https://iamops.dev/fr/device-code-phishing-ai-agents/">device code</a>.</strong> Le Client demande un code au point de terminaison <code>devicecode</code> v2.0. La requête ne porte que l'ID du Client et le scope de la middle API, aucun secret. L'utilisateur saisit le code sur un second appareil et Entra affiche un contrôle « approuver la connexion sur un autre appareil » qui nomme l'application et le lieu ; l'utilisateur doit l'approuver à la main.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/18-devicecode.webp" alt="Sortie du terminal de la demande d'autorisation d'appareil et de sa réponse, avec tenant, ID de client et code utilisateur remplacés par des espaces réservés." width="1894" height="530" loading="lazy" decoding="async"><figcaption><strong>Autorisation d'appareil.</strong> Les identifiants et le code utilisateur sont des espaces réservés.</figcaption></figure>
<p><strong>Le jeton utilisateur.</strong> Après l'approbation, le Client interroge le point de terminaison des jetons. Son jeton est inutilisable directement contre la Resource API ou Graph, car son audience est la middle API.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/24-user-token.webp" alt="Claims décodés du jeton utilisateur : l'audience est la middle API, appid est le Client, le scope est access_as_user. Identifiants et nom de l'utilisateur remplacés par des espaces réservés." width="1894" height="607" loading="lazy" decoding="async"><figcaption><strong>Le seul jeton du Client.</strong> Audience : la middle API. Application : le Client. Scope : access_as_user.</figcaption></figure>
<p><strong>L'échange.</strong> La middle API construit une assertion client (un JWT RS256 avec l'empreinte du certificat dans <code>x5t</code> ; émetteur et sujet sont son propre ID de client ; audience : le point de terminaison des jetons ; dix minutes de validité), la signe avec la clé privée et envoie la requête OBO :</p>
<pre><code class="language-text">POST https://login.microsoftonline.com/&lt;tenant-id&gt;/oauth2/v2.0/token
  grant_type=urn:ietf:params:oauth:grant-type:jwt-bearer
  client_id=&lt;middle-api-id&gt;
  client_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearer
  client_assertion=&lt;RS256 JWT with x5t in the header&gt;
  assertion=&lt;the user token&gt;
  scope=api://&lt;resource-api-id&gt;/Data.Read
  requested_token_use=on_behalf_of
</code></pre>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/25-obo-resource.webp" alt="Claims décodés du jeton OBO pour la Resource API : l'audience est la Resource API, appid la middle API, scope Data.Read, même identifiant d'objet de l'utilisateur. Identifiants remplacés par des espaces réservés." width="1894" height="607" loading="lazy" decoding="async"><figcaption><strong>Jeton pour la Resource API.</strong> Audience : la Resource API. Application : la middle API. Scope : Data.Read. Même utilisateur.</figcaption></figure>
<p>La même assertion avec le scope <code>https://graph.microsoft.com/User.Read</code> renvoie un jeton Graph, que le laboratoire utilise une fois pour <code>GET /v1.0/me</code>.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/26-obo-graph.webp" alt="Claims décodés du jeton OBO pour Microsoft Graph et réponse de l'appel Graph me, avec nom et nom principal de l'utilisateur remplacés par des espaces réservés." width="1894" height="721" loading="lazy" decoding="async"><figcaption><strong>Jeton pour Microsoft Graph, puis appel de /me.</strong> Une seule connexion se ramifie en plusieurs jetons liés chacun à une audience. Nom et nom principal de l'utilisateur sont des espaces réservés.</figcaption></figure>
<p><strong>Comparer les trois jetons.</strong> L'utilisateur ne change jamais. L'audience suit l'API appelée et <code>appid</code> passe du Client à la 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="Tableau côte à côte de l'audience, d'appid, du scope, de l'identifiant d'objet et de l'ID de tenant pour le jeton utilisateur et les deux jetons OBO. Identifiants remplacés par des espaces réservés." width="1894" height="416" loading="lazy" decoding="async"><figcaption><strong>Trois jetons côte à côte.</strong> Même utilisateur et même tenant ; l'audience et l'application appelante changent à chaque étape.</figcaption></figure>
<p><strong>Le test négatif.</strong> Demander <code>https://graph.microsoft.com/Mail.Read</code>, auquel personne n'a consenti, échoue au service de jetons :</p>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/28-negative.webp" alt="Sortie du terminal d'une erreur invalid_grant AADSTS65001 : l'utilisateur ou l'administrateur n'a pas consenti à l'utilisation de l'application. ID d'application, ID de trace et ID de corrélation remplacés par des espaces réservés." width="1894" height="416" loading="lazy" decoding="async"><figcaption><strong>AADSTS65001.</strong> Le consentement est vérifié au moment du jeton sur le service principal de la couche intermédiaire. Pour un agent non interactif, il n'y a pas de repli vers une invite interactive.</figcaption></figure>
<h2>Pièges</h2>
<ul>
<li><strong>Le client d'origine est perdu.</strong> Les jetons OBO v1 ne conservent que la dernière application (<code>appid</code>). Il n'y a pas de claim <code>act</code> comme dans une implémentation de la RFC 8693 ; un audit doit donc joindre les journaux de connexion pour reconstituer la chaîne.</li>
<li><strong>L'audience entrante doit être la middle API.</strong> Un jeton destiné à une autre application est rejeté : c'est la protection contre le confused deputy.</li>
<li><strong>Le device code exige « Allow public client flows ».</strong> C'est aussi le flux qu'exploite le device code phishing. L'écran « approuver la connexion sur un autre appareil » est la parade de Microsoft ; apprenez aux utilisateurs à appuyer sur « Ce n'était pas moi » et restreignez le flux par accès conditionnel là où les agents n'en ont pas besoin.</li>
<li><strong>Seul compte le consentement administrateur sur le service principal</strong>, pas ce que liste l'inscription.</li>
</ul>
<h2>Enseignements de sécurité</h2>
<ol>
<li>Utilisez un certificat ou un identifiant fédéré pour la couche intermédiaire. Pas de secret, c'est rien de réutilisable à laisser fuiter depuis la configuration, les variables de CI ou les journaux.</li>
<li>Gardez minimaux les scopes délégués de la couche intermédiaire et vérifiez-les sur le service principal.</li>
<li>Laissez le Client sans identifiant. Il ne pourra jamais détenir que le jeton de l'utilisateur pour la middle API, jamais un jeton en aval.</li>
<li>Prévoyez la jointure d'audit (utilisateur, agent, audience en aval), car les jetons OBO ne gardent pas le premier maillon.</li>
<li>Consignez quelle autorisation chaque étape utilise (OBO aujourd'hui ; ID-JAG quand Entra le prendra en charge) et où se trouve le consentement, pour que les revues d'accès voient les autorisations des service principals.</li>
</ol>
<h2>Ce qui n'a pas été exécuté</h2>
<p>Les blueprints et identités d'agent d'Entra Agent ID (le même laboratoire avec autorisations héritables) n'ont pas été exécutés. La stratégie d'accès conditionnel qui bloque le device code n'a pas été testée. Les exercices complémentaires (retirer le consentement et répéter l'échange, claims facultatifs, jetons v2) n'ont pas été exécutés. Les captures du portail sont recadrées sur le contenu de la page : la barre du navigateur, le menu de profil et tous les identifiants de tenant, d'applications et d'utilisateurs sont supprimés. Aucun enregistrement n'est publié pour ce laboratoire.</p>
<p><em>Les images du terminal ont été générées à partir de la sortie enregistrée de l'exécution, avec les identifiants remplacés par des espaces réservés. Les captures du portail ne montrent que le contenu de la page.</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>OAuth Token Exchange avec Keycloak (RFC 8693) : restreindre les jetons pour agents d'IA et serveurs MCP</title>
      <link>https://iamops.dev/fr/keycloak-token-exchange-rfc-8693/</link>
      <guid isPermaLink="true">https://iamops.dev/fr/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>Agents d'IA</category>
      <description>Lab Keycloak : un serveur MCP échange le jeton de l'utilisateur contre un jeton plus restreint pour une API en aval ; trois échanges invalides sont refusés.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/fr/keycloak-token-exchange-rfc-8693.png?v=986e5733" alt="" /></p><p><strong>En bref</strong></p>
<ul>
<li>L'échange de jetons RFC 8693 permet à un serveur MCP de remplacer le jeton de l'utilisateur par un jeton plus restreint, destiné à une seule API en aval.</li>
<li>Dans Keycloak, il s'active par client, et l'audience en aval est un scope facultatif.</li>
<li>Le jeton échangé garde l'utilisateur comme sujet, n'a que l'audience en aval, dure 300 secondes et ne contient pas de jeton d'actualisation.</li>
<li>Trois échanges invalides sont refusés : un client sans le privilège, une audience sans scope et la demande d'un jeton d'actualisation.</li>
<li>Il n'y a pas de claim act dans cette configuration ; le client agissant n'apparaît que comme authorized party.</li>
</ul>
<p>Le 12 novembre 2026, Amazon Cognito a ajouté OAuth 2.0 Token Exchange (RFC 8693), quelques jours après WorkOS Connect. Entra propose depuis des années son propre flux on-behalf-of. Le schéma est désormais commun aux grands fournisseurs d'identité : un service qui agit pour un utilisateur échange le jeton de celui-ci contre un nouveau jeton plus restreint, lié à un seul destinataire (audience) et de courte durée, au lieu de transmettre l'original. Je l'ai essayé sur un Keycloak local et j'ai noté ce que faisait le serveur.</p>
<p>Ce laboratoire exécute ce schéma sur un ordinateur portable avec Keycloak, un serveur d'autorisation open source, afin de voir exactement ce qui change dans le jeton et ce que le serveur refuse.</p>
<h2>Ce que montre le laboratoire</h2>
<p>Un agent d'IA connecte l'utilisateur et détient un jeton pour un <a href="https://iamops.dev/fr/mcp-server-no-token-passthrough/">serveur MCP</a>. Le serveur MCP doit appeler une API de paiement pour cet utilisateur, sans transmettre le jeton de l'agent. Il le présente donc au serveur d'autorisation et demande un jeton valable uniquement pour l'API de paiement.</p>
<p>Le laboratoire utilise trois clients dans un realm :</p>
<table>
<thead>
<tr>
<th>Client</th>
<th>Rôle</th>
<th>Peut échanger des jetons ?</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>agent</code></td>
<td>Obtient le jeton de l'utilisateur (password grant, simple raccourci de laboratoire)</td>
<td>Non</td>
</tr>
<tr>
<td><code>mcp-server</code></td>
<td>Échange le jeton de l'utilisateur</td>
<td>Oui</td>
</tr>
<tr>
<td><code>payments-api</code></td>
<td>Simple audience, l'API en aval</td>
<td>Non</td>
</tr>
</tbody>
</table>
<h2>Mise en place</h2>
<p>Keycloak 26.8.2 a tourné depuis la distribution zip avec Java 21, en mode développement, après une extraction toute neuve. Le mode développement ne sert qu'aux laboratoires. Les mots de passe sont des valeurs jetables ; ils apparaissent ici sous la forme <code>&lt;lab-password&gt;</code> et <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="Sortie du terminal du script de mise en place qui crée le realm agentlab, un utilisateur, trois clients et deux client scopes, avec les identifiants remplacés par des espaces réservés entre chevrons." width="1894" height="492" loading="lazy" decoding="async"><figcaption><strong>Mise en place.</strong> Le script crée le realm, un utilisateur de test, les trois clients et deux client scopes qui ajoutent des audiences. Les identifiants d'objets sont remplacés par des espaces réservés.</figcaption></figure>
<p>Dans la console d'administration, deux réglages portent la conception. Seul <code>mcp-server</code> a <strong>Standard Token Exchange</strong> activé, et l'audience en aval est un scope <em>optionnel</em> : elle n'est ajoutée que si l'échange la demande.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/keycloak-token-exchange-rfc-8693/05-exchange-toggle.webp" alt="Console d'administration Keycloak, configuration des capacités du client mcp-server, avec la case Standard Token Exchange cochée." width="1600" height="960" loading="lazy" decoding="async"><figcaption><strong>Le privilège.</strong> Standard Token Exchange n'est coché que sur le client mcp-server. Un client agent compromis ne peut pas émettre de jetons pour d'autres API.</figcaption></figure>
<figure class="b-fig"><img src="https://iamops.dev/media/keycloak-token-exchange-rfc-8693/06-client-scopes.webp" alt="Console d'administration Keycloak, client scopes du client mcp-server, avec le scope aud-payments-api indiqué comme Optional." width="1600" height="960" loading="lazy" decoding="async"><figcaption><strong>L'audience.</strong> aud-payments-api est optionnel pour mcp-server : l'audience en aval doit donc être demandée explicitement.</figcaption></figure>
<h2>Le déroulement</h2>
<p>L'agent obtient un jeton utilisateur, puis le serveur MCP l'échange. La requête centrale est un unique appel au point de terminaison des jetons :</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="Sortie du terminal comparant le jeton utilisateur décodé et le jeton échangé. L'audience passe de mcp-server et account à payments-api, azp passe de agent à mcp-server, expires_in vaut 300, sans jeton d'actualisation ni claim act." width="1894" height="1027" loading="lazy" decoding="async"><figcaption><strong>Avant et après.</strong> Même utilisateur, nouvelle audience (payments-api), nouvelle partie autorisée (mcp-server), 300 secondes de validité, pas de jeton d'actualisation. L'identifiant de l'utilisateur est remplacé par un espace réservé.</figcaption></figure>
<p>Comparez les deux jetons : le sujet est inchangé, l'audience est désormais uniquement l'API de paiement, la partie autorisée (<code>azp</code>) désigne le serveur MCP, la durée de vie est de 300 secondes et aucun jeton d'actualisation n'est renvoyé. Il n'y a <strong>pas de claim <code>act</code></strong> : la prise en charge de la délégation par Keycloak est une fonction en préversion, désactivée par défaut ; l'acteur n'apparaît donc que sous la forme <code>azp</code>.</p>
<h2>Faire échouer exprès</h2>
<p>Trois échanges doivent être refusés. Testez les trois mêmes cas chez n'importe quel fournisseur d'identité avant de lui confier la délégation pour des agents.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/keycloak-token-exchange-rfc-8693/08-negative.webp" alt="Sortie du terminal de trois échanges refusés : un client sans token exchange activé, une audience pour laquelle le serveur MCP n'a pas de scope, et la demande d'un jeton d'actualisation ; chacun renvoie invalid_request." width="1894" height="874" loading="lazy" decoding="async"><figcaption><strong>Trois refus.</strong> A : un client sans le privilège d'échange. B : une audience pour laquelle le serveur MCP n'a pas de scope. C : un jeton d'actualisation. Tous renvoient invalid_request. Les secrets de client sont remplacés par des espaces réservés.</figcaption></figure>
<h2>Pièges</h2>
<ul>
<li><strong>Le password grant est un raccourci.</strong> Le laboratoire ne l'utilise que pour obtenir vite un jeton utilisateur. La RFC 9700 et OAuth 2.1 l'écartent pour les vrais clients ; utilisez le flux authorization code avec <a href="https://iamops.dev/fr/tools/pkce/">PKCE</a>.</li>
<li><strong>Le claim <code>aud</code> peut lister plus que prévu.</strong> L'introspection du jeton échangé a montré l'API de paiement et <code>account</code>. Comprenez-le avant de vous reposer sur des contrôles d'audience.</li>
<li><strong>L'ordre des scopes varie</strong> d'une exécution à l'autre ; ne comparez donc pas les chaînes de scopes à la lettre.</li>
<li><strong>Pas de claim <code>act</code> par défaut.</strong> Si votre audit a besoin de l'acteur, prévoyez la fonction de délégation en préversion ou reliez vous-même <code>azp</code> dans les journaux.</li>
</ul>
<h2>Enseignements de sécurité</h2>
<ol>
<li>L'échange de jetons est un privilège. Accordez-le au seul client qui en a besoin.</li>
<li>Rendez l'audience en aval explicite et optionnelle, pour que les jetons échangés restent étroits par défaut.</li>
<li>Ne délivrez jamais de jeton d'actualisation dans un échange. Le serveur du laboratoire les refuse.</li>
<li>Un service doit rejeter les jetons qui ne lui sont pas destinés et échanger pour chaque API en aval, sans jamais transmettre le jeton de l'utilisateur.</li>
<li>Vérifiez ce que votre piste d'audit peut reconstituer. Si l'acteur n'apparaît que sous <code>azp</code>, une ligne de journal doit relier utilisateur, agent et audience en aval.</li>
</ol>
<h2>Ce qui n'a pas été exécuté</h2>
<p>La variante Docker, les exercices complémentaires (jetons d'actualisation dans l'échange standard, introspection par l'API en aval) et la fonction de délégation en préversion qui ajouterait <code>act</code> n'ont pas été exécutés. Le laboratoire n'a utilisé que des comptes jetables. Aucun enregistrement n'est publié pour ce laboratoire.</p>
<p><em>Les images du terminal ont été générées à partir de la sortie enregistrée de l'exécution, avec identifiants et secrets remplacés par des espaces réservés. Les captures de la console Keycloak ne montrent que des objets de test.</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>Protéger un serveur MCP avec OAuth : refuser le token passthrough et échanger pour chaque API en aval</title>
      <link>https://iamops.dev/fr/mcp-server-no-token-passthrough/</link>
      <guid isPermaLink="true">https://iamops.dev/fr/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>Agents d'IA</category>
      <description>Lab avec le SDK Python de MCP et Keycloak : handshake 401, contrôle d'audience, échange RFC 8693 pour l'API de paiement et passthrough refusé par le serveur.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/fr/mcp-server-no-token-passthrough.png?v=986e5733" alt="" /></p><p><strong>En bref</strong></p>
<ul>
<li>Un serveur MCP est un serveur de ressources OAuth : il répond 401 avec les Protected Resource Metadata pour que les clients trouvent le serveur d'autorisation.</li>
<li>Il fait l'introspection de chaque jeton porteur et refuse celui dont l'audience n'inclut pas le serveur MCP lui-même.</li>
<li>Pour une API en aval, il échange le jeton (RFC 8693) au lieu de transmettre celui de l'appelant.</li>
<li>Un passthrough délibéré échoue : le jeton pour l'API de paiement est inactif pour le serveur MCP, qui répond 401.</li>
<li>Journalisez l'utilisateur, le client de l'agent et l'audience en aval sur une seule ligne pour que les audits suivent la chaîne.</li>
</ul>
<p>Le 10 novembre 2026, WorkOS a ajouté l'échange de jetons (RFC 8693) à WorkOS Connect pour qu'un serveur MCP puisse appeler des API en aval pour un utilisateur sans transmettre le jeton de celui-ci. C'est le schéma qu'attend la spécification d'autorisation MCP. Je l'ai construit à la main avec le SDK Python officiel, pour voir chaque règle à l'œuvre.</p>
<p>Il prolonge le <a href="https://iamops.dev/fr/keycloak-token-exchange-rfc-8693/">laboratoire d'échange de jetons avec Keycloak</a> : même realm, mêmes trois clients.</p>
<h2>Ce que montre le laboratoire</h2>
<p>Un serveur MCP écrit avec le SDK Python officiel (<code>mcp</code> 2.3.0) joue le rôle de <em>serveur de ressources</em> OAuth pour un realm Keycloak. Il fait quatre choses :</p>
<ol>
<li>Il répond à une requête sans jeton par <code>401</code> et un renvoi vers ses Protected Resource Metadata (RFC 9728), si bien qu'un client trouve le serveur d'autorisation sans l'avoir en configuration.</li>
<li>Il vérifie chaque jeton porteur par introspection auprès de Keycloak et refuse les jetons dont l'audience n'inclut pas le serveur MCP lui-même.</li>
<li>Pour un outil, il échange le jeton de l'appelant contre un jeton destiné à l'API de paiement (RFC 8693) au lieu de le transmettre.</li>
<li>Il refuse un jeton émis pour l'API de paiement quand quelqu'un le présente au serveur MCP (une tentative de passthrough).</li>
</ol>
<p>Le vérificateur est court. La ligne décisive est le contrôle de l'audience :</p>
<pre><code class="language-python">data = introspect(token)            # RFC 7662, as the mcp-server client
aud = data.get(&quot;aud&quot;, [])
aud = [aud] if isinstance(aud, str) else aud
if not data.get(&quot;active&quot;) or &quot;mcp-server&quot; not in aud:
    return None                     # inactive, or minted for another API: no passthrough
</code></pre>
<h2>Le déroulement</h2>
<p>Figez la version du SDK : <code>mcp</code> 2.x a renommé <code>FastMCP</code> en <code>MCPServer</code>, et les SDK changent leurs classes d'authentification d'une version à l'autre. Le serveur écoute sur <code>127.0.0.1:8001</code>.</p>
<p><strong>Sans jeton.</strong> La première requête est le handshake de découverte par lequel commence tout client MCP : un <code>401</code> dont l'en-tête <code>WWW-Authenticate</code> porte une URL <code>resource_metadata</code>, et un document de métadonnées qui désigne le realm comme serveur d'autorisation.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/mcp-server-no-token-passthrough/03-no-token.webp" alt="Sortie du terminal : une requête sans jeton renvoie 401 Unauthorized avec un en-tête www-authenticate qui pointe vers les métadonnées de la ressource protégée ; le document de métadonnées désigne le realm Keycloak comme serveur d'autorisation." width="1894" height="530" loading="lazy" decoding="async"><figcaption><strong>Le handshake 401.</strong> Le client apprend où obtenir un jeton grâce au document de métadonnées, pas grâce à la configuration.</figcaption></figure>
<p><strong>Avec un jeton.</strong> Un petit script obtient un jeton utilisateur pour le client <code>agent</code>, ouvre une session MCP et appelle les deux outils. <code>whoami</code> montre que le serveur voit l'utilisateur à travers le client agent ; <code>downstream_token</code> montre le serveur qui échange le jeton contre un jeton limité à l'API de paiement.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/mcp-server-no-token-passthrough/04-call.webp" alt="Sortie du terminal des deux appels d'outils : whoami renvoie le sujet, le client agent et ses scopes ; downstream_token renvoie un jeton d'audience payments-api et de partie autorisée mcp-server. Le sujet est remplacé par un espace réservé." width="1894" height="683" loading="lazy" decoding="async"><figcaption><strong>Deux outils.</strong> Le premier montre qui a appelé. Le second montre le jeton échangé : audience payments-api, partie autorisée mcp-server, même sujet. Le sujet est un espace réservé.</figcaption></figure>
<p>Le même appel fonctionne avec le client en ligne de commande MCP Inspector, la façon standard de reproduire ce que ferait n'importe quel hôte MCP. Figez sa version dans les scripts ; ce laboratoire a utilisé la 2.15.0.</p>
<p><strong>La tentative de passthrough.</strong> Créez un jeton échangé tout neuf, regardez-le en introspection des deux côtés, puis présentez-le au serveur MCP.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/mcp-server-no-token-passthrough/06-passthrough.webp" alt="Sortie du terminal : l'introspection indique le jeton comme actif pour le client payments-api et inactif pour le client mcp-server ; le présenter au serveur MCP renvoie 401." width="1894" height="492" loading="lazy" decoding="async"><figcaption><strong>Pas de passthrough.</strong> Keycloak ne signale le jeton comme actif qu'au client pour lequel il a été émis. Le serveur MCP répond 401. Les secrets de client sont des espaces réservés.</figcaption></figure>
<h2>Pièges</h2>
<ul>
<li><strong>Introspection ou validation locale ?</strong> Le laboratoire utilise l'introspection : révocation immédiate, au prix d'un aller-retour vers le serveur d'autorisation. L'alternative est la validation locale du JWT avec les clés JWKS ; notez ce que l'on perd et ce que l'on gagne.</li>
<li><strong>Contrôlez l'audience, pas seulement la signature.</strong> Un jeton valable pour une autre API reste le mauvais jeton. C'est le contrôle d'audience qui transforme le passthrough en <code>401</code>.</li>
<li><strong>Les jetons vivent cinq minutes</strong> dans cette configuration : générez le jeton de passthrough juste avant le test.</li>
<li><strong>Dérive des SDK.</strong> Les noms de classes et les points d'accroche d'authentification ont bougé entre versions majeures ; testez avec la version que vous livrez.</li>
</ul>
<h2>Enseignements de sécurité</h2>
<ol>
<li>Un serveur MCP est un serveur de ressources OAuth. Il publie des métadonnées, valide l'audience et refuse tout ce qui ne lui est pas destiné.</li>
<li>Ne transmettez jamais le jeton de l'appelant à une API en aval. Échangez-le pour chaque audience en aval, plus étroit et de courte durée.</li>
<li>Laissez le serveur d'autorisation décider qui voit un jeton comme actif. Un jeton qui ne fonctionne que pour son destinataire limite ce qu'un maillon compromis peut faire.</li>
<li>Journalisez une ligne qui relie utilisateur, client agent et audience en aval ; le jeton seul ne raconte pas toute l'histoire à un auditeur.</li>
</ol>
<h2>Ce qui n'a pas été exécuté</h2>
<p>Le flux OAuth de l'interface web de MCP Inspector n'a pas été exécuté (le client <code>agent</code> du laboratoire autorise pour cela une redirection vers localhost). L'enregistrement dynamique de clients n'a pas été utilisé ; le client est préenregistré. Tout a tourné sur une seule machine avec des comptes jetables. Aucun enregistrement n'est publié pour ce laboratoire.</p>
<p><em>Les images du terminal ont été générées à partir de la sortie enregistrée de l'exécution, avec identifiants, secrets et horodatages remplacés par des espaces réservés.</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>Un agent d'IA autonome sans secret sur Azure : appeler une API avec une identité managée depuis Container Apps</title>
      <link>https://iamops.dev/fr/secretless-agent-managed-identity-container-app/</link>
      <guid isPermaLink="true">https://iamops.dev/fr/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>Identité managée</category>
      <category>Entra ID</category>
      <category>Agents d'IA</category>
      <category>Identité de workload</category>
      <category>Azure</category>
      <description>Lab : un agent Container Apps avec identité managée et sans secret reçoit un seul rôle étroit, obtient un jeton app-only et l'API le valide.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/fr/secretless-agent-managed-identity-container-app.png?v=986e5733" alt="" /></p><p><strong>En bref</strong></p>
<ul>
<li>Un agent autonome qui ne détient aucun secret n'a rien à laisser fuiter : une Container App avec identité managée affectée à l'utilisateur, sans secret client, ni certificat, ni ingress.</li>
<li>L'identité démarre sans rôle ; avec l'attribution obligatoire sur l'API, la demande de jeton est refusée (AADSTS501051) tant qu'un seul rôle étroit n'est pas accordé.</li>
<li>Le jeton app-only contient roles et pas scp, et l'API valide quand même signature, audience, émetteur et rôle.</li>
<li>Les jetons sont mis en cache environ 24 heures : retirer un rôle n'est donc pas une révocation immédiate.</li>
<li>Traitez l'identité comme un compte privilégié : un responsable, une date de revue et une alerte sur les attributions de rôles.</li>
</ul>
<p>Le 5 novembre 2026, Microsoft Threat Intelligence a décrit des attaquants qui utilisent un framework offensif à base d'agents pour chercher des secrets exposés dans des dépôts publics, puis se connectent comme des charges de travail avec des identifiants d'application valides. La lecture défensive est simple : un agent autonome qui ne détient aucun secret n'a rien à laisser fuiter. J'en ai construit un sur Azure et j'ai vérifié chaque affirmation.</p>
<h2>Ce que montre le laboratoire</h2>
<p>Un petit agent s'exécute comme Azure Container App. Il n'a ni utilisateur, ni secret client, ni certificat. Son identité est une <strong>identité managée affectée à l'utilisateur</strong> qui démarre sans aucun rôle. Le laboratoire :</p>
<ol>
<li>Attache l'identité à l'application et prouve que le conteneur ne détient aucun secret.</li>
<li>Fait exiger par l'API en aval (la <em>Resource API</em>, une inscription d'application) une attribution de rôle d'application.</li>
<li>Montre la demande de jeton refusée, puis accorde <strong>un seul</strong> rôle app-only étroit.</li>
<li>Lit le jeton app-only que l'agent obtient et le vérifie comme le ferait l'API.</li>
</ol>
<h2>Mise en place</h2>
<p>Utilisez un tenant et un abonnement de test séparés. L'agent tourne à 0,25 vCPU et 0,5 GiB sur le plan Consommation, sans ingress et sans espace de travail Log Analytics. Les 180 000 premières vCPU-secondes par mois sont gratuites, ce que cette taille épuise en environ 200 heures d'exécution : supprimez donc l'application quand vous avez fini. L'identité managée et le rôle d'application sont gratuits.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/01-context.webp" alt="Sortie du terminal : l'Azure CLI affiche l'abonnement et le tenant, l'identité managée avec son ID de client et son ID de principal, et zéro attribution de rôle. Les identifiants sont des espaces réservés." width="1894" height="683" loading="lazy" decoding="async"><figcaption><strong>Partir de zéro.</strong> L'identité managée n'a aucune attribution de rôle ; chaque autorisation du laboratoire est donc une concession délibérée et visible. Les identifiants sont des espaces réservés.</figcaption></figure>
<p>L'application est définie en YAML. L'image est publique et ne sert que pour son Python, donc aucun identifiant de registre n'est nécessaire. Le bloc identity attache l'identité managée. Il n'y a pas de section <code>ingress</code> : personne ne peut appeler de l'extérieur.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/03-app-definition.webp" alt="Sortie du terminal de la définition de l'application : emplacement, bloc identity affecté à l'utilisateur, ID de l'environnement, image publique de conteneur, ressources de 0,25 vCPU et 0,5 GiB et ID de client en variable d'environnement. Les ID sont des espaces réservés." width="1894" height="874" loading="lazy" decoding="async"><figcaption><strong>Rien à voler.</strong> Tout ce qu'un attaquant pourrait tirer de cette définition est public : un nom d'image, un ID de client et le code. Les ID d'abonnement et de client sont des espaces réservés.</figcaption></figure>
<h2>Le déroulement</h2>
<p><strong>Le conteneur détient un point de terminaison d'identité, pas un secret.</strong> La plateforme injecte <code>IDENTITY_ENDPOINT</code>, une URL localhost, et <code>IDENTITY_HEADER</code>, une valeur propre au conteneur (masquée dans la sortie). Aucune autre variable ne ressemble à un secret et aucun volume de secrets n'est monté.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/05-secretless.webp" alt="Sortie du terminal depuis l'intérieur du conteneur : le point de terminaison d'identité sur localhost, l'en-tête d'identité masqué, l'ID de client public et aucune variable nommée secret, password, key ou certificate, ni volume de secrets monté." width="1894" height="454" loading="lazy" decoding="async"><figcaption><strong>Dans le conteneur.</strong> L'en-tête n'est pas un identifiant pour Entra. Il prouve seulement au point de terminaison local que l'appelant se trouve dans ce conteneur, ce qui bloque les astuces SSRF.</figcaption></figure>
<p><strong>Exiger l'attribution sur l'API.</strong> Par défaut, Entra délivre un jeton app-only à tout service principal du tenant qui le demande, avec un claim <code>roles</code> vide. Mettre <code>appRoleAssignmentRequired</code> à <code>true</code> sur le service principal de la Resource API fait refuser le jeton à quiconque n'est pas attribué :</p>
<pre><code class="language-bash">az ad sp update --id &lt;resource-sp-id&gt; --set appRoleAssignmentRequired=true
</code></pre>
<p><strong>Deux tests négatifs.</strong> La demande de jeton de l'agent pour la Resource API est refusée par le service de jetons avec AADSTS501051, et un jeton pour Graph (Graph n'exige pas d'attribution) ne contient aucun rôle, si bien que <code>GET /v1.0/users</code> renvoie <code>403</code>.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/07-refused.webp" alt="Sortie du terminal de deux refus : HTTP 400 avec AADSTS501051 indiquant que l'identité managée n'est attribuée à aucun rôle pour la Resource API, et HTTP 403 Authorization_RequestDenied de Graph. Les ID sont des espaces réservés." width="1894" height="530" loading="lazy" decoding="async"><figcaption><strong>Refusé deux fois.</strong> Le refus intervient avant l'appel de l'API et nomme l'identité managée, ce qui le rend facile à repérer lors d'une revue ou d'un incident. « Avoir un jeton » ne signifie pas « avoir l'accès ».</figcaption></figure>
<p><strong>Une concession étroite.</strong> Ajoutez à la Resource API un rôle d'application app-only <code>Data.Read.All</code> (type de membre autorisé : application) et attribuez-le à l'identité managée via Microsoft Graph. Le centre d'administration ne peut pas attribuer un rôle d'application à une identité managée ; il faut passer par Graph, PowerShell ou la CLI.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/10-assign.webp" alt="Sortie du terminal de deux appels Graph : ajout du rôle d'application Data.Read.All à la Resource API et attribution au service principal de l'identité managée. Les ID d'objet sont des espaces réservés." width="1894" height="645" loading="lazy" decoding="async"><figcaption><strong>La seule concession du laboratoire.</strong> C'est un objet Graph ordinaire qu'un outil de gouvernance ou un script peut lire.</figcaption></figure>
<p><strong>Le jeton app-only.</strong> Entra met en cache les jetons des identités managées ; le conteneur continue donc de recevoir son ancien jeton jusqu'à un jour. Redémarrer la révision en fournit un nouveau, qui contient désormais le rôle.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/13-token.webp" alt="Claims décodés du jeton app-only après le redémarrage de la révision : l'audience est la Resource API, l'application et l'ID d'objet sont l'identité managée, idtyp vaut app, roles contient Data.Read.All et il n'y a pas de claim scope. Les identifiants sont des espaces réservés." width="1894" height="759" loading="lazy" decoding="async"><figcaption><strong>Jeton app-only.</strong> Un claim <code>roles</code> sans <code>scp</code> est la façon dont une API distingue un appel app-only d'un appel délégué. Il n'y a pas d'utilisateur ; les droits de l'identité elle-même sont la seule limite.</figcaption></figure>
<p><strong>Jouer le rôle de l'API.</strong> Le jeton passe du conteneur à un fichier temporaire en mode 0600 et est détruit à la fin ; il n'est jamais affiché. Un script de validation vérifie la signature RS256 avec les clés du tenant, l'audience, l'émetteur et l'expiration, puis autorise chaque route d'après le rôle.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/15-validate.webp" alt="Sortie du terminal du contrôle côté API : GET data renvoie 200 pour le rôle Data.Read.All, POST data renvoie 403 faute du rôle Data.Write.All et un jeton aux rôles modifiés renvoie 401 car la vérification de signature échoue." width="1894" height="339" loading="lazy" decoding="async"><figcaption><strong>L'API décide quand même.</strong> La lecture est autorisée, l'écriture refusée, et un jeton aux claims modifiés échoue à la vérification de signature.</figcaption></figure>
<h2>Pièges</h2>
<ul>
<li><strong>Les jetons sont mis en cache environ 24 heures.</strong> Retirer le rôle ne suffit pas pour une révocation urgente. Redémarrez ou redéployez la charge de travail, ou désactivez l'identité.</li>
<li><strong><code>exec</code> a une limite de débit.</strong> Sans <code>--replica</code>, <code>az containerapp exec</code> peut choisir une réplique arrêtée, et les nouvelles tentatives se heurtent à HTTP 429 avec dix minutes d'attente. Désignez la réplique en cours d'exécution.</li>
<li><strong>« Assignment required » est un interrupteur à activer.</strong> Sans lui, « pouvoir obtenir un jeton » et « être autorisé » sont deux choses différentes, et chaque API doit vérifier les rôles elle-même.</li>
<li><strong>Les tenants gratuits journalisent moins.</strong> Le journal d'audit de l'annuaire montre la concession. Les journaux de connexion des identités managées exigent Entra ID P1 ou P2 et doivent être exportés vers votre SIEM.</li>
<li><strong>Supprimez le calcul quand vous avez fini.</strong> Le calcul coûte de l'argent ; l'identité et le rôle portent le risque et ont besoin d'un responsable et d'une date de revue comme tout autre compte privilégié.</li>
</ul>
<h2>Enseignements de sécurité</h2>
<ol>
<li>Une charge de travail sans secret n'a rien à laisser fuiter. Préférez les identités managées ou les identifiants fédérés aux secrets clients.</li>
<li>Partez sans rôle et ajoutez un rôle à l'étendue la plus étroite. Nommez les rôles app-only <code>*.All</code> pour que les relecteurs voient qu'il n'y a pas de limite utilisateur.</li>
<li>Exigez l'attribution sur les API internes pour que le service de jetons soit la première barrière.</li>
<li>Validez signature, audience, émetteur et rôle dans l'API. Entra ne décide que de qui obtient un jeton.</li>
<li>Traitez les identités managées qui détiennent des rôles d'application comme des comptes non humains privilégiés : responsable, recertification, une alerte sur les attributions de rôles aux service principals.</li>
</ol>
<h2>Ce qui n'a pas été exécuté</h2>
<p>Le laboratoire n'a déployé ni blueprint ni identité d'agent Entra Agent ID, où un jeton d'identité managée serait l'identifiant du blueprint. La visite du portail sur les objets obtenus a été enregistrée mais n'est pas publiée, car les vues du portail montrent des identifiants de tenant. Aucun enregistrement n'est publié pour ce laboratoire.</p>
<p><em>Les images du terminal ont été générées à partir de la sortie enregistrée de l'exécution, avec identifiants, secrets et horodatages remplacés par des espaces réservés.</em></p>
]]></content:encoded>
    </item>
  </channel>
</rss>
