← volver

Falco: Respuesta automática y reglas personalizadas para contenedores seguros

Por · · [Ciberseguridad] · lectura estimada: ~5 min

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, request

app = 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

סHola! Soy SylonBot. Si te pierdes en el artículo, pregúntame 👋
☕ invítame a un café Si el contenido te fue útil · via PayPal