# GitHub Actions vers Azure avec la workload identity federation : quels runs obtiennent un jeton, et pourquoi

> Lab : un workflow GitHub se connecte à Azure sans secret. J'affiche le sub de six types de run et le credential qui fait passer chacun, PR comprises.

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

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

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

1. Fait confiance à la branche main avec un credential exact et voit `azure/login` réussir.
2. Pousse une branche feature, ouvre une pull request et les voit refusées toutes deux avec AADSTS700213.
3. Autorise `release/*` avec une claims-matching expression.
4. Affiche le `sub` exact de six types de run, puis ajoute les credentials qui les font tous passer.
5. 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.

```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"]}
```

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

![Sortie de terminal : le federated credential gh-main avec un subject exact pour la branche main, puis un run sur main qui se termine avec succès, affiche le même claim sub, liste le resource group et montre la connexion en tant que service principal. Les ID sont des placeholders.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/01-main.webp)

*Le sub correspond caractère par caractère. Le credential est toute la relation de confiance. Aucun secret à créer, rien à faire tourner. Les ID sont des placeholders.*

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

![Sortie de terminal : un push sur feature-x et une pull request se terminent tous deux en échec avec AADSTS700213, aucun enregistrement d'identité fédérée correspondant. Les subjects présentés se terminent par ref:refs/heads/feature-x et pull_request. Les ID sont des placeholders.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/02-feature-refused.webp)

*Refusés, par conception. Une faute de frappe dans un nom de branche ou une pull request non relue n'obtient pas l'identité de déploiement. Les ID sont des placeholders.*

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

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

![Sortie de terminal : az rest crée le credential gh-release avec une claims-matching expression sur le sub pour les branches release et une vérification de repository_id, puis un push sur release/1 se termine avec succès et affiche son sub. Les ID sont des placeholders.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/03-release-expression.webp)

*Un credential pour une famille de branches. Le motif garde les ID du propriétaire et du dépôt, et repository_id est vérifié à part. Les ID sont des placeholders.*

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

![Sortie de terminal : un tableau de six runs avec le seul credential pour main. main passe. Les runs branche feature, pull request, pull_request_target, tag et environment échouent avec AADSTS700213. Chaque ligne montre le sub après le préfixe du dépôt.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/04-subs-before.webp)

*1 sur 6 passe. La partie après les ID change pour chaque type de run, et un credential pour main ne correspond qu'à main.*

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.

![Sortie de terminal : les quatre credentials ajoutés avec leur nom et leur motif, puis le même tableau de six runs où chaque ligne passe. Le placeholder prefix remplace la partie du sub avec le dépôt et les ID du propriétaire et du dépôt.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/05-subs-after.webp)

*6 sur 6 passent. &lt;prefix&gt; remplace repo:&lt;owner&gt;@&lt;id&gt;/&lt;repo&gt;@&lt;id&gt;. Un credential contient soit un subject exact, soit une expression, jamais les deux.*

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

![Sortie de terminal avec trois phrases citées de la doc GitHub : les secrets ne sont pas transmis aux workflows déclenchés depuis un fork, le GITHUB_TOKEN est en lecture seule dans les pull requests depuis un fork, et les permissions d'écriture passent en lecture pour les événements de pull request autres que pull_request_target depuis un fork.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/06-forks-docs.webp)

*La doc seulement, pas un test. Les lignes sont affichées directement depuis les pages GitHub pour que vous puissiez vérifier le texte.*

`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 `sub` dans 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 que `az 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 `sub` sans 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é

1. En CI, utilisez la fédération au lieu d'un client secret. Rien à stocker, à laisser fuiter ou à faire tourner.
2. Prenez le credential le plus étroit qui convient : exact pour main et pour un environment, une expression seulement pour une vraie famille de refs.
3. Gardez les ID du propriétaire et du dépôt dans chaque subject et chaque motif, et ajoutez `repository_id` à chaque expression.
4. Considérez qu'un credential `pull_request` fait aussi confiance à `pull_request_target`. Ne faites jamais de checkout de code non fiable dans un workflow qui peut obtenir un jeton.
5. 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.

![Sortie de terminal : l'app registration et le resource group sont supprimés, az group exists affiche false, le nombre d'apps est 0 et le dépôt est archivé.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/07-cleanup.webp)

*Plus rien ne tourne. Aucun secret n'a jamais été créé, il n'y a donc rien à révoquer.*

## 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_id` ou `job_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** `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
```

### Étape 1: Cré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

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

**Résultat attendu**

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

### Étape 2: Cré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

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

**Résultat attendu**

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

### Étape 3: Faire 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

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

**Résultat attendu**

```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'}
```

### Étape 4: Tests 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

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

**Résultat attendu**

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

### Étape 5: Autoriser 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

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

**Résultat attendu**

```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'}
```

### Étape 6: Vé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

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

**Résultat attendu**

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

### Étape 7: Vé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

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

**Résultat attendu**

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

### Étape 8: Pull 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

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

**Résultat attendu**

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

### Étape 9: Nettoyage : 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

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

**Résultat attendu**

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