<?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/es/</link>
    <description>Notas desde la práctica sobre gestión de identidades y accesos, agentes de IA y DevOps: explicaciones, labs y noticias, con fuentes.</description>
    <language>es</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/es/</link>
    </image>
    <atom:link href="https://iamops.dev/es/rss.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Imponer el downscoping en el token exchange para llamadas entre agentes</title>
      <link>https://iamops.dev/es/enforce-downscoping-token-exchange-a2a/</link>
      <guid isPermaLink="true">https://iamops.dev/es/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>Agentes de IA</category>
      <description>Lab de Keycloak para agentes A2A: el token que B obtiene para C sigue los scopes de B, no los de A, sin downscoping impuesto. Prueba, control y solución.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/es/enforce-downscoping-token-exchange-a2a.png?v=986e5733" alt="" /></p><p><strong>En resumen</strong></p>
<ul>
<li>Cuando el agente B llama al agente C en nombre del agente A, B cambia el token de A por uno nuevo. En Keycloak 26.8.2 el scope de ese token nuevo sigue los scopes de B, no el token que entregó A, salvo que impongas el downscoping.</li>
<li>En mi prueba A tenía c.read, B tenía c.write como scope opcional propio, y el intercambio de B devolvió un token para A con c.write. El agente C aceptó una escritura que A nunca concedió.</li>
<li>Es B usando un derecho que posee, no B saltándose sus límites. Con c.write retirado a B, el mismo intercambio falla con invalid_scope. Es una lección de configuración, no una vulnerabilidad.</li>
<li>Una client policy con el executor downscope-assertion-grant-enforcer limita el intercambio a los scopes de A. El agente C debería exigir también el claim act y comprobar el scope de cada skill.</li>
<li>Solo probé Keycloak. A2A 1.0.0 deja la autorización a la implementación, y la Agent Card no tiene ningún campo para el token exchange.</li>
</ul>
<p>A2A 1.0.0 es la versión actual del protocolo Agent2Agent. Exige que un servidor autentique cada petición y deja la autorización a la implementación. No dice qué pasa cuando el agente B llama al agente C en nombre del agente A. Esa parte es OAuth corriente, y la herramienta habitual es el token exchange (<a href="https://www.rfc-editor.org/rfc/rfc8693">RFC 8693</a>). Monté una cadena pequeña sobre un Keycloak local y me hice una sola pregunta: ¿el token que B obtiene para C se queda dentro de lo que A entregó?</p>
<p>No, salvo que le pidas a Keycloak que lo imponga. Este artículo trata de ese ajuste. Si has leído mi <a href="https://iamops.dev/es/keycloak-token-exchange-rfc-8693/">primer lab de token exchange con Keycloak</a>, este continúa desde la trampa «sin claim act» y añade la delegación.</p>
<h2>Qué muestra este lab</h2>
<p>Tres agentes y un servidor de autorización, todos en localhost.</p>
<ul>
<li><strong>A</strong> es quien llama. Tiene un token con scope <code>agent-b c.read</code>. Un claim <code>may_act</code> en ese token señala a B como la parte autorizada a actuar por él.</li>
<li><strong>B</strong> es un agente intermedio. Recibe la llamada de A y luego pide a Keycloak un token para llamar a C, con el token de A como <code>subject_token</code> y el suyo como <code>actor_token</code>.</li>
<li><strong>C</strong> es un pequeño agente de notas con una skill de lectura y otra de escritura. Solo acepta tokens delegados y comprueba el scope de cada skill.</li>
</ul>
<table>
<thead>
<tr>
<th>Cliente</th>
<th>Papel</th>
<th>Scopes que puede pedir en un intercambio</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>agent-a</code></td>
<td>Quien llama, service account</td>
<td><code>agent-b</code> por defecto, <code>c.read</code> si lo pide</td>
</tr>
<tr>
<td><code>agent-b</code></td>
<td>Agente intermedio, hace el intercambio</td>
<td><code>c.read</code> y <code>c.write</code>, ambos opcionales</td>
</tr>
<tr>
<td><code>agent-c</code></td>
<td>Agente de notas, solo audience</td>
<td>ninguno</td>
</tr>
</tbody>
</table>
<figure class="b-fig"><img src="https://iamops.dev/media/enforce-downscoping-token-exchange-a2a/00-flow.webp" alt="Diagrama de secuencia: el agente A lee la Agent Card de B, obtiene un token de Keycloak, llama a B, y B lo cambia por un token delegado con claim act antes de llamar a C." width="1800" height="766" loading="lazy" decoding="async"><figcaption><strong>La cadena.</strong> Los pasos 1 a 4 son A llamando a B. Los pasos 5 a 7 muestran a B convirtiendo el token de A en un token delegado. Los pasos 8 a 10 son la llamada a C.</figcaption></figure>
<p>Cada agente publica una Agent Card en <code>/.well-known/agent-card.json</code> con un esquema de seguridad <code>oauth2</code> y los scopes por skill. El esquema puede decir <code>clientCredentials</code> y nada más cercano al token exchange: un objeto <code>OAuthFlows</code> contiene exactamente un flujo, y no existe un flujo de intercambio. Por eso la card de C lo dice en el texto de su descripción, y quien llama debe leerlo.</p>
<h2>Configuración</h2>
<p>Keycloak 26.8.2 desde el zip, Java 21, modo desarrollo. El standard token exchange viene activo por defecto en la 26.8. La delegación, es decir los claims <code>act</code> y <code>may_act</code>, no. Necesita dos funciones en vista previa.</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 imprime al arrancar las funciones en vista previa activadas. Las activé juntas y no las probé una por una. Sin ellas mi cadena falla: Keycloak rechaza en un intercambio simple cualquier subject token que lleve <code>may_act</code>, con «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="Salida de terminal: Keycloak 26.8.2 arranca con las funciones en vista previa parameterized-scopes y token-exchange-delegation activadas, y luego el script del realm informa realm a2a ready." width="1894" height="301" loading="lazy" decoding="async"><figcaption><strong>Funciones y realm.</strong> Keycloak 26.8.2 con dos funciones en vista previa activas, y luego el script del realm.</figcaption></figure>
<p>El script del realm crea los tres clientes con service accounts, los scopes <code>agent-b</code>, <code>c.read</code> y <code>c.write</code> (cada uno con un audience mapper) y un mapper <code>may_act</code> fijo en <code>agent-a</code>. También activa el Standard Token Exchange para <code>agent-b</code> y da a <code>agent-b</code> los scopes <code>c.read</code> y <code>c.write</code> como client scopes opcionales. Recuerda este último punto. Todo el artículo gira en torno a él.</p>
<h2>La cadena de llamadas funciona</h2>
<p>A lee la card de B, pide a Keycloak exactamente los scopes que lista la skill y envía <code>message:send</code>. B cambia el token y llama a C. El token delegado decodificado conserva a A como <code>sub</code>, restringe <code>aud</code> a C, lleva solo <code>c.read</code> y añade <code>act</code> para B.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/enforce-downscoping-token-exchange-a2a/02-chain.webp" alt="Salida de terminal: el agente A lee la Agent Card de B, pide los scopes agent-b y c.read y recibe de B una respuesta 200 que resume dos notas guardadas por C." width="1894" height="263" loading="lazy" decoding="async"><figcaption><strong>El camino legítimo.</strong> A pide a B que resuma las notas. B cambia el token de A y las lee en C.</figcaption></figure>
<h2>El intercambio que A nunca concedió</h2>
<p>Ahora B pide <code>c.write</code>. El token de A no tiene <code>c.write</code>. Esta es la petición, con marcadores:</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 emite el token. <code>sub</code> es A, <code>act</code> señala a B, <code>scope</code> es <code>c.write</code>. C comprueba la firma, la audience, el claim <code>act</code> y el scope que exige su skill de escritura, y añade la nota.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/enforce-downscoping-token-exchange-a2a/03-stock.webp" alt="Salida de terminal en Keycloak estándar: el agente B lista c.write entre sus scopes opcionales, el token de A tiene scope agent-b c.read, el token que B obtiene para el agente C tiene scope c.write con act agent-b, y C responde que la nota se añadió." width="1894" height="1218" loading="lazy" decoding="async"><figcaption><strong>Keycloak estándar.</strong> El token de A dice c.read. El token para C dice c.write. C añade la nota. Los ids están sustituidos por marcadores.</figcaption></figure>
<p>Ejecuté toda la secuencia cuatro veces sobre un Keycloak 26.8.2 nuevo, dos con los scripts del lab y dos con los de este artículo, y obtuve el mismo resultado cada vez.</p>
<h2>El control: B posee c.write</h2>
<p>Antes de llamarlo escalada, comprobé de quién es el derecho que se usa. En mi realm B tiene <code>c.write</code> como scope opcional propio. Lo puse yo. Así que B no obtuvo algo que nunca debió tener. Quité <code>c.write</code> de los scopes opcionales de B y repetí el mismo intercambio.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/enforce-downscoping-token-exchange-a2a/04-control.webp" alt="Salida de terminal de la prueba de control: tras eliminar c.write de los client scopes opcionales del agente B, el mismo intercambio es rechazado con invalid_scope, Invalid scopes: c.write." width="1894" height="225" loading="lazy" decoding="async"><figcaption><strong>El control.</strong> Sin c.write en B no se emite nada. B se queda dentro de sus propios derechos.</figcaption></figure>
<p>Esto aclara una cosa. B no puede ir más allá de lo que posee, y no hay un bug en el sentido de una evasión. Lo que se pierde es otra cosa: el scope del token nuevo lo limita el conjunto de scopes de B y no el token de A. A había dicho «lectura», y un salto después eso ya no significaba nada. La RFC 8693 deja esa decisión al servidor: <code>scope</code> es «the desired scope of the requested security token» y sus valores son «service specific» (<a href="https://www.rfc-editor.org/rfc/rfc8693#section-2.1">sección 2.1</a>). Nada exige que el resultado sea un subconjunto del subject token.</p>
<p>Para los agentes importa porque C registra <code>sub</code> A y <code>act</code> B. Quien lee el log ve «A escribió una nota». A nunca lo aceptó.</p>
<h2>Acotar el intercambio con la política de downscope</h2>
<p>Keycloak tiene para esto un executor de client policy: <code>downscope-assertion-grant-enforcer</code>. Limita los scopes del token nuevo a los que ya están en el subject token y responde <code>invalid_scope</code> en otro caso. No necesita configuración. Lo apliqué a todos los clientes del realm con una sola política.</p>
<pre><code class="language-json">{&quot;profiles&quot;:[{&quot;name&quot;:&quot;downscope-only&quot;,&quot;description&quot;:&quot;exchange can narrow, never widen&quot;,
  &quot;executors&quot;:[{&quot;executor&quot;:&quot;downscope-assertion-grant-enforcer&quot;,&quot;configuration&quot;:{}}]}]}
</code></pre>
<p>Con <code>c.write</code> de nuevo en B y la política activa, el intercambio se rechaza. El intercambio legítimo con <code>c.read</code> sigue funcionando.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/enforce-downscoping-token-exchange-a2a/05-enforcer.webp" alt="Salida de terminal con la política de downscope activa: el intercambio con c.write se rechaza porque c.write no está en el token de acceso inicial, y el intercambio con c.read sigue devolviendo un token delegado que C acepta." width="1894" height="836" loading="lazy" decoding="async"><figcaption><strong>Con la política.</strong> c.write se rechaza porque el token de A no lo lleva. c.read sigue funcionando. C también lista la nota de la prueba estándar.</figcaption></figure>
<p>La última línea de esa salida es la nota añadida por la prueba estándar. Se queda hasta que reinicies C.</p>
<h2>Qué debe comprobar también C</h2>
<p>La política vive en el servidor de autorización. C no debería depender solo de ella.</p>
<ul>
<li>Exige el claim <code>act</code> y compara <code>act.client_id</code> con los agentes que esperas. Mi C responde 403 sin él.</li>
<li>Comprueba el scope por skill. Mi C exige <code>c.read</code> para leer y <code>c.write</code> para escribir.</li>
<li>Comprueba <code>aud</code>. Un token para B lo rechaza C con un 401.</li>
<li>No trates <code>may_act</code> como una prueba. Cuando B presentó el token de C como actor, Keycloak lo rechazó con un mensaje sobre la audience. No comprobé si compara el actor con <code>may_act</code>.</li>
</ul>
<h2>Trampas</h2>
<ul>
<li><strong>El enforcer y un audience mapper a nivel de cliente.</strong> En mi primera configuración la audience de C estaba en un mapper del cliente B. Con el enforcer activo, cada intercambio fallaba con «Requested audience not available: agent-c». Mover el mapper a los scopes <code>c.read</code> y <code>c.write</code> lo arregló. No sé por qué. Pruébalo en tu propio realm.</li>
<li><strong>La audience por scopes tiene un efecto secundario.</strong> <code>c.read</code> lleva la audience de C, así que el token de A tiene <code>aud</code> B y C. Lo que impide a A usarlo en C es el requisito de <code>act</code>, no la audience.</li>
<li><strong>El error con el actor equivocado es vago.</strong> El cliente ve <code>access_denied</code> y «Client is not within the token audience». El registro de eventos de Keycloak nombra al actor.</li>
<li><strong><code>may_act</code> es fijo en mi realm.</strong> En un sistema real debería salir de una política y viajar con el token.</li>
</ul>
<h2>Lo que no ejecuté</h2>
<p>Solo ejecuté Keycloak 26.8.2. No probé Entra on-behalf-of, Okta ni Auth0, así que no afirmo nada sobre cómo acotan el scope en un intercambio. Un solo salto de delegación: sin cadena <code>act</code> anidada. Sin tareas, streaming ni Agent Cards firmadas, sin TLS ni tokens ligados al emisor. Sin usuario en la cadena: el sujeto es el service account del agente A. Los agentes son programas Flask míos y sus client secrets son valores estáticos de laboratorio.</p>
<p><em>Las imágenes de terminal se redibujaron a partir de la salida guardada de las ejecuciones, con los ids sustituidos por marcadores. Nada de esto es una credencial real.</em></p>
<p>Para los estándares que hay detrás, mira <a href="https://iamops.dev/es/id-jag-explained/">ID-JAG explicado</a> y <a href="https://iamops.dev/es/mcp-server-no-token-passthrough/">por qué un servidor MCP no debe reenviar tokens</a>.</p>
]]></content:encoded>
    </item>
    <item>
      <title>De GitHub Actions a Azure con workload identity federation: qué runs reciben un token, y por qué</title>
      <link>https://iamops.dev/es/github-actions-azure-workload-identity-federation/</link>
      <guid isPermaLink="true">https://iamops.dev/es/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>Identidad de workload</category>
      <category>Azure</category>
      <description>Lab: un workflow de GitHub inicia sesión en Azure sin secretos. Imprimo el sub de seis tipos de run y qué credencial deja pasar a cada uno, PR incluidas.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/es/github-actions-azure-workload-identity-federation.png?v=986e5733" alt="" /></p><p><strong>En resumen</strong></p>
<ul>
<li>Un workflow de GitHub puede iniciar sesión en Azure sin client secret. GitHub firma un token de corta duración y una credencial federada de Entra confía en un único claim sub exacto.</li>
<li>Los repositorios nuevos envían un sub inmutable con los ID del propietario y del repositorio. Crea primero el repositorio, lee los ID y luego escribe la credencial.</li>
<li>Con solo una credencial para main pasó 1 de 6 tipos de run. Una credencial para el environment, otra para pull_request y dos expresiones con comodín lo dejaron en 6 de 6.</li>
<li>pull_request y pull_request_target envían el mismo sub, así que una credencial pull_request también confía en los jobs pull_request_target, que corren con secretos. Nunca hagas checkout de la head de la PR ahí.</li>
<li>No probé pull requests desde forks. Según la documentación de GitHub no reciben permisos de escritura, así que espero que no haya token, pero no lo he visto.</li>
</ul>
<p>Un pipeline de despliegue con un client secret dentro es un secreto esperando a filtrarse. GitHub Actions puede iniciar sesión en Azure sin él: GitHub firma un token OIDC de corta duración para el job y Entra confía en él mediante una credencial federada. Este año cambiaron dos cosas. Desde el 15 de julio de 2026 los repositorios nuevos reciben un <a href="https://github.blog/changelog/2026-04-23-immutable-subject-claims-for-github-actions-oidc-tokens/">claim sub inmutable</a> con los ID del propietario y del repositorio, y las credenciales con comodín de Entra siguen en preview. Reuní las dos noticias en un <a href="https://iamops.dev/es/workload-identity-news-immutable-sub-entra-wildcards-workos/">artículo</a>. Este lab es la parte práctica.</p>
<h2>Qué muestra este lab</h2>
<p>Un app registration con Reader sobre un solo resource group vacío, un repositorio privado y ningún secreto en ninguna parte. El lab:</p>
<ol>
<li>Confía en la rama main con una credencial exacta y ve que <code>azure/login</code> funciona.</li>
<li>Hace push de una rama feature, abre una pull request y ve que las dos se rechazan con AADSTS700213.</li>
<li>Permite <code>release/*</code> con una claims-matching expression.</li>
<li>Imprime el <code>sub</code> exacto de seis tipos de run y luego añade las credenciales que hacen pasar a cada uno.</li>
<li>Revisa las pull requests desde forks, solo con la documentación, porque no pude probarlas.</li>
</ol>
<h2>Preparación</h2>
<p>Usa un tenant y una suscripción de usar y tirar, y una cuenta de GitHub tuya. El app registration recibe Reader sobre un solo resource group vacío, así que un login correcto prueba la federación y nada más. Los tres ID que necesita el workflow (cliente, tenant, suscripción) no son secretos y van en variables del repositorio.</p>
<p>Crea el repositorio antes que la credencial. Un repositorio nuevo envía <code>repo:&lt;owner&gt;@&lt;owner-id&gt;/&lt;repo&gt;@&lt;repo-id&gt;:...</code>, y los dos ID solo los conoces cuando el repositorio existe. Un subject escrito a la antigua, <code>repo:&lt;owner&gt;/&lt;repo&gt;:ref:refs/heads/main</code>, ya no coincide.</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>La ejecución</h2>
<p><strong>main inicia sesión.</strong> El workflow imprime los claims que presenta GitHub, ejecuta <code>azure/login</code> y lista los resource groups. Mi primer run falló después del login con &quot;No subscriptions found&quot;, porque el rol Reader aún no se había propagado. Un minuto de espera lo resolvió.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/github-actions-azure-workload-identity-federation/01-main.webp" alt="Salida de terminal: la credencial federada gh-main con un subject exacto para la rama main, luego un run en main que termina con éxito, imprime el mismo claim sub, lista el resource group y muestra la sesión como service principal. Los ID son placeholders." width="1894" height="492" loading="lazy" decoding="async"><figcaption><strong>El sub coincide carácter a carácter.</strong> La credencial es toda la relación de confianza. No hay secreto que crear ni nada que rotar. Los ID son placeholders.</figcaption></figure>
<p><strong>Una rama feature y una pull request se rechazan.</strong> Mismo workflow, otro <code>sub</code>. Entra responde AADSTS700213 y el mensaje muestra el subject recibido, que es la forma más rápida de depurar una credencial.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/github-actions-azure-workload-identity-federation/02-feature-refused.webp" alt="Salida de terminal: un push a feature-x y una pull request terminan con fallo AADSTS700213, sin registro de identidad federada que coincida. Los subjects presentados terminan en ref:refs/heads/feature-x y pull_request. Los ID son placeholders." width="1894" height="454" loading="lazy" decoding="async"><figcaption><strong>Rechazados, a propósito.</strong> Una errata en el nombre de una rama o una pull request sin revisar no obtienen la identidad de despliegue. Los ID son placeholders.</figcaption></figure>
<p><em><em>release/</em> con una expresión.</em>* Una credencial federada flexible guarda una <code>claimsMatchingExpression</code> en lugar de un subject. Para app registrations la creé con <code>az rest</code> contra el endpoint beta de Graph. Seguí la documentación de Microsoft y fijé también <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="Salida de terminal: az rest crea la credencial gh-release con una claims-matching expression sobre el sub para ramas release y una comprobación de repository_id, luego un push a release/1 termina con éxito e imprime su sub. Los ID son placeholders." width="1894" height="492" loading="lazy" decoding="async"><figcaption><strong>Una credencial para una familia de ramas.</strong> El patrón mantiene los ID del propietario y del repositorio, y repository_id se comprueba aparte. Los ID son placeholders.</figcaption></figure>
<h2>Comprobación a fondo: el sub de cada tipo de run</h2>
<p>Un lector preguntó si el rechazo de una rama feature y de una pull request es un bug. No lo es, y quería demostrarlo. Un script pequeño, <code>probe.sh</code>, pide un token a GitHub, decodifica el <code>sub</code>, ofrece el token a Entra e imprime una línea de resultado. El workflow lo ejecuta en un push a main, un push a una rama feature, <code>pull_request</code>, <code>pull_request_target</code>, un push de tag y un segundo job que usa un environment. Usé una app nueva y el mismo repositorio privado.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/github-actions-azure-workload-identity-federation/04-subs-before.webp" alt="Salida de terminal: una tabla de seis runs con solo la credencial de main. main pasa. Los runs de rama feature, pull request, pull_request_target, tag y environment fallan con AADSTS700213. Cada fila muestra el sub tras el prefijo del repositorio." width="1894" height="416" loading="lazy" decoding="async"><figcaption><strong>Pasa 1 de 6.</strong> La parte después de los ID cambia en cada tipo de run, y una credencial para main solo coincide con main.</figcaption></figure>
<p>Después añadí cuatro credenciales: una exacta para el environment, una exacta para <code>pull_request</code> y dos expresiones para ramas <code>feature-*</code> y tags <code>v*</code>. Volví a lanzar los mismos runs.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/github-actions-azure-workload-identity-federation/05-subs-after.webp" alt="Salida de terminal: las cuatro credenciales extra con su nombre y su patrón, y luego la misma tabla de seis runs en la que todas las filas pasan. El placeholder prefix representa la parte del sub con el repositorio y los ID del propietario y del repositorio." width="1894" height="568" loading="lazy" decoding="async"><figcaption><strong>Pasan 6 de 6.</strong> &lt;prefix&gt; representa repo:&lt;owner&gt;@&lt;id&gt;/&lt;repo&gt;@&lt;id&gt;. Una credencial tiene un subject exacto o una expresión, nunca las dos cosas.</figcaption></figure>
<table>
<thead>
<tr>
<th>Run</th>
<th><code>sub</code> tras el prefijo del repositorio</th>
<th>Credencial que lo deja pasar</th>
<th>Solo main</th>
<th>Después</th>
</tr>
</thead>
<tbody>
<tr>
<td>Push a main</td>
<td><code>ref:refs/heads/main</code></td>
<td>Subject exacto</td>
<td>Pasa</td>
<td>Pasa</td>
</tr>
<tr>
<td>Push a feature-probe</td>
<td><code>ref:refs/heads/feature-probe</code></td>
<td>Expresión <code>...ref:refs/heads/feature-*</code></td>
<td>AADSTS700213</td>
<td>Pasa</td>
</tr>
<tr>
<td><code>pull_request</code></td>
<td><code>pull_request</code></td>
<td>Subject exacto</td>
<td>AADSTS700213</td>
<td>Pasa</td>
</tr>
<tr>
<td><code>pull_request_target</code></td>
<td><code>pull_request</code></td>
<td>La misma credencial <code>pull_request</code></td>
<td>AADSTS700213</td>
<td>Pasa</td>
</tr>
<tr>
<td>Tag v1</td>
<td><code>ref:refs/tags/v1</code></td>
<td>Expresión <code>...ref:refs/tags/v*</code></td>
<td>AADSTS700213</td>
<td>Pasa</td>
</tr>
<tr>
<td>Job con environment lab-b1-prod</td>
<td><code>environment:lab-b1-prod</code></td>
<td>Subject exacto</td>
<td>AADSTS700213</td>
<td>Pasa</td>
</tr>
</tbody>
</table>
<p><strong>Una diferencia con la documentación de Microsoft.</strong> Las expresiones <code>feature-*</code> y <code>v*</code> solo tenían una condición sobre <code>sub</code>, sin <code>repository_id</code>. Entra aceptó las dos y los runs pasaron. Mis patrones ya llevaban dentro los ID del propietario y del repositorio, así que estaban fijados de todos modos. En una comprobación posterior, el mismo día, Entra también aceptó una expresión a nivel de propietario sin cláusula <code>repository_id</code> ni <code>repository_owner_id</code>, y esa credencial emitió un token a otro repositorio del mismo propietario. Las páginas de Microsoft dicen que una expresión para GitHub debe comprobar <code>sub</code> y <code>repository_id</code> o <code>repository_owner_id</code>. Aun así recomiendo añadir <code>repository_id</code> a cada expresión. La regla está documentada y la función está en preview, así que una credencial solo sobre el sub podría rechazarse o dejar de coincidir más adelante. Y la comprobación del ID no depende de escribir bien el patrón: un comodín a nivel de propietario ya emitió un token a otro de mis repositorios, y el <code>sub</code> solo con nombres de un repositorio antiguo puede coincidir con un nombre que ya no es tuyo.</p>
<h2>pull_request y pull_request_target comparten un subject</h2>
<p>Los dos eventos envían un <code>sub</code> que termina en <code>pull_request</code>, sea cual sea la rama. Por eso una credencial <code>pull_request</code> en Entra también confía en los jobs <code>pull_request_target</code>. Estos corren desde la rama base, con secretos y con un token OIDC. Si un workflow así hace checkout de la head de la pull request, el autor de la pull request ejecuta código con tu identidad en la nube. Mi workflow de prueba usaba el checkout por defecto, que toma la rama base. No lo cambies en un workflow que pueda obtener un token.</p>
<p>Un job que usa un environment es la otra sorpresa. Envía <code>environment:&lt;name&gt;</code> en lugar de la rama. Mover un job de despliegue a un environment rompe una credencial escrita para main.</p>
<h2>Pull requests desde forks: según la documentación, sin probar</h2>
<p>No probé una pull request desde un fork. Hace falta una segunda cuenta de GitHub, y no uso una que no sea mía. Lo que sigue es la documentación de GitHub y mi lectura.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/github-actions-azure-workload-identity-federation/06-forks-docs.webp" alt="Salida de terminal con tres frases citadas de la documentación de GitHub: los secretos no pasan a los workflows lanzados desde forks, el GITHUB_TOKEN es de solo lectura en pull requests desde forks y los permisos de escritura pasan a lectura para eventos de pull request distintos de pull_request_target desde un fork." width="1894" height="416" loading="lazy" decoding="async"><figcaption><strong>Solo documentación, no una prueba.</strong> Las líneas se imprimen directamente desde las páginas de GitHub para que puedas comprobar el texto.</figcaption></figure>
<p><code>id-token: write</code> es un permiso de escritura. Para una <code>pull_request</code> desde un fork pasa a lectura, así que según mi lectura el job no recibe ningún token OIDC. <code>probe.sh</code> contempla ese caso e imprimiría &quot;no OIDC token was offered&quot;. No lo he visto pasar. <code>pull_request_target</code> es la excepción en esa documentación, y es la trampa de arriba.</p>
<h2>Trampas</h2>
<ul>
<li><strong>Lee el <code>sub</code> de un run real antes de escribir una credencial.</strong> Lo muestran la línea del log y el mensaje AADSTS700213.</li>
<li><strong>Espera después de asignar el rol.</strong> Sin la espera, el login funcionó y el comando siguiente falló con &quot;No subscriptions found&quot;.</li>
<li><strong>Las expresiones están en preview y en Graph beta.</strong> Para app registrations usé <code>az rest</code>. La página conceptual de Microsoft dice que la CLI aún no las soporta de forma explícita, mientras que <code>az identity federated-credential</code> (identidades administradas asignadas por el usuario) lista parámetros en preview para ello.</li>
<li><strong>Los repositorios antiguos mantienen el <code>sub</code> solo con nombres</strong> hasta que alguien activa el formato nuevo. Escribe la credencial para el formato que el repositorio envía de verdad.</li>
</ul>
<h2>Lo que me llevo sobre seguridad</h2>
<ol>
<li>En CI usa federación en lugar de un client secret. No hay nada que guardar, filtrar ni rotar.</li>
<li>Usa la credencial más estrecha que sirva: exacta para main y para un environment, una expresión solo para una familia real de refs.</li>
<li>Mantén los ID del propietario y del repositorio en cada subject y patrón, y añade <code>repository_id</code> a cada expresión.</li>
<li>Da por hecho que una credencial <code>pull_request</code> también confía en <code>pull_request_target</code>. Nunca hagas checkout de código no confiable en un workflow que pueda obtener un token.</li>
<li>Borra las credenciales cuyo repositorio ya no existe. Con el formato antiguo solo con nombres, otra persona puede quedarse con el nombre.</li>
</ol>
<h2>Limpieza</h2>
<p>Borré el app registration, lo que elimina sus credenciales, borré el resource group, comprobé que ya no existían y archivé el repositorio privado. Después de la comprobación a fondo también eliminé la app extra, la rama, el tag, la pull request, el environment y las variables.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/github-actions-azure-workload-identity-federation/07-cleanup.webp" alt="Salida de terminal: se borran el app registration y el resource group, az group exists imprime false, el recuento de apps es 0 y el repositorio queda archivado." width="1894" height="377" loading="lazy" decoding="async"><figcaption><strong>No queda nada en marcha.</strong> Nunca se creó ningún secreto, así que no hay nada que revocar.</figcaption></figure>
<h2>Lo que no se ejecutó</h2>
<ul>
<li>Una pull request desde un fork. Esa parte se basa en la documentación de GitHub.</li>
<li>Un repositorio existente pasado al formato inmutable, y el endpoint de vista previa de GitHub para el prefijo del subject.</li>
<li>Un rol que pueda desplegar. La app solo tenía Reader sobre un resource group vacío.</li>
<li>Una expresión con <code>repository_owner_id</code> o <code>job_workflow_ref</code>.</li>
<li>Otras nubes. GitHub documenta AWS, Google Cloud y Vault, y yo solo probé Azure.</li>
</ul>
<p><em>Ejecutado el 20 de noviembre de 2026 con la CLI de Azure, la CLI de GitHub y <code>azure/login@v2</code> en un runner alojado por GitHub, en un tenant de usar y tirar y un repositorio privado. Las imágenes de terminal se redibujaron a partir de la salida guardada, con usuarios, ID y marcas de tiempo sustituidos por placeholders.</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>Notas de IETF 127: ID-JAG, grants de workload y transaction tokens para delegar en agentes</title>
      <link>https://iamops.dev/es/ietf-127-id-jag-workload-grants-transaction-tokens/</link>
      <guid isPermaLink="true">https://iamops.dev/es/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>Noticias</category>
      <category>IETF 127</category>
      <category>ID-JAG</category>
      <category>Identidad de workload</category>
      <category>Transaction Tokens</category>
      <category>Agentes de IA</category>
      <category>Estándares</category>
      <description>Mi lectura de las sesiones OAuth y WIMSE de IETF 127: ID-JAG, Workload Authorization Grant, transaction tokens y actores, con las revisiones de los drafts.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/es/ietf-127-id-jag-workload-grants-transaction-tokens.png?v=986e5733" alt="" /></p><p><strong>En resumen</strong></p>
<ul>
<li>En IETF 127 la delegación en agentes se trató en tres casos: un usuario (ID-JAG), un workload que actúa por sí mismo (Workload Authorization Grant, WAG) y una transacción en curso (un grant de transaction token).</li>
<li>ID-JAG está en el draft -06 y sigue siendo un documento del grupo de trabajo OAuth. El aprovisionamiento just-in-time y el key binding pasan a drafts separados, y las pasarelas en medio siguen siendo el problema abierto.</li>
<li>WAG, el perfil de transaction tokens, los Transactional Access Tokens, el Actor Profile y los tres drafts de delegación más recientes son drafts individuales. Nada de eso está adoptado ni es definitivo.</li>
<li>Para sus propios diseños: clasifique cada flujo de agente según el principal, no reenvíe nunca el token entrante al siguiente salto y anote la revisión del draft en todo diseño que dependa de él.</li>
</ul>
<p>IETF 127 se celebró esta semana en San Francisco. No estuve. Leí las diapositivas, las notas de los voluntarios y los drafts actuales de las sesiones OAuth y WIMSE, y el 20 de noviembre de 2026 comprobé el nombre y la revisión de cada draft en datatracker.ietf.org.</p>
<p>La sesión OAuth fue el miércoles 18 de noviembre. WIMSE se reunió esa misma tarde (22:00 UTC) y la sesión conjunta de OAuth y WIMSE llegó el jueves 19 de noviembre. OAuth tiene hoy una última sesión, que mientras escribo todavía no ha ocurrido. Cito las notas como notas. No son decisiones.</p>
<h2>Tres grants para tres clases de principal</h2>
<p>En la sesión conjunta, Justin Richer propuso una taxonomía sencilla, recogida en las <a href="https://notes.ietf.org/notes-ietf-127-wimse">notas de WIMSE</a>: ID-JAG trata de una persona, WAG de un workload y &quot;TAG&quot; de una transacción en curso. &quot;TAG&quot; es un apodo surgido en la discusión. No es un draft ni un nombre registrado.</p>
<table>
<thead>
<tr>
<th>Caso</th>
<th>Draft que comprobé</th>
<th>Estado</th>
</tr>
</thead>
<tbody>
<tr>
<td>Un usuario</td>
<td><a href="https://datatracker.ietf.org/doc/draft-ietf-oauth-identity-assertion-authz-grant/">draft-ietf-oauth-identity-assertion-authz-grant-06</a> (ID-JAG)</td>
<td>Documento del grupo de trabajo OAuth, publicado el 31 oct 2026</td>
</tr>
<tr>
<td>Un workload que actúa por sí mismo</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 individual, &quot;Informational&quot;, publicado el 2 nov 2026</td>
</tr>
<tr>
<td>Una transacción en curso</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 individual, publicado el 26 oct 2026</td>
</tr>
</tbody>
</table>
<p>ID-JAG y el perfil de transaction tokens son ambos perfiles de <a href="https://datatracker.ietf.org/doc/draft-ietf-oauth-identity-chaining/">identity chaining</a>. Ese draft está en el -17 y el datatracker lo muestra en la cola del RFC Editor, con el estado &quot;blocked: Final Approval Pending&quot;. Las notas de WIMSE lo llaman &quot;RFC 10092 (to be)&quot;. El datatracker aún no muestra un número de RFC, así que yo no citaría ninguno.</p>
<figure class="b-fig"><img src="https://iamops.dev/img/ietf-127-id-jag-workload-grants-transaction-tokens.es.svg" alt="Tres columnas, una por tipo de principal. Un usuario corresponde a ID-JAG, documento del grupo de trabajo de OAuth. Un workload corresponde a WAG, borrador individual. Una transacción corresponde al perfil de encadenado de txn-tokens, borrador individual. Las tres llevan a un servidor de autorización que emite un token con la API siguiente como audience." width="1200" height="630" loading="lazy" decoding="async"><figcaption><strong>Tres principals, tres grants.</strong> Es mi propio resumen del reparto, no una figura de las diapositivas. Estado a 20 de noviembre de 2026.</figcaption></figure>
<h2>ID-JAG en el draft -06</h2>
<p>Las diapositivas de ID-JAG enumeran los cambios de -05 y -06. Estos son los que leería primero:</p>
<ul>
<li>Un ID-JAG ligado a una clave puede sustituir la autenticación del cliente en el servidor de autorización del recurso.</li>
<li>El token exchange se limita a una sola audience. Una audience desconocida recibe <code>invalid_target</code>.</li>
<li>Se añadió el binding mTLS, y un ID-JAG ligado con <a href="https://iamops.dev/es/tools/dpop/">DPoP</a> exige el tipo de grant <code>jwt-dpop</code>.</li>
<li>Una nueva sección Subject Identifier Mapping, comprobaciones de tenant y un valor de metadatos <code>id_jag_signing_alg_values_supported</code>.</li>
<li>Una sección Privacy Considerations.</li>
</ul>
<p>Las <a href="https://datatracker.ietf.org/meeting/127/materials/slides-127-oauth-sessa-identity-assertion-jwt-authorization-grant-00">diapositivas</a> también indican quién lo implementa. La lista incluye Okta, Ping, Auth0, Descope, Keycloak, WorkOS y Oracle OCI IAM. Para lo básico escribí <a href="https://iamops.dev/es/id-jag-explained/">ID-JAG explained</a>.</p>
<p>De la experiencia de implementación salieron tres temas, y cada uno acabó fuera del draft principal:</p>
<ul>
<li><strong>Aprovisionamiento just-in-time</strong> (issues #83 y #121). La recomendación es una extensión futura. Una app puede ahora conocer a un usuario por primera vez a través de un ID-JAG, y los claims personalizados están permitidos pero no necesariamente son interoperables.</li>
<li><strong>Key binding</strong> (issue #103). Las diapositivas señalan las piezas que faltan en <a href="https://datatracker.ietf.org/doc/draft-mcguinness-oauth-token-exchange-cnf/">draft-mcguinness-oauth-token-exchange-cnf</a> y <a href="https://datatracker.ietf.org/doc/draft-parecki-oauth-jwt-dpop-grant/">draft-parecki-oauth-jwt-dpop-grant</a>, y preguntan si el key binding debe pasar a una extensión propia. En las notas, Hannes dijo que remitir a otros documentos hace que el draft parezca inacabado. Aaron Parecki respondió que el aprovisionamiento es opcional y que el binding se aplica más allá de ID-JAG.</li>
<li><strong>Pasarelas y proxies</strong> (issue #114). Una pasarela en medio realiza el token exchange, pero la audience del ID token es el cliente que llamó a la pasarela, y la comprobación de audience falla. Las diapositivas proponen declarar fuera de alcance las topologías con intermediario y señalan <a href="https://datatracker.ietf.org/doc/draft-mcguinness-oauth-id-continuation-assertion/">draft-mcguinness-oauth-id-continuation-assertion</a> como extensión.</li>
</ul>
<p>Los autores pidieron reuniones intermedias sobre pasarelas y key binding. Los siguientes pasos en las diapositivas son clasificar las issues restantes entre -07 y un aplazamiento explícito, y después pedir el working group last call.</p>
<p>Mi opinión: el grant básico parece lo bastante estable para construir sobre él. Todavía no montaría un diseño con una pasarela en medio, porque es justo el caso que los propios autores sacaron.</p>
<h2>WAG: la versión para workloads</h2>
<p>El draft de WAG describe una plataforma cuyo proveedor de identidad de workload firma un grant JWT según la <a href="https://www.rfc-editor.org/rfc/rfc7523">RFC 7523</a> que nombra un solo workload. El servidor de autorización de un tercero se configura una vez para confiar en ese proveedor y no rechaza un workload solo porque no lo haya visto antes. El draft dice que el caso que lo motiva es un agente de IA y que el acceso en nombre de un usuario queda fuera de alcance.</p>
<p>También dice con claridad que es un draft individual temprano y exploratorio, no un documento del grupo de trabajo. En la sesión de WIMSE, Aaron Parecki dijo que ID-JAG trata en esencia de un usuario, y que sin usuario el caso se parece a WAG. Jeff Lombardo dijo que apoyaba mucho la adopción. Karl McGuinness defendió mantener separados los tipos de principal en lugar de que el receptor deduzca el tipo a partir de los claims. Las notas no recogen ninguna objeción a la idea. Tampoco recogen una petición de adopción.</p>
<p>La identidad del cliente también salió. La charla 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> enumeraba las opciones: registro dinámico, una URL de metadatos (CIMD), un client ID como JWT y un SPIFFE ID. El draft <a href="https://datatracker.ietf.org/doc/draft-ietf-oauth-spiffe-client-auth/">SPIFFE client authentication</a> está en -03 (2 de noviembre) y cubre solo el token endpoint.</p>
<p>Otros dos puntos de WIMSE importan si construye sobre esto:</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>) movió la prueba a la cabecera <code>Authorization</code>. Una petición tiene una sola cabecera de ese tipo, así que un WPT no puede viajar junto a un access token de OAuth. Flemming Andreasen calificó el cambio de incoherente con la arquitectura, y Jonathan Rosenberg señaló que un agente que actúa por un usuario necesita tanto un access token como la autenticación del agente. El chair llevó la cuestión a la lista de correo.</li>
<li><strong>WIMSE Architecture</strong> (<a href="https://datatracker.ietf.org/doc/draft-ietf-wimse-arch/">-09</a>) apareció el 17 de noviembre (UTC). Los autores la consideran lista y los chairs prevén un working group last call en las próximas semanas.</li>
</ul>
<p>En la misma sesión, Brian Campbell presentó el draft <a href="https://datatracker.ietf.org/doc/draft-ietf-wimse-aims/">AI Identity Management System</a>, con la fórmula &quot;OAuth in the front, WIMSE in the back&quot;. Según las notas, no define ningún comportamiento de protocolo nuevo.</p>
<h2>Transaction tokens a través de una frontera</h2>
<p>Los Transaction Tokens se quedan dentro de un solo dominio de confianza. El <a href="https://datatracker.ietf.org/doc/draft-fletcher-oauth-txn-token-chaining-profile/">perfil de George Fletcher</a> describe cómo un workload cambia su Txn-Token en su propio servidor de autorización por un Txn-Token-JAG (<code>typ</code> igual a <code>txn-chain+jwt</code>) y lo presenta al servidor de un socio. Según las <a href="https://datatracker.ietf.org/meeting/127/materials/slides-127-wimse-ietf-127-txn-token-chaining-profile-00">diapositivas</a>, el grant dura como máximo 300 segundos, mejor 60, el <code>jti</code> es de un solo uso y la cadena de llamadas interna nunca cruza la frontera. Las preguntas abiertas son si el sender constraining debe pasar de SHOULD a MUST y cómo mapear el subject.</p>
<p>La discusión fue lo interesante:</p>
<ul>
<li>Max Gerber preguntó por qué hace falta un nuevo tipo de JAG si existen ID-JAG y WAG. Justin Richer y Pieter Kasselman respondieron que el artefacto de entrada es distinto y que el JAG llevaría un subconjunto reducido de sus claims.</li>
<li>Mark Atwood dijo que quitar los identificadores internos antes de que un token cruce una frontera debería ser un MUST. Antoine Fressancourt replicó que los identificadores aun así deben poder reconstruirse para la auditoría.</li>
<li>Arndt Schwenkschuster temía que los transaction tokens se conviertan en &quot;the new bearer AT&quot;, que se puede robar e intercambiar. George Fletcher respondió que son ortogonales a la autenticación del cliente.</li>
<li>Justin Richer: &quot;Semantically, the transaction token shouldn't contain authorization to do work, it should shape work being done.&quot;</li>
</ul>
<p>Las notas terminan con un amplio acuerdo en que el trabajo cubre una laguna real. Una nota práctica: las notas enlazan un nombre antiguo, <code>draft-fletcher-transaction-token-chaining-profile</code>. El datatracker lo muestra como sustituido por el nombre <code>oauth-txn</code> enlazado arriba, que es también el que usan las diapositivas.</p>
<p>Los <a href="https://datatracker.ietf.org/doc/draft-tulshi-oauth-transactional-access-tokens/">Transactional Access Tokens</a> (-01, fechado el 18 de noviembre) toman otro camino. Un Txn-AT es un access token JWT conforme a la <a href="https://www.rfc-editor.org/rfc/rfc9068">RFC 9068</a>, con identificador y contexto de transacción, para un solo resource server, solicitado mediante Rich Authorization Requests. Según el draft, la duración no debería superar 300 segundos (SHOULD NOT). Se puede emitir con token exchange, refresh y client credentials, pero no directamente con authorization code. En la sesión, un participante llamado George dijo que no hace falta estandarizarlo, y el autor respondió que un camino estándar es deseable. Justin Richer llevó la discusión a la lista de correo.</p>
<h2>Quién es el actor</h2>
<p>El <a href="https://datatracker.ietf.org/doc/draft-mcguinness-oauth-actor-profile/">OAuth Actor Profile for Delegation</a> (-01, 9 de octubre) perfila el claim <code>act</code> del token exchange, pide identificadores de actor con alcance limitado al emisor y clasifica a los actores con <code>sub_profile</code>. El resumen de Karl McGuinness en las notas: hacer explícita la delegación, y el client ID sigue siendo el cliente. Dos personas hablaron a favor de la adopción. Otro participante dijo que no es un trabajo corto, y Justin Richer consideró razonable buscar aclaraciones antes de adoptarlo. Las notas recogen que los chairs pidieron una muestra del sentir de la sala, pero no lo que respondió la sala.</p>
<p>Un nuevo draft individual va un paso más allá. <a href="https://datatracker.ietf.org/doc/draft-nandakumar-oauth-actor-bound-token-exchange/">Token Exchange with Actor-Bound Tokens</a> (-00, 16 de noviembre) permite a un orquestador pedir un token ligado a la clave del agente que hará el trabajo. El actor demuestra que posee esa clave, así que el token solo sirve para ese agente. Es un draft individual.</p>
<h2>Tres drafts más de esta semana</h2>
<p>Los tres son drafts individuales -00, sin estatus de grupo de trabajo.</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 que revoca una delegación y todo lo delegado a partir de ella, con reglas para que los agentes lo propaguen por la cadena, también mediante un flujo Shared Signals. Las Token Status Lists siguen siendo el mecanismo de estado por token.</li>
<li><a href="https://datatracker.ietf.org/doc/draft-sweeney-oauth-brokered-authorization/">OAuth Brokered Authorization</a> (20 nov). Un broker duradero es el cliente OAuth del recurso aguas arriba. Cada instancia de vida corta recibe un token con restricción de emisor (DPoP o mTLS) para el broker mediante client credentials, con un tipo de <code>authorization_details</code> igual a <code>brokered_access</code>. Una instancia nunca tiene un refresh token.</li>
<li><a href="https://datatracker.ietf.org/doc/draft-zehavi-oauth-aud-bound-authz/">OAuth 2.0 Audience-Bound Client Authorization</a> (18 nov). Solo un cliente que representa la audience del token puede intercambiarlo o introspeccionarlo. El vínculo puede venir de la política local, de un <code>private_key_jwt</code> comprobado contra el <code>jwks_uri</code> del recurso, o de un nuevo parámetro <code>resource_clients</code> en los metadatos de la RFC 9728. La agenda del viernes incluye un draft anterior del mismo autor, <code>draft-zehavi-oauth-audience-bound-token-exchange-00</code>. No he comprobado cómo se relacionan los dos.</li>
</ul>
<h2>Qué haría con esto</h2>
<p>Esta es mi opinión, no la del estándar.</p>
<ul>
<li>Clasificar primero cada flujo de agente según su principal: un usuario, un workload o una transacción. Los drafts se están dividiendo justo por esa línea, así que su diseño encajará mejor.</li>
<li>No reenviar el token entrante al siguiente salto. Cambiarlo por uno cuya audience sea la siguiente API. Lo traté en <a href="https://iamops.dev/es/mcp-server-no-token-passthrough/">MCP server, no token passthrough</a> y en <a href="https://iamops.dev/es/entra-on-behalf-of-agent-middle-tier/">Entra on-behalf-of for an agent middle tier</a>.</li>
<li>Tratar el caso de la pasarela como no resuelto hasta que las reuniones intermedias sobre la issue #114 informen.</li>
<li>Escribir el nombre y la revisión del draft en el documento de diseño. Varios de estos drafts cambiaron de nombre o de número en pocas semanas.</li>
</ul>
<h2>Qué no comprobé</h2>
<p>No asistí a ninguna sesión y no vi las grabaciones completas. Enlacé las grabaciones de la <a href="https://www.youtube.com/watch?v=V0tRi789ngE">sesión OAuth</a> y de la <a href="https://www.youtube.com/watch?v=g-EubYQF1xk">sesión WIMSE 1</a>. Todavía no encontré una grabación de la sesión conjunta, así que todo lo que la concierne viene de las notas. No ejecuté ni implementé ninguno de estos drafts. Las notas las escriben voluntarios y pueden contener errores. La sesión OAuth del viernes, que incluye varios de los drafts anteriores, aún no ha tenido lugar. Actualizaré este artículo si cambia algo importante.</p>
]]></content:encoded>
    </item>
    <item>
      <title>Workload identity: sub inmutable de GitHub, credenciales de Entra con wildcard y agent auth de WorkOS</title>
      <link>https://iamops.dev/es/workload-identity-news-immutable-sub-entra-wildcards-workos/</link>
      <guid isPermaLink="true">https://iamops.dev/es/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>Noticias</category>
      <category>GitHub Actions</category>
      <category>OIDC</category>
      <category>Entra ID</category>
      <category>Identidad de workload</category>
      <category>WorkOS</category>
      <category>Agentes de IA</category>
      <description>El sub OIDC por defecto de GitHub ya incluye los ID de owner y repo, las credenciales de Entra con wildcard siguen en preview y WorkOS lanzó agent auth.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/es/workload-identity-news-immutable-sub-entra-wildcards-workos.png?v=986e5733" alt="" /></p><p><strong>En resumen</strong></p>
<ul>
<li>Desde el 15 de julio de 2026, los tokens de GitHub Actions de los repositorios nuevos llevan el ID del owner y el ID del repositorio en el claim sub. Los repositorios antiguos conservan el formato solo con nombres hasta que lo actives: la credencial debe coincidir con el formato realmente emitido.</li>
<li>Las credenciales wildcard de Entra siguen en preview. Microsoft pide también repository_id o repository_owner_id. En mi lab Entra aceptó una expresión solo sobre el sub, y una a nivel de propietario emitió un token a otro repositorio del mismo propietario. Aun así añado repository_id.</li>
<li>WorkOS lanzó identidad para agentes (Agent Auth, acceso anticipado, 2 sep), Claude auto-connect para MCP Auth (acceso anticipado, 3 nov) y token exchange RFC 8693 para Connect (10 nov). No encontré nada de WorkOS sobre federar workloads de otro emisor.</li>
<li>Lo que haría: confiar en el sub inmutable, añadir repository_id a cada wildcard, borrar las credenciales de repositorios que ya no existen y comprobarlo con ejecuciones reales. Mi lab lo hace para GitHub Actions hacia Azure.</li>
</ul>
<p>Leí las páginas primarias de estas novedades el 20 de noviembre de 2026: el changelog y la documentación de GitHub, Microsoft Learn y el changelog de WorkOS. Las fechas de abajo son las que muestran esas páginas. Las dos primeras novedades importan para mi <a href="https://iamops.dev/es/github-actions-azure-workload-identity-federation/">lab de GitHub Actions a Azure</a>, y por eso las junto.</p>
<h2>GitHub pone los ID de owner y repo en el claim sub</h2>
<p>El 23 de abril de 2026 GitHub anunció los <a href="https://github.blog/changelog/2026-04-23-immutable-subject-claims-for-github-actions-oidc-tokens/">claims subject inmutables para los tokens OIDC de Actions</a>. La entrada se editó el 10 de junio de 2026: el delimitador entre un nombre y su ID ahora es <code>@</code>, no <code>-</code>. Si copiaste un ejemplo del texto de abril, revísalo.</p>
<p>Las reglas, según la <a href="https://docs.github.com/en/actions/reference/security/oidc">referencia de OIDC</a>:</p>
<ul>
<li>Los repositorios creados después del 15 de julio de 2026 reciben el nuevo <code>sub</code> por defecto. Los cambios de nombre y las transferencias posteriores a esa fecha también pasan al nuevo formato.</li>
<li>Los repositorios antiguos conservan el formato solo con nombres hasta que lo actives. Puedes hacerlo por organización o por repositorio, en los ajustes de OIDC o con la API REST (<code>use_immutable_subject</code>).</li>
<li>GitHub Enterprise Server no está incluido.</li>
<li>Una plantilla de claims personalizada no puede quitar los ID. Con <code>include_claim_keys</code>, <code>owner_id</code> y <code>repo_id</code> siguen en el segmento <code>repo</code>.</li>
</ul>
<table>
<thead>
<tr>
<th>Formato</th>
<th><code>sub</code> para un push a main</th>
</tr>
</thead>
<tbody>
<tr>
<td>Solo nombres</td>
<td><code>repo:octo-org/octo-repo:ref:refs/heads/main</code></td>
</tr>
<tr>
<td>Inmutable</td>
<td><code>repo:octo-org@123456/octo-repo@456789:ref:refs/heads/main</code></td>
</tr>
</tbody>
</table>
<p>Los valores de ejemplo vienen de la documentación de GitHub. El motivo está en el changelog: si se recicla el nombre de un repositorio o de una organización, un nuevo propietario puede emitir tokens con el mismo subject y llegar a recursos en la nube que aún confían en el original. Los ID no se reutilizan nunca, así que la confianza antigua no se transfiere.</p>
<p>En mi lab creé un repositorio privado nuevo y su <code>sub</code> salió en el formato nuevo. Eso cambia el orden de la preparación. Creo primero el repositorio, leo los dos ID desde la API y solo después creo la credencial federada. La documentación de GitHub muestra el formato inmutable para las políticas de confianza de Azure, AWS, Google Cloud y HashiCorp Vault. Yo solo probé Azure.</p>
<h2>Qué puede comparar ahora Entra</h2>
<p>Microsoft sigue marcando como preview las <a href="https://learn.microsoft.com/en-us/entra/workload-id/workload-identities-flexible-federated-identity-credentials">credenciales federadas flexibles</a>. La página tiene fecha del 18 de septiembre de 2026. En lugar de un <code>subject</code> exacto, la credencial lleva un <code>claimsMatchingExpression</code> con <code>languageVersion</code> en 1, y <code>subject</code> debe ser null. La página conceptual dice que Azure CLI aún no lo soporta de forma explícita y muestra <code>az rest</code> contra Graph beta, que es lo que usé para un app registration. La referencia de la CLI de <code>az identity federated-credential</code> (identidades administradas asignadas por el usuario) sí lista los parámetros <code>--claims-matching-expression-*</code>, marcados como Preview.</p>
<table>
<thead>
<tr>
<th>Operador</th>
<th>Qué hace</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>eq</code></td>
<td>Coincidencia exacta en un claim</td>
</tr>
<tr>
<td><code>matches</code></td>
<td>Wildcards: <code>*</code> para cualquier secuencia de caracteres, <code>?</code> para uno solo</td>
</tr>
<tr>
<td><code>and</code></td>
<td>Combina condiciones sobre varios claims</td>
</tr>
</tbody>
</table>
<p>Para GitHub, la <a href="https://learn.microsoft.com/en-us/entra/workload-id/workload-identities-set-up-flexible-federated-identity-credential">página de configuración</a> de Microsoft dice que la expresión debe comparar <code>sub</code> y uno de los claims <code>repository_id</code> y <code>repository_owner_id</code>, o ambos. Vale tanto si <code>sub</code> se basa en nombres como si está personalizado o es inmutable. <code>sub</code> y <code>job_workflow_ref</code> aceptan <code>eq</code> y <code>matches</code>. Los dos claims de ID solo aceptan <code>eq</code>. La <a href="https://learn.microsoft.com/en-us/entra/workload-id/workload-identities-github-immutable-subjects">guía de migración</a> de Microsoft usa este ejemplo:</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 también publicó una <a href="https://learn.microsoft.com/en-us/entra/workload-id/workload-identities-github-immutable-subjects">guía de migración</a>, con fecha del 28 de julio de 2026. El orden: crear una credencial para el subject inmutable junto a la antigua, activar los subjects inmutables en GitHub, validar una ejecución y borrar la credencial antigua. Una página relacionada sobre <a href="https://learn.microsoft.com/en-us/entra/workload-id/workload-identities-federated-credential-mutable-subjects">subjects mutables</a> describe el reciclaje de subjects y pide borrar las credenciales huérfanas, las que siguen configuradas cuando el workload ya no existe.</p>
<p>Aquí mi propia ejecución difiere de la documentación. En el <a href="https://iamops.dev/es/github-actions-azure-workload-identity-federation/">lab</a> creé dos expresiones que solo comparaban <code>sub</code> (<code>feature-*</code> y <code>v*</code>), sin <code>repository_id</code>. Entra aceptó ambas y las ejecuciones correspondientes pasaron. Esos patrones contenían los ID de owner y repositorio, así que quedaban fijados de todos modos. En una comprobación posterior, el mismo día, Entra también aceptó una expresión a nivel de propietario sin cláusula <code>repository_id</code> ni <code>repository_owner_id</code>, y esa credencial emitió un token a otro repositorio del mismo propietario. Aun así recomiendo añadir <code>repository_id</code>. Microsoft lo documenta como obligatorio y la función está en preview, así que una credencial solo sobre el sub podría rechazarse o dejar de coincidir más adelante. Y la comprobación del ID no depende de escribir bien el patrón: un comodín a nivel de propietario ya emitió un token a otro de mis repositorios, y el <code>sub</code> solo con nombres de un repositorio antiguo puede coincidir con un nombre que ya no es tuyo.</p>
<h2>Cómo un token se encuentra con dos credenciales</h2>
<figure class="b-fig"><img src="https://iamops.dev/img/workload-identity-news-immutable-sub-entra-wildcards-workos.es.svg" alt="Una matriz de dos credenciales federadas de Entra frente a cuatro ejecuciones de GitHub Actions. La credencial exacta para main solo acepta un push a main. La credencial con wildcard para release/* y comprobación de repository_id solo acepta un push a release/1. Una rama de funcionalidad y una pull request no coinciden con ninguna." width="1200" height="630" loading="lazy" decoding="async"><figcaption><strong>Qué valores de sub acepta cada credencial.</strong> Es un resumen propio, sacado del patrón de cada credencial. Los ID son los valores de ejemplo de la documentación de GitHub.</figcaption></figure>
<p>Lo que muestra la imagen: la parte de <code>sub</code> que va después de los ID es la ejecución. Un push a main, un push a una rama de release, una rama de funcionalidad y una pull request envían cada uno un valor distinto, y Entra lo compara con la credencial. Los ID del medio impiden que coincida otro repositorio con el mismo nombre. Mi lab ejecuta cada uno de estos casos e imprime el <code>sub</code> exacto de cada uno.</p>
<h2>WorkOS: lo que encontré</h2>
<p>Revisé el <a href="https://workos.com/changelog">changelog de WorkOS</a> porque no deja de publicar auth para agentes y MCP. Estas son las entradas de agosto al 20 de noviembre que tocan credenciales de agentes o de workloads:</p>
<table>
<thead>
<tr>
<th>Fecha</th>
<th>Entrada</th>
<th>Qué dice WorkOS</th>
</tr>
</thead>
<tbody>
<tr>
<td>2 sep 2026</td>
<td><a href="https://workos.com/changelog/agent-auth">Agent Auth</a></td>
<td>Acceso anticipado. Los agentes reciben identidades en AuthKit y, en cada ejecución, tokens de corta duración y alcance estrecho, delegados para un usuario o autónomos dentro de una organización. Las sesiones se pueden revocar al instante.</td>
</tr>
<tr>
<td>4 sep 2026</td>
<td><a href="https://workos.com/changelog/mcp-enterprise-managed-authorization-ema">MCP Enterprise-Managed Authorization (EMA)</a></td>
<td>MCP Auth admite EMA, de modo que un cliente MCP puede llegar a servidores MCP posteriores a través del proveedor de identidad de la empresa, sin una pantalla de consentimiento por aplicación. Acceso bajo petición.</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>Acceso anticipado. Para organizaciones cuyo proveedor de identidad no admite Cross App Access, Claude emite la aserción de identidad (ID-JAG) y MCP Auth la cambia por un token de acceso a tu servidor MCP.</td>
</tr>
<tr>
<td>10 nov 2026</td>
<td><a href="https://workos.com/changelog/token-exchange-for-workos-connect">Token exchange para WorkOS Connect</a></td>
<td>RFC 8693. Una aplicación Connect first-party puede cambiar un token por otro para un recurso registrado distinto, trasladar los claims clave y reducir los scopes.</td>
</tr>
</tbody>
</table>
<p>Las dos últimas se conectan con cosas que ya escribí. Claude auto-connect es el flujo ID-JAG de <a href="https://iamops.dev/es/id-jag-explained/">ID-JAG explained</a>, con Claude como emisor. El token exchange es el patrón que mi <a href="https://iamops.dev/es/mcp-server-no-token-passthrough/">lab de MCP sin passthrough de token</a> construye a mano.</p>
<p>Nada de esto es workload identity federation en el sentido de Entra, donde se confía en tokens de otro emisor. No encontré ninguna entrada del changelog de WorkOS sobre eso, ni sobre autenticación máquina a máquina. Lo que estas entradas comparten con la historia de GitHub es la idea de una credencial de corta duración y estrecha para cada ejecución en lugar de una clave guardada. Otras dos entradas sobre agentes, Agent Registration (4 de agosto) y Agent Vault (17 de noviembre), tratan del inicio de sesión de agentes en AuthKit con el protocolo auth.md y de sesiones de navegador ya iniciadas, así que las dejé fuera. No probé ningún producto de WorkOS.</p>
<h2>Lo que haría</h2>
<p>Esta es mi opinión, no una guía de Microsoft ni de GitHub.</p>
<ul>
<li>Si el repositorio es nuevo, revisa cualquier credencial que hayas escrito a partir de ejemplos antiguos. El subject ahora lleva ID, y un subject solo con nombres no coincidirá.</li>
<li>Si el repositorio es antiguo, sigue el orden de Microsoft: añade la credencial inmutable, activa el formato, ejecuta un workflow y borra la credencial antigua.</li>
<li>Pon <code>repository_id</code> en cada expresión, aunque el patrón contenga los ID. En mi lab Entra aceptó expresiones solo sobre el sub, y una a nivel de propietario emitió un token a otro repositorio del mismo propietario. La documentación sigue exigiendo la comprobación del ID, y yo la añado.</li>
<li>Lista las credenciales federadas de tus registros de aplicación y borra las de repositorios que ya no existen.</li>
</ul>
<p>El <a href="https://iamops.dev/es/github-actions-azure-workload-identity-federation/">lab</a> muestra el fallo que sigue de la coincidencia exacta. Con solo una credencial para main, pasó un tipo de ejecución de seis. También muestra una trampa: una credencial para <code>pull_request</code> también confía en las ejecuciones de <code>pull_request_target</code>, y estas reciben secretos.</p>
<h2>Lo que no comprobé</h2>
<ul>
<li>No activé el formato en un repositorio existente ni llamé al endpoint de vista previa de GitHub que muestra el nuevo prefijo del subject.</li>
<li>Solo probé Azure. AWS, Google Cloud y Vault aparecen en la documentación de GitHub y no los ejecuté.</li>
<li>No probé GitHub Enterprise Server, que GitHub excluye.</li>
<li>Leí las entradas del changelog de WorkOS sin probar ningún producto ni leer la documentación enlazada. Dos entradas son de acceso anticipado.</li>
<li>Las páginas de Microsoft sobre credenciales flexibles siguen diciendo preview. No encontré una fecha de disponibilidad general y no invento ninguna.</li>
</ul>
]]></content:encoded>
    </item>
    <item>
      <title>ID-JAG explicado: cómo los agentes de IA obtienen acceso entre aplicaciones bajo control empresarial</title>
      <link>https://iamops.dev/es/id-jag-explained/</link>
      <guid isPermaLink="true">https://iamops.dev/es/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>Agentes de IA</category>
      <category>OAuth</category>
      <category>Estándares</category>
      <description>Cómo ID-JAG y Cross App Access permiten que el proveedor de identidad de la empresa apruebe el acceso de agentes de IA a otras apps. Con capturas del lab.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/es/id-jag-explained.png?v=986e5733" alt="" /></p><p><strong>En resumen</strong></p>
<ul>
<li>ID-JAG es un estándar IETF propuesto (borrador -06) que permite al proveedor de identidad de una empresa aprobar el acceso de un agente de IA a otra aplicación.</li>
<li>El proveedor de identidad emite una aserción firmada de corta duración; la otra aplicación la verifica y emite su propio token de acceso de corta duración.</li>
<li>Sustituye las ventanas de consentimiento por aplicación y las claves de larga duración por un único punto para política y auditoría.</li>
<li>Sigue siendo un borrador: el key binding y el aprovisionamiento just-in-time podrían pasar a documentos aparte, y varios productos ya lo implementan.</li>
<li>El laboratorio con el ejemplo público xaa.dev muestra el flujo, con capturas censuradas y una grabación.</li>
</ul>
<p>Muchos agentes de IA necesitan acceder a varias aplicaciones corporativas en nombre de un usuario. Hoy, cada conexión suele activar su propia solicitud de consentimiento o depende de una clave de larga duración guardada en la configuración del agente. En ambos casos resulta difícil para una organización ver y controlar lo que ocurre.</p>
<p><strong>ID-JAG</strong> es un estándar propuesto que traslada esa aprobación del usuario individual al proveedor de identidad de la organización. Este artículo explica cómo funciona, en qué punto está la especificación y qué muestra una prueba de laboratorio con una aplicación de ejemplo pública.</p>
<h2>El problema</h2>
<p>Los empleados inician sesión una sola vez, con una sola cuenta, mediante el <em>inicio de sesión único</em> (single sign-on). El sistema que lo gestiona es el <em>proveedor de identidad</em> de la empresa, llamado aquí «inicio de sesión corporativo».</p>
<p>Después, un agente de IA necesita leer tareas en una aplicación, archivos en otra y un calendario en una tercera. Cada una de esas aplicaciones tiene su propio servidor de autorización, que no sabe nada del agente. En la práctica, cada conexión funciona de una de estas dos maneras:</p>
<ul>
<li><strong>Una solicitud de consentimiento</strong> por cada aplicación y cada usuario. Los usuarios tienden a aprobar sin leer y la organización no tiene un registro central.</li>
<li><strong>Una clave de larga duración</strong> pegada en la configuración del agente. No caduca y cualquiera que la obtenga puede usarla.</li>
</ul>
<p>La alternativa es un único punto que dé fe del usuario y del agente, aplique las reglas de la organización y deje constancia.</p>
<h2>Qué hace un ID-JAG</h2>
<p>El nombre completo es <em>Identity Assertion JWT Authorization Grant</em>. En la práctica es una <strong>aserción firmada y de corta duración</strong> emitida por el inicio de sesión corporativo. Indica que la organización de este usuario permite que este agente solicite a esa aplicación un acceso concreto.</p>
<p>El patrón construido a su alrededor se llama informalmente <strong>Cross App Access (XAA)</strong>. La página de oauth.net sobre él dice que «sustituye el paso de aprobación manual del usuario por un intercambio de tokens» (<a href="https://iamops.dev/es/keycloak-token-exchange-rfc-8693/">token exchange</a>).</p>
<p><img src="https://iamops.dev/img/id-jag-flow.es.svg" alt="Los cinco pasos de un flujo ID-JAG, desde el inicio de sesión único hasta el uso de un token de acceso de corta duración por parte del agente."></p>
<p>El flujo en cinco pasos:</p>
<ol>
<li>El usuario inicia sesión en el trabajo una sola vez, de la forma habitual.</li>
<li>El agente pide al inicio de sesión corporativo una aserción válida para una aplicación concreta.</li>
<li>El inicio de sesión corporativo evalúa su política. Si la conexión está permitida, emite el ID-JAG.</li>
<li>El agente presenta el ID-JAG al servidor de autorización de la otra aplicación. Ese servidor verifica la firma, aplica <strong>sus propias</strong> reglas y emite un token de acceso de corta duración.</li>
<li>El agente usa ese token para llamar a la aplicación.</li>
</ol>
<p>Importan dos detalles. La aplicación receptora sigue decidiendo qué concede, así que el ID-JAG no es un cheque en blanco. Y, como el inicio de sesión corporativo está en medio, hay un único lugar donde definir la política y un único lugar donde auditar lo ocurrido.</p>
<p>Técnicamente encadena dos estándares existentes: el intercambio de tokens (RFC 8693) y el JWT bearer grant (RFC 7523).</p>
<h2>Laboratorio: el flujo en el ejemplo de xaa.dev</h2>
<p>El área de pruebas gratuita <strong>xaa.dev</strong>, del equipo de desarrolladores de Okta, hace visible el flujo. En una prueba de laboratorio el 7 de noviembre de 2026, su aplicación de ejemplo se ejecutó en local en un entorno de pruebas. La aplicación tiene un panel «Behind the scenes» que marca cada fase al completarse: inicio de sesión corporativo, ID-JAG, token de acceso y lista de comprobación obtenida de la segunda aplicación. En ningún momento apareció una solicitud de consentimiento.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/xaa/dashboard.webp" alt="La aplicación de ejemplo de xaa.dev con la lista de incorporación a la izquierda y el panel Behind the scenes a la derecha, que muestra las cuatro fases completadas." width="1280" height="975" loading="lazy" decoding="async"><figcaption><strong>Visión general.</strong> La lista (izquierda) se obtuvo de la segunda aplicación con la identidad corporativa. El panel (derecha) enumera las cuatro fases: inicio de sesión corporativo, ID-JAG, token de acceso y lista mediante MCP. El claim del sujeto (sub) está tapado.</figcaption></figure>
<p><strong>Fase 2: la aserción.</strong> Tras el inicio de sesión corporativo, el ejemplo intercambia el ID token del usuario por un ID-JAG (RFC 8693). Al desplegar la fase 2 se ve la aserción decodificada: el emisor, la audiencia (el servidor de autorización de la otra aplicación), el recurso y el scope solicitados, y las horas de emisión y caducidad, que aquí están separadas por cinco minutos. Los identificadores que apuntan a una persona o a un cliente están tapados.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/xaa/id-jag.webp" alt="Fase 2 desplegada en el panel Behind the scenes: el ID-JAG decodificado con emisor, audiencia, recurso, horas de emisión y caducidad y scope visibles; los identificadores están cubiertos con recuadros negros." width="1280" height="975" loading="lazy" decoding="async"><figcaption><strong>Fase 2, el ID-JAG.</strong> Se ven el emisor, la audiencia, el recurso, el periodo de validez y el scope. El sujeto, el cliente y los identificadores del token están cubiertos con recuadros negros, y el token codificado no se muestra.</figcaption></figure>
<p><strong>Fases 3 y 4: el token de acceso.</strong> El servidor de autorización de la otra aplicación verifica el ID-JAG (RFC 7523) y devuelve un token de acceso con un scope limitado. El ejemplo lo usa después para obtener la lista mediante MCP. Los claims del token muestran quién lo emitió, para qué audiencia y con qué scope.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/xaa/access-token.webp" alt="La sección del token de acceso desplegada, con los claims que muestran emisor, audiencia y los scopes todos.read y mcp.access; el token codificado y el sujeto están tapados." width="1280" height="975" loading="lazy" decoding="async"><figcaption><strong>Fases 3 y 4, el token de acceso.</strong> Los claims del token (emisor, audiencia, scope) son reales. El token codificado y el sujeto están tapados.</figcaption></figure>
<p>Grabé todo el flujo en el playground público de xaa.dev, con la app de ejemplo en un entorno de pruebas local y un usuario sintético. Empieza en la página de inicio de sesión, así ves cada salto y después su header y payload decodificados. Lo único añadido es la barra de subtítulos de arriba. No tiene sonido y dura aproximadamente un minuto y 44 segundos.</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.es.vtt" srclang="es" label="Español" default></video><figcaption id="vid-cap"><strong>Grabación de pantalla</strong> (1 min 44 s, sin sonido, subtítulos disponibles): inicio de sesión en el IdP de la empresa y después cada salto con su header y payload decodificados. Usuario sintético y tokens de demostración de vida corta del playground público. Las cadenas de tokens codificados están acortadas por maquetación.</figcaption></figure>
<h3>Qué estás viendo</h3>
<ol>
<li><strong>0:08 Inicio de sesión en el IdP de la empresa.</strong> El usuario inicia sesión en idp.xaa.dev, no en la app del agente. La app nunca ve una contraseña, y en el IdP viven la MFA y las reglas de acceso. El playground acepta seis dígitos cualesquiera como segundo factor.</li>
<li><strong>0:30 La app del agente recibe un ID token.</strong> Demuestra quién inició sesión. Fíjate en <code>iss</code> (el IdP), <code>aud</code> (el client ID de la app) y <code>exp</code>, una hora después de <code>iat</code>. La app ya tiene una identidad de la organización, pero todavía ningún acceso a la app todo.</li>
<li><strong>0:47 El IdP lo cambia por un ID-JAG (RFC 8693).</strong> El agente pide una aserción dirigida a un solo destino. El tipo del header es <code>oauth-id-jag+jwt</code>. Los claims nombran en <code>aud</code> el servidor de autorización de la app todo, junto con <code>resource</code>, <code>client_id</code> y <code>scope</code>. En un despliegue real aquí decide la política del administrador. El playground simplemente lo permite.</li>
<li><strong>0:58 El ID-JAG vive poco.</strong> <code>exp</code> llega 300 segundos después de <code>iat</code>. Un ID-JAG filtrado no sirve pasados cinco minutos, y solo funciona en el servidor nombrado en <code>aud</code>.</li>
<li><strong>1:07 El servidor de autorización propio de la app todo emite el access token (RFC 7523).</strong> El agente le presenta el ID-JAG. Ese servidor comprueba la firma del IdP y luego aplica sus propias reglas. En el token, ese servidor es <code>iss</code>, el servidor MCP es <code>aud</code> y solo aparece el <code>scope</code> aprobado. El usuario se identifica dentro del espacio de nombres de la app todo.</li>
<li><strong>1:30 El agente llama a la API.</strong> Con el access token lee la checklist por MCP. La parte izquierda de la página es esa respuesta. En ningún momento apareció una pantalla de consentimiento.</li>
</ol>
<p><em>El laboratorio usa un ejemplo público con cuentas desechables y datos de muestra. Las capturas se recortaron a la aplicación y se tapó la información sensible antes de publicarlas. La grabación muestra los tokens de demostración decodificados por completo, porque vienen del playground público, pertenecen a un usuario sintético y caducan en una hora. Las cadenas de tokens codificados están acortadas por maquetación.</em></p>
<h2>En qué punto está la especificación</h2>
<p><strong>Sigue siendo un borrador, no un estándar terminado.</strong> El documento es <em>draft-ietf-oauth-identity-assertion-authz-grant</em>, ahora en la versión <strong>-06</strong>, con fecha del 31 de octubre de 2026. Es un documento del grupo de trabajo OAuth de la IETF, escrito por autores de Okta y Ping Identity y por un autor independiente. El resultado previsto es un documento Standards Track, pero los borradores aún pueden cambiar.</p>
<p><strong>IETF 127, 18 de noviembre de 2026.</strong> Los autores presentaron el borrador en la sesión de OAuth. Las diapositivas señalan tres temas abiertos:</p>
<ul>
<li><strong>Aprovisionamiento just-in-time</strong>: cómo trata una aplicación a un usuario que nunca ha visto, porque su primer contacto es un ID-JAG. Las diapositivas recomiendan abordarlo en una extensión futura.</li>
<li><strong>Key binding</strong>: vincular los tokens a una clave criptográfica para que un token robado sea inútil. Las diapositivas preguntan si debe pasar a una extensión propia, y las notas recogen una recomendación de varios borradores de seguimiento. Un participante dijo que trasladar temas a otros documentos hace que el borrador parezca inacabado. El autor respondió que el aprovisionamiento es opcional y que el key binding se aplica más ampliamente que este borrador.</li>
<li><strong>Gateways y proxies</strong>, habituales en despliegues de IA en los que un gateway se sitúa entre el agente y las aplicaciones. Es una cuestión abierta. Se propone un borrador aparte y las notas dicen que los autores querrían reuniones adicionales («interim») sobre gateways y key binding.</li>
</ul>
<p>Las notas las recogen como <strong>recomendaciones</strong>. En ellas no aparece ninguna decisión definitiva. Los siguientes pasos de las diapositivas son clasificar las cuestiones pendientes, resolviendo cada una en una versión -07 o descartándola deliberadamente, y después solicitar un last call del grupo de trabajo.</p>
<h2>Implementaciones</h2>
<p>Varios proveedores ya lo implementan, aunque el borrador no es definitivo. Según la <a href="https://oauth.net/cross-app-access/">lista de implementaciones de oauth.net</a>, consultada el 19 de noviembre de 2026:</p>
<ul>
<li><strong>Los proveedores de identidad que emiten ID-JAG</strong> incluyen Okta, Oracle OCI IAM, Ping, Gravitee, Descope, Keycloak (marcado «in progress») y otros.</li>
<li><strong>Los servidores de autorización que los aceptan</strong> incluyen Okta, Oracle OCI IAM, Ping, Gravitee, Auth0 (acceso anticipado), Stytch y WorkOS AuthKit (acceso anticipado).</li>
<li><strong>Las aplicaciones y herramientas de IA que actúan como clientes</strong> incluyen Claude, OpenAI Codex CLI y Visual Studio Code (versión preliminar).</li>
<li><strong>Las aplicaciones en el lado receptor</strong> incluyen Asana, Atlassian, Linear, Notion y Slack, algunas en beta.</li>
</ul>
<p>Algunos ejemplos con fecha:</p>
<ul>
<li><strong>Oracle</strong>: el 9 de octubre de 2026 Oracle publicó el intercambio de tokens ID-JAG en OCI IAM.</li>
<li><strong>Gravitee</strong>: Access Management 4.13, anunciado el 12 de noviembre de 2026, puede desempeñar ambos papeles: emitir ID-JAG y aceptarlos.</li>
<li><strong>Okta</strong>: el 13 de noviembre de 2026 anunció la disponibilidad general de la compatibilidad con proveedores de identidad de terceros, y cita a Ping, Descope y Oracle como proveedores habilitados para XAA con cuyos usuarios y agentes puede trabajar.</li>
<li><strong>MCP</strong>: el Model Context Protocol, una forma habitual de conectar herramientas de IA con aplicaciones, tiene una extensión «Enterprise-Managed Authorization» que usa un ID-JAG. El blog del proyecto la anunció como estable en junio de 2026.</li>
</ul>
<p>Microsoft Entra no figuraba en la lista de oauth.net en el momento de la comprobación.</p>
<h2>Diferencias con las pantallas de consentimiento y el on-behalf-of</h2>
<table>
<thead>
<tr>
<th></th>
<th>Solicitud de consentimiento</th>
<th>On-behalf-of (OBO)</th>
<th>ID-JAG / XAA</th>
</tr>
</thead>
<tbody>
<tr>
<td><strong>Quién aprueba</strong></td>
<td>El usuario, aplicación por aplicación</td>
<td>El consentimiento previo del usuario, transmitido</td>
<td>El inicio de sesión corporativo, según reglas fijadas por un administrador</td>
</tr>
<tr>
<td><strong>Qué ve el usuario</strong></td>
<td>Una solicitud por aplicación</td>
<td>Normalmente nada tras el primer inicio de sesión</td>
<td>Nada</td>
</tr>
<tr>
<td><strong>Dónde funciona</strong></td>
<td>En cualquier lugar donde funcione OAuth</td>
<td>Un servicio que llama a otro, dentro de un solo sistema de identidad</td>
<td>Entre aplicaciones y organizaciones que gestionan cada una su propio servidor de autorización</td>
</tr>
<tr>
<td><strong>Control central</strong></td>
<td>Limitado</td>
<td>Parcial</td>
<td>El objetivo del diseño</td>
</tr>
</tbody>
</table>
<p><strong>Frente a las pantallas de consentimiento:</strong> una solicitud de consentimiento pregunta al usuario cada vez. Un ID-JAG aplica una vez las reglas de la organización y después las hace cumplir en silencio.</p>
<p><strong>Frente al <a href="https://iamops.dev/es/entra-on-behalf-of-agent-middle-tier/">on-behalf-of</a>:</strong> la documentación de Microsoft describe el OBO como una API web que usa la identidad de un usuario para llamar a otra API, transmitiendo a lo largo de la cadena la identidad y los permisos del usuario. Ocurre dentro de la plataforma de identidad de Microsoft. El ID-JAG aborda un problema afín entre fronteras: las dos aplicaciones tienen servidores de autorización distintos y un tercero, el inicio de sesión corporativo, da fe del usuario. Desde el punto de vista del usuario se parecen, pero la confianza está organizada de otra manera.</p>
<h2>Una consideración</h2>
<p>Menos solicitudes significan más comodidad, pero también menos momentos en los que una persona revisa la petición. Es una valoración, no una afirmación del estándar: el diseño solo ayuda si las políticas de la organización son sólidas y se revisan con regularidad. El ID-JAG hace <strong>posible</strong> ver y controlar el acceso de los agentes en un solo lugar. Alguien tiene que seguir ejerciendo ese control.</p>
<p>Este artículo se actualizará a medida que el borrador avance hacia el last call del grupo de trabajo.</p>
]]></content:encoded>
    </item>
    <item>
      <title>Los bancos de EE. UU. dejan en manos del cliente la responsabilidad de los agentes de IA de terceros</title>
      <link>https://iamops.dev/es/banks-ai-agents-customer-liability/</link>
      <guid isPermaLink="true">https://iamops.dev/es/banks-ai-agents-customer-liability/</guid>
      <pubDate>Wed, 18 Nov 2026 08:00:00 GMT</pubDate>
      <dc:creator>Argo</dc:creator>
      <category>Noticias</category>
      <category>Agentes de IA</category>
      <category>Banca</category>
      <category>Seguridad</category>
      <category>Responsabilidad</category>
      <description>El 18 de noviembre de 2026 TechCrunch informó que Citi, PNC y bancos US tratan los actos de un agente IA de terceros como del cliente. Qué dicen los términos.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/es/banks-ai-agents-customer-liability.png?v=986e5733" alt="" /></p><p><strong>En resumen</strong></p>
<ul>
<li>El 18 de noviembre de 2026, TechCrunch informó de que Citi actualizó su Online User Agreement esa semana: quien concede acceso a un agente de IA de terceros es responsable de lo que ese agente hace, incluso si la herramienta filtra credenciales o es atacada.</li>
<li>El mismo artículo indica que JPMorgan y Bank of America anunciaron políticas similares en octubre de 2026, que PNC cambió sus términos el 18 de noviembre y que Citizens escribió a sus clientes esa misma semana.</li>
<li>El aviso de Wells Fargo indica que un Online Access Agreement actualizado entra en vigor el 24 de noviembre de 2026: una herramienta de IA de terceros no la opera el banco, y las solicitudes pueden tratarse como si vinieran de usted.</li>
<li>Según TechCrunch, los agentes de IA que Citi misma proporciona se pueden usar sin esa responsabilidad extra. Hasta que un banco distinga a una persona de un agente, un acceso compartido se trata como si fuera usted.</li>
</ul>
<p>El 18 de noviembre de 2026, TechCrunch informó de que varios grandes bancos de Estados Unidos han actualizado sus términos para los clientes que dan a un agente de IA de terceros acceso a una cuenta. El cambio no es una prohibición. Es una declaración sobre quién es responsable cuando algo sale mal.</p>
<h2>Qué dijeron los bancos</h2>
<p>Citibank actualizó su Online User Agreement en la semana del 18 de noviembre de 2026. Un portavoz de Citi dijo a TechCrunch que los clientes que conceden acceso a la cuenta a agentes de IA de terceros son responsables de las actividades realizadas a través de esos agentes. TechCrunch también informó de que la actualización de Citi va más allá: si la herramienta de IA filtra las credenciales, o es atacada, el cliente es responsable de lo que los atacantes hagan después con la cuenta.</p>
<p>El mismo artículo indica que JPMorgan y Bank of America anunciaron políticas similares en octubre de 2026, que PNC cambió sus términos el 18 de noviembre y que Citizens escribió a sus clientes esa misma semana.</p>
<p>Wells Fargo ha publicado su propio aviso a los clientes: un Online Access Agreement actualizado entra en vigor el 24 de noviembre de 2026. El banco dice que si usa una herramienta o un agente de IA de terceros para acceder a sus cuentas, la herramienta no la opera Wells Fargo, que las solicitudes enviadas a través de la herramienta pueden tratarse como si vinieran directamente de usted, y que se reserva el derecho de restringir o bloquear el acceso de ciertas herramientas de IA de terceros.</p>
<p>No soy abogado, y esto no es un consejo legal. Algunos de estos términos, incluido el de Wells Fargo, dejan margen para las protecciones que la ley ya le otorga. La dirección sigue siendo clara.</p>
<h2>Por qué ocurre ahora</h2>
<p>Un agente de IA que inicia sesión con el nombre de usuario y la contraseña del cliente parece, para el banco, el cliente. El rastro de auditoría, el registro de quién hizo qué, no muestra un actor distinto. Por eso un banco puede decir que el pago del agente, o el pago de un atacante después de una filtración de credenciales, fue autorizado por usted.</p>
<p>TechCrunch señala un contraste útil en los propios términos de Citi: los agentes de IA que Citi misma proporciona se pueden usar sin esa responsabilidad extra. El banco traza una línea entre las herramientas que controla y las que no controla.</p>
<p>La herramienta de finanzas personales de Anthropic, mencionada en el mismo artículo, se describe como de solo lectura: «no puede mover, gestionar ni invertir su dinero». Eso reduce el riesgo de que salga un pago, aunque no resuelve el caso en el que una herramienta que solo lee una cuenta sigue teniendo un inicio de sesión.</p>
<figure class="b-fig"><img src="https://iamops.dev/img/banks-ai-agents-customer-liability.es.svg" alt="Cuatro pasos en fila: un cliente comparte un inicio de sesión con un agente de IA, el agente actúa o es atacado, el banco solo ve las credenciales del cliente y trata la acción como suya. Un acceso compartido no deja un rastro distinto." width="1200" height="630" loading="lazy" decoding="async"><figcaption><strong>Lo que el banco puede ver.</strong> Una vez que el cliente comparte un inicio de sesión, el banco no tiene un rastro distinto para el agente. Un pago, o un acceso usado después de una filtración, puede parecer el cliente actuando solo.</figcaption></figure>
<h2>Qué haría yo</h2>
<p>No entregue el inicio de sesión de una cuenta bancaria a una herramienta de IA de terceros a menos que tenga un motivo claro y entienda los términos. Si una herramienta ya tiene ese acceso, revóquelo en el proveedor, cambie la contraseña si la herramienta la tenía, y conserve un registro.</p>
<p>El mejor modelo a largo plazo es un agente con nombre y un permiso estrecho y limitado en el tiempo, que pueda desactivar sin cambiar su propia contraseña. Los bancos y los proveedores empiezan a hablar de ello, pero los términos comunicados el 18 de noviembre siguen presuponiendo un acceso compartido. Mientras el banco no pueda distinguir a una persona de un agente, el agente es usted.</p>
<p>Si le interesa el lado técnico de cómo un agente puede obtener un token sin compartir una contraseña, escribí sobre <a href="https://iamops.dev/es/id-jag-explained/">ID-JAG</a>. El 17 de noviembre Microsoft también publicó un análisis de laboratorio sobre el <a href="https://iamops.dev/es/device-code-phishing-ai-agents/">device code phishing contra asistentes de código de IA</a>.</p>
]]></content:encoded>
    </item>
    <item>
      <title>Device code phishing y agentes de IA: riesgos y medidas de mitigación</title>
      <link>https://iamops.dev/es/device-code-phishing-ai-agents/</link>
      <guid isPermaLink="true">https://iamops.dev/es/device-code-phishing-ai-agents/</guid>
      <pubDate>Tue, 17 Nov 2026 08:00:00 GMT</pubDate>
      <dc:creator>Argo</dc:creator>
      <category>Noticias</category>
      <category>Phishing</category>
      <category>Device code</category>
      <category>Agentes de IA</category>
      <category>Seguridad</category>
      <description>Microsoft mostró en laboratorio que un código de dispositivo aprobado puede dar a un atacante el control de un asistente de código con IA. Riesgos y medidas.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/es/device-code-phishing-ai-agents.png?v=986e5733" alt="" /></p><p><strong>En resumen</strong></p>
<ul>
<li>El phishing con device code engaña a una persona para que apruebe un inicio de sesión que ha iniciado un atacante.</li>
<li>En una prueba de laboratorio controlada, Microsoft mostró que un solo código aprobado podía permitir a un atacante dirigir una sesión de GitHub Copilot CLI y llegar al historial de sesiones en la nube y a repositorios privados, según la configuración.</li>
<li>Son resultados de prueba de concepto; Microsoft dice que no los ha visto en ataques reales, aunque el phishing con device code es una vía recurrente de toma de cuentas.</li>
<li>Introduce un device code solo si has iniciado tú la solicitud.</li>
<li>Revisa las aplicaciones conectadas a tus cuentas y usa los ajustes más restrictivos de control remoto y almacenamiento de sesiones que permitan tus herramientas de IA.</li>
</ul>
<p>El inicio de sesión con código de dispositivo (device code) es el flujo en el que un dispositivo sin teclado cómodo muestra un código corto que el usuario introduce en un segundo dispositivo para autenticarse. Lo usan los televisores inteligentes y también muchas herramientas de línea de comandos empleadas por desarrolladores.</p>
<p>El 17 de noviembre de 2026, los investigadores de seguridad de Microsoft publicaron un análisis de cómo ese mismo flujo puede usarse contra los asistentes de programación con IA.</p>
<h2>El patrón del ataque</h2>
<p>En el <em>device code phishing</em>, el <strong>atacante</strong> inicia el inicio de sesión en su propio equipo, recibe un código y se lo envía a la víctima. El mensaje puede parecer una petición del departamento de TI o una comprobación de licencia. La víctima abre la página de inicio de sesión auténtica, introduce el código y aprueba, con lo que inicia sesión al atacante.</p>
<p>La página de inicio de sesión es legítima, y por eso funciona la técnica. En palabras de Microsoft, el sitio legítimo por sí solo no le dice al usuario quién inició la solicitud.</p>
<figure class="b-fig"><img src="https://iamops.dev/img/device-code-phishing-ai-agents.es.svg" alt="Diagrama de secuencia con tres partes: el atacante, la persona y la página de inicio de sesión real. El atacante pide un device code y envía el user code a la persona. Ella lo introduce en la página real y aprueba, y la consulta del atacante recibe los tokens de la cuenta de la persona." width="1200" height="630" loading="lazy" decoding="async"><figcaption><strong>El flujo visto desde el atacante.</strong> Los pasos 1 y 4 se ejecutan en la máquina del atacante. La persona solo hace el paso 3, en una página que sí pertenece al servicio de inicio de sesión, así que lo único que se puede comprobar es el código.</figcaption></figure>
<h2>Qué demostró Microsoft</h2>
<p>El equipo realizó una <strong>prueba de laboratorio controlada</strong> con la herramienta de línea de comandos de GitHub Copilot como ejemplo. Con un solo código aprobado, pudo, según la configuración de la cuenta:</p>
<ul>
<li>dirigir de forma remota una sesión activa del asistente y hacer que ejecutara comandos en el equipo de la persona,</li>
<li>añadir entradas engañosas a la memoria del asistente,</li>
<li>leer el historial de sesiones almacenado en la nube,</li>
<li>acceder a los repositorios de código privados visibles para la cuenta.</li>
</ul>
<p>Microsoft aclara que son resultados de prueba de concepto y que no ha observado estos cuatro resultados en ataques reales. El device code phishing en sí es otra cuestión. Según Microsoft, ha sido una vía recurrente de toma de cuentas y cita campañas anteriores, entre ellas una llamada EvilTokens, que ayudó a desarticular en septiembre de 2026.</p>
<h2>Medidas de mitigación recomendadas</h2>
<ul>
<li><strong>Introduce un código de dispositivo solo si lo has solicitado tú</strong>, en una pantalla que hayas iniciado tú. Un código que llega en un mensaje de otra persona es una señal de alerta, incluso cuando la página es auténtica.</li>
<li><strong>Revisa las aplicaciones conectadas a tus cuentas</strong> y elimina las que no reconozcas. La guía de Microsoft cita como ejemplo los ajustes «authorized OAuth apps» de GitHub.</li>
<li><strong>Usa los ajustes más restrictivos</strong> que permitan tus herramientas de IA para el control remoto y el almacenamiento de sesiones en la nube.</li>
</ul>
<p>La idea más general de Microsoft es que cuanto más puede alcanzar un asistente de IA, más vale una sola aprobación obtenida mediante phishing.</p>
<p><em>Fuente: <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 de noviembre de 2026</a>.</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>Device code phishing: una nota para responsables después de la prueba de laboratorio de Microsoft</title>
      <link>https://iamops.dev/es/device-code-phishing-briefing-for-managers/</link>
      <guid isPermaLink="true">https://iamops.dev/es/device-code-phishing-briefing-for-managers/</guid>
      <pubDate>Tue, 17 Nov 2026 08:00:00 GMT</pubDate>
      <dc:creator>Argo</dc:creator>
      <category>Noticias</category>
      <category>Phishing</category>
      <category>Device code</category>
      <category>Agentes de IA</category>
      <category>Seguridad</category>
      <description>El 17 de noviembre de 2026 Microsoft mostró en laboratorio que un device code puede entregar a un atacante un asistente de IA. Qué es y qué decir al equipo.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/es/device-code-phishing-briefing-for-managers.png?v=986e5733" alt="" /></p><p><strong>En resumen</strong></p>
<ul>
<li>El 17 de noviembre de 2026, Microsoft publicó un análisis de laboratorio sobre el device code phishing contra asistentes de código de IA. La página que ve la persona es auténtica; la solicitud es del atacante.</li>
<li>En el laboratorio, una sola solicitud de GitHub con device code aprobada permitió a los investigadores dirigir una sesión, escribir una memoria engañosa, leer el historial de sesiones en la nube o alcanzar repositorios privados, según la configuración.</li>
<li>Microsoft afirma que esos cuatro resultados son una prueba de concepto y no se han visto en ataques reales. El device code phishing en sí es una vía recurrente para tomar el control de una cuenta.</li>
<li>Introduzca un device code solo para un acceso que usted mismo haya iniciado. Revise las aplicaciones conectadas y limite lo que el asistente puede alcanzar.</li>
</ul>
<p>El acceso con device code es el flujo en el que un dispositivo sin un teclado cómodo muestra un código corto, y usted lo introduce en otro dispositivo para aprobar el inicio de sesión. Lo usan los televisores conectados. También muchas herramientas de línea de comandos.</p>
<p>El 17 de noviembre de 2026, los investigadores de seguridad de Microsoft publicaron un análisis de cómo el mismo flujo puede volverse contra los asistentes de programación basados en IA. Ya escribí un <a href="https://iamops.dev/es/device-code-phishing-ai-agents/">artículo más largo</a> sobre el detalle técnico. Esta es la nota más breve que daría a un responsable.</p>
<h2>Qué es realmente el ataque</h2>
<p>En el device code phishing, el atacante inicia el acceso en su propia máquina y recibe un código corto. Lo envía a otra persona, a menudo disfrazado de una petición de informática o de una comprobación de licencia. La persona abre la página de inicio de sesión auténtica, introduce el código y aprueba. Así el atacante queda conectado.</p>
<p>La página es real. Por eso funciona el truco. El punto de Microsoft es que un sitio legítimo no le dice quién inició la solicitud. La página de verificación de GitHub, señala Microsoft, advierte que nunca se use un código enviado por otra persona.</p>
<figure class="b-fig"><img src="https://iamops.dev/img/device-code-phishing-briefing-for-managers.es.svg" alt="Tres pasos en fila: alguien le envía un código corto, usted lo introduce en una página de inicio de sesión real y la persona que inició la solicitud queda conectada. Apruebe un código solo si usted inició el acceso." width="1200" height="630" loading="lazy" decoding="async"><figcaption><strong>Lo que hace realmente la persona.</strong> El único paso que da es introducir un código corto en una página de inicio de sesión real. La solicitud detrás de ese código la inició otra persona.</figcaption></figure>
<h2>Qué mostró Microsoft en el laboratorio</h2>
<p>El equipo usó la herramienta de línea de comandos de GitHub Copilot como ejemplo. La técnica no se limita a esa herramienta: cualquier cliente público que admita este flujo de acceso puede abusarse del mismo modo, y el atacante elige qué permisos pedir. Un cliente público es una aplicación que no puede guardar un secreto, como una herramienta de línea de comandos o un televisor.</p>
<p>En una prueba de laboratorio controlada, una cuenta de prueba aprobó una solicitud de GitHub con device code que habían iniciado los investigadores. Con esa sola aprobación, según la configuración de la cuenta, pudieron:</p>
<ul>
<li>dirigir de forma remota una sesión activa del asistente y hacer que ejecutara comandos en la máquina de la persona,</li>
<li>añadir entradas engañosas a la memoria del asistente,</li>
<li>leer el historial de sesiones guardado en la nube,</li>
<li>alcanzar repositorios de código privados visibles para la cuenta.</li>
</ul>
<p>Microsoft afirma que se trata de resultados de prueba de concepto, y que no ha visto esos cuatro desenlaces en ataques reales. El device code phishing en sí es más antiguo. Microsoft lo describe como una vía recurrente para tomar el control de una cuenta, y nombra campañas anteriores, entre ellas una llamada EvilTokens que ayudó a interrumpir en septiembre de 2026.</p>
<h2>Qué diría a un equipo</h2>
<p>Introduzca un device code solo para un acceso que usted mismo haya iniciado, en una pantalla que haya abierto. Un código que llega en un mensaje de otra persona es una alerta, incluso cuando la página es auténtica.</p>
<p>Revise las aplicaciones conectadas a las cuentas de trabajo y quite las que nadie reconoce. Microsoft señala, como ejemplo, la configuración de GitHub para las aplicaciones OAuth autorizadas. Las aplicaciones OAuth son las que una persona ha permitido usar una cuenta.</p>
<p>Para las herramientas de código de IA, use la configuración más estricta que pueda aceptar para el control remoto, el almacenamiento de sesiones en la nube y la memoria. Una aprobación solo vale tanto como lo que el asistente puede alcanzar.</p>
<p>Microsoft también describe detecciones en Microsoft Defender para este tipo de phishing llegado por correo o por Teams, y una forma de suspender una identidad GitHub administrada. Eso corresponde a los equipos de seguridad. El hábito que pediría a todos es el primero: si usted no inició el acceso, no introduzca el código.</p>
<p>El <a href="https://iamops.dev/es/device-code-phishing-ai-agents/">artículo más largo</a> tiene el paso a paso del flujo y la misma fuente.</p>
]]></content:encoded>
    </item>
    <item>
      <title>Flujo on-behalf-of de Microsoft Entra para la capa intermedia de un agente: certificado, sin secretos</title>
      <link>https://iamops.dev/es/entra-on-behalf-of-agent-middle-tier/</link>
      <guid isPermaLink="true">https://iamops.dev/es/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>Agentes de IA</category>
      <category>OAuth</category>
      <category>Identidad de workload</category>
      <description>Lab en un tenant de prueba: device code, la API del agente cambia el token on-behalf-of con certificado, sin secretos; un scope sin consentimiento falla.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/es/entra-on-behalf-of-agent-middle-tier.png?v=986e5733" alt="" /></p><p><strong>En resumen</strong></p>
<ul>
<li>Para los agentes que llaman a API en nombre de un usuario con sesión iniciada, la respuesta actual de Entra es el flujo on-behalf-of (OBO); ID-JAG es hoy solo una encuesta de disponibilidad.</li>
<li>La middle API se identifica con una aserción firmada con certificado y no guarda ningún secreto de cliente.</li>
<li>Un inicio de sesión produce tokens distintos por audiencia: el usuario sigue siendo el mismo y cambia la aplicación que llama.</li>
<li>Un scope sin consentimiento falla con AADSTS65001; lo que cuenta es el consentimiento en el service principal.</li>
<li>Los tokens OBO no conservan el cliente original, así que las auditorías deben cruzar los registros de inicio de sesión.</li>
</ul>
<p>El 14 de noviembre de 2026 Microsoft añadió un artículo de Learn que por primera vez nombra <a href="https://iamops.dev/es/id-jag-explained/">ID-JAG</a> junto a Microsoft Entra Agent ID y abre un formulario de interés. Es una encuesta de disponibilidad, no una función lanzada: hoy Entra ni emite ni acepta ID-JAG. Para los agentes que deben llamar a API por un usuario con sesión iniciada, la respuesta actual de Entra es el flujo on-behalf-of (OBO). Lo ejecuté de principio a fin en un tenant desechable y anoté qué hace cada paso.</p>
<h2>Qué muestra el laboratorio</h2>
<p>Tres registros de aplicación representan un sistema de agentes:</p>
<table>
<thead>
<tr>
<th>Aplicación</th>
<th>Función</th>
<th>Credencial</th>
</tr>
</thead>
<tbody>
<tr>
<td>Client</td>
<td>La interfaz o la línea de comandos del agente. Cliente público, inicio de sesión con device code.</td>
<td>Ninguna</td>
</tr>
<tr>
<td>Agent Middle API</td>
<td>El back end del agente. Realiza el intercambio OBO.</td>
<td>Un certificado X.509, <strong>cero secretos de cliente</strong></td>
</tr>
<tr>
<td>Resource API</td>
<td>La API posterior. Expone el scope delegado <code>Data.Read</code>.</td>
<td>n/a</td>
</tr>
</tbody>
</table>
<p>El usuario inicia sesión una vez en el Client. El Client guarda un token cuya audiencia es solo la middle API. La middle API lo intercambia por un token para la Resource API y otro para Microsoft Graph, demostrando quién es con una aserción firmada con certificado en lugar de un secreto.</p>
<h2>Preparación</h2>
<p>Use un <strong>tenant de prueba aparte</strong> (basta Entra ID Free, no se necesitan recursos de Azure). Los tokens OBO llevan claims reales del usuario, y un tenant desechable mantiene los experimentos lejos del consentimiento, el acceso condicional y los registros de auditoría de producción. En el portal:</p>
<ol>
<li>Registre la Resource API y exponga un scope delegado <code>Data.Read</code> (administradores y usuarios).</li>
<li>Registre la Agent Middle API, exponga <code>access_as_user</code> y añada los permisos delegados <code>Data.Read</code> y Microsoft Graph <code>User.Read</code>; después conceda el consentimiento de administrador.</li>
<li>Genere con <code>openssl</code> una clave RSA de 2048 bits y un certificado autofirmado de 60 días, deje la clave privada en la máquina (modo 0600) y suba solo el certificado público en <em>Certificates &amp; secrets</em>.</li>
<li>Registre el Client como cliente público (redirección <code>http://localhost</code>, <em>Allow public client flows</em> activado) con permiso para <code>access_as_user</code> y <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="Salida de terminal de openssl con el sujeto del certificado y la huella SHA-1, sustituida por un marcador." width="1894" height="301" loading="lazy" decoding="async"><figcaption><strong>La credencial.</strong> Un certificado autofirmado es la única credencial de la middle API. La huella está sustituida por un marcador; la clave privada nunca se muestra.</figcaption></figure>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/11-no-secrets.webp" alt="Centro de administración de Microsoft Entra, página Certificates and secrets de la Agent Middle API con la pestaña Client secrets abierta, que muestra cero secretos de cliente." width="1280" height="665" loading="lazy" decoding="async"><figcaption><strong>Sin secretos.</strong> La pestaña Client secrets muestra 0. Un certificado demuestra la posesión de una clave que nunca viaja; un secreto es una cadena reutilizable que acaba en configuraciones y registros.</figcaption></figure>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/08-permissions.webp" alt="Centro de administración de Microsoft Entra, API permissions de la Agent Middle API: User.Read de Microsoft Graph y Data.Read de la Resource API, ambos delegados y concedidos para el directorio." width="1280" height="665" loading="lazy" decoding="async"><figcaption><strong>Lo que puede pedir la capa intermedia.</strong> Entra comprueba estos permisos delegados en el momento del intercambio. Lo que no figura y no tiene consentimiento no puede obtenerse aguas abajo.</figcaption></figure>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/17-consent.webp" alt="Centro de administración de Microsoft Entra, Enterprise applications, Permissions del service principal de la Agent Middle API, con el consentimiento de administrador para User.Read y Data.Read." width="1280" height="665" loading="lazy" decoding="async"><figcaption><strong>Lo que obtuvo de verdad.</strong> Los registros de aplicación muestran lo que una app pide; los permisos del service principal muestran lo que se le dio. Las herramientas de gobierno deberían leer estos últimos.</figcaption></figure>
<h2>La ejecución</h2>
<p><strong>Inicio de sesión con <a href="https://iamops.dev/es/device-code-phishing-ai-agents/">device code</a>.</strong> El Client pide un código al endpoint <code>devicecode</code> v2.0. La petición lleva solo el ID del Client y el scope de la middle API, ningún secreto. El usuario introduce el código en un segundo dispositivo y Entra muestra una comprobación «aprobar el inicio de sesión en otro dispositivo» que nombra la app y la ubicación; el usuario debe aprobarla a mano.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/18-devicecode.webp" alt="Salida de terminal de la solicitud de autorización de dispositivo y su respuesta, con tenant, ID de cliente y código de usuario sustituidos por marcadores." width="1894" height="530" loading="lazy" decoding="async"><figcaption><strong>Autorización de dispositivo.</strong> Los identificadores y el código de usuario son marcadores.</figcaption></figure>
<p><strong>El token de usuario.</strong> Tras la aprobación, el Client consulta el endpoint de tokens. Su token no sirve directamente contra la Resource API ni contra Graph, porque su audiencia es 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 decodificados del token de usuario: la audiencia es la middle API, appid es el Client y el scope es access_as_user. Identificadores y nombre del usuario sustituidos por marcadores." width="1894" height="607" loading="lazy" decoding="async"><figcaption><strong>El único token del Client.</strong> Audiencia: la middle API. Aplicación: el Client. Scope: access_as_user.</figcaption></figure>
<p><strong>El intercambio.</strong> La middle API construye una aserción de cliente (un JWT RS256 con la huella del certificado en <code>x5t</code>; emisor y sujeto son su propio ID de cliente; audiencia, el endpoint de tokens; diez minutos de vida), la firma con la clave privada y envía la petición 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 decodificados del token OBO para la Resource API: la audiencia es la Resource API, appid la middle API, scope Data.Read, mismo ID de objeto del usuario. Identificadores sustituidos por marcadores." width="1894" height="607" loading="lazy" decoding="async"><figcaption><strong>Token para la Resource API.</strong> Audiencia: la Resource API. Aplicación: la middle API. Scope: Data.Read. Mismo usuario.</figcaption></figure>
<p>La misma aserción con el scope <code>https://graph.microsoft.com/User.Read</code> devuelve un token de Graph, que el laboratorio usa una vez para <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 decodificados del token OBO para Microsoft Graph y respuesta de la llamada Graph me, con el nombre y el nombre principal del usuario sustituidos por marcadores." width="1894" height="721" loading="lazy" decoding="async"><figcaption><strong>Token para Microsoft Graph y después una llamada a /me.</strong> Un solo inicio de sesión se ramifica en varios tokens, cada uno ligado a una audiencia. El nombre y el nombre principal del usuario son marcadores.</figcaption></figure>
<p><strong>Comparar los tres tokens.</strong> El usuario nunca cambia. La audiencia sigue a la API que se llama y <code>appid</code> pasa del Client a 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="Tabla en paralelo de audiencia, appid, scope, ID de objeto e ID de tenant para el token de usuario y los dos tokens OBO. Identificadores sustituidos por marcadores." width="1894" height="416" loading="lazy" decoding="async"><figcaption><strong>Tres tokens en paralelo.</strong> Mismo usuario y mismo tenant; en cada salto cambian la audiencia y la aplicación que llama.</figcaption></figure>
<p><strong>La prueba negativa.</strong> Pedir <code>https://graph.microsoft.com/Mail.Read</code>, que nadie ha consentido, falla en el servicio de tokens:</p>
<figure class="b-fig"><img src="https://iamops.dev/media/entra-on-behalf-of-agent-middle-tier/28-negative.webp" alt="Salida de terminal de un error invalid_grant AADSTS65001: el usuario o el administrador no ha dado su consentimiento para usar la aplicación. ID de aplicación, ID de traza e ID de correlación sustituidos por marcadores." width="1894" height="416" loading="lazy" decoding="async"><figcaption><strong>AADSTS65001.</strong> El consentimiento se comprueba al emitir el token, sobre el service principal de la capa intermedia. Para un agente no interactivo no hay recurso a una solicitud interactiva.</figcaption></figure>
<h2>Trampas habituales</h2>
<ul>
<li><strong>Se pierde el cliente original.</strong> Los tokens OBO v1 solo registran la última aplicación (<code>appid</code>). No hay claim <code>act</code> como en una implementación de RFC 8693, así que una auditoría debe cruzar los registros de inicio de sesión para reconstruir la cadena.</li>
<li><strong>La audiencia de entrada debe ser la middle API.</strong> Un token dirigido a otra app se rechaza: es la protección contra el confused deputy.</li>
<li><strong>Device code exige «Allow public client flows».</strong> Es también el flujo que explota el device code phishing. La pantalla «aprobar el inicio de sesión en otro dispositivo» es la mitigación de Microsoft; enseñe a los usuarios a pulsar «No fui yo» y restrinja el flujo con acceso condicional donde los agentes no lo necesiten.</li>
<li><strong>Cuenta el consentimiento de administrador en el service principal</strong>, no lo que enumera el registro.</li>
</ul>
<h2>Conclusiones de seguridad</h2>
<ol>
<li>Use un certificado o una credencial federada para la capa intermedia. Sin secreto no hay nada reutilizable que pueda filtrarse de la configuración, las variables de CI o los registros.</li>
<li>Mantenga mínimos los scopes delegados de la capa intermedia y revíselos en el service principal.</li>
<li>Deje el Client sin credenciales. Solo podrá guardar el token del usuario para la middle API, nunca un token posterior.</li>
<li>Planifique el cruce de datos de auditoría (usuario, agente, audiencia posterior), porque los tokens OBO no conservan el primer salto.</li>
<li>Anote qué concesión usa cada salto (OBO hoy; ID-JAG cuando Entra lo admita) y dónde reside el consentimiento, para que las revisiones de acceso vean las concesiones de los service principals.</li>
</ol>
<h2>Qué no se ejecutó</h2>
<p>No se ejecutaron los blueprints ni las identidades de agente de Entra Agent ID (el mismo laboratorio con permisos heredables). No se probó la directiva de acceso condicional que bloquea device code. Las tareas adicionales (retirar el consentimiento y repetir el intercambio, claims opcionales, tokens v2) no se ejecutaron. Las capturas del portal están recortadas al contenido de la página: se eliminaron la barra del navegador, el menú de perfil y todos los identificadores de tenant, aplicaciones y usuarios. Para este laboratorio no se publica ninguna grabación.</p>
<p><em>Las imágenes del terminal se generaron a partir de la salida guardada de la ejecución, con los identificadores sustituidos por marcadores. Las capturas del portal muestran solo el contenido de la página.</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>OAuth Token Exchange con Keycloak (RFC 8693): restringir tokens para agentes de IA y servidores MCP</title>
      <link>https://iamops.dev/es/keycloak-token-exchange-rfc-8693/</link>
      <guid isPermaLink="true">https://iamops.dev/es/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>Intercambio de tokens</category>
      <category>Keycloak</category>
      <category>RFC 8693</category>
      <category>MCP</category>
      <category>Agentes de IA</category>
      <description>Laboratorio con Keycloak: un servidor MCP cambia el token del usuario por otro más estrecho para una API posterior y se rechazan tres intercambios no válidos.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/es/keycloak-token-exchange-rfc-8693.png?v=986e5733" alt="" /></p><p><strong>En resumen</strong></p>
<ul>
<li>El intercambio de tokens RFC 8693 permite a un servidor MCP cambiar el token del usuario por otro más estrecho, dirigido a una sola API posterior.</li>
<li>En Keycloak se activa por cliente, y la audiencia posterior es un scope opcional.</li>
<li>El token intercambiado mantiene al usuario como sujeto, tiene solo la audiencia posterior, dura 300 segundos y no incluye refresh token.</li>
<li>Se rechazan tres intercambios no válidos: un cliente sin el privilegio, una audiencia sin scope y la petición de un refresh token.</li>
<li>En esta configuración no hay claim act, así que el cliente que actúa aparece solo como authorized party.</li>
</ul>
<p>El 12 de noviembre de 2026 Amazon Cognito añadió OAuth 2.0 Token Exchange (RFC 8693), pocos días después que WorkOS Connect. Entra lleva años con su propio flujo on-behalf-of. El patrón ya es común a los grandes proveedores de identidad: un servicio que actúa por un usuario intercambia el token de este por un token nuevo, más restringido, ligado a un solo destinatario (audiencia) y de corta duración, en lugar de reenviar el original. Lo probé contra un Keycloak local y anoté qué hizo el servidor.</p>
<p>Este laboratorio ejecuta el patrón en un portátil con Keycloak, un servidor de autorización de código abierto, para ver exactamente qué cambia dentro del token y qué rechaza el servidor.</p>
<h2>Qué muestra el laboratorio</h2>
<p>Un agente de IA inicia sesión al usuario y recibe un token para un <a href="https://iamops.dev/es/mcp-server-no-token-passthrough/">servidor MCP</a>. El servidor MCP debe llamar a una API de pagos por ese usuario, pero no debe reenviar el token del agente. En su lugar lo presenta al servidor de autorización y pide un token válido solo para la API de pagos.</p>
<p>El laboratorio usa tres clientes en un realm:</p>
<table>
<thead>
<tr>
<th>Cliente</th>
<th>Función</th>
<th>¿Puede intercambiar tokens?</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>agent</code></td>
<td>Obtiene el token del usuario (password grant, solo atajo de laboratorio)</td>
<td>No</td>
</tr>
<tr>
<td><code>mcp-server</code></td>
<td>Intercambia el token del usuario</td>
<td>Sí</td>
</tr>
<tr>
<td><code>payments-api</code></td>
<td>Solo una audiencia, la API posterior</td>
<td>No</td>
</tr>
</tbody>
</table>
<h2>Preparación</h2>
<p>Keycloak 26.8.2 se ejecutó desde la distribución zip con Java 21, en modo desarrollo y tras descomprimir de cero. El modo desarrollo es solo para laboratorios. Las contraseñas son valores desechables; en este artículo aparecen como <code>&lt;lab-password&gt;</code> y <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="Salida de terminal del script de preparación que crea el realm agentlab, un usuario, tres clientes y dos client scopes, con los identificadores sustituidos por marcadores entre corchetes angulares." width="1894" height="492" loading="lazy" decoding="async"><figcaption><strong>Preparación.</strong> El script crea el realm, un usuario de prueba, los tres clientes y dos client scopes que añaden audiencias. Los ID de los objetos están sustituidos por marcadores.</figcaption></figure>
<p>En la consola de administración dos ajustes sostienen el diseño. Solo <code>mcp-server</code> tiene activado <strong>Standard Token Exchange</strong>, y la audiencia posterior es un scope <em>opcional</em>, de modo que solo se añade cuando el intercambio la pide.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/keycloak-token-exchange-rfc-8693/05-exchange-toggle.webp" alt="Consola de administración de Keycloak, configuración de capacidades del cliente mcp-server, con la casilla Standard Token Exchange marcada." width="1600" height="960" loading="lazy" decoding="async"><figcaption><strong>El privilegio.</strong> Standard Token Exchange está marcado solo en el cliente mcp-server. Un cliente agente comprometido no puede emitir tokens para otras API.</figcaption></figure>
<figure class="b-fig"><img src="https://iamops.dev/media/keycloak-token-exchange-rfc-8693/06-client-scopes.webp" alt="Consola de administración de Keycloak, client scopes del cliente mcp-server, con el scope aud-payments-api indicado como Optional." width="1600" height="960" loading="lazy" decoding="async"><figcaption><strong>La audiencia.</strong> aud-payments-api es opcional para mcp-server, así que la audiencia posterior debe pedirse de forma explícita.</figcaption></figure>
<h2>La ejecución</h2>
<p>El agente obtiene un token de usuario y luego el servidor MCP lo intercambia. La petición central es una sola llamada al endpoint de tokens:</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="Salida de terminal que compara el token de usuario decodificado con el token intercambiado. La audiencia pasa de mcp-server y account a payments-api, azp pasa de agent a mcp-server, expires_in es 300 y no hay token de refresco ni claim act." width="1894" height="1027" loading="lazy" decoding="async"><figcaption><strong>Antes y después.</strong> Mismo usuario, nueva audiencia (payments-api), nueva parte autorizada (mcp-server), 300 segundos de vida y ningún token de refresco. El identificador del usuario está sustituido por un marcador.</figcaption></figure>
<p>Compare los dos tokens: el sujeto no cambia, la audiencia es ahora solo la API de pagos, la parte autorizada (<code>azp</code>) nombra al servidor MCP, la vida es de 300 segundos y no vuelve ningún token de refresco. <strong>No hay claim <code>act</code></strong>: el soporte de delegación de Keycloak es una función en vista previa y está desactivada por defecto, por lo que el actor solo aparece como <code>azp</code>.</p>
<h2>Hacerlo fallar a propósito</h2>
<p>Tres intercambios deben rechazarse. Pruebe esos mismos tres en cualquier proveedor de identidad antes de confiarle la delegación para agentes.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/keycloak-token-exchange-rfc-8693/08-negative.webp" alt="Salida de terminal de tres intercambios rechazados: un cliente sin token exchange activado, una audiencia para la que el servidor MCP no tiene scope y la petición de un token de refresco; cada uno devuelve invalid_request." width="1894" height="874" loading="lazy" decoding="async"><figcaption><strong>Tres rechazos.</strong> A: un cliente sin el privilegio de intercambio. B: una audiencia para la que el servidor MCP no tiene scope. C: un token de refresco. Todos devuelven invalid_request. Los secretos de cliente están sustituidos por marcadores.</figcaption></figure>
<h2>Trampas habituales</h2>
<ul>
<li><strong>El password grant es un atajo.</strong> El laboratorio solo lo usa para conseguir rápido un token de usuario. RFC 9700 y OAuth 2.1 lo descartan para clientes reales; use el flujo authorization code con <a href="https://iamops.dev/es/tools/pkce/">PKCE</a>.</li>
<li><strong>El claim <code>aud</code> puede listar más de lo esperado.</strong> Al introspeccionar el token intercambiado aparecieron la API de pagos y <code>account</code>. Entiéndalo antes de confiar en las comprobaciones de audiencia.</li>
<li><strong>El orden de los scopes varía</strong> entre ejecuciones, así que no compare cadenas de scopes literalmente.</li>
<li><strong>Sin claim <code>act</code> por defecto.</strong> Si su auditoría necesita al actor, prevea la función de delegación en vista previa o una los datos usted mismo mediante <code>azp</code> en los registros.</li>
</ul>
<h2>Conclusiones de seguridad</h2>
<ol>
<li>El intercambio de tokens es un privilegio. Concédalo solo al cliente que lo necesita.</li>
<li>Haga la audiencia posterior explícita y opcional, para que los tokens intercambiados sean estrechos por defecto.</li>
<li>No emita nunca tokens de refresco en un intercambio. El servidor del laboratorio los rechaza.</li>
<li>Un servicio debe rechazar los tokens que no se emitieron para él e intercambiar por cada API posterior, sin reenviar nunca el token del usuario.</li>
<li>Compruebe qué puede reconstruir su rastro de auditoría. Si el actor solo aparece como <code>azp</code>, una línea de registro debe unir usuario, agente y audiencia posterior.</li>
</ol>
<h2>Qué no se ejecutó</h2>
<p>No se ejecutaron la variante con Docker, las tareas adicionales (tokens de refresco en el intercambio estándar, introspección por la API posterior) ni la función de delegación en vista previa que añadiría <code>act</code>. El laboratorio usó solo cuentas desechables. Para este laboratorio no se publica ninguna grabación.</p>
<p><em>Las imágenes del terminal se generaron a partir de la salida guardada de la ejecución, con identificadores y secretos sustituidos por marcadores. Las capturas de la consola de Keycloak muestran solo objetos de prueba.</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>Proteger un servidor MCP con OAuth: rechazar el token passthrough e intercambiar por cada API posterior</title>
      <link>https://iamops.dev/es/mcp-server-no-token-passthrough/</link>
      <guid isPermaLink="true">https://iamops.dev/es/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>Intercambio de tokens</category>
      <category>Keycloak</category>
      <category>Agentes de IA</category>
      <description>Laboratorio con el SDK Python de MCP y Keycloak: handshake 401, audiencia, intercambio RFC 8693 para la API de pagos y passthrough rechazado en un servidor.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/es/mcp-server-no-token-passthrough.png?v=986e5733" alt="" /></p><p><strong>En resumen</strong></p>
<ul>
<li>Un servidor MCP es un servidor de recursos OAuth: responde 401 con los Protected Resource Metadata para que los clientes encuentren el servidor de autorización.</li>
<li>Hace introspección de cada token de portador y rechaza el que no incluye al propio servidor MCP en su audiencia.</li>
<li>Para una API posterior intercambia el token (RFC 8693) en lugar de reenviar el del llamante.</li>
<li>Un passthrough deliberado falla: el token para la API de pagos está inactivo para el servidor MCP, que responde 401.</li>
<li>Registra usuario, cliente del agente y audiencia posterior en una sola línea para que las auditorías sigan la cadena.</li>
</ul>
<p>El 10 de noviembre de 2026 WorkOS añadió el intercambio de tokens (RFC 8693) a WorkOS Connect para que un servidor MCP pueda llamar a API posteriores por un usuario sin reenviar el token de este. Es el patrón que espera la especificación de autorización de MCP. Lo construí a mano con el SDK oficial de Python, para ver cada regla en acción.</p>
<p>Se apoya en el <a href="https://iamops.dev/es/keycloak-token-exchange-rfc-8693/">laboratorio de intercambio de tokens con Keycloak</a>: mismo realm, mismos tres clientes.</p>
<h2>Qué muestra el laboratorio</h2>
<p>Un servidor MCP escrito con el SDK oficial de Python (<code>mcp</code> 2.3.0) actúa como <em>servidor de recursos</em> OAuth de un realm de Keycloak. Hace cuatro cosas:</p>
<ol>
<li>Responde a una petición sin token con <code>401</code> y una referencia a sus Protected Resource Metadata (RFC 9728), de modo que un cliente encuentra el servidor de autorización sin tenerlo fijado en la configuración.</li>
<li>Comprueba cada token de portador por introspección en Keycloak y rechaza los tokens cuya audiencia no incluya al propio servidor MCP.</li>
<li>Para una herramienta, intercambia el token del llamante por un token destinado a la API de pagos (RFC 8693) en lugar de reenviarlo.</li>
<li>Rechaza un token emitido para la API de pagos cuando alguien se lo presenta al servidor MCP (un intento de passthrough).</li>
</ol>
<p>El verificador es corto. La línea decisiva es la comprobación de la audiencia:</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>La ejecución</h2>
<p>Fije la versión del SDK: <code>mcp</code> 2.x renombró <code>FastMCP</code> a <code>MCPServer</code>, y los SDK cambian sus clases de autenticación entre versiones. El servidor escucha en <code>127.0.0.1:8001</code>.</p>
<p><strong>Sin token.</strong> La primera petición es el handshake de descubrimiento con el que empieza todo cliente MCP: un <code>401</code> cuya cabecera <code>WWW-Authenticate</code> lleva una URL <code>resource_metadata</code>, y un documento de metadatos que nombra al realm como servidor de autorización.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/mcp-server-no-token-passthrough/03-no-token.webp" alt="Salida de terminal: una petición sin token devuelve 401 Unauthorized con una cabecera www-authenticate que apunta a los metadatos del recurso protegido; el documento de metadatos nombra al realm de Keycloak como servidor de autorización." width="1894" height="530" loading="lazy" decoding="async"><figcaption><strong>El handshake 401.</strong> El cliente sabe dónde conseguir un token por el documento de metadatos, no por la configuración.</figcaption></figure>
<p><strong>Con token.</strong> Un pequeño script obtiene un token de usuario para el cliente <code>agent</code>, abre una sesión MCP y llama a las dos herramientas. <code>whoami</code> muestra que el servidor ve al usuario a través del cliente agente; <code>downstream_token</code> muestra al servidor cambiando el token por otro limitado a la API de pagos.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/mcp-server-no-token-passthrough/04-call.webp" alt="Salida de terminal de las dos llamadas a herramientas: whoami devuelve el sujeto, el cliente agente y sus scopes; downstream_token devuelve un token con audiencia payments-api y parte autorizada mcp-server. El sujeto está sustituido por un marcador." width="1894" height="683" loading="lazy" decoding="async"><figcaption><strong>Dos herramientas.</strong> La primera muestra quién llamó. La segunda muestra el token intercambiado: audiencia payments-api, parte autorizada mcp-server, mismo sujeto. El sujeto es un marcador.</figcaption></figure>
<p>La misma llamada funciona con el cliente de línea de comandos MCP Inspector, la forma estándar de reproducir lo que haría cualquier host MCP. Fije su versión en los scripts; este laboratorio usó la 2.15.0.</p>
<p><strong>El intento de passthrough.</strong> Cree un token intercambiado nuevo, obsérvelo por introspección desde ambos lados y preséntelo al servidor MCP.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/mcp-server-no-token-passthrough/06-passthrough.webp" alt="Salida de terminal: la introspección indica el token como activo para el cliente payments-api e inactivo para el cliente mcp-server; presentarlo al servidor MCP devuelve 401." width="1894" height="492" loading="lazy" decoding="async"><figcaption><strong>Sin passthrough.</strong> Keycloak solo informa del token como activo al cliente para el que se emitió. El servidor MCP responde 401. Los secretos de cliente son marcadores.</figcaption></figure>
<h2>Trampas habituales</h2>
<ul>
<li><strong>¿Introspección o validación local?</strong> El laboratorio usa introspección: revocación inmediata a cambio de una ida y vuelta al servidor de autorización. La alternativa es validar el JWT localmente con las claves JWKS; anote qué se pierde y qué se gana.</li>
<li><strong>Compruebe la audiencia, no solo la firma.</strong> Un token válido para otra API sigue siendo el token equivocado. La comprobación de audiencia convierte el passthrough en un <code>401</code>.</li>
<li><strong>Los tokens duran cinco minutos</strong> en esta configuración, así que genere el token del passthrough justo antes de la prueba.</li>
<li><strong>Deriva de los SDK.</strong> Los nombres de clases y los ganchos de autenticación cambiaron entre versiones mayores; pruebe con la versión que vaya a desplegar.</li>
</ul>
<h2>Conclusiones de seguridad</h2>
<ol>
<li>Un servidor MCP es un servidor de recursos OAuth. Publica metadatos, valida la audiencia y rechaza todo lo que no vaya dirigido a él.</li>
<li>No reenvíe nunca el token del llamante a una API posterior. Intercámbielo por cada audiencia posterior, más estrecho y de corta duración.</li>
<li>Deje que el servidor de autorización decida quién ve un token como activo. Un token que solo funciona para su destinatario limita lo que puede hacer un eslabón comprometido.</li>
<li>Registre una línea que una al usuario, cliente agente y audiencia posterior; el token por sí solo no cuenta la historia completa a un auditor.</li>
</ol>
<h2>Qué no se ejecutó</h2>
<p>No se ejecutó el flujo OAuth de la interfaz web de MCP Inspector (el cliente <code>agent</code> del laboratorio admite para ello una redirección a localhost). No se usó el registro dinámico de clientes; el cliente está preregistrado. Todo se ejecutó en una sola máquina con cuentas desechables. Para este laboratorio no se publica ninguna grabación.</p>
<p><em>Las imágenes del terminal se generaron a partir de la salida guardada de la ejecución, con identificadores, secretos y marcas de tiempo sustituidos por marcadores.</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>Agente de IA autónomo sin secretos en Azure: llamar a una API con identidad administrada desde Container Apps</title>
      <link>https://iamops.dev/es/secretless-agent-managed-identity-container-app/</link>
      <guid isPermaLink="true">https://iamops.dev/es/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>Identidad administrada</category>
      <category>Entra ID</category>
      <category>Agentes de IA</category>
      <category>Identidad de workload</category>
      <category>Azure</category>
      <description>Laboratorio: un agente de Container Apps con identidad administrada y sin secretos recibe un rol de aplicación estrecho y la API valida su token app-only.</description>
      <content:encoded><![CDATA[<p><img src="https://iamops.dev/og/es/secretless-agent-managed-identity-container-app.png?v=986e5733" alt="" /></p><p><strong>En resumen</strong></p>
<ul>
<li>Un agente autónomo que no guarda secretos no tiene nada que filtrar: una Container App con identidad administrada asignada por el usuario, sin secreto de cliente, certificado ni ingress.</li>
<li>La identidad empieza sin roles; con la asignación obligatoria en la API, la solicitud de token se rechaza (AADSTS501051) hasta que se concede un solo rol estrecho.</li>
<li>El token app-only contiene roles y no scp, y la API valida igualmente firma, audiencia, emisor y rol.</li>
<li>Los tokens se guardan en caché unas 24 horas, así que quitar un rol no es una revocación inmediata.</li>
<li>Trata la identidad como una cuenta privilegiada: un responsable, una fecha de revisión y una alerta sobre las asignaciones de rol.</li>
</ul>
<p>El 5 de noviembre de 2026, Microsoft Threat Intelligence describió a atacantes que usan un marco ofensivo basado en agentes para buscar secretos expuestos en repositorios públicos y luego iniciar sesión como cargas de trabajo con credenciales de aplicación válidas. La lectura defensiva es sencilla: un agente autónomo que no guarda ningún secreto no tiene nada que filtrar. Construí uno en Azure y comprobé cada afirmación.</p>
<h2>Qué muestra el laboratorio</h2>
<p>Un pequeño agente se ejecuta como Azure Container App. No tiene usuario, ni secreto de cliente, ni certificado. Su identidad es una <strong>identidad administrada asignada por el usuario</strong> que empieza sin ningún rol. El laboratorio:</p>
<ol>
<li>Asocia la identidad a la app y demuestra que el contenedor no guarda ningún secreto.</li>
<li>Hace que la API posterior (la <em>Resource API</em>, un registro de aplicación) exija una asignación de rol de aplicación.</li>
<li>Muestra la solicitud de token rechazada y luego concede <strong>un</strong> solo rol app-only estrecho.</li>
<li>Lee el token app-only que obtiene el agente y lo comprueba como lo haría la API.</li>
</ol>
<h2>Preparación</h2>
<p>Use un tenant y una suscripción de prueba aparte. El agente funciona con 0,25 vCPU y 0,5 GiB en el plan de Consumo, sin ingress y sin área de trabajo de Log Analytics. Los primeros 180 000 vCPU-segundos al mes son gratuitos, que este tamaño agota en unas 200 horas de ejecución: elimine la app cuando termine. La identidad administrada y el rol de aplicación son gratuitos.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/01-context.webp" alt="Salida de terminal: la Azure CLI muestra la suscripción y el tenant, la identidad administrada con su ID de cliente y su ID de principal, y cero asignaciones de rol. Los identificadores son marcadores." width="1894" height="683" loading="lazy" decoding="async"><figcaption><strong>Empezar de cero.</strong> La identidad administrada no tiene asignaciones de rol, así que cada permiso del laboratorio es una concesión deliberada y visible. Los identificadores son marcadores.</figcaption></figure>
<p>La app se define en YAML. La imagen es pública y solo se usa por su Python, así que no hace falta ninguna credencial de registro. El bloque identity asocia la identidad administrada. No hay sección <code>ingress</code>, así que nadie puede llamar desde fuera.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/03-app-definition.webp" alt="Salida de terminal de la definición de la app: ubicación, bloque identity asignado por el usuario, ID del entorno, imagen pública del contenedor, recursos de 0,25 vCPU y 0,5 GiB y el ID de cliente como variable de entorno. Los ID son marcadores." width="1894" height="874" loading="lazy" decoding="async"><figcaption><strong>Nada que robar.</strong> Todo lo que un atacante podría sacar de esta definición es público: el nombre de una imagen, un ID de cliente y el código. Los ID de suscripción y de cliente son marcadores.</figcaption></figure>
<h2>La ejecución</h2>
<p><strong>El contenedor guarda un endpoint de identidad, no un secreto.</strong> La plataforma inyecta <code>IDENTITY_ENDPOINT</code>, una URL de localhost, e <code>IDENTITY_HEADER</code>, un valor por contenedor (enmascarado en la salida). Ninguna otra variable parece un secreto y no hay montado ningún volumen de secretos.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/05-secretless.webp" alt="Salida de terminal desde dentro del contenedor: el endpoint de identidad en localhost, la cabecera de identidad enmascarada, el ID de cliente público y ninguna variable llamada secret, password, key o certificate, ni volúmenes de secretos montados." width="1894" height="454" loading="lazy" decoding="async"><figcaption><strong>Dentro del contenedor.</strong> La cabecera no es una credencial para Entra. Solo demuestra al endpoint local que quien llama está en este contenedor, lo que bloquea los trucos de SSRF.</figcaption></figure>
<p><strong>Exigir la asignación en la API.</strong> Por defecto Entra emite un token app-only a cualquier service principal del tenant que lo pida, con un claim <code>roles</code> vacío. Poner <code>appRoleAssignmentRequired</code> a <code>true</code> en el service principal de la Resource API hace que Entra rechace a quien no esté asignado:</p>
<pre><code class="language-bash">az ad sp update --id &lt;resource-sp-id&gt; --set appRoleAssignmentRequired=true
</code></pre>
<p><strong>Dos pruebas negativas.</strong> La solicitud del agente de un token para la Resource API es rechazada por el servicio de tokens con AADSTS501051, y un token para Graph (Graph no exige asignación) no contiene roles, de modo que <code>GET /v1.0/users</code> devuelve <code>403</code>.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/07-refused.webp" alt="Salida de terminal de dos rechazos: HTTP 400 con AADSTS501051, que indica que la identidad administrada no está asignada a un rol de la Resource API, y HTTP 403 Authorization_RequestDenied de Graph. Los ID son marcadores." width="1894" height="530" loading="lazy" decoding="async"><figcaption><strong>Rechazado dos veces.</strong> El rechazo ocurre antes de llamar a la API y nombra la identidad administrada, lo que lo hace fácil de localizar en una revisión o un incidente. «Tener un token» no significa «tener acceso».</figcaption></figure>
<p><strong>Una concesión estrecha.</strong> Añada a la Resource API un rol de aplicación solo app-only <code>Data.Read.All</code> (tipo de miembro permitido: aplicación) y asígnelo a la identidad administrada mediante Microsoft Graph. El centro de administración no puede asignar un rol de aplicación a una identidad administrada; se hace con Graph, PowerShell o la CLI.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/10-assign.webp" alt="Salida de terminal de dos llamadas a Graph: añadir el rol de aplicación Data.Read.All a la Resource API y asignarlo al service principal de la identidad administrada. Los ID de objeto son marcadores." width="1894" height="645" loading="lazy" decoding="async"><figcaption><strong>La única concesión del laboratorio.</strong> Es un objeto de Graph corriente que una herramienta de gobierno o un script pueden leer.</figcaption></figure>
<p><strong>El token app-only.</strong> Entra almacena en caché los tokens de las identidades administradas, así que el contenedor sigue recibiendo su token antiguo hasta un día. Reiniciar la revisión da uno nuevo, que ahora contiene el rol.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/13-token.webp" alt="Claims decodificados del token app-only tras reiniciar la revisión: la audiencia es la Resource API, la aplicación y el ID de objeto son la identidad administrada, idtyp es app, roles contiene Data.Read.All y no hay claim scope. Los identificadores son marcadores." width="1894" height="759" loading="lazy" decoding="async"><figcaption><strong>Token app-only.</strong> Un claim <code>roles</code> sin <code>scp</code> es como una API distingue una llamada app-only de una delegada. No hay usuario; los permisos propios de la identidad son el único límite.</figcaption></figure>
<p><strong>Hacer de API.</strong> El token pasa del contenedor a un archivo temporal con modo 0600 y se destruye al final; nunca se imprime. Un script de validación comprueba la firma RS256 con las claves del tenant, la audiencia, el emisor y la caducidad, y luego autoriza cada ruta según el rol.</p>
<figure class="b-fig"><img src="https://iamops.dev/media/secretless-agent-managed-identity-container-app/15-validate.webp" alt="Salida de terminal de la comprobación del lado de la API: GET data devuelve 200 para el rol Data.Read.All, POST data devuelve 403 por falta del rol Data.Write.All y un token con roles editados devuelve 401 porque falla la verificación de la firma." width="1894" height="339" loading="lazy" decoding="async"><figcaption><strong>La API sigue decidiendo.</strong> La lectura se permite, la escritura se rechaza y un token con claims manipulados no supera la verificación de la firma.</figcaption></figure>
<h2>Trampas habituales</h2>
<ul>
<li><strong>Los tokens se guardan en caché unas 24 horas.</strong> Quitar el rol no basta para una revocación urgente. Reinicie o vuelva a desplegar la carga de trabajo, o desactive la identidad.</li>
<li><strong><code>exec</code> tiene un límite de frecuencia.</strong> Sin <code>--replica</code>, <code>az containerapp exec</code> puede elegir una réplica detenida y los reintentos topan con HTTP 429 y diez minutos de espera. Indique la réplica en ejecución.</li>
<li><strong>«Assignment required» es un interruptor que hay que activar.</strong> Sin él, «poder obtener un token» y «estar autorizado» son cosas distintas, y cada API debe comprobar los roles por sí misma.</li>
<li><strong>Los tenants gratuitos registran menos.</strong> El registro de auditoría del directorio muestra la concesión. Los registros de inicio de sesión de las identidades administradas requieren Entra ID P1 o P2 y conviene exportarlos a su SIEM.</li>
<li><strong>Elimine el cómputo cuando termine.</strong> El cómputo cuesta dinero; la identidad y el rol llevan el riesgo y necesitan un responsable y una fecha de revisión como cualquier otra cuenta privilegiada.</li>
</ul>
<h2>Conclusiones de seguridad</h2>
<ol>
<li>Una carga de trabajo sin secretos no tiene nada que filtrar. Prefiera identidades administradas o credenciales federadas a los secretos de cliente.</li>
<li>Empiece sin roles y añada un rol con el ámbito más estrecho. Nombre los roles app-only <code>*.All</code> para que quien revise vea que no hay límite de usuario.</li>
<li>Exija la asignación en las API internas para que el servicio de tokens sea la primera puerta.</li>
<li>Valide firma, audiencia, emisor y rol en la API. Entra solo decide quién obtiene un token.</li>
<li>Trate las identidades administradas con roles de aplicación como cuentas no humanas privilegiadas: responsable, recertificación, una alerta sobre las asignaciones de rol a service principals.</li>
</ol>
<h2>Qué no se ejecutó</h2>
<p>El laboratorio no desplegó un blueprint ni una identidad de agente de Entra Agent ID, donde un token de identidad administrada sería la credencial del blueprint. El recorrido por el portal de los objetos resultantes se grabó pero no se publica, porque las vistas del portal muestran identificadores del tenant. Para este laboratorio no se publica ninguna grabación.</p>
<p><em>Las imágenes del terminal se generaron a partir de la salida guardada de la ejecución, con identificadores, secretos y marcas de tiempo sustituidos por marcadores.</em></p>
]]></content:encoded>
    </item>
  </channel>
</rss>
