# Kubernetes Hardening

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

## Strumenti per analizzare un cluster

### [Steampipe - Kubernetes Compliance](https://github.com/turbot/steampipe-mod-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.
```bash
# 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**](https://github.com/armosec/kubescape)

[**Kubescape**](https://github.com/armosec/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](https://www.armosec.io/blog/kubernetes-hardening-guidance-summary-by-armo) , [MITRE ATT\&CK®](https://www.microsoft.com/security/blog/2021/03/23/secure-containerized-environments-with-updated-threat-matrix-for-kubernetes/)), 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.
```bash
curl -s https://raw.githubusercontent.com/kubescape/kubescape/master/install.sh | /bin/bash
kubescape scan --verbose
```
### [**Popeye**](https://github.com/derailed/popeye)

[**Popeye**](https://github.com/derailed/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**](https://github.com/aquasecurity/kube-bench)

The tool [**kube-bench**](https://github.com/aquasecurity/kube-bench) is a tool that checks whether Kubernetes is deployed securely by running the checks documented in the [**CIS Kubernetes Benchmark**](https://www.cisecurity.org/benchmark/kubernetes/).\
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](https://github.com/aquasecurity/kube-bench/releases),
- compilare da sorgente.

### [**Kubeaudit**](https://github.com/Shopify/kubeaudit)

**[DEPRECATED]** The tool [**kubeaudit**](https://github.com/Shopify/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**](https://github.com/aquasecurity/kube-hunter)

**[DEPRECATO]** Lo strumento [**kube-hunter**](https://github.com/aquasecurity/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.
```bash
kube-hunter --remote some.node.com
```
### [Trivy](https://github.com/aquasecurity/trivy)

[Trivy](https://github.com/aquasecurity/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**](https://github.com/Erezf-p/kubei)

**[Sembra non mantenuto]**

[**Kubei**](https://github.com/Erezf-p/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**](https://github.com/cyberark/KubiScan)

[**KubiScan**](https://github.com/cyberark/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](https://github.com/DataDog/managed-kubernetes-auditing-toolkit)

[**Mkat**](https://github.com/DataDog/managed-kubernetes-auditing-toolkit) è 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**](https://github.com/Checkmarx/kics)

[**KICS**](https://github.com/Checkmarx/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**](https://github.com/bridgecrewio/checkov)

[**Checkov**](https://github.com/bridgecrewio/checkov) è uno strumento di analisi statica del codice per infrastructure-as-code.

Scansiona l'infrastruttura cloud provisionata tramite [Terraform](https://terraform.io), Terraform plan, [Cloudformation](https://aws.amazon.com/cloudformation/), [AWS SAM](https://aws.amazon.com/serverless/sam/), [Kubernetes](https://kubernetes.io), [Dockerfile](https://www.docker.com), [Serverless](https://www.serverless.com) o [ARM Templates](https://docs.microsoft.com/en-us/azure/azure-resource-manager/templates/overview) e rileva errate configurazioni di sicurezza e conformità usando una scansione basata su grafi.

### [**Kube-score**](https://github.com/zegl/kube-score)

[**kube-score**](https://github.com/zegl/kube-score) è uno strumento che esegue analisi statica del codice delle definizioni degli oggetti Kubernetes.

Per installare:

| Distribuzione                                        | Comando / Link                                                                          |
| --------------------------------------------------- | --------------------------------------------------------------------------------------- |
| Binarie precompilate per macOS, Linux, and Windows  | [GitHub releases](https://github.com/zegl/kube-score/releases)                          |
| Docker                                              | `docker pull zegl/kube-score` ([Docker Hub)](https://hub.docker.com/r/zegl/kube-score/) |
| Homebrew (macOS and Linux)                          | `brew install kube-score`                                                               |
| [Krew](https://krew.sigs.k8s.io/) (macOS and Linux) | `kubectl krew install score`                                                            |

## Strumenti per analizzare file YAML e Helm Charts

### [**Kube-linter**](https://github.com/stackrox/kube-linter)
```bash
# Install Kube-linter
brew install kube-linter

# Run Kube-linter
## lint ./path/to/yaml/or/chart
```
### [Checkov](https://github.com/bridgecrewio/checkov)
```bash
# Install Checkov
pip install checkov

# Run Checkov
checkov -d ./path/to/yaml/or/chart
```
### [kube‑score](https://github.com/zegl/kube-score)
```bash
# 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](https://github.com/controlplaneio/kubesec)
```bash
# 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
```bash
#!/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
```bash
#!/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:

{{#ref}}
kubernetes-securitycontext-s.md
{{#endref}}

### 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**](https://kubernetes.io/docs/reference/command-line-tools-reference/kubelet-authentication-authorization/) (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](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:
```yaml
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
```
- [https://kubernetes.io/docs/tasks/configure-pod-container/security-context/](https://kubernetes.io/docs/tasks/configure-pod-container/security-context/)
- [https://kubernetes.io/docs/concepts/policy/pod-security-policy/](https://kubernetes.io/docs/concepts/policy/pod-security-policy/)

### 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**](https://kubernetes.io/docs/setup/release/version-skew-policy/): 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**](https://kubernetes.io/docs/tasks/administer-cluster/cluster-upgrade/)**):**

- 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

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