Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 1: Secrets lesen

Ziel: KV-v2-Secrets per CLI, JSON und curl lesen, Versionen beherrschen, einen Token mit minimalen Rechten bauen und ein Secret sicher übergeben. · Dauer: ca. 60 min · Voraussetzung: Tag 0

Briefing

  • KV v2 versioniert jedes Secret. Die CLI sagt secret/shop/api, die API trennt in secret/data/… (Inhalt) und secret/metadata/… (Versionen, Metadaten).
  • Policies vergeben Rechte auf API-Pfade, also immer mit data/ oder metadata/.
  • Alles, was nicht erlaubt ist, ist verboten (403).
  • Response Wrapping verpackt eine Antwort in einen Einmal-Token mit kurzer TTL.
 bao kv get secret/shop/api  ──►  GET /v1/secret/data/shop/api
 bao kv metadata get …       ──►  GET /v1/secret/metadata/shop/api
 bao kv list secret/shop     ──►  LIST /v1/secret/metadata/shop

Drill 1: Lesen mit der CLI

cd ~/secrets-lab/tag01
~/secrets-lab/setup/check.sh | grep ✘ || echo "Gelände ok"
bao kv get secret/shop/api

Erwartet:

Gelände ok
==== Secret Path ====
secret/data/shop/api

======= Metadata =======
Key                Value
---                -----
created_time       2026-10-12T06:18:53.346454787Z
custom_metadata    <nil>
deletion_time      n/a
destroyed          false
version            1

======= Data =======
Key            Value
---            -----
api_key        lab-api-key-456
db_password    lab-db-pw-123
db_user        shop

Für Skripte brauchst du meist genau einen Wert:

bao kv get -field=db_password secret/shop/api; echo
bao kv get -mount=secret -field=db_user shop/api; echo
bao kv list secret/shop

Erwartet:

lab-db-pw-123
shop
Keys
----
api
stripe

-field gibt den Wert ohne Zeilenumbruch aus, daher das echo. -mount=secret ist die eindeutige Schreibweise, wenn ein Mount-Name selbst Schrägstriche enthält.

Fortschritt speichern? Kostenlos registrieren

Drill 2: JSON und jq

bao kv get -format=json secret/shop/api | jq -r '.data.data.api_key'
bao kv get -format=json secret/shop/api | jq '.data.metadata'

Erwartet:

lab-api-key-456
{
  "created_time": "2026-10-12T06:18:53.346454787Z",
  "custom_metadata": null,
  "deletion_time": "",
  "destroyed": false,
  "version": 1
}

Merke dir das doppelte .data.data: Das äußere data ist die API-Antwort, das innere sind deine Schlüssel. Genau diese Struktur taucht in ESO, Agent-Templates und hvac wieder auf.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Dieselbe Abfrage per curl

Jede CLI-Abfrage ist ein HTTP-Aufruf. Die CLI verrät ihn dir:

bao kv get -output-curl-string secret/shop/api

Erwartet (umbrochen):

curl -H "X-Vault-Request: true" -H "X-Vault-Token: $(bao print token)"
  "http://127.0.0.1:8200/v1/secret/data/shop/api"

Jetzt selbst, einmal mit Token-Header, einmal mit Bearer-Header, einmal ohne Token:

curl -s -H "X-Vault-Token: $BAO_TOKEN" \
  "$BAO_ADDR/v1/secret/data/shop/api" | jq '.data.data'
curl -s -H "Authorization: Bearer $BAO_TOKEN" \
  "$BAO_ADDR/v1/secret/data/shop/api" | jq -r '.data.data.db_password'
curl -s -w ' HTTP %{http_code}\n' "$BAO_ADDR/v1/secret/data/shop/api"
curl -s -X LIST -H "X-Vault-Token: $BAO_TOKEN" \
  "$BAO_ADDR/v1/secret/metadata/shop" | jq -c '.data'

Erwartet:

{
  "api_key": "lab-api-key-456",
  "db_password": "lab-db-pw-123",
  "db_user": "shop"
}
lab-db-pw-123
{"errors":["permission denied"]}
 HTTP 403
{"keys":["api","stripe"]}

Ohne Token kein Secret, und zwar mit 403, nicht 401. LIST ist eine eigene HTTP-Methode von OpenBao. Alternativ geht GET …?list=true.

Sicherheit: curl -v und set -x schreiben den Token-Header ins Log. In Pipelines beides vermeiden (Tag 14).

Fortschritt speichern? Kostenlos registrieren

Drill 4: patch statt put

Der häufigste KV-Unfall: kv put ersetzt das ganze Secret. Probier es auf einem Spielplatz-Pfad aus, nicht auf den Demo-Daten:

bao kv put secret/shop/playground user=demo password=lab-pw-1 | grep version
bao kv patch secret/shop/playground password=lab-pw-2 | grep version
bao kv get -format=json secret/shop/playground | jq -c '.data.data'
bao kv put secret/shop/playground password=lab-pw-3 | grep version
bao kv get -format=json secret/shop/playground | jq -c '.data.data'

Erwartet:

version            1
version            2
{"password":"lab-pw-2","user":"demo"}
version            3
{"password":"lab-pw-3"}

patch ändert einzelne Schlüssel, put schreibt eine neue Version mit nur den angegebenen Schlüsseln. user ist in Version 3 weg.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Versionen und Metadaten

Zum Glück ist nichts verloren:

bao kv get -version=2 -format=json secret/shop/playground | jq -c '.data.data'
bao kv rollback -version=2 secret/shop/playground | grep version
bao kv get -format=json secret/shop/playground \
  | jq -c '.data | {v: .metadata.version, d: .data}'

Erwartet:

{"password":"lab-pw-2","user":"demo"}
version            4
{"v":4,"d":{"password":"lab-pw-2","user":"demo"}}

rollback kopiert die alte Version als neue Version 4. Die Historie bleibt erhalten. Metadaten hängen am Pfad, nicht an einer Version:

bao kv metadata put -max-versions=5 \
  -custom-metadata=owner=team-shop -custom-metadata=rotation=90d \
  secret/shop/playground
bao kv metadata get -format=json secret/shop/playground \
  | jq '.data | {max_versions, custom_metadata}'

Erwartet:

Success! Data written to: secret/metadata/shop/playground
{
  "max_versions": 5,
  "custom_metadata": {
    "owner": "team-shop",
    "rotation": "90d"
  }
}

Gegen gleichzeitige Schreiber hilft Check-and-Set: Der Schreibvorgang klappt nur, wenn die angegebene Version die aktuelle ist.

bao kv put -cas=3 secret/shop/playground password=x
bao kv put -cas=4 secret/shop/playground user=demo password=lab-pw-5 | grep version

Erwartet (gekürzt):

Error writing data to secret/data/shop/playground: Error making API request.
...
Code: 400. Errors:

* check-and-set parameter did not match the current version
version            5

Fortschritt speichern? Kostenlos registrieren

Drill 6: Ein Token mit minimalen Rechten

Root-Token sind für Menschen im Lab. Eine Anwendung bekommt genau ihre Policy. Welche Policy ein Befehl braucht, verrät die CLI:

bao kv get -output-policy secret/shop/api
bao policy read shop-api-read

Erwartet:

path "secret/data/shop/api" {
  capabilities = ["read"]
}
path "secret/data/shop/*" {
  capabilities = ["read"]
}

Jetzt ein Token, der nur shop-api-read hat:

APP_TOKEN=$(bao token create -policy=shop-api-read -ttl=15m -field=token)
bao token lookup -format=json "$APP_TOKEN" | jq -c '.data | {policies, ttl}'
BAO_TOKEN=$APP_TOKEN bao kv get -field=api_key secret/shop/api; echo
BAO_TOKEN=$APP_TOKEN bao kv put secret/shop/api db_user=hacker
BAO_TOKEN=$APP_TOKEN bao kv list secret/shop

Erwartet (gekürzt):

{"policies":["default","shop-api-read"],"ttl":900}
lab-api-key-456
Error writing data to secret/data/shop/api: Error making API request.

URL: PUT http://127.0.0.1:8200/v1/secret/data/shop/api
Code: 403. Errors:

* 1 error occurred:
    * permission denied
Error listing secret/metadata/shop: Error making API request.

URL: GET http://127.0.0.1:8200/v1/secret/metadata/shop?list=true
Code: 403. Errors:
...

Lesen klappt, Schreiben und Auflisten nicht: list braucht eine Regel auf secret/metadata/…. Die Policy default hängt an jedem Token und erlaubt nur Selbstverwaltung (eigenen Token nachschlagen, erneuern, widerrufen).

Fortschritt speichern? Kostenlos registrieren

Drill 7: Rechte prüfen, ohne zu raten

for p in secret/data/shop/api secret/data/shop/playground \
         secret/metadata/shop/api secret/data/ci/deploy; do
  printf '%-30s %s\n' "$p" "$(bao token capabilities "$APP_TOKEN" "$p")"
done

Erwartet:

secret/data/shop/api           read
secret/data/shop/playground    read
secret/metadata/shop/api       deny
secret/data/ci/deploy          deny

Zeile 2 ist die Lektion: shop/* erlaubt auch den Spielplatz. Ein * in einer Policy deckt alles ab, was dort später einmal angelegt wird. Ohne Token-Argument prüft bao token capabilities <pfad> den eigenen Token.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Response Wrapping zur sicheren Übergabe

Du musst einem Kollegen oder einem Deploy-Job ein Secret geben, ohne dass es im Chat oder im Ticket liegt. Lösung: Wrapping-Token, einmal einlösbar, kurze TTL.

WRAP=$(bao kv get -wrap-ttl=5m -format=json secret/shop/stripe \
  | jq -r '.wrap_info.token')
bao write sys/wrapping/lookup token="$WRAP"

Erwartet:

Key              Value
---              -----
creation_path    secret/data/shop/stripe
creation_time    2026-10-12T06:19:41.138587204Z
creation_ttl     5m

Der Empfänger braucht keinen eigenen Token, nur den Wrapping-Token:

BAO_TOKEN=$WRAP bao unwrap -format=json | jq -c '.data.data'
BAO_TOKEN=$WRAP bao unwrap

Erwartet (gekürzt):

{"token":"lab-stripe-789"}
Error unwrapping: Error making API request.

URL: PUT http://127.0.0.1:8200/v1/sys/wrapping/unwrap
Code: 400. Errors:

* wrapping token is not valid or does not exist

Der zweite Versuch scheitert. Bekommt der echte Empfänger diesen Fehler, hat jemand anderes den Token vorher eingelöst: Alarm statt stillem Leck. Noch wertvoller ist das Wrapping eines Tokens statt eines Secrets, das „Secret Zero” für einen neuen Dienst:

WRAP=$(bao token create -policy=shop-api-read -ttl=1h -wrap-ttl=2m -format=json \
  | jq -r '.wrap_info.token')
NEW=$(BAO_TOKEN=$WRAP bao unwrap -field=token)
bao token lookup -format=json "$NEW" | jq -c '.data | {policies, ttl}'

Erwartet:

{"policies":["default","shop-api-read"],"ttl":3599}

Per curl geht beides mit dem Header X-Vault-Wrap-TTL:

WRAP=$(curl -s -H "X-Vault-Token: $BAO_TOKEN" -H "X-Vault-Wrap-TTL: 120s" \
  "$BAO_ADDR/v1/secret/data/shop/stripe" | jq -r '.wrap_info.token')
curl -s -X POST -H "X-Vault-Token: $WRAP" "$BAO_ADDR/v1/sys/wrapping/unwrap" \
  | jq -c '.data.data'

Erwartet:

{"token":"lab-stripe-789"}

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

T=$(bao token create -policy=shop-api-read -ttl=5m -field=token)
[ "$(bao token capabilities "$T" secret/data/shop/api)" = read ] \
  && echo "✔ shop-api-read darf lesen" || echo "✘ shop-api-read darf nicht lesen"
BAO_TOKEN=$T bao kv put secret/shop/api x=y >/dev/null 2>&1 \
  && echo "✘ shop-api-read darf schreiben!" || echo "✔ Schreiben verboten (403)"
bao kv metadata get -format=json secret/shop/playground 2>/dev/null \
  | jq -e '.data.custom_metadata.owner == "team-shop"' >/dev/null \
  && echo "✔ Metadaten owner=team-shop" || echo "✘ Metadaten fehlen (Drill 5)"
bao kv get -version=2 -field=user secret/shop/playground >/dev/null 2>&1 \
  && echo "✔ Version 2 lesbar" || echo "✘ Version 2 fehlt (Drill 4)"
W=$(bao kv get -wrap-ttl=1m -format=json secret/shop/stripe | jq -r .wrap_info.token)
BAO_TOKEN=$W bao unwrap >/dev/null 2>&1 && ! BAO_TOKEN=$W bao unwrap >/dev/null 2>&1 \
  && echo "✔ Wrapping-Token nur einmal einlösbar" || echo "✘ Wrapping"
bao token revoke "$T" >/dev/null

Challenge

shop-api braucht nur secret/shop/api, nicht secret/shop/stripe und erst recht nicht den Spielplatz. Schreib eine Policy shop-api-strict, die genau das erlaubt, und beweise mit bao token capabilities, dass stripe und metadata verboten sind.

Hinweis: Ohne * wird die Policy länger, aber jede neue Datei unter shop/ bleibt standardmäßig gesperrt.

Lösung

cat > ~/secrets-lab/tag01/shop-api-strict.hcl <<'EOF'
# Nur genau das eine Secret, das shop-api braucht – keine Wildcard
path "secret/data/shop/api" {
  capabilities = ["read"]
}
EOF
bao policy write shop-api-strict ~/secrets-lab/tag01/shop-api-strict.hcl
T=$(bao token create -policy=shop-api-strict -ttl=15m -field=token)
for p in secret/data/shop/api secret/data/shop/stripe secret/metadata/shop/api; do
  printf '%-26s %s\n' "$p" "$(bao token capabilities "$T" "$p")"
done

Erwartet:

Success! Uploaded policy: shop-api-strict
secret/data/shop/api       read
secret/data/shop/stripe    deny
secret/metadata/shop/api   deny

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Policies als Code (HCL im Git, Review per Merge Request), nicht per Hand im UI. Wildcards nur dort, wo ein Team einen eigenen Pfad-Baum besitzt.
  • Pfad-Konvention vorab festlegen, z. B. <mount>/<team>/<app>/<umgebung>. Sie bestimmt, wie schmal Policies werden können.
  • max_versions und delete_version_after bewusst setzen. Alte Versionen sind auch alte, noch gültige Passwörter, solange niemand rotiert.
  • Wrapping-Token mit Minuten-TTL für Übergaben an Menschen und Legacy-Systeme. Der Empfänger prüft mit sys/wrapping/lookup, ob creation_path stimmt.
  • Root-Token werden nach der Einrichtung widerrufen. Admins arbeiten mit eigenen Identitäten, damit das Audit-Log zeigt, wer was gelesen hat (Tag 14).