← volver

Coraza + OWASP CRS en Docker: WAF transparente para nginx con logs a Loki

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

El problema: nginx sin protección a nivel de aplicación

Cuando despliegas servicios web con nginx, el firewall de red (iptables, security groups) filtra el tráfico a nivel de puerto y protocolo. Pero las amenazas modernas viajan dentro de peticiones HTTP legítimas: inyecciones SQL, cross-site scripting (XSS), path traversal, o intentos de explotación de vulnerabilidades en tu stack de aplicaciones. Sin un WAF (Web Application Firewall), cada petición llega directamente a tu backend, donde una sola cadena mal formada puede comprometer todo el sistema.

La solución tradicional es instalar ModSecurity con nginx, pero su mantenimiento y configuración son farragosos. Aquí entra Coraza, un WAF escrito en Go que implementa la especificación de ModSecurity (SecLang) y que, combinado con el OWASP Core Rule Set (CRS), ofrece una protección robusta y actualizable. Lo mejor: puedes ejecutarlo como un proxy inverso transparente en Docker, sin tocar una sola línea de tu configuración nginx original. Y para que la seguridad sea auditable, enviaremos los logs de ataques a Loki, el sistema de agregación de logs de Grafana.

Arquitectura propuesta: el proxy transparente

En lugar de insertar Coraza como módulo dentro de nginx (lo cual requeriría compilar un binario personalizado), lo desplegamos como un contenedor independiente que se coloca delante de nginx. El flujo es:

Cliente → Coraza (WAF) → nginx (backend)

El tráfico llega al puerto 80/443 del host, donde un proxy Docker (o directamente la red Docker) lo redirige al contenedor de Coraza. Coraza analiza cada petición contra las reglas del OWASP CRS. Si detecta una amenaza, responde con un 403 Forbidden y registra el evento. Si la petición es limpia, la reenvía a nginx, que actúa como backend estático o proxy a tu aplicación.

Esta arquitectura es "transparente" porque tu aplicación no sabe que existe un WAF: simplemente recibe peticiones HTTP normales. Además, puedes escalar horizontalmente: un contenedor Coraza por instancia de nginx, o uno compartido para varios.

Configuración paso a paso

1. Estructura de directorios

Crea el proyecto con esta estructura:

waf-coraza/
├── docker-compose.yml
├── coraza/
│   ├── coraza.conf
│   └── crs/          # reglas OWASP CRS
└── nginx/
    └── default.conf

2. Descarga del OWASP CRS

OWASP CRS es un conjunto de reglas. La versión 4.x es la actual. Puedes clonar el repositorio dentro de coraza/crs:

git clone --depth 1 -b v4.8.0 https://github.com/coreruleset/coreruleset.git coraza/crs

No necesitas el directorio completo; solo las reglas y el archivo crs-setup.conf.example que renombraremos.

3. Configuración de Coraza

El archivo coraza/coraza.conf define el motor. Esta es una base mínima pero funcional:

# coraza.conf
SecRuleEngine On
SecRequestBodyAccess On
SecResponseBodyAccess Off
SecAuditEngine RelevantOnly
SecAuditLog /var/log/coraza/audit.log

# Incluir CRS
Include /etc/coraza/crs/crs-setup.conf
Include /etc/coraza/crs/rules/*.conf

# Regla por defecto: denegar con 403
SecDefaultAction "phase:1,log,auditlog,deny,status:403"

Fíjate en la variable SecAuditLog: enviaremos este archivo a Loki mediante un agente. En el contenedor, este archivo estará en /var/log/coraza/audit.log.

Ahora copia la configuración del CRS:

cp coraza/crs/crs-setup.conf.example coraza/crs/crs-setup.conf

En crs-setup.conf, puedes ajustar la severidad, los umbrales de paranoia, etc. Para pruebas, deja los valores por defecto (paranoia level 1).

4. Dockerfile para Coraza

No existe una imagen oficial de Coraza con CRS. Crearemos una. Guarda este Dockerfile en coraza/Dockerfile:

FROM golang:1.22-alpine AS builder
RUN apk add --no-cache git
RUN git clone https://github.com/corazawaf/coraza.git /src
WORKDIR /src
RUN go build -o coraza main.go

FROM alpine:3.19
RUN apk add --no-cache ca-certificates
COPY --from=builder /src/coraza /usr/local/bin/coraza
COPY coraza.conf /etc/coraza/coraza.conf
COPY crs/ /etc/coraza/crs/
RUN mkdir -p /var/log/coraza
EXPOSE 8080
ENTRYPOINT ["coraza", "-conf", "/etc/coraza/coraza.conf", "-listen", "0.0.0.0:8080"]

El binario de Coraza actúa como proxy inverso escuchando en el puerto 8080. Necesitamos indicarle a dónde reenviar el tráfico limpio: lo configuraremos con una variable de entorno en docker-compose.

5. Configuración de nginx (backend)

Un nginx estándar que sirva una página estática o haga proxy a tu app. Para demostración, crea nginx/default.conf:

server {
    listen 80;
    server_name _;
    root /usr/share/nginx/html;
    index index.html;
}

6. docker-compose.yml

El orquestador define tres servicios: coraza, nginx y promtail (el agente que envía logs a Loki). Añadimos también volúmenes para persistencia.

version: '3.8'

services:
  coraza:
    build: ./coraza
    environment:
      - BACKEND_URL=http://nginx:80   # redirige a nginx
    ports:
      - "8080:8080"
    volumes:
      - coraza_logs:/var/log/coraza
    depends_on:
      - nginx

  nginx:
    image: nginx:alpine
    volumes:
      - ./nginx/default.conf:/etc/nginx/conf.d/default.conf:ro
      - ./html:/usr/share/nginx/html:ro

  promtail:
    image: grafana/promtail:3.0.0
    volumes:
      - coraza_logs:/var/log/coraza
      - ./promtail-config.yml:/etc/promtail/config.yml:ro
    command: -config.file=/etc/promtail/config.yml
    depends_on:
      - coraza

volumes:
  coraza_logs:

Observa que el puerto 8080 del host mapea al contenedor Coraza. El contenedor nginx no expone puertos al host, solo es accesible desde la red interna de Docker.

Falta crear el archivo promtail-config.yml para enviar el log de auditoría a Loki:

# promtail-config.yml
server:
  http_listen_port: 9080
  grpc_listen_port: 0

positions:
  filename: /tmp/positions.yaml

clients:
  - url: http://loki:3100/loki/api/v1/push

scrape_configs:
  - job_name: coraza
    static_configs:
      - targets: [localhost]
        labels:
          job: waf
          __path__: /var/log/coraza/audit.log

En este ejemplo, asumimos que Loki corre en un host remoto o en otra red. Si quieres levantar Loki y Grafana también en Docker, añade esos servicios al compose, pero por simplicidad, aquí usamos una URL externa.

Explicación de las reglas y su comportamiento

El OWASP CRS contiene más de 200 reglas organizadas por categorías: inyección SQL (941xxx), XSS (931xxx), path traversal (930xxx), etc. Cada regla evalúa variables de la petición: ARGS, REQUEST_URI, REQUEST_HEADERS, REQUEST_BODY, entre otras.

Por ejemplo, una regla típica de inyección SQL busca patrones como ' OR 1=1 -- en los parámetros GET/POST. Si coincide, Coraza aplica la acción definida en SecDefaultAction: registrar y denegar con 403.

El CRS usa un sistema de paranoia levels. En el nivel 1 (por defecto), solo se detectan ataques muy evidentes. En el nivel 4, se vuelve extremadamente estricto y puede generar falsos positivos. Para producción, se recomienda empezar en nivel 1 y monitorizar los falsos positivos en los logs antes de subir de nivel.

Una característica clave es el modo de detección. Puedes configurar SecRuleEngine Detection

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