Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 15: Wettkampf – der verwanzte Cluster

Ziel: Du findest und schließt fünf Fehlkonfigurationen in einem fremden Namespace gegen die Uhr. · Dauer: ca. 75 min · Voraussetzung: Tag 1–14

Briefing

Spielsituation: Du übernimmst den Namespace arena – angeblich „fertig ausgerollt”. In Wahrheit stecken fünf der Fehler aus diesem Buch darin. Deine Aufgabe: alle finden, alle schließen, dann die Abschlusskontrolle grün bekommen. Stell dir eine Uhr: 30 Minuten.

Erst den Namespace verwanzen lassen (im echten Wettkampf macht das ein anderer):

kubectl create namespace arena
kubectl -n arena create secret generic payments --from-literal=key=sk-live-LAB

kubectl apply -f - <<'EOF'
apiVersion: v1
kind: Pod
metadata: {name: debug, namespace: arena}
spec:
  containers:
  - {name: c, image: docker.io/library/busybox:1.36, command: ["sleep","infinity"],
     securityContext: {privileged: true}}
---
apiVersion: v1
kind: Pod
metadata: {name: backup, namespace: arena}
spec:
  containers:
  - {name: c, image: docker.io/library/busybox:1.36, command: ["sleep","infinity"],
     volumeMounts: [{name: h, mountPath: /host}]}
  volumes: [{name: h, hostPath: {path: /}}]
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: web, namespace: arena}
spec:
  replicas: 1
  selector: {matchLabels: {app: web}}
  template:
    metadata: {labels: {app: web}}
    spec:
      containers:
      - {name: c, image: nginxinc/nginx-unprivileged:stable,
         env: [{name: DB_PASSWORD, value: p4ss-lab}]}
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata: {name: arena-secret-reader}
rules: [{apiGroups: [""], resources: ["secrets"], verbs: ["get","list"]}]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata: {name: arena-secret-reader}
subjects: [{kind: ServiceAccount, name: default, namespace: arena}]
roleRef: {kind: ClusterRole, name: arena-secret-reader, apiGroup: rbac.authorization.k8s.io}
EOF
kubectl -n arena expose deployment web --type=NodePort --port=80 --name=web-np

Die Aufklärung – finde die fünf Funde

Fahr deine Audit-Befehle aus den Tagen zuvor ab:

# Privilegierte Pods (Tag 5)
kubectl -n arena get pods -o json | python3 -c '
import sys,json
[print("privileged:",p["metadata"]["name"]) for p in json.load(sys.stdin)["items"]
 for c in p["spec"]["containers"] if (c.get("securityContext") or {}).get("privileged")]'

# hostPath (Tag 6)
kubectl -n arena get pods -o json | python3 -c '
import sys,json
[print("hostPath:",p["metadata"]["name"]) for p in json.load(sys.stdin)["items"]
 for v in (p["spec"].get("volumes") or []) if v.get("hostPath")]'

# Klartext-Secret-env (Tag 10)
kubectl -n arena get deploy -o json | python3 -c '
import sys,json
[print("env-secret:",d["metadata"]["name"],e["name"]) for d in json.load(sys.stdin)["items"]
 for c in d["spec"]["template"]["spec"]["containers"] for e in (c.get("env") or [])
 if "value" in e and any(x in e["name"].upper() for x in ("PASS","KEY","SECRET","TOKEN"))]'

# Zu breites RBAC (Tag 2)
kubectl auth can-i list secrets --as=system:serviceaccount:arena:default -A

# NodePort ohne Auth (Tag 9)
kubectl get svc -A --field-selector spec.type=NodePort --no-headers | awk '{print $1,$2}'

Erwartet (deine fünf Funde):

privileged: debug
hostPath: backup
env-secret: web DB_PASSWORD
yes
arena web-np

Die Lösung – alles schließen

# Fund 1+2: privileged & hostPath – Pod Security Admission restricted (Tag 5/6)
kubectl label namespace arena pod-security.kubernetes.io/enforce=restricted --overwrite
kubectl -n arena delete pod debug backup

# Fund 3: Klartext-env -> Secret + secretKeyRef, und web PSA-konform machen (Tag 5/10)
kubectl -n arena create secret generic web-db --from-literal=password=p4ss-lab
kubectl -n arena patch deploy web --type=json -p='[
  {"op":"replace","path":"/spec/template/spec/containers/0/env",
   "value":[{"name":"DB_PASSWORD","valueFrom":{"secretKeyRef":
     {"name":"web-db","key":"password"}}}]},
  {"op":"add","path":"/spec/template/spec/containers/0/securityContext",
   "value":{"allowPrivilegeEscalation":false,"runAsNonRoot":true,
     "capabilities":{"drop":["ALL"]},"seccompProfile":{"type":"RuntimeDefault"}}}]'

# Fund 4: zu breites RBAC entfernen (Tag 2)
kubectl delete clusterrolebinding arena-secret-reader
kubectl delete clusterrole arena-secret-reader

# Fund 5: NodePort -> weg (intern per ClusterIP erreichbar) (Tag 9)
kubectl -n arena delete svc web-np

# Zusätzlich: Default Deny als Grundlinie (Tag 8)
kubectl -n arena apply -f - <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata: {name: default-deny-ingress, namespace: arena}
spec: {podSelector: {}, policyTypes: ["Ingress"]}
EOF

Kontrollpunkt – die Abschlusskontrolle

Jede Zeile muss sauber sein:

echo -n "privileged: "; kubectl -n arena get pods -o json | python3 -c '
import sys,json;print(sum(1 for p in json.load(sys.stdin)["items"]
 for c in p["spec"]["containers"] if (c.get("securityContext") or {}).get("privileged")))'
echo -n "hostPath:    "; kubectl -n arena get pods -o json | python3 -c '
import sys,json;print(sum(1 for p in json.load(sys.stdin)["items"]
 for v in (p["spec"].get("volumes") or []) if v.get("hostPath")))'
echo -n "env-secret:  "; kubectl -n arena get deploy -o json | python3 -c '
import sys,json;print(sum(1 for d in json.load(sys.stdin)["items"]
 for c in d["spec"]["template"]["spec"]["containers"] for e in (c.get("env") or [])
 if "value" in e and any(x in e["name"].upper() for x in ("PASS","KEY","SECRET","TOKEN"))))'
echo -n "rbac secrets: "; kubectl auth can-i list secrets \
  --as=system:serviceaccount:arena:default -A
echo -n "nodeports:   "; kubectl -n arena get svc --field-selector spec.type=NodePort \
  --no-headers 2>/dev/null | wc -l

Erwartet:

privileged: 0
hostPath:    0
env-secret:  0
rbac secrets: no
nodeports:   0

Fünf von fünf. Räum die Arena ab:

kubectl delete namespace arena

Challenge

Verwanze die Arena ein zweites Mal selbst – füge einen sechsten Fund hinzu, den dieses Buch behandelt (z. B. einen Service mit externalIPs aus Tag 13 oder einen Pod ganz ohne automountServiceAccountToken: false, der die API erreicht). Lass einen Kollegen suchen.

Hinweis: Ein guter Fund ist leise – er sieht aus wie normale Konfiguration und tut genau einen Schritt zu viel.

Lösung

Es gibt keine eine Lösung – das ist der Punkt. Wer Funde baut, versteht sie am besten. Nimm die Audit-Befehle aus dem Spickzettel (Anhang A) als deine Prüf-Checkliste und erweitere sie um jeden neuen Fund.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Solche „Gamedays” regelmäßig fahren: ein Team verwanzt, ein Team härtet gegen die Uhr.
  • Die Audit-Befehle in eine CI/einen Cronjob gießen – dann findet die Maschine die Funde, bevor es ein Angreifer tut.
  • Der beste Zustand ist der, in dem die meisten Funde gar nicht erst entstehen können: PSA-Default, Default-Deny-Networkpolicies und Kyverno-Guardrails erzwingen das von Anfang an (Tag 5–14).
  • Dokumentiere jeden Fund mit „so erkannt, so geschlossen, so verhindert” – das ist die Übergabe, die im Betrieb trägt.