Graylog Pipeline: Parseo y Enriquecido de Logs en Tiempo Real
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.