Construção de Biblioteca de Padrões de Ataque a partir de Relatórios de CTI
Visão Geral
Relatórios de inteligência de ameaças cibernéticas (CTI) de fornecedores como Mandiant, CrowdStrike, Talos e Microsoft contêm descrições detalhadas de comportamentos adversários que podem ser extraídos, normalizados e catalogados em uma biblioteca estruturada de padrões de ataque. Esta skill abrange a análise de relatórios de CTI para extrair técnicas adversárias, mapear comportamentos para IDs de técnicas MITRE ATT&CK, criar objetos Attack Pattern STIX 2.1, construir uma biblioteca pesquisável indexada por tática, técnica e ator de ameaças, e gerar modelos de regras de detecção a partir de padrões documentados.
Quando Usar
- Ao implantar ou configurar capacidades de construção de biblioteca de padrões de ataque a partir de relatórios de CTI em seu ambiente
- Ao estabelecer controles de segurança alinhados a requisitos de conformidade
- Ao construir ou melhorar a arquitetura de segurança para este domínio
- Ao conduzir avaliações de segurança que exigem esta implementação
Pré-requisitos
- Python 3.9+ com as bibliotecas
stix2,mitreattack-python,spacy,requests - Coleção de relatórios de CTI (formato PDF, HTML ou texto)
- Dados STIX do MITRE ATT&CK (local ou via TAXII)
- Compreensão da estrutura de técnicas ATT&CK e convenções de nomenclatura
- Familiaridade com conceitos de engenharia de detecção (Sigma, YARA)
Conceitos Chave
Extração de Padrões de Ataque
Relatórios de CTI descrevem comportamentos adversários em linguagem natural. A extração envolve identificar verbos de ação e termos técnicos que mapeiam para técnicas ATT&CK, reconhecer nomes de ferramentas e famílias de malwares, identificar indicadores de infraestrutura e mapear sequências de comportamentos para cadeias de ataque (fases da cadeia de matança).
Objetos Attack Pattern STIX 2.1
STIX define Attack Pattern como um Structured Domain Object (SDO) que descreve maneiras pelas quais atores de ameaças tentam comprometer alvos. Cada padrão se liga ao ATT&CK via referências externas, inclui fases da cadeia de matança (táticas) e pode ser relacionado a objetos Intrusion Set, Malware e Tool.
Geração de Regras de Detecção
Padrões de ataque extraídos informam a engenharia de detecção fornecendo: exemplos de procedimentos específicos para criação de regras Sigma, sequências comportamentais para regras de correlação, padrões de IOC para regras YARA e Snort, e requisitos de fontes de dados para lacunas de telemetria.
Fluxo de Trabalho
Passo 1: Analisar Relatórios de CTI e Extrair Comportamentos
import re
import json
from collections import defaultdict
class CTIReportParser:
"""Analisa relatórios de CTI para extrair comportamentos adversários."""
BEHAVIOR_INDICATORS = [
"used", "executed", "deployed", "leveraged", "exploited",
"established", "created", "modified", "downloaded", "uploaded",
"exfiltrated", "injected", "enumerated", "spawned", "dropped",
"persisted", "escalated", "moved laterally", "collected",
"encrypted", "compressed", "encoded", "obfuscated",
]
TOOL_PATTERNS = [
r'\b(Cobalt Strike|Mimikatz|PsExec|BloodHound|Rubeus|Impacket)\b',
r'\b(PowerShell|cmd\.exe|WMI|WMIC|certutil|bitsadmin)\b',
r'\b(Metasploit|Empire|Covenant|Sliver|Brute Ratel)\b',
r'\b(Lazagne|SharpHound|ADFind|Sharphound|Invoke-Obfuscation)\b',
]
TECHNIQUE_KEYWORDS = {
"spearphishing": "T1566",
"phishing attachment": "T1566.001",
"phishing link": "T1566.002",
"powershell": "T1059.001",
"command line": "T1059.003",
"scheduled task": "T1053.005",
"registry run key": "T1547.001",
"process injection": "T1055",
"dll side-loading": "T1574.002",
"credential dumping": "T1003",
"lsass": "T1003.001",
"kerberoasting": "T1558.003",
"pass the hash": "T1550.002",
"remote desktop": "T1021.001",
"smb": "T1021.002",
"winrm": "T1021.006",
"data staging": "T1074",
"exfiltration over c2": "T1041",
"dns tunneling": "T1071.004",
"web shell": "T1505.003",
}
def parse_report(self, text, report_metadata=None):
"""Analisa um relatório de CTI e extrai comportamentos."""
sentences = re.split(r'[.!?]\s+', text)
behaviors = []
for sentence in sentences:
sentence_lower = sentence.lower()
# Verifica indicadores de comportamento
for indicator in self.BEHAVIOR_INDICATORS:
if indicator in sentence_lower:
behavior = {
"sentence": sentence.strip(),
"action": indicator,
"tools": self._extract_tools(sentence),
"technique_hints": self._match_techniques(sentence_lower),
}
if behavior["technique_hints"]:
behaviors.append(behavior)
break
print(f"[+] Extraídos {len(behaviors)} indicadores comportamentais do relatório")
return behaviors
def _extract_tools(self, text):
"""Extrai nomes de ferramentas/malwares do texto."""
tools = set()
for pattern in self.TOOL_PATTERNS:
matches = re.findall(pattern, text, re.IGNORECASE)
tools.update(matches)
return list(tools)
def _match_techniques(self, text):
"""Combina texto com dicas de técnicas ATT&CK."""
matches = []
for keyword, tech_id in self.TECHNIQUE_KEYWORDS.items():
if keyword in text:
matches.append({"keyword": keyword, "technique_id": tech_id})
return matches
parser = CTIReportParser()
sample_report = """
The threat actor used spearphishing attachments with macro-enabled documents to
gain initial access. Once inside, they executed PowerShell scripts to download
additional tooling. The actor leveraged Mimikatz to dump credentials from LSASS
memory. They then used pass the hash techniques for lateral movement via SMB
to multiple systems. Data was staged in a compressed archive and exfiltrated
over the existing C2 channel. The actor established persistence through
scheduled tasks and registry run keys.
"""
behaviors = parser.parse_report(sample_report)
Passo 2: Mapear Comportamentos para Técnicas ATT&CK
from attackcti import attack_client
class ATTACKMapper:
def __init__(self):
self.lift = attack_client()
self.techniques = {}
self._load_techniques()
def _load_techniques(self):
"""Carrega todas as técnicas ATT&CK para mapeamento."""
all_techs = self.lift.get_enterprise_techniques()
for tech in all_techs:
tech_id = ""
for ref in tech.get("external_references", []):
if ref.get("source_name") == "mitre-attack":
tech_id = ref.get("external_id", "")
break
if tech_id:
self.techniques[tech_id] = {
"name": tech.get("name", ""),
"description": tech.get("description", "")[:500],
"tactics": [p.get("phase_name") for p in tech.get("kill_chain_phases", [])],
"platforms": tech.get("x_mitre_platforms", []),
"data_sources": tech.get("x_mitre_data_sources", []),
}
print(f"[+] Carregadas {len(self.techniques)} técnicas ATT&CK")
def map_behaviors(self, behaviors):
"""Mapeia comportamentos extraídos para técnicas ATT&CK."""
mapped = []
for behavior in behaviors:
for hint in behavior.get("technique_hints", []):
tech_id = hint["technique_id"]
if tech_id in self.techniques:
tech_info = self.techniques[tech_id]
mapped.append({
"technique_id": tech_id,
"technique_name": tech_info["name"],
"tactics": tech_info["tactics"],
"source_sentence": behavior["sentence"],
"tools_observed": behavior["tools"],
"keyword_matched": hint["keyword"],
"data_sources": tech_info["data_sources"],
})
print(f"[+] Mapeados {len(mapped)} comportamentos para técnicas ATT&CK")
return mapped
mapper = ATTACKMapper()
mapped_behaviors = mapper.map_behaviors(behaviors)
Passo 3: Criar Biblioteca de Padrões de Ataque STIX 2.1
from stix2 import AttackPattern, Relationship, Bundle, TLP_GREEN
from datetime import datetime
class AttackPatternLibrary:
def __init__(self):
self.patterns = []
self.relationships = []
def add_pattern_from_mapping(self, mapping, report_source="CTI Report"):
"""Cria um Attack Pattern STIX a partir de um mapeamento comportamental."""
pattern = AttackPattern(
name=mapping["technique_name"],
description=f"Observado: {mapping['source_sentence']}\n\n"
f"Ferramentas: {', '.join(mapping['tools_observed']) or 'Nenhuma identificada'}\n"
f"Fonte: {report_source}",
external_references=[{
"source_name": "mitre-attack",
"external_id": mapping["technique_id"],
"url": f"https://attack.mitre.org/techniques/{mapping['technique_id'].replace('.', '/')}/",
}],
kill_chain_phases=[{
"kill_chain_name": "mitre-attack",
"phase_name": tactic,
} for tactic in mapping["tactics"]],
object_marking_refs=[TLP_GREEN],
)
self.patterns.append(pattern)
return pattern
def build_library(self, mapped_behaviors, report_source="CTI Report"):
"""Constrói biblioteca completa de padrões de ataque a partir de mapeamentos."""
seen_techniques = set()
for mapping in mapped_behaviors:
tech_id = mapping["technique_id"]
if tech_id not in seen_techniques:
self.add_pattern_from_mapping(mapping, report_source)
seen_techniques.add(tech_id)
bundle = Bundle(objects=self.patterns + self.relationships)
print(f"[+] Biblioteca: {len(self.patterns)} padrões de ataque")
return bundle
def export_library(self, output_file="attack_pattern_library.json"):
bundle = Bundle(objects=self.patterns + self.relationships)
with open(output_file, "w") as f:
f.write(bundle.serialize(pretty=True))
print(f"[+] Biblioteca exportada para {output_file}")
def generate_detection_templates(self, mapped_behaviors):
"""Gera modelos de regras Sigma a partir de padrões de ataque."""
templates = []
for mapping in mapped_behaviors:
template = {
"title": f"Detecção: {mapping['technique_name']} ({mapping['technique_id']})",
"status": "experimental",
"description": f"Detecta {mapping['technique_name']} com base em observação de relatório CTI",
"references": [
f"https://attack.mitre.org/techniques/{mapping['technique_id'].replace('.', '/')}/",
],
"tags": [
f"attack.{mapping['tactics'][0]}" if mapping['tactics'] else "attack.unknown",
f"attack.{mapping['technique_id'].lower()}",
],
"data_sources": mapping.get("data_sources", []),
"observed_tools": mapping.get("tools_observed", []),
"source_context": mapping["source_sentence"],
}
templates.append(template)
with open("detection_templates.json", "w") as f:
json.dump(templates, f, indent=2)
print(f"[+] Gerados {len(templates)} modelos de detecção")
return templates
library = AttackPatternLibrary()
bundle = library.build_library(mapped_behaviors, "Relatório CTI de Exemplo")
library.export_library()
templates = library.generate_detection_templates(mapped_behaviors)
Critérios de Validação
- Relatório CTI analisado e indicadores comportamentais extraídos
- Comportamentos mapeados para técnicas ATT&CK com confiança
- Objetos Attack Pattern STIX 2.1 criados com referências adequadas
- Biblioteca pesquisável por tática, técnica e ator de ameaças
- Modelos de detecção gerados a partir de padrões documentados
- Biblioteca exportável como bundle STIX para compartilhamento