Detekce za pomoci AI: LLM pro generování pravidel Sigma
Integrace velkých jazykových modelů do detekčního inženýrství představuje jednu z nejradikálnějších změn v prostředí SOC v posledních letech. Nejde jen o automatizaci opakujícího se úkolu: použití LLM ke generování pravidel Sigma znamená komprimaci procesu na sekundy, které expertní analytik dokončí během hodin, od přečtení zprávy o hrozbě až po napsání testovaného pravidla připraveného k nasazení.
Rámce jako SigmaGen, prezentované na MITER ATT&CK APAC 2025, ukazují, jak dokážou vyladěné modely přijímat zprávy o zpravodajství o hrozbách, extrahování technik ATT&CK a vytváření vysoce přesných mapovaných pravidel Sigma. Ve stejné době, open-source nástroje a Pracovní postupy založené na n8n umožňují menším týmům budovat kanály podporované umělou inteligencí bez podnikových investic.
Tento článek vás provede architekturou systému podporovaného umělou inteligencí pro generování pravidel detekce: od inženýrské výzvy, k automatickému ověřování, testování se syntetickými protokoly, k integraci do existujícího CI/CD potrubí.
Co se naučíte
- Jak LLM přemýšlí o formátu Sigma a proč produkují lepší výstup než přímé SPL
- Specifické techniky rychlého inženýrství pro generování pravidel detekce
- Architektura end-to-end potrubí s podporou umělé inteligence
- Automatická validace a testování vygenerovaných pravidel
- Integrace s workflow SigmaGen, pySigma a CI/CD
- Anti-vzory, kterým je třeba se vyhnout, a skutečné limity LLM v kontextu zabezpečení
proč LLMs Excel při generování pravidel Sigma
Jedním z nejzajímavějších pozorování, které vyplynulo z aplikovaného výzkumu (a potvrzeno praxí), je, že LLM produkují kvalitní výstup výrazně vyšší, když generují Sigma ve srovnání s přímými dotazy SPL nebo KQL. Důvod je strukturální.
Formát YAML společnosti Sigma jasně rozlišuje mezi:
- název a popis: Model musí formulovat, co detekuje a proč
- logsource: určuje zdroj dat (kategorii, produkt, službu)
- detekce: Booleovská porovnávací logika
- stav: Jak kombinovat voliče
- falešně pozitivní: Explicitní úvahy o okrajových případech
Tato struktura nutí model „myslet“ sekvenčně a deklarativně, čímž se snižují logické chyby, které vznikají, když přímo požaduje výstup v dotazovacím jazyce specifickém pro platformu. V praxi Sigma funguje jako a implicitní myšlenkový řetězec pro LLM aplikované na detekci.
Srovnávací data
Výzkumníci z projektu LLMCloudHunter (2024) prokázali, že obecné LLM jako GPT-4 generují pravidla Sigma, která jsou platná v 73 % případů. na strukturovaných zprávách CTI oproti 41 % při požadavku na přímý výstup SPL. Procento stoupá na 89 % s jemným doladěním datových sad bezpečnostní specifikace.
Architektura potrubí s podporou umělé inteligence
Potrubí za pomoci umělé inteligence pro generování pravidel detekce se skládá z pěti různých fází:
- Požití: přijímání zpráv o hrozbách, blogové příspěvky CTI, poradenství CVE
- Extrakce: Extrakce IOC, techniky ATT&CK, popsané chování
- Generace: generování pravidla Sigma prostřednictvím LLM
- Validace: automatická syntaktická a sémantická validace
- Testování: Testování se syntetickými protokoly a integrací CI/CD
# Architettura base della pipeline AI-assisted
# File: ai_sigma_pipeline.py
import openai
import yaml
import subprocess
from pathlib import Path
from dataclasses import dataclass
from typing import Optional
@dataclass
class ThreatReport:
content: str
source_url: str
report_type: str # 'cti_blog', 'advisory', 'malware_analysis'
@dataclass
class GeneratedRule:
sigma_yaml: str
mitre_techniques: list[str]
confidence: float
validation_passed: bool
test_results: Optional[dict] = None
class AISigmaPipeline:
def __init__(self, openai_api_key: str, rules_output_dir: str):
self.client = openai.OpenAI(api_key=openai_api_key)
self.output_dir = Path(rules_output_dir)
self.output_dir.mkdir(parents=True, exist_ok=True)
def process_report(self, report: ThreatReport) -> list[GeneratedRule]:
"""Pipeline completa da report a regole validate."""
# Stage 1: Extraction
techniques = self._extract_attack_techniques(report)
behaviors = self._extract_behaviors(report)
# Stage 2: Generation
rules = []
for technique in techniques:
rule = self._generate_sigma_rule(
report=report,
technique=technique,
behaviors=behaviors
)
if rule:
rules.append(rule)
# Stage 3: Validation + Testing
return [self._validate_and_test(r) for r in rules]
def _extract_attack_techniques(self, report: ThreatReport) -> list[str]:
"""Estrae tecniche ATT&CK dal report tramite LLM."""
response = self.client.chat.completions.create(
model="gpt-4o",
messages=[
{
"role": "system",
"content": (
"Sei un analista di threat intelligence esperto in MITRE ATT&CK. "
"Estrai SOLO le tecniche ATT&CK (formato T1234 o T1234.001) "
"esplicitamente descritte nel testo. Rispondi solo con una lista JSON."
)
},
{
"role": "user",
"content": f"Report:\n{report.content[:4000]}"
}
],
temperature=0.1 # Bassa temperatura per output deterministico
)
import json
try:
return json.loads(response.choices[0].message.content)
except json.JSONDecodeError:
return []Prompt Engineering pro kvalitní pravidla Sigma
Kvalita výstupu kriticky závisí na struktuře promptu. Existují tři základní vzorce, které přinášejí výsledky sestávající z generování pravidel Sigma:
Vzor 1: Výzva strukturovaného systému
Systémová výzva musí obsahovat přesně ty metainformace, které model potřebuje ke generování platných Sigmas:
strukturu YAML, platné hodnoty pro category e product, doporučené postupy na
falsepositives a povolené úrovně závažnosti.
# Prompt di sistema ottimizzato per generazione Sigma rules
SIGMA_SYSTEM_PROMPT = """
Sei un Detection Engineer esperto nella scrittura di Sigma rules.
Quando generi una Sigma rule, rispetta SEMPRE questa struttura YAML:
title: [titolo descrittivo, max 80 char]
id: [UUID v4]
status: experimental
description: [descrizione dettagliata del comportamento rilevato]
references:
- [URL del report originale se disponibile]
author: AI-Assisted Detection
date: [data odierna in formato YYYY-MM-DD]
tags:
- attack.[tattica]
- attack.[tecnica]
logsource:
category: [process_creation | network_connection | file_event | registry_event]
product: [windows | linux | macos]
detection:
[nome_selettore]:
[campo]: [valore o lista valori]
condition: [nome_selettore]
falsepositives:
- [casi legittimi plausibili]
level: [informational | low | medium | high | critical]
REGOLE CRITICHE:
- Usa SEMPRE wildcards (*) nei valori stringa per evitare match esatti fragili
- Preferisci campi con alta disponibilità (Image, CommandLine, ParentImage)
- Indica sempre almeno un falso positivo realistico
- Il campo 'condition' deve essere semplice e leggibile
- Non usare regex complesse se un approccio con keywords e sufficiente
"""
def build_generation_prompt(technique_id: str, behaviors: list[str],
logsource_hint: str, report_excerpt: str) -> str:
return f"""Genera una Sigma rule per rilevare la tecnica MITRE ATT&CK {technique_id}.
Comportamenti osservati nel report:
{chr(10).join(f'- {b}' for b in behaviors[:5])}
Tipo di log suggerito: {logsource_hint}
Estratto del report originale:
{report_excerpt[:1500]}
Genera UNA SOLA Sigma rule in formato YAML valido. Non aggiungere spiegazioni fuori dal YAML."""Vzor 2: Několik výstřelů s příklady kvality
Zahrnutí 2-3 příkladů vysoce kvalitních pravidel do výzvy (několik snímků) výrazně zlepšuje konzistenci výstupu, zejména pro neobvyklé zdroje protokolů nebo složité podmínky.
# Few-shot: esempio di regola di qualità inclusa nel prompt
FEW_SHOT_EXAMPLE = """
Esempio di regola di alta qualità per ispirazione:
title: Suspicious PowerShell Encoded Command Execution
id: 5b4f6d89-1234-4321-ab12-fedcba987654
status: stable
description: >
Rileva l'esecuzione di PowerShell con parametri di encoding (-enc, -EncodedCommand)
frequentemente usati da malware per offuscare payload malevoli.
references:
- https://attack.mitre.org/techniques/T1059/001/
author: SigmaHQ Community
date: 2025-01-15
tags:
- attack.execution
- attack.t1059.001
logsource:
category: process_creation
product: windows
detection:
selection:
Image|endswith:
- '\\\\powershell.exe'
- '\\\\pwsh.exe'
CommandLine|contains:
- ' -enc '
- ' -EncodedCommand '
- ' -ec '
condition: selection
falsepositives:
- Software legittimo che usa PowerShell con encoding per configurazioni complesse
- Script di deployment enterprise
level: medium
"""Vzor 3: Explicitní řetězec myšlenek
U složitých technik poskytuje přesnější výstupy požadavek na zdůvodnění modelu před napsáním pravidla. Tento přístup zvyšuje latenci, ale výrazně snižuje počet potřebných iterací.
def generate_with_cot(self, technique_id: str, report: ThreatReport) -> GeneratedRule:
"""Generazione con Chain-of-Thought esplicito."""
# Step 1: Chiedi al modello di ragionare
reasoning_response = self.client.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system", "content": SIGMA_SYSTEM_PROMPT},
{
"role": "user",
"content": f"""Prima di scrivere la regola per {technique_id}, analizza:
1. Quali artefatti forensi questa tecnica lascia nei log?
2. Qual è il logsource più appropriato?
3. Quali campi hanno la maggiore discriminazione signal/noise?
4. Quali sono i falsi positivi più comuni?
Report: {report.content[:2000]}"""
}
],
temperature=0.3
)
reasoning = reasoning_response.choices[0].message.content
# Step 2: Usa il ragionamento per guidare la generazione
rule_response = self.client.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system", "content": SIGMA_SYSTEM_PROMPT},
{"role": "user", "content": f"Analisi tecnica:\n{reasoning}"},
{
"role": "assistant",
"content": "Basandomi su questa analisi, genero la Sigma rule ottimale:"
},
{"role": "user", "content": "Procedi con la generazione YAML."}
],
temperature=0.1
)
return GeneratedRule(
sigma_yaml=rule_response.choices[0].message.content,
mitre_techniques=[technique_id],
confidence=0.0, # Calcolata nella validazione
validation_passed=False
)Automatická validace vygenerovaných pravidel
LLM může produkovat syntakticky platný, ale sémanticky nesprávný YAML: neexistující zdroj protokolu, pole misnamed, stav, který neodkazuje na selektory správně. Automatická validace a kritická brána před tím, než pravidlo vstoupí do úložiště.
import yaml
from sigma.rule import SigmaRule
from sigma.exceptions import SigmaError
import re
import uuid
class SigmaRuleValidator:
# Logsource validi più comuni
VALID_CATEGORIES = {
'process_creation', 'network_connection', 'file_event',
'registry_event', 'registry_add', 'registry_set',
'dns_query', 'image_load', 'pipe_created', 'raw_access_read'
}
VALID_LEVELS = {'informational', 'low', 'medium', 'high', 'critical'}
VALID_STATUSES = {'stable', 'test', 'experimental', 'deprecated', 'unsupported'}
def validate(self, sigma_yaml: str) -> tuple[bool, list[str]]:
"""Valida una Sigma rule. Restituisce (valida, lista errori)."""
errors = []
# 1. Validazione YAML sintattico
try:
rule_dict = yaml.safe_load(sigma_yaml)
except yaml.YAMLError as e:
return False, [f"YAML invalido: {str(e)}"]
# 2. Campi obbligatori
required_fields = ['title', 'description', 'logsource', 'detection']
for field in required_fields:
if field not in rule_dict:
errors.append(f"Campo obbligatorio mancante: {field}")
if errors:
return False, errors
# 3. Validazione logsource
logsource = rule_dict.get('logsource', {})
if 'category' in logsource:
if logsource['category'] not in self.VALID_CATEGORIES:
errors.append(
f"Categoria logsource non valida: {logsource['category']}. "
f"Valide: {', '.join(self.VALID_CATEGORIES)}"
)
# 4. Validazione detection
detection = rule_dict.get('detection', {})
if 'condition' not in detection:
errors.append("Campo 'condition' mancante in detection")
else:
condition = detection['condition']
# Verifica che i selettori nella condition esistano
selectors = [k for k in detection.keys() if k != 'condition']
# Parse base della condition per trovare riferimenti
referenced = re.findall(r'\b([a-zA-Z_][a-zA-Z0-9_]*)\b', condition)
for ref in referenced:
if ref not in ['and', 'or', 'not', '1', 'of', 'all', 'them', 'filter']:
if ref not in selectors:
errors.append(
f"Condition referenzia '{ref}' che non esiste nei selettori: {selectors}"
)
# 5. Validazione level
level = rule_dict.get('level', '')
if level and level not in self.VALID_LEVELS:
errors.append(f"Level non valido: {level}. Validi: {self.VALID_LEVELS}")
# 6. UUID check
rule_id = rule_dict.get('id', '')
if rule_id:
try:
uuid.UUID(str(rule_id))
except ValueError:
errors.append(f"ID non e un UUID valido: {rule_id}")
else:
errors.append("Campo 'id' mancante - genera un UUID v4")
# 7. Validazione pySigma (se disponibile)
try:
SigmaRule.from_yaml(sigma_yaml)
except SigmaError as e:
errors.append(f"Errore pySigma: {str(e)}")
return len(errors) == 0, errorsAnti-Pattern: Slepě důvěřovat výstupu LLM
Častou chybou v týmech implementujících detekci pomocí AI je nasazování generovaných pravidel bez ověření. LLM dělají specifické a opakovatelné chyby v generování Sigma:
- Použijte pole
ProcessNamemístoImage(Sysmon) - Napište podmínky, které odkazují na neexistující selektory
- Vymyslet nestandardní kategorie logsource
- Použití
containsna polích, která nepodporují zástupné znaky v cílovém zdroji protokolu
Automatické ověřování a testování se skutečnými protokoly NENÍ VOLITELNÉ.
Automatizované testování se syntetickými protokoly
Po syntaktickém ověření musí být každé pravidlo otestováno na protokolech, které simulují obě chování očekávaný škodlivý provoz (skutečně pozitivní test) než normální provoz (falešně pozitivní test). Tento přístup, volal testování jednotek pravidela praxe, která odlišuje vyzrálé potrubí od a experimentovat.
import json
from sigma.collection import SigmaCollection
from sigma.backends.test import TextQueryTestBackend
from typing import Any
class SigmaRuleTester:
def __init__(self):
self.backend = TextQueryTestBackend()
def generate_test_events(self, sigma_yaml: str,
llm_client) -> dict[str, list[dict]]:
"""Genera eventi di test tramite LLM basandosi sulla regola."""
rule_dict = yaml.safe_load(sigma_yaml)
prompt = f"""Data questa Sigma rule:
{sigma_yaml}
Genera in formato JSON due liste di eventi di log:
1. "true_positives": 3 eventi che DEVONO triggherare la regola
2. "false_positives": 3 eventi legittimi che NON devono triggherare la regola
Ogni evento deve avere i campi esatti che la regola usa per il matching.
Formato richiesto:
{
"true_positives": [
{"Image": "C:\\\\Windows\\\\System32\\\\cmd.exe", "CommandLine": "...", ...}
],
"false_positives": [
{"Image": "C:\\\\Program Files\\\\...", "CommandLine": "...", ...}
]
}"""
response = llm_client.chat.completions.create(
model="gpt-4o-mini", # Modello più economico per i test
messages=[{"role": "user", "content": prompt}],
temperature=0.2
)
try:
return json.loads(response.choices[0].message.content)
except json.JSONDecodeError:
return {"true_positives": [], "false_positives": []}
def run_tests(self, sigma_yaml: str, test_events: dict) -> dict[str, Any]:
"""Esegue i test e restituisce risultati dettagliati."""
results = {
"tp_tests": {"passed": 0, "failed": 0, "details": []},
"fp_tests": {"passed": 0, "failed": 0, "details": []},
"overall_pass": False
}
# Nota: questa e una simulazione del meccanismo di test.
# In produzione si usano tool come sigma-test o un SIEM sandbox.
rule_dict = yaml.safe_load(sigma_yaml)
detection = rule_dict.get('detection', {})
for event in test_events.get('true_positives', []):
matched = self._simulate_match(event, detection)
if matched:
results["tp_tests"]["passed"] += 1
results["tp_tests"]["details"].append({"event": event, "result": "PASS"})
else:
results["tp_tests"]["failed"] += 1
results["tp_tests"]["details"].append({"event": event, "result": "FAIL - non matchato"})
for event in test_events.get('false_positives', []):
matched = self._simulate_match(event, detection)
if not matched:
results["fp_tests"]["passed"] += 1
results["fp_tests"]["details"].append({"event": event, "result": "PASS"})
else:
results["fp_tests"]["failed"] += 1
results["fp_tests"]["details"].append({"event": event, "result": "FAIL - falso positivo"})
tp_ok = results["tp_tests"]["failed"] == 0
fp_ok = results["fp_tests"]["failed"] == 0
results["overall_pass"] = tp_ok and fp_ok
return results
def _simulate_match(self, event: dict, detection: dict) -> bool:
"""Simulazione semplificata del match. Per produzione: usa sigma-test."""
# Logica di matching semplificata per demo
for selector_name, selector_criteria in detection.items():
if selector_name == 'condition':
continue
if not isinstance(selector_criteria, dict):
continue
for field, value in selector_criteria.items():
actual_field = field.split('|')[0]
modifier = field.split('|')[1] if '|' in field else 'exact'
event_value = event.get(actual_field, '')
if isinstance(value, list):
for v in value:
if self._apply_modifier(str(event_value), str(v), modifier):
return True
else:
if self._apply_modifier(str(event_value), str(value), modifier):
return True
return False
def _apply_modifier(self, event_val: str, pattern: str, modifier: str) -> bool:
pattern_clean = pattern.replace('*', '')
if modifier == 'contains':
return pattern_clean.lower() in event_val.lower()
elif modifier == 'endswith':
return event_val.lower().endswith(pattern_clean.lower())
elif modifier == 'startswith':
return event_val.lower().startswith(pattern_clean.lower())
return event_val.lower() == pattern_clean.lower()SigmaGen: Open-Source Framework pro AI-Assisted Detection
SigmaGen, představený na MITER ATT&CK APAC 2025, představuje nejmodernější rámce open-source pro generování pravidel detekce pomocí umělé inteligence. Projekt kombinuje jemné doladění kurátorských datových sad s architektura potrubí, která pokrývá celý životní cyklus pravidla.
# Integrazione con SigmaGen (workflow concettuale)
# SigmaGen usa un approccio in tre fasi:
# 1. Ingestion di CTI (blog, advisory, STIX feeds)
# 2. Extraction di tecniche ATT&CK tramite NER specializzato
# 3. Generazione Sigma tramite modello fine-tuned
# Workflow alternativo con n8n e LLM generici:
# n8n Workflow JSON (estratto concettuale)
N8N_WORKFLOW_STRUCTURE = {
"nodes": [
{
"name": "RSS_CTI_Feed",
"type": "n8n-nodes-base.rssFeedRead",
"parameters": {
"url": "https://example-cti-blog.com/feed.xml"
}
},
{
"name": "Extract_Techniques",
"type": "n8n-nodes-base.openAi",
"parameters": {
"model": "gpt-4o",
"prompt": "Estrai tecniche ATT&CK da: {{$json.content}}",
"system_prompt": "Sei un analista CTI esperto..."
}
},
{
"name": "Generate_Sigma",
"type": "n8n-nodes-base.openAi",
"parameters": {
"model": "gpt-4o",
"prompt": "Genera Sigma rule per: {{$json.techniques}}",
"system_prompt": SIGMA_SYSTEM_PROMPT
}
},
{
"name": "Validate_Rule",
"type": "n8n-nodes-base.code",
"parameters": {
"code": "// Chiama API di validazione Python"
}
},
{
"name": "GitHub_PR",
"type": "n8n-nodes-base.github",
"parameters": {
"operation": "createPullRequest",
"repository": "org/detection-rules"
}
}
]
}
# Pipeline Python completa con gestione errori
class FullAISigmaPipeline:
def __init__(self, config: dict):
self.llm_client = openai.OpenAI(api_key=config['openai_key'])
self.validator = SigmaRuleValidator()
self.tester = SigmaRuleTester()
self.max_retries = config.get('max_retries', 3)
def generate_validated_rule(self, technique_id: str,
report: ThreatReport) -> Optional[GeneratedRule]:
"""Genera, valida e testa una regola con retry automatico."""
errors_history = []
for attempt in range(self.max_retries):
# Genera la regola (con errori precedenti nel prompt se disponibili)
sigma_yaml = self._generate_with_error_feedback(
technique_id, report, errors_history
)
# Valida
is_valid, errors = self.validator.validate(sigma_yaml)
if not is_valid:
errors_history.extend(errors)
continue
# Test con eventi sintetici
test_events = self.tester.generate_test_events(sigma_yaml, self.llm_client)
test_results = self.tester.run_tests(sigma_yaml, test_events)
if test_results['overall_pass']:
return GeneratedRule(
sigma_yaml=sigma_yaml,
mitre_techniques=[technique_id],
confidence=self._calculate_confidence(test_results),
validation_passed=True,
test_results=test_results
)
else:
errors_history.append(f"Test falliti: {test_results}")
return None # Non e riuscito a generare una regola valida
def _generate_with_error_feedback(self, technique_id: str,
report: ThreatReport,
errors: list[str]) -> str:
"""Genera con feedback sugli errori precedenti."""
error_context = ""
if errors:
error_context = f"\n\nTentativo precedente fallito con errori:\n" + \
"\n".join(f"- {e}" for e in errors[-3:]) # Ultimi 3 errori
prompt = build_generation_prompt(
technique_id=technique_id,
behaviors=[],
logsource_hint="process_creation",
report_excerpt=report.content[:2000] + error_context
)
response = self.llm_client.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system", "content": SIGMA_SYSTEM_PROMPT},
{"role": "user", "content": prompt}
],
temperature=0.1
)
return response.choices[0].message.content
def _calculate_confidence(self, test_results: dict) -> float:
"""Calcola un confidence score basato sui test."""
tp = test_results["tp_tests"]
fp = test_results["fp_tests"]
total_tp = tp["passed"] + tp["failed"]
total_fp = fp["passed"] + fp["failed"]
if total_tp == 0 or total_fp == 0:
return 0.5
tp_rate = tp["passed"] / total_tp
fp_ok_rate = fp["passed"] / total_fp
return (tp_rate + fp_ok_rate) / 2Integrace do potrubí CI/CD
Vygenerovaná a ověřená pravidla se automaticky nedostanou do výroby: musí projít procesem Human review a CI/CD brány potrubí Detection-as-Code. Doporučený tok je AI vygenerovat Pull Request, nikoli přímé sloučení.
# GitHub Actions workflow per AI-generated rules
# File: .github/workflows/ai-sigma-generation.yml
"""
name: AI Sigma Rule Generation
on:
schedule:
- cron: '0 6 * * *' # Ogni giorno alle 6:00 UTC
workflow_dispatch:
inputs:
cti_url:
description: 'URL del CTI report da processare'
required: false
jobs:
generate-rules:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Setup Python
uses: actions/setup-python@v5
with:
python-version: '3.12'
- name: Install dependencies
run: pip install openai pySigma pySigma-backend-splunk pyyaml
- name: Run AI pipeline
env:
OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
run: python scripts/ai_sigma_pipeline.py
- name: Validate generated rules
run: python scripts/validate_all_rules.py rules/ai-generated/
- name: Create Pull Request
uses: peter-evans/create-pull-request@v6
with:
title: '[AI-Generated] Detection rules da CTI feed'
body: |
## Regole generate automaticamente da AI
Tecniche ATT&CK rilevate e tradotte in Sigma rules.
**REVIEW OBBLIGATORIA** - Verificare prima del merge:
- [ ] Logsource corretto per il SIEM target
- [ ] Condition logicamente corretta
- [ ] Falsi positivi accettabili
- [ ] Test su ambiente staging completato
labels: 'ai-generated,needs-review'
branch: 'ai-generated-rules'
"""
# Script di validazione bulk
# File: scripts/validate_all_rules.py
import sys
from pathlib import Path
def validate_directory(rules_dir: str) -> int:
"""Valida tutte le regole in una directory. Restituisce exit code."""
validator = SigmaRuleValidator()
rules_path = Path(rules_dir)
failed = []
for rule_file in rules_path.glob("**/*.yml"):
content = rule_file.read_text()
is_valid, errors = validator.validate(content)
if not is_valid:
failed.append((rule_file.name, errors))
print(f"FAIL: {rule_file.name}")
for e in errors:
print(f" - {e}")
else:
print(f"OK: {rule_file.name}")
print(f"\nRisultati: {len(failed)} fallite su {len(list(rules_path.glob('**/*.yml')))} totali")
return 1 if failed else 0
if __name__ == "__main__":
sys.exit(validate_directory(sys.argv[1] if len(sys.argv) > 1 else "rules/"))Alternativní modely a úvahy o nákladech
Ne všechny organizace mohou nebo chtějí odesílat citlivá data CTI do cloudových API. Použití šablon prostory přes Ollama o vLLM a konkrétní alternativa pro prostředí s požadavky na umístění dat.
| Model | Kvalita Sigma | Cena za 100 pravidel | Průměrná latence | Datum pobytu |
|---|---|---|---|---|
| GPT-4o | Vysoká (87 % platných) | ~2,50 $ | 3-8s | Cloud (OpenAI) |
| GPT-4o-mini | Dobré (71 % platných) | ~0,15 $ | 1-3s | Cloud (OpenAI) |
| Sonety Claude 3.5 | Vysoká (84 % platných) | ~3,00 $ | 3-6s | Cloud (antropický) |
| Llama 3.1 70B (místní) | Spravedlivé (58 % platných) | ~$0 (níže) | 15-45s | On-premise |
| Mistral 7B doladěn | Dobré (69 % platných) | ~$0 (níže) | 5-15s | On-premise |
Nákladově efektivní strategie
Použijte GPT-4o-mini pro počáteční generování a opakování iterací (nízká cena, dobrá kvalita), a GPT-4o pouze pro případy, kdy mini selže po 2 pokusech. S tímto hybridním přístupem průměrné náklady klesnou na 30 % oproti výhradnímu použití GPT-4o při zachování srovnatelné kvality.
Skutečné limity a anti-vzorce
Upřímnost je při hodnocení této technologie zásadní. LLM nejsou neomylní generování pravidel detekce a znalost jejich omezení je stejně důležitá jako jejich využívání silné stránky.
Zdokumentovaná omezení LLM pro detekční inženýrství
-
Halucinace polí: Model může vymýšlet názvy polí, které neexistují
ve skutečných protokolech (např.
ProcessHashmístoHashesv Systemonu). - Přehnaná sestava: Vygenerovaná pravidla mohou být příliš konkrétní (na základě IOC) místo zachycování obecného chování.
- Nereálné falešné poplachy: "falsepositives" generované LLM jsou často obecné a nepředstavují skutečné případy ve specifickém kontextu organizace.
- Temné techniky: Pro vzácné nebo velmi nedávné (post-cutoff) techniky ATT&CK, kvalita výrazně klesá bez zvýšeného získávání.
- Nedostatek kontextu SIEM: Model nezná konkrétní normalizaci vašeho SIEM (např. jak Splunk normalizuje pole Windows ve srovnání s Elastic ECS).
RAG pro SIEM kontextově specifické
Retrieval Augmented Generation (RAG) umožňuje vložit kontext specifický pro organizaci do výzvy: normalizace polí SIEM, stávající pravidla, falešně pozitivní kalibrační data. Tento přístup výrazně snižuje chyby související s nedostatkem kontextu.
# RAG per generazione Sigma contestualizzata
from chromadb import Client
from chromadb.utils import embedding_functions
class RAGSigmaGenerator:
def __init__(self, chroma_persist_dir: str, openai_key: str):
self.chroma_client = Client()
self.embed_fn = embedding_functions.OpenAIEmbeddingFunction(
api_key=openai_key,
model_name="text-embedding-3-small"
)
# Collection di regole esistenti per few-shot contestuale
self.rules_collection = self.chroma_client.get_or_create_collection(
name="sigma_rules",
embedding_function=self.embed_fn
)
# Collection di field mappings SIEM-specifici
self.field_mappings_collection = self.chroma_client.get_or_create_collection(
name="siem_field_mappings",
embedding_function=self.embed_fn
)
def index_existing_rules(self, rules_dir: str) -> None:
"""Indicizza le regole esistenti per few-shot retrieval."""
for rule_file in Path(rules_dir).glob("**/*.yml"):
content = rule_file.read_text()
rule_dict = yaml.safe_load(content)
self.rules_collection.add(
documents=[content],
metadatas=[{
"title": rule_dict.get('title', ''),
"category": rule_dict.get('logsource', {}).get('category', ''),
"tags": str(rule_dict.get('tags', []))
}],
ids=[str(rule_file)]
)
def generate_with_rag(self, technique_id: str, report: ThreatReport) -> str:
"""Genera Sigma rule con contesto recuperato dal RAG."""
# Recupera regole simili come few-shot examples
similar_rules = self.rules_collection.query(
query_texts=[report.content[:500]],
n_results=3
)
# Recupera field mappings SIEM-specifici
field_mappings = self.field_mappings_collection.query(
query_texts=[f"process_creation windows {technique_id}"],
n_results=2
)
# Costruisce prompt arricchito con contesto RAG
context = "\n\n".join(similar_rules['documents'][0][:2])
mappings_context = "\n".join(field_mappings['documents'][0])
enhanced_prompt = f"""
Regole simili esistenti nel nostro repository (usa come ispirazione):
{context}
Field mappings specifici del nostro SIEM:
{mappings_context}
Ora genera una nuova regola per la tecnica {technique_id}
basandoti sul seguente report: {report.content[:2000]}
"""
# Continua con la generazione standard...
return enhanced_promptZávěry a další kroky
Technika detekce za pomoci umělé inteligence není trendem: je to provozní nutnost pro týmy, které to potřebují držet krok s rychlostí, s jakou se objevují nové útočné techniky. Kombinace LLM pro generování, přísné automatické ověřování a testování se syntetickými protokoly umožňuje zkrátit dobu do detekce nově publikované zprávy o hrozbě ze dnů na hodiny.
Klíčové věci
- LLM vytvářejí kvalitnější pravidla Sigma než přímé SPL dotazy díky struktuře YAML
- Pro kvalitu je zásadní rychlé inženýrství (strukturovaný systémový prompt, několik záběrů, řetěz myšlenek).
- Automatická syntaktická a sémantická validace není volitelné
- Testování se syntetickými protokoly generovanými AI uzavírá smyčku kvality
- Vygenerovaná pravidla musí projít lidskou kontrolou PR, nikoli automatickým sloučením
- Kontextově specifické RAG SIEM snižuje chyby v poli a falešné poplachy
- Místní modely (Llama, Mistral jemně vyladěné) jsou platnou alternativou pro rezidenci dat
Související články
- Pravidla Sigma: Univerzální detekční logika a SIEM konverze
- Detection-as-Code Pipeline s Git a CI/CD
- Testování pravidel detekce: Testování jednotek pro bezpečnostní logiku
- Inteligence hrozeb Požití: Procesor podávání STIX/TAXII