Falco: Respuesta automática y reglas personalizadas para contenedores seguros
El runtime security y la necesidad de Falco
La seguridad en contenedores ya no se limita a escanear imágenes o endurecer imágenes base. Una vez que el contenedor está en ejecución, el riesgo se desplaza hacia el comportamiento anómalo: procesos inesperados, lecturas de archivos sensibles, creación de sockets sospechosos o escapes de namespace. Aquí es donde entra Falco, el proyecto de runtime security de CNCF (Cloud Native Computing Foundation), diseñado específicamente para detectar comportamientos anómalos en tiempo real.
Falco actúa como un sistema de detección de intrusiones (IDS) para tu infraestructura cloud-native. Se apoya en eBPF (Extended Berkeley Packet Filter) o en módulos de kernel para interceptar llamadas al sistema (syscalls) a nivel de kernel. Esto le permite observar cada proceso, archivo y conexión de red dentro de tus contenedores sin necesidad de agentes dentro de cada contenedor.
Lo que hace a Falco verdaderamente poderoso no es solo su capacidad de detección, sino su motor de reglas altamente configurable. Puedes definir qué es "normal" para tu aplicación y, cuando algo se desvía, Falco no solo genera un evento, sino que puede desencadenar una respuesta automática mediante falcoctl, webhooks, o integración con herramientas como ArgoCD, Prometheus o un simple script de mitigación.
Instalación rápida y configuración base
Para empezar, si tienes un cluster Kubernetes, la instalación con Helm es la más directa:
helm repo add falcosecurity https://falcosecurity.github.io/charts
helm repo update
helm install falco falcosecurity/falco \
--set driver.kind=ebpf \
--set ebpf.enabled=true \
--namespace falco --create-namespace
Si prefieres ejecutarlo en un host con Docker directamente:
docker run -i -t \
--name falco \
--privileged \
-v /var/run/docker.sock:/var/run/docker.sock \
-v /proc:/host/proc:ro \
-v /boot:/host/boot:ro \
-v /lib/modules:/host/lib/modules:ro \
-v /usr:/host/usr:ro \
falcosecurity/falco:latest
Una vez corriendo, Falco ya incluye un conjunto de reglas predeterminadas en /etc/falco/falco_rules.yaml. Puedes ver los eventos en vivo con:
falco --output-rule "priority=warning"
Pero el verdadero control comienza cuando escribes tus propias reglas.
Anatomía de una regla personalizada
Una regla en Falco tiene tres componentes clave: rule (la condición), macro (fragmentos reutilizables) y list (conjuntos de valores). Vamos a crear una regla que detecte el acceso a archivos de claves SSH dentro de cualquier contenedor.
Primero, definimos una lista con las rutas sensibles:
- list: ssh_private_keys
items: ["/root/.ssh/id_rsa", "/root/.ssh/id_ed25519", "/home/*/.ssh/id_rsa"]
Luego, una macro para verificar que estamos dentro de un contenedor y que el proceso no es el propio Falco:
- macro: container_ssh_access
condition: >
container and
not proc.name = "falco" and
not proc.name in (sshd, ssh-agent)
Ahora la regla final:
- rule: Detect SSH Key Access in Container
desc: "Detecta lectura de claves privadas SSH dentro de un contenedor"
condition: >
container_ssh_access and
open_read and
fd.name in (ssh_private_keys)
output: >
Acceso a clave SSH detectado (user=%user.name
command=%proc.cmdline file=%fd.name container=%container.id)
priority: CRITICAL
tags: [filesystem, ssh, container]
Para cargar esta regla, crea un archivo custom_rules.yaml y colócalo en /etc/falco/, o si usas Helm, añade el contenido en la sección falco.rulesFiles del values.yaml.
Respuesta automática con falcoctl y webhooks
Detectar es solo la mitad del problema. La otra mitad es reaccionar. Falco, por defecto, escribe eventos en stdout o en un archivo. Pero podemos conectarlo a un sistema de respuesta automática usando falcoctl (la herramienta oficial) o mediante el plugin de webhook.
El enfoque más práctico es usar un webhook que apunte a un servicio interno que ejecute acciones de mitigación, como eliminar el pod o aislar la red.
Primero, habilita el plugin de webhook en /etc/falco/falco.yaml:
plugins:
- name: webhook
library_path: libwebhook.so
init_config:
address: "http://falco-svc.default.svc.cluster.local:8080"
headers:
Content-Type: application/json
open_params: ""
Luego, en tu regla personalizada, añade el campo output con formato JSON y configura que se envíe al webhook:
- rule: Terminate Malicious Container
desc: "Elimina un contenedor que intente leer secretos"
condition: container and open_read and fd.name in (secret_files)
output: >
{"action": "kill", "container_id": "%container.id", "message": "Secreto accedido"}
priority: CRITICAL
tags: [mitigation]
El servicio receptor (puede ser una Cloud Function, un Knative Service o un simple script Python con Flask) recibe el evento, parsea el container_id y ejecuta un docker stop o una llamada a la API de Kubernetes para eliminar el pod:
import subprocess from flask import Flask, requestapp = Flask(name)
@app.route(’/’, methods=[‘POST’]) def handle_falco_event(): data = request.get_json() if data.get(‘action’) == ‘kill’: container_id = data.get(‘container_id’) subprocess.run([‘docker’, ‘stop’, container_id]) return ‘OK’, 200
Este flujo convierte a Falco en un sistema de prevención y respuesta (EDR) ligero, actuando en milisegundos ante una anomalía.
Alerta avanzada y priorización de eventos
Las prioridades en Falco son: EMERGENCY, ALERT, CRITICAL, ERROR, WARNING, NOTICE, INFO, DEBUG. Es fundamental elegir la prioridad correcta para evitar fatiga de alertas.
También puedes usar condiciones temporales para reducir falsos positivos. Por ejemplo, una regla que solo se activa durante horas de mantenimiento:
- rule: Sensitive Mount in Maintenance Window
desc: "Mount de /var/run/docker.sock solo permitido entre 2am-4am"
condition: >
container and
evt.type in (mount) and
mount.target = /var/run/docker.sock and
evt.time >= 2:00 and evt.time <= 4:00
output: "Mount sospechoso en ventana de mantenimiento"
priority: ERROR
Además, Falco soporta métricas de rendimiento. Puedes exponer métricas Prometheus para monitorizar cuántos eventos se están procesando y cuántas reglas se están evaluando por segundo:
falco --metrics "cpu,memory,events,outputs"
Esto te permite ajustar la carga del sistema y evitar que Falco se convierta en un cuello de botella.
Falsos positivos y cómo refinarlos
El mayor desafío al escribir reglas personalizadas es el ruido. Un contenedor que ejecuta migraciones de base de datos puede abrir muchos archivos, y tu regla podría dispararse innecesariamente. La solución es añadir excepciones usando la palabra clave and not o usando campos de contexto como proc.pcmdline (proceso padre) o k8s.ns.name (namespace).
Ejemplo de refinamiento:
- rule: Detect Shell in Container
desc: "Detecta shell interactiva en contenedor"
condition: >
container and
proc.name in (bash, sh, zsh) and
proc.cmdline contain "interactive" and
not k8s.ns.name in (default, kube-system) and
not proc.pcmdline in (containerd-shim, docker-init)
output: "Shell interactivo en contenedor %container.id"
priority: WARNING
Recuerda que Falco permite
comentarios(0)
$ dejar comentario