Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 16: Wettkampf – das Leck im Repo

Ziel: Du findest und behebst in acht Runden eingebaute Pannen quer durch das Buch – sops, Regeln, Hook, Sealed Secrets und Shamir – gegen die Uhr und mit Nachweis. · Dauer: ca. 120 min · Voraussetzung: Tag 0–15

Briefing

  • Gespielt wird in einem frischen Klon ~/sops/tag16/klon (nichts wird gepusht) und in den Namespaces tag16 und tag16b.
  • Acht Runden, alle Schichten: Hook, MAC, Recipients, Regeln, Anwenden, Scope, Controller-Schlüssel, Key Groups.
  • Werkzeuge: sops decrypt und seine Meldungen, sops filestatus, updatekeys, yq, git, kubeseal --validate, kubectl get sealedsecret.
  • Jede Runde endet mit einem Beweis-Befehl.
Runde  Symptom                                              Zeitziel
1      git commit: leaks found                              3 min
2      sops: MAC mismatch                                   4 min
3      Kollegin: Group 0: FAILED                            4 min
4      sops: no matching creation rules found               3 min
5      kubectl: illegal base64 data                         3 min
6      SealedSecret: no key could decrypt secret (token)    4 min
7      Secret weg, SealedSecret kann nicht entschlüsseln    6 min
8      Notfall: der Tresor geht nicht auf                   4 min

Spielregeln

  • Pro Runde führt der Schiedsrichter die Schiedsrichter-Befehle aus – ein Kollege oder du selbst, ohne hinzusehen. Dann die Uhr starten.
  • Ursache finden, beheben, mit einem Befehl beweisen. Erst dann Uhr stoppen.
  • Repariere die Ursache, nicht das Symptom: Wer den Hook abschaltet (--no-verify), Klartext committet, --ignore-mac auf eine fremde Datei loslässt oder statt Wiederherstellung neu versiegelt, bekommt null Punkte.
  • Den Hinweis erst lesen, wenn das Zeitziel abgelaufen ist.

Spielfeld

Erst der wichtigste Check: Runde 7 löscht die Controller-Schlüssel. Die Sicherung im Repo muss alle Schlüssel enthalten, die gerade im Cluster liegen.

# auf argo
cd ~/sops/repo
B=$(sops decrypt backup/sealed-secrets-keys.yaml \
  | yq '[.items[].metadata.name] | sort | join(",")')
C=$(kubectl -n kube-system get secret -l sealedsecrets.bitnami.com/sealed-secrets-key \
  -o json | jq -r '[.items[].metadata.name] | sort | join(",")')
echo "$B" | tr ',' '\n' | wc -l
[ "$B" = "$C" ] && echo gleich || echo VERSCHIEDEN

Erwartet (Anzahl bei dir eventuell anders):

4
gleich

Achtung: Steht dort VERSCHIEDEN, erst die Sicherung nachziehen (Tag 13, Kontrollpunkt) – sonst ist Runde 7 echter Datenverlust.

# auf argo
mkdir -p ~/sops/tag16 && cd ~/sops/tag16
git clone -q http://172.16.0.182:30300/lab/secrets.git klon
cd klon && git config core.hooksPath hooks
kubectl create namespace tag16
kubectl create namespace tag16b

Erwartet:

namespace/tag16 created
namespace/tag16b created

Runde 1: Der eilige Commit

Lage: „Nur schnell das Token fürs Webhook-Secret einchecken.“ Der Commit geht nicht durch.

Schiedsrichter-Befehle:

# auf argo
cd ~/sops/tag16/klon
kubectl create secret generic wk -n notes-dev --from-literal=token=lab-wk-123 \
  --dry-run=client -o yaml > dev/wk.yaml
git add dev/wk.yaml

Zeitziel: 3 min

Hinweis: Was steht in der Datei, die gestaged ist – und was sagt filestatus?

Lösung Runde 1

# auf argo
cd ~/sops/tag16/klon
git commit -q -m "Webhook-Token"; echo "rc=$?"
sops filestatus dev/wk.yaml
sops encrypt -i dev/wk.yaml
git add dev/wk.yaml && git commit -q -m "Webhook-Token"; echo "rc=$?"

Erwartet:

6:35PM WRN leaks found: 2
rc=1
{"encrypted":false}
rc=0

gitleaks erkennt das Kubernetes-Secret im Klartext (Tag 9). Verschlüsseln, neu stagen – der Hook prüft den gestagten Stand, nicht die Datei auf der Platte.

Fortschritt speichern? Kostenlos registrieren

Runde 2: Der Umzug

Lage: „Das Secret neu gehört ab heute nach notes-qa. Hab den Namespace geändert, jetzt geht nichts mehr.“

Schiedsrichter-Befehle:

# auf argo
cd ~/sops/tag16/klon
sed -i 's/namespace: notes-dev/namespace: notes-qa/' dev/neu.yaml

Zeitziel: 4 min

Hinweis: Die Änderung ist gewollt. Wer berechnet den MAC neu?

Lösung Runde 2

# auf argo
cd ~/sops/tag16/klon
sops decrypt dev/neu.yaml 2>&1 | cut -c1-20
sops decrypt --ignore-mac dev/neu.yaml \
  | sops encrypt --filename-override dev/neu.yaml /dev/stdin > ~/sops/tag16/neu.yaml
mv ~/sops/tag16/neu.yaml dev/neu.yaml
sops decrypt --extract '["metadata"]["namespace"]' dev/neu.yaml; echo
git commit -q -am "neu nach notes-qa"; echo "rc=$?"

Erwartet:

MAC mismatch. File ha
notes-qa
rc=0

Der MAC deckt den Klartext ab (Tag 3, Tag 14). --ignore-mac ist hier in Ordnung, weil die Änderung bekannt und gewollt ist.

Fortschritt speichern? Kostenlos registrieren

Runde 3: Die vergessene Kollegin

Lage: „Ich hab die Kollegin doch in .sops.yaml eingetragen. Sie kann dev/notes-db.yaml trotzdem nicht öffnen.“

Schiedsrichter-Befehle:

# auf argo
cd ~/sops/tag16/klon
K=$(age-keygen -y ~/sops/tag01/kollegin.key)
yq -i '(.creation_rules[] | select(.path_regex == "^dev/.*\\.yaml$")).age
  += ",'"$K"'"' .sops.yaml
git commit -q -am "Kollegin für dev"

Zeitziel: 4 min

Hinweis: Wen listet die Fehlermeldung – die Recipients der Regel oder der Datei?

Lösung Runde 3

# auf argo
cd ~/sops/tag16/klon
XDG_CONFIG_HOME=/nirgends SOPS_AGE_KEY_FILE=~/sops/tag01/kollegin.key \
  sops decrypt dev/notes-db.yaml 2>&1 | grep -c ': FAILED'
sops updatekeys -y dev/notes-db.yaml >/dev/null 2>&1
XDG_CONFIG_HOME=/nirgends SOPS_AGE_KEY_FILE=~/sops/tag01/kollegin.key \
  sops decrypt --extract '["metadata"]["name"]' dev/notes-db.yaml; echo
git commit -q -am "Kollegin: updatekeys"; echo "rc=$?"

Erwartet:

3
notes-db
rc=0

Drei FAILED: die Gruppe und die zwei Recipients der Datei (du und Argo CD). Die Kollegin steht nur in der Regel; updatekeys überträgt sie in die Datei (Tag 5).

Fortschritt speichern? Kostenlos registrieren

Runde 4: Die Endung

Lage: „Die Cache-Konfiguration lässt sich nicht verschlüsseln. Bei allen anderen Dateien geht es.“

Schiedsrichter-Befehle:

# auf argo
cd ~/sops/tag16/klon
kubectl create secret generic cache -n notes-dev --from-literal=pw=lab-cache-123 \
  --dry-run=client -o yaml > dev/cache.yml

Zeitziel: 3 min

Hinweis: Lies path_regex der dev-Regel Zeichen für Zeichen.

Lösung Runde 4

# auf argo
cd ~/sops/tag16/klon
sops encrypt -i dev/cache.yml 2>&1 | tail -1
yq '.creation_rules[] | select(.path_regex | test("dev")) | .path_regex' .sops.yaml
yq -i '(.creation_rules[] | select(.path_regex == "^dev/.*\\.yaml$")).path_regex
  = "^dev/.*\\.ya?ml$"' .sops.yaml
sops encrypt -i dev/cache.yml && sops filestatus dev/cache.yml
git add .sops.yaml dev/cache.yml && git commit -q -m "cache"; echo "rc=$?"

Erwartet:

error loading config: no matching creation rules found
^dev/.*\.yaml$
^dev/.*\.env$
{"encrypted":true}
rc=0

.yml ist nicht .yaml. Alternativ die Datei umbenennen – Hauptsache, Regel und Dateiname passen zusammen (Tag 4).

Fortschritt speichern? Kostenlos registrieren

Runde 5: Das direkte Apply

Lage: „Ich wollte das Secret wk aus Runde 1 nur kurz in tag16 testen.“

Schiedsrichter-Befehle: keine – der Kollege hat es nur versucht.

Zeitziel: 3 min

Hinweis: Was bekommt kubectl zu sehen, wenn du die Datei direkt anwendest?

Lösung Runde 5

# auf argo
cd ~/sops/tag16/klon
kubectl apply -f dev/wk.yaml 2>&1 | grep -o 'cannot be handled.*'
sops decrypt dev/wk.yaml | yq '.metadata.namespace = "tag16"' \
  | kubectl apply --server-side -f -
kubectl -n tag16 get secret wk -o jsonpath='{.data.token}' | base64 -d; echo

Erwartet:

cannot be handled as a Secret: illegal base64 data at input byte 3
secret/wk serverside-applied
lab-wk-123

Die ENC[…]-Werte sind kein base64 (Tag 3). Entschlüsseln in der Pipe, den Namespace dort setzen (nicht in der Datei – das bräche den MAC) und server-seitig anwenden (Tag 11).

Fortschritt speichern? Kostenlos registrieren

Runde 6: Der Umzug im Cluster

Lage: „Das SealedSecret aus tag16 brauche ich auch in tag16b. Hab einfach den Namespace geändert.“

Schiedsrichter-Befehle:

# auf argo
cd ~/sops/tag16
kubectl create secret generic app -n tag16 --from-literal=token=lab-app-16 \
  --dry-run=client -o yaml | kubeseal -o yaml > app.sealed.yaml
kubectl apply -f app.sealed.yaml >/dev/null
sed 's/namespace: tag16$/namespace: tag16b/' app.sealed.yaml | kubectl apply -f -
sleep 3

Zeitziel: 4 min

Hinweis: Welcher Scope steht im SealedSecret – und was bedeutet er?

Lösung Runde 6

# auf argo
cd ~/sops/tag16
kubectl -n tag16b get sealedsecret app -o jsonpath='{.status.conditions[0].message}'
echo
yq '.metadata.annotations // "strict"' app.sealed.yaml
kubectl create secret generic app -n tag16b --from-literal=token=lab-app-16 \
  --dry-run=client -o yaml | kubeseal -o yaml | kubectl apply -f -
sleep 3
kubectl -n tag16b get secret app -o jsonpath='{.data.token}' | base64 -d; echo

Erwartet:

no key could decrypt secret (token)
strict
sealedsecret.bitnami.com/app configured
lab-app-16

Scope strict: Namespace und Name gehören zur Verschlüsselung (Tag 12). Für den zweiten Namespace wird neu versiegelt – oder, wenn bewusst gewollt, --scope namespace-wide/cluster-wide.

Fortschritt speichern? Kostenlos registrieren

Runde 7: Der neue Controller

Lage: „Nach dem Neuaufbau des Controllers fehlt das Secret app in tag16. Das SealedSecret ist doch noch da!“

Schiedsrichter-Befehle:

Achtung: Nur mit erfolgreichem Check aus dem Spielfeld.

# auf argo
kubectl -n kube-system delete secret -l sealedsecrets.bitnami.com/sealed-secrets-key \
  >/dev/null
kubectl -n kube-system delete pod -l app.kubernetes.io/name=sealed-secrets >/dev/null
kubectl -n kube-system rollout status deploy/sealed-secrets-controller >/dev/null
sleep 3
kubectl -n tag16 delete secret app >/dev/null
sleep 5

Zeitziel: 6 min

Hinweis: Wie viele Schlüssel kennt der Controller, und woher bekommt er die alten?

Lösung Runde 7

# auf argo
kubectl -n tag16 get sealedsecret app -o jsonpath='{.status.conditions[0].message}'
echo
kubectl -n kube-system get secret -l sealedsecrets.bitnami.com/sealed-secrets-key \
  --no-headers | wc -l
cd ~/sops/repo
sops decrypt backup/sealed-secrets-keys.yaml | kubectl create -f -
kubectl -n kube-system delete pod -l app.kubernetes.io/name=sealed-secrets >/dev/null
kubectl -n kube-system rollout status deploy/sealed-secrets-controller >/dev/null
sleep 6
kubectl -n tag16 get secret app -o jsonpath='{.data.token}' | base64 -d; echo

Erwartet:

no key could decrypt secret (token)
1
secret/sealed-secrets-keyfdv6z created
secret/sealed-secrets-keyh7bnt created
secret/sealed-secrets-keyk7bkd created
secret/sealed-secrets-keytbvdh created
lab-app-16

Ein einziger, neuer Schlüssel – der Controller hat beim Start einen erzeugt. Mit der Sicherung zurück (create, nicht apply, Tag 13), Neustart, und der Controller legt das Secret wieder an.

Fortschritt speichern? Kostenlos registrieren

Runde 8: Der Tresor

Lage: Notfall. Du brauchst das Root-Passwort aus tresor/notfall.yaml.

Schiedsrichter-Befehle: keine – der Tresor ist so gebaut (Tag 6).

Zeitziel: 4 min

Hinweis: Wie viele Gruppen braucht die Datei, und in welcher Gruppe steckt dein Schlüssel?

Lösung Runde 8

# auf argo
cd ~/sops/tag16/klon
sops decrypt tresor/notfall.yaml 2>&1 | grep -oE 'Recovery failed|threshold.*' \
  | head -1
yq '.sops.shamir_threshold, (.sops.key_groups | length)' tresor/notfall.yaml
SOPS_AGE_KEY="$(cat ~/sops/tag06/ben.key)" sops decrypt tresor/notfall.yaml

Erwartet:

Recovery failed
2
3
root_password: lab-root-123

Schwellwert 2 von 3 Gruppen. Dein Schlüssel öffnet eine; Bens Schlüssel aus Gruppe 2 öffnet die zweite. keys.txt und SOPS_AGE_KEY werden zusammen gelesen (Tag 4).

Fortschritt speichern? Kostenlos registrieren

Wertung

Runde Fehler Zeitziel Punkte
1 Klartext gestaged 3 min 2
2 Klartext außerhalb von sops geändert 4 min 2
3 Recipient nur in .sops.yaml 4 min 2
4 path_regex passt nicht zu .yml 3 min 2
5 verschlüsselte Datei direkt angewendet 3 min 2
6 SealedSecret strict umgezogen 4 min 2
7 Controller-Schlüssel verloren 6 min 3
8 Shamir: zu wenige Gruppen 4 min 3

Volle Punkte nur innerhalb des Zeitziels, ohne Hinweis und mit Beweis-Befehl; sonst die Hälfte (abrunden). Gesamtzeitziel: 31 min, Maximum: 18 Punkte.

Punkte Einschätzung
15–18 bereit für die Abschlussprüfung (Anhang B)
10–14 gut; die Tage der verpassten Runden wiederholen
0–9 Tag 3, 4, 5, 12 und 13 noch einmal durcharbeiten

Die Endmessung:

# auf argo
cd ~/sops/tag16/klon
git status -s | wc -l
git log --oneline origin/main.. | wc -l
kubectl get sealedsecret -A --no-headers | awk '{print $1, $2, $3}'

Erwartet:

0
5
tag16 app True
tag16b app True

Challenge

Der Controller hat nach Runde 7 einen Schlüssel mehr als die Sicherung. Bring die Sicherung im Haupt-Repo auf den Stand – so, dass weder Klartext noch eine last-applied-configuration hineingerät – und beweise, dass beide Listen gleich sind.

Hinweis: Der yq-Filter aus Tag 13 entfernt Annotationen.

Lösung

# auf argo
cd ~/sops/repo
kubectl -n kube-system get secret -l sealedsecrets.bitnami.com/sealed-secrets-key \
  -o yaml | yq 'del(.items[].metadata.uid, .items[].metadata.resourceVersion,
  .items[].metadata.creationTimestamp, .items[].metadata.managedFields,
  .items[].metadata.annotations)' > backup/sealed-secrets-keys.yaml
sops encrypt -i backup/sealed-secrets-keys.yaml
git add backup && git commit -q -m "tag16: Sicherung nach Wettkampf" && git push -q
[ "$(sops decrypt backup/sealed-secrets-keys.yaml \
  | yq '[.items[].metadata.name] | sort | join(",")')" = "$(kubectl -n kube-system \
  get secret -l sealedsecrets.bitnami.com/sealed-secrets-key -o json \
  | jq -r '[.items[].metadata.name] | sort | join(",")')" ] && echo gleich

Erwartet:

gleich

Fortschritt speichern? Kostenlos registrieren

Aufräumen

# auf argo
kubectl delete namespace tag16 tag16b
rm -rf ~/sops/tag16
cd ~/sops/repo && git status -sb | head -1

Erwartet:

namespace "tag16" deleted
namespace "tag16b" deleted
## main...origin/main

Kontrollpunkt

# auf argo
kubectl get ns --no-headers | awk '{print $1}' | grep -cE 'tag16'
kubectl -n notes-stage get secret --no-headers | wc -l

Erwartet:

0
3

Interview-Notiz

  • Welche Panne mit verschlüsselten Secrets ist die häufigste? Klartext im Commit – dagegen hilft der Hook, und gegen den umgangenen Hook dieselbe Prüfung in CI.
  • Woran erkennst du, ob ein Recipient fehlt oder der falsche Schlüssel benutzt wird? An der Liste unter Group 0: FAILED: Sie zeigt die Recipients der Datei.
  • Was passiert ohne Sicherung der Controller-Schlüssel? Alle SealedSecrets sind verloren; die Werte müssen neu erzeugt werden.

Enterprise-Notiz

  • Einen solchen Wettkampf als Game Day mit dem Team: Pannen vorher geheim vorbereiten, jede Runde mit Runbook-Eintrag abschließen.
  • Runde 7 ist die wichtigste Übung im Jahr – Wiederherstellung auf einem leeren Cluster, mit der Sicherung aus dem Tresor, nicht von der Platte des Admins.
  • Die Meldungen aus allen Runden gehören in ein Runbook „Secrets“ neben die Alarmierung.