Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 2: Maschinen-Identität

Ziel: Verstehen und ausprobieren, wie ein Pod sich bei OpenBao ausweist: mit Kubernetes-Auth, mit JWT-Auth gegen den Cluster-Issuer und mit Policies, die sich nach dem Namespace richten. · Dauer: ca. 75 min · Voraussetzung: Tag 1

Briefing

  • Ein Pod hat kein Passwort, aber einen ServiceAccount-Token (JWT), signiert vom API-Server.
  • Kubernetes-Auth fragt den API-Server per TokenReview: „Ist dieser Token gültig?”
  • JWT-Auth prüft nur die Signatur mit dem öffentlichen Schlüssel, ohne Rückfrage.
  • Die Rolle entscheidet, welcher ServiceAccount, Namespace und welche Audience passen.
  • Policy-Templating spart eine Policy pro Namespace.
 Pod (SA shop-api)                OpenBao                     API-Server
   │ 1. JWT (aud=openbao) ──────►  kubernetes/login
   │                                 │ 2. TokenReview ──────────► gültig? SA? NS?
   │                                 │ ◄──────────────────────── ok
   │ ◄──── 3. OpenBao-Token (15m, Policy shop-api-read)

Drill 1: Anatomie der Kubernetes-Auth

cd ~/secrets-lab/tag02
bao read auth/kubernetes/config
bao read auth/kubernetes/role/shop-api

Erwartet (gekürzt):

Key                       Value
---                       -----
disable_iss_validation    true
disable_local_ca_jwt      false
kubernetes_ca_cert        n/a
kubernetes_host           https://kubernetes.default.svc:443
token_reviewer_jwt_set    false
Key                                         Value
---                                         -----
alias_name_source                           serviceaccount_uid
audience                                    openbao
bound_service_account_names                 [shop-api]
bound_service_account_namespace_selector    n/a
bound_service_account_namespaces            [shop]
token_max_ttl                               1h
token_policies                              [shop-api-read]
token_ttl                                   15m

Kein CA-Zertifikat, kein Reviewer-Token gesetzt? Richtig: Läuft OpenBao im Cluster, nimmt es beides aus seinem eigenen Pod (disable_local_ca_jwt=false). Damit OpenBao TokenReviews stellen darf, braucht sein ServiceAccount die ClusterRole system:auth-delegator. Das Helm-Chart bringt die Bindung mit:

kubectl get clusterrolebinding openbao-openbao-server-binding -o wide

Erwartet (gekürzt):

NAME                             ROLE                                ... SERVICEACCOUNTS
openbao-openbao-server-binding   ClusterRole/system:auth-delegator   ... openbao/openbao

Fortschritt speichern? Kostenlos registrieren

Drill 2: Projizierte Tokens unter der Lupe

Ein JWT ist Base64. jq kann ihn dekodieren:

kubectl -n shop create token shop-api --audience openbao --duration 10m \
  | jq -R 'split(".")[1] | @base64d | fromjson'

Erwartet:

{
  "aud": [
    "openbao"
  ],
  "exp": 1791786622,
  "iat": 1791786022,
  "iss": "https://kubernetes.default.svc.cluster.local",
  "jti": "94a61af1-24cf-4a20-ae5c-7bb5ce6bd49d",
  "kubernetes.io": {
    "namespace": "shop",
    "serviceaccount": {
      "name": "shop-api",
      "uid": "10fceaf2-b96b-4f72-9a1f-a51222b20440"
    }
  },
  "nbf": 1791786022,
  "sub": "system:serviceaccount:shop:shop-api"
}

Zum Vergleich der Token ohne --audience und ein zu kurzer Token:

kubectl -n shop create token shop-api \
  | jq -R 'split(".")[1] | @base64d | fromjson | {aud, gueltig_s: (.exp - .iat)}'
kubectl -n shop create token shop-api --audience openbao --duration 5m

Erwartet (umbrochen):

{
  "aud": [
    "https://kubernetes.default.svc.cluster.local"
  ],
  "gueltig_s": 3600
}
error: failed to create token: TokenRequest.authentication.k8s.io "" is invalid:
  spec.expirationSeconds: Invalid value: 300: may not specify a duration less than
  10 minutes

Warum projizierte Tokens? Sie laufen ab (exp), gelten nur für eine Audience (aud) und sind an Pod und ServiceAccount gebunden. Die alten Token-Secrets liefen nie ab und galten für jeden Empfänger. Ein Token mit aud=openbao ist für den API-Server selbst wertlos, und ein Token für den API-Server wird von OpenBao abgelehnt.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Fehlerbilder kennenlernen

Jeder dieser Fehler begegnet dir später in ESO, Injector oder CSI wieder, nur versteckter. Hier siehst du ihn im Klartext:

kubectl create namespace evil
kubectl -n evil create serviceaccount shop-api
kubectl -n shop create serviceaccount other
login() { bao write auth/kubernetes/login role="$1" jwt="$2" 2>&1 | grep '^\* '; }
login shop-api "$(kubectl -n shop create token shop-api)"
login shop-api "$(kubectl -n shop create token shop-api --audience vault)"
login shop-api "$(kubectl -n evil create token shop-api --audience openbao)"
login shop-api "$(kubectl -n shop create token other --audience openbao)"
login nope     "$(kubectl -n shop create token shop-api --audience openbao)"
login shop-api "abc.def.ghi"

Erwartet (umbrochen):

namespace/evil created
serviceaccount/shop-api created
serviceaccount/other created
* invalid audience (aud) claim: audience claim does not match any expected
  audience
* invalid audience (aud) claim: audience claim does not match any expected
  audience
* namespace not authorized
* service account name not authorized
* invalid role name "nope"
* permission denied
Meldung Ursache Abhilfe
invalid audience (aud) claim Token ohne/mit falscher Audience audience in Token und Rolle angleichen
namespace not authorized Namespace nicht in der Rolle bound_service_account_namespaces
service account name not authorized anderer ServiceAccount bound_service_account_names
invalid role name Tippfehler in der Rolle bao list auth/kubernetes/role
permission denied TokenReview sagt nein Token kaputt, abgelaufen, SA/Pod gelöscht

Gleicher ServiceAccount-Name in einem anderen Namespace (evil/shop-api) bringt nichts: OpenBao prüft beides.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Login aus dem Pod per curl

So sieht es aus, wenn kein Werkzeug hilft: ein Pod mit einem projizierten Token für openbao, sonst nichts. Das automatische API-Server-Token ist aus.

cat > login-pod.yaml <<'EOF'
# Pod mit projiziertem SA-Token für OpenBao (Audience openbao, 10 min gültig)
apiVersion: v1
kind: Pod
metadata:
  name: login-test
  namespace: shop
spec:
  serviceAccountName: shop-api
  automountServiceAccountToken: false
  containers:
    - name: curl
      image: curlimages/curl:8.22.0
      command: ["sleep", "3600"]
      volumeMounts:
        - name: bao-token
          mountPath: /var/run/secrets/openbao
          readOnly: true
  volumes:
    - name: bao-token
      projected:
        sources:
          - serviceAccountToken:
              path: token
              audience: openbao
              expirationSeconds: 600
EOF
kubectl apply -f login-pod.yaml
kubectl -n shop wait --for=condition=Ready pod/login-test --timeout=180s

Erwartet:

pod/login-test created
pod/login-test condition met

Jetzt im Pod: einloggen, Token herausschneiden, Secret lesen. Das Image hat kein jq, also hilft sed.

kubectl -n shop exec -i login-test -- sh <<'EOF'
BAO=http://openbao.openbao.svc:8200
JWT=$(cat /var/run/secrets/openbao/token)
curl -s -X POST "$BAO/v1/auth/kubernetes/login" \
  -d "{\"role\":\"shop-api\",\"jwt\":\"$JWT\"}" > /tmp/login.json
TOKEN=$(sed 's/.*"client_token":"\([^"]*\)".*/\1/' /tmp/login.json)
echo "Token: $(echo "$TOKEN" | cut -c1-6)…"
curl -s -H "X-Vault-Token: $TOKEN" "$BAO/v1/secret/data/shop/api" \
  | grep -o '"data":{"api_key[^}]*}'
EOF

Erwartet:

Token: s.jW3y…
"data":{"api_key":"lab-api-key-456","db_password":"lab-db-pw-123","db_user":"shop"}

Das Kubelet erneuert die Datei /var/run/secrets/openbao/token automatisch vor Ablauf. Eine Anwendung liest sie deshalb bei jedem Login neu, statt sie einmal zu cachen.

Fortschritt speichern? Kostenlos registrieren

Drill 5: JWT-Auth gegen den Cluster-Issuer

JWT-Auth prüft den Token offline mit dem öffentlichen Schlüssel des API-Servers. In kind liegt er auf dem Node:

docker exec secrets-lab-control-plane cat /etc/kubernetes/pki/sa.pub > sa.pub
bao auth enable -path=jwt-k8s jwt
bao write auth/jwt-k8s/config [email protected] \
  bound_issuer="https://kubernetes.default.svc.cluster.local"

Erwartet:

Success! Enabled jwt auth method at: jwt-k8s/
Success! Data written to: auth/jwt-k8s/config

Die Rolle bindet über Claims. Verschachtelte Claims wie kubernetes.io/namespace adressierst du per JSON-Pointer, deshalb schreibst du die Rolle als JSON:

bao write auth/jwt-k8s/role/shop-api - <<'EOF'
{
  "role_type": "jwt",
  "user_claim": "sub",
  "bound_audiences": ["openbao"],
  "bound_subject": "system:serviceaccount:shop:shop-api",
  "claim_mappings": {
    "/kubernetes.io/namespace": "namespace",
    "/kubernetes.io/serviceaccount/name": "service_account"
  },
  "token_policies": ["shop-api-read"],
  "token_ttl": "15m"
}
EOF
bao write auth/jwt-k8s/login role=shop-api \
  jwt="$(kubectl -n shop create token shop-api --audience openbao)"

Erwartet (gekürzt):

Success! Data written to: auth/jwt-k8s/role/shop-api
Key                           Value
---                           -----
token                         s.fls6hMZlkxq7FoJVuz655AOo
token_duration                15m
token_policies                ["default" "shop-api-read"]
token_meta_namespace          shop
token_meta_role               shop-api
token_meta_service_account    shop-api

Die Fehler klingen ähnlich, kommen aber mit Code 400 statt 403:

bao write auth/jwt-k8s/login role=shop-api \
  jwt="$(kubectl -n evil create token shop-api --audience openbao)" 2>&1 | grep '^\* '
bao write auth/jwt-k8s/login role=shop-api \
  jwt="$(kubectl -n shop create token shop-api)" 2>&1 | grep '^\* '

Erwartet (umbrochen):

* error validating token: invalid subject (sub) claim
* error validating token: invalid audience (aud) claim: audience claim does not match
  any expected audience

Variante ohne festen Schlüssel: OpenBao holt die Schlüssel per OIDC-Discovery vom API-Server und bekommt so Key-Rotationen mit. Der API-Server erlaubt Discovery aber nur angemeldeten Clients:

kubectl config view --raw --minify \
  -o jsonpath='{.clusters[0].cluster.certificate-authority-data}' \
  | base64 -d > k8s-ca.crt
bao auth enable -path=jwt-oidc jwt
bao write auth/jwt-oidc/config \
  oidc_discovery_url=https://kubernetes.default.svc.cluster.local \
  [email protected] 2>&1 | grep -o 'User.*configuration\\"'

Erwartet:

Success! Enabled jwt auth method at: jwt-oidc/
User \"system:anonymous\" cannot get path \"/.well-known/openid-configuration\"
kubectl create clusterrolebinding oidc-discovery-anonymous \
  --clusterrole=system:service-account-issuer-discovery --group=system:unauthenticated
bao write auth/jwt-oidc/config \
  oidc_discovery_url=https://kubernetes.default.svc.cluster.local \
  [email protected]
bao write auth/jwt-oidc/role/shop-api role_type=jwt user_claim=sub \
  bound_audiences=openbao bound_subject=system:serviceaccount:shop:shop-api \
  token_policies=shop-api-read token_ttl=15m
bao write -field=token_policies auth/jwt-oidc/login role=shop-api \
  jwt="$(kubectl -n shop create token shop-api --audience openbao)"; echo

Erwartet:

clusterrolebinding.rbac.authorization.k8s.io/oidc-discovery-anonymous created
Success! Data written to: auth/jwt-oidc/config
Success! Data written to: auth/jwt-oidc/role/shop-api
[default shop-api-read]

Sicherheit: Die Bindung macht nur Issuer-URL und öffentliche Schlüssel anonym lesbar, keine Secrets. Im Kunden-Cluster trotzdem mit dem Plattform-Team abstimmen.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Pod weg – Token noch gültig?

Der wichtigste Unterschied der beiden Methoden. Ein projizierter Pod-Token ist an den Pod gebunden:

PODJWT=$(kubectl -n shop exec login-test -- cat /var/run/secrets/openbao/token)
echo "$PODJWT" | jq -R 'split(".")[1] | @base64d | fromjson
  | {aud, gueltig_s: (.exp - .iat), pod: ."kubernetes.io".pod.name}'
kubectl -n shop delete pod login-test
bao write auth/kubernetes/login role=shop-api jwt="$PODJWT" 2>&1 | grep '^\* '
bao write -field=token_policies auth/jwt-k8s/login role=shop-api jwt="$PODJWT"; echo

Erwartet:

{
  "aud": [
    "openbao"
  ],
  "gueltig_s": 600,
  "pod": "login-test"
}
pod "login-test" deleted from shop namespace
* permission denied
[default shop-api-read]

Der Pod ist gelöscht. Die TokenReview erkennt das, die reine Signaturprüfung nicht: Bei jwt-k8s/ gilt der Token bis exp. Kurze Laufzeiten sind dort Pflicht.

Kriterium kubernetes/ jwt-k8s/
Prüfung TokenReview beim API-Server Signatur offline (Key/JWKS)
Pod/SA gelöscht sofort ungültig gültig bis exp
Netz zum API-Server bei jedem Login nein (pubkeys) / nur Discovery
Binden über SA-Name, Namespace (Selector) bound_subject, bound_claims
Metadaten fest: service_account_* frei per claim_mappings
Passt für OpenBao im/nahe Cluster viele Cluster, API-Server privat

Fortschritt speichern? Kostenlos registrieren

Drill 7: Policy-Templating

Zehn Namespaces, zehn Policies? Nein: Eine Policy setzt den Namespace aus den Metadaten des Logins ein. Welche Metadaten gibt es? Frag die Identität:

T=$(bao write -field=token auth/kubernetes/login role=shop-api \
  jwt="$(kubectl -n shop create token shop-api --audience openbao)")
EID=$(bao token lookup -format=json "$T" | jq -r '.data.entity_id')
bao read -format=json "identity/entity/id/$EID" \
  | jq '.data.aliases[] | {name, mount_type, metadata}'

Erwartet:

{
  "name": "0c305dd5-720a-43b2-a08d-609287d60948",
  "mount_type": "kubernetes",
  "metadata": {
    "service_account_name": "shop-api",
    "service_account_namespace": "shop",
    "service_account_secret_name": "",
    "service_account_uid": "0c305dd5-720a-43b2-a08d-609287d60948"
  }
}

Der Alias heißt wie die SA-UID (alias_name_source=serviceaccount_uid). Für die Policy brauchst du den Accessor des Mounts:

A=$(bao auth list -format=json | jq -r '."kubernetes/".accessor'); echo "$A"
bao policy write ns-kv-read - <<EOF
path "secret/data/{{identity.entity.aliases.$A.metadata.service_account_namespace}}/*" {
  capabilities = ["read"]
}
EOF
bao write auth/kubernetes/role/ns-default bound_service_account_names='*' \
  bound_service_account_namespaces=shop,lager audience=openbao \
  token_policies=ns-kv-read token_ttl=15m

Erwartet:

auth_kubernetes_9055edbe
Success! Uploaded policy: ns-kv-read
Success! Data written to: auth/kubernetes/role/ns-default

Das unquotierte <<EOF ist Absicht: Die Shell setzt $A ein, die {{…}} bleiben für OpenBao stehen. Jetzt ein zweiter Mandant lager und die Probe über Kreuz:

kubectl create namespace lager
kubectl -n lager create serviceaccount lager-api
bao kv put secret/lager/db password=lab-lager-pw >/dev/null
for x in shop/shop-api lager/lager-api; do
  T=$(bao write -field=token auth/kubernetes/login role=ns-default \
    jwt="$(kubectl -n "${x%/*}" create token "${x#*/}" --audience openbao)")
  for p in shop/api lager/db; do
    printf '%-16s -> %-9s ' "$x" "$p"
    BAO_TOKEN=$T bao kv get "secret/$p" >/dev/null 2>&1 && echo "✔ read" || echo "✘ 403"
  done
done

Erwartet:

namespace/lager created
serviceaccount/lager-api created
shop/shop-api    -> shop/api  ✔ read
shop/shop-api    -> lager/db  ✘ 403
lager/lager-api  -> shop/api  ✘ 403
lager/lager-api  -> lager/db  ✔ read

Eine Rolle, eine Policy, saubere Trennung. Neue Namespaces kommen per bound_service_account_namespaces (oder bound_service_account_namespace_selector) dazu.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

ok() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
tok() { kubectl -n "$1" create token "$2" ${3:+--audience "$3"}; }
ok "Rolle shop-api verlangt Audience openbao" \
  '[ "$(bao read -field=audience auth/kubernetes/role/shop-api)" = openbao ]'
ok "kubernetes/ Login shop-api" \
  'bao write auth/kubernetes/login role=shop-api jwt="$(tok shop shop-api openbao)"'
ok "kubernetes/ lehnt Token ohne Audience ab" \
  '! bao write auth/kubernetes/login role=shop-api jwt="$(tok shop shop-api)"'
ok "jwt-k8s/ Login shop-api" \
  'bao write auth/jwt-k8s/login role=shop-api jwt="$(tok shop shop-api openbao)"'
L=$(bao write -field=token auth/kubernetes/login role=ns-default \
  jwt="$(tok lager lager-api openbao)" 2>/dev/null)
ok "Templating: lager liest lager/db" 'BAO_TOKEN=$L bao kv get secret/lager/db'
ok "Templating: lager liest NICHT shop/api" '! BAO_TOKEN=$L bao kv get secret/shop/api'

Challenge

Bau Drill 7 mit JWT-Auth nach: Eine Rolle ns-default auf jwt-k8s/ lässt jeden ServiceAccount aus shop und lager herein, eine Policy ns-kv-read-jwt erlaubt nur secret/data/<namespace>/*. Ein Token aus evil muss scheitern.

Hinweis: bound_claims filtert den Namespace, claim_mappings macht ihn zu Alias-Metadaten, die Policy liest metadata.namespace am Accessor von jwt-k8s/.

Lösung

J=$(bao auth list -format=json | jq -r '."jwt-k8s/".accessor')
bao policy write ns-kv-read-jwt - <<EOF
path "secret/data/{{identity.entity.aliases.$J.metadata.namespace}}/*" {
  capabilities = ["read"]
}
EOF
bao write auth/jwt-k8s/role/ns-default - <<'EOF'
{
  "role_type": "jwt",
  "user_claim": "sub",
  "bound_audiences": ["openbao"],
  "bound_claims": {"/kubernetes.io/namespace": ["shop", "lager"]},
  "claim_mappings": {"/kubernetes.io/namespace": "namespace"},
  "token_policies": ["ns-kv-read-jwt"],
  "token_ttl": "15m"
}
EOF
T=$(bao write -field=token auth/jwt-k8s/login role=ns-default \
  jwt="$(kubectl -n lager create token lager-api --audience openbao)")
BAO_TOKEN=$T bao kv get -field=password secret/lager/db; echo
BAO_TOKEN=$T bao kv get secret/shop/api 2>&1 | grep -c 'permission denied'
bao write auth/jwt-k8s/login role=ns-default \
  jwt="$(kubectl -n evil create token shop-api --audience openbao)" 2>&1 | grep '^\* '

Erwartet:

Success! Uploaded policy: ns-kv-read-jwt
Success! Data written to: auth/jwt-k8s/role/ns-default
lab-lager-pw
1
* error validating claims: claim "/kubernetes.io/namespace" does not match any
  associated bound claim values

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Pro Cluster ein eigener Auth-Mount (kubernetes-prod-a/, kubernetes-prod-b/), sonst verwechselt OpenBao gleichnamige Namespaces verschiedener Cluster.
  • Läuft OpenBao außerhalb des Clusters, braucht auth/kubernetes/config explizit kubernetes_host, kubernetes_ca_cert und einen Reviewer-Token. Alternative: den Client-Token als Reviewer nutzen, dann braucht jeder Client-SA system:auth-delegator.
  • Audience immer setzen und eindeutig wählen (z. B. openbao-prod), nie die API-Server-Audience akzeptieren.
  • JWT-Auth gegen Managed-Cluster (EKS, GKE, AKS) nutzt deren öffentlichen OIDC-Issuer per oidc_discovery_url, ohne RBAC-Tricks. Token-TTL kurz halten.
  • Templating-Policies sparen Pflege, verlangen aber eine strikte Namespace-Konvention. bound_service_account_names='*' nur zusammen mit fester Namespace-Liste.