Tag 10: Secrets verschlüsseln
Ziel: Du zeigst, dass Secrets im Klartext in etcd liegen, aktivierst Encryption at Rest im API-Server, verschlüsselst alle vorhandenen Secrets neu und rotierst den Schlüssel. · Dauer: ca. 60 min · Voraussetzung: Tag 6
Briefing
- CKS: Minimize Microservice Vulnerabilities – „Manage Kubernetes secrets“.
- Ein Secret ist nur base64-kodiert. Wer etcd lesen kann (Backup,
Snapshot, Zertifikat aus
/etc/kubernetes/pki), hat alle Passwörter. - Die
EncryptionConfigurationsagt dem API-Server, welche Ressourcen er vor dem Schreiben verschlüsselt. Der erste Provider schreibt, alle Provider lesen. - Bestehende Objekte bleiben unverschlüsselt, bis sie neu geschrieben werden.
k create secret --> kube-apiserver --(1. Provider: aescbc, key2)--> etcd
^ k8s:enc:aescbc:v1:key2:...
+-- /etc/kubernetes/enc/enc.yaml (hostPath, nur root)
mkdir -p ~/cks/tag10/backup && cd ~/cks/tag10
k create ns tag10
k config set-context --current --namespace=tag10Drill 1: etcdctl bereitstellen
Der etcd-Pod bringt etcdctl mit. Für die Arbeit auf
cp1 ist ein eigenes Binary in der Version des Servers
bequemer:
k -n kube-system get pod etcd-cp1 -o jsonpath='{.spec.containers[0].image}{"\n"}'
V=v3.7.0
B=https://github.com/etcd-io/etcd/releases/download/$V
ARCH=$(dpkg --print-architecture)
curl -sLO $B/etcd-$V-linux-${ARCH}.tar.gz
curl -sL $B/SHA256SUMS \
| grep linux-${ARCH}.tar.gz | sha256sum -c
tar xzf etcd-$V-linux-${ARCH}.tar.gz
sudo install etcd-$V-linux-${ARCH}/etcdctl /usr/local/bin/
etcdctl versionErwartet:
registry.k8s.io/etcd:3.7.0-0
etcd-v3.7.0-linux-amd64.tar.gz: OK
etcdctl version: 3.7.0
API version: 3.7
ETCDCTL_API=3 brauchst du nicht mehr. Zum Anmelden taugt
das Client-Zertifikat, mit dem auch der API-Server spricht:
P=/etc/kubernetes/pki
E="--cacert=$P/etcd/ca.crt --cert=$P/apiserver-etcd-client.crt"
E="$E --key=$P/apiserver-etcd-client.key"Ohne eigenes Binary geht es im etcd-Pod (dort mit
server.crt/server.key):
k -n kube-system exec etcd-cp1 -- etcdctl --cacert=/etc/kubernetes/pki/etcd/ca.crt \
--cert=/etc/kubernetes/pki/etcd/server.crt --key=/etc/kubernetes/pki/etcd/server.key \
get /registry/secrets/kube-system --prefix --keys-only | head -1Erwartet: eine Zeile
/registry/secrets/kube-system/…
Fortschritt speichern? Kostenlos registrieren
Drill 2: Secret im Klartext in etcd
k create secret generic db-cred --from-literal=password=Lab-Geheim-42
sudo etcdctl $E get /registry/secrets/tag10/db-cred --print-value-only \
| hexdump -C | grep -A1 passwordErwartet (gekürzt):
000000e0 65 22 3a 7b 7d 7d 42 00 12 19 0a 08 70 61 73 73 |e":{}}B.....pass|
000000f0 77 6f 72 64 12 0d 4c 61 62 2d 47 65 68 65 69 6d |word..Lab-Geheim|
00000100 2d 34 32 1a 06 4f 70 61 71 75 65 1a 00 22 00 0a |-42..Opaque.."..|
Lab-Geheim-42 (ein reiner Lab-Wert) steht
unverschlüsselt im Protobuf-Objekt – nicht einmal base64. Jedes
etcd-Backup enthält es genauso.
Fortschritt speichern? Kostenlos registrieren
Drill 3: EncryptionConfiguration anlegen
Ein Schlüssel für aescbc ist 32 zufällige Bytes,
base64-kodiert:
sudo mkdir -p /etc/kubernetes/enc
K1=$(head -c 32 /dev/urandom | base64)
sudo tee /etc/kubernetes/enc/enc.yaml >/dev/null <<EOF
apiVersion: apiserver.config.k8s.io/v1
kind: EncryptionConfiguration
resources:
- resources:
- secrets
providers:
- aescbc:
keys:
- name: key1
secret: $K1
- identity: {}
EOF
sudo chmod 600 /etc/kubernetes/enc/enc.yaml
sudo ls -l /etc/kubernetes/encErwartet:
-rw------- 1 root root 239 Nov 18 18:19 enc.yaml
Hier bewusst <<EOF ohne Anführungszeichen, damit
die Shell $K1 einsetzt. identity steht
zuletzt: Es schreibt Klartext, liest aber die alten,
unverschlüsselten Secrets. Statt aescbc geht
secretbox (gleiche Schlüssellänge; die Doku stuft
aescbc wegen CBC als schwach ein und zieht
secretbox vor); aesgcm ist schnell, verlangt
aber Rotation alle 200 000 Schreibvorgänge. In Produktion empfiehlt die
Doku kms (v2) mit externem Schlüsseldienst.
Fortschritt speichern? Kostenlos registrieren
Drill 4: API-Server einschalten
M=/etc/kubernetes/manifests
sudo cp $M/kube-apiserver.yaml ~/cks/tag10/backup/
sudo vim $M/kube-apiserver.yamlFlag, Mount und Volume ergänzen – die Einträge aus Tag 6 bleiben:
- --encryption-provider-config=/etc/kubernetes/enc/enc.yaml
# unter volumeMounts:
- mountPath: /etc/kubernetes/enc
name: enc
readOnly: true
# unter volumes:
- hostPath:
path: /etc/kubernetes/enc
type: Directory
name: encsudo diff ~/cks/tag10/backup/kube-apiserver.yaml $M/kube-apiserver.yamlErwartet:
43a44
> - --encryption-provider-config=/etc/kubernetes/enc/enc.yaml
83a85,87
> - mountPath: /etc/kubernetes/enc
> name: enc
> readOnly: true
108a113,116
> - hostPath:
> path: /etc/kubernetes/enc
> type: Directory
> name: enc
Nach etwa einer Minute:
k -n kube-system get pod kube-apiserver-cp1
k get --raw /readyz; echoErwartet:
NAME READY STATUS RESTARTS AGE
kube-apiserver-cp1 1/1 Running 0 37s
ok
Startet er nicht, zeigt
sudo crictl ps -a --name kube-apiserver den Container und
sudo crictl logs <id> den Grund (Tippfehler im YAML,
fehlendes Volume).
Fortschritt speichern? Kostenlos registrieren
Drill 5: Nachweis und Neuschreiben
k create secret generic api-key --from-literal=key=Lab-Neu-99
for s in db-cred api-key; do
sudo etcdctl $E get /registry/secrets/tag10/$s --print-value-only \
| head -c 23 | hexdump -C | head -1
done
k get secret api-key -o jsonpath='{.data.key}' | base64 -d; echoErwartet:
00000000 6b 38 73 00 0a 0c 0a 02 76 31 12 06 53 65 63 72 |k8s.....v1..Secr|
00000000 6b 38 73 3a 65 6e 63 3a 61 65 73 63 62 63 3a 76 |k8s:enc:aescbc:v|
Lab-Neu-99
Das neue Secret beginnt mit k8s:enc:aescbc:v1:key1:, das
alte ist noch Klartext. Für k ändert sich nichts – der
API-Server entschlüsselt transparent. Alle Secrets neu schreiben:
k get secrets -A -o json | k replace -f - | tail -2
sudo etcdctl $E get /registry/secrets --prefix --keys-only | grep -c .
sudo etcdctl $E get /registry/secrets --prefix --print-value-only \
| grep -ac "^k8s:enc:aescbc"Erwartet:
secret/db-cred replaced
secret/sh.helm.release.v1.traefik.v1 replaced
9
9
Gleich viele Schlüssel wie verschlüsselte Werte: Kein Secret liegt mehr im Klartext. Die Zahl hängt von deinem Cluster ab – wichtig ist, dass beide Werte gleich sind.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Schlüssel rotieren
Neuen Schlüssel vor den alten setzen –
key2 schreibt, key1 liest noch:
sudo cp /etc/kubernetes/enc/enc.yaml ~/cks/tag10/backup/enc-key1.yaml
K2=$(head -c 32 /dev/urandom | base64)
sudo sed -i "s| keys:|&\n - name: key2\n secret: $K2|" \
/etc/kubernetes/enc/enc.yaml
sudo grep -A5 "keys:" /etc/kubernetes/enc/enc.yaml | grep nameErwartet:
- name: key2
- name: key1
Der API-Server liest die Datei nur beim Start. Achtung:
k delete pod kube-apiserver-cp1 löscht nur den Mirror-Pod,
der Container läuft weiter. Neu starten über die Runtime:
sudo crictl stop $(sudo crictl ps --name kube-apiserver -q)
k -n kube-system get pod kube-apiserver-cp1Erwartet (nach etwa einer Minute):
NAME READY STATUS RESTARTS AGE
kube-apiserver-cp1 1/1 Running 1 (51s ago) 2m4s
k get secrets -A -o json | k replace -f - >/dev/null
sudo etcdctl $E get /registry/secrets --prefix --print-value-only \
| grep -ac "k8s:enc:aescbc:v1:key2"Erwartet:
11
Erst jetzt, wenn alles mit key2 geschrieben ist,
key1 entfernen und noch einmal neu starten:
sudo sed -i "/name: key1/,+1d" /etc/kubernetes/enc/enc.yaml
sudo crictl stop $(sudo crictl ps --name kube-apiserver -q)Warte, bis k get --raw /readyz wieder ok
meldet (ca. 1 min):
k get secret db-cred -o jsonpath='{.data.password}' | base64 -d; echoErwartet:
Lab-Geheim-42
Wer key1 vor dem Neuschreiben löscht, macht alle damit
verschlüsselten Secrets unlesbar. Bei mehreren API-Servern gibt es einen
Zwischenschritt: neuen Schlüssel zuerst überall an zweiter Stelle
eintragen.
Fortschritt speichern? Kostenlos registrieren
Drill 7: Upgradefest und Secrets im Pod
Wie in Tag 6 gehört das Flag in kubeadm-config, sonst
löscht es kubeadm upgrade:
k -n kube-system edit cm kubeadm-configUnter apiServer ergänzen:
extraArgs:
# ... profiling, authentication-config bleiben
- name: encryption-provider-config
value: /etc/kubernetes/enc/enc.yaml
extraVolumes:
- hostPath: /etc/kubernetes/enc
mountPath: /etc/kubernetes/enc
name: enc
pathType: Directory
readOnly: truesudo kubeadm upgrade diff v1.37.2 | grep -c -- "--encryption-provider-config"Erwartet:
0
Das Flag wird nicht mehr entfernt (der Rest des Diffs ist nur Reihenfolge). Und im Pod? Ein Secret als Umgebungsvariable landet in der Container-Konfiguration:
cat > pod-secret.yaml <<'EOF'
apiVersion: v1
kind: Pod
metadata:
name: app
spec:
containers:
- name: app
image: docker.io/library/busybox:1.37
command: ["sleep", "3600"]
env:
- name: DB_PASSWORD
valueFrom:
secretKeyRef:
name: db-cred
key: password
volumeMounts:
- name: cred
mountPath: /etc/cred
readOnly: true
volumes:
- name: cred
secret:
secretName: db-cred
defaultMode: 0400
EOF
k apply -f pod-secret.yaml
k wait --for=condition=Ready pod/app
k get pod app -o jsonpath='{.spec.nodeName}{"\n"}'
k exec app -- sh -c "mount | grep /etc/cred; ls -lL /etc/cred"Erwartet (gekürzt):
worker2
tmpfs on /etc/cred type tmpfs (ro,relatime,size=3907440k,inode64,noswap)
-r-------- 1 root root 13 Nov 18 18:24 password
Auf worker2 (ssh [email protected]):
C=$(sudo crictl ps --name app -q --label io.kubernetes.pod.namespace=tag10)
sudo crictl inspect $C | grep DB_PASSWORDErwartet:
"key": "DB_PASSWORD",
"DB_PASSWORD=Lab-Geheim-42",
Die Variable steht im Klartext in der Runtime-Konfiguration, vererbt
sich an jeden Kindprozess und taucht in Crash-Dumps auf. Das Volume
liegt im RAM (tmpfs), ist nur für den Container lesbar und
wird bei Änderung des Secrets aktualisiert – vorziehen.
Fortschritt speichern? Kostenlos registrieren
Übung: Speed-Drills
- Welche Datei nutzt der API-Server für Encryption at Rest? Zeitziel: 15 s
- Welcher Provider verschlüsselt neue Secrets? Zeitziel: 20 s
- Ist
tag10/api-keyin etcd verschlüsselt, und mit welchem Schlüssel? Zeitziel: 45 s - Erzeuge einen gültigen Schlüssel für
aescbcodersecretbox. Zeitziel: 10 s
Lösung
sudo grep -- --encryption-provider /etc/kubernetes/manifests/kube-apiserver.yaml
sudo grep -A2 "providers:" /etc/kubernetes/enc/enc.yaml
sudo etcdctl $E get /registry/secrets/tag10/api-key --print-value-only \
| head -c 23; echo
head -c 32 /dev/urandom | base64Erwartet (Schlüssel zufällig):
- --encryption-provider-config=/etc/kubernetes/enc/enc.yaml
providers:
- aescbc:
keys:
k8s:enc:aescbc:v1:key2:
yjnOuN73vFOYidBvGl0BosfFvLnuA4287Zy1g5xNsKY=
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
k get --raw /readyz; echoErwartet: ok
sudo grep -c -- "--encryption-provider-config" \
/etc/kubernetes/manifests/kube-apiserver.yamlErwartet: 1
sudo etcdctl $E get /registry/secrets/tag10/db-cred --print-value-only \
| head -c 23; echoErwartet: k8s:enc:aescbc:v1:key2:
k -n kube-system get cm kubeadm-config -o yaml | grep -c "/etc/kubernetes/enc"Erwartet: 3 (Flag,
hostPath, mountPath)
Nach der Challenge aufräumen: k delete ns tag10 und
k config set-context --current --namespace=default. Im
Labor bleibt die Verschlüsselung mit key2
aktiv – Flag, Volume, /etc/kubernetes/enc/enc.yaml und der
Eintrag in kubeadm-config. Tag 15 und Tag 19 bauen darauf
auf.
Challenge
Ein Kollege hat in enc.yaml „nur die Reihenfolge
aufgeräumt“. Stelle es nach, weise nach, dass neue Secrets wieder im
Klartext landen, und repariere es.
sudo cp /etc/kubernetes/enc/enc.yaml ~/cks/tag10/backup/enc-key2.yaml
sudo sed -i -e "/ - identity: {}/d" -e "s|^ providers:|&\n - identity: {}|" \
/etc/kubernetes/enc/enc.yaml
sudo crictl stop $(sudo crictl ps --name kube-apiserver -q)Hinweis: Vergleiche die Zahl der Secret-Schlüssel in etcd mit der Zahl der verschlüsselten Werte.
Lösung
Warte, bis k get --raw /readyz wieder ok
meldet (ca. 1 min):
k create secret generic token --from-literal=t=Lab-Token-7
sudo etcdctl $E get /registry/secrets --prefix --keys-only | grep -c .
sudo etcdctl $E get /registry/secrets --prefix --print-value-only \
| grep -ac "^k8s:enc:aescbc"
sudo grep -A1 "providers:" /etc/kubernetes/enc/enc.yamlErwartet:
secret/token created
12
11
providers:
- identity: {}
Ein Secret zu wenig verschlüsselt, identity steht vorn
und schreibt Klartext. Die alten Secrets bleiben lesbar, weil
aescbc weiter als Lese-Provider dient – darum fällt der
Fehler sonst niemandem auf. Reparieren:
sudo cp ~/cks/tag10/backup/enc-key2.yaml /etc/kubernetes/enc/enc.yaml
sudo crictl stop $(sudo crictl ps --name kube-apiserver -q)Warte, bis k get --raw /readyz wieder ok
meldet (ca. 1 min):
k get --raw /readyz; echo
k get secrets -A -o json | k replace -f - >/dev/null
sudo etcdctl $E get /registry/secrets/tag10/token --print-value-only | head -c 23; echoErwartet:
ok
k8s:enc:aescbc:v1:key2:
Fortschritt speichern? Kostenlos registrieren
Prüfungstipp
- Drei Teile, alle nötig:
EncryptionConfiguration, Flag--encryption-provider-config, hostPath-Volume samt Mount. Danachk get secrets -A -o json | k replace -f -, sonst bleibt der Bestand Klartext. - Typische Falle:
identityan erster Stelle oder ein Schlüssel nicht 32 Byte lang (head -c 32 /dev/urandom | base64). Pod1/1 Readyabwarten. - Doku: kubernetes.io → Tasks → Administer a Cluster → „Encrypting Confidential Data at Rest“ (Beispiel-YAML und etcdctl-Nachweis zum Kopieren).
Enterprise-Notiz
- Den Schlüssel nicht neben etcd liegen lassen:
kmsv2 mit Vault, Cloud-KMS oder HSM; der API-Server sieht dann nur noch einen Datenschlüssel. - etcd-Backups ohne
enc.yaml(oder KMS-Zugang) sind wertlos – Schlüssel getrennt und ebenso sicher sichern. - Managed Kubernetes (EKS, GKE, AKS) bietet Envelope Encryption per Cloud-KMS als Schalter; Rotation dort per KMS-Richtlinie.
- Secrets gar nicht erst im Cluster speichern: External Secrets Operator oder Secrets Store CSI Driver holen sie zur Laufzeit aus Vault oder dem Cloud-Tresor.
- RBAC auf
secretseng halten – werget secretsdarf, liest trotz Verschlüsselung alles im Klartext.