Security scanning: Trivy, Falco e Polaris para compliance

1. Introdução à Segurança em Ambientes Kubernetes

Em ambientes Kubernetes, os riscos de segurança são multifacetados. Vulnerabilidades em imagens de contêineres podem expor pacotes desatualizados com CVEs conhecidas. Em runtime, um atacante pode executar comandos maliciosos dentro de um pod. Configurações incorretas — como containers rodando como root ou sem limites de recursos — abrem brechas para escalonamento de privilégios. A conformidade com padrões como CIS Kubernetes Benchmarks e NIST torna-se essencial para auditorias e certificações (SOC 2, PCI DSS).

Três ferramentas se destacam para cobrir essas frentes:

  • Trivy: varredura de vulnerabilidades em imagens Docker e IaC (Infrastructure as Code).
  • Falco: monitoramento comportamental em runtime, detectando atividades anômalas.
  • Polaris: auditoria de configuração e boas práticas, alinhada a benchmarks de segurança.

Este artigo apresenta exemplos práticos de como integrar essas ferramentas em pipelines DevOps e clusters Kubernetes.

2. Trivy: Varredura de Vulnerabilidades em Imagens e IaC

Trivy é um scanner rápido e abrangente, capaz de detectar CVEs em pacotes do sistema operacional e dependências de linguagens (Python, Node.js, Java, Go). Suporta também análise de IaC: Dockerfiles, Helm charts, Terraform e manifests Kubernetes.

Instalação e uso básico

# Instalar Trivy (Linux)
curl -sfL https://raw.githubusercontent.com/aquasecurity/trivy/main/contrib/install.sh | sh

# Escanear uma imagem Docker local
trivy image nginx:1.25

# Escanear um Dockerfile
trivy config ./Dockerfile

# Escanear um diretório com manifests Kubernetes
trivy config ./k8s-manifests/

Integração com CI/CD (GitHub Actions)

# .github/workflows/trivy-scan.yml
name: Trivy Scan
on: [push]
jobs:
  scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run Trivy on IaC
        uses: aquasecurity/trivy-action@master
        with:
          scan-type: 'config'
          scan-ref: './k8s-manifests/'
          severity: 'HIGH,CRITICAL'
          format: 'sarif'
          output: 'trivy-results.sarif'
      - name: Upload SARIF
        uses: github/codeql-action/upload-sarif@v3
        with:
          sarif_file: 'trivy-results.sarif'

No GitLab CI, o mesmo conceito se aplica:

# .gitlab-ci.yml
trivy-scan:
  stage: test
  image: aquasec/trivy:latest
  script:
    - trivy image --severity HIGH,CRITICAL --exit-code 1 myregistry/myapp:latest
    - trivy config --severity HIGH,CRITICAL --exit-code 1 ./k8s-manifests/

3. Falco: Monitoramento de Comportamento em Runtime

Falco é um projeto da CNCF que monitora chamadas de sistema (syscalls) no kernel Linux. Ele detecta comportamentos suspeitos como shells interativos em containers, montagem de diretórios sensíveis (como /var/run/docker.sock) e escalonamento de privilégios.

Arquitetura simplificada

Falco utiliza um driver de kernel (eBPF ou módulo kernel) para capturar syscalls. As regras definem padrões de alerta. As saídas podem ser enviadas para syslog, gRPC, webhook ou arquivos JSON.

Instalação no Kubernetes via Helm

helm repo add falcosecurity https://falcosecurity.github.io/charts
helm repo update
helm install falco falcosecurity/falco \
  --set falco.driver.enabled=true \
  --set falco.driver.kind=ebpf

Regras pré-definidas e customização

Algumas regras padrão do Falco:

  • Terminal shell in container: detecta execução de /bin/bash ou /bin/sh em container.
  • Sensitive mount: alerta se um container monta /var/run/docker.sock.
  • Privilege escalation: detecta uso de --privileged em pods.

Para customizar regras, crie um arquivo falco-rules.yaml:

- rule: Detect curl or wget in container
  desc: Detecta download de binários suspeitos
  condition: >
    spawned_process and container
    and (proc.name = "curl" or proc.name = "wget")
  output: >
    Download tool used in container (user=%user.name
    command=%proc.cmdline container=%container.name)
  priority: WARNING
  tags: [network, container]

Aplique a regra com:

kubectl create configmap custom-rules --from-file=falco-rules.yaml
helm upgrade falco falcosecurity/falco \
  --set falco.rulesFile={/etc/falco/falco_rules.yaml,/etc/falco/custom-rules/falco-rules.yaml}

4. Polaris: Auditoria de Configuração e Boas Práticas

Polaris verifica se os recursos Kubernetes seguem boas práticas de segurança e conformidade com CIS Benchmarks. Ele analisa PodSecurityContext, resource limits, probes, network policies e muito mais.

Instalação como dashboard

# Instalar Polaris Dashboard
kubectl apply -f https://raw.githubusercontent.com/FairwindsOps/polaris/main/deploy/dashboard.yaml
kubectl port-forward -n polaris svc/polaris-dashboard 8080:80

Acesse http://localhost:8080 para ver o score de todos os namespaces.

Uso como CLI

# Analisar um manifesto específico
polaris audit --audit-path ./k8s-manifests/

# Analisar um cluster ativo
polaris audit --cluster

Integração como admission controller (OPA/Gatekeeper)

Polaris pode ser usado como admission controller para bloquear recursos não conformes. Exemplo de política customizada:

# policy.yaml
apiVersion: constraints.gatekeeper.sh/v1beta1
kind: K8sRequiredLabels
metadata:
  name: require-pod-security-context
spec:
  match:
    kinds:
      - apiGroups: [""]
        kinds: ["Pod"]
  parameters:
    labels:
      - key: "security-tier"
        allowedRegex: "^high|medium$"

5. Implementação Combinada: Pipeline de Segurança Contínua

Para uma segurança contínua, integre as três ferramentas em um pipeline:

  1. Pré-deploy: Trivy escaneia imagens e IaC. Se vulnerabilidades críticas forem encontradas, o pipeline falha.
  2. Runtime: Falco monitora pods em staging e produção. Alertas críticos disparam exclusão automática de pods suspeitos via webhook.
  3. Admission: Polaris (como OPA/Gatekeeper) bloqueia recursos que não atendem às políticas de compliance.

Exemplo de pipeline GitLab CI completo:

stages:
  - scan
  - deploy
  - monitor

trivy-scan:
  stage: scan
  image: aquasec/trivy:latest
  script:
    - trivy image --severity HIGH,CRITICAL --exit-code 1 $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
    - trivy config --severity HIGH,CRITICAL --exit-code 1 ./k8s-manifests/

deploy-staging:
  stage: deploy
  script:
    - kubectl apply -f ./k8s-manifests/

falco-alert:
  stage: monitor
  image: bitnami/kubectl
  script:
    - kubectl logs -n falco -l app.kubernetes.io/name=falco --tail=50

6. Estratégias de Compliance e Relatórios

Para atender a frameworks como SOC 2, PCI DSS ou HIPAA, é necessário:

  • Mapear resultados: relacione cada alerta do Trivy, Falco e Polaris a controles específicos (ex.: "Imagem com CVE crítica" → controle de patch management).
  • Centralizar logs: envie eventos do Falco para Elasticsearch ou Loki. Exemplo de configuração Falco para syslog:
# falco-config.yaml
stdout_output:
  enabled: true
  json: true
syslog_output:
  enabled: true
program_output:
  enabled: true
  keep_alive: true
  program: "logger -t falco"
  • Dashboards de segurança: crie painéis no Grafana com métricas de score do Polaris, número de CVEs por severidade e eventos do Falco por namespace.

7. Desafios e Boas Práticas em Produção

  • Falsos positivos: ajuste regras do Falco para ignorar comportamentos legítimos (ex.: scripts de CI que executam curl). Use exceptions nas regras.
  • Overhead: Trivy pode consumir CPU durante varreduras completas. Agende scans noturnos ou apenas em commits. Falco com eBPF tem baixo overhead (~1-2% de CPU).
  • Versionamento: mantenha políticas de Polaris e regras do Falco em Git. Teste em staging antes de aplicar em produção.
  • Multi-cluster: use ferramentas como ArgoCD para aplicar políticas de forma consistente em vários clusters.

Referências