Zum Inhalt springen
Trainingslager IT-Trainingslager

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 EncryptionConfiguration sagt 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=tag10

Drill 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 version

Erwartet:

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 -1

Erwartet: 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 password

Erwartet (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/enc

Erwartet:

-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.yaml

Flag, 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: enc
sudo diff ~/cks/tag10/backup/kube-apiserver.yaml $M/kube-apiserver.yaml

Erwartet:

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; echo

Erwartet:

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; echo

Erwartet:

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 name

Erwartet:

      - 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-cp1

Erwartet (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; echo

Erwartet:

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-config

Unter 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: true
sudo 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_PASSWORD

Erwartet:

          "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

  1. Welche Datei nutzt der API-Server für Encryption at Rest? Zeitziel: 15 s
  2. Welcher Provider verschlüsselt neue Secrets? Zeitziel: 20 s
  3. Ist tag10/api-key in etcd verschlüsselt, und mit welchem Schlüssel? Zeitziel: 45 s
  4. Erzeuge einen gültigen Schlüssel für aescbc oder secretbox. 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 | base64

Erwartet (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; echo

Erwartet: ok

sudo grep -c -- "--encryption-provider-config" \
  /etc/kubernetes/manifests/kube-apiserver.yaml

Erwartet: 1

sudo etcdctl $E get /registry/secrets/tag10/db-cred --print-value-only \
  | head -c 23; echo

Erwartet: 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.yaml

Erwartet:

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; echo

Erwartet:

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. Danach k get secrets -A -o json | k replace -f -, sonst bleibt der Bestand Klartext.
  • Typische Falle: identity an erster Stelle oder ein Schlüssel nicht 32 Byte lang (head -c 32 /dev/urandom | base64). Pod 1/1 Ready abwarten.
  • 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: kms v2 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 secrets eng halten – wer get secrets darf, liest trotz Verschlüsselung alles im Klartext.