Tag 8: Flaches Netz und Lateral Movement
Ziel: Du stoppst die seitliche Bewegung vom Angreifer-Pod zur Datenbank mit Default-Deny plus gezielten Allow-Regeln. · Dauer: ca. 70 min · Voraussetzung: Tag 1
Briefing
In Kubernetes darf standardmäßig jeder Pod jeden anderen erreichen –
über alle Namespaces hinweg. Ein kompromittierter Pod in
attacker spricht die Datenbank in shop an, als
gehörten sie zusammen. Das ist lateral movement: der Sprung vom
ersten übernommenen Pod zum eigentlichen Ziel. Die Abwehr ist eine
NetworkPolicy – erst alles zu (Default
Deny), dann nur die Pfade auf, die die Anwendung wirklich
braucht.
attacker/shell --X--> shop/db (soll blockiert sein)
shop/frontend -----> shop/api ----> shop/db (soll erlaubt sein)
Drill 1: Die Fehlkonfiguration – kein Default Deny
Der Ausgangszustand aus Tag 1, nochmal scharf gemacht: Der Angreifer erreicht die DB.
kubectl -n attacker exec shell -- nc -zv -w3 db.shop.svc 5432Erwartet:
Connection to db.shop.svc (10.43.161.163) 5432 port [tcp/postgresql] succeeded!
Fortschritt speichern? Kostenlos registrieren
Drill 2: Erster Schritt – alles zu
Eine NetworkPolicy mit leerem podSelector
trifft alle Pods des Namespace; ohne ingress-Regel ist
damit jeder eingehende Verkehr verboten:
kubectl -n shop apply -f - <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata: {name: default-deny-ingress, namespace: shop}
spec:
podSelector: {}
policyTypes: ["Ingress"]
EOFDer Angreifer ist draußen:
kubectl -n attacker exec shell -- nc -zv -w4 db.shop.svc 5432Erwartet:
command terminated with exit code 1
Aber Vorsicht – jetzt ist auch die Anwendung selbst blockiert:
FE=$(kubectl -n shop get pod -l app=frontend -o jsonpath='{.items[0].metadata.name}')
kubectl -n shop exec $FE -- curl -s -o /dev/null -w "%{http_code}\n" --max-time 4 \
http://api.shop.svc:80Erwartet:
command terminated with exit code 28
28 ist der curl-Timeout: Default Deny trifft eben
wirklich alle. Deshalb folgt sofort der zweite Schritt.
Fortschritt speichern? Kostenlos registrieren
Drill 3: Fix – nur die nötigen Pfade öffnen
Erlaube genau frontend → api und api → db,
je auf dem richtigen Port:
kubectl -n shop apply -f - <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata: {name: allow-frontend-to-api, namespace: shop}
spec:
podSelector: {matchLabels: {app: api}}
policyTypes: ["Ingress"]
ingress:
- from: [{podSelector: {matchLabels: {app: frontend}}}]
ports: [{protocol: TCP, port: 80}]
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata: {name: allow-api-to-db, namespace: shop}
spec:
podSelector: {matchLabels: {app: db}}
policyTypes: ["Ingress"]
ingress:
- from: [{podSelector: {matchLabels: {app: api}}}]
ports: [{protocol: TCP, port: 5432}]
EOFWarum podSelector statt namespaceSelector? NetworkPolicies wählen Quellen über Labels, nicht über IPs.
app: frontendist der Vertrag – wer dieses Label trägt, darf; alle anderen nicht.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Nachweis – legitim läuft, Angreifer bleibt draußen
FE=$(kubectl -n shop get pod -l app=frontend -o jsonpath='{.items[0].metadata.name}')
echo -n "frontend->api: "; kubectl -n shop exec $FE -- \
curl -s -o /dev/null -w "%{http_code}\n" --max-time 5 http://api.shop.svc:80
echo -n "attacker->db: "; kubectl -n attacker exec shell -- \
nc -zv -w4 db.shop.svc 5432 2>&1 | tail -1
echo -n "attacker->api: "; kubectl -n attacker exec shell -- \
curl -s -o /dev/null -w "code=%{http_code}\n" --max-time 4 http://api.shop.svc:80Erwartet:
frontend->api: 200
attacker->db: command terminated with exit code 1
attacker->api: command terminated with exit code 28
Die Anwendung funktioniert, der seitliche Sprung ist tot. Diese
Policies bleiben – sie sind ab jetzt der gehärtete
Zustand von shop.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
Der Angreifer erreicht die DB nicht mehr:
kubectl -n attacker exec shell -- nc -zv -w4 db.shop.svc 5432; echo "rc=$?"Erwartet: rc=1
Der legitime Pfad steht:
FE=$(kubectl -n shop get pod -l app=frontend -o jsonpath='{.items[0].metadata.name}')
kubectl -n shop exec $FE -- curl -s -o /dev/null -w "%{http_code}\n" --max-time 5 \
http://api.shop.svc:80Erwartet: 200
Challenge
Default Deny für Ingress hält Angreifer von
shop fern. Aber ein kompromittierter shop-Pod
könnte noch nach außen telefonieren (Exfiltration, C2). Ergänze eine
Default-Deny-Egress-Regel, die nur DNS erlaubt, und
prüfe, dass beliebiger Ausgangsverkehr dann scheitert.
Hinweis: DNS läuft über UDP/TCP 53 zu CoreDNS in
kube-system (k8s-app: kube-dns). Ohne diese
Ausnahme funktioniert nicht einmal Namensauflösung.
Lösung
kubectl -n shop apply -f - <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata: {name: default-deny-egress, namespace: shop}
spec:
podSelector: {}
policyTypes: ["Egress"]
egress:
- to:
- namespaceSelector: {matchLabels: {kubernetes.io/metadata.name: kube-system}}
podSelector: {matchLabels: {k8s-app: kube-dns}}
ports: [{protocol: UDP, port: 53}, {protocol: TCP, port: 53}]
EOF
FE=$(kubectl -n shop get pod -l app=frontend -o jsonpath='{.items[0].metadata.name}')
kubectl -n shop exec $FE -- curl -s -o /dev/null -w "%{http_code}\n" --max-time 4 \
https://example.comErwartet:
command terminated with exit code 28
Ein curl-Timeout – beliebiger Ausgangsverkehr ist dicht, nur DNS
bliebe erlaubt. (Für die weiteren Tage räum diese Egress-Regel wieder
weg:
kubectl -n shop delete networkpolicy default-deny-egress.)
Fortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- Default Deny (Ingress und Egress) pro Namespace ist die Grundlinie; Kyverno kann sie für jeden neuen Namespace automatisch erzeugen (Tag 12).
- Policies brauchen einen CNI, der sie durchsetzt – RKE2 bringt Canal (Calico) mit. Flannel allein ignoriert NetworkPolicies stillschweigend.
- Für L7-Regeln (nur
GET /health), FQDN-Egress und Sichtbarkeit (welcher Verkehr wurde verworfen?) siehe Cilium/Hubble – Thema des Kurses „Kyverno & NetworkPolicies”. - Namespaces konsequent mit Labels versehen;
namespaceSelectorist nur so verlässlich wie die Labels, auf die er zeigt.