RSigma

Um kit completo de engenharia de detecção Sigma

RSigma é um kit completo de engenharia de detecção para o padrão de detecção Sigma, incluindo um parser, mecanismo de avaliação, conversão de regras, runtime de streaming, linter, CLI, MCP e LSP.

RSigma analisa regras Sigma em YAML em uma AST fortemente tipada, compila-as em correspondentes otimizados e as avalia contra eventos de log em tempo real. Ele lida com lógica de correlação com estado em processo com armazenamento de eventos compactado e eficiente em memória. Ou, como Zack Allen colocou em DEW #149, "RSigma é essencialmente um SIEM."

Você pode enviar eventos em muitos formatos, incluindo JSON, syslog (RFC 3164/5424), logfmt, CEF, EVTX (Windows Event Log), texto simples e OTLP (OpenTelemetry Protocol), com detecção automática por padrão. Pipelines de processamento compatíveis com pySigma lidam com mapeamento de campos e configuração de backend. O suporte a OTLP permite que qualquer agente compatível com OpenTelemetry (Grafana Alloy, Vector, Fluent Bit, OTel Collector) encaminhe logs para RSigma via HTTP ou gRPC para detecção.

Para qualidade de regras e integração com editores, um linter integrado valida regras contra 90 verificações derivadas da especificação Sigma v2.1.0, e um servidor LSP fornece diagnósticos em tempo real, autocompletar, documentação ao passar o mouse e ações de correção rápida em qualquer editor.

RSigma é construído sobre padrões abertos da indústria em todo o processo: Sigma para regras de detecção, OpenTelemetry para ingestão de logs e exportação de detecções, e STIX e TAXII para inteligência de ameaças.

Documentação completa, incluindo guias, referência de CLI e documentação da API da biblioteca, está disponível em rsigma.io.

Recursos Suportados

Autor

• Análise Sigma: Analisa YAML Sigma em uma AST fortemente tipada com suporte para regras de detecção, correlação e filtro
• Correspondência de arrays (experimental): Corresponde membros de arrays em dados de eventos aninhados com semântica de qualquer/todos os membros, correlação de mesmo elemento e indexação posicional, opt-in via sigma-version: 3
• Rascunho de regras: Elabora regras de detecção e correlações temporais a partir de eventos exemplares contrastados com um corpus de linha de base com rule draft
• Ajuste de regras: Propõe um filtro nativo da especificação a partir de eventos de falso positivo, verifica que todo verdadeiro positivo conhecido ainda dispara e recusa separadores inseguros com rule tune
• Linter integrado: Valida regras com 90 verificações, quatro níveis de severidade, supressões, namespaces de tags personalizados e correção automática para 14 regras seguras
• Metadados ADS: Documenta regras com seções Palantir ADS sob rsigma.ads.*, aplicadas pelo linter e estruturadas com rule doc
• Servidor LSP: Fornece diagnósticos em tempo real, autocompletar, documentação ao passar o mouse, símbolos de documento e ações de correção rápida em VSCode, Neovim e qualquer editor compatível com LSP
• Servidor MCP: Expõe a ferramenta a agentes de IA (Cursor, Claude Code, ...) como ferramentas MCP estruturadas via stdio ou HTTP Streamable com rsigma mcp serve

Teste

• Diagnósticos de detecção: Explica por que uma regra correspondeu ou não a um evento com engine explain, compara transformações de pipeline com pipeline diff e inspeciona janelas de correlação ao vivo
• Backtesting de corpus: Reproduz um corpus de eventos contra expectativas declaradas por regra com rule backtest, emitindo um relatório JSON ou JUnit XML para CI
• Formatos de saída: Comandos estruturados renderizam JSON, NDJSON, tabela, CSV ou TSV com um padrão ciente de TTY via uma flag global --output-format; comandos de artefato e protocolo mantêm seu formato de fio fixo (veja o contrato por comando)

Implantação

• Integração com CI: Controla um repositório de regras em uma única verificação de pull request com a GitHub Action timescale/rsigma-action, envolvendo lint, validação, diff de drift de campos, backtest e cobertura
• Configuração: Camadas de configurações de arquivos YAML, variáveis de ambiente e flags de CLI, gerenciadas com o grupo de comandos rsigma config
• Artefatos assinados: Entrega imagens Docker multi-arquitetura com assinaturas cosign, SBOM e proveniência SLSA Build L3, além de binários pré-compilados para Linux, macOS e Windows

Detecção

• Avaliação de regras: Compila regras em correspondentes otimizados e as avalia contra eventos em tempo real, com detecção sem estado e correlação com estado (janelas deslizantes/tumbling/sessão, agrupamento por, encadeamento, supressão)
• Daemon de streaming: Executa como um daemon de detecção de longa duração com recarga a quente, métricas Prometheus, entrada stdin/HTTP/NATS/OTLP/socket Unix e sinks assíncronos (stdout, arquivo, NATS, OTLP, webhook, socket Unix) com retry por sink, DLQ e formato de fio por sink (NDJSON nativo ou OCSF Detection Finding JSON)
• Formatos de entrada: Ingere logs JSON, syslog (RFC 3164/5424), logfmt, CEF, EVTX (Windows Event Log), texto simples e OTLP com detecção automática de formato
• Pipelines de processamento: Mapeia campos e transforma regras com pipelines compatíveis com pySigma (transformações, condições, finalizadores)
• Pipelines dinâmicos: Popula qualquer valor de pipeline de fontes externas (HTTP, arquivos, comandos, NATS) com expansão de template, atualização automática e extração via jq, JSONPath ou CEL
• Reconhecimento de esquema: Reconhece qual esquema cada evento usa (ECS, Sysmon, CEF, OCSF ou definido pelo usuário) com engine classify, observa um daemon ao vivo para fontes não reconhecidas e extrai assinaturas candidatas com engine discover-schemas
• Roteamento de esquema: Constrói um mecanismo por conjunto de pipelines e despacha cada evento classificado para seu mecanismo, alimentando um armazenamento de correlação compartilhado
• Roteamento de logsource: Ignora regras cujo logsource conflita com o product/service/category declarado de um evento, para que um stream de produtos mistos só pague pelas regras que podem corresponder
• Pré-filtros de avaliação: Poda grandes conjuntos de regras antes da avaliação com um pré-filtro de substring bloom e um índice Aho-Corasick entre regras
• NATS JetStream: Consome e publica via JetStream com autenticação (credenciais, mTLS), replay, grupos de consumidores e filas de mensagens mortas
• Integração OTLP: Recebe logs de qualquer agente compatível com OpenTelemetry (Grafana Alloy, Vector, Fluent Bit, OTel Collector) via HTTP ou gRPC, e exporta detecções para um coletor OTLP
• Terminação TLS: Termina TLS em processo no listener da API do daemon com TLS mútuo opcional e recarga a quente de certificados entre plataformas
• Persistência de estado: Persiste estado de correlação, pipeline de alertas, risco e disposição em SQLite com --state-db e o restaura entre reinicializações. O anel de captura não é persistido.
• Operações ao vivo: Inspeciona um daemon em execução com engine status, registra fixtures reproduzíveis com engine tap e transmite detecções ao vivo com engine tail

Alerta e Triagem

• Enriquecimento: Injeta contexto (informações de ativos, reputação de IP, identidade, GeoIP, URLs de runbook, ...) em resultados de detecção e correlação via primitivas template, lookup, http e command
• Alertas baseados em risco: Pontua cada disparo por entidade (usuário, host, IP de origem) e levanta um único incidente quando o risco acumulado de uma entidade cruza um limite
• Pipeline de alertas: Silencia, inibe e deduplica resultados, então agrupa os sobreviventes em incidentes, modelado no Alertmanager
• Alertas via webhook: Entrega detecções para Slack, Teams, Discord, PagerDuty ou qualquer endpoint HTTP com payloads modelados, assinatura de requisição HMAC, retry por webhook, limitação de taxa e DLQ
• Feedback de triagem: Ingere disposições de analistas em uma proporção de falso positivo por regra que alimenta o scorecard de detecção
• Corpora orientados por veredito: Retém eventos de detecção group_by admitidos e escreve pacotes TP/FP após uma disposição aceita para rule backtest e rule tune --from-dispositions

Medição

• Cobertura ATT&CK: Exporta uma camada ATT&CK Navigator com rule coverage e relata lacunas contra Atomic Red Team, a linha de base SigmaHQ e uma lista de técnicas alvo
• Visibilidade de telemetria: Pontua a maturidade de fontes de dados com rule visibility, exportando arquivos de administração DeTT&CT e uma camada Navigator que revela pontos cegos
• Observabilidade de campos: Revela quais campos de eventos nenhuma regra referencia e quais campos de regras nunca aparecem em eventos, ao vivo no daemon ou como um relatório único de engine eval
• Scorecard de detecção: Funde sinais de backtest, cobertura, volume de produção e triagem com rule scorecard em vereditos de manter/ajustar/desativar por regra
• Higiene de regras: Sinaliza candidatos a desativação com rule hygiene: silenciosos, ruidosos, sem tags, sem dono, ADS incompleto, cobertura de campos quebrada ou status desatualizado

Caça

• Conversão de regras: Converte regras em consultas nativas de backend via uma trait de backend plugável, com backends nativos PostgreSQL/TimescaleDB, LynxDB e Fibratus, além de delegação sigma-cli para mais de 30 backends pySigma (Splunk, Elasticsearch, Microsoft Sentinel, ...)
• Execução de caça: Executa regras de detecção convertidas somente leitura contra um arquivo PostgreSQL/TimescaleDB com hunt run e transmite linhas correspondentes de volta como NDJSON em formato de exemplo que rule draft, rule tune, rule test e rule backtest consomem diretamente
• Catálogo de campos: Lista cada campo que um conjunto de regras referencia, antes ou depois do mapeamento de pipeline, com rule fields

Crates

Crate	Descrição
rsigma-parser	Analisa YAML Sigma em um AST fortemente tipado
rsigma-ir	Representação intermediária compartilhada entre avaliação e conversão
rsigma-eval	Compila e avalia regras contra eventos JSON
rsigma-convert	Transforma regras em strings de consulta nativas do backend
rsigma-runtime	Runtime de streaming com adaptadores de entrada, processador de logs e hot-reload
rsigma-mcp	Servidor Model Context Protocol (MCP) expondo a toolchain como ferramentas para agentes de IA
rsigma	CLI para analisar, validar, lintar, avaliar, converter regras, catálogo de campos e executar um daemon de detecção
rsigma-lsp	Servidor Language Server Protocol (LSP) para suporte a IDEs
rstix	Biblioteca STIX 2.1: objetos tipados, parse/stream de bundles, validação semântica e mecanismo de padrões

[!TIP] Para saber mais sobre o RSigma, leia estes artigos:

• Detecção de Padrões e Correlação em Logs JSON
• Transmitindo Logs para o RSigma para Detecção em Tempo Real
• Construindo uma Camada de Detecção no PostgreSQL com Regras Sigma
• Observabilidade de Segurança com RSigma e a Stack LGTM
• Integrando Threat Intel ao Vivo na Detecção Sigma com Pipelines Dinâmicos
• Detecção em Nuvem em Escala em um Laptop
• O Estado do RSigma
• Detecção-como-Código em uma Única Ação do GitHub com RSigma
• O Estado do RSigma, Parte Dois: O Loop

[!NOTE] O RSigma foi destaque em:

• Detection Engineering Weekly #149 (Março de 2026) "Construir uma ferramenta como o RSigma é desafiador porque a especificação Sigma evoluiu para uma linguagem de domínio específico robusta ao longo dos anos."
• tl;dr sec #320 (Março de 2026) "Avaliar com precisão todo o espectro do que as regras Sigma podem expressar é bastante complexo; é muito legal ler sobre como o RSigma lida com todas essas expressões condicionais, correlacionando entre regras, etc."
• The Deep Purple Sec by BlackNoise - Março de 2026 (Abril de 2026) "Equipes defensivas podem canalizar logs por comandos CLI, aplicar pipelines de mapeamento de campos e encadear correlações para detecção de ataques em múltiplos estágios."
• Detection Engineering Weekly #154 (Abril de 2026) "O RSigma não é um SIEM, mas é uma façanha impressionante construir um binário Rust autônomo que opera de forma muito semelhante a um. Para equipes que fazem validação de regras pré-SIEM ou forense, é uma opção sólida de plug-and-play."
• Detection Engineering Weekly #157 (Maio de 2026) "Em vez de codificar valores de IOC no YAML da regra, você declara fontes externas na configuração do pipeline, e o RSigma as busca e injeta no momento da avaliação. Isso funciona de forma muito semelhante a como vi SIEMs implementarem pipelines de inteligência de ameaças, mas como é o RSigma, é autossuficiente dentro do seu ecossistema."

Instalação

Binários pré-compilados para Linux, macOS e Windows (amd64 e arm64), com proveniência SLSA Build L3, estão anexados a cada lançamento do GitHub.

Ou instale a partir do crates.io:

# Install the CLI
cargo install --locked rsigma

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

Para compilar a partir do código-fonte:

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

Docker

Imagens multi-arquitetura (linux/amd64, linux/arm64) são publicadas no GHCR a cada lançamento, assinadas com cosign e contendo um SBOM SPDX e proveniência SLSA Build L3. Consulte o guia de implantação Docker.

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

Execute com endurecimento completo do 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/

Verifique a assinatura da imagem:

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

Início 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

Consulte o guia de Início Rápido para um tour guiado e o README da CLI para documentação completa de todos os subcomandos e flags.

Servidor MCP (agentes de IA)

Exponha a toolchain para agentes compatíveis com MCP (Cursor, Claude Code, ...) via stdio:

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

O agente então chama ferramentas estruturadas (parse_rule, lint_rules, validate_rules, evaluate_events, convert_rules, list_fields, ...) e recebe JSON de volta. Aponte --daemon-url para um daemon em execução para adicionar as ferramentas do ciclo Operate. Consulte o guia do servidor MCP.

Para ensinar a um agente a CLI atual e esse loop, instale a skill (a criação de YAML Sigma é uma skill separada):

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

Uso como Biblioteca

Use os crates diretamente do 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");

Arquitetura

Uma regra Sigma é analisada em um AST fortemente tipado (rsigma-parser), reduzida a uma representação intermediária compartilhada (rsigma-ir), e então compilada e avaliada contra eventos ao vivo (rsigma-eval dentro de rsigma-runtime), convertida em consultas nativas do backend (rsigma-convert), ou servida para editores e agentes de IA (rsigma-lsp, rsigma-mcp). A biblioteca de avaliação também alimenta a elaboração de regras orientada por exemplos e o ajuste verificado de filtros por meio da CLI e do MCP. O passo a passo completo, cobrindo todos os módulos e as quatro formas de execução, está na referência de Arquitetura.

Desempenho

O RSigma é projetado para detecção de alto throughput. Em um Apple M4 Pro:

• Análise: 12,4 MiB/s para 1000 regras
• Detecção: 1,12M eventos/seg (pipeline de runtime JSON, 100 regras)
• Correlação: 501K eventos/seg (temporal + contagem de eventos)
• Pipelines dinâmicos: 2,85M eventos/seg uma vez construídos (sem overhead por evento)

Consulte BENCHMARKS.md para resultados completos do Criterion em todos os subsistemas.

Referência

• pySigma: implementação Python de referência
• Especificação Sigma V2.1.0: especificação formal
• sigma-rust: abordagem de parsing Pratt
• sigmars: padrões de suporte a correlação
• sigma_engine: biblioteca Rust oficial do SigmaHQ para analisar e corresponder regras Sigma contra eventos
• pySigma-backend-sqlite: backend SQLite para pySigma (inspiração para o backend PostgreSQL)
• pySigma-backend-athena: backend AWS Athena para pySigma (campos SELECT, correlação baseada em CTE, padrões de janela deslizante)

Licença

MIT