Zum Inhalt springen
Trainingslager IT-Trainingslager

Kapitel 6: Secrets-Management, Rotation und Ablösung von Zugangsdaten im Repository (Vault/OpenBao, External Secrets Operator)

In diesem Kapitel lernst du:

  • wie du eingecheckte Zugangsdaten in einem Repository samt Historie findest
  • wie Vault (bzw. OpenBao) Secrets speichert, verteilt, protokolliert und wieder einzieht
  • den Unterschied zwischen statischen und dynamischen Secrets mit Lease und TTL
  • wie der External Secrets Operator Secrets aus Vault in Kubernetes synchronisiert und Rotationen nachzieht
  • einen belastbaren Ablösungsplan für ein geleaktes Credential: erst rotieren, dann aufräumen

Worum geht es?

Stell dir ein Bürogebäude vor. In vielen Firmen hängt der Generalschlüssel an einem Haken neben der Tür, für alle sichtbar, seit Jahren derselbe. Wer einmal da war, kann ihn nachmachen lassen. Niemand weiß, wie viele Kopien es gibt.

Ein besseres Gebäude hat einen Pförtner mit Schlüsselschrank. Du zeigst deinen Ausweis, bekommst einen Schlüssel für genau die Räume, die du brauchst, und musst ihn nach einer festen Zeit zurückgeben. Der Pförtner schreibt jede Ausgabe in ein Buch. Verliert jemand einen Schlüssel, tauscht der Pförtner das Schloss aus.

Ein Passwort im Git-Repository ist der Schlüssel am Haken. Vault oder OpenBao ist der Pförtner mit Schlüsselschrank und Ausgabebuch. Der External Secrets Operator (ESO) ist der Bote, der Schlüssel aus dem Schrank holt und in Kubernetes dort ablegt, wo die Anwendung sie erwartet.

  Entwickler/CI                Vault / OpenBao                 Kubernetes (kind)
 +-------------+   Login     +-------------------+   Login    +--------------------+
 | GitLab-Job  |-- JWT ----->| Auth-Methoden     |<-- SA-JWT--| External Secrets   |
 | (id_tokens) |             |  jwt, kubernetes, |            | Operator (ESO)     |
 +-------------+             |  approle          |            +---------+----------+
                             | Policies          |                      |
  Git-Repo                   | Secrets Engines   |   liest kv/...       v
 +-------------+  gitleaks   |  kv v2, database  |----------->  K8s-Secret
 | config.py   |--> Fund!    | Audit-Log         |              (refreshInterval)
 +-------------+             +---------+---------+                      |
                                       | erzeugt/widerruft              v
                                       v                          Pod der demo-app
                               +---------------+
                               | PostgreSQL    |  dynamische User mit TTL
                               +---------------+

Die Konzepte in einfach

Was ist ein Secret?

Ein Secret ist jede Information, mit der man sich als jemand ausgeben oder etwas entschlüsseln kann: Passwörter, API-Tokens, private Schlüssel, Zertifikate, Verbindungs-Strings mit Passwort, Cloud-Zugangsschlüssel. Faustregel: Wenn ein Angreifer es in einem öffentlichen Gist findet und du danach schlecht schläfst, ist es ein Secret.

Der Lebenszyklus eines Secrets

Secrets sind keine Konfiguration, die man einmal setzt. Sie haben einen Lebenszyklus (Secret Lifecycle):

Phase Frage Beispiel im Lab
Erzeugen Wer erzeugt es, wie stark? Vault erzeugt DB-User
Speichern Wo liegt es verschlüsselt? KV v2 in Vault
Verteilen Wie kommt es zur Anwendung? ESO, Vault-Agent, CI-Job
Nutzen Wer darf es lesen? Policy demo-app-read
Rotieren Wie oft wird es erneuert? neuer KV-Wert, neue Lease
Widerrufen Wie ziehe ich es sofort ein? vault lease revoke
Prüfen Wer hat es wann gelesen? Audit-Log

Ein Passwort im Repository überspringt fast alle Phasen: Es wird von Hand erzeugt, in Klartext gespeichert, per git clone an alle verteilt, nie rotiert und lässt sich nicht widerrufen, weil niemand weiß, wo überall Kopien liegen.

Statische und dynamische Secrets

Ein statisches Secret existiert unabhängig vom Tresor. Du legst etwa das Datenbank-Passwort in Vault ab. Vault bewahrt es nur auf. Rotieren musst du selbst (oder ein Skript).

Ein dynamisches Secret entsteht erst bei Abfrage. Fragt die Anwendung nach Datenbank-Zugangsdaten, legt Vault in diesem Moment einen neuen Datenbank-User an, gibt ihn heraus und löscht ihn nach Ablauf wieder. Jeder Abnehmer bekommt eigene Zugangsdaten. Ein Leck betrifft nur eine kurze Zeitspanne und lässt sich einem Abnehmer zuordnen.

Lease und TTL

Zu jedem dynamischen Secret gehört eine Lease (Mietvertrag). Sie hat eine ID und eine TTL (Time to Live, Lebensdauer). Läuft die TTL ab, widerruft Vault das Secret automatisch. Die Anwendung kann die Lease bis zur max_ttl verlängern (renew). Ein Mensch kann sie jederzeit vorzeitig widerrufen (revoke), auch alle Leases einer Rolle auf einmal (-prefix).

Auch Vault-Tokens haben eine TTL. Ein Token, das nach 15 Minuten verfällt, ist ein deutlich kleineres Problem als eines, das ewig gilt.

Auth-Methoden: Wie weist sich ein Abnehmer aus?

Vault gibt nichts heraus, ohne dass sich der Abnehmer anmeldet. Das Henne-Ei-Problem lautet: Womit meldet man sich an, ohne wieder ein Passwort zu speichern? Antwort: mit einer Identität, die die Plattform ohnehin ausstellt.

Methode Wer nutzt sie? Identitätsnachweis
kubernetes Pods, ESO ServiceAccount-Token (JWT)
jwt / oidc GitLab-CI-Jobs, Menschen signiertes JWT vom IdP
approle Maschinen ohne Plattform-ID Role-ID + Secret-ID
token Admin, Notfall Vault-Token

Kubernetes-Auth: Der Pod schickt sein ServiceAccount-Token an Vault. Vault fragt die Kubernetes-API per TokenReview: „Ist das echt, und zu welchem ServiceAccount gehört es?” Passt die Antwort zu einer Vault-Rolle (Namespace und ServiceAccount-Name), bekommt der Pod ein Vault-Token mit den Policies dieser Rolle.

JWT/OIDC für GitLab CI: GitLab stellt jedem Job auf Wunsch ein signiertes JWT aus. Du forderst es in der .gitlab-ci.yml über id_tokens an. Das Token enthält Claims (Aussagen) wie project_path, ref, ref_protected und environment. Vault prüft die Signatur über den JWKS-Endpunkt von GitLab und vergleicht die Claims mit bound_claims der Rolle. So bekommt nur der Job auf dem geschützten main-Branch des richtigen Projekts das Produktions-Secret. Kein gespeichertes Vault-Token in CI-Variablen nötig.

vault auth enable jwt
vault write auth/jwt/config \
  oidc_discovery_url="https://gitlab.example.internal" \
  bound_issuer="https://gitlab.example.internal"
vault write auth/jwt/role/demo-app-ci - <<'EOF'
{
  "role_type": "jwt",
  "user_claim": "user_login",
  "bound_audiences": ["https://vault.example.internal"],
  "bound_claims": {
    "project_path": "root/demo-app",
    "ref": "main",
    "ref_protected": "true"
  },
  "token_policies": ["demo-app-read"],
  "token_explicit_max_ttl": 300
}
EOF

Der passende Job in GitLab:

read-secret:
  image: hashicorp/vault:1.18
  id_tokens:
    VAULT_ID_TOKEN:
      aud: https://vault.example.internal
  variables:
    VAULT_ADDR: https://vault.example.internal
  script:
    - LOGIN="auth/jwt/login role=demo-app-ci jwt=$VAULT_ID_TOKEN"
    - export VAULT_TOKEN="$(vault write -field=token $LOGIN)"
    - vault kv get -field=username kv/demo-app/db

Tipp: GitLab Premium bietet mit dem Schlüsselwort secrets: eine eingebaute Vault-Anbindung, die genau diesen Login für dich erledigt. Der Mechanismus darunter ist derselbe.

AppRole ist für Maschinen ohne eigene Plattform-Identität gedacht, etwa eine VM oder einen alten Jenkins. Die Role-ID ist wie ein Benutzername, die Secret-ID wie ein kurzlebiges Passwort. Das Problem verschiebt sich dabei nur: Die Secret-ID muss sicher zur Maschine kommen (Stichwort „Secret Zero”). Nutze AppRole deshalb nur, wenn Kubernetes- oder JWT-Auth nicht gehen.

vault auth enable approle
vault write auth/approle/role/legacy-job \
  token_policies=demo-app-read secret_id_ttl=10m secret_id_num_uses=1
vault read -field=role_id auth/approle/role/legacy-job/role-id
vault write -f -field=secret_id auth/approle/role/legacy-job/secret-id

Policies

Eine Policy ist eine Liste von Pfaden mit erlaubten Fähigkeiten (read, create, update, delete, list, deny). Alles, was nicht erlaubt ist, ist verboten (Default Deny). Policies schreibt man in HCL.

Merke: Bei KV Version 2 liegen die Daten unter <mount>/data/... und die Metadaten unter <mount>/metadata/.... Die CLI blendet das aus (vault kv get kv/demo-app/db), die Policy aber nicht. Eine Policy auf kv/demo-app/* greift deshalb ins Leere. Richtig ist kv/data/demo-app/*.

Audit-Log

Vault kann jede Anfrage und jede Antwort in ein Audit-Device schreiben (Datei, Syslog, Socket). Secret-Werte erscheinen dort nicht im Klartext, sondern als HMAC-Hash. So kannst du später nachweisen, wer wann welchen Pfad gelesen hat, ohne dass das Log selbst zum Secret-Lager wird.

Achtung: Ist ein Audit-Device aktiviert, aber nicht beschreibbar (Platte voll), verweigert Vault die Anfragen. Das ist Absicht: lieber kein Zugriff als ein unprotokollierter. Für die Produktion heißt das: mindestens zwei Audit-Devices und Platz überwachen.

Vault oder OpenBao?

HashiCorp hat Vault im August 2023 ab Version 1.15 von der Open-Source-Lizenz MPL 2.0 auf die Business Source License (BSL 1.1) umgestellt. Die BSL erlaubt die eigene Nutzung, verbietet aber, ein konkurrierendes Produkt darauf aufzubauen. Für viele Behörden und Firmen mit strengen Lizenzregeln ist das ein Prüfpunkt. 2025 hat IBM HashiCorp übernommen.

Als Reaktion entstand OpenBao, ein Fork des letzten MPL-Stands unter dem Dach der Linux Foundation. OpenBao ist API-kompatibel, die CLI heißt bao, das Container-Image openbao/openbao. Die meisten Befehle in diesem Kapitel funktionieren, wenn du vault durch bao ersetzt. Umgebungsvariablen heißen dort BAO_ADDR und BAO_TOKEN. Funktionen der Vault-Enterprise-Edition (etwa Performance-Replikation oder Namespaces in der alten Form) fehlen oder sind anders umgesetzt. ESO spricht OpenBao über denselben vault-Provider an.

Merkmal Vault OpenBao
Lizenz BSL 1.1 (ab 1.15) MPL 2.0
Träger HashiCorp / IBM Linux Foundation
CLI / Image vault, hashicorp/vault bao, openbao/openbao
Support kommerziell verfügbar Community, Dienstleister

External Secrets Operator (ESO)

ESO ist ein Kubernetes-Operator. Er liest Secrets aus einem externen Tresor und legt sie als normale Kubernetes-Secrets an. Die Anwendung merkt nichts von Vault. Drei Objekte sind wichtig:

Objekt Bereich Aufgabe
SecretStore ein Namespace Wie komme ich an den Tresor? (URL, Auth)
ClusterSecretStore ganzer Cluster dasselbe, für alle Namespaces nutzbar
ExternalSecret ein Namespace Welche Werte, in welches K8s-Secret?

Das Feld refreshInterval im ExternalSecret legt fest, wie oft ESO im Tresor nachsieht. Ändert sich dort ein Wert, aktualisiert ESO das Kubernetes-Secret. So wird eine Rotation in Vault automatisch im Cluster sichtbar.

Merke: Ein ClusterSecretStore ist bequem, aber mächtig: Jeder Namespace kann ihn referenzieren. In Mandanten-Clustern ist ein SecretStore pro Namespace mit eigener Vault-Rolle die sicherere Wahl.

Hands-on-Lab: Vom Leck im Repo zum rotierenden Secret im Cluster

Du arbeitest in ~/seclab/kap06. Voraussetzung: der kind-Cluster seclab aus Kapitel 0 läuft, die Werkzeuge gitleaks, vault, helm, kubectl, jq sind installiert.

Schritt 1: Vorbereitung

mkdir -p ~/seclab/kap06 && cd ~/seclab/kap06
kubectl config use-context kind-seclab
docker network ls --filter name=^kind$
gitleaks version
vault version

Erwartung: Das Netz kind wird gelistet, gitleaks meldet eine Version 8.x, vault eine Version 1.x. Notiere die gitleaks-Version. Ab 8.19 gibt es die Unterbefehle git und dir, ältere Versionen kennen nur detect und protect.

Schritt 2: Ein Demo-Repo mit Leck anlegen

Du simulierst einen typischen Fehler: Jemand checkt Zugangsdaten ein und „repariert” das später mit einem zweiten Commit.

mkdir leak-demo && cd leak-demo
git init -b main
cat > config.py <<'EOF'
# Lab-Werte, absichtlich falsch und ungueltig!
DB_HOST = "postgres"
DB_PASSWORD = "Lab-9xQ2mZ7vK4pR8tW1"
GITLAB_TOKEN = "glpat-LabFake0000Abcd1234X"
EOF
git add config.py && git commit -m "feat: DB-Konfiguration"
cat > config.py <<'EOF'
import os
DB_HOST = os.environ.get("DB_HOST", "postgres")
DB_PASSWORD = os.environ["DB_PASSWORD"]
EOF
git commit -am "fix: Secrets aus Code entfernt"
git log --oneline

Erwartung: zwei Commits. Die aktuelle config.py enthält kein Secret mehr.

Sicherheit: Alle Werte hier sind erfundene Lab-Werte. Verwende in Übungen nie echte Tokens, auch nicht „nur kurz”.

Schritt 3: gitleaks auf Arbeitskopie und Historie

Zuerst nur die Dateien, wie sie jetzt auf der Platte liegen:

# gitleaks >= 8.19:
gitleaks dir . -v
# aeltere Versionen:
gitleaks detect --source . --no-git -v

Erwartung: no leaks found. Die Arbeitskopie ist sauber. Nun die gesamte Git-Historie:

# gitleaks >= 8.19:
gitleaks git . -v
# aeltere Versionen (in neuen Versionen noch vorhanden, aber veraltet):
gitleaks detect --source . -v
echo "Exit-Code: $?"

Erwartete Ausgabe (gekürzt):

Finding:     GITLAB_TOKEN = "glpat-LabFake0000Abcd1234X"
Secret:      glpat-LabFake0000Abcd1234X
RuleID:      gitlab-pat
File:        config.py
Line:        4
Commit:      3f1c2a9...
Fingerprint: 3f1c2a9...:config.py:gitlab-pat:4

WRN leaks found: 1
Exit-Code: 1

Je nach gitleaks-Version meldet die Regel generic-api-key zusätzlich das DB_PASSWORD. Entscheidend ist: Der Fund steckt im ersten Commit. Der Fix-Commit hat das Secret nur aus der aktuellen Version entfernt, nicht aus der Historie. Jeder, der das Repo klont, hat es.

Für Berichte und Automatisierung nutzt du JSON und --redact, damit der Wert nicht im CI-Log landet:

gitleaks git . --redact --report-format json --report-path gitleaks.json
jq -r '.[] | "\(.RuleID)  \(.File):\(.StartLine)  \(.Commit[0:7])"' gitleaks.json

Der Exit-Code 1 bei Funden ist wichtig: Damit bricht ein CI-Job ab.

Schritt 4: Vault-Dev-Server starten

cd ~/seclab/kap06
docker run -d --name vault --network kind -p 8200:8200 \
  --cap-add=IPC_LOCK \
  -e VAULT_DEV_ROOT_TOKEN_ID=root \
  -e VAULT_DEV_LISTEN_ADDRESS=0.0.0.0:8200 \
  hashicorp/vault:1.18
export VAULT_ADDR=http://127.0.0.1:8200
export VAULT_TOKEN=root
vault status

Erwartung: Sealed false, Storage Type inmem. Der Container hängt im Netz kind. Dadurch erreichen ihn später der Postgres-Container und der kind-Cluster unter dem Namen vault.

Achtung: Der Dev-Modus hält alles im Arbeitsspeicher, ist automatisch entsiegelt, spricht unverschlüsseltes HTTP und hat das Root-Token root. Ein Neustart löscht alle Daten. Das ist nur für das Lab gedacht.

OpenBao-Äquivalent:

docker run -d --name vault --network kind -p 8200:8200 openbao/openbao \
  server -dev -dev-root-token-id=root -dev-listen-address=0.0.0.0:8200
export BAO_ADDR=http://127.0.0.1:8200 BAO_TOKEN=root
bao status

Schritt 5: KV v2 anlegen, Secret schreiben und lesen

Der Dev-Server bringt unter secret/ schon eine KV-Engine mit. Du legst eine eigene an, so wie du es in der Produktion auch tun würdest:

vault secrets enable -path=kv -version=2 kv
vault kv put kv/demo-app/db username=demo password='Lab-Start-1'
vault kv get kv/demo-app/db

Erwartete Ausgabe (gekürzt):

==== Secret Path ====
kv/data/demo-app/db

======= Metadata =======
Key                Value
---                -----
created_time       2026-10-08T09:12:44.1Z
version            1

====== Data ======
Key         Value
---         -----
password    Lab-Start-1
username    demo

Achte auf kv/data/demo-app/db im Secret Path: Das ist der echte API-Pfad. KV v2 speichert Versionen:

vault kv put kv/demo-app/db username=demo password='Lab-Start-2'
vault kv get -version=1 -field=password kv/demo-app/db
vault kv metadata get kv/demo-app/db | grep -E 'current_version|max_versions'

Erwartung: Version 1 liefert Lab-Start-1, current_version ist 2. Versionen sind nützlich, um eine misslungene Rotation zurückzurollen (vault kv rollback -version=1 kv/demo-app/db).

Schritt 6: Policy, eingeschränktes Token und Audit-Log

Aktiviere zuerst das Audit-Log, damit die folgenden Zugriffe protokolliert werden:

vault audit enable file file_path=/vault/logs/audit.log

Erwartung: Success! Enabled the file audit device at: file/.

Nun eine Policy, die nur lesen darf:

cat > demo-app-read.hcl <<'EOF'
path "kv/data/demo-app/*" {
  capabilities = ["read"]
}
EOF
vault policy write demo-app-read demo-app-read.hcl
APP_TOKEN=$(vault token create -policy=demo-app-read -ttl=15m -field=token)
VAULT_TOKEN=$APP_TOKEN vault kv get -field=username kv/demo-app/db
VAULT_TOKEN=$APP_TOKEN vault kv put kv/demo-app/db password=hack

Erwartung: Das Lesen liefert demo. Das Schreiben scheitert mit Code: 403 und permission denied. Sieh dir den letzten Eintrag im Audit-Log an:

docker exec vault tail -n 1 /vault/logs/audit.log | jq '{
  type, path: .request.path, op: .request.operation,
  policies: .auth.policies, error }'

Erwartung: type ist response, path ist kv/data/demo-app/db, policies enthält demo-app-read und error den Text permission denied. Das Token selbst steht dort nur als HMAC-Hash.

Schritt 7: Postgres und die Database Secrets Engine

Starte eine Postgres-Datenbank im selben Docker-Netz:

docker run -d --name postgres --network kind -p 5432:5432 \
  -e POSTGRES_PASSWORD=lab-postgres-pw -e POSTGRES_DB=demo postgres:16
sleep 5
docker exec postgres pg_isready -U postgres

Erwartung: accepting connections. Jetzt bekommt Vault die Admin-Zugangsdaten und eine Rolle, die beschreibt, wie ein Kurzzeit-User angelegt wird:

vault secrets enable database
vault write database/config/demo-postgres \
  plugin_name=postgresql-database-plugin \
  connection_url="postgresql://{{username}}:{{password}}@\
postgres:5432/demo?sslmode=disable" \
  allowed_roles="demo-app-ro" \
  username="postgres" password="lab-postgres-pw"

vault write database/roles/demo-app-ro \
  db_name=demo-postgres \
  default_ttl=5m max_ttl=1h \
  creation_statements="CREATE ROLE \"{{name}}\" WITH LOGIN PASSWORD '{{password}}' \
VALID UNTIL '{{expiration}}'; \
GRANT SELECT ON ALL TABLES IN SCHEMA public TO \"{{name}}\";"

Erwartung: jeweils Success! Data written to: .... Vault erreicht die Datenbank unter postgres:5432, weil beide Container im Netz kind hängen und Docker dort Container-Namen auflöst.

Tipp: Das Passwort lab-postgres-pw kennt jetzt noch jeder, der dieses Buch liest. Mit vault write -f database/rotate-root/demo-postgres setzt Vault ein neues Admin-Passwort, das nur Vault kennt. In der Produktion gehört das zur Einrichtung dazu. Im Lab lässt du es weg, damit du dich noch selbst anmelden kannst.

Schritt 8: Dynamische Credentials nutzen und widerrufen

vault read -format=json database/creds/demo-app-ro > creds.json
jq '{lease_id, lease_duration, user: .data.username}' creds.json
LEASE=$(jq -r .lease_id creds.json)
DBUSER=$(jq -r .data.username creds.json)
DBPASS=$(jq -r .data.password creds.json)

Erwartete Ausgabe:

{
  "lease_id": "database/creds/demo-app-ro/Xy7kP...",
  "lease_duration": 300,
  "user": "v-root-demo-app-ro-AbC1d2EfG3h4IjK5lM6n-1791451234"
}

300 Sekunden sind die 5 Minuten aus default_ttl. Teste den Login von einem zweiten Container aus, damit wirklich eine Passwort-Prüfung über das Netz stattfindet:

docker run --rm --network kind -e PGPASSWORD="$DBPASS" postgres:16 \
  psql -h postgres -U "$DBUSER" -d demo -c 'select current_user;'
docker exec postgres psql -U postgres -c '\du' | grep v-root

Erwartung: current_user zeigt den v-root-...-Namen, und \du listet diese Rolle. Nun widerrufst du die Lease, als wäre das Credential geleakt:

vault lease lookup "$LEASE" | grep ttl
vault lease revoke "$LEASE"
docker run --rm --network kind -e PGPASSWORD="$DBPASS" postgres:16 \
  psql -h postgres -U "$DBUSER" -d demo -c 'select 1;'

Erwartung: Nach dem Revoke schlägt der Login fehl (password authentication failed oder role ... does not exist). Vault hat den User in Postgres gelöscht. Hättest du nichts getan, wäre dasselbe nach 5 Minuten automatisch passiert. Alle Leases einer Rolle widerrufst du mit vault lease revoke -prefix database/creds/demo-app-ro.

Schritt 9: External Secrets Operator per Helm installieren

helm repo add external-secrets https://charts.external-secrets.io
helm repo update
helm install external-secrets external-secrets/external-secrets \
  -n external-secrets --create-namespace --wait
kubectl get pods -n external-secrets
kubectl api-resources --api-group=external-secrets.io | grep -i secretstore

Erwartung: drei Pods Running (Controller, Webhook, Cert-Controller). Die letzte Zeile zeigt die API-Version, etwa external-secrets.io/v1. Ältere ESO-Versionen (vor 0.16) kennen nur v1beta1. Passe dann apiVersion in den YAML-Dateien unten an.

Schritt 10: Kubernetes-Auth in Vault konfigurieren

Hier steckt die Netzwerk-Besonderheit dieses Labs. Vault läuft nicht im Cluster, sondern als Container daneben. Beide Richtungen müssen funktionieren:

 Docker-Netz "kind"
 +-------------------------------------------------------------------+
 |  Container "vault"  --- TokenReview ---> seclab-control-plane:6443 |
 |        ^                                  (K8s-API im kind-Node)   |
 |        |  http://vault:8200                                        |
 |  ESO-Pod im kind-Node (Pod-DNS -> Node -> Docker-DNS)              |
 +-------------------------------------------------------------------+
  1. ESO im Cluster muss Vault erreichen: über den Namen vault, den Docker im Netz kind auflöst.
  2. Vault muss die Kubernetes-API erreichen, um ServiceAccount-Tokens zu prüfen: über den Namen des Control-Plane-Containers seclab-control-plane auf Port 6443. Der Eintrag 127.0.0.1:... aus deiner Kubeconfig funktioniert aus dem Vault-Container heraus nicht.

Prüfe zuerst die Richtung Cluster → Vault:

kubectl create namespace demo --dry-run=client -o yaml | kubectl apply -f -
kubectl run nettest -n demo --rm -i --restart=Never \
  --image=curlimages/curl -- curl -s http://vault:8200/v1/sys/health

Erwartung: JSON mit "initialized":true,"sealed":false. Die interne API-Adresse zeigt dir kind selbst:

kind get kubeconfig --name seclab --internal | grep server

Erwartung: server: https://seclab-control-plane:6443. Nun legst du den ServiceAccount an, mit dem sich ESO bei Vault anmeldet. Er darf zusätzlich TokenReviews durchführen (system:auth-delegator), damit Vault sein Token zur Prüfung verwenden kann:

kubectl create serviceaccount eso-vault -n demo
kubectl create clusterrolebinding eso-vault-tokenreview \
  --clusterrole=system:auth-delegator --serviceaccount=demo:eso-vault

kubectl config view --raw --minify --flatten \
  -o jsonpath='{.clusters[0].cluster.certificate-authority-data}' \
  | base64 --decode > k8s-ca.crt

vault auth enable kubernetes
vault write auth/kubernetes/config \
  kubernetes_host="https://seclab-control-plane:6443" \
  [email protected]
vault write auth/kubernetes/role/demo-app \
  bound_service_account_names=eso-vault \
  bound_service_account_namespaces=demo \
  token_policies=demo-app-read token_ttl=15m

Weil du kein token_reviewer_jwt gesetzt hast und Vault außerhalb des Clusters läuft, nimmt Vault das Token des sich anmeldenden ServiceAccounts selbst für den TokenReview. Dafür ist die ClusterRoleBinding nötig. Teste den Login von Hand, bevor ESO ins Spiel kommt:

SA_JWT=$(kubectl create token eso-vault -n demo)
vault write auth/kubernetes/login role=demo-app jwt="$SA_JWT" | grep policies

Erwartung: token_policies ["default" "demo-app-read"]. Klappt das nicht, liegt der Fehler in Vault oder Netz, nicht in ESO. Das spart viel Suchzeit.

Schritt 11: SecretStore und ExternalSecret

cat > secretstore.yaml <<'EOF'
apiVersion: external-secrets.io/v1
kind: SecretStore
metadata:
  name: vault-backend
  namespace: demo
spec:
  provider:
    vault:
      server: "http://vault:8200"
      path: "kv"
      version: "v2"
      auth:
        kubernetes:
          mountPath: "kubernetes"
          role: "demo-app"
          serviceAccountRef:
            name: "eso-vault"
EOF
cat > externalsecret.yaml <<'EOF'
apiVersion: external-secrets.io/v1
kind: ExternalSecret
metadata:
  name: demo-app-db
  namespace: demo
spec:
  refreshInterval: 15s
  secretStoreRef:
    name: vault-backend
    kind: SecretStore
  target:
    name: demo-app-db
    creationPolicy: Owner
  data:
    - secretKey: DB_USER
      remoteRef:
        key: demo-app/db
        property: username
    - secretKey: DB_PASSWORD
      remoteRef:
        key: demo-app/db
        property: password
EOF
kubectl apply -f secretstore.yaml -f externalsecret.yaml
kubectl get secretstore,externalsecret -n demo

Erwartete Ausgabe:

NAME                                          AGE  STATUS  CAPABILITIES  READY
secretstore.external-secrets.io/vault-backend 10s  Valid   ReadWrite     True

NAME                                           STORE          STATUS        READY
externalsecret.external-secrets.io/demo-app-db vault-backend  SecretSynced  True

(Die Spalten sind hier gekürzt, je nach ESO-Version siehst du zusätzlich REFRESH.)

Beachte: Im SecretStore steht path: "kv" und im ExternalSecret key: demo-app/db, ohne data/. Das ergänzt ESO selbst, weil version: "v2" gesetzt ist. Prüfe den Inhalt:

kubectl get secret demo-app-db -n demo \
  -o jsonpath='{.data.DB_PASSWORD}' | base64 --decode; echo

Erwartung: Lab-Start-2.

Merke: refreshInterval: 15s ist nur für die Vorführung so kurz. Jede Synchronisation ist ein Vault-Login plus Lesezugriff. In der Produktion sind 5 bis 60 Minuten üblich.

Schritt 12: Rotation demonstrieren

Ändere den Wert in Vault, so wie es ein Rotationsprozess tun würde:

vault kv put kv/demo-app/db username=demo password='Lab-Rotiert-3'
sleep 20
kubectl get secret demo-app-db -n demo \
  -o jsonpath='{.data.DB_PASSWORD}' | base64 --decode; echo
kubectl get externalsecret demo-app-db -n demo \
  -o jsonpath='{.status.refreshTime}'; echo

Erwartung: Lab-Rotiert-3 und ein frischer Zeitstempel. Willst du nicht warten, erzwingst du eine Synchronisation:

kubectl annotate externalsecret demo-app-db -n demo \
  force-sync="$(date +%s)" --overwrite

Achtung: Das Kubernetes-Secret ist jetzt aktuell, der laufende Pod aber nicht unbedingt. Umgebungsvariablen werden nur beim Pod-Start gelesen. Als Datei gemountete Secrets aktualisiert das Kubelet nach einiger Zeit (nicht bei subPath). Die Anwendung muss die Datei dann neu lesen. Üblich sind ein Rollout-Neustart (kubectl rollout restart) oder ein Werkzeug wie Stakater Reloader, das bei Secret-Änderungen automatisch neu startet.

Sieh im Audit-Log nach, dass ESO mit seiner eigenen Identität gelesen hat:

docker exec vault cat /vault/logs/audit.log \
  | jq -r 'select(.type=="response" and .auth.metadata.role=="demo-app")
           | .request.path' | sort | uniq -c

Erwartung: Zeilen für auth/kubernetes/login und kv/data/demo-app/db. Die Zahlen wachsen mit jedem Refresh. Die Rolle steht in den Metadaten im Klartext, die Secret-Werte nicht.

Schritt 13: Ablösungsplan für das geleakte Credential

Zurück zum Leck aus Schritt 2. Die Reihenfolge ist entscheidend:

 1. Eindämmen   -> Credential widerrufen/rotieren   (Minuten)
 2. Bewerten    -> Wurde es benutzt? Logs prüfen     (Stunden)
 3. Umstellen   -> Code liest aus Secret-Quelle      (Tage)
 4. Bereinigen  -> Historie umschreiben (optional)   (geplant)
 5. Verhindern  -> Pre-commit + CI-Scan              (dauerhaft)

1. Eindämmen. Das GitLab-Token widerrufst du in GitLab unter User Settings → Access Tokens → Revoke. Das DB-Passwort ersetzt du durch einen neuen Wert in Vault. Das hast du in Schritt 12 bereits geübt. Noch besser: dynamische Credentials wie in Schritt 8, dann gibt es kein langlebiges Passwort mehr.

2. Bewerten. Prüfe in den Logs des betroffenen Systems (GitLab-Audit-Events, DB-Logins), ob das Credential zwischen Commit und Widerruf benutzt wurde. Das bestimmt, ob es ein Sicherheitsvorfall mit Meldepflicht wird.

3. Umstellen. Der Code liest jetzt os.environ["DB_PASSWORD"]. Das Kubernetes-Secret demo-app-db aus ESO liefert genau diese Variable. Im Deployment der demo-app sieht das so aus:

          envFrom:
            - secretRef:
                name: demo-app-db

4. Bereinigen. Erst jetzt, wenn das alte Credential wertlos ist, schreibst du die Historie um.

Achtung: Historie bereinigen ist kein Ersatz für Rotation. Das Secret steckt bereits in Klonen auf Laptops, in CI-Caches, in Forks, in Merge-Request-Diffs und eventuell in Backups. Du kannst das nicht zurückholen. Ein rotiertes Secret ist ungefährlich, auch wenn es noch irgendwo steht. Ein bereinigtes, aber nicht rotiertes Secret ist weiter gültig.

Schritt 14: Historie mit git filter-repo bereinigen

git filter-repo ist ein eigenständiges Werkzeug (Installation z. B. per pip install git-filter-repo oder Paketmanager). Es arbeitet aus Sicherheitsgründen nur auf einem frischen Klon:

cd ~/seclab/kap06
git clone --no-local leak-demo leak-demo-clean
cd leak-demo-clean
cat > ../replacements.txt <<'EOF'
glpat-LabFake0000Abcd1234X==>***ENTFERNT***
Lab-9xQ2mZ7vK4pR8tW1==>***ENTFERNT***
EOF
git log --oneline
git filter-repo --replace-text ../replacements.txt
git log --oneline
gitleaks git . -v

Erwartung: Die Commit-IDs vor und nach filter-repo unterscheiden sich, denn jeder betroffene Commit wurde neu geschrieben. gitleaks meldet no leaks found. Mit git show HEAD~1:config.py siehst du ***ENTFERNT*** an Stelle der Werte.

In einem echten Projekt folgen weitere Schritte:

  • filter-repo entfernt den Remote origin. Du fügst ihn wieder hinzu und pushst mit git push --force --all und git push --force --tags. Dafür muss der Branch-Schutz kurz gelockert werden.
  • Alle Beteiligten müssen neu klonen. Ein git pull auf einem alten Klon bringt die alte Historie zurück.
  • GitLab hält alte Objekte noch in Merge-Request-Refs und Caches. Housekeeping im Projekt (Settings → General → Advanced → Housekeeping) und gegebenenfalls das Entfernen betroffener MRs gehören dazu.

Schritt 15: Pre-commit-Hook mit gitleaks

Damit es nicht wieder passiert, prüft ein Hook jeden Commit vor dem Speichern:

cd ~/seclab/kap06/leak-demo-clean
cat > .git/hooks/pre-commit <<'EOF'
#!/bin/sh
# gitleaks >= 8.19; aeltere Versionen: gitleaks protect --staged --redact -v
exec gitleaks git --pre-commit --staged --redact -v
EOF
chmod +x .git/hooks/pre-commit
echo 'TOKEN = "glpat-LabFake9999Wxyz5678Q"' > neu.py
git add neu.py
git commit -m "test: sollte blockiert werden"
echo "Exit-Code: $?"

Erwartung: leaks found: 1, Exit-Code 1, kein neuer Commit (git log --oneline zeigt ihn nicht). Räume die Testdatei weg: git reset neu.py && rm neu.py.

Im Team verteilst du den Hook über das Framework pre-commit mit einer .pre-commit-config.yaml im Repo:

repos:
  - repo: https://github.com/gitleaks/gitleaks
    rev: v8.21.2
    hooks:
      - id: gitleaks

Lokale Hooks lassen sich mit git commit --no-verify umgehen. Deshalb gehört derselbe Scan zusätzlich in die Pipeline. Dort kann ihn niemand überspringen:

secret-scan:
  stage: test
  image:
    name: zricethezav/gitleaks:v8.21.2
    entrypoint: [""]
  variables:
    GIT_DEPTH: "0"
  script:
    - gitleaks git . --redact -v --report-format json --report-path gitleaks.json
  artifacts:
    when: always
    paths: [gitleaks.json]

GIT_DEPTH: "0" holt die volle Historie. Mit dem Standard-Shallow-Clone sähe gitleaks nur die letzten Commits. In einer abgeschotteten Umgebung beziehst du das Image aus deiner Spiegel-Registry (siehe Kapitel 3).

Schritt 16: Aufräumen

kubectl delete -f ~/seclab/kap06/externalsecret.yaml -f ~/seclab/kap06/secretstore.yaml
kubectl delete clusterrolebinding eso-vault-tokenreview
kubectl delete serviceaccount eso-vault -n demo
helm uninstall external-secrets -n external-secrets
kubectl delete namespace external-secrets
docker rm -f vault postgres

Erwartung: Alle Befehle laufen ohne Fehler. docker ps zeigt weder vault noch postgres. Den Namespace demo lässt du stehen, er wird in späteren Kapiteln gebraucht.

Fortschritt speichern? Kostenlos registrieren

Typische Stolperfallen

Symptom Ursache Lösung
permission denied trotz Policy Policy auf kv/demo-app/* statt kv/data/... bei KV v2 data/ im Policy-Pfad
gitleaks findet nichts in CI Shallow Clone GIT_DEPTH: "0" setzen
SecretStore InvalidProviderConfig Vault-Name nicht auflösbar Netz kind prüfen; notfalls IP per docker inspect
Login: permission denied bei K8s-Auth SA oder Namespace passt nicht zur Rolle bound_service_account_* prüfen
Login: x509 oder connection refused kubernetes_host zeigt auf 127.0.0.1 https://seclab-control-plane:6443
TokenReview 403 SA fehlt system:auth-delegator ClusterRoleBinding anlegen
Secret aktualisiert, App nutzt alten Wert Env-Variablen nur beim Start Rollout-Neustart oder Reloader
Nach Neustart von Vault alles weg Dev-Modus speichert im RAM Lab-Schritte ab 4 wiederholen
no matches for kind ExternalSecret falsche apiVersion kubectl api-resources prüfen

Für die Namensauflösung als Notlösung ermittelst du die IP so: docker inspect -f '{{.NetworkSettings.Networks.kind.IPAddress}}' vault. Diese IP ändert sich aber beim Neustart des Containers.

Übung: Zweites Team, getrennte Tresorfächer

Ein zweites Team betreibt im Namespace team-b eine Anwendung. Es soll ein eigenes Secret unter kv/team-b/api mit dem Schlüssel apikey (Lab-Wert Lab-TeamB-1) bekommen. Richte Vault und ESO so ein, dass:

  1. im Namespace team-b ein Kubernetes-Secret team-b-api mit dem Wert entsteht,
  2. der SecretStore im Namespace demo dieses Secret nicht lesen kann (nachweisen!),
  3. das Team-B-Secret höchstens alle 5 Minuten synchronisiert wird.

Starte vorher Vault und ESO neu, falls du schon aufgeräumt hast (Schritte 4, 5, 6, 9, 10, 11).

Hinweis 1

Du brauchst pro Team drei Dinge in Vault: eine Policy, eine Rolle in der Kubernetes-Auth-Methode und einen ServiceAccount im Cluster. Die Vault-Rolle verbindet ServiceAccount und Namespace mit der Policy. Denke an die ClusterRoleBinding für TokenReview.

Hinweis 2

Den Nachweis für Punkt 2 führst du am einfachsten mit einem zweiten ExternalSecret im Namespace demo, das key: team-b/api aus dem Store vault-backend lesen will. Sein Status sollte nicht SecretSynced sein. kubectl describe externalsecret zeigt dir die Fehlermeldung von Vault.

Lösung

vault kv put kv/team-b/api apikey='Lab-TeamB-1'
cat > team-b-read.hcl <<'EOF'
path "kv/data/team-b/*" {
  capabilities = ["read"]
}
EOF
vault policy write team-b-read team-b-read.hcl

kubectl create namespace team-b
kubectl create serviceaccount eso-vault -n team-b
kubectl create clusterrolebinding eso-vault-tokenreview-team-b \
  --clusterrole=system:auth-delegator --serviceaccount=team-b:eso-vault
vault write auth/kubernetes/role/team-b \
  bound_service_account_names=eso-vault \
  bound_service_account_namespaces=team-b \
  token_policies=team-b-read token_ttl=15m

Für die Kubernetes-Objekte kopierst du secretstore.yaml und externalsecret.yaml und änderst namespace: team-b, role: "team-b", refreshInterval: 5m, target.name: team-b-api und den data-Block:

  data:
    - secretKey: APIKEY
      remoteRef:
        key: team-b/api
        property: apikey

Nach kubectl apply zeigt kubectl get externalsecret -n team-b den Status SecretSynced. Für den Negativtest legst du im Namespace demo ein ExternalSecret klau-versuch mit key: team-b/api an. Erwartung: READY False, und kubectl describe externalsecret klau-versuch -n demo zeigt einen Fehler mit permission denied bzw. 403. Der Grund: Der Store in demo meldet sich mit der Rolle demo-app an, und deren Policy erlaubt nur kv/data/demo-app/*.

Die Trennung entsteht also nicht durch ESO, sondern durch die Kombination aus Vault-Rolle (wer bin ich?) und Policy (was darf ich?). Ein gemeinsamer ClusterSecretStore mit einer einzigen Vault-Rolle hätte diese Trennung aufgehoben.

Fortschritt speichern? Kostenlos registrieren

Aus der Praxis

Betrieb von Vault/OpenBao. In der Produktion läuft Vault nicht im Dev-Modus, sondern als Cluster mit drei oder fünf Knoten und integriertem Raft-Speicher, TLS auf allen Verbindungen und Auto-Unseal über ein HSM oder einen KMS. In abgeschotteten Umgebungen (air-gapped) ist das HSM oft die einzige Option, weil kein Cloud-KMS erreichbar ist. Das Root-Token wird nach der Einrichtung widerrufen (vault token revoke) und nur im Notfall über die Unseal- bzw. Recovery-Key-Halter neu erzeugt (Vier-Augen-Prinzip mit Shamir-Teilschlüsseln).

Wer verwaltet Vault selbst? Policies, Rollen und Auth-Methoden gehören in Git und werden per Terraform/OpenTofu oder einem eigenen Pipeline-Job ausgerollt. Dann sind Berechtigungsänderungen über Merge Requests prüfbar. Kein Mensch klickt Policies in der UI zusammen.

Audit und Monitoring. Das Audit-Log geht in das zentrale SIEM. Sinnvolle Alarme: Root-Token benutzt, Policy geändert, viele permission denied von einer Identität, Audit-Device ausgefallen. Vault exportiert Metriken im Prometheus-Format (/v1/sys/metrics). Dort lohnt der Blick auf Lease-Anzahl, Seal-Status und Request-Latenz. Viele Leases ohne Revoke deuten auf Anwendungen hin, die bei jedem Start neue Credentials ziehen und nie aufräumen.

Behörden und KRITIS. Prüfer fragen meist: Wo liegen Secrets? Wer hat Zugriff? Wie oft wird rotiert? Wie schnell kann widerrufen werden? Gibt es einen Nachweis? Mit Vault beantwortest du das aus den Policies, den TTLs und dem Audit-Log. Im IT-Grundschutz des BSI findest du passende Anforderungen etwa im Baustein zur Kryptokonzept- und Schlüsselverwaltung und zum Identitäts- und Berechtigungsmanagement. Lizenzfragen (BSL vs. MPL) klärst du früh mit der Beschaffung. Mancher Auftraggeber verlangt ausdrücklich Open-Source-Lizenzen, dann ist OpenBao gesetzt.

Ablösung im Bestand. In gewachsenen Organisationen findet ein erster gitleaks-Lauf über alle Repos oft Hunderte Funde. Nicht alle auf einmal angehen. Bewährt hat sich:

  1. Funde nach Art klassifizieren (Cloud-Keys, DB-Passwörter, Test-Dummies).
  2. Echte, noch gültige Credentials sofort rotieren.
  3. Für Altlasten eine Baseline erstellen (--baseline-path in gitleaks), damit neue Funde sofort auffallen.
  4. Mit den Teams Übergangsfristen für die Umstellung auf Vault vereinbaren (siehe Kapitel 10).

Kein Secret im Git, auch nicht verschlüsselt? Werkzeuge wie SOPS oder Sealed Secrets legen verschlüsselte Secrets ins Repo. Das ist besser als Klartext, löst aber Rotation, Widerruf und Audit nicht. ESO mit Vault trennt Speicherung und Verteilung sauber und ist deshalb in regulierten Umgebungen oft die bevorzugte Lösung. Argo CD oder Flux (siehe Kapitel 1) rollen dann nur das ExternalSecret aus, nie den Wert selbst.

Interviewfragen

F: Ein Kollege hat ein Produktions-Datenbankpasswort in ein internes Repo gepusht und es zehn Minuten später wieder gelöscht. Was tust du?

A: Zuerst das Passwort rotieren bzw. den Zugang widerrufen, denn es steht weiter in der Historie und in allen Klonen. Danach in den DB-Logs prüfen, ob es missbraucht wurde, und je nach Ergebnis den Vorfallprozess starten. Dann den Code auf eine Secret-Quelle umstellen, die Historie mit git filter-repo bereinigen und gitleaks als Pre-commit-Hook und CI-Job einführen.

F: Was ist der Unterschied zwischen statischen und dynamischen Secrets?

A: Ein statisches Secret existiert unabhängig vom Tresor und wird dort nur gespeichert. Rotieren muss man es selbst. Ein dynamisches Secret erzeugt Vault erst bei Anfrage, individuell pro Abnehmer und mit einer Lease. Nach Ablauf der TTL oder bei Revoke löscht Vault es im Zielsystem wieder.

F: Wie authentifiziert sich ein GitLab-CI-Job bei Vault, ohne dass ein Token in CI-Variablen liegt?

A: Über id_tokens fordert der Job ein von GitLab signiertes JWT mit passender Audience an. Vault prüft es per JWT-Auth-Methode gegen den JWKS-Endpunkt von GitLab und vergleicht Claims wie project_path, ref und ref_protected mit bound_claims der Rolle. Der Job bekommt ein kurzlebiges Vault-Token mit genau der Policy dieser Rolle.

F: Warum braucht Vault Zugriff auf die Kubernetes-API, wenn es Kubernetes-Auth nutzt?

A: Vault prüft das ServiceAccount-Token des Pods über die TokenReview-API. Nur so weiß es, ob das Token gültig ist und zu welchem ServiceAccount und Namespace es gehört. Läuft Vault außerhalb des Clusters, braucht es dafür Netzwerkzugang zur API, das CA-Zertifikat und ein JWT mit Recht auf TokenReview.

F: Was ist der Unterschied zwischen SecretStore und ClusterSecretStore im External Secrets Operator?

A: Ein SecretStore gilt für einen Namespace und kann nur von ExternalSecrets dort genutzt werden. Ein ClusterSecretStore gilt clusterweit. Für Mandantentrennung nimmt man SecretStores pro Namespace mit eigener Vault-Rolle und Policy, sonst könnte jeder Namespace alles lesen, was die gemeinsame Rolle darf.

F: Wie kommt eine Rotation in Vault bis zur laufenden Anwendung?

A: ESO prüft im refreshInterval und aktualisiert das Kubernetes-Secret. Gemountete Secret-Dateien aktualisiert das Kubelet danach, die Anwendung muss sie neu lesen. Umgebungsvariablen bleiben bis zum Neustart alt. Deshalb braucht man einen Rollout-Neustart oder einen Reloader. Bei Datenbanken lässt man alte und neue Credentials kurz parallel gelten.

F: Vault oder OpenBao, wie entscheidest du?

A: Technisch sind beide für die Kernfunktionen weitgehend gleich und API-kompatibel. Entscheidend sind Lizenz (BSL bei Vault ab 1.15, MPL 2.0 bei OpenBao), Bedarf an Enterprise-Funktionen, Support-Anforderungen und Beschaffungsvorgaben. In Umgebungen mit Open-Source-Pflicht ist OpenBao naheliegend.

F: Warum ist eine Policy auf kv/myapp/* bei KV v2 wirkungslos?

A: KV v2 legt die Daten unter kv/data/myapp/... und Metadaten unter kv/metadata/myapp/... ab. Die CLI versteckt das, Policies arbeiten aber mit den echten API-Pfaden.

Zusammenfassung

Das hast du gelernt:

  • Ein gelöschtes Secret ist nicht weg: gitleaks findet es in der Historie, und nur Rotation macht es wertlos.
  • Ein Secret hat einen Lebenszyklus. Vault deckt Speichern, Verteilen, Rotieren, Widerrufen und Prüfen ab.
  • Dynamische Secrets mit Lease und TTL sind pro Abnehmer eindeutig, verfallen von selbst und lassen sich gezielt widerrufen.
  • Abnehmer melden sich mit Plattform-Identitäten an: Kubernetes-ServiceAccounts, GitLab-id_tokens per JWT, notfalls AppRole.
  • Policies arbeiten mit echten API-Pfaden und Default Deny. Das Audit-Log weist jeden Zugriff nach.
  • ESO synchronisiert Secrets aus Vault in Kubernetes. Mit refreshInterval kommen Rotationen automatisch an, laufende Pods brauchen aber einen Neustart oder Reload.
  • Läuft Vault außerhalb des kind-Clusters, verbindet das Docker-Netz kind beide Seiten über die Namen vault und seclab-control-plane.
  • OpenBao ist der MPL-lizenzierte Fork von Vault mit bao-CLI und kompatibler API.