En bref
- Un workflow GitHub peut se connecter à Azure sans client secret. GitHub signe un jeton de courte durée, et un federated credential Entra fait confiance à un seul claim sub exact.
- Les nouveaux dépôts envoient un sub immuable qui contient les ID du propriétaire et du dépôt. Créez d'abord le dépôt, lisez les ID, puis écrivez le credential.
- Avec un seul credential pour main, 1 type de run sur 6 est passé. Un credential pour l'environment, un pour pull_request et deux expressions avec wildcard ont donné 6 sur 6.
- pull_request et pull_request_target envoient le même sub : un credential pull_request fait donc aussi confiance aux jobs pull_request_target, qui tournent avec les secrets. N'y faites jamais de checkout de la head de la PR.
- Je n'ai pas testé les pull requests depuis un fork. Selon la doc GitHub, elles n'ont pas de permissions d'écriture, donc j'attends aucun jeton, mais je ne l'ai pas vu.
Refaire ce lab
J’ai écrit ce lab pour que vous puissiez le refaire vous-même. Chaque étape contient les commandes à copier et la sortie que j’ai obtenue, et vous pouvez la cocher une fois faite. Les coches restent uniquement dans ce navigateur.
Copie un prompt prêt à l’emploi pour Claude Code, Cursor, Codex ou tout autre agent de code. Pour les environnements de test uniquement.
Afficher le prompt
I want to run a hands-on lab from iamops.dev, and I would like your help to do it safely. Lab: GitHub Actions vers Azure avec la workload identity federation : quels runs obtiennent un jeton, et pourquoi Read the whole lab here (Markdown): https://iamops.dev/fr/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 déploiement qui contient un client secret, c’est un secret qui attend de fuiter. GitHub Actions peut se connecter à Azure sans : GitHub signe un jeton OIDC de courte durée pour le job, et Entra lui fait confiance via un federated credential. Deux choses ont changé cette année. Depuis le 15 juillet 2026, les nouveaux dépôts reçoivent un claim sub immuable avec les ID du propriétaire et du dépôt, et les credentials avec wildcard d’Entra sont toujours en préversion. J’ai regroupé les deux dans un article d’actualité. Ce lab en est la partie pratique.
Ce que montre ce lab#
Une app registration avec Reader sur un seul resource group vide, un dépôt privé, aucun secret nulle part. Le lab :
- Fait confiance à la branche main avec un credential exact et voit
azure/loginréussir. - Pousse une branche feature, ouvre une pull request et les voit refusées toutes deux avec AADSTS700213.
- Autorise
release/*avec une claims-matching expression. - Affiche le
subexact de six types de run, puis ajoute les credentials qui les font tous passer. - Examine les pull requests depuis un fork, d’après la doc seulement, car je n’ai pas pu les tester.
Mise en place#
Utilisez un tenant et un abonnement jetables, et un compte GitHub à vous. L’app registration reçoit Reader sur un seul resource group vide : un login réussi prouve alors la fédération et rien d’autre. Les trois ID dont le workflow a besoin (client, tenant, abonnement) ne sont pas des secrets et vont dans des variables du dépôt.
Créez le dépôt avant le credential. Un nouveau dépôt envoie repo:<owner>@<owner-id>/<repo>@<repo-id>:..., et vous ne connaissez les deux ID qu’une fois le dépôt créé. Un subject écrit à l’ancienne, repo:<owner>/<repo>:ref:refs/heads/main, ne correspond plus.
{"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"]}Le run#
main se connecte. Le workflow affiche les claims présentés par GitHub, lance azure/login et liste les resource groups. Mon premier run a échoué après le login avec “No subscriptions found”, car le rôle Reader ne s’était pas encore propagé. Une minute d’attente a suffi.

Une branche feature et une pull request sont refusées. Même workflow, autre sub. Entra répond AADSTS700213 et le message donne le subject reçu : c’est le moyen le plus rapide de corriger un credential.

release/ avec une expression.* Un federated credential flexible contient une claimsMatchingExpression à la place d’un subject. Pour les app registrations, je l’ai créé avec az rest sur l’endpoint beta de Graph. J’ai suivi la doc Microsoft et fixé aussi 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>'
Vérification approfondie : le sub de chaque type de run#
Un lecteur m’a demandé si le refus d’une branche feature et d’une pull request était un bug. Ce n’en est pas un, et je voulais le montrer. Un petit script, probe.sh, demande un jeton à GitHub, décode le sub, présente le jeton à Entra et affiche une ligne de résultat. Le workflow le lance sur un push sur main, un push sur une branche feature, pull_request, pull_request_target, un push de tag et un second job qui utilise un environment. J’ai utilisé une nouvelle app et le même dépôt privé.

J’ai ensuite ajouté quatre credentials : un exact pour l’environment, un exact pour pull_request et deux expressions pour les branches feature-* et les tags v*. J’ai relancé les mêmes runs.

| Run | sub après le préfixe du dépôt |
Credential qui le fait passer | Main seul | Après |
|---|---|---|---|---|
| Push sur main | ref:refs/heads/main |
Subject exact | Passe | Passe |
| Push sur feature-probe | ref:refs/heads/feature-probe |
Expression ...ref:refs/heads/feature-* |
AADSTS700213 | Passe |
pull_request |
pull_request |
Subject exact | AADSTS700213 | Passe |
pull_request_target |
pull_request |
Le même credential pull_request |
AADSTS700213 | Passe |
| Tag v1 | ref:refs/tags/v1 |
Expression ...ref:refs/tags/v* |
AADSTS700213 | Passe |
| Job avec environment lab-b1-prod | environment:lab-b1-prod |
Subject exact | AADSTS700213 | Passe |
Un écart avec la doc Microsoft. Les expressions feature-* et v* n’avaient qu’une condition sur sub, sans repository_id. Entra a accepté les deux et les runs sont passés. Mes motifs contenaient déjà les ID du propriétaire et du dépôt, ils étaient donc verrouillés malgré tout. Lors d’un contrôle plus tard le même jour, Entra a aussi accepté une expression couvrant tous les dépôts du propriétaire, sans clause repository_id ni repository_owner_id, et cet identifiant a délivré un jeton à un autre dépôt du même propriétaire. Les pages Microsoft disent qu’une expression pour GitHub doit vérifier sub et repository_id ou repository_owner_id. Je recommande quand même d’ajouter repository_id à chaque expression. La règle est documentée et la fonction est en préversion : un credential sur le seul sub pourrait être refusé ou cesser de correspondre plus tard. Et la vérification de l’ID ne dépend pas d’un motif bien écrit : un wildcard à l’échelle du propriétaire a déjà délivré un jeton à un autre de mes dépôts, et le sub sans ID d’un dépôt plus ancien peut correspondre à un nom qui n’est plus le vôtre.
pull_request et pull_request_target partagent un même subject#
Les deux événements envoient un sub qui se termine par pull_request, quelle que soit la branche. Un credential pull_request dans Entra fait donc aussi confiance aux jobs pull_request_target. Ceux-ci tournent depuis la branche de base, avec les secrets et avec un jeton OIDC. Si un tel workflow fait un checkout de la head de la pull request, l’auteur de la pull request exécute du code avec votre identité cloud. Mon workflow de test utilisait le checkout par défaut, qui prend la branche de base. Ne changez pas cela dans un workflow qui peut obtenir un jeton.
Un job qui utilise un environment est l’autre surprise. Il envoie environment:<name> à la place de la branche. Déplacer un job de déploiement dans un environment casse un credential écrit pour main.
Pull requests depuis un fork : d’après la doc, non testé#
Je n’ai pas testé de pull request depuis un fork. Il faut un second compte GitHub, et je n’en utilise pas un qui ne soit pas à moi. Ce qui suit, c’est la doc GitHub et ma lecture.

id-token: write est une permission d’écriture. Pour une pull_request depuis un fork, elle passe en lecture, donc d’après moi le job ne reçoit aucun jeton OIDC. probe.sh gère ce cas et afficherait “no OIDC token was offered”. Je ne l’ai pas vu se produire. pull_request_target est l’exception dans cette doc, et c’est le piège décrit plus haut.
Pièges#
- Lisez le
subdans un vrai run avant d’écrire un credential. La ligne du log et le message AADSTS700213 le montrent tous les deux. - Attendez après l’attribution du rôle. Sans attente, le login a marché et la commande suivante a échoué avec “No subscriptions found”.
- Les expressions sont en préversion et sur Graph beta. Pour les app registrations, j’ai utilisé
az rest. La page de concept Microsoft dit que la CLI ne les prend pas encore en charge explicitement, alors queaz identity federated-credential(identités managées attribuées par l’utilisateur) liste des paramètres en préversion pour cela. - Les anciens dépôts gardent le
subsans ID jusqu’à ce que quelqu’un active le nouveau format. Écrivez le credential pour le format que le dépôt envoie vraiment.
Ce qu’il faut retenir pour la sécurité#
- En CI, utilisez la fédération au lieu d’un client secret. Rien à stocker, à laisser fuiter ou à faire tourner.
- Prenez le credential le plus étroit qui convient : exact pour main et pour un environment, une expression seulement pour une vraie famille de refs.
- Gardez les ID du propriétaire et du dépôt dans chaque subject et chaque motif, et ajoutez
repository_idà chaque expression. - Considérez qu’un credential
pull_requestfait aussi confiance àpull_request_target. Ne faites jamais de checkout de code non fiable dans un workflow qui peut obtenir un jeton. - Supprimez les credentials dont le dépôt n’existe plus. Avec l’ancien format sans ID, quelqu’un d’autre peut reprendre le nom.
Nettoyage#
J’ai supprimé l’app registration, ce qui retire ses credentials, supprimé le resource group, vérifié que les deux avaient disparu et archivé le dépôt privé. Après la vérification approfondie, j’ai aussi retiré l’app supplémentaire, la branche, le tag, la pull request, l’environment et les variables.

Ce qui n’a pas été exécuté#
- Une pull request depuis un fork. Cette partie repose sur la doc GitHub.
- Un dépôt existant passé au format immuable, et l’endpoint de préversion de GitHub pour le préfixe du subject.
- Un rôle qui peut déployer. L’app n’avait que Reader sur un resource group vide.
- Une expression avec
repository_owner_idoujob_workflow_ref. - D’autres clouds. GitHub documente AWS, Google Cloud et Vault, je n’ai testé qu’Azure.
Exécuté le 20 novembre 2026 avec l’Azure CLI, la GitHub CLI et azure/login@v2 sur un runner hébergé par GitHub, dans un tenant jetable et un dépôt privé. Les images de terminal ont été redessinées à partir de la sortie enregistrée, avec les utilisateurs, les ID et les horodatages remplacés par des placeholders.
Refaire ce lab#
Environ 30 minutes : l'Azure CLI et la GitHub CLI sur votre machine, un tenant Entra et un abonnement jetables, et un compte GitHub à vous. Cela ne coûte rien : une app registration, un resource group vide, un dépôt privé et quelques minutes de GitHub Actions. Ouvrez chaque étape, copiez les blocs et comparez votre résultat avec le mien.
Chaque valeur entre chevrons est un espace réservé pour votre environnement de test. Rien sur cette page n’est un identifiant ou un secret réel.
Définissez vos variables une seule fois
# 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 Étapes terminées : 0 sur 9
Étape 1Créer un resource group, une app registration et le rôle Reader
Objectif. Créez l'identité que le pipeline va prendre et donnez-lui Reader sur un seul resource group vide, sans autre droit. Un login réussi prouve alors la fédération, pas une permission large.
Prérequis
- Azure CLI connectée à un tenant et un abonnement de test, avec le droit de créer des app registrations et des attributions de rôle
- jq et 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 Résultat attendu
{
"location": "<AZURE_REGION>",
"name": "lab-b1-rg-wif"
}
app registration created
[
{
"role": "Reader",
"scope": "/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/lab-b1-rg-wif"
}
] Étape 2Créer d'abord le dépôt privé, puis trois ID en variables
Objectif. Ajoutez un workflow qui affiche les claims présentés par GitHub puis lance azure/login. Créez le dépôt avant le federated credential : les nouveaux dépôts utilisent un sub immuable avec les ID du propriétaire et du dépôt, qui n'existent qu'une fois le dépôt créé.
Prérequis
- GitHub CLI connectée, avec le droit de créer un dépôt privé
- Les variables APPID et OBJ de l'étape précédente dans ce terminal
- Enregistrez login.yml sous .github/workflows/login.yml dans gh-lab avant de lancer 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 Résultat attendu
https://github.com/<GITHUB_USER>/lab-b1-gh-wif
AZURE_CLIENT_ID
AZURE_SUBSCRIPTION_ID
AZURE_TENANT_ID Étape 3Faire confiance à main avec un credential exact, puis pousser
Objectif. Écrivez un federated credential dont le subject est exactement le sub d'un push sur main, attendez la propagation du rôle, poussez, et regardez le job se connecter comme service principal.
Prérequis
- Les variables OBJ, OWNERID et REPOID des étapes précédentes dans ce terminal
- Aucun secret n'est créé à cette étape
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 Résultat attendu
{
"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'} Étape 4Tests négatifs : une branche feature et une pull request
Objectif. Poussez une branche que le credential ne couvre pas, puis ouvrez une pull request depuis cette branche. Les deux logins échouent avec AADSTS700213, et le message donne le subject exact présenté.
Prérequis
- Le run sur main de l'étape précédente s'est terminé avec succès
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 Résultat attendu
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 Étape 5Autoriser release/* avec une claims-matching expression
Objectif. Créez un federated credential flexible via l'endpoint beta de Graph : le sub correspond aux branches release de ce dépôt, et repository_id est vérifié à part, comme le demande la doc Microsoft. Poussez ensuite release/1.
Prérequis
- Les federated credentials flexibles sont en préversion ; pour les app registrations, on les crée avec az rest sur 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 Résultat attendu
{
"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'} Étape 6Vérification approfondie : afficher le sub de six types de run
Objectif. Lancez probe.sh sur un push sur main, une branche feature, pull_request, pull_request_target, un tag et un job avec un environment. Il décode le sub, présente le jeton à Entra et affiche une ligne RESULT. Avec le seul credential pour main, seul main passe.
Prérequis
- Enregistrez probe.sh à la racine du dépôt, probe.yml dans .github/workflows/ et fmt.py à côté
- Cette étape remplace login.yml par probe.yml, seule la sonde tourne
#!/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 Résultat attendu
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 Étape 7Vérification approfondie : ajouter les credentials qui font passer chaque run
Objectif. Ajoutez un credential exact pour l'environment, un exact pour pull_request et deux expressions pour feature-* et v*. Relancez les mêmes runs : les six passent. Le credential pull_request laisse aussi passer le run pull_request_target.
Prérequis
- RUN_IDS de l'étape précédente toujours défini dans ce terminal
- Ces deux expressions ne vérifient que le sub ; la doc Microsoft demande aussi repository_id, voir l'article
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 Résultat attendu
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 Étape 8Pull requests depuis un fork : afficher ce que dit la doc GitHub
Objectif. Je n'ai pas pu tester un vrai fork. docs.py affiche les trois phrases de la doc GitHub qui tranchent : pas de secrets pour les forks, un GITHUB_TOKEN en lecture seule, et les permissions d'écriture ramenées à la lecture pour tout événement de pull request sauf pull_request_target.
Prérequis
- python3 avec accès à internet ; cette étape lit seulement docs.github.com
- Non testé : si un job pull_request depuis un fork reçoit un jeton OIDC. D'après ma lecture de la doc, non
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 Résultat attendu
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. Étape 9Nettoyage : Entra, Azure et le dépôt
Objectif. Supprimez l'app registration, ce qui retire tous ses federated credentials, supprimez le resource group, vérifiez que les deux ont disparu et archivez ou supprimez le dépôt privé.
Prérequis
- À lancer depuis le dossier gh-lab avec le bloc env et OBJ toujours définis
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 Résultat attendu
false
0 Sources#
- 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
Discuter de cet article#
Utile ? Partagez-le et dites-moi ce que vous en pensez.
Cet article en Markdown · RSS · JSON feed
Les nouveaux articles par e-mail
Un e-mail par semaine avec les nouveaux articles et labs. Désinscription à tout moment.
Votre adresse est conservée chez Kit, le service qui envoie les e-mails. Détails