Creación de Reglas de Detección con Sigma

¿Qué hace Creación de Reglas de Detección con Sigma?

Cuándo Usarlo

Utiliza este skill cuando:

• Los ingenieros de SOC necesitan crear reglas de detección portátiles entre múltiples plataformas SIEM
• Los informes de inteligencia de amenazas describen TTPs que requieren nueva cobertura de detección
• Las reglas existentes específicas de un proveedor necesitan estandarizarse en un formato compartible
• El equipo adopta Sigma como estándar de detección como código en pipelines CI/CD

No lo uses para detección en tiempo real por streaming (Sigma es para búsquedas por lotes o programadas) ni cuando el SIEM de destino tenga funciones de detección nativas que Sigma no pueda expresar (por ejemplo, la puntuación de riesgo RBA de Splunk).

Prerrequisitos

• Python 3.8+ con pySigma y el backend apropiado (pySigma-backend-splunk, pySigma-backend-elasticsearch, pySigma-backend-microsoft365defender)
• Repositorio de reglas Sigma clonado: git clone https://github.com/SigmaHQ/sigma.git
• Conocimiento del framework MITRE ATT&CK para el mapeo de técnicas
• Comprensión de las asignaciones de campos de fuentes de registro del SIEM de destino

Flujo de Trabajo

Paso 1: Definir la Lógica de Detección a partir de Inteligencia de Amenazas

Comienza con un informe de amenazas o una técnica ATT&CK. Ejemplo: detección de robo de credenciales con Mimikatz (T1003.001 — Memoria LSASS):

title: Detección de Robo de Credenciales con Mimikatz mediante Acceso a LSASS
id: 0d894093-71bc-43c3-8d63-bf520e73a7c5
status: stable
level: high
description: Detecta procesos que acceden a la memoria de lsass.exe, indicativo de herramientas de robo de credenciales 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:
    - Herramientas de seguridad legítimas accediendo a LSASS
    - Escaneo de Windows Defender
    - Sensor de CrowdStrike Falcon

Paso 2: Validar la Sintaxis de la Regla Sigma

Usa sigma check para validar la regla:

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

# Validar regla
sigma check rule.yml

Alternativamente, valida con 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}")

Paso 3: Convertir a Consultas del SIEM de Destino

Convertir a 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])

Salida:

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")

Convertir a Elastic Query (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])

Convertir a Microsoft Sentinel KQL:

from sigma.backends.microsoft365defender import Microsoft365DefenderBackend

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

Paso 4: Mapear a MITRE ATT&CK y Agregar Metadatos de Cobertura

Etiqueta cada regla con IDs de técnicas ATT&CK en el campo tags:

tags:
    - attack.credential_access        # Táctica
    - attack.t1003.001                # Sub-técnica
    - attack.t1003                    # Técnica padre

Rastrea la cobertura de detección usando el ATT&CK Navigator:

import json

# Generar capa de ATT&CK Navigator a partir de reglas Sigma
layer = {
    "name": "Cobertura de Detección del SOC",
    "versions": {"attack": "14", "navigator": "4.9", "layer": "4.5"},
    "domain": "enterprise-attack",
    "techniques": []
}

# Analizar directorio de reglas Sigma para etiquetas 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)

Paso 5: Probar la Regla Contra Datos de Muestra

Crea datos de prueba y valida que la regla detecte los eventos esperados:

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

# O probar manualmente en Splunk con datos de muestra
# Subir registro Sysmon process_access con firma conocida de Mimikatz

Valida la tasa de falsos positivos ejecutando contra 7 días de datos de producción en una búsqueda guardada sin alertas.

Paso 6: Desplegar en el SIEM de Producción

Despliega la consulta convertida como una búsqueda programada o regla de correlación:

Búsqueda de Correlación 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

Regla de Elastic Security (formato TOML):

[rule]
name = "Acceso a Memoria LSASS - Robo de Credenciales"
description = "Detecta acceso sospechoso a la memoria del proceso 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 = "Robo de Credenciales del SO"

Paso 7: Control de Versiones e Integración CI/CD

Almacena las reglas en Git con pruebas automatizadas:

# .github/workflows/sigma-ci.yml
name: Sigma CI de Reglas
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

Conceptos Clave

Término	Definición
Sigma	Formato de reglas de detección agnóstico al proveedor (basado en YAML) que se compila a consultas específicas de SIEM mediante backends
pySigma	Biblioteca Python que reemplaza al sigmac heredado para conversión, validación y procesamiento de pipelines de reglas
Backend	Plugin de pySigma que traduce la lógica de detección Sigma al lenguaje de consulta de la plataforma de destino (SPL, KQL, Lucene)
Pipeline	Configuración de mapeo de campos que traduce nombres de campo genéricos de Sigma a nombres de campo específicos del SIEM
Logsource	Sección de la regla Sigma que define la categoría (process_creation, network_connection) y el producto (windows, linux) de los datos objetivo
Detección como Código	Práctica de gestionar reglas de detección en control de versiones con pruebas CI/CD y despliegue automatizado

Herramientas y Sistemas

• SigmaHQ: Repositorio oficial de reglas Sigma con más de 3000 reglas de detección mantenidas por la comunidad en GitHub
• pySigma: Framework de procesamiento de reglas Sigma basado en Python con backends y pipelines modulares
• ATT&CK Navigator: Herramienta de MITRE para visualizar la cobertura de detección mapeada a técnicas ATT&CK
• Uncoder.IO: Conversor de reglas Sigma basado en web que soporta más de 30 plataformas SIEM para traducción rápida

Escenarios Comunes

• Detección de Nuevo CVE: Escribir regla Sigma para indicadores de explotación (ej. patrones de búsqueda JNDI de Log4Shell en registros web)
• Promoción de Regla de Cacería: Convertir una consulta de cacería ad-hoc de Splunk en una regla Sigma para detección automatizada continua
• Migración Multi-SIEM: Convertir 500+ búsquedas de correlación de Splunk a Sigma para migrar a Elastic Security
• Resultado de Purple Team: Convertir hallazgos del equipo rojo en reglas Sigma para cobertura defensiva inmediata
• Operacionalización de Inteligencia de Amenazas: Transformar informes de amenazas basados en IOCs en reglas Sigma de comportamiento

Formato de Salida

INFORME DE DESPLIEGUE DE REGLA SIGMA
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
ID de Regla:    0d894093-71bc-43c3-8d63-bf520e73a7c5
Título:         Detección de Robo de Credenciales con Mimikatz mediante Acceso a LSASS
ATT&CK:         T1003.001 - Memoria LSASS
Severidad:      Alta
Estado:         Desplegado en Producción

Conversiones:
  Splunk SPL:    ÉXITO — Búsqueda guardada "sigma_lsass_access" creada
  Elastic EQL:   ÉXITO — Regla de detección ID elastic-0d894093 habilitada
  Sentinel KQL:  ÉXITO — Regla de analítica desplegada mediante plantilla ARM

Pruebas:
  Verdaderos Positivos:    4/4 casos de prueba coincidieron
  Falsos Positivos:       2 en prueba retrospectiva de 7 días (caso borde svchost — filtro agregado)
  Rendimiento:             Ejecución promedio 3.2s en 50M eventos/día