Confluent Sigma: Guia de Solução Open-Source para Engenheiros de Detecção

As equipes de segurança precisam de maneiras mais rápidas e flexíveis para detectar ameaças em ambientes de dados complexos. Fluxos de dados de alto volume tornam a detecção difícil quando as operações estão fragmentadas em várias ferramentas, a agilidade na resposta a incidentes é limitada e gerenciar grandes conjuntos de dados é caro.

O Confluent Sigma aborda esses desafios ao permitir uma estratégia de detecção de ameaças Shift-Left que move a lógica de detecção do SIEM para a camada de processamento de fluxo. Isso permite que as equipes de segurança detectem ameaças mais próximas da origem e ajam sobre sinais de alta fidelidade enquanto um ataque está em andamento, em vez de esperar que os dados sejam normalizados, indexados e armazenados.

O Confluent Sigma usa Kafka Streams para executar regras Sigma em dados de origem antes de chegarem ao SIEM. Sigma é o padrão open-source e agnóstico de fornecedor para descrever eventos de log. Ao aplicar regras a fluxos de dados ao vivo, o Confluent Sigma combina a portabilidade do Sigma com a velocidade e escalabilidade do Apache Kafka.

Este guia o acompanha na instalação do Confluent Sigma e apresenta cenários práticos para seus principais casos de uso, ajudando as equipes de segurança a adotarem Detecção como Código e a responderem a ameaças de forma mais eficaz. 

Para equipes de segurança que precisam de escala imediata e recursos empresariais avançados, a Plataforma SOC Prime oferece uma solução totalmente suportada e de nível empresarial baseada no Confluent Sigma.

Módulos & Lógica de Processamento do Confluent Sigma

O Confluent Sigma é composto por três módulos principais:

• sigma-parser: Uma biblioteca Java que fornece a funcionalidade principal para ler e processar regras Sigma.
• sigma-streams-ui: Uma interface orientada ao desenvolvimento para interagir com o processo Sigma Streams, permitindo que os usuários visualizem regras publicadas, adicionem ou editem regras, monitorem o status dos processadores e visualizem detecções.
• sigma-streams: O módulo principal do projeto, que contém o processador de fluxos real e scripts de linha de comando associados.

O processador Sigma Streams aproveita o Kafka Streams para aplicar de forma eficiente a lógica de detecção com base no tipo de regra:

• Topologia Simples: Esta topologia suporta uma sub-topologia para muitas regras e é usada para detecções não agregadas com base em um único registro de evento. O processador usa a função flatMapValues do Kafka Streams para transformar registros. Ele percorre cada regra para filtragem, valida os dados em streaming contra a regra DSL e adiciona os resultados da correspondência a uma lista de saída. Este processo é altamente eficiente, e o registro de detecção final é enviado imediatamente para o tópico de saída dinâmico.
• Topologia de Agregação: Esta topologia requer uma sub-topologia para cada regra para gerenciar o estado e é usada para detecções complexas e com estado envolvendo contagem ou janelas de tempo. Para regras avançadas, o processador primeiro valida os dados e depois os agrupa por uma chave definida (ex.: id_orig_h). Aplica uma janela deslizante da regra (ex.: timeframe: 10s), conta o número de instâncias dentro dessa janela, e finalmente filtra com base na agregação e operação na regra (ex.: count() > 10). O registro de detecção agregado final é então enviado para o tópico de saída dinâmico.

Quando uma correspondência ocorre, o evento de detecção resultante é enriquecido antes da saída:

• Metadados da Regra: O evento inclui o title, author, product, service.
• Mapeamento de Campos: Se a regra utilizar uma expressão regular (regex), os campos extraídos serão adicionados à saída.
• Campos Personalizados: Qualquer metadado personalizado definido na regra é incluído para contextos e roteamento downstream.
• Saída Dinâmica: O resultado é enviado para o tópico especificado pelo campo outputTopic da regra.

Como Instalar o Confluent Sigma

Passo 1: Iniciando

O Confluent Sigma depende de três tópicos principais do Kafka para funcionar. O processador Sigma Streams monitora continuamente esses tópicos para aplicar a lógica e gerar detecções.

• Tópico de Regras: Contém regras Sigma
• Tópico de dados de entrada: Contém dados de eventos recebidos (ex.: logs).
• Tópico de saída: Contém eventos que corresponderam a uma ou mais regras Sigma.
  
  

As regras Sigma são publicadas em um tópico dedicado do Kafka, que o processador Sigma Streams monitora. Essas regras são então aplicadas em tempo real aos dados de outro tópico assinado. Quaisquer registros que correspondam às regras são encaminhados para um tópico de saída designado. 

Nota: Todos os três tópicos devem ser definidos na configuração. No entanto, as regras podem substituir o destino de saída para roteamento para diferentes tópicos com base na lógica da regra específica.

Antes de começar com o Confluent Sigma, certifique-se de ter o seguinte em vigor:

1. Ambiente Kafka
   • Um cluster Apache Kafka em execução (local ou em produção).
   • Acesso às ferramentas de CLI do Kafka (kafka-topics, kafka-console-producer, kafka-console-consumer).
   • Conexão de rede apropriada e permissões adequadas para criar e gerenciar tópicos.
2. Aplicativo Sigma Streams
   • Baixe e instale o aplicativo Confluent Sigma Streams.
   • Certifique-se de que o script bin/confluent-sigma.sh é executável.
3. Regras Sigma
   • Arquivos de regra Sigma válidos no formato YAML ou JSON.
   • Cada regra deve seguir a especificação Sigma.
4. Carregador de Regras Sigma (opcional)
   • Instale a utilidade SigmaRuleLoader se planeja carregar regras em lote.
5. Arquivos de Configuração
   Certifique-se de ter um arquivo de configuração sigma.properties válido com:
   • Tópico de regras
   • Tópico de dados de entrada
   • Tópico de saída
   • Configurações do servidor de bootstrap

Passo 2: Criando um Tópico de Regras Sigma

Antes de adicionar uma regra Sigma, certifique-se de criar um tópico de regra Sigma. Abaixo está um exemplo de como criar um tópico de regra Sigma:

kafka-topics --bootstrap-server localhost:9092 --topic sigma_rules --replication-factor 1 --partitions 1 --config cleanup.policy=compact --create

Nota: Para implantações de produção, use um fator de replicação de pelo menos 3. Como as regras são relativamente poucas em comparação com os dados de eventos, one uma partição é tipicamente suficiente.

Passo 3. Carregando Regras Sigma

As regras Sigma são armazenadas em um tópico do Kafka especificado pelo usuário. A chave de cada registro do Kafka deve atender aos seguintes requisitos:

• Tipo: string
• Definida para o campo de título da regra

Nota: A especificação Sigma não exige um campo de ID, portanto, os títulos das regras devem ser únicos. Regras recém-publicadas ou atualizadas são automaticamente capturadas por um processador Sigma Streams em execução.

As regras podem ser ingeridas no Kafka usando:

• aplicativo SigmaRuleLoader 
• The ferramenta de linha de comando kafka-console-producer Ingestão de Regras via SigmaRuleLoader

Rule Ingestion via SigmaRuleLoader

O aplicativo SigmaRuleLoader permite a ingestão em lote ou única de regras como arquivos YAML. 

Para carregar um único arquivo de regra Sigma, use a opção -file. Por exemplo:

sigma-rule-loader.sh -bootStrapServer localhost:9092 -topic sigma-rules -file zeek_sigma_rule.yml 

Para carregar todo o diretório contendo regras Sigma, use a opção -dir:

sigma-rule-loader.sh -bootStrapServer localhost:9092 -topic sigma-rules -dir zeek_sigma_rules

Ingestão de Regras via CLI

Você também pode carregar regras Sigma manualmente via um CLI padrão do Kafka, por exemplo, a utilidade ferramenta de linha de comando kafka-console-producer :

kafka-console-producer --broker-list localhost:9092 --topic sigma-rules --property "key.separator=:"

Aqui está um trecho de código da ingestão de regras via CLI no formato JSON:

--property "key.separator=:"

{"title":Sigma Rule Test,"id":"123456789","status":"experimental","description":"This is just a test.", "author":"Test", "date":"1970/01/01","references":["https://confluent.io/"],"tags":["test.test"],"logsource": {"category":"process_creation","product":"windows"},"detection":{"selection":{"CommandLine|contains|all": [" /vss "," /y "]},"condition":"selection"},"fields":["CommandLine","ParentCommandLine"],"falsepositives": ["Administrative activity"],"level":"high"}

Passo 4. Executando o Aplicativo Sigma Streams

O Confluent Sigma Streams é uma aplicação Java que pode ser executada diretamente ou através do script confluent-sigma.sh . Para executar a aplicação via script, use o seguinte comando: 

bin/confluent-sigma.sh properties-file

Ordem de pesquisa de configuração do Confluent Sigma Streams:

• Argumento de linha de comando (properties-file).
• variável de ambiente $SIGMAPROPS. Se você não especificar o

Nota: , o aplicativo verificará a variável properties-file, the application will check the variável de ambiente $SIGMAPROPS.

• Se a variável anterior não estiver definida, o aplicativo pesquisará os seguintes diretórios pelo arquivo properties-file:
  • ~/.config
  • ~/.confluent
  • ~/tmp

Veja os exemplos de sigma.properties aqui.

aqui

Recomendações de Implementação

Recarregamento a Quente de Regras via um Tópico Kafka

• : Crie um tópico Kafka dedicado e compactado para servir como “tópico de regras”. O aplicativo confluent-sigma deve consumir desse tópico usando um GlobalKTable. Quando uma nova regra Sigma ou uma regra atualizada for publicada nesse tópico (com chave por um ID de regra único), o GlobalKTable será atualizado automaticamente em tempo quase real. O fluxo de processamento do evento principal pode então se unir a este GlobalKTable, garantindo que sempre tenha o conjunto mais atual de regras sem precisar de um reinício.Recomendação
• Impacto: Isso fornece implantação de regras sem tempo de inatividade, permitindo que analistas de segurança reajam a novas ameaças quase instantaneamente. Desacopla o ciclo de vida de gerenciamento de regras do ciclo de vida de implantação de aplicativos.

Enriqueça Eventos No Fluxo Antes da Correspondência de Regras

Logs de segurança brutos muitas vezes carecem do contexto necessário para alertas de alta fidelidade. Por exemplo, um log bruto pode conter um endereço IP, mas não sua reputação, ou um ID de usuário, mas não o departamento ou função do usuário. Contar com o SIEM para todo o enriquecimento pode atrasar o contexto e criar alertas mais ruidosos.

• Recomendação Específica: Antes da lógica principal de correspondência de regras Sigma, implemente uma fase de enriquecimento dentro da topologia do Kafka Streams. Use uniões stream-table para enriquecer o fluxo de eventos de entrada.
  • Inteligência de Ameaças: Junte o fluxo de eventos com um GlobalKTable de IPs, domínios ou hashes de arquivos maliciosos conhecidos carregados a partir de um feed de inteligência de ameaças.
  • Informações de Ativos/Usuários: Junte o fluxo de eventos com um KTable populado a partir de um feed do CMDB ou Active Directory para adicionar contexto como proprietário do dispositivo, criticidade do servidor ou função do usuário.
• Impacto: Isso reduz drasticamente falsos positivos and aumenta a precisão da prioridade de alerta. Um evento envolvendo um servidor crítico ou um usuário privilegiado pode ser imediatamente escalado. Também torna os alertas enviados ao SIEM muito mais valiosos desde o início.

Melhores práticas

Tópicos Kafka Dedicados

• Isolamento: Usar tópicos dedicados para diferentes fluxos de dados fornece isolamento entre eles. Isso significa que um problema com um fluxo de dados (por exemplo, um pico repentino de tráfego) é menos provável de afetar os outros.
• Desempenho: Tópicos dedicados também podem melhorar o desempenho, permitindo que você otimize a configuração de cada tópico para seu caso de uso específico. Por exemplo, você pode definir um número diferente de partições ou um fator de replicação diferente para cada tópico.

Escalabilidade

• Escalonamento Horizontal: O aplicativo Confluent Sigma pode ser escalado horizontalmente executando várias instâncias do aplicativo em paralelo. Cada instância processará uma subseção dos dados, o que aumentará a taxa de transferência total do sistema.
• Particionamento: Para habilitar o escalonamento horizontal, você precisa particionar seus tópicos Kafka. Isso permitirá que múltiplas instâncias do aplicativo consumam dados do mesmo tópico em paralelo. Você deve escolher uma chave de particionamento que distribua os dados uniformemente nas partições.
• Grupos de Consumidores: Quando você executa várias instâncias do aplicativo Confluent Sigma, deve configurá-las para serem parte do mesmo grupo de consumidores. Isso garantirá que cada mensagem no tópico de entrada seja processada por apenas uma instância do aplicativo.

Criptografia

Você deve usar TLS/SSL para criptografar os dados em trânsito entre os produtores, consumidores e os brokers do Kafka. Isso protegerá os dados contra escuta clandestina e adulteração.

Monitoramento

É crucial monitorar a saúde e o desempenho do aplicativo Confluent Sigma em um ambiente de produção. Você deve monitorar as seguintes métricas:

• O número de mensagens processadas
• O número de alertas gerados
• A latência do aplicativo
• O uso de CPU e memória do aplicativo

Principais Métricas

Além das métricas mencionadas anteriormente, você também deve monitorar o seguinte:

• Atraso do Consumidor: Este é o número de mensagens em um tópico que ainda não foram processadas pelo consumidor. Um alto atraso do consumidor pode indicar que o aplicativo não consegue acompanhar a taxa de dados recebidos.
• Latência de Ponta a Ponta: Este é o tempo que leva para uma mensagem viajar do produtor para o consumidor. Uma alta latência de ponta a ponta pode indicar um problema com a rede ou o cluster Kafka.

Casos de Uso do Confluent Sigma

O Confluent Sigma permite que equipes de segurança detectem ameaças em tempo real ao aplicar regras Sigma diretamente a streams do Kafka, permitindo que engenheiros de detecção respondam a anomalias antes que os dados cheguem ao SIEM e otimizem o refinamento de regras.

Os principais casos de uso incluem os seguintes:

• Detecção de Ameaças Shift-Left: Aplicar lógica de detecção na origem, antes que os logs alcancem o SIEM, permitindo uma resposta mais rápida a ataques ao vivo.
• Configurar Pipeline CI/CD para Detecções: Automatizar implantação e atualizações de regras em ambientes enquanto melhora a eficiência operacional e a consistência.
• Versionar Regras Entre Ambientes: Manter versionamento estrutural de regras usando tópicos do Kafka ou Git, garantindo rastreabilidade e reversões mais fáceis.
• Reduzir Custos de Ingestão de Logs: Detectar ameaças em tempo de voo sem ingerir todos os logs no SIEM, reduzindo custos de armazenamento e processamento.

• Remover Latência de Consulta do SIEM: Acessar detecções de alta fidelidade instantaneamente ao processar regras em streams de dados em tempo real.
• Aumentar Velocidade de Correlação: Aplicar lógica de agregação e janela deslizante dentro do Kafka Streams para correlacionar eventos rapidamente e gerar alertas.

Confluent Sigma Potencializado pela Tecnologia SOC Prime

Enquanto o projeto open-source Confluent Sigma fornece uma base robusta para detecção Shift-Left, seu verdadeiro potencial para escala e cobertura avançada de ameaças é desbloqueado quando integrado a soluções empresariais como SOC Prime. A comparação abaixo destaca como as capacidades centrais evoluem para atender às demandas de ambientes complexos e em larga escala.

A solução Confluent Sigma & SOC Prime oferece acesso direto a ferramentas e conteúdos que aceleram drasticamente o ciclo de vida da detecção:

• Marketplace de Detecção de Ameaças: Ao utilizar o Marketplace de Detecção de Ameaças, as equipes de segurança podem escolher entre mais de 15 mil regras Sigma que abordam ameaças emergentes e transmiti-las diretamente para o ambiente Kafka de maneira automatizada. 
• Uncoder AI: Com o Uncoder AI da SOC Prime, um IDE e co-piloto para engenharia de detecção de ponta a ponta, os defensores podem converter código de detecção de múltiplos formatos de linguagem para Sigma, fazer mapeamento automático para o MITRE ATT&CK, escrever código do zero com IA, ou ajustar o código em tempo real para garantir uma detecção de ameaças otimizada.. 
• Excelência Operacional: A implantação automatizada via APIs e CI/CD garante uma implementação de regras consistente e repetível, enquanto o desempenho de alta capacidade (até 23 TB/dia por núcleo de CPU) permite a detecção de ameaças em tempo real e escalável em qualquer ambiente.
• Suporte Especializado: Confie na expertise de engenharia de ponta da SOC Prime para receber suporte orientado na instalação, gerenciamento e escalonamento do stack de detecção de código aberto.