Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 11: GitHub Actions

Ziel: Ein GitHub-Workflow holt Secrets aus OpenBao per OIDC, ohne gespeicherten Token, einmal mit hashicorp/vault-action, einmal mit bao und curl. · Dauer: ca. 90 min · Voraussetzung: Tag 10

Briefing

  • Mit permissions: id-token: write darf ein Job bei GitHub ein OIDC-JWT anfordern. Issuer ist https://token.actions.githubusercontent.com.
  • Der sub-Claim hängt vom Kontext ab: Environment schlägt Branch, Tag und Pull Request.
  • hashicorp/vault-action spricht 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 -1

Erwartet:

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 echten sub deiner Organisation, bevor du bound_subject setzt. Mit include_claim_keys lä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
done

Erwartet:

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
EOF

Wichtig: 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.js

Jetzt 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-env

Erwartet:

::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-env

Erwartet:

::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
EOF

Sicherheit: ::add-mask:: wirkt erst ab der Zeile, in der es steht, und nur auf exakt diesen String. Werte nie vorher ausgeben, kein set -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.py

Erwartet:

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

Erwartet:

✔ 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 -1

Erwartet:

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/login und die nötigen Pfade). Sonst Self-hosted Runner im internen Netz und runner_environment=self-hosted binden.
  • 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_ref bzw. job_workflow_ref. Nie nur repository_owner für Schreib- oder Prod-Rechte.
  • Org-weit ein festes sub-Format per include_claim_keys setzen und die Rollen dazu per Code (OpenTofu, Tag 13) verwalten.
  • OpenBao-Token im letzten Schritt widerrufen (bao token revoke -self), auch bei Fehlern über if: always().