Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 1: Was ein kompromittierter Pod sieht

Ziel: Du siehst den Cluster mit den Augen eines übernommenen Workloads – Token, API, Netz. · Dauer: ca. 60 min · Voraussetzung: Tag 0

Briefing

Ein Angreifer bekommt selten gleich cluster-admin. Der übliche Einstieg: Eine Anwendung hat eine Lücke (SSRF, RCE, ein verwundbares Image), und der Angreifer sitzt plötzlich in einem Pod. Von dort zählt nur, was dieser Pod kann. Heute inventarisierst du diesen Startpunkt – zwei Fragen:

  • Was darf das Token des Pods an der Kubernetes-API?
  • Wen erreicht der Pod im Netz?

Die erste Antwort ist in einem frischen Cluster beruhigend, die zweite alarmierend.

Drill 1: Wer bin ich? (Token-Identität)

Im Angreifer-Pod aus Tag 0. Das Token liegt im Dateisystem; mit ihm fragst du die API, als wer du giltst:

kubectl -n attacker exec shell -- bash -c '
TOKEN=$(cat /var/run/secrets/kubernetes.io/serviceaccount/token)
CACERT=/var/run/secrets/kubernetes.io/serviceaccount/ca.crt
curl -s --cacert $CACERT -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -X POST https://kubernetes.default.svc/apis/authentication.k8s.io/v1/selfsubjectreviews \
  -d "{\"apiVersion\":\"authentication.k8s.io/v1\",\"kind\":\"SelfSubjectReview\"}"'

Erwartet (gekürzt):

"status": {
  "userInfo": {
    "username": "system:serviceaccount:attacker:default",
    "groups": [
      "system:serviceaccounts",
      "system:serviceaccounts:attacker",
      "system:authenticated"
    ]

Du bist system:serviceaccount:attacker:default – der Standard-ServiceAccount des Namespace. Merk dir die Gruppen: Eine zu weite Rolle, die an system:authenticated oder system:serviceaccounts hängt, trifft jeden Pod im Cluster.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Was darf ich? (RBAC von innen)

Versuch, die Pods im eigenen Namespace zu listen:

kubectl -n attacker exec shell -- bash -c '
TOKEN=$(cat /var/run/secrets/kubernetes.io/serviceaccount/token)
CACERT=/var/run/secrets/kubernetes.io/serviceaccount/ca.crt
curl -s -o /dev/null -w "%{http_code}\n" --cacert $CACERT \
  -H "Authorization: Bearer $TOKEN" \
  https://kubernetes.default.svc/api/v1/namespaces/attacker/pods'

Erwartet:

403

Gut so. Der default-ServiceAccount hat in einem frischen Cluster keine RBAC-Rechte. Lesen kannst du trotzdem etwas – alles, was jeder authentifizierte Nutzer darf:

kubectl -n attacker exec shell -- bash -c '
TOKEN=$(cat /var/run/secrets/kubernetes.io/serviceaccount/token)
CACERT=/var/run/secrets/kubernetes.io/serviceaccount/ca.crt
curl -s --cacert $CACERT -H "Authorization: Bearer $TOKEN" \
  https://kubernetes.default.svc/version'

Erwartet (gekürzt):

{
  "major": "1",
  "minor": "36",
  "gitVersion": "v1.36.6+rke2r1",

Die Version zu kennen ist der erste Schritt zum passenden CVE (Tag 13). Schon diese Kleinigkeit solltest du einem anonymen Aufrufer nicht schenken – dazu die Enterprise-Notiz.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Wen erreiche ich? (Netz von innen)

Jetzt die zweite Frage. Leg der Opfer-Anwendung Services vor (falls aus Tag 0 noch nicht da), damit du sie über DNS triffst:

kubectl -n shop expose deployment frontend --port=8080
kubectl -n shop expose deployment api --port=80
kubectl -n shop expose deployment db --port=5432

Und nun aus dem Angreifer-Pod heraus quer durch den Cluster:

kubectl -n attacker exec shell -- bash -c '
echo -n "frontend: "; curl -s -o /dev/null -w "%{http_code}\n" --max-time 5 \
  http://frontend.shop.svc:8080
echo -n "api:      "; curl -s -o /dev/null -w "%{http_code}\n" --max-time 5 \
  http://api.shop.svc:80
echo -n "db:5432:  "; nc -zv -w3 db.shop.svc 5432'

Erwartet:

frontend: 200
api:      200
db:5432:  Connection to db.shop.svc (10.43.161.163) 5432 port [tcp/postgresql] succeeded!

Das ist der Schock: Ein Pod im Namespace attacker erreicht die Datenbank im Namespace shop – ungefragt. In Kubernetes ist das Netz standardmäßig flach: Ohne NetworkPolicy darf jeder Pod jeden anderen ansprechen. Genau das schließt du an Tag 8.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Fix – Token abschalten, wo keins gebraucht wird

Die meisten Workloads reden nie mit der Kubernetes-API. Dann gehört ihnen auch kein Token. Bau denselben Pod mit automountServiceAccountToken: false:

kubectl -n attacker apply -f - <<'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: shell-notoken
spec:
  automountServiceAccountToken: false
  containers:
  - name: shell
    image: nicolaka/netshoot
    command: ["sleep","infinity"]
EOF
kubectl -n attacker wait --for=condition=Ready pod/shell-notoken --timeout=90s

Fortschritt speichern? Kostenlos registrieren

Drill 5: Nachweis – kein Token, keine API

kubectl -n attacker exec shell-notoken -- \
  ls /var/run/secrets/kubernetes.io/serviceaccount/

Erwartet:

ls: /var/run/secrets/kubernetes.io/serviceaccount/: No such file or directory
command terminated with exit code 1

Und ohne Token gilt der Pod an der API als niemand:

kubectl -n attacker exec shell-notoken -- bash -c '
curl -s -o /dev/null -w "%{http_code}\n" --max-time 5 -k \
  https://kubernetes.default.svc/api/v1/namespaces/attacker/pods'

Erwartet:

401

401 statt 403: Vorher warst du ein bekannter, aber rechtloser Account; jetzt bist du gar nicht erst authentifiziert. Eine Angriffsfläche weniger.

kubectl -n attacker delete pod shell-notoken

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

Der normale Angreifer-Pod hat ein Token und ist ein benannter Account (403, nicht 401):

kubectl -n attacker exec shell -- bash -c '
TOKEN=$(cat /var/run/secrets/kubernetes.io/serviceaccount/token)
curl -s -o /dev/null -w "%{http_code}\n" -k \
  -H "Authorization: Bearer $TOKEN" \
  https://kubernetes.default.svc/api/v1/namespaces/attacker/pods'

Erwartet: 403

Das flache Netz ist real – die DB ist aus attacker erreichbar:

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

Erwartet: … 5432 port [tcp/postgresql] succeeded!

Challenge

Finde heraus, ob der default-ServiceAccount des Namespace shop mehr darf als der in attacker – ohne in einen Pod zu gehen. Nutze die Fähigkeit von kubectl, eine Anfrage im Namen eines anderen Accounts zu stellen.

Hinweis: kubectl auth can-i --list kennt die Flagge --as.

Lösung

kubectl auth can-i --list \
  --as=system:serviceaccount:shop:default -n shop

Erwartet (gekürzt):

Resources                                       Non-Resource URLs       Resource Names   Verbs
selfsubjectreviews.authentication.k8s.io        []                      []               [create]
selfsubjectaccessreviews.authorization.k8s.io   []                      []               [create]
selfsubjectrulesreviews.authorization.k8s.io    []                      []               [create]
                                                [/api/*]                []               [get]
                                                [/healthz]              []               [get]
...

In einem frischen Cluster sieht die Liste karg aus – nur Selbstauskünfte und ein paar Non-Resource-URLs, die jeder authentifizierte Account darf. Taucht dort eine echte Ressource wie pods oder secrets auf, hat ein Chart oder eine RoleBinding zu viel vergeben. Das jagst du an Tag 2.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • automountServiceAccountToken: false als Default pro ServiceAccount setzen; nur Pods, die die API wirklich brauchen, bekommen ein Token (per Pod wieder true).
  • Anonymen Zugriff auf /version und Discovery einschränken: Der kube-apiserver kann anonyme Requests begrenzen; in gehärteten Setups (CIS) ist --anonymous-auth=false bzw. eine AnonymousAuthConfiguration gesetzt.
  • Das flache Netz ist der größte Hebel: Default-Deny-NetworkPolicy pro Namespace (Tag 8).
  • Audit-Logging einschalten, damit solche API-Aufrufe eines Workload-Tokens überhaupt sichtbar werden (Tag 3).