← volver

Graylog Pipeline: Parseo y Enriquecido de Logs en Tiempo Real

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

El problema del ruido en los logs

En ciberseguridad, el volumen de datos supera a la capacidad de análisis humano. Un SIEM como Graylog recibe cientos de miles de eventos por minuto: firewalls, sistemas de autenticación, servidores web, bases de datos. Sin embargo, la mayoría llegan en formatos heterogéneos: JSON, CEF, syslog RFC3164, key=value, o texto libre. Si no se procesan adecuadamente, quedan como una masa inutilizable en el índice de Elasticsearch.

Aquí es donde entra el Graylog Pipeline Processor, un motor de reglas que actúa como una capa de transformación entre la entrada (input) y el índice. Permite filtrar, reescribir, enriquecer y rutear mensajes en tiempo real, antes de que se almacenen. En este artículo, exploraremos sus componentes, escribiremos reglas funcionales y veremos casos de uso reales en defensa perimetral.

Arquitectura: Pipeline, Etapas y Reglas

Un pipeline es un conjunto ordenado de etapas (stages). Cada etapa contiene una o más reglas (rules). La ejecución es secuencial: si una regla de una etapa decide continuar, se pasa a la siguiente. Si una regla tiene condición false, se puede saltar la etapa completa.

El pipeline se vincula a un stream específico. Cada mensaje entrante se evalúa contra el stream; si coincide, se ejecuta el pipeline. Esto da un control granular: podemos aplicar pipelines distintos según el origen (p.ej., logs de firewall vs. logs de Active Directory).

Las reglas se escriben en un lenguaje propio llamado Graylog Pipeline Rule Language, con sintaxis similar a Java. Un ejemplo mínimo:

rule "normaliza_timestamp"
when
  has_field("timestamp")
then
  let timestamp = to_long(to_string($message.timestamp));
  // Convierte epoch a formato ISO
  set_field("timestamp_iso", from_epoch(timestamp));
end

Las funciones disponibles incluyen regex, grok, lookup, geoip, substring, entre decenas más.

Parseo con Grok y Regex

El parseo es el primer paso. La función grok es la reina: permite extraer campos de texto no estructurado usando patrones predefinidos o personalizados. Por ejemplo, un log típico de Apache:

192.168.1.10 - admin [10/Oct/2023:13:55:36 -0700] "POST /login HTTP/1.1" 200 5234

Podemos crear una regla que lo descomponga:

rule "parsear_apache"
when
  has_field("message")
  and not has_field("src_ip")
then
  let patron = "%{IPORHOST:src_ip} %{USER:ident} %{USER:usuario} \\[%{HTTPDATE:fecha}\\] \"%{WORD:metodo} %{URIPATHPARAM:request} HTTP/%{NUMBER:http_version}\" %{NUMBER:status} %{NUMBER:bytes}";
  let resultado = grok(pattern: patron, value: to_string($message.message));
  if (resultado.isMatches()) {
    set_fields(resultado.getMatches());
    // Limpiar campos vacíos
    remove_field("ident");
  }
end

El poder de grok radica en que reutiliza patrones. Si no existe uno para tu formato, puedes definir uno en System → Grok Patterns. Por ejemplo, para logs de Fortinet:

FORTINET_LOG = "date=%{DATA:date} time=%{TIME:time} devname=%{DATA:devname} srcip=%{IP:src_ip} srcport=%{NUMBER:src_port} dstip=%{IP:dst_ip} dstport=%{NUMBER:dst_port} action=%{WORD:action}"

Y luego en la regla:

rule "parsear_fortinet"
when
  contains(to_string($message.message), "devname=")
then
  let resultado = grok(pattern: "%{FORTINET_LOG}", value: to_string($message.message));
  if (resultado.isMatches()) {
    set_fields(resultado.getMatches());
  }
end

Normalización de campos y tipado

Un problema común es que los campos llegan como cadenas, pero necesitamos compararlos numéricamente o como IPs. Graylog permite convertir tipos y renombrar campos para que los dashboards y las alertas funcionen correctamente.

Ejemplo: si un firewall reporta puertos como "22" (string), queremos convertirlos a entero para filtrar rangos.

rule "normalizar_puertos"
when
  has_field("src_port") and is_string("src_port")
then
  let puerto = to_long($message.src_port);
  set_field("src_port_num", puerto);
  // Eliminar el campo original para evitar indexación duplicada
  remove_field("src_port");
end

También es útil renombrar campos que varían según el fabricante. Por ejemplo, Cisco usa src y dst, mientras que otros usan source_ip. Una regla de normalización puede unificarlos a un estándar interno:

rule "unificar_ip_origen"
when
  has_field("src") and not has_field("src_ip")
then
  set_field("src_ip", $message.src);
  remove_field("src");
end

Enriquecido con GeoIP y listas de amenazas

El enriquecido añade contexto. En ciberseguridad, saber la geolocalización de una IP o si aparece en una lista negra pública es crucial para priorizar alertas.

Para GeoIP, Graylog incluye un lookup table de MaxMind. Primero, debes cargar la base de datos en System → Lookup Tables. Luego, la regla:

rule "enriquecer_geoip"
when
  has_field("src_ip")
then
  let geo = lookup("geoip_maxmind", to_string($message.src_ip));
  if (geo != null) {
    set_field("src_country", geo.country_name);
    set_field("src_city", geo.city_name);
    set_field("src_lat", geo.latitude);
    set_field("src_lon", geo.longitude);
  }
end

Para listas de amenazas (p.ej., AlienVault OTX o feeds propios), usaremos un Data Adapter que consulte un CSV o una API. Si tenemos una lista de IPs maliciosas cargada en una lookup table llamada threat_intel:

rule "marcar_maliciosas"
when
  has_field("src_ip")
then
  let threat = lookup("threat_intel", to_string($message.src_ip));
  if (threat != null) {
    set_field("threat_score", threat.score);
    set_field("threat_category", threat.category);
    // Elevar severidad para alertas posteriores
    set_field("alert_severity", "HIGH");
  }
end

Esto permite en una sola pasada convertir un evento anodino en una prioridad crítica.

Filtrado condicional y enrutamiento a streams

No todos los logs merecen ser indexados. Los mensajes de debug o los health-checks internos solo consumen espacio. El pipeline permite descartar mensajes con drop_message() o rutarlos a streams específicos según su contenido.

rule "descartar_pings_internos"
when
  has_field("source") and to_string($message.source) == "monitor_interno"
  and has_field("message") and contains(to_string($message.message), "heartbeat")
then
  // Elimina el mensaje por completo
  drop_message();
end

En cambio, si queremos separar tráfico de administración de tráfico de usuarios, podemos asignar un nuevo campo y usar la condición route_to_stream:

rule "rutear_admin"
when
  has_field("dst_port") and to_long($message.dst_port) == 3389
then
  route_to_stream("RDP_Admin_Stream");
  set_field("session_type", "administrativa");
end

Función lookup: enriquecido con datos internos

Muchas organizaciones tienen datos maestros: IPs de servidores críticos, nombres de departamentos, propietarios de activos. Podemos usar una lookup table basada en CSV para traducir una IP interna a un nombre de servicio.

rule "asignar_servicio"
when
  has_field("dst_ip")
then
  let servicio = lookup("inventario_servicios", to_string($message.dst_ip));
  if (servicio != null) {
    set_field("servicio_critico", servicio.nombre);
    set_field("criticidad", servicio.criticidad);
  }
end

Esto es especialmente útil en ataques laterales: si vemos movimiento desde una workstation hacia un servidor de base de datos marcado como crítico, el pipeline ya nos lo indica sin necesidad de consultas posteriores.

Dinámica de ejecución: condiciones y flujo

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