Ciberseguridad ·

Falco en Kubernetes: eBPF, alertas a Elastic SIEM y respuesta automática

La seguridad en runtime dentro de Kubernetes dejó de ser un lujo para convertirse en una necesidad operativa. Los contenedores se comportan como cajas negras: una imagen aparentemente limpia puede desplegar un criptominero minutos después del arranque, o un proceso legítimo puede ser secuestrado para abrir una reverse shell. Falco, el proyecto graduado de la CNCF, se ha consolidado como el estándar de facto para la detección de comportamientos anómalos en clústeres, y su integración con eBPF, Elastic SIEM y flujos de respuesta automatizada permite construir una defensa en profundidad real, no solo un panel de alertas que nadie mira.

Por qué Falco y por qué eBPF

Falco nació como un motor de reglas que consumía eventos del kernel a través de un módulo (kernel module) o de una sonda basada en eBPF. La evolución hacia eBPF moderno (CO-RE, con libbpf) resolvió los dos grandes dolores históricos: la necesidad de compilar módulos contra cada versión de kernel y los riesgos de estabilidad al cargar código en el espacio del kernel. Con eBPF, Falco instrumenta syscalls, cambios en el sistema de archivos, actividad de red y eventos de procesos sin recompilar nada y con un consumo de recursos medible.

En Kubernetes, Falco se despliega típicamente como un DaemonSet para cubrir todos los nodos, más un Deployment que actúa como servidor gRPC, expone métricas y centraliza la salida. La sonda moderna se activa con --modern-bpf o mediante el driver kmod si el entorno lo exige.

Instalación rápida con Helm

helm repo add falcosecurity https://falcosecurity.github.io/charts
helm repo update
helm install falco falcosecurity/falco \
  --namespace falco --create-namespace \
  --set driver.kind=modern_ebpf \
  --set tty=true \
  --set falcosidekick.enabled=true \
  --set falcosidekick.config.elasticsearch.hostPort=http://elastic-siem:9200 \
  --set falcosidekick.config.elasticsearch.index=falco

El componente Falcosidekick es la pieza clave: recibe los eventos de Falco y los reenvía a más de 60 destinos, incluyendo Elasticsearch, OpenSearch, Slack, PagerDuty o webhooks genéricos. Con esa configuración, cada alerta llega ya indexada a Elastic SIEM.

Reglas personalizadas: más allá del catálogo por defecto

Falco trae cientos de reglas comunitarias, pero el valor real aparece cuando adaptas las detecciones a tu carga de trabajo. Supongamos que quieres detectar la ejecución de shells dentro de contenedores que no deberían abrir una terminal interactiva, y además etiquetar el namespace para que Elastic pueda correlacionar.

- rule: Shell spawned in production namespace
  desc: Detecta una shell interactiva dentro de un contenedor en producción
  condition: >
    spawned_process and container
    and k8s.ns.name startswith "prod-"
    and proc.name in (bash, sh, zsh, ash)
    and not proc.pname in (cron, runc)
  output: >
    Shell interactiva detectada
    (user=%user.name pod=%k8s.pod.name ns=%k8s.ns.name
    cmd=%proc.cmdline image=%container.image.repository)
  priority: WARNING
  tags: [container, shell, mitre_execution]

La variable k8s.ns.name requiere que Falco tenga habilitado el plugin de Kubernetes (k8smeta), algo que el chart de Helm activa por defecto. Para recargar reglas sin reiniciar el DaemonSet basta con:

kubectl -n falco exec ds/falco -- kill -1 1

Esto envía SIGHUP al proceso principal y Falco recompila las reglas en caliente. Es una práctica útil durante ajustes de tuning en producción, aunque en entornos GitOps conviene versionar las reglas como ConfigMaps y dejar que Argo CD o Flux gestionen el ciclo.

Envío de alertas a Elastic SIEM

Elasticsearch recibe los eventos de Falcosidekick en el índice falco-*. Para que el SIEM los interprete correctamente, conviene crear un index template que asigne el mapping ECS (Elastic Common Schema) a campos clave: host.name, container.id, process.name, user.name y event.action. Un fragmento del template sería:

PUT _index_template/falco-template
{
  "index_patterns": ["falco-*"],
  "template": {
    "mappings": {
      "properties": {
        "priority": {"type": "keyword"},
        "rule":     {"type": "keyword"},
        "output_fields": {
          "properties": {
            "k8s.ns.name": {"type": "keyword"},
            "k8s.pod.name": {"type": "keyword"},
            "proc.cmdline": {"type": "keyword"}
          }
        }
      }
    }
  }
}

Con los datos indexados, las reglas de detección en Kibana pueden correlacionar un evento de Falco con telemetría de audit logs de Kubernetes o de métricas de red. Una consulta típica de hunting sería:

GET falco-*/_search
{
  "query": {
    "bool": {
      "must": [
        {"term": {"priority": "Warning"}},
        {"wildcard": {"output_fields.proc.cmdline": "*curl*"}}
      ],
      "filter": [{"range": {"@timestamp": {"gte": "now-15m"}}}]
    }
  }
}

El siguiente paso lógico es crear detection rules en el SIEM que disparen cuando se supere un umbral de eventos por pod o namespace en una ventana temporal. Por ejemplo, más de cinco shells interactivas en un namespace de producción en diez minutos debería generar una alerta de severidad alta, no un simple warning.

Respuesta automática: de la alerta a la acción

Detectar sin responder deja la mitad del trabajo sin hacer. Falcosidekick permite definir webhooks que apunten a un pequeño servicio receptor, habitualmente escrito en Go o Python, que decide qué hacer. Un patrón común es aislar el pod comprometido aplicando una NetworkPolicy de denegación total y, opcionalmente, matar el pod.

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: quarantine-
  namespace: 
spec:
  podSelector:
    matchLabels:
      app: 

El receptor del webhook recibe el JSON de Falco, extrae k8s.ns.name y k8s.pod.name, genera la NetworkPolicy con un nombre único y la aplica usando la Kubernetes API vía client-go o kubernetes-client/python. Con kubectl desde un job de respuesta se vería así:

kubectl -n prod-app patch networkpolicy quarantine-pod-xyz \
  --type merge -p '{"spec":{"podSelector":{"matchLabels":{"app":"victim"}}}}'

Para que la respuesta sea segura, el receptor debe ejecutarse con un ServiceAccount de privilegios mínimos: solo create, patch y delete sobre networkpolicies en namespaces concretos. Nunca uses cluster-admin para un componente que reacciona a eventos externos.

Bucle de mejora continua

  • Tuning de reglas: revisa semanalmente las alertas más ruidosas y ajusta condiciones o añade excepciones por imagen o namespace.
  • Métricas de Falco: expón falcosecurity_falco_events_total a Prometheus para detectar caídas de la sonda o picos anómalos.
  • Playbooks: documenta cada acción automática y su reversión; un aislamiento mal ejecutado puede tumbar servicios legítimos.
  • Pruebas con chaos: ejecuta contenedores que simulen minería o exfiltración para validar que reglas, SIEM y respuesta funcionan de extremo a extremo.

Falco con eBPF, Elastic SIEM y respuesta automatizada conforma una tríada coherente para la seguridad en runtime de Kubernetes. La sonda captura con bajo overhead, el SIEM da contexto y correlación, y la automatización reduce el tiempo de contención de horas a segundos. El reto no es tecnológico, sino disciplinario: mantener las reglas afinadas, los permisos mínimos y los playbooks probados. En ciberseguridad, la diferencia entre un incidente contenido y una brecha suele medirse en esos segundos que la automatización te regala.