Tag 11: GitHub Actions
Ziel: Ein GitHub-Workflow holt Secrets aus OpenBao per OIDC, ohne gespeicherten Token, einmal mit
hashicorp/vault-action, einmal mitbaoundcurl. · Dauer: ca. 90 min · Voraussetzung: Tag 10
Briefing
- Mit
permissions: id-token: writedarf ein Job bei GitHub ein OIDC-JWT anfordern. Issuer isthttps://token.actions.githubusercontent.com. - Der
sub-Claim hängt vom Kontext ab: Environment schlägt Branch, Tag und Pull Request. hashicorp/vault-actionspricht die Vault-HTTP-API (/v1/auth/<path>/login) und funktioniert damit auch gegen OpenBao.- Ohne Action geht es mit zwei HTTP-Aufrufen: JWT bei GitHub holen, bei OpenBao einlösen.
- Ein GitHub-Environment mit Reviewern ist die Freigabe. Die Rolle bindet genau dieses Environment.
GitHub-Job ──(ACTIONS_ID_TOKEN_REQUEST_URL&audience=openbao)──▶ JWT
│
└── POST /v1/auth/jwt-github/login {role, jwt} ──▶ OpenBao ──▶ Token 5 min
Drill 1: Echten GitHub-Issuer anbinden
OpenBao holt sich die Signaturschlüssel per OIDC-Discovery selbst. Dafür braucht der OpenBao-Pod ausgehend HTTPS zu GitHub.
mkdir -p ~/secrets-lab/tag11 && cd ~/secrets-lab/tag11
export BAO_ADDR=http://127.0.0.1:8200 BAO_TOKEN=root
bao auth enable -path=jwt-github jwt
bao write auth/jwt-github/config \
oidc_discovery_url=https://token.actions.githubusercontent.com \
bound_issuer=https://token.actions.githubusercontent.com
bao read -format=json auth/jwt-github/config \
| jq '.data | {oidc_discovery_url, bound_issuer, status}'Erwartet:
Success! Enabled jwt auth method at: jwt-github/
Success! Data written to: auth/jwt-github/config
{
"oidc_discovery_url": "https://token.actions.githubusercontent.com",
"bound_issuer": "https://token.actions.githubusercontent.com",
"status": "valid"
}
Das Gegenstück zu GitHub ist eine Rolle pro Repo und Environment:
bao write auth/jwt-github/role/shop-prod - <<'EOF'
{
"role_type": "jwt",
"user_claim": "sub",
"bound_audiences": ["openbao"],
"bound_subject": "repo:acme/shop:environment:production",
"bound_claims": {
"repository_id": "100001",
"workflow_ref": "acme/shop/.github/workflows/deploy.yml@refs/heads/main"
},
"claim_mappings": {"repository": "repository", "run_id": "run_id", "actor": "actor"},
"token_policies": ["ci-deploy"],
"token_ttl": "5m",
"token_max_ttl": "10m"
}
EOF
bao write auth/jwt-github/login role=shop-prod \
jwt="$(cd ../tag10 && ./mint-jwt.sh aud=openbao)" 2>&1 | tail -1Erwartet:
Success! Data written to: auth/jwt-github/role/shop-prod
* error validating token: error verifying token signature: failed to verify id token
signature
Richtig so: Dein Lab-JWT ist nicht von GitHub signiert. Ab hier
spielst du den Ablauf deshalb auf jwt-ci/ mit deinem
Lab-Issuer aus Tag 10 nach.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Claims und sub-Formate
Die wichtigsten Claims im GitHub-Token (Stand GitHub-Doku):
| Claim | Beispiel | Wofür binden? |
|---|---|---|
sub |
repo:acme/shop:environment:production |
Kontext des Jobs |
repository / repository_id |
acme/shop / 100001 |
Repo, ID ist umbenennungsfest |
ref, ref_type |
refs/heads/main, branch |
Branch oder Tag |
environment |
production |
nur bei Jobs mit environment: |
workflow_ref |
acme/shop/.github/workflows/deploy.yml@refs/heads/main |
Workflow-Datei |
job_workflow_ref |
acme/ci/.github/workflows/deploy.yml@refs/heads/main |
Reusable Workflow |
repository_owner |
acme |
Organisation |
runner_environment |
github-hosted / self-hosted |
Runner-Typ |
Die sub-Formate:
repo:acme/shop:environment:production Job mit environment: (hat Vorrang)
repo:acme/shop:ref:refs/heads/main Branch, ohne Environment
repo:acme/shop:ref:refs/tags/v1.4.0 Tag, ohne Environment
repo:acme/shop:pull_request Pull Request, ohne Environment
Achtung: Repos, die nach dem 15. Juli 2026 angelegt, umbenannt oder übertragen wurden (oder per Opt-in), bekommen das unveränderliche Format
repo:acme@<owner-id>/shop@<repo-id>:…. Prüfe den echtensubdeiner Organisation, bevor dubound_subjectsetzt. Mitinclude_claim_keyslässt sich das Format zusätzlich anpassen.
Die Audience ist standardmäßig die URL des Owners
(https://github.com/acme). Setze im Workflow eine eigene,
hier openbao, damit ein für AWS gedachtes Token nicht bei
OpenBao funktioniert.
Fortschritt speichern? Kostenlos registrieren
Drill 3: Rolle shop-prod im Lab
nachstellen
Dieselbe Rolle wie in Drill 1, nur auf dem Lab-Mount:
cp ../tag10/{mint-jwt.sh,ci-issuer.key} .
bao write auth/jwt-ci/role/shop-prod - <<'EOF'
{
"role_type": "jwt",
"user_claim": "sub",
"bound_audiences": ["openbao"],
"bound_subject": "repo:acme/shop:environment:production",
"bound_claims": {
"repository_id": "100001",
"workflow_ref": "acme/shop/.github/workflows/deploy.yml@refs/heads/main"
},
"claim_mappings": {"repository": "repository", "run_id": "run_id", "actor": "actor"},
"token_policies": ["ci-deploy"],
"token_ttl": "5m",
"token_max_ttl": "10m"
}
EOF
PROD="sub=repo:acme/shop:environment:production environment=production"
for args in "$PROD" \
"sub=repo:acme/shop:pull_request event_name=pull_request" \
"$PROD workflow_ref=acme/shop/.github/workflows/evil.yml@refs/heads/feat"; do
BAO_TOKEN= bao write -field=token_policies auth/jwt-ci/login role=shop-prod \
jwt="$(./mint-jwt.sh $args)" 2>&1 | tail -1; echo
doneErwartet:
Success! Data written to: auth/jwt-ci/role/shop-prod
[ci-deploy default]
* error validating token: invalid subject (sub) claim
* error validating claims: claim "workflow_ref" does not match any associated bound
claim values
Warum workflow_ref? Ohne die Bindung könnte jeder, der
in acme/shop einen Branch pushen darf, einen eigenen
Workflow mit environment: production schreiben. Erst die
Environment-Regel „nur main” plus workflow_ref
schließt das. Rufst du zentrale Reusable Workflows auf, bindest du
job_workflow_ref statt workflow_ref.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Variante A –
hashicorp/vault-action
Der Workflow, so wie er in acme/shop liegen würde
(.github/workflows/deploy.yml). Die Action liegt aktuell in
Major-Version v4 (Node-24-Runtime).
mkdir -p .github/workflows
cat > .github/workflows/deploy.yml <<'EOF'
name: deploy
on:
push:
branches: [main]
permissions:
contents: read
id-token: write # ohne das kein OIDC-Token
jobs:
deploy:
runs-on: ubuntu-latest
environment: production # sub = repo:acme/shop:environment:production
steps:
- uses: actions/checkout@v7
- name: Secrets aus OpenBao
id: bao
uses: hashicorp/vault-action@v4
with:
url: https://openbao.example.com
method: jwt
path: jwt-github
role: shop-prod
jwtGithubAudience: openbao
secrets: |
secret/data/ci/deploy registry_password | REGISTRY_PASSWORD ;
secret/data/ci/deploy kubeconfig_token | KUBE_TOKEN
- name: Registry-Login
run: |
echo "$REGISTRY_PASSWORD" | docker login registry.example.com \
-u ci --password-stdin
EOFWichtig: KV v2 braucht den vollen API-Pfad mit data/.
Die Action maskiert jeden gelesenen Wert automatisch und exportiert ihn
als Umgebungsvariable (exportEnv: true ist Standard).
Ausgeführt auf GitHub sieht das Log so aus (gekürzt, kann je nach
Version abweichen):
Run hashicorp/vault-action@v4
Get Vault Secrets
✔ secret/data/ci/deploy => outputs.REGISTRY_PASSWORD | env.REGISTRY_PASSWORD
✔ secret/data/ci/deploy => outputs.KUBE_TOKEN | env.KUBE_TOKEN
Run echo "$REGISTRY_PASSWORD" | docker login registry.example.com ...
Login Succeeded
Fortschritt speichern? Kostenlos registrieren
Drill 5: Die Action lokal gegen OpenBao testen
Die Action ist ein einzelnes Node-Skript. Sie liest ihre Inputs aus
INPUT_* und das OIDC-Token von
ACTIONS_ID_TOKEN_REQUEST_URL. Eine kleine Attrappe spielt
diesen GitHub-Endpunkt und signiert mit deinem Lab-Issuer (braucht
Node.js 24 oder neuer).
cat > fake-oidc.py <<'EOF'
#!/usr/bin/env python3
"""Lab-Attrappe für den GitHub-OIDC-Token-Endpunkt (ACTIONS_ID_TOKEN_REQUEST_URL).
Antwortet wie GitHub mit {"value": "<JWT>"}; signiert wird per mint-jwt.sh (Tag 10).
Zusätzliche Claims kommen aus der Umgebungsvariable CLAIMS (z. B. "environment=prod").
Nur fürs Lab!
"""
import json, os, subprocess, sys
from http.server import BaseHTTPRequestHandler, HTTPServer
from urllib.parse import parse_qs, urlparse
BEARER = os.environ.get("REQUEST_TOKEN", "lab-request-token")
MINT = os.environ.get("MINT", "./mint-jwt.sh")
class Handler(BaseHTTPRequestHandler):
def do_GET(self):
if self.headers.get("Authorization", "").lower() != f"bearer {BEARER}":
self.send_error(401, "bad request token")
return
query = parse_qs(urlparse(self.path).query)
aud = query.get("audience", ["https://github.com/acme"])[0]
args = [MINT, f"aud={aud}"] + os.environ.get("CLAIMS", "").split()
jwt = subprocess.run(args, check=True, capture_output=True, text=True).stdout
body = json.dumps({"value": jwt.strip()}).encode()
self.send_response(200)
self.send_header("Content-Type", "application/json")
self.end_headers()
self.wfile.write(body)
print(f"Token ausgestellt, aud={aud}", file=sys.stderr)
def log_message(self, *args):
pass
HTTPServer(("127.0.0.1", int(os.environ.get("PORT", "8299"))), Handler).serve_forever()
EOF
CLAIMS="sub=repo:acme/shop:environment:production environment=production" \
python3 fake-oidc.py 2>fake-oidc.log &
export ACTIONS_ID_TOKEN_REQUEST_URL="http://127.0.0.1:8299/token?api-version=2.0"
export ACTIONS_ID_TOKEN_REQUEST_TOKEN=lab-request-token
curl -sSfLo vault-action.js \
https://raw.githubusercontent.com/hashicorp/vault-action/v4.0.0/dist/index.jsJetzt die Action mit denselben Inputs wie im Workflow, nur gegen dein Lab:
: > gh-output; : > gh-env
env -u BAO_TOKEN GITHUB_OUTPUT=$PWD/gh-output GITHUB_ENV=$PWD/gh-env \
INPUT_URL=$BAO_ADDR INPUT_METHOD=jwt INPUT_PATH=jwt-ci INPUT_ROLE=shop-prod \
INPUT_JWTGITHUBAUDIENCE=openbao INPUT_EXPORTENV=true \
INPUT_SECRETS='secret/data/ci/deploy registry_password | REGISTRY_PASSWORD' \
node vault-action.js | cut -c1-80
echo "---"; grep -A1 '^REGISTRY_PASSWORD' gh-envErwartet:
::group::Get Vault Secrets
::debug::ID token url is http://127.0.0.1:8299/token?api-version=2.0&audience=o
::add-mask::eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsImtpZCI6ImxhYi1jaS0xIn0.eyJpc3Mi
::debug::Retrieving Vault Token from v1/auth/jwt-ci/login endpoint
::debug::✔ Vault Token successfully retrieved
::group::Token Info
::debug::Operating under policies: ["ci-deploy","default"]
::debug::Token Metadata: {"actor":"zachmann","repository":"acme/shop","role":"sh
::endgroup::
::add-mask::s.1KuV01SfzTf0JvDvra05AIYD
::add-mask::lab-reg-pw
::debug::✔ secret/data/ci/deploy => outputs.REGISTRY_PASSWORD | env.REGISTRY_PAS
::endgroup::
---
REGISTRY_PASSWORD<<ghadelimiter_179d4f2a-2955-46d8-b6a8-71ceec142682
lab-reg-pw
Du siehst die Workflow-Commands im Rohformat: Die Action maskiert
JWT, OpenBao-Token und jeden Secret-Wert per ::add-mask::,
bevor sie ihn verwendet. Der OpenBao-Token wird am Ende nicht
widerrufen, er läuft nach token_ttl ab. Deshalb die 5
Minuten.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Variante B – Token selbst holen mit
curl und bao
Ohne Action, volle Kontrolle. Das ist der run-Schritt im
Workflow; hier läuft er gegen deine Attrappe. Die Variablen setzt GitHub
sonst selbst.
cat > get-secrets.sh <<'EOF'
#!/usr/bin/env bash
# GitHub-Actions-Schritt: OIDC-JWT holen, bei OpenBao einlösen, Secret lesen
set -euo pipefail
JWT=$(curl -sSf -H "Authorization: bearer $ACTIONS_ID_TOKEN_REQUEST_TOKEN" \
"$ACTIONS_ID_TOKEN_REQUEST_URL&audience=openbao" | jq -r .value)
echo "::add-mask::$JWT"
BAO_TOKEN=$(bao write -field=token "auth/$BAO_AUTH_PATH/login" \
role=shop-prod jwt="$JWT")
echo "::add-mask::$BAO_TOKEN"
export BAO_TOKEN
PW=$(bao kv get -field=registry_password secret/ci/deploy)
echo "::add-mask::$PW"
echo "REGISTRY_PASSWORD=$PW" >> "$GITHUB_ENV"
bao token revoke -self >/dev/null
echo "✔ Secret übergeben, OpenBao-Token widerrufen"
EOF
chmod +x get-secrets.sh
: > gh-env
env -u BAO_TOKEN GITHUB_ENV=$PWD/gh-env BAO_AUTH_PATH=jwt-ci ./get-secrets.sh \
| cut -c1-60
cat gh-envErwartet:
::add-mask::eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsImtpZCI6ImxhYi1j
::add-mask::s.7MIGoeu4CNYFfCRKtYn50XKW
::add-mask::lab-reg-pw
✔ Secret übergeben, OpenBao-Token widerrufen
REGISTRY_PASSWORD=lab-reg-pw
Im Workflow stehen davor die Installation von bao mit
Prüfsumme und danach die Nutzung (nicht ausgeführt):
cat > .github/workflows/deploy-cli.yml <<'EOF'
name: deploy-cli
on:
push:
branches: [main]
permissions:
contents: read
id-token: write
jobs:
deploy:
runs-on: ubuntu-latest
environment: production
env:
BAO_ADDR: https://openbao.example.com
BAO_AUTH_PATH: jwt-github
BAO_VERSION: 2.7.1
steps:
- uses: actions/checkout@v7
- name: bao installieren
run: |
base=https://github.com/openbao/openbao/releases/download/v$BAO_VERSION
curl -sSfLO "$base/openbao_${BAO_VERSION}_linux_amd64.tar.gz"
curl -sSfLO "$base/checksums.txt"
sha256sum --ignore-missing -c checksums.txt
tar xzf "openbao_${BAO_VERSION}_linux_amd64.tar.gz" bao
sudo install bao /usr/local/bin/bao
- name: Secrets holen
run: ./ci/get-secrets.sh
- name: Registry-Login
run: |
echo "$REGISTRY_PASSWORD" | docker login registry.example.com \
-u ci --password-stdin
EOFSicherheit:
::add-mask::wirkt erst ab der Zeile, in der es steht, und nur auf exakt diesen String. Werte nie vorher ausgeben, keinset -x, und abgeleitete Formen (Base64, URL-kodiert) separat maskieren.
Fortschritt speichern? Kostenlos registrieren
Drill 7: Environments als Schutz
Das Environment production in GitHub bekommt „Required
reviewers” und „Deployment branches: main”. Erst nach Freigabe startet
der Job und erst dann gibt es ein Token mit
environment:production im sub. Prüfe, dass ein
Job ohne Environment auf main nicht an Produktions-Secrets
kommt:
BAO_TOKEN= bao write auth/jwt-ci/login role=shop-prod \
jwt="$(./mint-jwt.sh)" 2>&1 | tail -1
pkill -f fake-oidc.pyErwartet:
* error validating token: invalid subject (sub) claim
Der sub lautet dann
repo:acme/shop:ref:refs/heads/main. Damit ist die Freigabe
im GitHub-Environment die einzige Tür zur Rolle
shop-prod.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
cat > check.sh <<'EOF'
#!/usr/bin/env bash
cd ~/secrets-lab/tag11
export BAO_ADDR="${BAO_ADDR:-http://127.0.0.1:8200}"
login() { BAO_TOKEN= bao write -field=token auth/jwt-ci/login role=shop-prod \
jwt="$(./mint-jwt.sh "$@")" >/dev/null 2>&1; }
[ "$(BAO_TOKEN=root bao read -field=status auth/jwt-github/config)" = valid ] \
&& echo "✔ jwt-github per Discovery" || echo "✘ jwt-github-Config"
login sub=repo:acme/shop:environment:production && echo "✔ Environment-Login" \
|| echo "✘ Environment-Login"
login sub=repo:acme/shop:pull_request && echo "✘ PR kommt rein" \
|| echo "✔ PR abgewiesen"
login sub=repo:acme/shop:environment:production repository_id=999 \
&& echo "✘ fremde repository_id" || echo "✔ fremde repository_id abgewiesen"
grep -q 'id-token: write' .github/workflows/deploy.yml \
&& echo "✔ Workflow fordert id-token an" || echo "✘ permissions fehlt"
EOF
bash check.shErwartet:
✔ jwt-github per Discovery
✔ Environment-Login
✔ PR abgewiesen
✔ fremde repository_id abgewiesen
✔ Workflow fordert id-token an
Challenge
Pull Requests sollen Integrationstests gegen eine Test-Datenbank
fahren, aber nur aus dem eigenen Repo, nie aus Forks. Lege eine Rolle
shop-pr mit Policy ci-test (read auf
secret/data/ci/test) an und prüfe sie mit deinem
Lab-Issuer.
Hinweis: Binde event_name=pull_request.
pull_request_target läuft mit den Rechten des Ziel-Repos
und darf nie an Secrets kommen.
Lösung
export BAO_TOKEN=root
bao kv put secret/ci/test db_password=lab-test-db >/dev/null
bao policy write ci-test - <<'HCL'
path "secret/data/ci/test" {
capabilities = ["read"]
}
HCL
bao write auth/jwt-ci/role/shop-pr - <<'EOF'
{
"role_type": "jwt", "user_claim": "sub", "bound_audiences": ["openbao"],
"bound_subject": "repo:acme/shop:pull_request",
"bound_claims": {"repository_id": "100001", "event_name": "pull_request"},
"token_policies": ["ci-test"], "token_ttl": "10m"
}
EOF
PR="sub=repo:acme/shop:pull_request event_name=pull_request"
T=$(BAO_TOKEN= bao write -field=token auth/jwt-ci/login role=shop-pr \
jwt="$(./mint-jwt.sh $PR)")
BAO_TOKEN=$T bao kv get -field=db_password secret/ci/test; echo
BAO_TOKEN=$T bao kv get secret/ci/deploy 2>&1 | grep -m1 denied
BAO_TOKEN= bao write auth/jwt-ci/login role=shop-pr \
jwt="$(./mint-jwt.sh $PR event_name=pull_request_target)" 2>&1 | tail -1Erwartet:
lab-test-db
* permission denied
* error validating claims: claim "event_name" does not match any associated bound
claim values
Fork-PRs laufen im Kontext des Ziel-Repos, repository
hilft also nicht. Der Schutz kommt von GitHub: Fork-PRs bekommen kein
id-token: write, solange du das in den Repo-Einstellungen
nicht ausdrücklich erlaubst.
Fortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- GitHub-hosted Runner kommen aus dem Internet: OpenBao braucht dann
einen öffentlich erreichbaren Endpunkt (WAF, nur
/v1/auth/jwt-github/loginund die nötigen Pfade). Sonst Self-hosted Runner im internen Netz undrunner_environment=self-hostedbinden. - Actions per Commit-SHA pinnen
(
hashicorp/vault-action@<sha>), nicht per Tag. Die Action sieht alle Secrets des Jobs. - Einen Vertrag pro Repo:
repository_id, Environment,workflow_refbzw.job_workflow_ref. Nie nurrepository_ownerfür Schreib- oder Prod-Rechte. - Org-weit ein festes
sub-Format perinclude_claim_keyssetzen und die Rollen dazu per Code (OpenTofu, Tag 13) verwalten. - OpenBao-Token im letzten Schritt widerrufen
(
bao token revoke -self), auch bei Fehlern überif: always().