Kubernetes Hardening

Tip

Aprenda e pratique Hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Aprenda e pratique Hacking GCP: HackTricks Training GCP Red Team Expert (GRTE) Aprenda e pratique Hacking Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Support HackTricks

Ferramentas para analisar um cluster

Steampipe - Kubernetes Compliance

Realiza várias verificações de conformidade no cluster Kubernetes. Inclui suporte para CIS, National Security Agency (NSA) e o relatório técnico da Cybersecurity and Infrastructure Security Agency (CISA) sobre Kubernetes hardening.

# 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 é uma ferramenta open-source para K8s que fornece um painel unificado multi-cloud, incluindo análise de risco, conformidade de segurança, visualizador de RBAC e varredura de vulnerabilidades em imagens. Kubescape escaneia clusters K8s, arquivos YAML e charts HELM, detectando misconfigurações de acordo com múltiplos frameworks (como o NSA-CISA, MITRE ATT&CK®), vulnerabilidades de software e violações de RBAC (role-based-access-control) nas fases iniciais da pipeline CI/CD, calcula a pontuação de risco instantaneamente e mostra tendências de risco ao longo do tempo.

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

Popeye

Popeye é uma utilidade que analisa clusters Kubernetes em execução e relata potenciais problemas com recursos e configurações implantadas. Ele sanitiza seu cluster com base no que está implantado e não no que está em disco. Ao escanear seu cluster, detecta configurações incorretas e ajuda a garantir que as melhores práticas estejam em vigor, prevenindo dores de cabeça futuras. Visa reduzir a sobrecarga cognitiva que se enfrenta ao operar um cluster Kubernetes em produção. Além disso, se seu cluster empregar um metric-server, ele relata possíveis alocações excessivas/insuficientes de recursos e tenta avisar caso seu cluster fique sem capacidade.

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:

  • run kube-bench from inside a container (sharing PID namespace with the host)
  • run a container that installs kube-bench on the host, and then run kube-bench directly on the host
  • install the latest binaries from the Releases page,
  • compile it from source.

Kubeaudit

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

Kubeaudit can detect if it is running within a container in a cluster. If so, it will try to audit all Kubernetes resources in that cluster:

kubeaudit all

Esta ferramenta também tem o argumento autofix para corrigir automaticamente problemas detectados.

Kube-hunter

[OBSOLETO] A ferramenta kube-hunter procura por vulnerabilidades de segurança em clusters Kubernetes. A ferramenta foi desenvolvida para aumentar a conscientização e a visibilidade sobre problemas de segurança em ambientes Kubernetes.

kube-hunter --remote some.node.com

Trivy

Trivy possui scanners que procuram por problemas de segurança e alvos onde pode encontrar essas questões:

  • Imagem de contêiner
  • Sistema de arquivos
  • Repositório Git (remoto)
  • Imagem de máquina virtual
  • Kubernetes

Kubei

[Parece descontinuado]

Kubei é uma ferramenta de escaneamento de vulnerabilidades e CIS Docker benchmark que permite aos usuários obter uma avaliação de risco precisa e imediata de seus clusters do Kubernetes. Kubei escaneia todas as imagens que estão sendo usadas em um cluster Kubernetes, incluindo imagens de pods de aplicação e pods do sistema.

KubiScan

KubiScan é uma ferramenta para escanear clusters Kubernetes em busca de permissões arriscadas no modelo de autorização Role-based access control (RBAC) do Kubernetes.

Managed Kubernetes Auditing Toolkit

Mkat é uma ferramenta construída para testar outros tipos de verificações de alto risco comparada com as outras ferramentas. Ela possui principalmente 3 modos diferentes:

  • find-role-relationships: Que encontrará quais AWS roles estão sendo executadas em quais pods
  • find-secrets: Que tenta identificar segredos em recursos K8s como Pods, ConfigMaps e Secrets.
  • test-imds-access: Que tentará executar pods e tentar acessar o metadata v1 e v2. AVISO: Isto irá executar um pod no cluster; tenha muito cuidado porque talvez você não queira fazer isso!

Auditar código IaC

KICS

KICS encontra vulnerabilidades de segurança, problemas de conformidade e configurações incorretas de infraestrutura nas seguintes soluções de Infrastructure as Code: Terraform, Kubernetes, Docker, AWS CloudFormation, Ansible, Helm, Microsoft ARM e especificações OpenAPI 3.0

Checkov

Checkov é uma ferramenta de análise estática de código para infraestrutura como código.

Ele escaneia infraestrutura em nuvem provisionada usando Terraform, Terraform plan, Cloudformation, AWS SAM, Kubernetes, Dockerfile, Serverless ou ARM Templates e detecta configurações incorretas de segurança e conformidade usando análise baseada em grafo.

Kube-score

kube-score é uma ferramenta que realiza análise estática de código das suas definições de objetos do Kubernetes.

Para instalar:

DistributionCommand / Link
Pre-built binaries for 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

Tools to analyze YAML files & 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 -

Escanear problemas de dependência

Escanear imagens

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

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

Dicas

Kubernetes PodSecurityContext e SecurityContext

Você pode configurar o contexto de segurança dos Pods (com PodSecurityContext) e dos containers que serão executados (com SecurityContext). Para mais informações leia:

Kubernetes SecurityContext(s)

Endurecimento da API do Kubernetes

É muito importante proteger o acesso ao Kubernetes Api Server pois um ator malicioso com privilégios suficientes pode abusar dele e danificar o ambiente de várias formas.
É importante proteger tanto o acesso (whitelist origens para acessar o API Server e negar qualquer outra conexão) quanto a authentication (seguindo o princípio do menor privilégio). E definitivamente nunca permitir requisições anônimas.

Processo comum de requisição:
User or K8s ServiceAccount –> Authentication –> Authorization –> Admission Control.

Dicas:

  • Fechar portas.
  • Evitar acesso anônimo.
  • NodeRestriction; negar acesso de determinados nós à API.
  • https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/#noderestriction
  • Basicamente impede que kubelets adicionem/removam/atualizem labels com o prefixo node-restriction.kubernetes.io/. Esse prefixo de label é reservado para administradores rotularem seus objetos Node para fins de isolamento de workloads, e kubelets não serão autorizados a modificar labels com esse prefixo.
  • E também, permite que kubelets adicionem/removam/atualizem esses labels e prefixos de label.
  • Garanta, com labels, o isolamento seguro de workloads.
  • Evitar que pods específicos acessem a API.
  • Evitar exposição do ApiServer na internet.
  • Evitar acesso não autorizado via RBAC.
  • Proteja a porta do ApiServer com firewall e IP whitelisting.

Endurecimento do SecurityContext

Por padrão o usuário root será usado quando um Pod for iniciado se nenhum outro usuário for especificado. Você pode executar sua aplicação dentro de um contexto mais seguro usando um template similar ao seguinte:

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

Endurecimento geral

Você deve atualizar seu ambiente Kubernetes com a frequência necessária para ter:

  • Dependências atualizadas.
  • Correções de bugs e de segurança.

Release cycles: A cada 3 meses há um novo lançamento minor – 1.20.3 = 1(Major).20(Minor).3(patch)

A melhor maneira de atualizar um Kubernetes Cluster é (a partir de here):

  • Atualize os componentes do Master Node seguindo esta sequência:
  • etcd (todas as instâncias).
  • kube-apiserver (todos os hosts do plano de controle).
  • kube-controller-manager.
  • kube-scheduler.
  • cloud controller manager, se você usar um.
  • Atualize os componentes dos Worker Nodes, como kube-proxy e kubelet.

Monitoramento e segurança do Kubernetes:

  • Kyverno Policy Engine
  • Cilium Tetragon - Observabilidade de segurança baseada em eBPF e aplicação em tempo de execução
  • Políticas de Segurança de Rede
  • Falco - monitoramento e detecção de segurança em tempo de execução

Tip

Aprenda e pratique Hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Aprenda e pratique Hacking GCP: HackTricks Training GCP Red Team Expert (GRTE) Aprenda e pratique Hacking Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Support HackTricks