Falco: detecção de ameaças em runtime para containers e Kubernetes

1. O que é o Falco e por que ele é essencial para segurança em runtime

O Falco é um projeto de código aberto originalmente criado pela Sysdig e posteriormente doado à Cloud Native Computing Foundation (CNCF), onde alcançou o status de projeto graduado em 2022. Sua proposta central é fornecer detecção de ameaças em tempo de execução para ambientes conteinerizados e Kubernetes.

A diferença fundamental entre o Falco e scanners de imagem tradicionais reside na abordagem de segurança. Scanners estáticos analisam vulnerabilidades em imagens de containers antes da execução, mas não conseguem detectar comportamentos anômalos que ocorrem durante a operação. O Falco preenche essa lacuna monitorando chamadas de sistema (syscalls) em tempo real, permitindo identificar atividades como shell reverso, leitura não autorizada de secrets, escalada de privilégios e execução de binários suspeitos.

Casos de uso típicos incluem:
- Detecção de kubectl exec interativo em pods críticos
- Identificação de tentativas de montagem de diretórios sensíveis do host
- Alerta sobre containers que iniciam processos em modo privilegiado
- Reconhecimento de padrões de crypto miners em execução

2. Arquitetura do Falco: como funciona a detecção em tempo real

A arquitetura do Falco é composta por três camadas principais: drivers de captura, engine de processamento e sistema de regras.

Drivers de captura: O Falco oferece três opções para interceptar syscalls:
- Kernel module: driver tradicional, alta performance, mas requer inserção manual
- eBPF (modern probe): recomendado para Kubernetes, não requer módulo kernel
- Driver genérico: compatibilidade máxima, performance reduzida

Pipeline de eventos: O fluxo de processamento segue a sequência:
1. Syscalls são capturadas pelo driver
2. Eventos são filtrados pelo libscap (biblioteca de captura)
3. Libsinsp analisa o contexto do evento (container, processo, namespace)
4. Engine do Falco avalia regras YAML contra os eventos filtrados
5. Alertas são gerados quando uma regra corresponde

Componentes principais:
- falco - engine principal
- libscap - captura de syscalls
- libsinsp - inspeção e interpretação de eventos
- falco_rules.yaml - conjunto padrão de regras de detecção

3. Instalação e configuração do Falco em Kubernetes

A instalação recomendada utiliza o Helm chart oficial, que configura o Falco como um DaemonSet para monitorar todos os nós do cluster.

# Adicionar repositório Helm do Falco
helm repo add falcosecurity https://falcosecurity.github.io/charts
helm repo update

# Instalar Falco com driver eBPF (recomendado)
helm install falco falcosecurity/falco \
  --namespace falco \
  --create-namespace \
  --set driver.kind=ebpf \
  --set falco.grpc.enabled=true \
  --set falco.grpcOutput.enabled=true

Para verificar se a instalação foi bem-sucedida:

# Verificar pods do Falco
kubectl get pods -n falco

# Verificar logs de um pod específico
kubectl logs -n falco falco-xxxxx

A configuração do driver eBPF é particularmente importante em ambientes Kubernetes modernos, pois elimina a necessidade de módulos kernel e funciona com containerd e CRI-O.

4. Regras de detecção: da sintaxe à criação de regras customizadas

Uma regra Falco é composta por elementos YAML específicos. Vamos criar uma regra customizada para detectar execução interativa via kubectl exec:

# macros.yaml
- macro: container_with_shell
  condition: container.image contains "bash" or container.image contains "sh"

- macro: interactive_terminal
  condition: evt.type=execve and proc.name in (bash, sh, zsh, dash)

# rules.yaml
- rule: Interactive Kubectl Exec Detected
  desc: Detecta execução interativa em containers via kubectl exec
  condition: >
    spawned_process and
    container and
    interactive_terminal and
    not container_with_shell
  output: >
    Execução interativa detectada (user=%user.name command=%proc.cmdline
    container=%container.info image=%container.image)
  priority: CRITICAL
  tags: [k8s, exec, interactive]

As regras padrão do Falco estão em /etc/falco/falco_rules.yaml e podem ser estendidas ou sobrescritas. Para aplicar regras customizadas no Kubernetes:

# ConfigMap com regras customizadas
kubectl create configmap falco-rules \
  --from-file=my_rules.yaml \
  -n falco

# Atualizar deployment para montar o ConfigMap
helm upgrade falco falcosecurity/falco \
  --namespace falco \
  --set-file falco.rules.my_rules.yaml=my_rules.yaml

5. Alertas e outputs: integração com sistemas externos

O Falco suporta múltiplos outputs nativos e pode ser integrado com ferramentas de alerta populares.

Outputs nativos:
- stdout - saída padrão (logs do container)
- syslog - envio para syslog do host
- file - escrita em arquivo específico
- gRPC - comunicação com clientes gRPC

Integração com Slack:

# values.yaml para Helm
falco:
  outputs:
    rate:
      rate: 1
      max_burst: 1000
  slack:
    enabled: true
    channel: "#security-alerts"
    webhook: "https://hooks.slack.com/services/T00/B00/XXXX"
    icon: ":falco:"
    message: "Falco Alert: %rule (priority=%priority)"

Integração com Prometheus Alertmanager:

# Configuração de webhook
falco:
  webhook:
    enabled: true
    url: "http://alertmanager.monitoring.svc:9093/api/v1/alerts"
    check_cert: false

Para ambientes SIEM, o Falco pode enviar alertas no formato JSON para Splunk, Elasticsearch ou qualquer sistema que aceite webhooks HTTP.

6. Falco e Kubernetes: detecção de ameaças específicas do ecossistema

O Falco inclui regras especializadas para o ecossistema Kubernetes. Exemplos de detecções relevantes:

Criação de pods privilegiados:

- rule: Create Privileged Pod
  desc: Detecção de criação de pod com privilégios elevados
  condition: >
    kevt and pod and kcreate and
    ka.req.pod.containers.privileged exists and
    ka.req.pod.containers.privileged intersects (true)
  output: >
    Pod privilegiado criado (user=%ka.user.name pod=%ka.req.pod.name
    namespace=%ka.req.pod.namespace)
  priority: CRITICAL

Montagem de hostPath:

- rule: Mount Host Path
  condition: >
    kevt and pod and kcreate and
    ka.req.pod.volumes.hostPath exists
  output: >
    HostPath montado (pod=%ka.req.pod.name path=%ka.req.pod.volumes.hostPath)
  priority: WARNING

Identificação de crypto miners: O Falco detecta padrões como alto consumo de CPU, conexões com pools de mineração conhecidos e execução de binários suspeitos.

Para ignorar containers confiáveis, utilize labels e anotações:

- macro: trusted_containers
  condition: >
    container.labels.trusted == "true" or
    k8s.ns.name in (kube-system, istio-system)

7. Boas práticas e operação contínua do Falco em produção

Ajuste de prioridades: O Falco utiliza oito níveis de prioridade: emergency, alert, critical, error, warning, notice, informational, debug. Ajuste conforme a criticidade do ambiente.

Gerenciamento de falsos positivos:
- Crie exceções em macros para ignorar comportamentos legítimos
- Use a tag falco_exceptions para regras específicas
- Monitore o volume de alertas e ajuste thresholds

Atualização sem reinicialização:

# Atualizar regras via ConfigMap sem reiniciar pods
kubectl create configmap falco-rules-new \
  --from-file=new_rules.yaml -n falco

# O Falco recarrega regras automaticamente quando o arquivo é modificado

8. Comparação com outras ferramentas e o futuro do Falco

Falco vs. Tracee (Aqua Security): Ambos utilizam eBPF, mas Tracee foca mais em rastreamento de processos e detecção de malware, enquanto Falco é mais orientado a regras e integração com Kubernetes.

Falco vs. Tetragon (Cilium): Tetragon utiliza eBPF para segurança de rede e política de segurança, complementando Falco na camada de rede.

Roadmap futuro: O Falco está evoluindo para suportar plugins WASM (WebAssembly), permitindo extensões personalizadas sem modificar o núcleo. Há também pesquisas em machine learning para detecção de anomalias comportamentais, reduzindo falsos positivos e identificando ameaças desconhecidas.

Em comparação com soluções EDR tradicionais, o Falco oferece vantagens significativas para ambientes containers: leveza, integração nativa com Kubernetes e capacidade de monitorar milhares de containers sem degradação de performance.

Referências