En resumen
- 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
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.
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:
- Confía en la rama main con una credencial exacta y ve que
azure/loginfunciona. - Hace push de una rama feature, abre una pull request y ve que las dos se rechazan con AADSTS700213.
- Permite
release/*con una claims-matching expression. - Imprime el
subexacto de seis tipos de run y luego añade las credenciales que hacen pasar a cada uno. - 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.
{"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ó.

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.

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:
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>'
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.

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.

| 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.

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
subde 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 queaz identity federated-credential(identidades administradas asignadas por el usuario) lista parámetros en preview para ello. - Los repositorios antiguos mantienen el
subsolo 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#
- En CI usa federación en lugar de un client secret. No hay nada que guardar, filtrar ni rotar.
- 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.
- Mantén los ID del propietario y del repositorio en cada subject y patrón, y añade
repository_ida cada expresión. - Da por hecho que una credencial
pull_requesttambién confía enpull_request_target. Nunca hagas checkout de código no confiable en un workflow que pueda obtener un token. - 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.

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_idojob_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
# 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 0 de 9 pasos hechos
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
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
{
"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
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 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
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
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
{
"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
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
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
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
{
"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
#!/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" 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 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) 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
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
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
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
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)) python3 docs.py Salida esperada
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
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
false
0 Fuentes#
- GitHub Changelog, 23 Apr 2026 (edited 10 Jun 2026): Immutable subject claims for GitHub Actions OIDC tokens
- GitHub Docs: OpenID Connect reference
- GitHub Docs: Events that trigger workflows
- GitHub Docs: Workflow syntax (permissions)
- GitHub Docs: Securely using pull_request_target
- Microsoft Learn: Configure an app to trust an external identity provider
- Microsoft Learn: Flexible federated identity credentials (preview)
- Microsoft Learn: Migrate GitHub Actions federated credentials to immutable subjects
Comenta este artículo#
¿Te ha servido? Compártelo y dime qué piensas.
Este artículo en Markdown · RSS · JSON feed
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