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=5432Und 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=90sFortschritt 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-notokenFortschritt 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 5432Erwartet: … 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 shopErwartet (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: falseals Default pro ServiceAccount setzen; nur Pods, die die API wirklich brauchen, bekommen ein Token (per Pod wiedertrue).- Anonymen Zugriff auf
/versionund Discovery einschränken: Der kube-apiserver kann anonyme Requests begrenzen; in gehärteten Setups (CIS) ist--anonymous-auth=falsebzw. eineAnonymousAuthConfigurationgesetzt. - 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).