Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 19: Wettkampf – den unsicheren Cluster absichern

Ziel: Du findest und behebst acht Sicherheitslücken quer über den CKS-Lehrplan – gegen die Uhr, mit Nachweis vorher und nachher. · Dauer: ca. 90 min · Voraussetzung: Tag 0–18

Briefing

  • Alle sechs Lehrplanbereiche: Cluster Setup, Cluster Hardening, System Hardening, Microservice Vulnerabilities, Supply Chain Security, Monitoring/Logging/Runtime Security.
  • Acht Runden; sechs davon in eigenem Namespace (tag19-r1 … tag19-r8), Runde 4 (kubelet) und Runde 5 (API-Server) bauen eine Lücke in den Cluster selbst ein – du baust sie zurück.
  • Jede Runde endet mit einem Beweis-Befehl: unsicher vorher, sicher nachher.
  • Die Härtungen aus Tag 3, 6, 10, 11, 12, 15 und 16 müssen am Ende noch aktiv sein (Kontrollpunkt).
Runde  Lücke                                  Werkzeug
1      privilegierter Pod mit hostPath        PSA restricted, securityContext
2      ServiceAccount mit cluster-admin       Role/RoleBinding, auth can-i
3      NetworkPolicy "allow-all"              Default Deny, podSelector
4      kubelet anonym + AlwaysAllow           /var/lib/kubelet/config.yaml
5      NodeRestriction fehlt                  kube-bench, Static-Pod-Manifest
6      Klartext-Key, Secret-Leser             secretKeyRef, Audit-Log + jq
7      Image mit CRITICAL-Lücken              Trivy, RuntimeClass gvisor
8      Falco meldet /etc/shadow               Falco-Logs, Quarantäne
mkdir -p ~/cks/tag19/backup && cd ~/cks/tag19

Spielregeln

  • Pro Runde: Namespace anlegen, Einbau-Befehle ausführen, dann Uhr starten. Das Manifest nicht studieren – in der Prüfung siehst du es auch erst, wenn du suchst.
  • Ursache finden, beheben, mit einem Befehl beweisen. Erst dann Uhr stoppen.
  • Die Sicherheitsvorgabe der Aufgabe bleibt bestehen: Wer eine Härtung abschaltet, damit der Pod läuft, bekommt null Punkte.
  • Den Hinweis erst lesen, wenn das Zeitziel abgelaufen ist.

Jede Runde mit eigenem Namespace beginnt gleich (hier für Runde 1):

k create ns tag19-r1
k config set-context --current --namespace=tag19-r1

Runde 1: Backup mit Blick auf den Host

Lage: Team 1 betreibt einen Backup-Container. Der Namespace soll ab sofort den Pod Security Standard restricted erzwingen, und backup muss danach weiterlaufen – mit schreibgeschütztem Root-Dateisystem. /data bleibt beschreibbar.

k apply -f - <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: backup
spec:
  replicas: 1
  selector:
    matchLabels:
      app: backup
  template:
    metadata:
      labels:
        app: backup
    spec:
      containers:
      - name: backup
        image: busybox:1.37
        command: ["sh", "-c", "while true; do date > /data/last; sleep 30; done"]
        securityContext:
          privileged: true
        volumeMounts:
        - name: data
          mountPath: /data
        - name: host
          mountPath: /host
      volumes:
      - name: data
        emptyDir: {}
      - name: host
        hostPath:
          path: /
EOF
k rollout status deploy/backup
k exec deploy/backup -- ls /host/etc/kubernetes

Erwartet:

deployment.apps/backup created
deployment "backup" successfully rolled out
kubelet.conf
manifests
pki
tmp

Der Container sieht das ganze Dateisystem des Nodes – samt kubelet-Zugangsdaten.

Zeitziel: 4 min

Hinweis: Das Label wirkt nur auf neue Pods. Die Warnung beim Setzen ist deine Checkliste – sechs Punkte.

Lösung

k label ns tag19-r1 pod-security.kubernetes.io/enforce=restricted
k rollout restart deploy/backup
k get events --field-selector reason=FailedCreate | tail -1

Erwartet (gekürzt):

namespace/tag19-r1 labeled
Warning: existing pods in namespace "tag19-r1" violate the new PodSecurity enforce
level "restricted:latest"
Warning: backup-765668c6fb-cmvj4: privileged, allowPrivilegeEscalation != false,
unrestricted capabilities, restricted volume types, runAsNonRoot != true, seccompProfile
deployment.apps/backup restarted
1s   Warning   FailedCreate   replicaset/backup-767fc5b66c   ... Error creating: pods
"backup-767fc5b66c-hlc8x" is forbidden: violates PodSecurity "restricted:latest": ...

Der alte Pod läuft weiter, neue werden abgelehnt. Alle sechs Punkte plus das schreibgeschützte Root-FS in einem JSON-Patch (Index 1 = Volume host):

k patch deploy backup --type=json -p='[
 {"op": "remove", "path": "/spec/template/spec/volumes/1"},
 {"op": "remove", "path": "/spec/template/spec/containers/0/volumeMounts/1"},
 {"op": "add", "path": "/spec/template/spec/securityContext", "value":
  {"runAsNonRoot": true, "runAsUser": 65532,
   "seccompProfile": {"type": "RuntimeDefault"}}},
 {"op": "replace", "path": "/spec/template/spec/containers/0/securityContext",
  "value": {"allowPrivilegeEscalation": false, "readOnlyRootFilesystem": true,
   "capabilities": {"drop": ["ALL"]}}}]'
k rollout status deploy/backup
k exec deploy/backup -- id
k exec deploy/backup -- touch /x
k exec deploy/backup -- sh -c 'date > /data/test && echo ok'
k label --dry-run=server --overwrite ns tag19-r1 \
  pod-security.kubernetes.io/enforce=restricted

Erwartet (gekürzt):

deployment.apps/backup patched
deployment "backup" successfully rolled out
uid=65532 gid=0(root) groups=0(root)
touch: /x: Read-only file system
command terminated with exit code 1
ok
namespace/tag19-r1 not labeled (server dry run)

Der Server-Dry-Run ohne Warnung beweist: Kein laufender Pod verletzt mehr restricted. readOnlyRootFilesystem verlangt restricted nicht – das war die Zusatzvorgabe.

Fortschritt speichern? Kostenlos registrieren

Runde 2: Der Deployer ist Cluster-Admin

Lage: Die Pipeline nutzt den ServiceAccount deployer in tag19-r2. Sie darf Deployments in diesem Namespace lesen und ändern (get, list, watch, update, patch) – sonst nichts.

k create ns tag19-r2
k config set-context --current --namespace=tag19-r2
k create sa deployer
k create clusterrolebinding tag19-r2-deployer --clusterrole=cluster-admin \
  --serviceaccount=tag19-r2:deployer

Zeitziel: 3 min

Hinweis: Die Bindung steht nicht im Namespace – k get rolebindings bleibt leer.

Lösung

SA=system:serviceaccount:tag19-r2:deployer
k auth can-i get secrets -A --as=$SA
k get clusterrolebindings -o wide | grep -E 'NAME|deployer'

Erwartet (gekürzt):

yes
NAME                ROLE                        AGE  ...  SERVICEACCOUNTS
tag19-r2-deployer   ClusterRole/cluster-admin   1s   ...  tag19-r2/deployer

Bindung löschen, enge Role anlegen:

k delete clusterrolebinding tag19-r2-deployer
k create role deployer --verb=get,list,watch,update,patch \
  --resource=deployments.apps
k create rolebinding deployer --role=deployer --serviceaccount=tag19-r2:deployer
k auth can-i patch deployments -n tag19-r2 --as=$SA
k auth can-i create deployments -n tag19-r2 --as=$SA
k auth can-i get secrets -n tag19-r2 --as=$SA
k auth can-i patch deployments -n kube-system --as=$SA

Erwartet:

clusterrolebinding.rbac.authorization.k8s.io "tag19-r2-deployer" deleted
role.rbac.authorization.k8s.io/deployer created
rolebinding.rbac.authorization.k8s.io/deployer created
yes
no
no
no

Vier can-i beweisen beide Richtungen: Was erlaubt sein soll, geht; Anlegen, Secrets und fremde Namespaces nicht.

Fortschritt speichern? Kostenlos registrieren

Runde 3: Die Policy, die alles erlaubt

Lage: In tag19-r3 läuft notes-api. Nur Pods mit dem Label role=frontend aus demselben Namespace dürfen auf Port 8080 zugreifen; jeder andere eingehende Verkehr in den Namespace ist zu sperren.

k create ns tag19-r3
k config set-context --current --namespace=tag19-r3
k apply -f - <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: notes
spec:
  replicas: 1
  selector:
    matchLabels:
      app: notes
  template:
    metadata:
      labels:
        app: notes
    spec:
      containers:
      - name: notes-api
        image: 172.16.0.126:30500/notes-api:1.0
        env:
        - name: NOTES_API_KEY
          value: lab-key-123
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: notes
spec:
  selector:
    app: notes
  ports:
  - port: 80
    targetPort: 8080
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-all
spec:
  podSelector: {}
  ingress:
  - {}
EOF
k run frontend --image=busybox:1.37 -l role=frontend -- sleep 3600
k run fremd --image=busybox:1.37 -- sleep 3600
k create ns tag19-r3-gast
k -n tag19-r3-gast run gast --image=busybox:1.37 -l role=frontend -- sleep 3600

Zeitziel: 4 min

Hinweis: NetworkPolicies addieren sich. Eine Deny-Policy neben einer, die alles erlaubt, ändert nichts.

Lösung

Ausgangslage – alle drei kommen durch:

k exec frontend -- wget -qO- -T3 notes/healthz
k exec fremd -- wget -qO- -T3 notes/healthz
k -n tag19-r3-gast exec gast -- wget -qO- -T3 notes.tag19-r3/healthz

Erwartet:

ok
ok
ok

Default Deny und die gezielte Freigabe:

k apply -f - <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny
spec:
  podSelector: {}
  policyTypes:
  - Ingress
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: notes-from-frontend
spec:
  podSelector:
    matchLabels:
      app: notes
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          role: frontend
    ports:
    - port: 8080
EOF
k exec fremd -- wget -qO- -T3 notes/healthz
k get netpol

Erwartet:

networkpolicy.networking.k8s.io/default-deny created
networkpolicy.networking.k8s.io/notes-from-frontend created
ok
NAME                  POD-SELECTOR   AGE
allow-all             <none>         12s
default-deny          <none>         0s
notes-from-frontend   app=notes      0s

fremd kommt immer noch durch. Der Grund steht in allow-all:

k describe netpol allow-all | sed -n '/Spec/,$p'
k delete netpol allow-all
k exec frontend -- wget -qO- -T3 notes/healthz
k exec fremd -- wget -qO- -T3 notes/healthz
k -n tag19-r3-gast exec gast -- wget -qO- -T3 notes.tag19-r3/healthz

Erwartet:

Spec:
  PodSelector:     <none> (Allowing the specific traffic to all pods in this namespace)
  Allowing ingress traffic:
    To Port: <any> (traffic allowed to all ports)
    From: <any> (traffic not restricted by source)
  Not affecting egress traffic
  Policy Types: Ingress
networkpolicy.networking.k8s.io "allow-all" deleted from tag19-r3 namespace
ok
wget: download timed out
command terminated with exit code 1
wget: download timed out
command terminated with exit code 1

gast trägt zwar role=frontend, kommt aber aus einem anderen Namespace: Ein podSelector ohne namespaceSelector gilt nur im eigenen Namespace.

Fortschritt speichern? Kostenlos registrieren

Runde 4: Das offene kubelet

Lage: „Zum Debuggen“ hat jemand auf worker2 die kubelet-API geöffnet. Finde die Lücke von cp1 aus und schließe sie. Einbau von cp1 aus (Sicherung zuerst):

ssh [email protected]
sudo cp /var/lib/kubelet/config.yaml /root/kubelet-config.tag19
sudo sed -i -e '/anonymous:/{n;s/enabled: false/enabled: true/}' \
  -e 's/  mode: Webhook/  mode: AlwaysAllow/' /var/lib/kubelet/config.yaml
sudo systemctl restart kubelet
exit

Zeitziel: 4 min

Hinweis: Teste Port 10250 aller Nodes ohne Anmeldung. Die Konfigurationsdatei verrät ps am kubelet-Prozess.

Lösung

Auf cp1:

curl -sk https://172.16.0.228:10250/pods; echo
curl -sk https://172.16.0.83:10250/pods | jq -r '.items[].metadata.name' | head -2
P=$(k -n kube-system get pod -l k8s-app=cilium \
  --field-selector spec.nodeName=worker2 -o name | cut -d/ -f2)
curl -sk -X POST "https://172.16.0.83:10250/run/kube-system/$P/cilium-agent?cmd=id"

Erwartet (gekürzt):

Unauthorized
cilium-zg9q2
falco-ld8gg
uid=0(root) gid=0(root) groups=0(root)

worker1 lehnt ab, worker2 führt anonym Befehle als root aus. Auf worker2:

ssh [email protected]
ps -o args= -C kubelet | tr ' ' '\n' | grep -- --config
sudo grep -A1 -E "  anonymous:|^authorization:" /var/lib/kubelet/config.yaml
sudo sed -i -e '/anonymous:/{n;s/enabled: true/enabled: false/}' \
  -e 's/  mode: AlwaysAllow/  mode: Webhook/' /var/lib/kubelet/config.yaml
sudo grep -A1 -E "  anonymous:|^authorization:" /var/lib/kubelet/config.yaml
sudo systemctl restart kubelet
systemctl is-active kubelet
sudo cmp /var/lib/kubelet/config.yaml /root/kubelet-config.tag19 && echo gleich
sudo rm /root/kubelet-config.tag19
exit

Erwartet:

--config=/var/lib/kubelet/config.yaml
  anonymous:
    enabled: true
--
authorization:
  mode: AlwaysAllow
  anonymous:
    enabled: false
--
authorization:
  mode: Webhook
active
gleich

Beweis auf cp1:

curl -sk https://172.16.0.83:10250/pods; echo
k get nodes worker2

Erwartet (gekürzt):

Unauthorized
NAME      STATUS   ROLES    AGE    VERSION
worker2   Ready    <none>   112m   …

cmp gegen die Sicherung zeigt: Die Datei ist bitgenau wie vor dem Einbau. Die Rechte 600 aus Tag 3 bleiben, weil sed -i sie übernimmt.

Fortschritt speichern? Kostenlos registrieren

Runde 5: Der Node darf zu viel

Lage: Ein Audit meldet: Ein übernommener Worker könnte sich selbst Labels mit dem Präfix node-restriction.kubernetes.io/ geben und so sicherheitsrelevante Pods auf sich ziehen. Finde die Ursache am API-Server und behebe sie. Einbau auf cp1 (Sicherung außerhalb des Manifest-Ordners):

M=/etc/kubernetes/manifests
sudo cp $M/kube-apiserver.yaml ~/cks/tag19/backup/kube-apiserver.yaml
sudo sed -i '/--enable-admission-plugins=NodeRestriction/d' $M/kube-apiserver.yaml

Ein bis zwei Minuten warten, bis k get --raw /readyz wieder ok meldet.

Zeitziel: 5 min

Hinweis: Teste mit der kubeconfig des kubelets auf worker1. Welcher CIS-Check gehört zu Admission-Plugins?

Lösung

Nachweis auf worker1 (von cp1 aus per ssh [email protected]):

export KUBECONFIG=/etc/kubernetes/kubelet.conf
sudo -E kubectl auth whoami | grep Username
sudo -E kubectl label node worker1 node-restriction.kubernetes.io/tag19=pwn
exit

Erwartet:

Username                                            system:node:worker1
node/worker1 labeled

Das hätte NodeRestriction verboten. Auf cp1:

sudo kube-bench run --targets master --benchmark cis-1.12 --check 1.2.14 \
  | grep -E '^\[(FAIL|PASS)'
sudo grep -c admission $M/kube-apiserver.yaml

Erwartet:

[FAIL] 1.2.14 Ensure that the admission control plugin NodeRestriction is set
(Automated)
0

Flag wieder eintragen – in der Prüfung mit vim, hier per sed direkt hinter --client-ca-file:

sudo sed -i '/- --client-ca-file=/a\    - --enable-admission-plugins=NodeRestriction' \
  $M/kube-apiserver.yaml
sudo grep -B1 -A1 -- '--enable-admission' $M/kube-apiserver.yaml
sudo md5sum $M/kube-apiserver.yaml ~/cks/tag19/backup/kube-apiserver.yaml

Erwartet (Prüfsummen gekürzt):

    - --client-ca-file=/etc/kubernetes/pki/ca.crt
    - --enable-admission-plugins=NodeRestriction
    - --enable-bootstrap-token-auth=true
…  /etc/kubernetes/manifests/kube-apiserver.yaml
…  /home/ubuntu/cks/tag19/backup/kube-apiserver.yaml

Beide Prüfsummen sind gleich. Nach dem Neustart (1–2 min):

k get --raw /readyz; echo
ps -o args= -C kube-apiserver | tr ' ' '\n' | grep admission

Erwartet:

ok
--enable-admission-plugins=NodeRestriction

Beweis auf worker1, dann das eingeschmuggelte Label als Admin auf cp1 entfernen:

export KUBECONFIG=/etc/kubernetes/kubelet.conf
sudo -E kubectl label node worker1 node-restriction.kubernetes.io/tag19=pwn2 \
  --overwrite
exit
k label node worker1 node-restriction.kubernetes.io/tag19-

Erwartet:

Error from server (Forbidden): nodes "worker1" is forbidden: is not allowed to modify
labels: node-restriction.kubernetes.io/tag19
node/worker1 unlabeled

kubeadm setzt das Flag von sich aus (eingebauter Standardwert, nicht in kubeadm-config sichtbar) – ein Upgrade stellt es also wieder her. Ein Label, das der Angreifer gesetzt hat, bleibt dagegen stehen, bis du es entfernst.

Fortschritt speichern? Kostenlos registrieren

Runde 6: Schlüssel im Klartext, Secret mit Zuschauer

Lage: In tag19-r6 steht der API-Key von notes-api im Klartext im Deployment. Lege ihn in ein Secret notes-key. Außerdem soll das Audit-Log zeigen, wer das Secret db-cred gelesen hat – diesem Konto nimmst du den Zugriff auf Secrets (ConfigMaps darf es weiter lesen).

k create ns tag19-r6
k config set-context --current --namespace=tag19-r6
k create deployment notes --image=172.16.0.126:30500/notes-api:1.0
k set env deploy/notes NOTES_API_KEY=lab-key-123
k create secret generic db-cred --from-literal=password=Lab-Geheim-19
k create sa reporter
k create role reporter --verb=get,list --resource=secrets,configmaps
k create rolebinding reporter --role=reporter --serviceaccount=tag19-r6:reporter
T=$(k create token reporter --duration=10m)
curl -s --cacert /etc/kubernetes/pki/ca.crt -H "Authorization: Bearer $T" \
  https://172.16.0.126:6443/api/v1/namespaces/tag19-r6/secrets/db-cred > /dev/null

Lab-Geheim-19 ist ein reiner Lab-Wert.

Zeitziel: 5 min

Hinweis: Das Audit-Log liegt in /var/log/kubernetes/audit/audit.log (Tag 15); objectRef und user sind die Felder für jq.

Lösung

k get deploy notes -o jsonpath='{.spec.template.spec.containers[0].env}'; echo
L=/var/log/kubernetes/audit/audit.log
sudo jq -c 'select(.objectRef.resource=="secrets" and .objectRef.name=="db-cred"
  and .objectRef.namespace=="tag19-r6" and .verb=="get")
  | [.user.username, .verb, .responseStatus.code, .sourceIPs[0]]' $L
k get rolebindings -o wide

Erwartet (gekürzt):

[{"name":"NOTES_API_KEY","value":"lab-key-123"}]
["system:serviceaccount:tag19-r6:reporter","get",200,"172.16.0.126"]
NAME       ROLE            AGE   USERS   GROUPS   SERVICEACCOUNTS
reporter   Role/reporter   7s                     tag19-r6/reporter

Key ins Secret, Variable aus dem Secret, Role ohne Secrets:

k create secret generic notes-key --from-literal=NOTES_API_KEY=lab-key-123
k set env deploy/notes NOTES_API_KEY-
k set env deploy/notes --from=secret/notes-key
k rollout status deploy/notes
k set env deploy/notes --list
k create role reporter --verb=get,list --resource=configmaps $do | k apply -f -
SA=system:serviceaccount:tag19-r6:reporter
k auth can-i get secrets --as=$SA
k auth can-i list configmaps --as=$SA
k exec deploy/notes -- wget -qO- localhost:8080/healthz; echo

Erwartet (gekürzt):

secret/notes-key created
deployment.apps/notes env updated
deployment.apps/notes env updated
deployment "notes" successfully rolled out
# Deployment notes, container notes-api
# NOTES_API_KEY from secret notes-key, key NOTES_API_KEY
Warning: resource roles/reporter is missing the kubectl.kubernetes.io/last-applied-...
role.rbac.authorization.k8s.io/reporter configured
no
yes
ok

Die Warnung ist harmlos: apply ergänzt die fehlende Annotation. Dank Tag 10 liegt das neue Secret verschlüsselt in etcd (k8s:enc:aescbc:v1:key2, siehe Kontrollpunkt).

Fortschritt speichern? Kostenlos registrieren

Runde 7: Das alte Proxy-Image

Lage: In tag19-r7 darf kein Image mit CRITICAL-Lücken laufen. Ersetze betroffene Images durch nginx:1.29-alpine-slim. Weil der Proxy fremde Daten verarbeitet, soll er zusätzlich in der gVisor-Sandbox laufen (RuntimeClass gvisor, Tag 11).

k create ns tag19-r7
k config set-context --current --namespace=tag19-r7
k create deployment proxy --image=nginx:1.19 --port=80
k expose deploy proxy --port=80
k create deployment notes --image=172.16.0.126:30500/notes-api:1.0
k set env deploy/notes NOTES_API_KEY=lab-key-123

Zeitziel: 5 min (Trivy braucht pro Image etwas Zeit)

Hinweis: Erst die Image-Liste aus den Pods holen, dann jedes Image einzeln scannen; --exit-code 1 spart das Lesen der Tabelle.

Lösung

k get pods -o jsonpath='{range .items[*]}{.spec.containers[*].image}{"\n"}{end}' \
  | sort -u
trivy image -q --severity CRITICAL nginx:1.19 | grep Total
trivy image -q --insecure --severity CRITICAL --exit-code 1 \
  172.16.0.126:30500/notes-api:1.0 > /dev/null; echo $?
trivy image -q --severity CRITICAL --exit-code 1 nginx:1.29-alpine-slim \
  > /dev/null; echo $?

Erwartet:

172.16.0.126:30500/notes-api:1.0
nginx:1.19
Total: 42 (CRITICAL: 42)
0
0

Nur der Proxy ist betroffen; das Ersatz-Image ist sauber (Stand der Trivy-DB vom 2026-11-18). Image tauschen und in die Sandbox:

k set image deploy/proxy nginx=nginx:1.29-alpine-slim
k patch deploy proxy -p '{"spec":{"template":{"spec":{"runtimeClassName":"gvisor"}}}}'
k rollout status deploy/proxy
k get deploy -o custom-columns=NAME:.metadata.name,\
IMAGE:.spec.template.spec.containers[0].image,RC:.spec.template.spec.runtimeClassName
k exec deploy/proxy -- dmesg | head -1
k exec deploy/notes -- wget -qO- -S -T5 proxy 2>&1 | grep -E 'HTTP|Server'

Erwartet (gekürzt):

deployment.apps/proxy image updated
deployment.apps/proxy patched
deployment "proxy" successfully rolled out
NAME    IMAGE                              RC
notes   172.16.0.126:30500/notes-api:1.0   <none>
proxy   nginx:1.29-alpine-slim             gvisor
[   0.000000] Starting gVisor...
  HTTP/1.1 200 OK
  Server: nginx/1.29.8

Der Container-Name nginx stammt von k create deployment (Name des Images). Die RuntimeClass bringt ihren nodeSelector sandbox=gvisor selbst mit – der Pod landet nur auf vorbereiteten Workern.

Fortschritt speichern? Kostenlos registrieren

Runde 8: Falco schlägt an

Lage: Falco meldet seit Minuten Zugriffe auf /etc/shadow. Finde Pod und Besitzer, sperre den Pod im Netz, sichere YAML und Logs nach ~/cks/tag19/evidence-r8/, entferne ihn und sorge dafür, dass er nicht wiederkommt. web läuft unverändert weiter.

k create ns tag19-r8
k config set-context --current --namespace=tag19-r8
k create deployment web --image=nginx:1.29-alpine-slim --replicas=2
k create deployment sync --image=busybox:1.37 -- \
  sh -c 'while true; do cat /etc/shadow > /dev/null; sleep 20; done'

Eine Minute warten, damit Falco etwas zu melden hat.

Zeitziel: 5 min

Hinweis: Falco hängt k8s_pod_name und k8s_ns_name an jede Meldung an. Die Logs aller drei Falco-Pods holst du mit einem Label-Selector.

Lösung

k -n falco logs -l app.kubernetes.io/name=falco -c falco --since=5m --tail=-1 \
  | grep 'Sensitive file' \
  | grep -o 'file=[^ ]*\|k8s_pod_name=[^ ]*\|k8s_ns_name=[^ ]*' | sort | uniq -c

Erwartet:

      3 file=/etc/shadow
      3 k8s_ns_name=tag19-r8
      3 k8s_pod_name=sync-7cdd59b4db-gvfwc

Nicht verwirren lassen: Meldungen „Detected ptrace PTRACE_ATTACH attempt“ mit containerd-shim als Elternprozess entstehen beim Start der gVisor-Sandbox aus Runde 7.

P=sync-7cdd59b4db-gvfwc
k get pod $P -o jsonpath='{.metadata.ownerReferences[0].name}{"\n"}'
k get pod $P -o jsonpath='{.spec.containers[0].command}{"\n"}'

Erwartet:

sync-7cdd59b4db
["sh","-c","while true; do cat /etc/shadow > /dev/null; sleep 20; done"]

Erst die Quarantäne-Policy, dann den Pod aus dem ReplicaSet lösen, dann den Besitzer stilllegen:

k apply -f - <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: quarantine
spec:
  podSelector:
    matchLabels:
      quarantine: "true"
  policyTypes:
  - Ingress
  - Egress
EOF
k label pod $P app- quarantine=true
k scale deploy sync --replicas=0
k get pods --show-labels
k get cep $P -o jsonpath='{.status.identity.labels}' \
  | grep -o 'k8s:quarantine=true'

Leer? Kurz warten und wiederholen (die Identity folgt den Labels verzögert, Tag 18). Dann:

k exec $P -- wget -qO- -T3 http://web

Erwartet (gekürzt):

networkpolicy.networking.k8s.io/quarantine created
pod/sync-7cdd59b4db-gvfwc modified
deployment.apps/sync scaled
NAME                    READY   STATUS        ...   LABELS
sync-7cdd59b4db-f7pjp   0/1     Terminating   ...   app=sync,pod-template-hash=...
sync-7cdd59b4db-gvfwc   1/1     Running       ...   ...,quarantine=true
web-846db866-q5dll      1/1     Running       ...   app=web,pod-template-hash=846db866
web-846db866-q99rb      1/1     Running       ...   app=web,pod-template-hash=846db866
wget: bad address 'web'
command terminated with exit code 1

Der Terminating-Pod ist der Ersatz, den das ReplicaSet nach dem Umlabeln sofort startete – scale räumt ihn ab. bad address: Selbst DNS ist für den Quarantäne-Pod gesperrt. Beweise sichern, dann löschen:

mkdir -p ~/cks/tag19/evidence-r8
k get pod $P -o yaml > ~/cks/tag19/evidence-r8/pod.yaml
k logs $P > ~/cks/tag19/evidence-r8/log.txt
k delete pod $P --now
k get deploy

Erwartet (gekürzt):

pod "sync-7cdd59b4db-gvfwc" deleted from tag19-r8 namespace
NAME   READY   UP-TO-DATE   AVAILABLE   AGE
sync   0/0     0            0           71s
web    2/2     2            2           71s

Eine Minute später:

k -n falco logs -l app.kubernetes.io/name=falco -c falco --since=30s --tail=-1 \
  | grep -c tag19-r8

Erwartet: 0

Uhr stoppen.

Fortschritt speichern? Kostenlos registrieren

Wertung

Runde Lücke Zeitziel Punkte
1 privilegiert + hostPath, PSA restricted 4 min 2
2 cluster-admin für ServiceAccount 3 min 2
3 NetworkPolicy allow-all 4 min 2
4 kubelet anonym + AlwaysAllow 4 min 2
5 NodeRestriction fehlt 5 min 2
6 Klartext-Key + Audit-Spur 5 min 3
7 CRITICAL-Image + gVisor 5 min 2
8 Falco-Fund isolieren 5 min 3

Volle Punkte nur innerhalb des Zeitziels, ohne Hinweis und mit Beweis-Befehl; sonst die Hälfte (abrunden). Wer eine Härtung abschaltet, bekommt für die Runde 0. Gesamtzeitziel: 35 min, Maximum: 18 Punkte.

Punkte Einschätzung
15–18 prüfungsreif – weiter mit der Probeprüfung (Anhang B)
10–14 gut; die Tage der verpassten Runden wiederholen
0–9 Tag 5, 6, 9 und 15 noch einmal durcharbeiten

Kontrollpunkt

Erst die Runden, dann die Härtungen, die über den Tag hinaus bleiben.

k get deploy -A | grep tag19

Erwartet: backup 1/1 (r1), notes 1/1 (r3, r6, r7), proxy 1/1 (r7), sync 0/0 und web 2/2 (r8).

k get ns -l pod-security.kubernetes.io/enforce=restricted

Erwartet: tag19-r1 Active …

k auth can-i get secrets -A --as=system:serviceaccount:tag19-r2:deployer

Erwartet: no

curl -sk https://172.16.0.83:10250/pods; echo

Erwartet: Unauthorized (ebenso für 172.16.0.228)

ssh [email protected] 'sudo stat -c "%a %n" /var/lib/kubelet/config.yaml'

Erwartet: 600 /var/lib/kubelet/config.yaml

ps -o args= -C kube-apiserver | tr ' ' '\n' \
  | grep -E 'admission|profiling|authentication-config|encryption-pro|audit-log-pa'

Erwartet:

--enable-admission-plugins=NodeRestriction
--profiling=false
--authentication-config=/etc/kubernetes/authn/authn-config.yaml
--encryption-provider-config=/etc/kubernetes/enc/enc.yaml
--audit-log-path=/var/log/kubernetes/audit/audit.log
ps -o args= -C kube-scheduler | tr ' ' '\n' | grep profiling

Erwartet: --profiling=false (ebenso für kube-controller-manager)

curl -sk https://172.16.0.126:6443/version | jq -r .code

Erwartet: 401

P=/etc/kubernetes/pki
E="--cacert=$P/etcd/ca.crt --cert=$P/apiserver-etcd-client.crt"
E="$E --key=$P/apiserver-etcd-client.key"
sudo etcdctl $E get /registry/secrets/tag19-r6/notes-key --print-value-only \
  | hexdump -C | head -2

Erwartet:

00000000  6b 38 73 3a 65 6e 63 3a  61 65 73 63 62 63 3a 76  |k8s:enc:aescbc:v|
00000010  31 3a 6b 65 79 32 3a 66  bb 42 01 70 b6 e3 2b 65  |1:key2:f.B.p..+e|
k -n falco get ds falco
k get runtimeclass gvisor

Erwartet: falco mit 3 bei DESIRED und READY; gvisor mit Handler runsc.

k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg encrypt status

Erwartet (gekürzt):

Encryption: Wireguard
Interface: cilium_wg0
    Number of peers: 2
k get --raw='/readyz?verbose' | tail -1
k get nodes
k get pods -A --no-headers | grep -vc Running

Erwartet: readyz check passed, drei Nodes Ready, 0.

Challenge

Ein Kollege hat zwei Altlasten im Cluster versteckt. Finde sie clusterweit, ohne den Namespace zu kennen, und beseitige sie. Legitime System-Pods (Falco braucht privileged) bleiben.

k create ns tag19-ch
k -n tag19-ch create sa ci
k create clusterrolebinding tag19-ch-ci --clusterrole=cluster-admin \
  --serviceaccount=tag19-ch:ci
k -n tag19-ch run debug --image=busybox:1.37 --privileged -- sleep 3600

Hinweis: Zwei jq-Abfragen: Pods mit privileged oder hostPath außerhalb von kube-system, und alle Bindungen auf cluster-admin.

Lösung

k get pods -A -o json | jq -r '.items[]
  | select(.metadata.namespace != "kube-system")
  | select(any(.spec.containers[]; .securityContext.privileged == true)
      or any(.spec.volumes[]?; .hostPath))
  | .metadata.namespace + "/" + .metadata.name'
k get clusterrolebindings -o json | jq -r '.items[]
  | select(.roleRef.name == "cluster-admin")
  | .metadata.name + " " + ([.subjects[]? | .kind + ":" + .name] | join(","))'

Erwartet:

falco/falco-j78wr
falco/falco-ld8gg
falco/falco-vlb49
tag19-ch/debug
cluster-admin Group:system:masters
kubeadm:cluster-admins Group:kubeadm:cluster-admins
tag19-ch-ci ServiceAccount:ci

Falco und die beiden Gruppen-Bindungen von kubeadm sind gewollt; debug und tag19-ch-ci nicht:

k -n tag19-ch delete pod debug --now
k delete clusterrolebinding tag19-ch-ci
k auth can-i '*' '*' --as=system:serviceaccount:tag19-ch:ci

Erwartet:

pod "debug" deleted from tag19-ch namespace
clusterrolebinding.rbac.authorization.k8s.io "tag19-ch-ci" deleted
no

Aufräumen (die Cluster-Änderungen aus Runde 4 und 5 sind bereits zurückgebaut):

k config set-context --current --namespace=default
k delete ns tag19-r1 tag19-r2 tag19-r3 tag19-r3-gast tag19-r6 tag19-r7 tag19-r8 \
  tag19-ch

Fortschritt speichern? Kostenlos registrieren

Prüfungstipp

  • Jede Aufgabe mit Vorher/Nachher-Beweis abschließen (auth can-i, wget, curl auf 10250, Server-Dry-Run): So fallen versteckte Zweitfehler wie allow-all (Runde 3) oder alte Pods (Runde 1) auf.
  • Vor jeder Änderung an Static-Pod-Manifest oder kubelet-Konfiguration: Kopie außerhalb von /etc/kubernetes/manifests, danach readyz und k get nodes. Ein API-Server, der nicht wiederkommt, kostet mehr Punkte als die Aufgabe bringt.
  • Die Sicherheitsvorgabe nie abschwächen, um einen Pod zum Laufen zu bringen: Den Pod an die Vorgabe anpassen (Runde 1), nicht die Vorgabe an den Pod.

Enterprise-Notiz

  • Fast alle Lücken dieses Tages verhindert Policy-as-Code vor dem Deploy: PSA-Labels per Namespace-Vorlage, Kyverno/Gatekeeper oder ValidatingAdmissionPolicy gegen privileged, hostPath, fremde Registries und cluster-admin-Bindungen.
  • Node- und API-Server-Konfiguration gehört in Konfigurationsmanagement (Ansible, Cluster API, Image-Pipelines) mit Drift-Erkennung; kube-bench als Job.
  • Image-Scans gehören in CI und laufend in den Cluster (z. B. Trivy Operator), weil neue CVEs alte Images über Nacht kritisch machen.
  • Falco-Meldungen gehen per Falcosidekick an SIEM und Bereitschaft; Quarantäne-Policy und Beweissicherung stehen im Incident-Runbook, nicht im Kopf.
  • Regelmäßige „Red-Team-Tage“ wie dieser Wettkampf zeigen, ob Alarme, Runbooks und Zuständigkeiten im Ernstfall tragen.