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.
Dieses Lab nachbauen
Dieses Lab habe ich so geschrieben, dass Sie es selbst nachbauen können. Jeder Schritt enthält die Befehle zum Kopieren und die Ausgabe, die ich bekommen habe, und Sie können ihn als erledigt abhaken. Die Haken bleiben nur in diesem Browser.
Kopiert einen fertigen Prompt für Claude Code, Cursor, Codex oder einen anderen Coding-Agenten. Nur für Testumgebungen.
Prompt anzeigen
I want to run a hands-on lab from iamops.dev, and I would like your help to do it safely. Lab: Von GitHub Actions nach Azure mit Workload Identity Federation: welche Läufe ein Token bekommen, und warum Read the whole lab here (Markdown): https://iamops.dev/de/github-actions-azure-workload-identity-federation.md What the lab needs before the first step: - Azure CLI signed in to a throwaway tenant and subscription, with rights to create app registrations and role assignments - jq and python3 - Values I have to set myself (the lab uses placeholders): <GITHUB_USER>, <TENANT_ID>, <SUBSCRIPTION_ID>, <AZURE_REGION> How I want you to work: 1. Read the lab from start to finish first (each step lists its own prerequisites). Then check that the prerequisites are in place and that the tool versions match what the lab expects. Tell me what is missing before you run anything. 2. Run one step at a time. Before each command, show it to me and say in a sentence what it does. 3. Ask me before anything that costs money, creates cloud resources, touches a real tenant or account, or deletes anything. Wait for my answer. 4. Use the placeholders from the lab. Never paste real secrets, tokens or production identities into a command, a file or this chat. If a value is needed, tell me where to set it myself. 5. After each step, compare the output with the expected output in the lab. If it does not match, stop and tell me what differs. Do not carry on or invent a fix without asking me. 6. At the end, report what passed, what failed and which cleanup you did. Then offer to tick the steps off for me. The lab page keeps ticks only in my browser, so if you cannot do that, list the steps I should tick. This lab is for test environments only. Do not run it against production, or against a tenant or account that holds real data or real users. You may answer in my language.
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 mit Owner- und Repository-ID, und die Wildcard-Credentials von Entra sind noch in Preview. Beides habe ich in einem News-Beitrag 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:
- Vertraut dem Branch main mit einem exakten Credential und sieht
azure/logingelingen. - Pusht einen Feature-Branch, öffnet einen Pull Request und sieht beide mit AADSTS700213 abgelehnt.
- Erlaubt
release/*mit einer Claims-Matching-Expression. - Gibt den genauen
subvon sechs Laufarten aus und legt dann die Credentials an, mit denen jede durchgeht. - 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.
{"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.

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.

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

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.

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

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
subaus 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 restverwendet. Die Konzeptseite von Microsoft sagt, die CLI unterstütze sie noch nicht explizit, währendaz 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#
- Nutzen Sie in der CI Federation statt eines Client Secrets. Es gibt nichts zu speichern, zu verlieren oder zu rotieren.
- 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.
- Behalten Sie Owner- und Repository-ID in jedem Subject und Muster, und nehmen Sie
repository_idin jede Expression auf. - Gehen Sie davon aus, dass ein
pull_request-Credential auchpull_request_targetvertraut. Checken Sie in einem Workflow, der ein Token bekommen kann, nie fremden Code aus. - 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.

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_idoderjob_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
# 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 0 von 9 Schritten erledigt
Schritt 1Ressourcengruppe, 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
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
{
"location": "<AZURE_REGION>",
"name": "lab-b1-rg-wif"
}
app registration created
[
{
"role": "Reader",
"scope": "/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/lab-b1-rg-wif"
}
] Schritt 2Zuerst 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
name: login
on:
push:
branches: [main, feature-x, 'release/**']
pull_request:
permissions:
id-token: write
contents: read
jobs:
azure:
runs-on: ubuntu-latest
steps:
- name: Show the claims GitHub presents to Entra
run: |
TOKEN=$(curl -s -H "Authorization: bearer $ACTIONS_ID_TOKEN_REQUEST_TOKEN" "$ACTIONS_ID_TOKEN_REQUEST_URL&audience=api://AzureADTokenExchange" | jq -r .value)
echo "$TOKEN" | python3 -c 'import sys,json,base64;t=sys.stdin.read().split(".")[1];c=json.loads(base64.urlsafe_b64decode(t+"="*(-len(t)%4)));print({k:c[k] for k in ("sub","event_name","ref")})'
- uses: azure/login@v2
with:
client-id: ${{ vars.AZURE_CLIENT_ID }}
tenant-id: ${{ vars.AZURE_TENANT_ID }}
subscription-id: ${{ vars.AZURE_SUBSCRIPTION_ID }}
- name: Use the identity
run: |
az group list --query "[].name" -o tsv
az account show --query "{signedInAs: user.type}" -o json git init -q -b main && git add -A && git commit -q -m "Login workflow"
gh repo create $GH_USER/$REPO --private --source . --remote origin
export OWNERID=$(gh api repos/$GH_USER/$REPO --jq .owner.id)
export REPOID=$(gh api repos/$GH_USER/$REPO --jq .id)
for kv in AZURE_CLIENT_ID=$APPID AZURE_TENANT_ID=$TENANT AZURE_SUBSCRIPTION_ID=$SUBSCRIPTION; do gh variable set ${kv%%=*} --body ${kv#*=} -R $GH_USER/$REPO; done
gh variable list -R $GH_USER/$REPO | cut -f1 Erwartete Ausgabe
https://github.com/<GITHUB_USER>/lab-b1-gh-wif
AZURE_CLIENT_ID
AZURE_SUBSCRIPTION_ID
AZURE_TENANT_ID Schritt 3main 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
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
{
"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 4Negativtests: 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
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
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 5release/* 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
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
{
"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 6Vertiefte 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
#!/usr/bin/env bash
# Print the sub claim GitHub issues for this run, then try to exchange it at Entra.
JOB=$1
if [ -z "$ACTIONS_ID_TOKEN_REQUEST_URL" ]; then echo "RESULT job=$JOB event=$GITHUB_EVENT_NAME ref=$GITHUB_REF sub=none entra=no OIDC token was offered to this job"; exit 0; fi
T=$(curl -s -H "Authorization: bearer $ACTIONS_ID_TOKEN_REQUEST_TOKEN" "$ACTIONS_ID_TOKEN_REQUEST_URL&audience=api://AzureADTokenExchange" | jq -r .value)
SUB=$(echo "$T" | cut -d. -f2 | tr '_-' '/+' | awk '{while(length($0)%4)$0=$0"=";print}' | base64 -d 2>/dev/null | jq -r .sub)
R=$(curl -s -X POST "https://login.microsoftonline.com/$TID/oauth2/v2.0/token" -d client_id=$CID -d grant_type=client_credentials -d scope=https://graph.microsoft.com/.default -d client_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearer -d client_assertion="$T")
OUT=$(echo "$R" | jq -r 'if .access_token then "token issued" else (.error_description | split(":")[0]) end')
echo "RESULT job=$JOB event=$GITHUB_EVENT_NAME ref=$GITHUB_REF sub=$SUB entra=$OUT" name: probe
on:
push:
branches: [main, 'feature-*']
tags: ['v*']
pull_request:
pull_request_target:
permissions:
id-token: write
contents: read
env:
CID: ${{ vars.AZURE_CLIENT_ID }}
TID: ${{ vars.AZURE_TENANT_ID }}
jobs:
plain:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- run: ./probe.sh plain
with-environment:
if: github.event_name == 'push' && github.ref == 'refs/heads/main'
runs-on: ubuntu-latest
environment: lab-b1-prod
steps:
- uses: actions/checkout@v4
- run: ./probe.sh environment import sys, re
rows = []
for l in open(sys.argv[1]):
m = re.search(r'job=(\S+) event=(\S+) ref=(\S+) sub=(\S+) entra=(.*)', l)
if not m: continue
job, ev, ref, sub, res = m.groups()
ctx = sub.split(':', 1)[1].split(':', 1)[1] if sub.count(':') > 1 else sub
ctx = re.sub(r'^repo:[^:]*:', '', sub)
case = {'refs/heads/main': 'main', 'refs/heads/feature-probe': 'feature branch', 'refs/tags/v1': 'tag', }.get(ref, 'pull request' if ev == 'pull_request' else 'PR (pull_request_target)' if ev == 'pull_request_target' else ref)
if job == 'environment': case = 'environment'
if ev == 'pull_request_target': case = 'PR (pull_request_target)'
rows.append((case, ctx, 'PASS' if 'issued' in res else 'FAIL ' + res))
order = ['main', 'feature branch', 'pull request', 'PR (pull_request_target)', 'tag', 'environment']
rows.sort(key=lambda r: order.index(r[0]))
print('%-26s %-34s %s' % ('run', 'sub (after repo:<owner>/<repo>)', 'Entra'))
for r in rows: print('%-26s %-34s %s' % r) git checkout -q main && git rm -q .github/workflows/login.yml
chmod +x probe.sh && git add probe.sh .github/workflows/probe.yml
gh api -X PUT repos/$GH_USER/$REPO/environments/lab-b1-prod > /dev/null
git commit -q -m probe && git push -q origin main
git switch -q -c feature-probe && echo x > note.txt && git add . && git commit -q -m f && git push -q -u origin feature-probe
gh pr create --head feature-probe --base main --title probe --body lab
git tag v1 main && git push -q origin v1
sleep 60
RUN_IDS=$(gh run list --workflow probe.yml --limit 5 --json databaseId -q ".[].databaseId")
for id in $RUN_IDS; do gh run view $id --log | grep -o "RESULT.*"; done | sort -u > phase1.txt
python3 fmt.py phase1.txt Erwartete Ausgabe
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 7Vertiefte 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
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
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 8Pull 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
import re, html, urllib.request
t = urllib.request.urlopen('https://docs.github.com/en/actions/reference/workflows-and-actions/events-that-trigger-workflows').read().decode()
t = html.unescape(re.sub(r'<[^>]+>', ' ', t)); t = re.sub(r'\s+', ' ', t)
for pat in [r"With the exception of GITHUB_TOKEN , secrets are not passed to the runner when a workflow is triggered from a forked repository\.", r"The GITHUB_TOKEN has read-only permissions in pull requests from forked repositories\."]:
print('events-that-trigger-workflows: ' + re.search(pat, t).group(0).replace(' ,', ','))
t = urllib.request.urlopen('https://docs.github.com/en/actions/reference/workflows-and-actions/workflow-syntax').read().decode()
t = html.unescape(re.sub(r'<[^>]+>', ' ', t)); t = re.sub(r'\s+', ' ', t)
print('workflow-syntax: ' + re.search(r"if the workflow was triggered by a pull request event other than pull_request_target from a forked repository.{0,160}?read only\.", t).group(0)) python3 docs.py Erwartete Ausgabe
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 9Aufrä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
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
false
0 Quellen#
- GitHub Changelog, 23 Apr 2026 (edited 10 Jun 2026): Immutable subject claims for GitHub Actions OIDC tokens
- GitHub Docs: OpenID Connect reference
- GitHub Docs: Events that trigger workflows
- GitHub Docs: Workflow syntax (permissions)
- GitHub Docs: Securely using pull_request_target
- Microsoft Learn: Configure an app to trust an external identity provider
- Microsoft Learn: Flexible federated identity credentials (preview)
- Microsoft Learn: Migrate GitHub Actions federated credentials to immutable subjects
Diesen Beitrag diskutieren#
Hat es dir geholfen? Teile es und sag mir, was du denkst.
Dieser Beitrag als Markdown · RSS · JSON feed
Neue Beiträge per E-Mail
Eine E-Mail pro Woche mit neuen Beiträgen und Labs. Jederzeit abbestellbar.
Ihre Adresse wird bei Kit gespeichert, dem Dienst, der die E-Mails versendet. Details