iamops.dev
Argo en X Feed RSS
ESEspañol

Labs Técnico 9 min de lectura

De GitHub Actions a Azure con workload identity federation: qué runs reciben un token, y por qué

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.

Dos capturas de terminal de mi lab: un push a feature-x y una pull request rechazados con AADSTS700213, y una tabla en la que los seis tipos de run pasan tras las credenciales extra. Los identificadores son placeholders.
En resumenUn workflow de GitHub puede iniciar sesión en Azure sin client secret.…
  • 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.
  • 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.
  • 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.
  • 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í.
  • 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.
Repite este lab 9 pasos

Escribí este lab para que puedas repetirlo tú mismo. Cada paso tiene los comandos para copiar y la salida que obtuve yo, y puedes marcarlo como hecho. Las marcas se quedan solo en este navegador.

Ir a los pasos

Cómo funciona

Copia un prompt listo para Claude Code, Cursor, Codex o cualquier agente de código. Solo para entornos de prueba.

Mostrar el prompt
I want to run a hands-on lab from iamops.dev, and I would like your help to do it safely.

Lab: De GitHub Actions a Azure con workload identity federation: qué runs reciben un token, y por qué
Read the whole lab here (Markdown): https://iamops.dev/es/github-actions-azure-workload-identity-federation.md

What the lab needs before the first step:
- Azure CLI signed in to a throwaway tenant and subscription, with rights to create app registrations and role assignments
- jq and python3
- Values I have to set myself (the lab uses placeholders): <GITHUB_USER>, <TENANT_ID>, <SUBSCRIPTION_ID>, <AZURE_REGION>

How I want you to work:
1. Read the lab from start to finish first (each step lists its own prerequisites). Then check that the prerequisites are in place and that the tool versions match what the lab expects. Tell me what is missing before you run anything.
2. Run one step at a time. Before each command, show it to me and say in a sentence what it does.
3. Ask me before anything that costs money, creates cloud resources, touches a real tenant or account, or deletes anything. Wait for my answer.
4. Use the placeholders from the lab. Never paste real secrets, tokens or production identities into a command, a file or this chat. If a value is needed, tell me where to set it myself.
5. After each step, compare the output with the expected output in the lab. If it does not match, stop and tell me what differs. Do not carry on or invent a fix without asking me.
6. At the end, report what passed, what failed and which cleanup you did. Then offer to tick the steps off for me. The lab page keeps ticks only in my browser, so if you cannot do that, list the steps I should tick.

This lab is for test environments only. Do not run it against production, or against a tenant or account that holds real data or real users.

You may answer in my language.

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 claim sub inmutable 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 artículo. Este lab es la parte práctica.

Qué muestra este lab#

Un app registration con Reader sobre un solo resource group vacío, un repositorio privado y ningún secreto en ninguna parte. El lab:

  1. Confía en la rama main con una credencial exacta y ve que azure/login funciona.
  2. Hace push de una rama feature, abre una pull request y ve que las dos se rechazan con AADSTS700213.
  3. Permite release/* con una claims-matching expression.
  4. Imprime el sub exacto de seis tipos de run y luego añade las credenciales que hacen pasar a cada uno.
  5. Revisa las pull requests desde forks, solo con la documentación, porque no pude probarlas.

Preparación#

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.

Crea el repositorio antes que la credencial. Un repositorio nuevo envía repo:<owner>@<owner-id>/<repo>@<repo-id>:..., y los dos ID solo los conoces cuando el repositorio existe. Un subject escrito a la antigua, repo:<owner>/<repo>:ref:refs/heads/main, ya no coincide.

json
{"name": "gh-main", "issuer": "https://token.actions.githubusercontent.com",
 "subject": "repo:<github-user>@<owner-id>/lab-b1-gh-wif@<repo-id>:ref:refs/heads/main",
 "audiences": ["api://AzureADTokenExchange"]}

La ejecución#

main inicia sesión. El workflow imprime los claims que presenta GitHub, ejecuta azure/login y lista los resource groups. Mi primer run falló después del login con “No subscriptions found”, porque el rol Reader aún no se había propagado. Un minuto de espera lo resolvió.

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.
El sub coincide carácter a carácter. La credencial es toda la relación de confianza. No hay secreto que crear ni nada que rotar. Los ID son placeholders.

Una rama feature y una pull request se rechazan. Mismo workflow, otro sub. Entra responde AADSTS700213 y el mensaje muestra el subject recibido, que es la forma más rápida de depurar una credencial.

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.
Rechazados, a propósito. Una errata en el nombre de una rama o una pull request sin revisar no obtienen la identidad de despliegue. Los ID son placeholders.

release/ con una expresión.* Una credencial federada flexible guarda una claimsMatchingExpression en lugar de un subject. Para app registrations la creé con az rest contra el endpoint beta de Graph. Seguí la documentación de Microsoft y fijé también repository_id:

text
claims['sub'] matches 'repo:<github-user>@<owner-id>/lab-b1-gh-wif@<repo-id>:ref:refs/heads/release/*' and claims['repository_id'] eq '<repo-id>'
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.
Una credencial para una familia de ramas. El patrón mantiene los ID del propietario y del repositorio, y repository_id se comprueba aparte. Los ID son placeholders.

Comprobación a fondo: el sub de cada tipo de run#

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, probe.sh, pide un token a GitHub, decodifica el sub, 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, pull_request, pull_request_target, un push de tag y un segundo job que usa un environment. Usé una app nueva y el mismo repositorio privado.

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.
Pasa 1 de 6. La parte después de los ID cambia en cada tipo de run, y una credencial para main solo coincide con main.

Después añadí cuatro credenciales: una exacta para el environment, una exacta para pull_request y dos expresiones para ramas feature-* y tags v*. Volví a lanzar los mismos runs.

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.
Pasan 6 de 6. <prefix> representa repo:<owner>@<id>/<repo>@<id>. Una credencial tiene un subject exacto o una expresión, nunca las dos cosas.
Run sub tras el prefijo del repositorio Credencial que lo deja pasar Solo main Después
Push a main ref:refs/heads/main Subject exacto Pasa Pasa
Push a feature-probe ref:refs/heads/feature-probe Expresión ...ref:refs/heads/feature-* AADSTS700213 Pasa
pull_request pull_request Subject exacto AADSTS700213 Pasa
pull_request_target pull_request La misma credencial pull_request AADSTS700213 Pasa
Tag v1 ref:refs/tags/v1 Expresión ...ref:refs/tags/v* AADSTS700213 Pasa
Job con environment lab-b1-prod environment:lab-b1-prod Subject exacto AADSTS700213 Pasa

Una diferencia con la documentación de Microsoft. Las expresiones feature-* y v* solo tenían una condición sobre sub, sin repository_id. 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 repository_id ni repository_owner_id, 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 sub y repository_id o repository_owner_id. Aun así recomiendo añadir repository_id 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 sub solo con nombres de un repositorio antiguo puede coincidir con un nombre que ya no es tuyo.

pull_request y pull_request_target comparten un subject#

Los dos eventos envían un sub que termina en pull_request, sea cual sea la rama. Por eso una credencial pull_request en Entra también confía en los jobs pull_request_target. 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.

Un job que usa un environment es la otra sorpresa. Envía environment:<name> en lugar de la rama. Mover un job de despliegue a un environment rompe una credencial escrita para main.

Pull requests desde forks: según la documentación, sin probar#

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.

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.
Solo documentación, no una prueba. Las líneas se imprimen directamente desde las páginas de GitHub para que puedas comprobar el texto.

id-token: write es un permiso de escritura. Para una pull_request desde un fork pasa a lectura, así que según mi lectura el job no recibe ningún token OIDC. probe.sh contempla ese caso e imprimiría “no OIDC token was offered”. No lo he visto pasar. pull_request_target es la excepción en esa documentación, y es la trampa de arriba.

Trampas#

  • Lee el sub de un run real antes de escribir una credencial. Lo muestran la línea del log y el mensaje AADSTS700213.
  • Espera después de asignar el rol. Sin la espera, el login funcionó y el comando siguiente falló con “No subscriptions found”.
  • Las expresiones están en preview y en Graph beta. Para app registrations usé az rest. La página conceptual de Microsoft dice que la CLI aún no las soporta de forma explícita, mientras que az identity federated-credential (identidades administradas asignadas por el usuario) lista parámetros en preview para ello.
  • Los repositorios antiguos mantienen el sub solo con nombres hasta que alguien activa el formato nuevo. Escribe la credencial para el formato que el repositorio envía de verdad.

Lo que me llevo sobre seguridad#

  1. En CI usa federación en lugar de un client secret. No hay nada que guardar, filtrar ni rotar.
  2. 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.
  3. Mantén los ID del propietario y del repositorio en cada subject y patrón, y añade repository_id a cada expresión.
  4. Da por hecho que una credencial pull_request también confía en pull_request_target. Nunca hagas checkout de código no confiable en un workflow que pueda obtener un token.
  5. Borra las credenciales cuyo repositorio ya no existe. Con el formato antiguo solo con nombres, otra persona puede quedarse con el nombre.

Limpieza#

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.

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.
No queda nada en marcha. Nunca se creó ningún secreto, así que no hay nada que revocar.

Lo que no se ejecutó#

  • Una pull request desde un fork. Esa parte se basa en la documentación de GitHub.
  • Un repositorio existente pasado al formato inmutable, y el endpoint de vista previa de GitHub para el prefijo del subject.
  • Un rol que pueda desplegar. La app solo tenía Reader sobre un resource group vacío.
  • Una expresión con repository_owner_id o job_workflow_ref.
  • Otras nubes. GitHub documenta AWS, Google Cloud y Vault, y yo solo probé Azure.

Ejecutado el 20 de noviembre de 2026 con la CLI de Azure, la CLI de GitHub y azure/login@v2 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.

Repite este lab#

Unos 30 minutos: la CLI de Azure y la CLI de GitHub en tu equipo, un tenant de Entra y una suscripción de usar y tirar, y una cuenta de GitHub tuya. No cuesta nada: un app registration, un resource group vacío, un repositorio privado y unos minutos de GitHub Actions. Abre cada paso, copia los bloques y compara tu salida con la mía.

Cada valor entre corchetes angulares es un marcador para tu entorno de prueba. Nada en esta página es un identificador o secreto real.

Define tus variables una sola vez

bash · env.sh
# Paste into every terminal you use for this lab. Replace each <PLACEHOLDER> with a value from your own test tenant and GitHub account.
export GH_USER='<GITHUB_USER>'
export TENANT='<TENANT_ID>'
export SUBSCRIPTION='<SUBSCRIPTION_ID>'
export REPO='lab-b1-gh-wif'
export RG='lab-b1-rg-wif'
export LOCATION='<AZURE_REGION>'
mkdir -p gh-lab && cd gh-lab
Paso 1Crea un resource group, un app registration y el rol Reader

Objetivo. Crea la identidad que usará el pipeline y dale Reader sobre un solo resource group vacío, nada más. Así un login correcto prueba la federación y no un permiso amplio.

Requisitos

  • CLI de Azure conectada a un tenant y una suscripción de prueba, con permiso para crear app registrations y asignaciones de rol
  • jq y python3
bash · azure.sh
az account set --subscription "$SUBSCRIPTION"
az group create -n $RG -l $LOCATION --query "{name:name, location:location}" -o json
export APPID=$(az ad app create --display-name lab-b1-gh-app --sign-in-audience AzureADMyOrg --query appId -o tsv)
export OBJ=$(az ad app show --id $APPID --query id -o tsv)
az ad sp create --id $APPID --query id -o tsv > /dev/null
echo "app registration created"
sleep 15
az role assignment create --assignee $APPID --role Reader --scope $(az group show -n $RG --query id -o tsv) -o none
az role assignment list --assignee $APPID --all --query "[].{role:roleDefinitionName, scope:scope}" -o json

Salida esperada

salida
{
  "location": "<AZURE_REGION>",
  "name": "lab-b1-rg-wif"
}
app registration created
[
  {
    "role": "Reader",
    "scope": "/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/lab-b1-rg-wif"
  }
]
Paso 2Crea primero el repo privado y luego tres ID como variables

Objetivo. Añade un workflow que imprime los claims que presenta GitHub y luego ejecuta azure/login. Crea el repositorio antes de la credencial federada: los repositorios nuevos usan un sub inmutable con los ID del propietario y del repositorio, que solo existen cuando el repositorio ya existe.

Requisitos

  • CLI de GitHub conectada, con permiso para crear un repositorio privado
  • Las variables APPID y OBJ del paso anterior en esta terminal
  • Guarda login.yml como .github/workflows/login.yml dentro de gh-lab antes de ejecutar repo.sh
yaml · .github/workflows/login.yml
name: login
on:
  push:
    branches: [main, feature-x, 'release/**']
  pull_request:
permissions:
  id-token: write
  contents: read
jobs:
  azure:
    runs-on: ubuntu-latest
    steps:
      - name: Show the claims GitHub presents to Entra
        run: |
          TOKEN=$(curl -s -H "Authorization: bearer $ACTIONS_ID_TOKEN_REQUEST_TOKEN" "$ACTIONS_ID_TOKEN_REQUEST_URL&audience=api://AzureADTokenExchange" | jq -r .value)
          echo "$TOKEN" | python3 -c 'import sys,json,base64;t=sys.stdin.read().split(".")[1];c=json.loads(base64.urlsafe_b64decode(t+"="*(-len(t)%4)));print({k:c[k] for k in ("sub","event_name","ref")})'
      - uses: azure/login@v2
        with:
          client-id: ${{ vars.AZURE_CLIENT_ID }}
          tenant-id: ${{ vars.AZURE_TENANT_ID }}
          subscription-id: ${{ vars.AZURE_SUBSCRIPTION_ID }}
      - name: Use the identity
        run: |
          az group list --query "[].name" -o tsv
          az account show --query "{signedInAs: user.type}" -o json
bash · repo.sh
git init -q -b main && git add -A && git commit -q -m "Login workflow"
gh repo create $GH_USER/$REPO --private --source . --remote origin
export OWNERID=$(gh api repos/$GH_USER/$REPO --jq .owner.id)
export REPOID=$(gh api repos/$GH_USER/$REPO --jq .id)
for kv in AZURE_CLIENT_ID=$APPID AZURE_TENANT_ID=$TENANT AZURE_SUBSCRIPTION_ID=$SUBSCRIPTION; do gh variable set ${kv%%=*} --body ${kv#*=} -R $GH_USER/$REPO; done
gh variable list -R $GH_USER/$REPO | cut -f1

Salida esperada

salida
https://github.com/<GITHUB_USER>/lab-b1-gh-wif
AZURE_CLIENT_ID
AZURE_SUBSCRIPTION_ID
AZURE_TENANT_ID
Paso 3Confía en main con una credencial exacta y haz push

Objetivo. Escribe una credencial federada cuyo subject sea exactamente el sub de un push a main, espera a que el rol se propague, haz push y mira cómo el job inicia sesión como service principal.

Requisitos

  • Las variables OBJ, OWNERID y REPOID de los pasos anteriores en esta terminal
  • En este paso no se crea ningún secreto
bash · fic-main.sh
cat > fic-main.json <<EOF
{"name": "gh-main", "issuer": "https://token.actions.githubusercontent.com",
 "subject": "repo:$GH_USER@$OWNERID/$REPO@$REPOID:ref:refs/heads/main",
 "audiences": ["api://AzureADTokenExchange"]}
EOF
az ad app federated-credential create --id $OBJ --parameters @fic-main.json --query "{name:name, subject:subject}" -o json
sleep 60  # give the Reader role assignment time to propagate
git push -q -u origin main 2>&1 | tail -1
for i in $(seq 1 30); do RUN=$(gh run list -R $GH_USER/$REPO --branch main --limit 1 --json databaseId -q ".[0].databaseId"); [ -n "$RUN" ] && break; sleep 3; done
gh run watch $RUN -R $GH_USER/$REPO --exit-status > /dev/null 2>&1; echo "run finished: $(gh run view $RUN -R $GH_USER/$REPO --json conclusion -q .conclusion)"
gh run view $RUN -R $GH_USER/$REPO --log | grep -E "'sub'|Login successful|signedInAs|lab-b1-rg-wif" | sed -E "s/^[^\t]*\t[^\t]*\t[0-9TZ:.-]+ //" | sort -u

Salida esperada

salida
{
  "name": "gh-main",
  "subject": "repo:<GITHUB_USER>@<OWNER_ID>/lab-b1-gh-wif@<REPO_ID>:ref:refs/heads/main"
}
run finished: success
  "signedInAs": "servicePrincipal"
lab-b1-rg-wif
{'sub': 'repo:<GITHUB_USER>@<OWNER_ID>/lab-b1-gh-wif@<REPO_ID>:ref:refs/heads/main', 'event_name': 'push', 'ref': 'refs/heads/main'}
Paso 4Pruebas negativas: una rama feature y una pull request

Objetivo. Haz push de una rama que la credencial no cubre y abre una pull request desde ella. Los dos logins fallan con AADSTS700213 y el mensaje muestra el subject exacto presentado.

Requisitos

  • El run en main del paso anterior terminó con éxito
bash · refused.sh
git checkout -q -b feature-x && echo "# change" >> README.md && git add -A && git commit -q -m "feature-x"
git push -q origin feature-x 2>&1 | tail -1
for i in $(seq 1 30); do RUN=$(gh run list -R $GH_USER/$REPO --branch feature-x --limit 1 --json databaseId -q ".[0].databaseId"); [ -n "$RUN" ] && break; sleep 3; done
gh run watch $RUN -R $GH_USER/$REPO --exit-status > /dev/null 2>&1; echo "run finished: $(gh run view $RUN -R $GH_USER/$REPO --json conclusion -q .conclusion)"
gh run view $RUN -R $GH_USER/$REPO --log-failed | grep -E "AADSTS|'sub'" | sed -E "s/^[^\t]*\t[^\t]*\t[0-9TZ:.-]+ //" | cut -c1-230 | sort -u
gh pr create -R $GH_USER/$REPO --head feature-x --base main --title "feature-x" --body "lab"
for i in $(seq 1 30); do RUN=$(gh run list -R $GH_USER/$REPO --event pull_request --limit 1 --json databaseId -q ".[0].databaseId"); [ -n "$RUN" ] && break; sleep 3; done
gh run watch $RUN -R $GH_USER/$REPO --exit-status > /dev/null 2>&1; echo "run finished: $(gh run view $RUN -R $GH_USER/$REPO --json conclusion -q .conclusion)"
gh run view $RUN -R $GH_USER/$REPO --log-failed | grep -E "AADSTS" | sed -E "s/^[^\t]*\t[^\t]*\t[0-9TZ:.-]+ //" | cut -c1-230 | sort -u

Salida esperada

salida
run finished: failure
##[error]AADSTS700213: No matching federated identity record found for presented assertion subject 'repo:<GITHUB_USER>@<OWNER_ID>/lab-b1-gh-wif@<REPO_ID>:ref:refs/heads/feature-x'. Check your federated identity credential Subject, Audience and Issu
https://github.com/<GITHUB_USER>/lab-b1-gh-wif/pull/1
run finished: failure
##[error]AADSTS700213: No matching federated identity record found for presented assertion subject 'repo:<GITHUB_USER>@<OWNER_ID>/lab-b1-gh-wif@<REPO_ID>:pull_request'. Check your federated identity credential Subject, Audience and Issu
Paso 5Permite release/* con una claims-matching expression

Objetivo. Crea una credencial federada flexible con el endpoint beta de Graph: el sub coincide con las ramas release de este repositorio y repository_id se comprueba aparte, como pide la documentación de Microsoft. Luego haz push de release/1.

Requisitos

  • Las credenciales federadas flexibles están en preview; para app registrations se crean con az rest contra Graph beta
bash · release.sh
cat > fic-expr.json <<EOF
{"name": "gh-release", "issuer": "https://token.actions.githubusercontent.com",
 "audiences": ["api://AzureADTokenExchange"],
 "claimsMatchingExpression": {"languageVersion": 1,
  "value": "claims['sub'] matches 'repo:$GH_USER@$OWNERID/$REPO@$REPOID:ref:refs/heads/release/*' and claims['repository_id'] eq '$REPOID'"}}
EOF
az rest --method post --url https://graph.microsoft.com/beta/applications/$OBJ/federatedIdentityCredentials --body @fic-expr.json --query "{name:name, expression:claimsMatchingExpression.value}" -o json 2>&1 | grep -v WARNING
git checkout -q -b release/1 main && git commit -q --allow-empty -m "release" && git push -q origin release/1 2>&1 | tail -1
for i in $(seq 1 30); do RUN=$(gh run list -R $GH_USER/$REPO --branch release/1 --limit 1 --json databaseId -q ".[0].databaseId"); [ -n "$RUN" ] && break; sleep 3; done
gh run watch $RUN -R $GH_USER/$REPO --exit-status > /dev/null 2>&1; echo "run finished: $(gh run view $RUN -R $GH_USER/$REPO --json conclusion -q .conclusion)"
gh run view $RUN -R $GH_USER/$REPO --log | grep -E "'sub'|Login successful" | sed -E "s/^[^\t]*\t[^\t]*\t[0-9TZ:.-]+ //" | sort -u

Salida esperada

salida
{
  "expression": "claims['sub'] matches 'repo:<GITHUB_USER>@<OWNER_ID>/lab-b1-gh-wif@<REPO_ID>:ref:refs/heads/release/*' and claims['repository_id'] eq '<REPO_ID>'",
  "name": "gh-release"
}
run finished: success
{'sub': 'repo:<GITHUB_USER>@<OWNER_ID>/lab-b1-gh-wif@<REPO_ID>:ref:refs/heads/release/1', 'event_name': 'push', 'ref': 'refs/heads/release/1'}
Paso 6Comprobación a fondo: imprime el sub de seis tipos de run

Objetivo. Ejecuta probe.sh en un push a main, una rama feature, pull_request, pull_request_target, un tag y un job con environment. Decodifica el sub, ofrece el token a Entra e imprime una línea RESULT. Con solo la credencial de main, solo pasa main.

Requisitos

  • Guarda probe.sh en la raíz del repositorio, probe.yml en .github/workflows/ y fmt.py al lado
  • Este paso cambia login.yml por probe.yml, así solo corre la sonda
bash · probe.sh
#!/usr/bin/env bash
# Print the sub claim GitHub issues for this run, then try to exchange it at Entra.
JOB=$1
if [ -z "$ACTIONS_ID_TOKEN_REQUEST_URL" ]; then echo "RESULT job=$JOB event=$GITHUB_EVENT_NAME ref=$GITHUB_REF sub=none entra=no OIDC token was offered to this job"; exit 0; fi
T=$(curl -s -H "Authorization: bearer $ACTIONS_ID_TOKEN_REQUEST_TOKEN" "$ACTIONS_ID_TOKEN_REQUEST_URL&audience=api://AzureADTokenExchange" | jq -r .value)
SUB=$(echo "$T" | cut -d. -f2 | tr '_-' '/+' | awk '{while(length($0)%4)$0=$0"=";print}' | base64 -d 2>/dev/null | jq -r .sub)
R=$(curl -s -X POST "https://login.microsoftonline.com/$TID/oauth2/v2.0/token" -d client_id=$CID -d grant_type=client_credentials -d scope=https://graph.microsoft.com/.default -d client_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearer -d client_assertion="$T")
OUT=$(echo "$R" | jq -r 'if .access_token then "token issued" else (.error_description | split(":")[0]) end')
echo "RESULT job=$JOB event=$GITHUB_EVENT_NAME ref=$GITHUB_REF sub=$SUB entra=$OUT"
yaml · .github/workflows/probe.yml
name: probe
on:
  push:
    branches: [main, 'feature-*']
    tags: ['v*']
  pull_request:
  pull_request_target:
permissions:
  id-token: write
  contents: read
env:
  CID: ${{ vars.AZURE_CLIENT_ID }}
  TID: ${{ vars.AZURE_TENANT_ID }}
jobs:
  plain:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: ./probe.sh plain
  with-environment:
    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    environment: lab-b1-prod
    steps:
      - uses: actions/checkout@v4
      - run: ./probe.sh environment
python · fmt.py
import sys, re
rows = []
for l in open(sys.argv[1]):
    m = re.search(r'job=(\S+) event=(\S+) ref=(\S+) sub=(\S+) entra=(.*)', l)
    if not m: continue
    job, ev, ref, sub, res = m.groups()
    ctx = sub.split(':', 1)[1].split(':', 1)[1] if sub.count(':') > 1 else sub
    ctx = re.sub(r'^repo:[^:]*:', '', sub)
    case = {'refs/heads/main': 'main', 'refs/heads/feature-probe': 'feature branch', 'refs/tags/v1': 'tag', }.get(ref, 'pull request' if ev == 'pull_request' else 'PR (pull_request_target)' if ev == 'pull_request_target' else ref)
    if job == 'environment': case = 'environment'
    if ev == 'pull_request_target': case = 'PR (pull_request_target)'
    rows.append((case, ctx, 'PASS' if 'issued' in res else 'FAIL ' + res))
order = ['main', 'feature branch', 'pull request', 'PR (pull_request_target)', 'tag', 'environment']
rows.sort(key=lambda r: order.index(r[0]))
print('%-26s %-34s %s' % ('run', 'sub (after repo:<owner>/<repo>)', 'Entra'))
for r in rows: print('%-26s %-34s %s' % r)
bash · phase1.sh
git checkout -q main && git rm -q .github/workflows/login.yml
chmod +x probe.sh && git add probe.sh .github/workflows/probe.yml
gh api -X PUT repos/$GH_USER/$REPO/environments/lab-b1-prod > /dev/null
git commit -q -m probe && git push -q origin main
git switch -q -c feature-probe && echo x > note.txt && git add . && git commit -q -m f && git push -q -u origin feature-probe
gh pr create --head feature-probe --base main --title probe --body lab
git tag v1 main && git push -q origin v1
sleep 60
RUN_IDS=$(gh run list --workflow probe.yml --limit 5 --json databaseId -q ".[].databaseId")
for id in $RUN_IDS; do gh run view $id --log | grep -o "RESULT.*"; done | sort -u > phase1.txt
python3 fmt.py phase1.txt

Salida esperada

salida
run                        sub (after repo:<owner>/<repo>)    Entra
main                       ref:refs/heads/main                PASS
feature branch             ref:refs/heads/feature-probe       FAIL AADSTS700213
pull request               pull_request                       FAIL AADSTS700213
PR (pull_request_target)   pull_request                       FAIL AADSTS700213
tag                        ref:refs/tags/v1                   FAIL AADSTS700213
environment                environment:lab-b1-prod            FAIL AADSTS700213
Paso 7Comprobación a fondo: añade las credenciales que hacen pasar cada run

Objetivo. Añade una credencial exacta para el environment, una exacta para pull_request y dos expresiones para feature-* y v*. Vuelve a lanzar los mismos runs: pasan los seis. La credencial pull_request también deja pasar el run pull_request_target.

Requisitos

  • RUN_IDS del paso anterior sigue definido en esta terminal
  • Estas dos expresiones solo comprueban el sub; la documentación de Microsoft pide también repository_id, mira el artículo
bash · phase2.sh
P="repo:$GH_USER@$OWNERID/$REPO@$REPOID"
mk() { az ad app federated-credential create --id $OBJ --parameters "{\"name\":\"$1\",\"issuer\":\"https://token.actions.githubusercontent.com\",\"subject\":\"$2\",\"audiences\":[\"api://AzureADTokenExchange\"]}" -o none; }
mk gh-env "$P:environment:lab-b1-prod"
mk gh-pr  "$P:pull_request"
for n in feature:heads/feature- tag:tags/v; do
  cat > expr-${n%%:*}.json <<EOF
{"name":"gh-${n%%:*}-glob","issuer":"https://token.actions.githubusercontent.com","audiences":["api://AzureADTokenExchange"],
 "claimsMatchingExpression":{"languageVersion":1,"value":"claims['sub'] matches '$P:ref:refs/${n#*:}*'"}}
EOF
  az rest -m POST -u "https://graph.microsoft.com/beta/applications/$OBJ/federatedIdentityCredentials" --headers Content-Type=application/json -b @expr-${n%%:*}.json -o none
done
sleep 40
for id in $RUN_IDS; do gh run rerun $id; done
sleep 60
for id in $RUN_IDS; do gh run view $id --attempt 2 --log | grep -o 'RESULT.*'; done | sort -u > phase2.txt
python3 fmt.py phase2.txt

Salida esperada

salida
run                        sub (after repo:<owner>/<repo>)    Entra
main                       ref:refs/heads/main                PASS
feature branch             ref:refs/heads/feature-probe       PASS
pull request               pull_request                       PASS
PR (pull_request_target)   pull_request                       PASS
tag                        ref:refs/tags/v1                   PASS
environment                environment:lab-b1-prod            PASS
Paso 8Pull requests desde forks: imprime lo que dice la documentación de GitHub

Objetivo. No pude probar un fork real. docs.py imprime las tres frases de la documentación de GitHub que lo deciden: sin secretos para forks, un GITHUB_TOKEN de solo lectura y permisos de escritura reducidos a lectura para cualquier evento de pull request salvo pull_request_target.

Requisitos

  • python3 con acceso a internet; este paso solo lee docs.github.com
  • No probado: si un job pull_request desde un fork recibe un token OIDC. Según mi lectura de la documentación, no
python · docs.py
import re, html, urllib.request
t = urllib.request.urlopen('https://docs.github.com/en/actions/reference/workflows-and-actions/events-that-trigger-workflows').read().decode()
t = html.unescape(re.sub(r'<[^>]+>', ' ', t)); t = re.sub(r'\s+', ' ', t)
for pat in [r"With the exception of GITHUB_TOKEN , secrets are not passed to the runner when a workflow is triggered from a forked repository\.", r"The GITHUB_TOKEN has read-only permissions in pull requests from forked repositories\."]:
    print('events-that-trigger-workflows: ' + re.search(pat, t).group(0).replace(' ,', ','))
t = urllib.request.urlopen('https://docs.github.com/en/actions/reference/workflows-and-actions/workflow-syntax').read().decode()
t = html.unescape(re.sub(r'<[^>]+>', ' ', t)); t = re.sub(r'\s+', ' ', t)
print('workflow-syntax: ' + re.search(r"if the workflow was triggered by a pull request event other than pull_request_target from a forked repository.{0,160}?read only\.", t).group(0))
bash · forks.sh
python3 docs.py

Salida esperada

salida
events-that-trigger-workflows: With the exception of GITHUB_TOKEN, secrets are not passed to the runner when a workflow is triggered from a forked repository.
events-that-trigger-workflows: The GITHUB_TOKEN has read-only permissions in pull requests from forked repositories.
workflow-syntax: if the workflow was triggered by a pull request event other than pull_request_target from a forked repository, and the Send write tokens to workflows from pull requests setting is not selected, the permissions are adjusted to change any write permissions to read only.
Paso 9Limpieza: Entra, Azure y el repo

Objetivo. Borra el app registration, lo que elimina todas sus credenciales federadas, borra el resource group, comprueba que ya no existen y archiva o borra el repositorio privado.

Requisitos

  • Ejecuta desde la carpeta gh-lab con el bloque env y OBJ todavía definidos
bash · cleanup.sh
az ad app delete --id $OBJ
az group delete -n $RG --yes
az group exists -n $RG
az ad app list --display-name lab-b1-gh-app --query "length(@)" -o tsv
gh repo archive $GH_USER/$REPO --yes 2>&1 | tail -1

Salida esperada

salida
false
0

Fuentes#

Comenta este artículo#

¿Te ha servido? Compártelo y dime qué piensas.

Seguir en X

Nuevos artículos por correo

Un correo a la semana con nuevos artículos y labs. Puedes darte de baja cuando quieras.

Tu dirección se guarda en Kit, el servicio que envía los correos. Detalles

Artículos y labs relacionados