# Da GitHub Actions ad Azure con la workload identity federation: quali run ricevono un token, e perché

> Lab: un workflow GitHub accede ad Azure senza segreti. Stampo il sub di sei tipi di run e mostro quale credenziale fa passare ciascuno, pull request comprese.

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

## In breve

- Un workflow GitHub può accedere ad Azure senza client secret. GitHub firma un token di breve durata e una credenziale federata in Entra si fida di un solo claim sub esatto.
- I repository nuovi inviano un sub immutabile con dentro gli ID di owner e repository. Crea prima il repository, leggi gli ID, poi scrivi la credenziale.
- Con la sola credenziale per main è passato 1 tipo di run su 6. Una credenziale per l'environment, una per pull_request e due espressioni con wildcard hanno portato a 6 su 6.
- pull_request e pull_request_target inviano lo stesso sub, quindi una credenziale pull_request si fida anche dei job pull_request_target, che girano con i segreti. Lì non fare mai checkout della head della PR.
- Le pull request da fork non le ho provate. Secondo la documentazione GitHub non ricevono permessi di scrittura, quindi mi aspetto nessun token, ma non l'ho visto.

Una pipeline di deploy con dentro un client secret è un segreto che aspetta di trapelare. GitHub Actions può accedere ad Azure senza: GitHub firma un token OIDC di breve durata per il job ed Entra se ne fida tramite una credenziale federata. Quest'anno sono cambiate due cose. Dal 15 luglio 2026 i repository nuovi ricevono un [claim sub immutabile](https://github.blog/changelog/2026-04-23-immutable-subject-claims-for-github-actions-oidc-tokens/) con dentro gli ID di owner e repository, e le credenziali con wildcard di Entra sono ancora in preview. Ho raccolto entrambe le notizie in un [articolo](https://iamops.dev/it/workload-identity-news-immutable-sub-entra-wildcards-workos/). Questo lab è la parte pratica.

## Cosa mostra questo lab

Una app registration con Reader su un solo resource group vuoto, un repository privato, nessun segreto da nessuna parte. Il lab:

1. Si fida del branch main con una credenziale esatta e vede `azure/login` riuscire.
2. Fa push di un feature branch e apre una pull request, e li vede rifiutati entrambi con AADSTS700213.
3. Consente `release/*` con una claims-matching expression.
4. Stampa il `sub` esatto di sei tipi di run, poi aggiunge le credenziali che li fanno passare tutti.
5. Guarda le pull request da fork, solo dalla documentazione, perché non ho potuto provarle.

## Preparazione

Usa un tenant e una sottoscrizione usa e getta, e un account GitHub tuo. La app registration riceve Reader su un solo resource group vuoto, così un login riuscito prova la federazione e nient'altro. I tre ID che servono al workflow (client, tenant, sottoscrizione) non sono segreti e vanno nelle variabili del repository.

Crea il repository prima della credenziale. Un repository nuovo invia `repo:<owner>@<owner-id>/<repo>@<repo-id>:...`, e i due ID li conosci solo quando il repository esiste. Un subject scritto alla vecchia maniera, `repo:<owner>/<repo>:ref:refs/heads/main`, non corrisponde più.

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

## L'esecuzione

**main accede.** Il workflow stampa i claim che GitHub presenta, poi esegue `azure/login` ed elenca i resource group. Il mio primo run è fallito dopo il login con "No subscriptions found", perché il ruolo Reader non si era ancora propagato. Un minuto di attesa ha risolto.

![Output di terminale: la credenziale federata gh-main con un subject esatto per il branch main, poi un run su main che termina con successo, stampa lo stesso claim sub, elenca il resource group e mostra l'accesso come service principal. Gli ID sono segnaposto.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/01-main.webp)

*Il sub corrisponde carattere per carattere. La credenziale è tutta la relazione di fiducia. Non c'è nessun segreto da creare né da ruotare. Gli ID sono segnaposto.*

**Un feature branch e una pull request vengono rifiutati.** Stesso workflow, `sub` diverso. Entra risponde AADSTS700213 e il messaggio riporta il subject ricevuto, che è il modo più rapido per correggere una credenziale.

![Output di terminale: un push su feature-x e una pull request terminano entrambi con errore AADSTS700213, nessun record di identità federata corrispondente. I subject presentati finiscono con ref:refs/heads/feature-x e pull_request. Gli ID sono segnaposto.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/02-feature-refused.webp)

*Rifiutati, per costruzione. Un errore di battitura nel nome di un branch o una pull request non revisionata non ottengono l'identità di deploy. Gli ID sono segnaposto.*

**release/* con un'espressione.** Una credenziale federata flessibile contiene una `claimsMatchingExpression` al posto del subject. Per le app registration l'ho creata con `az rest` sull'endpoint beta di Graph. Ho seguito la documentazione Microsoft e ho fissato anche `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>'
```

![Output di terminale: az rest crea la credenziale gh-release con una claims-matching expression sul sub per i branch release più un controllo su repository_id, poi un push su release/1 termina con successo e stampa il suo sub. Gli ID sono segnaposto.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/03-release-expression.webp)

*Una credenziale per una famiglia di branch. Il pattern mantiene gli ID di owner e repository, e repository_id viene controllato a parte. Gli ID sono segnaposto.*

## Verifica approfondita: il sub di ogni tipo di run

Un lettore mi ha chiesto se il rifiuto di un feature branch e di una pull request sia un bug. Non lo è, e volevo dimostrarlo. Un piccolo script, `probe.sh`, chiede un token a GitHub, decodifica il `sub`, offre il token a Entra e stampa una riga di risultato. Il workflow lo esegue su un push a main, un push su un feature branch, `pull_request`, `pull_request_target`, un push di tag e un secondo job che usa un environment. Ho usato una nuova app e lo stesso repository privato.

![Output di terminale: una tabella di sei run con la sola credenziale per main. main passa. I run su feature branch, pull request, pull_request_target, tag ed environment falliscono con AADSTS700213. Ogni riga mostra il sub dopo il prefisso del repository.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/04-subs-before.webp)

*Ne passa 1 su 6. La parte dopo gli ID cambia per ogni tipo di run, e una credenziale per main corrisponde solo a main.*

Poi ho aggiunto quattro credenziali: una esatta per l'environment, una esatta per `pull_request` e due espressioni per i branch `feature-*` e i tag `v*`. Ho rilanciato gli stessi run.

![Output di terminale: le quattro credenziali aggiuntive elencate per nome e pattern, poi la stessa tabella di sei run in cui ogni riga passa. Il segnaposto prefix sta per la parte del sub con il repository e gli ID di owner e repository.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/05-subs-after.webp)

*Passano 6 su 6. &lt;prefix&gt; sta per repo:&lt;owner&gt;@&lt;id&gt;/&lt;repo&gt;@&lt;id&gt;. Una credenziale contiene un subject esatto oppure un'espressione, mai entrambi.*

| Run | `sub` dopo il prefisso del repository | Credenziale che lo fa passare | Solo main | Dopo |
| --- | --- | --- | --- | --- |
| Push su main | `ref:refs/heads/main` | Subject esatto | Passa | Passa |
| Push su feature-probe | `ref:refs/heads/feature-probe` | Espressione `...ref:refs/heads/feature-*` | AADSTS700213 | Passa |
| `pull_request` | `pull_request` | Subject esatto | AADSTS700213 | Passa |
| `pull_request_target` | `pull_request` | La stessa credenziale `pull_request` | AADSTS700213 | Passa |
| Tag v1 | `ref:refs/tags/v1` | Espressione `...ref:refs/tags/v*` | AADSTS700213 | Passa |
| Job con environment lab-b1-prod | `environment:lab-b1-prod` | Subject esatto | AADSTS700213 | Passa |

**Una differenza rispetto alla documentazione Microsoft.** Le espressioni `feature-*` e `v*` avevano solo una condizione sul `sub`, senza `repository_id`. Entra le ha accettate entrambe e i run sono passati. I miei pattern contenevano già gli ID di owner e repository, quindi erano vincolati comunque. In un controllo successivo, lo stesso giorno, Entra ha accettato anche un'espressione a livello di owner senza `repository_id` né `repository_owner_id`, e quella credenziale ha emesso un token a un altro repository dello stesso owner. Le pagine Microsoft dicono che un'espressione per GitHub deve verificare `sub` e `repository_id` o `repository_owner_id`. Consiglio lo stesso di aggiungere `repository_id` a ogni espressione. La regola è documentata e la funzione è in preview, quindi una credenziale solo sul sub potrebbe essere rifiutata o smettere di corrispondere più avanti. E il controllo sull'ID non dipende dallo scrivere bene il pattern: un wildcard a livello di owner ha già emesso un token a un altro dei miei repository, e il `sub` solo con i nomi di un repository più vecchio può corrispondere a un nome che non è più tuo.

## pull_request e pull_request_target condividono lo stesso subject

Entrambi gli eventi inviano un `sub` che finisce con `pull_request`, qualunque sia il branch. Quindi una credenziale `pull_request` in Entra si fida anche dei job `pull_request_target`. Questi girano dal branch base, con i segreti e con un token OIDC. Se un workflow del genere fa checkout della head della pull request, l'autore della pull request esegue codice con la tua identità cloud. Il mio workflow di prova usava il checkout predefinito, che prende il branch base. Non cambiarlo in un workflow che può ottenere un token.

Un job che usa un environment è l'altra sorpresa. Invia `environment:<name>` al posto del branch. Spostare un job di deploy in un environment rompe una credenziale scritta per main.

## Pull request da fork: dalla documentazione, non provate

Non ho provato una pull request da un fork. Serve un secondo account GitHub, e non ne uso uno che non sia mio. Quello che segue è la documentazione GitHub e la mia lettura.

![Output di terminale con tre frasi citate dalla documentazione GitHub: i segreti non passano ai workflow avviati da fork, il GITHUB_TOKEN è in sola lettura nelle pull request da fork e i permessi di scrittura diventano lettura per gli eventi di pull request diversi da pull_request_target da un fork.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/06-forks-docs.webp)

*Solo documentazione, non un test. Le righe sono stampate direttamente dalle pagine GitHub, così puoi controllarne il testo.*

`id-token: write` è un permesso di scrittura. Per una `pull_request` da un fork viene ridotto a lettura, quindi secondo me il job non riceve alcun token OIDC. `probe.sh` gestisce questo caso e stamperebbe "no OIDC token was offered". Non l'ho visto succedere. `pull_request_target` è l'eccezione in quella documentazione, ed è la trappola descritta sopra.

## Insidie

- **Leggi il `sub` da un run reale prima di scrivere una credenziale.** Lo mostrano sia la riga nel log sia il messaggio AADSTS700213.
- **Aspetta dopo l'assegnazione del ruolo.** Senza attesa il login funzionava e il comando successivo falliva con "No subscriptions found".
- **Le espressioni sono in preview e su Graph beta.** Per le app registration ho usato `az rest`. La pagina concettuale di Microsoft dice che la CLI non le supporta ancora in modo esplicito, mentre `az identity federated-credential` (identità gestite assegnate dall'utente) elenca parametri in preview per farlo.
- **I repository vecchi mantengono il `sub` solo con i nomi** finché qualcuno non fa l'opt-in. Scrivi la credenziale per il formato che il repository invia davvero.

## Cosa portarsi a casa sulla sicurezza

1. In CI usa la federazione al posto di un client secret. Non c'è niente da conservare, far trapelare o ruotare.
2. Usa la credenziale più stretta possibile: esatta per main e per un environment, un'espressione solo per una vera famiglia di ref.
3. Mantieni gli ID di owner e repository in ogni subject e pattern, e aggiungi `repository_id` a ogni espressione.
4. Considera che una credenziale `pull_request` si fida anche di `pull_request_target`. Mai fare checkout di codice non fidato in un workflow che può ottenere un token.
5. Elimina le credenziali il cui repository non esiste più. Con il vecchio formato solo con i nomi, qualcun altro può prendersi quel nome.

## Pulizia

Ho eliminato la app registration, che rimuove le sue credenziali, ho eliminato il resource group, ho verificato che non esistessero più e ho archiviato il repository privato. Dopo la verifica approfondita ho rimosso anche l'app aggiuntiva, il branch, il tag, la pull request, l'environment e le variabili.

![Output di terminale: la app registration e il resource group vengono eliminati, az group exists stampa false, il conteggio delle app è 0 e il repository viene archiviato.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/07-cleanup.webp)

*Non resta niente in esecuzione. Non è mai stato creato alcun segreto, quindi non c'è niente da revocare.*

## Cosa non è stato eseguito

- Una pull request da un fork. Quella parte si basa sulla documentazione GitHub.
- Un repository esistente passato al formato immutabile, e l'endpoint di anteprima di GitHub per il prefisso del subject.
- Un ruolo che può fare deploy. L'app aveva solo Reader su un resource group vuoto.
- Un'espressione con `repository_owner_id` o `job_workflow_ref`.
- Altri cloud. GitHub documenta AWS, Google Cloud e Vault, io ho provato solo Azure.

*Eseguito il 20 novembre 2026 con l'Azure CLI, la GitHub CLI e `azure/login@v2` su un runner ospitato da GitHub, in un tenant usa e getta e in un repository privato. Le immagini di terminale sono state ridisegnate dall'output salvato, con utenti, ID e orari sostituiti da segnaposto.*

## Ripeti questo lab

Circa 30 minuti: l'Azure CLI e la GitHub CLI sul tuo computer, un tenant Entra e una sottoscrizione usa e getta, e un account GitHub tuo. Non costa nulla: una app registration, un resource group vuoto, un repository privato e qualche minuto di GitHub Actions. Apri ogni passo, copia i blocchi e confronta il tuo output con il mio.

Ogni valore tra parentesi angolari è un segnaposto per il tuo ambiente di test. Nulla in questa pagina è un identificativo o un segreto reale.

**Imposta le variabili una sola volta** `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
```

### Passo 1: Crea un resource group, una app registration e il ruolo Reader

**Obiettivo.** Crea l'identità che la pipeline userà e dalle Reader su un solo resource group vuoto, niente di più. Un login riuscito prova così la federazione e non un permesso ampio.

**Prerequisiti**

- Azure CLI collegata a un tenant e a una sottoscrizione di prova, con i diritti per creare app registration e assegnazioni di ruolo
- jq e 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
```

**Output atteso**

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

### Passo 2: Crea prima il repo privato, poi imposta tre ID come variabili

**Obiettivo.** Aggiungi un workflow che stampa i claim presentati da GitHub e poi esegue azure/login. Crea il repository prima della credenziale federata: i nuovi repository usano un sub immutabile con gli ID di owner e repository, che esistono solo dopo il repository.

**Prerequisiti**

- GitHub CLI collegata, con il permesso di creare un repository privato
- Le variabili APPID e OBJ del passo precedente in questo terminale
- Salva login.yml come .github/workflows/login.yml dentro gh-lab prima di eseguire 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
```

**Output atteso**

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

### Passo 3: Fidati di main con una credenziale esatta e fai push

**Obiettivo.** Scrivi una credenziale federata il cui subject è esattamente il sub di un push su main, aspetta che il ruolo si propaghi, fai push e guarda il job autenticarsi come service principal.

**Prerequisiti**

- Le variabili OBJ, OWNERID e REPOID dei passi precedenti in questo terminale
- In questo passo non si crea nessun segreto

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

**Output atteso**

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

### Passo 4: Test negativi: un feature branch e una pull request

**Obiettivo.** Fai push di un branch che la credenziale non copre, poi apri una pull request da quel branch. Entrambi i login falliscono con AADSTS700213 e il messaggio riporta il subject esatto presentato.

**Prerequisiti**

- Il run su main del passo precedente è terminato con successo

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

**Output atteso**

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

### Passo 5: Consenti release/* con una claims-matching expression

**Obiettivo.** Crea una credenziale federata flessibile tramite l'endpoint beta di Graph: il sub corrisponde ai branch release di questo repository e repository_id viene controllato a parte, come chiede la documentazione Microsoft. Poi fai push di release/1.

**Prerequisiti**

- Le credenziali federate flessibili sono in preview; per le app registration si creano con az rest su 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
```

**Output atteso**

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

### Passo 6: Verifica approfondita: stampa il sub di sei tipi di run

**Obiettivo.** Esegui probe.sh su un push a main, un feature branch, pull_request, pull_request_target, un tag e un job con un environment. Decodifica il sub, offre il token a Entra e stampa una riga RESULT. Con la sola credenziale per main, passa solo main.

**Prerequisiti**

- Salva probe.sh nella radice del repository, probe.yml in .github/workflows/ e fmt.py accanto
- Questo passo sostituisce login.yml con probe.yml, così gira solo 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
```

**Output atteso**

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

### Passo 7: Verifica approfondita: aggiungi le credenziali che fanno passare ogni run

**Obiettivo.** Aggiungi una credenziale esatta per l'environment, una esatta per pull_request e due espressioni per feature-* e v*. Rilancia gli stessi run: passano tutti e sei. Nota che la credenziale pull_request fa passare anche il run pull_request_target.

**Prerequisiti**

- RUN_IDS del passo precedente ancora impostato in questo terminale
- Queste due espressioni controllano solo il sub; la documentazione Microsoft chiede anche repository_id, vedi l'articolo

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

**Output atteso**

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

### Passo 8: Pull request da fork: stampa cosa dice la documentazione GitHub

**Obiettivo.** Non ho potuto provare un vero fork. docs.py stampa le tre frasi della documentazione GitHub che decidono la questione: niente segreti per i fork, un GITHUB_TOKEN in sola lettura e permessi di scrittura ridotti a lettura per ogni evento di pull request tranne pull_request_target.

**Prerequisiti**

- python3 con accesso a internet; questo passo legge solo docs.github.com
- Non provato: se un job pull_request da un fork riceve un token OIDC. Secondo la mia lettura della documentazione, 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
```

**Output atteso**

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

### Passo 9: Pulizia: Entra, Azure e il repo

**Obiettivo.** Elimina la app registration, che rimuove tutte le sue credenziali federate, elimina il resource group, verifica che non esistano più e archivia o elimina il repository privato.

**Prerequisiti**

- Esegui dalla cartella gh-lab con il blocco env e OBJ ancora impostati

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

**Output atteso**

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