Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 14: Leitplanken und Anti-Patterns

Ziel: Du schneidest Policies knapp zu, siehst im Audit-Log, wer was gelesen hat, und erkennst die typischen Lecks rund um Secrets. · Dauer: ca. 120 min · Voraussetzung: Tag 2, Tag 9

Briefing

  • Least Privilege heißt: eine Policy pro App, nur read, Unterpfade per deny sperren.
  • Ein Policy-Template mit Kubernetes-Metadaten ersetzt viele fast gleiche Policies.
  • Das Audit-Log zeigt jeden Zugriff. Werte und Tokens stehen dort nur als HMAC.
  • Kurze TTLs begrenzen den Schaden eines geleakten Tokens. Der Root-Token läuft nie ab.
  • Die meisten Lecks entstehen nicht in OpenBao, sondern danach: Env, Shell-Trace, ConfigMap, Image, Git.
 Pod (SA shop-api) ──login──► auth/kubernetes ──► Entity-Alias {ns: shop, sa: shop-api}
                                                       │
 Policy-Template: secret/data/{{…service_account_namespace}}/*  ──► secret/data/shop/*
                                                       │
 jede Anfrage ──► Audit-Device (stdout) ──► kubectl logs openbao-0   (Werte als HMAC)

Drill 1: Audit-Device einschalten

Zuerst die Kamera an, dann die Drills. OpenBao 2.x verbietet das Anlegen von Audit-Devices per API:

mkdir -p ~/secrets-lab/tag14 && cd ~/secrets-lab/tag14
export BAO_ADDR=http://127.0.0.1:8200 BAO_TOKEN=root
bao audit enable file file_path=stdout

Erwartet (gekürzt):

Error enabling audit device: Error making API request.
Code: 400. Errors:

* cannot enable audit device via API; use declarative, config-based audit device
management instead

Also deklarativ: eine zusätzliche Config-Datei per ConfigMap, die der Dev-Server über server.extraArgs mitliest. Die Werte-Datei aus Tag 0 kommt mit -f zuerst, so bleibt auch der CSI-Provider aus Tag 6 (csi.enabled: true) erhalten. Betrieb und Härtung des Servers sind Thema von „OpenBao zum Anfassen”, hier geht es nur ums Mitlesen.

cat > audit.hcl <<'EOF'
# Audit-Device deklarativ: per API lässt OpenBao 2.x das nicht mehr zu
audit "file" "stdout" {
  options {
    file_path = "stdout"
  }
}
EOF
cat > audit-values.yaml <<'EOF'
# Ergänzt ~/secrets-lab/setup/openbao-values.yaml um ein Audit-Device (Lab)
server:
  extraArgs: "-config=/openbao/userconfig/openbao-audit/audit.hcl"
  extraVolumes:
  - type: configMap
    name: openbao-audit
EOF
kubectl -n openbao create configmap openbao-audit --from-file=audit.hcl
helm upgrade openbao openbao/openbao -n openbao --server-side=false \
  -f ~/secrets-lab/setup/openbao-values.yaml -f audit-values.yaml | head -1
kubectl -n openbao delete pod openbao-0
kubectl -n openbao wait --for=condition=Ready pod/openbao-0 --timeout=120s

Erwartet:

configmap/openbao-audit created
Release "openbao" has been upgraded. Happy Helming!
pod "openbao-0" deleted from openbao namespace
pod/openbao-0 condition met

Achtung: Das StatefulSet nutzt OnDelete, daher das manuelle Löschen. Der Dev-Server hält alles im Speicher: Nach dem Neustart sind KV-Daten, Policies und Auth-Konfiguration weg. Starte den Port-Forward neu und lass seed.sh erneut laufen.

pkill -f 'port-forward svc/openbao' # der alte Forward hängt am gelöschten Pod
kubectl -n openbao port-forward svc/openbao 8200:8200 >/dev/null 2>&1 &
sleep 3
~/secrets-lab/setup/seed.sh
bao audit list
kubectl -n openbao logs openbao-0 | grep -c '"type":"request"'

Erwartet:

✔ Demo-Daten, Policy shop-api-read, Rolle kubernetes/shop-api, NS shop angelegt
Path       Type    Description
----       ----    -----------
stdout/    file    n/a
19

Jede Anfrage seit dem Neustart, auch die von seed.sh, steht schon im Log, als Paar aus request und response.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Least Privilege mit deny und bao token capabilities

Unter secret/shop/ liegt jetzt auch etwas, das die App nie lesen darf. Die Policy erlaubt den Pfad, sperrt aber den Unterpfad admin/.

bao kv put secret/shop/admin/root-ca key=lab-ca-key-000 >/dev/null
cat > shop-api-guard.hcl <<'EOF'
# Nur, was shop-api wirklich braucht
path "secret/data/shop/*" {
  capabilities = ["read"]
}
# Unterpfad explizit sperren: deny schlägt jede andere Regel
path "secret/data/shop/admin/*" {
  capabilities = ["deny"]
}
EOF
bao policy write shop-api-guard shop-api-guard.hcl
T=$(bao token create -policy=shop-api-guard -ttl=10m -field=token)
for p in secret/data/shop/api secret/data/shop/admin/root-ca \
         secret/metadata/shop/api sys/policies/acl/shop-api-guard; do
  printf '%-36s %s\n' "$p" "$(bao token capabilities "$T" "$p")"
done

Erwartet:

Success! Uploaded policy: shop-api-guard
secret/data/shop/api                 read
secret/data/shop/admin/root-ca       deny
secret/metadata/shop/api             deny
sys/policies/acl/shop-api-guard      deny

bao token capabilities beantwortet „darf dieser Token das?“, ohne den Zugriff auszuführen. Ideal für Reviews und CI-Tests von Policies. Ohne Token-Argument prüft der Befehl den eigenen Token. Kein list und kein Zugriff auf metadata/ heißt: Die App kann auch nicht herausfinden, welche anderen Secrets es gibt.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Ein Policy-Template für alle Namespaces

Statt shop-read, blog-read, …-read schreibst du eine Policy, die den Namespace aus dem Entity-Alias der Kubernetes-Auth nimmt. Erst die verfügbaren Metadaten ansehen:

kubectl -n shop create token shop-api --audience=openbao > shop.jwt
bao write -format=json auth/kubernetes/login role=shop-api [email protected] \
  | jq '.auth.metadata'
ACC=$(bao auth list -format=json | jq -r '."kubernetes/".accessor'); echo "$ACC"

Erwartet:

{
  "role": "shop-api",
  "service_account_name": "shop-api",
  "service_account_namespace": "shop",
  "service_account_secret_name": "",
  "service_account_uid": "8e080002-73b6-41b4-8bdc-88c6e32b5f2f"
}
auth_kubernetes_5e14660b

Bis auf role landen diese Felder auch am Entity-Alias und sind damit im Template nutzbar. Der Accessor ist in jedem Lab anders, deshalb setzt die Shell ihn ein:

M="identity.entity.aliases.$ACC.metadata"
cat > ns-read.hcl <<EOF
# Ein Template für alle Namespaces: NS aus dem Entity-Alias der Kubernetes-Auth
path "secret/data/{{$M.service_account_namespace}}/*" {
  capabilities = ["read"]
}
EOF
bao policy write ns-read ns-read.hcl
kubectl create namespace blog
kubectl -n blog create serviceaccount blog-api
bao kv put secret/blog/api db_password=lab-blog-pw-321 >/dev/null
bao write auth/kubernetes/role/ns-apps \
  bound_service_account_names=shop-api,blog-api \
  bound_service_account_namespaces=shop,blog \
  audience=openbao token_policies=ns-read token_ttl=10m
for ns in shop blog; do
  J=$(kubectl -n "$ns" create token "$ns-api" --audience=openbao)
  T=$(bao write -field=token auth/kubernetes/login role=ns-apps jwt="$J")
  for p in shop/api blog/api; do
    echo "$ns/$ns-api -> secret/$p: $(bao token capabilities "$T" secret/data/$p)"
  done
done

Erwartet:

Success! Uploaded policy: ns-read
namespace/blog created
serviceaccount/blog-api created
Success! Data written to: auth/kubernetes/role/ns-apps
shop/shop-api -> secret/shop/api: read
shop/shop-api -> secret/blog/api: deny
blog/blog-api -> secret/shop/api: deny
blog/blog-api -> secret/blog/api: read

Eine Rolle, eine Policy, zwei Mandanten sauber getrennt. Die Konvention „KV-Pfad = Namespace” ist dabei die eigentliche Leitplanke. Halte sie verbindlich fest.

Achtung: Das Template bindet nur den Pfad. Wer bound_service_account_names=* setzt, öffnet die Rolle für jeden ServiceAccount im erlaubten Namespace.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Audit-Log lesen – wer las was?

Erst ein paar Zugriffe als shop-api, darunter ein verbotener:

T=$(bao write -field=token auth/kubernetes/login role=shop-api [email protected])
BAO_TOKEN=$T bao kv get -field=api_key secret/shop/api; echo
BAO_TOKEN=$T bao kv get secret/blog/api >/dev/null 2>&1 || echo "403 wie erwartet"
kubectl -n openbao logs openbao-0 | grep '^{' > audit.jsonl
jq -c 'select(.type=="response" and (.request.path|startswith("secret/data/")))
  | {t: .time[11:19], who: .auth.display_name, op: .request.operation,
     path: .request.path, ok: (.error == null)}' audit.jsonl | tail -3

Erwartet (umbrochen):

lab-api-key-456
403 wie erwartet
{"t":"07:23:58","who":"token","op":"create","path":"secret/data/blog/api","ok":true}
{"t":"07:23:59","who":"kubernetes-shop-shop-api","op":"read",
"path":"secret/data/shop/api","ok":true}
{"t":"07:23:59","who":"kubernetes-shop-shop-api","op":"read",
"path":"secret/data/blog/api","ok":false}

display_name setzt sich aus Mount, Namespace und ServiceAccount zusammen. Mehr Details liefert .auth.metadata (Namespace, SA, UID), die IP steht in .request.remote_address. Und die Werte?

jq 'select(.type=="response" and .request.path=="secret/data/shop/api"
  and .request.operation=="read") | .response.data.data
  | map_values(.[0:40] + "…")' audit.jsonl | tail -5

Erwartet:

{
  "api_key": "hmac-sha256:b6d734987b1664d4f78a191fa2ef…",
  "db_password": "hmac-sha256:301ac28c7140e2db3d4c331bd292…",
  "db_user": "hmac-sha256:b6b59eae0851c8ac996c48a133ef…"
}

Alle Werte und auch Client-Tokens stehen nur als HMAC mit einem Schlüssel pro Audit-Device im Log. Wer das Log liest, sieht keine Secrets. Mit sys/audit-hash berechnest du den HMAC eines bekannten Werts und findest so heraus, wer ihn gelesen hat:

H=$(bao write -field=hash sys/audit-hash/stdout input=lab-api-key-456)
echo "$H" | cut -c1-40
grep "$H" audit.jsonl \
  | jq -r '[.time[11:19], .type, .auth.display_name, .request.operation] | @tsv'

Erwartet:

hmac-sha256:b6d734987b1664d4f78a191fa2ef
07:23:56    request token   create
07:23:56    response    token   create
07:23:59    response    kubernetes-shop-shop-api    read

Geschrieben hat ihn root (token) per seed.sh, gelesen hat ihn shop-api. Dieselbe Technik funktioniert für Token-Accessoren: HMAC des Accessors bilden, im Feld client_token_accessor suchen.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Token-TTLs und Nutzungslimits

Wie lange lebt ein Token, wenn niemand etwas einstellt?

bao read -format=json sys/auth/token/tune | jq -c '.data
  | {default_lease_ttl, max_lease_ttl}'
bao token lookup -format=json \
  | jq -c '.data | {display_name, policies, ttl, expire_time}'

Erwartet:

{"default_lease_ttl":2764800,"max_lease_ttl":2764800}
{"display_name":"token","policies":["root"],"ttl":0,"expire_time":null}

32 Tage Standard, und der Root-Token läuft nie ab. Begrenze die TTL am Auth-Mount, dann kann keine Rolle darüber hinaus:

bao auth tune -default-lease-ttl=15m -max-lease-ttl=1h kubernetes/
bao write auth/kubernetes/role/shop-api-long \
  bound_service_account_names=shop-api bound_service_account_namespaces=shop \
  audience=openbao token_policies=shop-api-read token_ttl=24h
bao write -format=json auth/kubernetes/login role=shop-api-long [email protected] \
  | jq -c '{ttl: .auth.lease_duration, warnings}'

Erwartet (umbrochen):

Success! Tuned the auth method at: kubernetes/
Success! Data written to: auth/kubernetes/role/shop-api-long
{"ttl":3600,"warnings":["TTL of \"24h\" exceeded the effective max_ttl of \"1h\"; TTL
value is capped accordingly"]}

Für Einmal-Aufgaben gibt es zusätzlich ein Nutzungslimit:

T=$(bao token create -policy=shop-api-read -ttl=60s -use-limit=2 -field=token)
for i in 1 2 3; do
  curl -s -o /dev/null -w "Lesen $i: HTTP %{http_code}\n" \
    -H "X-Vault-Token: $T" "$BAO_ADDR/v1/secret/data/shop/api"
done

Erwartet:

Lesen 1: HTTP 200
Lesen 2: HTTP 200
Lesen 3: HTTP 403

Nach zwei Anfragen ist der Token verbraucht und widerrufen. Vorsicht mit der CLI: Sie stellt vor dem Lesen eigene Anfragen (etwa nach dem Mount-Typ) und verbraucht so zusätzliche Nutzungen.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Anti-Patterns live

Drei Lecks, die du in jedem Projekt findest. Erstens: Env-Variablen sind für jeden lesbar, der in den Container darf, und landen in Crash-Dumps und Debug-Ausgaben.

kubectl -n shop exec deploy/shop-api -- sh -c 'tr "\0" "\n" < /proc/1/environ' \
  | grep DB_

Erwartet:

DB_PASSWORD=lab-db-pw-600
STAKATER_SHOP_DB_SECRET=f1bf6f9e42b4c5de827f367b47b23b2fa6c351bd

Die zweite Zeile ist der Hash, den Reloader aus Tag 9 setzt, kein Secret.

Zweitens: set -x in Skripten schreibt jede Zuweisung ins CI-Log.

cat > deploy.sh <<'EOF'
#!/usr/bin/env bash
set -euxo pipefail
DB_PW=$(bao kv get -field=db_password secret/shop/api)
echo "deploy mit ${#DB_PW} Zeichen Passwort"
EOF
bash deploy.sh

Erwartet:

++ bao kv get -field=db_password secret/shop/api
+ DB_PW=lab-db-pw-123
+ echo 'deploy mit 13 Zeichen Passwort'
deploy mit 13 Zeichen Passwort

Gegenmittel: Trace vor dem Secret abschalten und danach wieder an.

cat > deploy-ok.sh <<'EOF'
#!/usr/bin/env bash
set -euxo pipefail
{ set +x; } 2>/dev/null          # Trace aus, bevor ein Secret auftaucht
DB_PW=$(bao kv get -field=db_password secret/shop/api)
set -x
echo "deploy mit ${#DB_PW} Zeichen Passwort"
EOF
bash deploy-ok.sh

Erwartet:

+ echo 'deploy mit 13 Zeichen Passwort'
deploy mit 13 Zeichen Passwort

Drittens: Secrets in ConfigMaps. Die eingebaute Rolle view darf ConfigMaps lesen, Secrets aber nicht. Ein Support-Account sieht also jedes Passwort, das in einer ConfigMap steckt.

kubectl -n shop create serviceaccount support
kubectl -n shop create rolebinding support-view --clusterrole=view \
  --serviceaccount=shop:support
for r in configmaps secrets; do
  echo "$r: $(kubectl -n shop auth can-i get $r \
    --as=system:serviceaccount:shop:support)"
done

Erwartet:

serviceaccount/support created
rolebinding.rbac.authorization.k8s.io/support-view created
configmaps: yes
secrets: no

Die übrigen Anti-Patterns und ihre Gegenmittel:

Anti-Pattern Warum gefährlich Gegenmittel
Secret in Env-Variable /proc/1/environ, Kindprozesse, Dumps Datei-Mount, App liest Datei (Tag 9)
set -x in CI-Skripten Klartext im Job-Log { set +x; } 2>/dev/null, Masking (Tag 11)
Secret in Image, Git, ConfigMap Kopien ohne Ablaufdatum ESO/CSI/Agent, Secret-Scanner im CI
Root-Token in Pipelines unbegrenzt, alle Rechte, nie ablaufend JWT-Auth je Repo/Branch (Tag 10)
lange TTLs (Standard 32 Tage) geleakte Tokens bleiben gültig auth tune, token_max_ttl an Rolle
eine Policy für alles jede App liest jedes Secret Policy je App oder Template (Drill 3)

Fortschritt speichern? Kostenlos registrieren

Drill 7: Kyverno gegen Klartext-Secrets in Pods

Eine Admission-Regel verhindert Env-Variablen mit Secret-Namen, deren Wert direkt im Manifest steht. Die Policy ist mit der Kyverno-CLI 1.19 offline geprüft. Im Cluster brauchst du Kyverno ab 1.15 mit den CEL-basierten Policy-Typen.

cat > no-plaintext-secret-env.yaml <<'EOF'
apiVersion: policies.kyverno.io/v1
kind: ValidatingPolicy
metadata:
  name: no-plaintext-secret-env
spec:
  validationActions: [Deny]
  matchConstraints:
    resourceRules:
    - apiGroups: [""]
      apiVersions: [v1]
      operations: [CREATE, UPDATE]
      resources: [pods]
  validations:
  - expression: >-
      object.spec.containers.all(c, !has(c.env) || c.env.all(e,
        !e.name.matches('(?i)(password|secret|token|api_?key)') || !has(e.value)))
    message: "Secret-Variablen nie als value:, sondern per secretKeyRef oder Datei"
EOF
cat > pods.yaml <<'EOF'
apiVersion: v1
kind: Pod
metadata: {name: klartext, namespace: shop}
spec:
  containers:
  - name: app
    image: busybox:1.37
    env:
    - {name: DB_PASSWORD, value: lab-db-pw-123}
---
apiVersion: v1
kind: Pod
metadata: {name: sauber, namespace: shop}
spec:
  containers:
  - name: app
    image: busybox:1.37
    env:
    - name: DB_PASSWORD
      valueFrom:
        secretKeyRef: {name: shop-db, key: db_password}
    - {name: LOG_LEVEL, value: info}
EOF
kyverno apply no-plaintext-secret-env.yaml -r pods.yaml --remove-color | tail -4

Erwartet:

policy no-plaintext-secret-env -> resource shop/Pod/klartext failed:
1 -  Secret-Variablen nie als value:, sondern per secretKeyRef oder Datei

pass: 1, fail: 1, warn: 0, error: 0, skip: 0

Die Regel greift nur bei Pods und nur bei den Containern in containers. Für Deployments erzeugt Kyverno passende Regeln über autogen, für initContainers erweiterst du den Ausdruck.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

cd ~/secrets-lab/tag14
bao audit list -format=json | jq -e '."stdout/"' >/dev/null \
  && echo "✔ Audit-Device stdout/" || echo "✘ kein Audit-Device"
bao policy read ns-read >/dev/null 2>&1 \
  && echo "✔ Policy-Template ns-read" || echo "✘ ns-read fehlt"
J=$(kubectl -n blog create token blog-api --audience=openbao)
T=$(bao write -field=token auth/kubernetes/login role=ns-apps jwt="$J")
[ "$(bao token capabilities "$T" secret/data/shop/api)" = "deny" ] \
  && echo "✔ blog liest nicht bei shop" || echo "✘ Mandantentrennung kaputt"
[ "$(bao read -field=max_lease_ttl sys/auth/kubernetes/tune)" = "3600" ] \
  && echo "✔ max TTL kubernetes/ = 1h" || echo "✘ max TTL nicht gesetzt"
kubectl -n openbao logs openbao-0 | grep -q 'kubernetes-blog-blog-api' \
  && echo "✔ Login von blog-api im Audit-Log" || echo "✘ Audit-Eintrag fehlt"

Challenge

Team shop will, dass jede App nur ihren eigenen Unterpfad liest: secret/shop/shop-api/* für shop-api, nicht aber secret/shop/other-app/*. Baue ein zweites Template und eine Rolle ns-sa-apps, die nur dieses Template nutzt.

Hinweis: Der Entity-Alias kennt neben dem Namespace auch service_account_name.

Lösung

bao policy write ns-sa-read - <<EOF
path "secret/data/{{$M.service_account_namespace}}/{{$M.service_account_name}}/*" {
  capabilities = ["read"]
}
EOF
bao kv put secret/shop/shop-api/db pw=lab-x >/dev/null
bao kv put secret/shop/other-app/db pw=lab-y >/dev/null
bao write auth/kubernetes/role/ns-sa-apps \
  bound_service_account_names=shop-api,blog-api \
  bound_service_account_namespaces=shop,blog \
  audience=openbao token_policies=ns-sa-read token_ttl=10m
J=$(kubectl -n shop create token shop-api --audience=openbao)
T=$(bao write -field=token auth/kubernetes/login role=ns-sa-apps jwt="$J")
for p in shop/shop-api/db shop/other-app/db shop/api; do
  echo "$p: $(bao token capabilities "$T" secret/data/$p)"
done

Erwartet:

Success! Uploaded policy: ns-sa-read
Success! Data written to: auth/kubernetes/role/ns-sa-apps
shop/shop-api/db: read
shop/other-app/db: deny
shop/api: deny

$M stammt aus Drill 3. In einer neuen Shell setzt du ACC und M vorher erneut.

Aufräumen für Tag 15:

kubectl -n shop delete rolebinding support-view
kubectl -n shop delete serviceaccount support
kubectl delete namespace blog

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Audit-Devices gehören in die Server-Konfiguration, mit mindestens zwei Zielen. Fällt das einzige Device aus, beantwortet OpenBao keine Anfragen mehr.
  • Leite das Audit-Log ins SIEM und alarmiere auf Muster: viele 403 für eine Identität, Zugriffe auf sys/, Logins mit Root-Token.
  • Teste Policies in CI mit bao token capabilities gegen eine Wegwerf-Instanz, bevor sie produktiv gehen.
  • Schaffe den Root-Token nach dem Bootstrap ab und erzeuge ihn nur im Notfall per Quorum neu (siehe „OpenBao zum Anfassen”).
  • Setze Kyverno-Regeln zuerst mit validationActions: [Audit] auf und schalte erst nach Auswertung der Policy Reports auf Deny.