Kubernetes Hardening

Tip

Impara e pratica il hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica il hacking GCP: HackTricks Training GCP Red Team Expert (GRTE) Impara e pratica il hacking Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Supporta HackTricks

Strumenti per analizzare un cluster

Steampipe - Kubernetes Compliance

Esegue diversi controlli di compliance sul cluster Kubernetes. Include il supporto per CIS e per il Cybersecurity technical report della National Security Agency (NSA) e della Cybersecurity and Infrastructure Security Agency (CISA) per il hardening di Kubernetes.

# Install Steampipe
brew install turbot/tap/powerpipe
brew install turbot/tap/steampipe
steampipe plugin install kubernetes

# Start the service
steampipe service start

# Install the module
mkdir dashboards
cd dashboards
powerpipe mod init
powerpipe mod install github.com/turbot/steampipe-mod-kubernetes-compliance

# Run the module
powerpipe server

Kubescape

Kubescape è uno strumento open-source per K8s che fornisce una single pane of glass multi-cloud per K8s, inclusa analisi del rischio, compliance di sicurezza, visualizzatore RBAC e scansione delle vulnerabilità delle immagini. Kubescape esegue la scansione di cluster K8s, file YAML e chart HELM, rilevando misconfigurazioni secondo più framework (come il NSA-CISA , MITRE ATT&CK®), vulnerabilità software e violazioni RBAC (role-based-access-control) nelle prime fasi della pipeline CI/CD, calcola istantaneamente il punteggio di rischio e mostra le tendenze del rischio nel tempo.

curl -s https://raw.githubusercontent.com/kubescape/kubescape/master/install.sh | /bin/bash
kubescape scan --verbose

Popeye

Popeye è un’utilità che esegue la scansione di cluster Kubernetes live e segnala potenziali problemi con le risorse e le configurazioni deployate. Pulisce il tuo cluster basandosi su ciò che è effettivamente deployato e non su ciò che è presente su disco. Scansionando il cluster rileva le misconfigurazioni e ti aiuta a garantire che le best practice siano in atto, prevenendo così futuri mal di testa. Ha l’obiettivo di ridurre il sovraccarico cognitivo che si incontra nell’operare un cluster Kubernetes in ambienti non controllati. Inoltre, se il tuo cluster utilizza un metric-server, segnala potenziali sovra/sotto-allocazioni di risorse e tenta di avvisarti qualora il cluster stia esaurendo la capacità.

Kube-bench

The tool kube-bench is a tool that checks whether Kubernetes is deployed securely by running the checks documented in the CIS Kubernetes Benchmark.
You can choose to:

  • eseguire kube-bench all’interno di un container (condivisione del namespace PID con l’host)
  • eseguire un container che installa kube-bench sull’host, e poi eseguire kube-bench direttamente sull’host
  • installare gli ultimi binari dalla Releases page,
  • compilare da sorgente.

Kubeaudit

[DEPRECATED] The tool kubeaudit is a command line tool and a Go package to audit Kubernetes clusters for various different security concerns.

Kubeaudit può rilevare se è in esecuzione all’interno di un container in un cluster. In tal caso, proverà a eseguire l’audit di tutte le risorse Kubernetes in quel cluster:

kubeaudit all

Questo strumento ha anche l’argomento autofix per correggere automaticamente i problemi rilevati.

Kube-hunter

[DEPRECATO] Lo strumento kube-hunter ricerca vulnerabilità di sicurezza nei cluster Kubernetes. Lo strumento è stato sviluppato per aumentare la consapevolezza e la visibilità dei problemi di sicurezza negli ambienti Kubernetes.

kube-hunter --remote some.node.com

Trivy

Trivy ha scanner che cercano problemi di sicurezza e obiettivi dove può trovare questi problemi:

  • Immagine container
  • File system
  • Repository Git (remoto)
  • Immagine macchina virtuale
  • Kubernetes

Kubei

[Sembra non mantenuto]

Kubei è uno strumento di vulnerability scanning e CIS Docker benchmark che permette agli utenti di ottenere una valutazione accurata e immediata del rischio dei loro cluster Kubernetes. Kubei scansiona tutte le immagini usate in un cluster Kubernetes, incluse le immagini dei pod di applicazioni e dei pod di sistema.

KubiScan

KubiScan è uno strumento per scansionare cluster Kubernetes alla ricerca di permessi rischiosi nel modello di autorizzazione Role-based access control (RBAC) di Kubernetes.

Managed Kubernetes Auditing Toolkit

Mkat è uno strumento creato per testare altri tipi di controlli ad alto rischio rispetto agli altri strumenti. Ha principalmente 3 modalità differenti:

  • find-role-relationships: che troverà quali AWS roles sono in esecuzione in quali pod
  • find-secrets: che cerca di identificare secrets nelle risorse K8s come Pods, ConfigMaps e Secrets.
  • test-imds-access: che cercherà di eseguire pod e tentare di accedere ai metadati v1 e v2. ATTENZIONE: questo farà girare un pod nel cluster, presta molta attenzione perché potresti non volerlo fare!

Audit del codice IaC

KICS

KICS trova vulnerabilità di sicurezza, problemi di conformità e errate configurazioni d’infrastruttura nelle seguenti soluzioni Infrastructure as Code: Terraform, Kubernetes, Docker, AWS CloudFormation, Ansible, Helm, Microsoft ARM e specifiche OpenAPI 3.0

Checkov

Checkov è uno strumento di analisi statica del codice per infrastructure-as-code.

Scansiona l’infrastruttura cloud provisionata tramite Terraform, Terraform plan, Cloudformation, AWS SAM, Kubernetes, Dockerfile, Serverless o ARM Templates e rileva errate configurazioni di sicurezza e conformità usando una scansione basata su grafi.

Kube-score

kube-score è uno strumento che esegue analisi statica del codice delle definizioni degli oggetti Kubernetes.

Per installare:

DistribuzioneComando / Link
Binarie precompilate per macOS, Linux, and WindowsGitHub releases
Dockerdocker pull zegl/kube-score (Docker Hub)
Homebrew (macOS and Linux)brew install kube-score
Krew (macOS and Linux)kubectl krew install score

Strumenti per analizzare file YAML e Helm Charts

Kube-linter

# Install Kube-linter
brew install kube-linter

# Run Kube-linter
## lint ./path/to/yaml/or/chart

Checkov

# Install Checkov
pip install checkov

# Run Checkov
checkov -d ./path/to/yaml/or/chart

kube‑score

# Install kube-score
brew install kube-score

# Run kube-score
kube-score score ./path/to/yaml
# or
helm template chart /path/to/chart | kube-score score -
# or if the chart needs some values
helm template chart /path/to/chart \
--set 'config.urls[0]=https://dummy.backend.internal' \
| kube-score score -

Kubesec

# Install Kubesec
## Download from https://github.com/controlplaneio/kubesec/releases

# Run Kubesec in a yaml
kubesec scan ./path/to/yaml
# or
helm template chart /path/to/chart | kubesec scan -
# or if the chart needs some values
helm template chart /path/to/chart \
--set 'config.urls[0]=https://dummy.backend.internal' \
| kubesec scan -

Scansione dei problemi delle dipendenze

Scansione delle immagini

#!/bin/bash
export images=$(kubectl get pods --all-namespaces -o jsonpath="{range .items[]}{.spec.containers[].image}{'\n'}{end}" | sort | uniq)
echo "All images found: $images"
echo ""
echo ""
for image in $images; do
# Run trivy scan and save JSON output
trivy image --format json --output /tmp/result.json --severity HIGH,CRITICAL "$image" >/dev/null 2>&1
# Extract binary targets that have vulnerabilities
binaries=$(jq -r '.Results[] | select(.Vulnerabilities != null) | .Target' /tmp/result.json)
if [ -n "$binaries" ]; then
echo "- **Image:** $image"
while IFS= read -r binary; do
echo "  - **Binary:** $binary"
jq -r --arg target "$binary" '
.Results[] | select(.Target == $target) | .Vulnerabilities[] |
"    - **\(.Title)** (\(.Severity)): Affecting `\(.PkgName)` fixed in version `\(.FixedVersion)` (current version is `\(.InstalledVersion)`)."
' /tmp/result.json
done <<< "$binaries"
echo ""
echo ""
echo ""
fi
done

Scansiona Helm charts

#!/bin/bash
# scan-helm-charts.sh
# This script lists all Helm releases, renders their manifests,
# and then scans each manifest with Trivy for configuration issues.

# Check that jq is installed
if ! command -v jq &>/dev/null; then
echo "jq is required but not installed. Please install jq and rerun."
exit 1
fi

# List all helm releases and extract namespace and release name
echo "Listing Helm releases..."
helm list --all-namespaces -o json | jq -r '.[] | "\(.namespace) \(.name)"' > helm_releases.txt

# Check if any releases were found
if [ ! -s helm_releases.txt ]; then
echo "No Helm releases found."
exit 0
fi

# Loop through each Helm release and scan its rendered manifest
while IFS=" " read -r namespace release; do
echo "---------------------------------------------"
echo "Scanning Helm release '$release' in namespace '$namespace'..."
# Render the Helm chart manifest
manifest_file="${release}-manifest.yaml"
helm get manifest "$release" -n "$namespace" > "$manifest_file"
if [ $? -ne 0 ]; then
echo "Failed to get manifest for $release in $namespace. Skipping."
continue
fi
# Scan the manifest with Trivy (configuration scan)
echo "Running Trivy config scan on $manifest_file..."
trivy config --severity MEDIUM,HIGH,CRITICAL "$manifest_file"
echo "Completed scan for $release."
done < helm_releases.txt

echo "---------------------------------------------"
echo "Helm chart scanning complete."

Suggerimenti

Kubernetes PodSecurityContext e SecurityContext

Puoi configurare il contesto di sicurezza dei Pod (con PodSecurityContext) e dei container che verranno eseguiti (con SecurityContext). Per maggiori informazioni leggi:

Kubernetes SecurityContext(s)

Hardening dell’API di Kubernetes

È molto importante proteggere l’accesso al Kubernetes Api Server perché un attore malevolo con privilegi sufficienti potrebbe abusarne e danneggiare in molti modi l’ambiente.
È importante mettere in sicurezza sia l’accesso (whitelist delle origini per accedere all’API Server e negare qualsiasi altra connessione) sia la authentication (seguendo il principio del minimo privilegio). E sicuramente mai consentire richieste anonime.

Processo comune delle richieste:
User o K8s ServiceAccount –> Authentication –> Authorization –> Admission Control.

Consigli:

  • Chiudere le porte.
  • Evitare l’accesso Anonymous.
  • NodeRestriction; nessun accesso da specifici nodi all’API.
  • https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/#noderestriction
  • Fondamentalmente impedisce ai kubelet di aggiungere/rimuovere/aggiornare label con il prefisso node-restriction.kubernetes.io/. Questo prefisso di label è riservato agli amministratori per etichettare gli oggetti Node a scopi di isolamento dei workload, e ai kubelet non sarà permesso modificare label con quel prefisso.
  • Inoltre, permette ai kubelet di aggiungere/rimuovere/aggiornare queste label e i prefissi di label.
  • Assicurare l’isolamento sicuro dei workload tramite label.
  • Evitare che specifici pod abbiano accesso all’API.
  • Evitare l’esposizione dell’ApiServer su Internet.
  • Evitare accessi non autorizzati tramite RBAC.
  • Proteggere la porta dell’ApiServer con firewall e whitelist di IP.

Hardening di SecurityContext

Per default l’utente root verrà utilizzato quando un Pod viene avviato se non viene specificato un altro utente. Puoi eseguire la tua applicazione in un contesto più sicuro usando un template simile al seguente:

apiVersion: v1
kind: Pod
metadata:
name: security-context-demo
spec:
securityContext:
runAsUser: 1000
runAsGroup: 3000
fsGroup: 2000
volumes:
- name: sec-ctx-vol
emptyDir: {}
containers:
- name: sec-ctx-demo
image: busybox
command: [ "sh", "-c", "sleep 1h" ]
securityContext:
runAsNonRoot: true
volumeMounts:
- name: sec-ctx-vol
mountPath: /data/demo
securityContext:
allowPrivilegeEscalation: true

Hardening generale

Dovresti aggiornare il tuo ambiente Kubernetes con la frequenza necessaria per avere:

  • Dipendenze aggiornate.
  • Correzioni di bug e patch di sicurezza.

Release cycles: Ogni 3 mesi viene rilasciata una nuova minor release – 1.20.3 = 1(Major).20(Minor).3(patch)

Il modo migliore per aggiornare un Kubernetes Cluster è (da here):

  • Aggiorna i componenti del Master Node seguendo questa sequenza:
  • etcd (tutte le istanze).
  • kube-apiserver (tutti i control plane hosts).
  • kube-controller-manager.
  • kube-scheduler.
  • cloud controller manager, se ne usi uno.
  • Aggiorna i componenti dei Worker Node come kube-proxy, kubelet.

Monitoraggio e sicurezza di Kubernetes:

  • Kyverno Policy Engine
  • Cilium Tetragon - osservabilità della sicurezza basata su eBPF e enforcement a runtime
  • Policy di sicurezza di rete
  • Falco - monitoraggio e rilevamento della sicurezza a runtime

Tip

Impara e pratica il hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica il hacking GCP: HackTricks Training GCP Red Team Expert (GRTE) Impara e pratica il hacking Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Supporta HackTricks