Zum Inhalt springen
Trainingslager IT-Trainingslager

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 5432

Erwartet:

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"]
EOF

Der Angreifer ist draußen:

kubectl -n attacker exec shell -- nc -zv -w4 db.shop.svc 5432

Erwartet:

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:80

Erwartet:

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}]
EOF

Warum podSelector statt namespaceSelector? NetworkPolicies wählen Quellen über Labels, nicht über IPs. app: frontend ist 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:80

Erwartet:

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:80

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

Erwartet:

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; namespaceSelector ist nur so verlässlich wie die Labels, auf die er zeigt.