iamops.dev
Argo auf X RSS-Feed
DEDeutsch

Labs Technisch 8 Min. Lesezeit

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.

Zwei Terminal-Aufnahmen aus meinem Lab: ein Push auf feature-x und ein Pull Request, beide mit AADSTS700213 abgelehnt, und eine Tabelle, in der nach den zusätzlichen Credentials alle sechs Laufarten durchgehen. Kennungen sind Platzhalter.
Kurz gesagtEin GitHub-Workflow kann sich ohne Client Secret bei Azure anmelden:…
  • 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 9 Schritte

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.

Zu den Schritten

So funktioniert es

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:

  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.
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.
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.
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.
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.
6 von 6 gehen durch. <prefix> steht für repo:<owner>@<id>/<repo>@<id>. 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.
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.
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

bash · env.sh
# 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 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
bash · azure.sh
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

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
yaml · .github/workflows/login.yml
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
bash · repo.sh
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

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
bash · fic-main.sh
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

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
bash · refused.sh
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

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
bash · release.sh
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

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
bash · probe.sh
#!/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"
yaml · .github/workflows/probe.yml
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
python · fmt.py
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)
bash · phase1.sh
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

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
bash · phase2.sh
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

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
python · docs.py
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))
bash · forks.sh
python3 docs.py

Erwartete Ausgabe

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
bash · cleanup.sh
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

Ausgabe
false
0

Quellen#

Diesen Beitrag diskutieren#

Hat es dir geholfen? Teile es und sag mir, was du denkst.

Auf X folgen

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

Verwandte Beiträge und Labs