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-apiErwartet (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 wideErwartet (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 5mErwartet (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=180sErwartet:
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[^}]*}'
EOFErwartet:
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)"; echoErwartet:
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"; echoErwartet:
{
"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=15mErwartet:
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
doneErwartet:
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/configexplizitkubernetes_host,kubernetes_ca_certund einen Reviewer-Token. Alternative: den Client-Token als Reviewer nutzen, dann braucht jeder Client-SAsystem: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.