# Von GitHub Actions nach Azure mit Workload Identity Federation: welche Läufe ein Token bekommen, und warum

> Lab: Ein GitHub-Workflow meldet sich ohne Secret bei Azure an. Ich zeige den sub von sechs Laufarten und welches Credential jede zulässt, auch Pull Requests.

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

## Kurz gesagt

- Ein GitHub-Workflow kann sich ohne Client Secret bei Azure anmelden: GitHub signiert ein kurzlebiges Token, und ein Federated Credential in Entra vertraut genau einem sub-Claim.
- Neue Repositories senden einen unveränderlichen sub mit Owner- und Repository-ID. Legen Sie zuerst das Repository an, lesen Sie die IDs und schreiben Sie dann das Credential.
- Mit nur einem Credential für main ging 1 von 6 Laufarten durch. Ein Credential für das Environment, eines für pull_request und zwei Wildcard-Expressions brachten 6 von 6.
- pull_request und pull_request_target senden denselben sub. Ein pull_request-Credential vertraut also auch pull_request_target-Jobs, die mit Secrets laufen. Checken Sie dort nie den Head des Pull Requests aus.
- Pull Requests aus Forks habe ich nicht getestet. Laut GitHub-Doku bekommen sie keine Schreibrechte, ich erwarte also kein Token, habe es aber nicht gesehen.

Eine Deployment-Pipeline mit einem Client Secret darin ist ein Secret, das auf sein Leck wartet. GitHub Actions kann sich ohne Secret bei Azure anmelden: GitHub signiert für den Job ein kurzlebiges OIDC-Token, und Entra vertraut ihm über ein Federated Credential. Dieses Jahr hat sich zweierlei geändert. Seit dem 15. Juli 2026 bekommen neue Repositories einen [unveränderlichen sub-Claim](https://github.blog/changelog/2026-04-23-immutable-subject-claims-for-github-actions-oidc-tokens/) mit Owner- und Repository-ID, und die Wildcard-Credentials von Entra sind noch in Preview. Beides habe ich in einem [News-Beitrag](https://iamops.dev/de/workload-identity-news-immutable-sub-entra-wildcards-workos/) zusammengefasst. Dieses Lab ist der praktische Teil.

## Was dieses Lab zeigt

Eine App-Registrierung mit Reader auf einer einzigen leeren Ressourcengruppe, ein privates Repository, nirgends ein Secret. Das Lab:

1. Vertraut dem Branch main mit einem exakten Credential und sieht `azure/login` gelingen.
2. Pusht einen Feature-Branch, öffnet einen Pull Request und sieht beide mit AADSTS700213 abgelehnt.
3. Erlaubt `release/*` mit einer Claims-Matching-Expression.
4. Gibt den genauen `sub` von sechs Laufarten aus und legt dann die Credentials an, mit denen jede durchgeht.
5. Betrachtet Pull Requests aus Forks, nur anhand der Doku, weil ich sie nicht testen konnte.

## Aufbau

Verwenden Sie einen Tenant und ein Abonnement nur zum Testen und ein GitHub-Konto, das Ihnen gehört. Die App-Registrierung bekommt Reader auf eine leere Ressourcengruppe. Ein erfolgreicher Login beweist so die Federation und sonst nichts. Die drei IDs, die der Workflow braucht (Client, Tenant, Abonnement), sind keine Secrets und kommen in Repository-Variablen.

Legen Sie das Repository vor dem Credential an. Ein neues Repository sendet `repo:<owner>@<owner-id>/<repo>@<repo-id>:...`, und die beiden IDs kennen Sie erst, wenn das Repository existiert. Ein Subject nach alter Art, `repo:<owner>/<repo>:ref:refs/heads/main`, passt nicht mehr.

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

## Der Lauf

**main meldet sich an.** Der Workflow gibt die Claims aus, die GitHub vorlegt, führt dann `azure/login` aus und listet die Ressourcengruppen. Mein erster Lauf scheiterte nach dem Login mit "No subscriptions found", weil die Reader-Rolle noch nicht verteilt war. Eine Minute Warten hat es behoben.

![Terminalausgabe: das Federated Credential gh-main mit exaktem Subject für den Branch main, dann ein Lauf auf main, der erfolgreich endet, denselben sub-Claim ausgibt, die Ressourcengruppe listet und die Anmeldung als Service Principal zeigt. IDs sind Platzhalter.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/01-main.webp)

*Der sub passt Zeichen für Zeichen. Das Credential ist die ganze Vertrauensbeziehung. Es gibt kein Secret anzulegen und nichts zu rotieren. IDs sind Platzhalter.*

**Ein Feature-Branch und ein Pull Request werden abgelehnt.** Gleicher Workflow, anderer `sub`. Entra antwortet mit AADSTS700213, und die Meldung nennt das empfangene Subject. Schneller lässt sich ein Credential nicht debuggen.

![Terminalausgabe: ein Push auf feature-x und ein Pull Request enden beide mit Fehler AADSTS700213, kein passender Federated-Identity-Eintrag. Die vorgelegten Subjects enden auf ref:refs/heads/feature-x und pull_request. IDs sind Platzhalter.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/02-feature-refused.webp)

*Abgelehnt, und zwar absichtlich. Ein Tippfehler im Branch-Namen oder ein ungeprüfter Pull Request bekommt die Deployment-Identität nicht. IDs sind Platzhalter.*

**release/* mit einer Expression.** Ein flexibles Federated Credential enthält statt eines Subjects eine `claimsMatchingExpression`. Für App-Registrierungen habe ich es mit `az rest` über den Graph-Beta-Endpunkt angelegt. Ich bin der Microsoft-Doku gefolgt und habe zusätzlich `repository_id` festgelegt:

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

![Terminalausgabe: az rest legt das Credential gh-release mit einer Claims-Matching-Expression auf sub für release-Branches plus einer Prüfung von repository_id an, dann endet ein Push auf release/1 erfolgreich und gibt seinen sub aus. IDs sind Platzhalter.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/03-release-expression.webp)

*Ein Credential für eine ganze Familie von Branches. Das Muster behält Owner- und Repository-ID, und repository_id wird separat geprüft. IDs sind Platzhalter.*

## Vertiefte Prüfung: der sub jeder Laufart

Ein Leser fragte, ob die Ablehnung eines Feature-Branches und eines Pull Requests ein Fehler ist. Ist sie nicht, und ich wollte es zeigen. Ein kleines Skript, `probe.sh`, holt bei GitHub ein Token, dekodiert den `sub`, bietet das Token Entra an und gibt eine Ergebniszeile aus. Der Workflow führt es bei einem Push auf main, einem Push auf einen Feature-Branch, `pull_request`, `pull_request_target`, einem Tag-Push und in einem zweiten Job mit Environment aus. Ich habe eine neue App und dasselbe private Repository verwendet.

![Terminalausgabe: eine Tabelle mit sechs Läufen und nur dem main-Credential. main geht durch. Die Läufe für Feature-Branch, Pull Request, pull_request_target, Tag und Environment scheitern mit AADSTS700213. Jede Zeile zeigt den sub nach dem Repository-Präfix.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/04-subs-before.webp)

*1 von 6 geht durch. Der Teil nach den IDs ist für jede Laufart anders, und ein Credential für main passt nur auf main.*

Dann habe ich vier Credentials hinzugefügt: ein exaktes für das Environment, ein exaktes für `pull_request` und zwei Expressions für `feature-*`-Branches und `v*`-Tags. Danach habe ich dieselben Läufe wiederholt.

![Terminalausgabe: die vier zusätzlichen Credentials mit Name und Muster, dann dieselbe Tabelle mit sechs Läufen, in der jede Zeile durchgeht. Der Platzhalter prefix steht für den Repository-Teil des sub mit Owner- und Repository-ID.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/05-subs-after.webp)

*6 von 6 gehen durch. &lt;prefix&gt; steht für repo:&lt;owner&gt;@&lt;id&gt;/&lt;repo&gt;@&lt;id&gt;. Ein Credential enthält entweder ein exaktes Subject oder eine Expression, nie beides.*

| Lauf | `sub` nach dem Repository-Präfix | Credential, mit dem er durchgeht | Nur main | Danach |
| --- | --- | --- | --- | --- |
| Push auf main | `ref:refs/heads/main` | Exaktes Subject | Durch | Durch |
| Push auf feature-probe | `ref:refs/heads/feature-probe` | Expression `...ref:refs/heads/feature-*` | AADSTS700213 | Durch |
| `pull_request` | `pull_request` | Exaktes Subject | AADSTS700213 | Durch |
| `pull_request_target` | `pull_request` | Dasselbe `pull_request`-Credential | AADSTS700213 | Durch |
| Tag v1 | `ref:refs/tags/v1` | Expression `...ref:refs/tags/v*` | AADSTS700213 | Durch |
| Job mit Environment lab-b1-prod | `environment:lab-b1-prod` | Exaktes Subject | AADSTS700213 | Durch |

**Ein Unterschied zur Microsoft-Doku.** Die Expressions für `feature-*` und `v*` hatten nur eine Bedingung auf `sub`, ohne `repository_id`. Entra hat beide akzeptiert, und die Läufe gingen durch. Meine Muster enthielten Owner- und Repository-ID bereits, sie waren also trotzdem festgelegt. In einer späteren Prüfung am selben Tag akzeptierte Entra auch eine Expression für den gesamten Owner ohne `repository_id` oder `repository_owner_id`, und dieses Credential stellte einem anderen Repository desselben Owners ein Token aus. Laut Microsoft muss eine Expression für GitHub `sub` und `repository_id` oder `repository_owner_id` prüfen. Ich empfehle dennoch, `repository_id` in jede Expression aufzunehmen. Die Regel ist dokumentiert und die Funktion ist in Preview, ein Credential nur auf sub kann also später abgelehnt werden oder nicht mehr passen. Die ID-Prüfung hängt auch nicht davon ab, dass das Muster stimmt: Ein Wildcard für den gesamten Owner hat bereits einem anderen meiner Repositories ein Token ausgestellt, und der reine Namens-`sub` eines älteren Repositorys kann auf einen Namen passen, der Ihnen nicht mehr gehört.

## pull_request und pull_request_target teilen ein Subject

Beide Ereignisse senden einen `sub`, der auf `pull_request` endet, egal welcher Branch. Ein `pull_request`-Credential in Entra vertraut also auch `pull_request_target`-Jobs. Diese laufen vom Basis-Branch, mit Secrets und mit OIDC-Token. Checkt ein solcher Workflow den Head des Pull Requests aus, führt der Autor des Pull Requests Code mit Ihrer Cloud-Identität aus. Mein Probe-Workflow nutzte den Standard-Checkout, der den Basis-Branch nimmt. Ändern Sie das nicht in einem Workflow, der ein Token bekommen kann.

Ein Job mit Environment ist die zweite Überraschung. Er sendet `environment:<name>` statt des Branches. Wer einen Deploy-Job in ein Environment verschiebt, bricht ein Credential, das für main geschrieben wurde.

## Pull Requests aus Forks: aus der Doku, nicht getestet

Einen Pull Request aus einem Fork habe ich nicht getestet. Dafür braucht es ein zweites GitHub-Konto, und ich nutze keines, das nicht mir gehört. Was folgt, ist die GitHub-Doku und meine Lesart davon.

![Terminalausgabe mit drei aus der GitHub-Doku zitierten Sätzen: Secrets werden nicht an Workflows aus Forks übergeben, das GITHUB_TOKEN hat in Pull Requests aus Forks nur Leserechte, und Schreibrechte werden für Pull-Request-Ereignisse außer pull_request_target aus einem Fork auf Lesen reduziert.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/06-forks-docs.webp)

*Nur Doku, kein Test. Die Zeilen sind direkt von den GitHub-Seiten ausgegeben, damit Sie den Wortlaut prüfen können.*

`id-token: write` ist ein Schreibrecht. Bei einem `pull_request` aus einem Fork wird es auf Lesen reduziert. Nach meiner Lesart bekommt der Job also gar kein OIDC-Token. `probe.sh` behandelt diesen Fall und würde "no OIDC token was offered" ausgeben. Gesehen habe ich es nicht. `pull_request_target` ist in dieser Doku die Ausnahme, und das ist die Falle von oben.

## Stolpersteine

- **Lesen Sie den `sub` aus einem echten Lauf, bevor Sie ein Credential schreiben.** Die Log-Zeile und die Meldung AADSTS700213 zeigen ihn beide.
- **Warten Sie nach der Rollenzuweisung.** Ohne Wartezeit klappte der Login, und der nächste Befehl scheiterte mit "No subscriptions found".
- **Expressions sind Preview und Graph Beta.** Für App-Registrierungen habe ich `az rest` verwendet. Die Konzeptseite von Microsoft sagt, die CLI unterstütze sie noch nicht explizit, während `az identity federated-credential` (benutzerseitig zugewiesene verwaltete Identitäten) dafür Preview-Parameter auflistet.
- **Alte Repositories behalten den reinen Namens-`sub`**, bis jemand umstellt. Schreiben Sie das Credential für das Format, das das Repository wirklich sendet.

## Was das für die Sicherheit heißt

1. Nutzen Sie in der CI Federation statt eines Client Secrets. Es gibt nichts zu speichern, zu verlieren oder zu rotieren.
2. Nehmen Sie das engste passende Credential: exakt für main und für ein Environment, eine Expression nur für eine echte Familie von Refs.
3. Behalten Sie Owner- und Repository-ID in jedem Subject und Muster, und nehmen Sie `repository_id` in jede Expression auf.
4. Gehen Sie davon aus, dass ein `pull_request`-Credential auch `pull_request_target` vertraut. Checken Sie in einem Workflow, der ein Token bekommen kann, nie fremden Code aus.
5. Löschen Sie Credentials, deren Repository nicht mehr existiert. Mit dem alten Namensformat kann sich jemand anderes den Namen holen.

## Aufräumen

Ich habe die App-Registrierung gelöscht, was ihre Credentials entfernt, die Ressourcengruppe gelöscht, geprüft, dass beide weg sind, und das private Repository archiviert. Nach der vertieften Prüfung habe ich auch die zusätzliche App, den Branch, das Tag, den Pull Request, das Environment und die Variablen entfernt.

![Terminalausgabe: App-Registrierung und Ressourcengruppe werden gelöscht, az group exists gibt false aus, die Anzahl der Apps ist 0 und das Repository wird archiviert.](https://iamops.dev/media/github-actions-azure-workload-identity-federation/07-cleanup.webp)

*Nichts läuft weiter. Es wurde nie ein Secret angelegt, also gibt es nichts zu widerrufen.*

## Was nicht ausgeführt wurde

- Ein Pull Request aus einem Fork. Dieser Teil stützt sich auf die GitHub-Doku.
- Ein bestehendes Repository, das auf das unveränderliche Format umgestellt wurde, und der Preview-Endpunkt von GitHub für das Subject-Präfix.
- Eine Rolle, die deployen darf. Die App hatte nur Reader auf einer leeren Ressourcengruppe.
- Eine Expression mit `repository_owner_id` oder `job_workflow_ref`.
- Andere Clouds. GitHub dokumentiert AWS, Google Cloud und Vault, ich habe nur Azure getestet.

*Ausgeführt am 20. November 2026 mit der Azure CLI, der GitHub CLI und `azure/login@v2` auf einem von GitHub gehosteten Runner, in einem Test-Tenant und einem privaten Repository. Die Terminalbilder wurden aus der gespeicherten Ausgabe neu gezeichnet, Benutzer, IDs und Zeitstempel sind durch Platzhalter ersetzt.*

## Dieses Lab nachbauen

Etwa 30 Minuten: die Azure CLI und die GitHub CLI auf Ihrem Rechner, ein Entra-Tenant und ein Abonnement nur zum Testen und ein GitHub-Konto, das Ihnen gehört. Es kostet nichts: eine App-Registrierung, eine leere Ressourcengruppe, ein privates Repository und ein paar Minuten GitHub Actions. Öffnen Sie jeden Schritt, kopieren Sie die Blöcke und vergleichen Sie Ihre Ausgabe mit meiner.

Jeder Wert in spitzen Klammern ist ein Platzhalter für Ihre Testumgebung. Nichts auf dieser Seite ist eine echte Kennung oder ein echtes Geheimnis.

**Variablen einmal setzen** `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
```

### Schritt 1: Ressourcengruppe, App-Registrierung und Reader-Rolle anlegen

**Ziel.** Legen Sie die Identität an, die die Pipeline annimmt, und geben Sie ihr Reader auf genau eine leere Ressourcengruppe. Ein erfolgreicher Login beweist dann die Federation und keine breite Berechtigung.

**Voraussetzungen**

- Azure CLI angemeldet an einem Test-Tenant und Test-Abonnement, mit dem Recht, App-Registrierungen und Rollenzuweisungen anzulegen
- jq und 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
```

**Erwartete Ausgabe**

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

### Schritt 2: Zuerst das private Repo anlegen, dann drei IDs als Variablen setzen

**Ziel.** Fügen Sie einen Workflow hinzu, der die Claims von GitHub ausgibt und dann azure/login ausführt. Legen Sie das Repository vor dem Federated Credential an: neue Repositories nutzen einen unveränderlichen sub mit Owner- und Repository-ID, und die gibt es erst, wenn das Repository existiert.

**Voraussetzungen**

- GitHub CLI angemeldet, mit dem Recht, ein privates Repository anzulegen
- Die Variablen APPID und OBJ aus dem vorigen Schritt in diesem Terminal
- Speichern Sie login.yml als .github/workflows/login.yml in gh-lab, bevor Sie repo.sh ausführen

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

**Erwartete Ausgabe**

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

### Schritt 3: main mit einem exakten Credential vertrauen und pushen

**Ziel.** Schreiben Sie ein Federated Credential, dessen Subject genau dem sub eines Pushs auf main entspricht, warten Sie, bis die Rolle verteilt ist, pushen Sie und sehen Sie, wie sich der Job als Service Principal anmeldet.

**Voraussetzungen**

- Die Variablen OBJ, OWNERID und REPOID aus den vorigen Schritten in diesem Terminal
- In diesem Schritt entsteht kein Secret

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

**Erwartete Ausgabe**

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

### Schritt 4: Negativtests: ein Feature-Branch und ein Pull Request

**Ziel.** Pushen Sie einen Branch, den das Credential nicht abdeckt, und öffnen Sie daraus einen Pull Request. Beide Logins scheitern mit AADSTS700213, und die Meldung nennt das genaue Subject.

**Voraussetzungen**

- Der main-Lauf aus dem vorigen Schritt ist erfolgreich beendet

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

**Erwartete Ausgabe**

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

### Schritt 5: release/* mit einer Claims-Matching-Expression erlauben

**Ziel.** Legen Sie über den Graph-Beta-Endpunkt ein flexibles Federated Credential an: sub passt auf die release-Branches dieses Repositorys, und repository_id wird zusätzlich geprüft, wie es die Microsoft-Doku verlangt. Pushen Sie dann release/1.

**Voraussetzungen**

- Flexible Federated Credentials sind in Preview; für App-Registrierungen legt man sie mit az rest über Graph Beta an

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

**Erwartete Ausgabe**

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

### Schritt 6: Vertiefte Prüfung: den sub für sechs Arten von Läufen ausgeben

**Ziel.** Führen Sie probe.sh bei einem Push auf main, einem Feature-Branch, pull_request, pull_request_target, einem Tag und einem Job mit Environment aus. Das Skript dekodiert den sub, bietet das Token Entra an und gibt eine RESULT-Zeile aus. Mit nur dem main-Credential läuft nur main durch.

**Voraussetzungen**

- Speichern Sie probe.sh im Wurzelverzeichnis des Repositorys, probe.yml unter .github/workflows/ und fmt.py daneben
- Dieser Schritt ersetzt login.yml durch probe.yml, damit nur die Probe läuft

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

**Erwartete Ausgabe**

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

### Schritt 7: Vertiefte Prüfung: die Credentials anlegen, mit denen jeder Lauf durchgeht

**Ziel.** Legen Sie ein exaktes Credential für das Environment, ein exaktes für pull_request und zwei Expressions für feature-* und v* an. Starten Sie dieselben Läufe neu: alle sechs gehen durch. Das pull_request-Credential lässt auch den pull_request_target-Lauf herein.

**Voraussetzungen**

- RUN_IDS aus dem vorigen Schritt ist in diesem Terminal noch gesetzt
- Diese zwei Expressions prüfen nur sub; die Microsoft-Doku verlangt zusätzlich repository_id, siehe Beitrag

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

**Erwartete Ausgabe**

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

### Schritt 8: Pull Requests aus Forks: ausgeben, was die GitHub-Doku sagt

**Ziel.** Einen echten Fork konnte ich nicht testen. docs.py gibt die drei Sätze aus der GitHub-Doku aus, die es entscheiden: keine Secrets für Forks, ein GITHUB_TOKEN nur mit Leserechten und Schreibrechte auf Lesen reduziert für jedes Pull-Request-Ereignis außer pull_request_target.

**Voraussetzungen**

- python3 mit Internetzugang; dieser Schritt liest nur docs.github.com
- Nicht getestet: ob ein pull_request-Job aus einem Fork ein OIDC-Token bekommt. Nach meiner Lesart der Doku nicht

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

**Erwartete Ausgabe**

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

### Schritt 9: Aufräumen: Entra, Azure und das Repo

**Ziel.** Löschen Sie die App-Registrierung, was alle ihre Federated Credentials entfernt, löschen Sie die Ressourcengruppe, prüfen Sie, dass beide weg sind, und archivieren oder löschen Sie das private Repository.

**Voraussetzungen**

- Im Ordner gh-lab ausführen, mit gesetztem env-Block und OBJ

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

**Erwartete Ausgabe**

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