Construyendo una Biblioteca de Patrones de Ataque a partir de Informes CTI
Resumen
Los informes de inteligencia de amenazas cibernéticas (CTI) de proveedores como Mandiant, CrowdStrike, Talos y Microsoft contienen descripciones detalladas de los comportamientos de los adversarios que pueden ser extraídos, normalizados y catalogados en una biblioteca estructurada de patrones de ataque. Esta habilidad cubre el análisis de informes CTI para extraer técnicas de adversarios, el mapeo de comportamientos a IDs de técnicas de MITRE ATT&CK, la creación de objetos STIX 2.1 Attack Pattern, la construcción de una biblioteca indexable por táctica, técnica y actor de amenaza, y la generación de plantillas de reglas de detección a partir de patrones documentados.
Cuándo Usarlo
- Al implementar o configurar capacidades de construcción de bibliotecas de patrones de ataque a partir de informes CTI en su entorno
- Al establecer controles de seguridad alineados con requisitos de cumplimiento
- Al construir o mejorar la arquitectura de seguridad para este dominio
- Al realizar evaluaciones de seguridad que requieran esta implementación
Prerrequisitos
- Python 3.9+ con las librerías
stix2,mitreattack-python,spacy,requests - Colección de informes CTI (formato PDF, HTML o texto)
- Datos STIX de MITRE ATT&CK (local o a través de TAXII)
- Comprensión de la estructura de técnicas ATT&CK y convenciones de nomenclatura
- Familiaridad con conceptos de ingeniería de detección (Sigma, YARA)
Conceptos Clave
Extracción de Patrones de Ataque
Los informes CTI describen comportamientos de adversarios en lenguaje natural. La extracción implica identificar verbos de acción y términos técnicos que se asignan a técnicas ATT&CK, reconocer nombres de herramientas y familias de malware, identificar indicadores de infraestructura y mapear secuencias de comportamientos a cadenas de ataque (fases de la cadena de eliminación).
Objetos STIX 2.1 Attack Pattern
STIX define Attack Pattern como un Objeto de Dominio Estructurado (SDO) que describe las formas en que los adversarios intentan comprometer objetivos. Cada patrón se vincula a ATT&CK a través de referencias externas, incluye fases de la cadena de eliminación (tácticas) y puede relacionarse con objetos Intrusion Set, Malware y Tool.
Generación de Reglas de Detección
Los patrones de ataque extraídos informan la ingeniería de detección al proporcionar: ejemplos de procedimientos específicos para la creación de reglas Sigma, secuencias de comportamiento para reglas de correlación, patrones de IOC para reglas YARA y Snort, y requisitos de fuentes de datos para brechas de telemetría.
Flujo de Trabajo
Paso 1: Analizar Informes CTI y Extraer Comportamientos
import re
import json
from collections import defaultdict
class CTIReportParser:
"""Parse CTI reports to extract adversary behaviors."""
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):
"""Parse a CTI report and extract behaviors."""
sentences = re.split(r'[.!?]\s+', text)
behaviors = []
for sentence in sentences:
sentence_lower = sentence.lower()
# Check for behavior indicators
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 de comportamiento del informe")
return behaviors
def _extract_tools(self, text):
"""Extract tool/malware names from text."""
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):
"""Match text to ATT&CK technique hints."""
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)
Paso 2: Mapear Comportamientos a 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):
"""Load all ATT&CK techniques for mapping."""
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"[+] Cargadas {len(self.techniques)} técnicas ATT&CK")
def map_behaviors(self, behaviors):
"""Map extracted behaviors to ATT&CK techniques."""
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)} comportamientos a técnicas ATT&CK")
return mapped
mapper = ATTACKMapper()
mapped_behaviors = mapper.map_behaviors(behaviors)
Paso 3: Crear Biblioteca de Patrones 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"):
"""Create STIX Attack Pattern from mapped behavior."""
pattern = AttackPattern(
name=mapping["technique_name"],
description=f"Observado: {mapping['source_sentence']}\n\n"
f"Herramientas: {', '.join(mapping['tools_observed']) or 'Ninguna identificada'}\n"
f"Fuente: {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"):
"""Build complete attack pattern library from mappings."""
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)} patrones 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 a {output_file}")
def generate_detection_templates(self, mapped_behaviors):
"""Generate Sigma rule templates from attack patterns."""
templates = []
for mapping in mapped_behaviors:
template = {
"title": f"Detección: {mapping['technique_name']} ({mapping['technique_id']})",
"status": "experimental",
"description": f"Detecta {mapping['technique_name']} basado en observación de informe 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"[+] Generadas {len(templates)} plantillas de detección")
return templates
library = AttackPatternLibrary()
bundle = library.build_library(mapped_behaviors, "Informe CTI de Muestra")
library.export_library()
templates = library.generate_detection_templates(mapped_behaviors)
Criterios de Validación
- Informe CTI analizado e indicadores de comportamiento extraídos
- Comportamientos mapeados a técnicas ATT&CK con confianza
- Objetos STIX 2.1 Attack Pattern creados con referencias adecuadas
- Biblioteca indexable por táctica, técnica y actor de amenaza
- Plantillas de detección generadas a partir de patrones documentados
- Biblioteca exportable como bundle STIX para compartir