Análisis de TTPs de Actores de Amenaza con MITRE ATT&CK

¿Qué hace Análisis de TTPs de Actores de Amenaza con MITRE ATT&CK?

Resumen

MITRE ATT&CK es una base de conocimiento de acceso global sobre tácticas, técnicas y procedimientos (TTPs) de adversarios basada en observaciones del mundo real. Esta habilidad cubre el mapeo sistemático del comportamiento de actores de amenaza al marco ATT&CK, la construcción de mapas de calor de cobertura de técnicas con ATT&CK Navigator, la identificación de brechas de detección y la producción de informes de inteligencia procesables que vinculan los IOCs observados con técnicas específicas de adversarios en las matrices Enterprise, Mobile e ICS.

Cuándo usar

• Al investigar incidentes de seguridad que requieran analizar TTPs de actores de amenaza con MITRE ATT&CK
• Al construir reglas de detección o consultas de caza de amenazas para este dominio
• Cuando los analistas del SOC necesiten procedimientos estructurados para este tipo de análisis
• Al validar la cobertura de monitoreo de seguridad para técnicas de ataque relacionadas

Prerrequisitos

• Python 3.9+ con las librerías mitreattack-python, attackcti, stix2
• MITRE ATT&CK Navigator (implementación web o local)
• Comprensión de la estructura de la matriz ATT&CK: Tácticas, Técnicas, Sub-técnicas
• Acceso a informes de inteligencia de amenazas o a MISP/OpenCTI para datos de actores de amenaza
• Familiaridad con objetos STIX 2.1 Attack Pattern

Conceptos clave

Estructura de la matriz ATT&CK

La matriz Enterprise de ATT&CK organiza el comportamiento del adversario en 14 Tácticas (el "por qué") que contienen Técnicas (el "cómo") y Sub-técnicas (implementaciones específicas). Cada técnica tiene asociadas fuentes de datos, detecciones, mitigaciones y ejemplos de procedimientos del mundo real provenientes de grupos de amenaza observados.

Perfiles de grupos de amenaza

ATT&CK cataloga más de 140 grupos de amenaza (por ejemplo, APT28, APT29, Lazarus Group, FIN7) con uso documentado de técnicas. Cada perfil de grupo incluye alias, sectores objetivo, campañas asociadas, software utilizado y mapeos de técnicas con detalles a nivel de procedimiento.

ATT&CK Navigator

ATT&CK Navigator es una herramienta web para crear visualizaciones personalizadas de la matriz ATT&CK. Los analistas crean capas (archivos JSON) que anotan técnicas con puntuaciones, colores, comentarios y metadatos para visualizar la cobertura de actores de amenaza, las capacidades de detección o las evaluaciones de riesgo.

Flujo de trabajo

Paso 1: Consultar datos de ATT&CK de forma programática

from attackcti import attack_client
import json

# Inicializar el cliente ATT&CK (consulta al servidor TAXII de MITRE)
lift = attack_client()

# Obtener todas las técnicas de Enterprise
enterprise_techniques = lift.get_enterprise_techniques()
print(f"Total de técnicas Enterprise: {len(enterprise_techniques)}")

# Obtener todos los grupos de amenaza
groups = lift.get_groups()
print(f"Total de grupos de amenaza: {len(groups)}")

# Obtener un grupo específico por nombre
apt29 = [g for g in groups if 'APT29' in g.get('name', '')]
if apt29:
    group = apt29[0]
    print(f"Grupo: {group['name']}")
    print(f"Alias: {group.get('aliases', [])}")
    print(f"Descripción: {group.get('description', '')[:200]}")

Paso 2: Mapear actor de amenaza a técnicas ATT&CK

from attackcti import attack_client

lift = attack_client()

# Obtener técnicas utilizadas por APT29
apt29_techniques = lift.get_techniques_used_by_group("G0016")  # ID del grupo APT29

technique_map = {}
for entry in apt29_techniques:
    tech_id = entry.get("external_references", [{}])[0].get("external_id", "")
    tech_name = entry.get("name", "")
    description = entry.get("description", "")
    tactic_refs = [
        phase.get("phase_name", "")
        for phase in entry.get("kill_chain_phases", [])
    ]

    technique_map[tech_id] = {
        "name": tech_name,
        "tactics": tactic_refs,
        "description": description[:300],
    }

print(f"\nAPT29 utiliza {len(technique_map)} técnicas:")
for tid, info in sorted(technique_map.items()):
    print(f"  {tid}: {info['name']} [{', '.join(info['tactics'])}]")

Paso 3: Generar capa de ATT&CK Navigator

import json

def create_navigator_layer(group_name, technique_map, description=""):
    """Generar JSON de capa de ATT&CK Navigator para un grupo de amenaza."""
    techniques_list = []
    for tech_id, info in technique_map.items():
        techniques_list.append({
            "techniqueID": tech_id,
            "tactic": info["tactics"][0] if info["tactics"] else "",
            "color": "#ff6666",  # Rojo para técnicas observadas
            "comment": info["description"][:200],
            "enabled": True,
            "score": 100,
            "metadata": [
                {"name": "group", "value": group_name},
            ],
        })

    layer = {
        "name": f"{group_name} TTP Coverage",
        "versions": {
            "attack": "16.1",
            "navigator": "5.1.0",
            "layer": "4.5",
        },
        "domain": "enterprise-attack",
        "description": description or f"Técnicas atribuidas a {group_name}",
        "filters": {"platforms": ["Windows", "Linux", "macOS", "Cloud"]},
        "sorting": 0,
        "layout": {
            "layout": "side",
            "aggregateFunction": "average",
            "showID": True,
            "showName": True,
            "showAggregateScores": False,
            "countUnscored": False,
        },
        "hideDisabled": False,
        "techniques": techniques_list,
        "gradient": {
            "colors": ["#ffffff", "#ff6666"],
            "minValue": 0,
            "maxValue": 100,
        },
        "legendItems": [
            {"label": "Técnica observada", "color": "#ff6666"},
            {"label": "No observada", "color": "#ffffff"},
        ],
        "showTacticRowBackground": True,
        "tacticRowBackground": "#dddddd",
        "selectTechniquesAcrossTactics": True,
        "selectSubtechniquesWithParent": False,
        "selectVisibleTechniques": False,
    }

    return layer


# Generar y guardar la capa
layer = create_navigator_layer("APT29", technique_map, "Análisis de TTPs de APT29 (Cozy Bear)")
with open("apt29_navigator_layer.json", "w") as f:
    json.dump(layer, f, indent=2)
print("[+] Capa de Navigator guardada en apt29_navigator_layer.json")

Paso 4: Identificar brechas de detección

from attackcti import attack_client

lift = attack_client()

# Obtener todas las técnicas con fuentes de datos
all_techniques = lift.get_enterprise_techniques()

# Construir mapa de cobertura de fuentes de datos
data_source_coverage = {}
for tech in all_techniques:
    tech_id = tech.get("external_references", [{}])[0].get("external_id", "")
    data_sources = tech.get("x_mitre_data_sources", [])

    for ds in data_sources:
        if ds not in data_source_coverage:
            data_source_coverage[ds] = []
        data_source_coverage[ds].append(tech_id)

# Comparar técnicas del actor de amenaza con las detecciones disponibles
detected_techniques = {"T1059", "T1071", "T1566"}  # Ejemplo: técnicas que puedes detectar
actor_techniques = set(technique_map.keys())

covered = actor_techniques.intersection(detected_techniques)
gaps = actor_techniques - detected_techniques

print(f"\n=== Análisis de brechas de detección para APT29 ===")
print(f"Técnicas del actor: {len(actor_techniques)}")
print(f"Detectadas: {len(covered)} ({len(covered)/len(actor_techniques)*100:.0f}%)")
print(f"Brechas: {len(gaps)} ({len(gaps)/len(actor_techniques)*100:.0f}%)")
print(f"\nTécnicas no detectadas:")
for tech_id in sorted(gaps):
    if tech_id in technique_map:
        print(f"  {tech_id}: {technique_map[tech_id]['name']}")

Paso 5: Comparación de técnicas entre grupos

from attackcti import attack_client

lift = attack_client()

# Comparar técnicas entre varios grupos
groups_to_compare = {
    "G0016": "APT29",
    "G0007": "APT28",
    "G0032": "Lazarus Group",
}

group_techniques = {}
for gid, gname in groups_to_compare.items():
    techs = lift.get_techniques_used_by_group(gid)
    tech_ids = set()
    for t in techs:
        tid = t.get("external_references", [{}])[0].get("external_id", "")
        if tid:
            tech_ids.add(tid)
    group_techniques[gname] = tech_ids

# Encontrar técnicas comunes y únicas
all_groups = list(group_techniques.keys())
common_to_all = set.intersection(*group_techniques.values())
print(f"\nTécnicas comunes a todos los {len(all_groups)} grupos: {len(common_to_all)}")
for tid in sorted(common_to_all):
    print(f"  {tid}")

for gname, techs in group_techniques.items():
    unique = techs - set.union(*[t for n, t in group_techniques.items() if n != gname])
    print(f"\nÚnicas de {gname}: {len(unique)} técnicas")

Criterios de validación

• Datos de ATT&CK consultados exitosamente a través del servidor TAXII o copia local
• Actor de amenaza mapeado a técnicas específicas con ejemplos de procedimientos
• Archivo JSON de capa de ATT&CK Navigator válido y que se renderice correctamente
• Análisis de brechas de detección identifica técnicas no monitoreadas
• Comparación entre grupos revela TTPs compartidas y únicas
• El resultado es procesable para la priorización de ingeniería de detección

Referencias

• MITRE ATT&CK
• ATT&CK Navigator
• Librería Python attackcti
• Datos STIX de ATT&CK
• Grupos ATT&CK