Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 13: Governance – Root-Token, Rekey, Rotation, Namespaces, Konfiguration als Code

Ziel: Kein Root-Token mehr im Alltag, Schlüssel rotiert, Teams in Namespaces getrennt, Konfiguration in OpenTofu. · Dauer: ca. 150 min · Voraussetzung: Tag 12

Briefing

  • Alltag läuft über eine Admin-Policy bao-admin. Root gibt es nur kurz als Break-Glass per generate-root.
  • Seit v2.6 nutzt bao operator generate-root die authentifizierten Endpunkte sys/generate-root-token/*: Recovery-Keys und ein Token mit passender Policy. Die alten unauthentifizierten Endpunkte bleiben per Default gesperrt. Rekey heißt bao operator rotate-keys und braucht ebenfalls ein Token.
  • Mit Auto-Unseal (Tag 10) hast du Recovery-Keys statt Unseal-Keys. Die Kommandos brauchen dafür -target=recovery.
  • Namespaces gibt es ab OpenBao v2.3.
breakglass (Policy break-glass) + Recovery-Keys -> generate-root -> Root kurz
  -> rotate-keys / rotate -> revoke
Alltag: userpass admin -> Policy bao-admin

Drill 1: Least-Privilege-Admin

mkdir -p ~/bao-lab/tag13 && cd ~/bao-lab/tag13
kubectl -n openbao port-forward svc/openbao-active 8200:8200 >/dev/null 2>&1 &
export BAO_ADDR=https://127.0.0.1:8200 BAO_CACERT=~/bao-lab/tls/ca.crt
export BAO_TOKEN=$(jq -r .root_token ~/bao-lab/k8s/init.json)
cat > bao-admin.hcl <<'EOF'
# Mounts und Auth-Methoden
path "sys/mounts"           { capabilities = ["read","list"] }
path "sys/mounts/*"         { capabilities = ["create","read","update","delete","list"] }
path "sys/auth"             { capabilities = ["read"] }
path "sys/auth/*"           { capabilities = ["create","read","update","delete","sudo"] }
path "auth/*"               { capabilities = ["create","read","update","delete","list"] }

# Policies, Namespaces, Audit lesen
path "sys/policies/acl"     { capabilities = ["list"] }
path "sys/policies/acl/*"   { capabilities = ["create","read","update","delete","list"] }
path "sys/namespaces/*"     { capabilities = ["create","read","update","delete","list"] }
path "sys/audit"            { capabilities = ["read","sudo"] }

# Betrieb: Leases, Snapshots, Step-down, Raft-Status, Log-Level
path "sys/leases/*"         { capabilities = ["read","update","list","sudo"] }
path "sys/storage/raft/*"   { capabilities = ["read"] }
path "sys/step-down"        { capabilities = ["update","sudo"] }
path "sys/loggers*"         { capabilities = ["read","update","delete","sudo"] }

# Team-Namespaces (eine Ebene tief)
path "+/sys/mounts/*"       { capabilities = ["create","read","update","delete","list"] }
path "+/sys/auth/*"         { capabilities = ["create","read","update","delete","sudo"] }
path "+/sys/policies/acl/*" { capabilities = ["create","read","update","delete","list"] }
path "+/auth/*"             { capabilities = ["create","read","update","delete","list"] }

# Schlüssel- und Root-Operationen: nur Break-Glass
path "sys/rotate/*"         { capabilities = ["deny"] }
path "sys/generate-root-token/*" { capabilities = ["deny"] }
path "sys/raw/*"            { capabilities = ["deny"] }
EOF
bao policy write bao-admin bao-admin.hcl
bao auth enable userpass
bao write auth/userpass/users/admin password=lab-admin-pw \
  token_policies=bao-admin token_ttl=8h          # Lab-Passwort

Erwartet:

Success! Uploaded policy: bao-admin
Success! Enabled userpass auth method at: userpass/
Success! Data written to: auth/userpass/users/admin

Warum? Der Admin verwaltet Mounts, Auth und Policies, liest aber keine Secrets und kann weder Schlüssel rotieren noch Root erzeugen.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Root-Token revoken

bao token revoke -self
bao token lookup
unset BAO_TOKEN
export BAO_TOKEN=$(bao login -no-store -token-only -method=userpass \
  username=admin password=lab-admin-pw)
bao token lookup | grep -E '^policies|^ttl'
bao operator rotate

Erwartet (gekürzt):

Success! Revoked token (if it existed)
Error looking up token: Error making API request.
...
* permission denied
policies            [bao-admin default]
ttl                 7h59m58s
Error rotating key: Error making API request.

URL: POST https://127.0.0.1:8200/v1/sys/rotate/keyring
Code: 403. Errors:
...
    * permission denied

root_token in init.json ist ab jetzt wertlos. Gut so.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Break-Glass vorbereiten

Bis v2.5 musstest du dafür disable_unauthed_generate_root_endpoints = false am Listener ausrollen. Mit 2.7 reicht eine eigene Policy für die authentifizierten Endpunkte – kein Config-Rollout.

bao policy write break-glass - <<'EOF'
path "sys/generate-root-token/*" {
  capabilities = ["create", "read", "update", "delete"]
}
EOF
bao write auth/userpass/users/breakglass password=lab-bg-pw \
  token_policies=break-glass token_ttl=1h          # Lab-Passwort
bao operator generate-root -status

Erwartet (gekürzt):

Success! Uploaded policy: break-glass
Success! Data written to: auth/userpass/users/breakglass
Error getting root generation status: Error making API request.

URL: GET https://127.0.0.1:8200/v1/sys/generate-root-token/attempt
Code: 403. Errors:
...
    * permission denied

Warum? bao-admin verbietet sys/generate-root-token/* ausdrücklich. Nur breakglass darf den Vorgang starten, und auch nur zusammen mit drei Recovery-Keys.

Achtung: Wer Policies schreiben darf, könnte sich break-glass selbst zuweisen. Ohne Key-Quorum nützt ihm das nichts – trotzdem gehört jede Änderung an break-glass ins Audit-Review.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Root-Token neu erzeugen (OTP)

Nach der Seal-Migration (Tag 10) sind die alten Unseal-Keys aus init.json deine Recovery-Keys. Hast du neu initialisiert, nimm .recovery_keys_b64.

export BAO_TOKEN=$(bao login -no-store -token-only -method=userpass \
  username=breakglass password=lab-bg-pw)
RK='.unseal_keys_b64'; INIT=~/bao-lab/k8s/init.json
OTP=$(bao operator generate-root -generate-otp)
bao operator generate-root -init -otp="$OTP"
NONCE=$(bao operator generate-root -status -format=json | jq -r .nonce)
for i in 0 1 2; do
  jq -r "$RK[$i]" "$INIT" \
    | bao operator generate-root -nonce="$NONCE" -format=json - > gr.json
done
jq -c '{progress, required, complete}' gr.json
ENC=$(jq -r .encoded_token gr.json)
export BAO_TOKEN=$(bao operator generate-root -decode="$ENC" -otp="$OTP")
bao token lookup | grep -E '^policies|^ttl'

Erwartet:

Nonce         68d347df-6a00-66b6-ceff-15c39715d3d8
Started       true
Progress      0/3
Complete      false
OTP Length    26
{"progress":3,"required":3,"complete":true}
policies            [root]
ttl                 0s

Warum? Das Ergebnis kommt XOR-verschlüsselt mit dem OTP zurück. Wer nur die Key-Eingaben mitliest, hat noch kein Token. In Produktion: -pgp-key statt OTP. -decode arbeitet lokal und braucht kein Token.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Recovery-Keys rotieren (Rekey)

bao operator rekey -target=recovery -init -key-shares=5 -key-threshold=3
NONCE=$(bao operator rotate-keys -target=recovery -init \
  -key-shares=5 -key-threshold=3 -format=json | jq -r .nonce)
for i in 0 1 2; do
  jq -r "$RK[$i]" "$INIT" | bao operator rotate-keys -target=recovery \
    -nonce="$NONCE" -format=json - > ~/bao-lab/k8s/recovery-neu.json
done
jq -c '{complete, anzahl: (.keys_base64 | length)}' ~/bao-lab/k8s/recovery-neu.json

Erwartet (gekürzt):

Error initializing rekey: Error making API request.
...
* unsupported path
{"complete":true,"anzahl":5}

Die Schlüssel in init.json sind jetzt ungültig. Ab Tag 14 gilt recovery-neu.json (.keys_base64). Im Lab liegen sie lokal, in Produktion bekommt jede Person nur ihren Anteil, PGP-verschlüsselt (-pgp-keys).

Fortschritt speichern? Kostenlos registrieren

Drill 6: Keyring rotieren

bao operator key-status
bao operator rotate
bao operator key-status

Erwartet (gekürzt):

Key Term            1
Install Time        08 Oct 26 07:01 UTC
Encryption Count    1843
Success! Rotated key

Key Term            2
Install Time        08 Oct 26 09:13 UTC
Encryption Count    1
...

Ab 2.7 gibt rotate den neuen Key-Status gleich mit aus, das zweite key-status zeigt dasselbe.

Warum? rotate tauscht den Datenverschlüsselungs-Key (Keyring) online aus, alte Daten bleiben lesbar. rotate-keys tauscht dagegen nur die Anteile, die den Root Key schützen.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Root wieder weg, Tür bleibt zu

bao token revoke -self
export BAO_TOKEN=$(bao login -no-store -token-only -method=userpass \
  username=admin password=lab-admin-pw)
bao operator generate-root -status
curl -s --cacert "$BAO_CACERT" "$BAO_ADDR/v1/sys/generate-root/attempt"; echo

Erwartet (gekürzt):

Success! Revoked token (if it existed)
Error getting root generation status: Error making API request.
...
Code: 403. Errors:
...
    * permission denied
{"errors":["unsupported operation"]}

Der Admin kommt nicht an generate-root, der alte unauthentifizierte Pfad antwortet weiter mit 405. Es gab keinen Config-Rollout, also gibt es auch keinen zurückzurollen.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Namespaces

bao namespace create team-shop
bao secrets enable -namespace=team-shop -path=secret kv-v2
bao policy write -namespace=team-shop shop-dev - <<'EOF'
path "secret/data/webshop/*" {
  capabilities = ["create", "read", "update"]
}
EOF
bao auth enable -namespace=team-shop userpass
bao write -namespace=team-shop auth/userpass/users/shopdev \
  password=lab-shop-pw token_policies=shop-dev        # Lab-Passwort
T=$(bao login -no-store -token-only -namespace=team-shop -method=userpass \
  username=shopdev password=lab-shop-pw)
echo "$T"
BAO_TOKEN=$T bao kv put -namespace=team-shop -mount=secret webshop/config \
  api_key=lab-ns-key
BAO_TOKEN=$T BAO_NAMESPACE=team-shop \
  bao kv get -mount=secret -field=api_key webshop/config; echo
BAO_TOKEN=$T bao kv get -mount=secret webshop/config
bao kv get -namespace=team-shop -mount=secret webshop/config

Erwartet (gekürzt, letzte Meldung kann abweichen):

path               team-shop/
Success! Enabled the kv-v2 secrets engine at: secret/
Success! Uploaded policy: shop-dev
Success! Enabled userpass auth method at: userpass/
Success! Data written to: auth/userpass/users/shopdev
s.4WRq2WJJHVEjWFYWOuRmU1PC.bXoLKD
...
lab-ns-key
* preflight capability check returned 403, please ensure client's policies grant
access to path "secret/"
* preflight capability check returned 403, ...

Warum? Das Token trägt die Namespace-ID als Suffix (.bXoLKD) und gilt nur dort. Auch bao-admin aus dem Root-Namespace verwaltet den Namespace, liest aber keine Team-Secrets.

Per API gibt es zwei Wege: Header X-Vault-Namespace oder Pfad-Präfix.

curl -s --cacert "$BAO_CACERT" -H "X-Vault-Token: $T" \
  "$BAO_ADDR/v1/team-shop/secret/data/webshop/config" | jq -c .data.data

Erwartet:

{"api_key":"lab-ns-key"}

Fortschritt speichern? Kostenlos registrieren

Drill 9: Konfiguration als Code mit OpenTofu

Der Provider hashicorp/vault spricht die kompatible API. Er liest aber nur VAULT_*-Variablen.

mkdir -p ~/bao-lab/tag13/tofu && cd ~/bao-lab/tag13/tofu
cat > main.tf <<'EOF'
terraform {
  required_providers {
    vault = {
      source  = "hashicorp/vault"
      version = "~> 5.0"
    }
  }
}

provider "vault" {}   # VAULT_ADDR, VAULT_TOKEN, VAULT_CACERT aus der Umgebung

resource "vault_mount" "kv_shop" {
  path    = "shop-kv"
  type    = "kv"
  options = { version = "2" }
}

resource "vault_policy" "webshop_read" {
  name   = "webshop-read-tf"
  policy = <<-EOT
    path "shop-kv/data/webshop/*" {
      capabilities = ["read"]
    }
  EOT
}

resource "vault_auth_backend" "approle" {
  type = "approle"
}

resource "vault_approle_auth_backend_role" "webshop" {
  backend        = vault_auth_backend.approle.path
  role_name      = "webshop"
  token_policies = [vault_policy.webshop_read.name]
  token_ttl      = 3600
}
EOF
export VAULT_ADDR=$BAO_ADDR VAULT_CACERT=$BAO_CACERT VAULT_TOKEN=$BAO_TOKEN
tofu init
tofu apply -auto-approve
bao read auth/approle/role/webshop | grep token_policies

Erwartet (gekürzt):

OpenTofu has been successfully initialized!
...
vault_policy.webshop_read: Creation complete after 0s [id=webshop-read-tf]
vault_mount.kv_shop: Creation complete after 0s [id=shop-kv]
vault_auth_backend.approle: Creation complete after 0s [id=approle]
vault_approle_auth_backend_role.webshop: Creation complete after 0s [id=auth/...]

Apply complete! Resources: 4 added, 0 changed, 0 destroyed.
token_policies             [webshop-read-tf]

Drift-Test: bao policy delete webshop-read-tf, dann zeigt tofu plan (Provider 5.12) 0 to add, 1 to change – die Policy wird in-place neu geschrieben.

Sicherheit: Der State enthält Secrets im Klartext (z. B. gelesene Werte, AppRole-Secret-IDs). Nutze ein verschlüsseltes Remote-Backend oder die State-Verschlüsselung von OpenTofu.

Fortschritt speichern? Kostenlos registrieren

Drill 10: Deklarative Selbstinitialisierung (lokal)

Neue Cluster können sich beim ersten Start selbst einrichten (initialize-Stanza, ab v2.4; seit v2.6 mit when, CEL und Templates, unbekannte Keys sind ein Fehler). Voraussetzung ist Auto-Unseal, es entsteht kein nutzbares Root-Token. Lokal probierst du das mit dem Static Seal aus (Port 8300, damit kein Konflikt mit dem Port-Forward entsteht).

mkdir -p ~/bao-lab/tag13/selfinit/data && cd ~/bao-lab/tag13/selfinit
openssl rand -out unseal.key 32
cat > config.hcl <<EOF
api_addr     = "http://127.0.0.1:8300"
cluster_addr = "http://127.0.0.1:8301"
listener "tcp" {
  address         = "127.0.0.1:8300"
  cluster_address = "127.0.0.1:8301"
  tls_disable     = 1
}
storage "raft" {
  path    = "$PWD/data"
  node_id = "selfinit"
}
seal "static" {
  current_key_id = "lab-1"
  current_key    = "file://$PWD/unseal.key"
}
initialize "auth" {
  request "enable-userpass" {
    operation = "update"
    path      = "sys/auth/userpass"
    data      = { type = "userpass" }
  }
}
initialize "admin" {
  request "admin-policy" {
    operation = "update"
    path      = "sys/policies/acl/bao-admin"
    data      = { policy = "path \"sys/*\" { capabilities = [\"read\", \"list\"] }" }
  }
  request "admin-user" {
    operation = "update"
    path      = "auth/userpass/users/admin"
    data = {
      password = {
        eval_type       = "string"
        eval_source     = "env"
        env_var         = "INITIAL_ADMIN_PASSWORD"
        require_present = true
      }
      token_policies = ["bao-admin"]
    }
  }
}
EOF
INITIAL_ADMIN_PASSWORD=lab-admin-pw bao server -config=config.hcl > server.log 2>&1 &
sleep 5
B=http://127.0.0.1:8300
bao status -address=$B | grep -E 'Seal Type|Initialized|Recovery Shares'
bao login -address=$B -no-store -method=userpass \
  username=admin password=lab-admin-pw | grep token_policies
kill %1

Erwartet:

Seal Type                static
Recovery Seal Type       shamir
Initialized              true
Total Recovery Shares    0
token_policies         ["bao-admin" "default"]

Warum? Recovery-Keys erzeugst du danach authentifiziert mit bao operator rotate-keys -target=recovery -init …. Audit-Devices gehören auch hier in die audit-Stanza, nicht in initialize.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

#!/usr/bin/env bash
ok() { echo "✔ $1"; }; nok() { echo "✘ $1"; }
OLD=$(jq -r .root_token ~/bao-lab/k8s/init.json)
BAO_TOKEN=$OLD bao token lookup >/dev/null 2>&1 \
  && nok "Alt-Root ist noch gültig" || ok "Alt-Root revoked"
bao token lookup -format=json | jq -e '.data.policies | index("bao-admin")' >/dev/null \
  && ok "Arbeite als bao-admin" || nok "Arbeite als bao-admin"
bao operator generate-root -status >/dev/null 2>&1 \
  && nok "Admin darf generate-root" || ok "generate-root nur Break-Glass"
[ "$(jq '.keys_base64 | length' ~/bao-lab/k8s/recovery-neu.json)" = 5 ] \
  && ok "Neue Recovery-Keys" || nok "Neue Recovery-Keys"
bao namespace list | grep -q team-shop && ok "Namespace" || nok "Namespace"
(cd ~/bao-lab/tag13/tofu && tofu plan -detailed-exitcode >/dev/null) \
  && ok "OpenTofu ohne Drift" || nok "OpenTofu ohne Drift"

Challenge

Lege per OpenTofu im Namespace team-shop eine AppRole-Rolle ci mit Policy shop-dev an – mit dem bao-admin-Token, nicht mit Root.

Hinweis: Die Ressourcen des Providers kennen das Argument namespace.

Lösung

cd ~/bao-lab/tag13/tofu
cat >> main.tf <<'EOF'

resource "vault_auth_backend" "approle_shop" {
  namespace = "team-shop"
  type      = "approle"
}

resource "vault_approle_auth_backend_role" "shop_ci" {
  namespace      = "team-shop"
  backend        = vault_auth_backend.approle_shop.path
  role_name      = "ci"
  token_policies = ["shop-dev"]
}
EOF
tofu apply -auto-approve
bao read -namespace=team-shop auth/approle/role/ci | grep token_policies

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Root-Token nur im Vier-Augen-Prinzip: Break-Glass-Konto (Policy break-glass, eigener Auth-Mount, MFA) plus Key-Quorum mit PGP-Keys, sofort danach revoken. Jede Nutzung steht im Audit-Log.
  • Recovery-Keys an verschiedene Personen verteilen (-pgp-keys), regelmäßig rotieren, Übergaben dokumentieren.
  • rotate (Keyring) regelmäßig oder nach Vorfällen. Hängt am Keyring eine Compliance-Vorgabe, zählt Encryption Count.
  • Namespaces pro Mandant/Team, Admin-Policies mit +/-Pfaden statt Root. Namespace-Löschung ist destruktiv.
  • Gesamte Konfiguration in OpenTofu mit Remote-State, Reviews per Merge Request. Für den ersten Start nur minimale initialize-Stanzas.