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

- URL: https://iamops.dev/es/github-actions-azure-workload-identity-federation/
- Language: es
- Author: Argo
- Published: 2026-11-20
- Category: Labs
- Topics: GitHub Actions, OIDC, Entra ID, Identidad de workload, Azure

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

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](https://github.blog/changelog/2026-04-23-immutable-subject-claims-for-github-actions-oidc-tokens/) 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](https://iamops.dev/es/workload-identity-news-immutable-sub-entra-wildcards-workos/). 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.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/01-main.webp)

*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.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/02-feature-refused.webp)

*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.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/03-release-expression.webp)

*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.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/04-subs-before.webp)

*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.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/05-subs-after.webp)

*Pasan 6 de 6. &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.*

| 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.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/06-forks-docs.webp)

*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.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/07-cleanup.webp)

*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** `env.sh` (bash)

```bash
# 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 1: Crea 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

`azure.sh` (bash)

```bash
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**

```text
{
  "location": "<AZURE_REGION>",
  "name": "lab-b1-rg-wif"
}
app registration created
[
  {
    "role": "Reader",
    "scope": "/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/lab-b1-rg-wif"
  }
]
```

### Paso 2: Crea 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

`.github/workflows/login.yml` (yaml)

```yaml
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
```

`repo.sh` (bash)

```bash
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**

```text
https://github.com/<GITHUB_USER>/lab-b1-gh-wif
AZURE_CLIENT_ID
AZURE_SUBSCRIPTION_ID
AZURE_TENANT_ID
```

### Paso 3: Confí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

`fic-main.sh` (bash)

```bash
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**

```text
{
  "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 4: Pruebas 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

`refused.sh` (bash)

```bash
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**

```text
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 5: Permite 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

`release.sh` (bash)

```bash
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**

```text
{
  "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 6: Comprobació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

`probe.sh` (bash)

```bash
#!/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"
```

`.github/workflows/probe.yml` (yaml)

```yaml
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
```

`fmt.py` (python)

```python
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)
```

`phase1.sh` (bash)

```bash
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**

```text
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 7: Comprobació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

`phase2.sh` (bash)

```bash
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**

```text
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 8: Pull 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

`docs.py` (python)

```python
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))
```

`forks.sh` (bash)

```bash
python3 docs.py
```

**Salida esperada**

```text
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 9: Limpieza: 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

`cleanup.sh` (bash)

```bash
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**

```text
false
0
```


## Sources

- [GitHub Changelog, 23 Apr 2026 (edited 10 Jun 2026): Immutable subject claims for GitHub Actions OIDC tokens](https://github.blog/changelog/2026-04-23-immutable-subject-claims-for-github-actions-oidc-tokens/)
- [GitHub Docs: OpenID Connect reference](https://docs.github.com/en/actions/reference/security/oidc)
- [GitHub Docs: Events that trigger workflows](https://docs.github.com/en/actions/reference/workflows-and-actions/events-that-trigger-workflows)
- [GitHub Docs: Workflow syntax (permissions)](https://docs.github.com/en/actions/reference/workflows-and-actions/workflow-syntax)
- [GitHub Docs: Securely using pull_request_target](https://docs.github.com/en/actions/reference/security/securely-using-pull_request_target)
- [Microsoft Learn: Configure an app to trust an external identity provider](https://learn.microsoft.com/en-us/entra/workload-id/workload-identity-federation-create-trust)
- [Microsoft Learn: Flexible federated identity credentials (preview)](https://learn.microsoft.com/en-us/entra/workload-id/workload-identities-flexible-federated-identity-credentials)
- [Microsoft Learn: Migrate GitHub Actions federated credentials to immutable subjects](https://learn.microsoft.com/en-us/entra/workload-id/workload-identities-github-immutable-subjects)
