Kubernetes-Härtung

Tip

Lernen & üben Sie AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Lernen & üben Sie GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE) Lernen & üben Sie Azure Hacking: HackTricks Training Azure Red Team Expert (AzRTE)

Unterstützen Sie HackTricks

Tools zur Analyse eines Clusters

Steampipe - Kubernetes Compliance

Es führt mehrere Compliance-Checks für den Kubernetes-Cluster durch. Es enthält Unterstützung für CIS sowie die Empfehlungen der National Security Agency (NSA) und den Cybersecurity Technical Report der Cybersecurity and Infrastructure Security Agency (CISA) zur Kubernetes-Härtung.

# 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 ist ein K8s Open-Source-Tool, das ein einheitliches Multi-Cloud-Dashboard bereitstellt und Risikoanalyse, Sicherheits-Compliance, RBAC-Visualizer und Scans auf Image-Schwachstellen umfasst. Kubescape scannt K8s-Cluster, YAML-Dateien und HELM-Charts und erkennt Fehlkonfigurationen gemäß mehreren Frameworks (wie dem NSA-CISA , MITRE ATT&CK®), Software-Schwachstellen und RBAC (role-based-access-control)-Verstöße in frühen Phasen der CI/CD-Pipeline, berechnet sofort einen Risikoscore und zeigt Risikotendenzen im Zeitverlauf.

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

Popeye

Popeye ist ein Dienstprogramm, das laufende Kubernetes-Cluster scannt und mögliche Probleme mit bereitgestellten Ressourcen und Konfigurationen meldet. Es bereinigt Ihren Cluster basierend auf dem, was bereitgestellt ist, und nicht auf dem, was auf der Festplatte liegt. Durch das Scannen Ihres Clusters erkennt es Fehlkonfigurationen und hilft Ihnen sicherzustellen, dass Best Practices eingehalten werden, wodurch zukünftige Probleme vermieden werden. Es hat sich zum Ziel gesetzt, die kognitive _Überlastung zu reduzieren, der man beim Betreiben eines Kubernetes-Clusters in freier Wildbahn ausgesetzt ist. Außerdem, falls Ihr Cluster einen metric-server verwendet, meldet es mögliche Über-/Unter-Allokationen von Ressourcen und versucht, Sie zu warnen, falls Ihrem Cluster die Kapazität ausgeht.

Kube-bench

Das Tool kube-bench prüft, ob Kubernetes sicher bereitgestellt ist, indem es die in den CIS Kubernetes Benchmark.
dokumentierten Checks ausführt.
Sie können wählen:

  • kube-bench aus einem Container heraus ausführen (PID-Namespace mit dem Host teilen)
  • einen Container ausführen, der kube-bench auf dem Host installiert, und dann kube-bench direkt auf dem Host ausführen
  • die neuesten Binaries von der Releases page installieren,
  • es aus dem Quellcode kompilieren.

Kubeaudit

[DEPRECATED] Das Tool kubeaudit ist ein Kommandozeilen-Tool und ein Go-Paket, um Kubernetes-Cluster zu auditieren auf verschiedene Sicherheitsaspekte hin.

Kubeaudit kann erkennen, ob es innerhalb eines Containers in einem Cluster läuft. Falls ja, versucht es, alle Kubernetes-Ressourcen in diesem Cluster zu auditieren:

kubeaudit all

Dieses Tool hat außerdem das Argument autofix, um erkannte Probleme automatisch zu beheben.

Kube-hunter

[VERALTET] Das Tool kube-hunter sucht nach Sicherheitslücken in Kubernetes-Clustern. Das Tool wurde entwickelt, um das Bewusstsein und die Sichtbarkeit für Sicherheitsprobleme in Kubernetes-Umgebungen zu erhöhen.

kube-hunter --remote some.node.com

Trivy

Trivy hat Scanner, die nach Sicherheitsproblemen suchen, und Zielbereiche, in denen diese Probleme gefunden werden können:

  • Container-Image
  • Dateisystem
  • Git-Repository (remote)
  • Virtual Machine Image
  • Kubernetes

Kubei

[Scheint nicht gepflegt zu sein]

Kubei ist ein Tool zum Scannen nach Schwachstellen und für das CIS Docker Benchmark, das Benutzern eine genaue und sofortige Risikobewertung ihrer Kubernetes-Cluster ermöglicht. Kubei scannt alle Images, die in einem Kubernetes-Cluster verwendet werden, einschließlich Images von Application Pods und System Pods.

KubiScan

KubiScan ist ein Tool zum Scannen von Kubernetes-Clustern nach riskanten Berechtigungen im Role-based access control (RBAC)-Autorisierungsmodell von Kubernetes.

Managed Kubernetes Auditing Toolkit

Mkat ist ein Tool, das entwickelt wurde, um andere Arten von hochriskanten Prüfungen im Vergleich zu den anderen Tools zu testen. Es verfügt hauptsächlich über 3 verschiedene Modi:

  • find-role-relationships: Findet, welche AWS-Rollen in welchen Pods laufen
  • find-secrets: Versucht, Secrets in K8s-Ressourcen wie Pods, ConfigMaps und Secrets zu identifizieren.
  • test-imds-access: Versucht, Pods zu starten und auf die Metadata v1 und v2 zuzugreifen. WARNUNG: Dies startet einen Pod im Cluster. Seien Sie sehr vorsichtig, da Sie dies möglicherweise nicht ausführen möchten!

IaC-Code auditieren

KICS

KICS findet Sicherheitslücken, Compliance-Probleme und Infrastrukturfehlkonfigurationen in den folgenden Infrastructure-as-Code-Lösungen: Terraform, Kubernetes, Docker, AWS CloudFormation, Ansible, Helm, Microsoft ARM und OpenAPI 3.0-Spezifikationen

Checkov

Checkov ist ein statisches Code-Analyse-Tool für Infrastructure-as-Code.

Es scannt Cloud-Infrastruktur, die mit Terraform, Terraform plan, Cloudformation, AWS SAM, Kubernetes, Dockerfile, Serverless oder ARM Templates bereitgestellt wurde, und erkennt Sicherheits- und Compliance-Fehlkonfigurationen mittels graphbasierter Scans.

Kube-score

kube-score ist ein Tool, das eine statische Code-Analyse deiner Kubernetes-Objektdefinitionen durchführt.

To install:

DistributionCommand / Link
Vorgefertigte Binärdateien für macOS, Linux und WindowsGitHub releases
Dockerdocker pull zegl/kube-score (Docker Hub)
Homebrew (macOS und Linux)brew install kube-score
Krew (macOS and Linux)kubectl krew install score

Tools zur Analyse von YAML-Dateien & 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 -

Abhängigkeitsprobleme scannen

Container-Images scannen

#!/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

Helm charts scannen

#!/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."

Tipps

Kubernetes PodSecurityContext und SecurityContext

Sie können den security context der Pods (mit PodSecurityContext) und der Container, die ausgeführt werden, (mit SecurityContext) konfigurieren. Für weitere Informationen lesen:

Kubernetes SecurityContext(s)

Kubernetes API-Härtung

Es ist sehr wichtig, den Zugriff auf den Kubernetes Api Server zu schützen, da ein böswilliger Akteur mit ausreichenden Rechten diesen missbrauchen und die Umgebung auf viele Arten schädigen könnte.
Wichtig ist, sowohl den Zugriff (whitelist Origins, die auf den API Server zugreifen dürfen, und alle anderen Verbindungen verweigern) als auch die authentication (nach dem Prinzip der least privilege) abzusichern. Und auf keinen Fall anonymous requests zulassen.

Common Request process:
User or K8s ServiceAccount –> Authentication –> Authorization –> Admission Control.

Tipps:

  • Ports schließen.
  • Anonymen Zugriff vermeiden.
  • NodeRestriction; kein Zugriff von bestimmten Nodes auf die API.
  • https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/#noderestriction
  • Verhindert im Wesentlichen, dass kubelets Labels mit dem Prefix node-restriction.kubernetes.io/ hinzufügen/entfernen/aktualisieren. Dieses Label-Prefix ist Administrators vorbehalten, um ihre Node objects zur Workload-Isolierung zu labeln, und kubelets dürfen Labels mit diesem Prefix nicht ändern.
  • Und ermöglicht außerdem kubelets, diese Labels und Label-Prefixes hinzuzufügen/zu entfernen/zu aktualisieren.
  • Sichere Workload-Isolierung mit Labels gewährleisten.
  • Bestimmte Pods vom API-Zugriff ausschließen.
  • ApiServer nicht dem Internet aussetzen.
  • Unautorisierten Zugriff durch RBAC vermeiden.
  • ApiServer-Port per Firewall und IP-Whitelisting absichern.

SecurityContext-Härtung

Standardmäßig wird der root user verwendet, wenn ein Pod gestartet wird und kein anderer Benutzer angegeben ist. Du kannst deine Anwendung in einem sichereren Kontext ausführen, indem du eine Vorlage ähnlich der folgenden verwendest:

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

Allgemeine Härtung

Aktualisieren Sie Ihre Kubernetes-Umgebung so oft wie nötig, um Folgendes zu gewährleisten:

  • Abhängigkeiten auf dem neuesten Stand.
  • Fehler- und Sicherheitspatches.

Release cycles: Alle 3 Monate erscheint ein neues Minor-Release – 1.20.3 = 1(Major).20(Minor).3(Patch)

Der beste Weg, ein Kubernetes-Cluster zu aktualisieren, ist (von here):

  • Aktualisieren Sie die Master-Node-Komponenten in folgender Reihenfolge:
  • etcd (alle Instanzen).
  • kube-apiserver (auf allen Control-Plane-Hosts).
  • kube-controller-manager.
  • kube-scheduler.
  • cloud controller manager, falls Sie einen verwenden.
  • Aktualisieren Sie die Worker-Node-Komponenten wie kube-proxy, kubelet.

Kubernetes-Monitoring & Sicherheit:

  • Kyverno Policy Engine
  • Cilium Tetragon - eBPF-basierte Sicherheits-Observability und Laufzeitdurchsetzung
  • Network-Sicherheitsrichtlinien
  • Falco - Runtime-Sicherheitsüberwachung & Erkennung

Tip

Lernen & üben Sie AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Lernen & üben Sie GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE) Lernen & üben Sie Azure Hacking: HackTricks Training Azure Red Team Expert (AzRTE)

Unterstützen Sie HackTricks