RSigma

Un kit completo de ingeniería de detección Sigma

RSigma es un kit completo de ingeniería de detección para el estándar de detección Sigma, que incluye un analizador sintáctico, motor de evaluación, conversión de reglas, runtime de streaming, linter, CLI, MCP y LSP.

RSigma analiza reglas Sigma YAML en un AST fuertemente tipado, las compila en matchers optimizados y las evalúa contra eventos de registro en tiempo real. Maneja lógica de correlación con estado en proceso con almacenamiento de eventos comprimido eficiente en memoria. O como lo expresó Zack Allen en DEW #149, "RSigma es esencialmente un SIEM."

Puedes enviar eventos en muchos formatos, incluyendo JSON, syslog (RFC 3164/5424), logfmt, CEF, EVTX (Registro de eventos de Windows), texto plano y OTLP (Protocolo OpenTelemetry), con autodetección por defecto. Los pipelines de procesamiento compatibles con pySigma manejan el mapeo de campos y la configuración de backend. El soporte OTLP permite que cualquier agente compatible con OpenTelemetry (Grafana Alloy, Vector, Fluent Bit, OTel Collector) reenvíe registros a RSigma a través de HTTP o gRPC para detección.

Para la calidad de reglas y la integración con editores, un linter integrado valida reglas contra 90 comprobaciones derivadas de la especificación Sigma v2.1.0, y un servidor LSP proporciona diagnósticos en tiempo real, autocompletado, documentación al pasar el cursor y acciones de corrección rápida en cualquier editor.

RSigma se basa en estándares industriales abiertos en todo momento: Sigma para reglas de detección, OpenTelemetry para ingesta de registros y exportación de detecciones, y STIX y TAXII para inteligencia de amenazas.

La documentación completa, incluyendo guías, referencia de CLI y documentación de la API de la biblioteca, está en rsigma.io.

Funcionalidades compatibles

Autor

• Análisis Sigma: Analiza Sigma YAML en un AST fuertemente tipado con soporte para reglas de detección, correlación y filtro
• Coincidencia de arrays (experimental): Coincide miembros de arrays en datos de eventos anidados con semántica de cualquier/todos los miembros, correlación del mismo elemento e indexación posicional, opt-in a través de sigma-version: 3
• Redacción de reglas: Redacta reglas de detección y correlaciones temporales a partir de eventos de ejemplo contrastados contra un corpus de referencia con rule draft
• Ajuste de reglas: Propone un filtro nativo de la especificación a partir de eventos de falsos positivos, verifica que cada verdadero positivo conocido aún se active y rechaza separadores inseguros con rule tune
• Linter integrado: Valida reglas con 90 comprobaciones, cuatro niveles de severidad, supresiones, espacios de nombres de etiquetas personalizados y corrección automática para 14 reglas seguras
• Metadatos ADS: Documenta reglas con secciones Palantir ADS bajo rsigma.ads.*, aplicadas por el linter y generadas con rule doc
• Servidor LSP: Proporciona diagnósticos en tiempo real, autocompletado, documentación al pasar el cursor, símbolos de documento y acciones de corrección rápida en VSCode, Neovim y cualquier editor compatible con LSP
• Servidor MCP: Expone el conjunto de herramientas a agentes de IA (Cursor, Claude Code, ...) como herramientas MCP estructuradas a través de stdio o HTTP Streamable con rsigma mcp serve

Prueba

• Diagnósticos de detección: Explica por qué una regla coincidió o no con un evento con engine explain, compara las transformaciones del pipeline con pipeline diff e inspecciona ventanas de correlación en vivo
• Pruebas retrospectivas de corpus: Reproduce un corpus de eventos contra expectativas declaradas por regla con rule backtest, emitiendo un informe JSON o JUnit XML para CI
• Formatos de salida: Los comandos estructurados renderizan JSON, NDJSON, tabla, CSV o TSV con un valor predeterminado consciente de TTY a través de un indicador global --output-format; los comandos de artefactos y protocolo mantienen su formato de cable fijo (ver el contrato por comando)

Despliegue

• Integración CI: Controla un repositorio de reglas en una sola verificación de solicitud de extracción con la Acción de GitHub timescale/rsigma-action, que envuelve lint, validación, diff de desviación de campos, pruebas retrospectivas y cobertura
• Configuración: Superpone configuraciones de archivos YAML, variables de entorno e indicadores de CLI, gestionados con el grupo de comandos rsigma config
• Artefactos firmados: Distribuye imágenes Docker multi-arquitectura con firmas cosign, SBOM y procedencia SLSA Build L3, además de binarios precompilados para Linux, macOS y Windows

Detección

• Evaluación de reglas: Compila reglas en matchers optimizados y las evalúa contra eventos en tiempo real, con detección sin estado y correlación con estado (ventanas deslizantes/por lotes/sesión, agrupación por, encadenamiento, supresión)
• Daemon de streaming: Se ejecuta como un daemon de detección de larga duración con recarga en caliente, métricas Prometheus, entrada stdin/HTTP/NATS/OTLP/socket Unix y sumideros asíncronos (stdout, archivo, NATS, OTLP, webhook, socket Unix) con reintento por sumidero, DLQ y un formato de cable por sumidero (NDJSON nativo o Hallazgo de detección OCSF JSON)
• Formatos de entrada: Ingiere registros JSON, syslog (RFC 3164/5424), logfmt, CEF, EVTX (Registro de eventos de Windows), texto plano y OTLP con autodetección de formato
• Pipelines de procesamiento: Mapea campos y transforma reglas con pipelines compatibles con pySigma (transformaciones, condiciones, finalizadores)
• Pipelines dinámicos: Rellena cualquier valor de pipeline desde fuentes externas (HTTP, archivos, comandos, NATS) con expansión de plantillas, actualización automática y extracción mediante jq, JSONPath o CEL
• Reconocimiento de esquema: Reconoce qué esquema usa cada evento (ECS, Sysmon, CEF, OCSF o definido por el usuario) con engine classify, observa un daemon en vivo para fuentes no reconocidas y extrae firmas candidatas con engine discover-schemas
• Enrutamiento de esquema: Construye un motor por conjunto de pipelines y despacha cada evento clasificado a su motor, alimentando un almacén de correlación compartido
• Enrutamiento de logsource: Omite reglas cuyo logsource entra en conflicto con el product/service/category declarado de un evento, de modo que un flujo de productos mixtos solo paga por las reglas que pueden coincidir
• Prefiltros de evaluación: Poda grandes conjuntos de reglas antes de la evaluación con un prefiltro de subcadenas bloom y un índice Aho-Corasick entre reglas
• NATS JetStream: Consume y publica a través de JetStream con autenticación (credenciales, mTLS), reproducción, grupos de consumidores y colas de mensajes muertos
• Integración OTLP: Recibe registros de cualquier agente compatible con OpenTelemetry (Grafana Alloy, Vector, Fluent Bit, OTel Collector) a través de HTTP o gRPC, y exporta detecciones a un colector OTLP
• Terminación TLS: Termina TLS en proceso en el listener de la API del daemon con TLS mutuo opcional y recarga en caliente de certificados multiplataforma
• Persistencia de estado: Persiste el estado de correlación, pipeline de alertas, riesgo y disposición en SQLite con --state-db y lo restaura entre reinicios. El anillo de captura no se persiste.
• Operaciones en vivo: Inspecciona un daemon en ejecución con engine status, registra fixtures reproducibles con engine tap y transmite detecciones en vivo con engine tail

Alerta y triaje

• Enriquecimiento: Inyecta contexto (información de activos, reputación de IP, identidad, GeoIP, URL de runbooks, ...) en resultados de detección y correlación a través de primitivas template, lookup, http y command
• Alertas basadas en riesgo: Puntúa cada activación por entidad (usuario, host, IP de origen) y eleva un solo incidente cuando el riesgo acumulado de una entidad cruza un umbral
• Pipeline de alertas: Silencia, inhibe y deduplica resultados, luego agrupa los sobrevivientes en incidentes, modelado en Alertmanager
• Alertas webhook: Entrega detecciones a Slack, Teams, Discord, PagerDuty o cualquier endpoint HTTP con payloads de plantilla, firma de solicitudes HMAC, reintento por webhook, limitación de velocidad y DLQ
• Retroalimentación de triaje: Ingiere disposiciones de analistas en una proporción de falsos positivos por regla que alimenta el cuadro de mando de detección
• Corpus impulsados por veredicto: Retiene eventos de detección group_by admitidos y escribe paquetes TP/FP después de una disposición aceptada para rule backtest y rule tune --from-dispositions

Medición

• Cobertura ATT&CK: Exporta una capa de ATT&CK Navigator con rule coverage e informa brechas contra Atomic Red Team, la línea base SigmaHQ y una lista de técnicas objetivo
• Visibilidad de telemetría: Puntúa la madurez de fuentes de datos con rule visibility, exportando archivos de administración DeTT&CT y una capa de Navigator que revela puntos ciegos
• Observabilidad de campos: Superficie qué campos de eventos ninguna regla referencia y qué campos de reglas nunca aparecen en eventos, en vivo en el daemon o como informe único desde engine eval
• Cuadro de mando de detección: Fusiona pruebas retrospectivas, cobertura, volumen de producción y señales de triaje con rule scorecard en veredictos de mantener/ajustar/retirar por regla
• Higiene de reglas: Señala candidatos a retiro con rule hygiene: silenciosos, ruidosos, sin etiquetar, sin propietario, ADS incompleto, cobertura de campos rota o estado obsoleto

Caza

• Conversión de reglas: Convierte reglas en consultas nativas de backend a través de un trait de backend conectable, con backends nativos PostgreSQL/TimescaleDB, LynxDB y Fibratus más delegación sigma-cli para más de 30 backends pySigma (Splunk, Elasticsearch, Microsoft Sentinel, ...)
• Ejecución de caza: Ejecuta reglas de detección convertidas de solo lectura contra un archivo PostgreSQL/TimescaleDB con hunt run y transmite filas coincidentes de vuelta como NDJSON con forma de ejemplo que rule draft, rule tune, rule test y rule backtest consumen directamente
• Catálogo de campos: Lista cada campo que un conjunto de reglas referencia, antes o después del mapeo de pipeline, con rule fields

Crates

Crate	Descripción
rsigma-parser	Analiza Sigma YAML en un AST fuertemente tipado
rsigma-ir	Representación intermedia compartida por evaluación y conversión
rsigma-eval	Compila y evalúa reglas contra eventos JSON
rsigma-convert	Transforma reglas en cadenas de consulta nativas del backend
rsigma-runtime	Runtime de streaming con adaptadores de entrada, procesador de logs y recarga en caliente
rsigma-mcp	Servidor Model Context Protocol (MCP) que expone el toolchain como herramientas para agentes de IA
rsigma	CLI para analizar, validar, hacer linting, evaluar, convertir reglas, catálogo de campos y ejecutar un daemon de detección
rsigma-lsp	Servidor Language Server Protocol (LSP) para soporte en IDE
rstix	Librería STIX 2.1: objetos tipados, parseo/streaming de bundles, validación semántica y motor de patrones

[!TIP] Para aprender más sobre RSigma, lee estos artículos:

• Detección de patrones y correlación en logs JSON
• Transmisión de logs a RSigma para detección en tiempo real
• Construyendo una capa de detección en PostgreSQL con reglas Sigma
• Observabilidad de seguridad con RSigma y el stack LGTM
• Integrando inteligencia de amenazas en vivo en la detección Sigma con pipelines dinámicos
• Detección en la nube a escala en una laptop
• El estado de RSigma
• Detección-como-código en una sola GitHub Action con RSigma
• El estado de RSigma, Parte Dos: El Bucle

[!NOTE] RSigma ha sido destacado en:

• Detection Engineering Weekly #149 (marzo 2026) "Construir una herramienta como RSigma es desafiante porque la especificación Sigma ha evolucionado hasta convertirse en un lenguaje de dominio específico robusto a lo largo de los años."
• tl;dr sec #320 (marzo 2026) "Evaluar con precisión todo el espectro de lo que las reglas Sigma pueden expresar es bastante complejo; es bastante interesante leer cómo RSigma maneja todas estas expresiones condicionales, correlacionando entre reglas, etc."
• The Deep Purple Sec by BlackNoise - marzo 2026 (abril 2026) "Los equipos defensivos pueden canalizar logs a través de comandos CLI, aplicar pipelines de mapeo de campos y encadenar correlaciones para la detección de ataques en múltiples etapas."
• Detection Engineering Weekly #154 (abril 2026) "RSigma no es un SIEM, pero es una hazaña impresionante construir un binario Rust autónomo que opera de manera muy similar. Para equipos que hacen validación de reglas pre-SIEM o forense, es una opción sólida de plug-and-play."
• Detection Engineering Weekly #157 (mayo 2026) "En lugar de codificar valores IOC en el YAML de las reglas, declaras fuentes externas en la configuración del pipeline, y RSigma las obtiene e inyecta en el momento de la evaluación. Esto funciona de manera muy similar a como he visto que los SIEM implementan pipelines de inteligencia de amenazas, pero como es RSigma, está autocontenido dentro de su ecosistema."

Instalación

Los binarios precompilados para Linux, macOS y Windows (amd64 y arm64), con procedencia SLSA Build L3, están adjuntos a cada release de GitHub.

O instala desde crates.io:

# Install the CLI
cargo install --locked rsigma

# Install the LSP server
cargo install --locked rsigma-lsp

Para compilar desde el código fuente:

cargo build --release --all-features --workspace

Docker

Las imágenes multi-arquitectura (linux/amd64, linux/arm64) se publican en GHCR en cada release, firmadas con cosign y con un SBOM SPDX y procedencia SLSA Build L3. Consulta la guía de despliegue con Docker.

docker pull ghcr.io/timescale/rsigma:latest
docker run --rm ghcr.io/timescale/rsigma:latest --help

Ejecuta con endurecimiento completo del runtime:

docker run --rm \
  --read-only \
  --cap-drop=ALL \
  --security-opt=no-new-privileges:true \
  -v /path/to/rules:/rules:ro \
  ghcr.io/timescale/rsigma:latest rule validate /rules/

Verifica la firma de la imagen:

cosign verify \
  --certificate-identity-regexp 'github.com/timescale/rsigma' \
  --certificate-oidc-issuer https://token.actions.githubusercontent.com \
  ghcr.io/timescale/rsigma:latest

Inicio Rápido

# Evaluate a single event against Sigma rules
rsigma engine eval -r rules/ -e '{"CommandLine": "cmd /c whoami"}'

# Stream NDJSON from stdin (auto-selected when stdout is piped)
cat events.ndjson | rsigma engine eval -r rules/

# Interactive triage in a terminal: width-aligned table view
rsigma engine eval -r rules/ -e @events.ndjson --output-format table

# Recognize which schema each event is (ECS, Sysmon, CEF, OCSF, ...)
cat events.ndjson | rsigma engine classify --output-format table

# Pipe a CSV view into a spreadsheet or data tool
rsigma engine eval -r rules/ -e @events.ndjson --output-format csv > matches.csv

# Run as a daemon with hot-reload and Prometheus metrics
rsigma engine daemon -r rules/ -p ecs.yml --api-addr 127.0.0.1:9090

# Accept events via HTTP POST
rsigma engine daemon -r rules/ --input http

# Check a running daemon's status (rules loaded, events processed, uptime)
rsigma engine status

# Record 30s of a running daemon's live events to a replayable fixture
# (opt-in: start the daemon with --enable-tap)
rsigma engine tap --duration 30s --redact-fields user.email,src_ip -o fixture.ndjson

# Stream a running daemon's live detections to the terminal
# (opt-in: start the daemon with --enable-tail)
rsigma engine tail --level high

# Convert rules to PostgreSQL SQL for historical threat hunting
rsigma backend convert rules/ -t postgres

# Any non-native target delegates to sigma-cli when it is installed (pipx install sigma-cli)
rsigma backend convert rules/ -t splunk

# Draft a detection rule from exemplar events, contrasted against a baseline corpus
rsigma rule draft -e @incident.ndjson --baseline @normal-day.ndjson

# Draft a temporal correlation from grouped, timed exemplars
rsigma rule draft --groups @observed.ndjson --negative @benign.ndjson

# Backtest a corpus against per-rule expectations (CI fixture harness)
rsigma rule backtest -r rules/ --corpus ci/corpus/ --expectations ci/expectations.yml

# Map coverage onto MITRE ATT&CK: export a Navigator layer and gate on a target list
rsigma rule coverage -r rules/ --navigator coverage.json --targets threat-model.txt --fail-on-gaps

Consulta la guía de Inicio Rápido para un recorrido guiado y el README del CLI para documentación completa de todos los subcomandos y banderas.

Servidor MCP (agentes de IA)

Expone el toolchain a agentes compatibles con MCP (Cursor, Claude Code, ...) a través de stdio:

# Run the MCP server (register it in your agent's mcp.json / via `claude mcp add`)
rsigma mcp serve --rules-dir rules/

El agente entonces llama a herramientas estructuradas (parse_rule, lint_rules, validate_rules, evaluate_events, convert_rules, list_fields, ...) y recibe JSON. Apunta --daemon-url a un daemon en ejecución para agregar las herramientas del ciclo Operate. Consulta la guía del servidor MCP.

Para enseñar a un agente el CLI actual y ese ciclo, instala la skill (la autoría de Sigma YAML es una skill separada):

npx skills add timescale/sigma-rules -g -y
npx skills add timescale/rsigma -g -y

Uso como Librería

Usa los crates directamente desde Rust:

use rsigma_parser::parse_sigma_yaml;
use rsigma_eval::Engine;
use rsigma_eval::event::JsonEvent;
use serde_json::json;

let yaml = r#"
title: Detect Whoami
logsource:
    product: windows
    category: process_creation
detection:
    selection:
        CommandLine|contains: 'whoami'
    condition: selection
level: medium
"#;

let collection = parse_sigma_yaml(yaml).unwrap();
let mut engine = Engine::new();
engine.add_collection(&collection).unwrap();

let event = JsonEvent::borrow(&json!({"CommandLine": "cmd /c whoami"}));
let matches = engine.evaluate(&event);
assert_eq!(matches[0].rule_title, "Detect Whoami");

Arquitectura

Una regla Sigma se analiza en un AST fuertemente tipado (rsigma-parser), se reduce a una representación intermedia compartida (rsigma-ir), y luego se compila y evalúa contra eventos en vivo (rsigma-eval dentro de rsigma-runtime), se convierte en consultas nativas del backend (rsigma-convert), o se sirve a editores y agentes de IA (rsigma-lsp, rsigma-mcp). La librería de evaluación también impulsa el borrador de reglas basado en ejemplos y el ajuste verificado de filtros a través del CLI y MCP. El recorrido completo, que cubre cada módulo y las cuatro formas de ejecución, se encuentra en la referencia de Arquitectura.

Rendimiento

RSigma está diseñado para detección de alto rendimiento. En un Apple M4 Pro:

• Análisis: 12.4 MiB/s para 1000 reglas
• Detección: 1.12M eventos/seg (pipeline de runtime JSON, 100 reglas)
• Correlación: 501K eventos/seg (temporal + conteo de eventos)
• Pipelines dinámicos: 2.85M eventos/seg una vez construidos (sin sobrecarga por evento)

Consulta BENCHMARKS.md para resultados completos de Criterion en todos los subsistemas.

Referencia

• pySigma: implementación de referencia en Python
• Especificación Sigma V2.1.0: especificación formal
• sigma-rust: enfoque de análisis Pratt
• sigmars: patrones de soporte de correlación
• sigma_engine: librería Rust oficial de SigmaHQ para analizar y comparar reglas Sigma contra eventos
• pySigma-backend-sqlite: backend SQLite para pySigma (inspiración para el backend PostgreSQL)
• pySigma-backend-athena: backend AWS Athena para pySigma (campos SELECT, correlación basada en CTE, patrones de ventana deslizante)

Licencia

MIT