construção-de-regras-de-detecção-com-sigma

Construção de Regras de Detecção com Sigma

Quando Usar

Use esta habilidade quando:

• Engenheiros de SOC precisam criar regras de detecção portáteis entre múltiplas plataformas SIEM
• Relatórios de inteligência de ameaças descrevem TTPs que exigem nova cobertura de detecção
• Regras específicas de fornecedor existentes precisam de padronização em um formato compartilhável
• A equipe adota Sigma como padrão de detecção como código em pipelines CI/CD

Não use para detecção em streaming em tempo real (Sigma é para buscas em lote/agendadas) ou quando o SIEM de destino possui funcionalidades de detecção nativas que Sigma não consegue expressar (ex.: pontuação de risco RBA do Splunk).

Pré-requisitos

• Python 3.8+ com pySigma e backend apropriado (pySigma-backend-splunk, pySigma-backend-elasticsearch, pySigma-backend-microsoft365defender)
• Repositório de regras Sigma clonado: git clone https://github.com/SigmaHQ/sigma.git
• Conhecimento do framework MITRE ATT&CK para mapeamento de técnicas
• Compreensão dos mapeamentos de campos de origem de log do SIEM de destino

Fluxo de Trabalho

Passo 1: Definir Lógica de Detecção a partir de Inteligência de Ameaças

Comece com um relatório de ameaça ou técnica ATT&CK. Exemplo: detecção de roubo de credenciais Mimikatz (T1003.001 — Memória LSASS):

title: Detecção de Roubo de Credenciais Mimikatz via Acesso LSASS
id: 0d894093-71bc-43c3-8d63-bf520e73a7c5
status: stable
level: high
description: Detecta processos acessando a memória do lsass.exe, indicativo de ferramentas de roubo de credenciais como Mimikatz
references:
    - https://attack.mitre.org/techniques/T1003/001/
    - https://github.com/gentilkiwi/mimikatz
author: mahipal
date: 2024/03/15
modified: 2024/03/15
tags:
    - attack.credential_access
    - attack.t1003.001
logsource:
    category: process_access
    product: windows
detection:
    selection:
        TargetImage|endswith: '\lsass.exe'
        GrantedAccess|contains:
            - '0x1010'
            - '0x1038'
            - '0x1fffff'
            - '0x40'
    filter_main_svchost:
        SourceImage|endswith: '\svchost.exe'
    filter_main_csrss:
        SourceImage|endswith: '\csrss.exe'
    filter_main_wininit:
        SourceImage|endswith: '\wininit.exe'
    condition: selection and not 1 of filter_main_*
falsepositives:
    - Ferramentas de segurança legítimas acessando LSASS
    - Varredura do Windows Defender
    - Sensor CrowdStrike Falcon

Passo 2: Validar Sintaxe da Regra Sigma

Use sigma check para validar a regra:

# Instalar pySigma e validadores
pip install pySigma pySigma-validators-sigmaHQ

# Validar regra
sigma check rule.yml

Alternativamente, valide com Python:

from sigma.rule import SigmaRule
from sigma.validators.core import SigmaValidator

rule = SigmaRule.from_yaml(open("rule.yml").read())
validator = SigmaValidator()
issues = validator.validate_rule(rule)
for issue in issues:
    print(f"{issue.severity}: {issue.message}")

Passo 3: Converter para Consulta SIEM de Destino

Converter para Splunk SPL:

from sigma.rule import SigmaRule
from sigma.backends.splunk import SplunkBackend
from sigma.pipelines.splunk import splunk_windows_pipeline

pipeline = splunk_windows_pipeline()
backend = SplunkBackend(pipeline)

rule = SigmaRule.from_yaml(open("rule.yml").read())
splunk_query = backend.convert_rule(rule)
print(splunk_query[0])

Saída:

TargetImage="*\\lsass.exe" (GrantedAccess="*0x1010*" OR GrantedAccess="*0x1038*"
OR GrantedAccess="*0x1fffff*" OR GrantedAccess="*0x40*")
NOT (SourceImage="*\\svchost.exe") NOT (SourceImage="*\\csrss.exe")
NOT (SourceImage="*\\wininit.exe")

Converter para Consulta Elastic (Lucene):

from sigma.backends.elasticsearch import LuceneBackend
from sigma.pipelines.elasticsearch import ecs_windows_pipeline

pipeline = ecs_windows_pipeline()
backend = LuceneBackend(pipeline)
elastic_query = backend.convert_rule(rule)
print(elastic_query[0])

Converter para Microsoft Sentinel KQL:

from sigma.backends.microsoft365defender import Microsoft365DefenderBackend

backend = Microsoft365DefenderBackend()
kql_query = backend.convert_rule(rule)
print(kql_query[0])

Passo 4: Mapear para MITRE ATT&CK e Adicionar Metadados de Cobertura

Identifique cada regra com IDs de técnica ATT&CK no campo tags:

tags:
    - attack.credential_access        # Tática
    - attack.t1003.001                # Sub-técnica
    - attack.t1003                    # Técnica pai

Rastreie a cobertura de detecção usando o ATT&CK Navigator:

import json

# Gerar camada do ATT&CK Navigator a partir de regras Sigma
layer = {
    "name": "Cobertura de Detecção SOC",
    "versions": {"attack": "14", "navigator": "4.9", "layer": "4.5"},
    "domain": "enterprise-attack",
    "techniques": []
}

# Analisar diretório de regras Sigma para tags de técnicas
import os
from sigma.rule import SigmaRule

for root, dirs, files in os.walk("sigma/rules/windows/"):
    for f in files:
        if f.endswith(".yml"):
            rule = SigmaRule.from_yaml(open(os.path.join(root, f)).read())
            for tag in rule.tags:
                if str(tag).startswith("attack.t"):
                    technique_id = str(tag).replace("attack.", "").upper()
                    layer["techniques"].append({
                        "techniqueID": technique_id,
                        "color": "#31a354",
                        "score": 1
                    })

with open("coverage_layer.json", "w") as f:
    json.dump(layer, f, indent=2)

Passo 5: Testar Regra Contra Dados de Amostra

Crie dados de teste e valide que a regra captura os eventos esperados:

# Usar framework de teste sigma
sigma test rule.yml --target splunk --pipeline splunk_windows

# Ou testar manualmente no Splunk com dados de amostra
# Carregar log Sysmon process_access com assinatura conhecida do Mimikatz

Valide a taxa de falsos positivos executando contra 7 dias de dados de produção em uma busca salva sem alertas.

Passo 6: Implantar no SIEM de Produção

Implante a consulta convertida como uma busca agendada ou regra de correlação:

Correlação de Busca Splunk ES:

| tstats summariesonly=true count from datamodel=Endpoint.Processes
  where Processes.process_name="*\\lsass.exe"
  by Processes.src, Processes.user, Processes.process_name, Processes.parent_process_name
| `drop_dm_object_name(Processes)`
| where count > 0

Regra de Segurança Elastic (formato TOML):

[rule]
name = "Acesso à Memória LSASS - Roubo de Credenciais"
description = "Detecta acesso suspeito à memória do processo LSASS"
risk_score = 73
severity = "high"
type = "eql"
query = '''
process where event.action == "access" and
  process.name == "lsass.exe" and
  not process.executable : ("*\\svchost.exe", "*\\csrss.exe")
'''

[rule.threat]
framework = "MITRE ATT&CK"
[[rule.threat.technique]]
id = "T1003"
name = "Roubo de Credenciais do SO"

Passo 7: Controle de Versão e Integração CI/CD

Armazene regras no Git com testes automatizados:

# .github/workflows/sigma-ci.yml
name: CI de Regras Sigma
on: [push, pull_request]
jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: '3.11'
      - run: pip install pySigma pySigma-validators-sigmaHQ
      - run: sigma check rules/
      - run: sigma convert -t splunk -p splunk_windows rules/ > /dev/null

Conceitos Chave

Termo	Definição
Sigma	Formato de regra de detecção independente de fornecedor (baseado em YAML) que compila para consultas SIEM específicas via backends
pySigma	Biblioteca Python que substitui o sigmac legado para conversão, validação e processamento de pipeline de regras
Backend	Plugin pySigma que traduz a lógica de detecção Sigma para uma linguagem de consulta da plataforma de destino (SPL, KQL, Lucene)
Pipeline	Configuração de mapeamento de campos que traduz nomes de campos genéricos do Sigma para nomes de campos específicos do SIEM
Logsource	Seção da regra Sigma que define a categoria (process_creation, network_connection) e o produto (windows, linux) dos dados de destino
Detecção como Código	Prática de gerenciar regras de detecção em controle de versão com testes CI/CD e implantação automatizada

Ferramentas e Sistemas

• SigmaHQ: Repositório oficial de regras Sigma com mais de 3.000 regras de detecção mantidas pela comunidade no GitHub
• pySigma: Framework Python para processamento de regras Sigma com backends e pipelines modulares
• ATT&CK Navigator: Ferramenta MITRE para visualizar cobertura de detecção mapeada para técnicas ATT&CK
• Uncoder.IO: Conversor de regras Sigma baseado em web com suporte a mais de 30 plataformas SIEM para tradução rápida

Cenários Comuns

• Detecção de Nova CVE: Escrever regra Sigma para indicadores de exploração (ex.: padrões de consulta JNDI do Log4Shell em logs web)
• Promoção de Regra de Caça: Converter consulta de caça Splunk ad-hoc em regra Sigma para detecção automatizada contínua
• Migração Multi-SIEM: Converter mais de 500 correlações de busca Splunk para Sigma para migração para Elastic Security
• Saída de Equipe Roxa: Converter descobertas da equipe vermelha em regras Sigma para cobertura defensiva imediata
• Operacionalização de Inteligência de Ameaças: Transformar relatórios de ameaças baseados em IOC em regras Sigma comportamentais

Formato de Saída

RELATÓRIO DE IMPLANTAÇÃO DE REGRA SIGMA
━━━━━━━━━━━━━━━━━━━━━━━━━━━
ID da Regra:  0d894093-71bc-43c3-8d63-bf520e73a7c5
Título:       Detecção de Roubo de Credenciais Mimikatz via Acesso LSASS
ATT&CK:       T1003.001 - Memória LSASS
Severidade:   Alta
Status:       Implantado em Produção

Conversões:
  Splunk SPL:    PASS — Busca salva "sigma_lsass_access" criada
  Elastic EQL:   PASS — Regra de detecção ID elastic-0d894093 habilitada
  Sentinel KQL:  PASS — Regra de análise implantada via template ARM

Testes:
  Verdadeiros Positivos:    4/4 casos de teste correspondidos
  Falsos Positivos:   2 em 7 dias de retroteste (caso extremo svchost — filtro adicionado)
  Desempenho:       Média de execução 3,2s em 50M eventos/dia