Analyse von Bedrohungsakteur-TTPs mit MITRE ATT&CK

Was macht Analyse von Bedrohungsakteur-TTPs mit MITRE ATT&CK?

Überblick

MITRE ATT&CK ist eine weltweit zugängliche Wissensdatenbank über Taktiken, Techniken und Verfahren (TTPs) von Gegnern, die auf realen Beobachtungen basiert. Diese Fähigkeit umfasst die systematische Zuordnung des Verhaltens von Bedrohungsakteuren zum ATT&CK-Framework, die Erstellung von Heatmaps zur Technikabdeckung mit dem ATT&CK Navigator, die Identifizierung von Erkennungslücken und die Erstellung umsetzbarer Bedrohungsanalyseberichte, die beobachtete IOCs mit bestimmten Gegnertechniken in den Enterprise-, Mobile- und ICS-Matrizen verknüpfen.

Verwendung

• Bei der Untersuchung von Sicherheitsvorfällen, die eine Analyse der TTPs von Bedrohungsakteuren mit MITRE ATT&CK erfordern
• Bei der Erstellung von Erkennungsregeln oder Bedrohungsjagdabfragen für diesen Bereich
• Wenn SOC-Analysten strukturierte Verfahren für diesen Analysetyp benötigen
• Bei der Validierung der Sicherheitsüberwachungsabdeckung für verwandte Angriffstechniken

Voraussetzungen

• Python 3.9+ mit den Bibliotheken mitreattack-python, attackcti, stix2
• MITRE ATT&CK Navigator (webbasiert oder lokal bereitgestellt)
• Verständnis der ATT&CK-Matrixstruktur: Taktiken, Techniken, Sub-Techniken
• Zugriff auf Bedrohungsanalyseberichte oder MISP/OpenCTI für Bedrohungsakteurdaten
• Vertrautheit mit STIX 2.1 Attack Pattern-Objekten

Schlüsselkonzepte

ATT&CK-Matrixstruktur

Die ATT&CK Enterprise-Matrix organisiert das Verhalten von Gegnern in 14 Taktiken (das "Warum"), die Techniken (das "Wie") und Sub-Techniken (spezifische Implementierungen) enthalten. Jede Technik hat zugehörige Datenquellen, Erkennungen, Gegenmaßnahmen und reale Verfahrensbeispiele von beobachteten Bedrohungsgruppen.

Bedrohungsgruppenprofile

ATT&CK katalogisiert über 140 Bedrohungsgruppen (z.B. APT28, APT29, Lazarus Group, FIN7) mit dokumentierter Techniknutzung. Jedes Gruppenprofil enthält Aliase, anvisierte Sektoren, zugehörige Kampagnen, verwendete Software und Technikzuordnungen mit Details auf Verfahrensebene.

ATT&CK Navigator

Der ATT&CK Navigator ist ein webbasiertes Tool zum Erstellen benutzerdefinierter ATT&CK-Matrixvisualisierungen. Analysten erstellen Layer (JSON-Dateien), die Techniken mit Bewertungen, Farben, Kommentaren und Metadaten annotieren, um die Abdeckung von Bedrohungsakteuren, Erkennungsfähigkeiten oder Risikobewertungen zu visualisieren.

Arbeitsablauf

Schritt 1: ATT&CK-Daten programmatisch abfragen

from attackcti import attack_client
import json

# ATT&CK-Client initialisieren (fragt MITRE TAXII-Server ab)
lift = attack_client()

# Alle Enterprise-Techniken abrufen
enterprise_techniques = lift.get_enterprise_techniques()
print(f"Gesamtzahl Enterprise-Techniken: {len(enterprise_techniques)}")

# Alle Bedrohungsgruppen abrufen
groups = lift.get_groups()
print(f"Gesamtzahl Bedrohungsgruppen: {len(groups)}")

# Bestimmte Gruppe nach Namen abrufen
apt29 = [g for g in groups if 'APT29' in g.get('name', '')]
if apt29:
    group = apt29[0]
    print(f"Gruppe: {group['name']}")
    print(f"Aliase: {group.get('aliases', [])}")
    print(f"Beschreibung: {group.get('description', '')[:200]}")

Schritt 2: Bedrohungsakteur ATT&CK-Techniken zuordnen

from attackcti import attack_client

lift = attack_client()

# Von APT29 verwendete Techniken abrufen
apt29_techniques = lift.get_techniques_used_by_group("G0016")  # APT29 Gruppen-ID

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 verwendet {len(technique_map)} Techniken:")
for tid, info in sorted(technique_map.items()):
    print(f"  {tid}: {info['name']} [{', '.join(info['tactics'])}]")

Schritt 3: ATT&CK Navigator-Layer generieren

import json

def create_navigator_layer(group_name, technique_map, description=""):
    """ATT&CK Navigator Layer-JSON für eine Bedrohungsgruppe erstellen."""
    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",  # Rot für beobachtete Techniken
            "comment": info["description"][:200],
            "enabled": True,
            "score": 100,
            "metadata": [
                {"name": "group", "value": group_name},
            ],
        })

    layer = {
        "name": f"{group_name} TTP-Abdeckung",
        "versions": {
            "attack": "16.1",
            "navigator": "5.1.0",
            "layer": "4.5",
        },
        "domain": "enterprise-attack",
        "description": description or f"{group_name} zugeschriebene Techniken",
        "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": "Beobachtete Technik", "color": "#ff6666"},
            {"label": "Nicht beobachtet", "color": "#ffffff"},
        ],
        "showTacticRowBackground": True,
        "tacticRowBackground": "#dddddd",
        "selectTechniquesAcrossTactics": True,
        "selectSubtechniquesWithParent": False,
        "selectVisibleTechniques": False,
    }

    return layer


# Layer generieren und speichern
layer = create_navigator_layer("APT29", technique_map, "APT29 (Cozy Bear) TTP-Analyse")
with open("apt29_navigator_layer.json", "w") as f:
    json.dump(layer, f, indent=2)
print("[+] Navigator-Layer gespeichert unter apt29_navigator_layer.json")

Schritt 4: Erkennungslücken identifizieren

from attackcti import attack_client

lift = attack_client()

# Alle Techniken mit Datenquellen abrufen
all_techniques = lift.get_enterprise_techniques()

# Datenquellen-Abdeckungskarte erstellen
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)

# Techniken des Bedrohungsakteurs mit verfügbaren Erkennungen vergleichen
detected_techniques = {"T1059", "T1071", "T1566"}  # Beispiel: erkennbare Techniken
actor_techniques = set(technique_map.keys())

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

print(f"\n=== Erkennungslückenanalyse für APT29 ===")
print(f"Techniken des Akteurs: {len(actor_techniques)}")
print(f"Erkannt: {len(covered)} ({len(covered)/len(actor_techniques)*100:.0f}%)")
print(f"Lücken: {len(gaps)} ({len(gaps)/len(actor_techniques)*100:.0f}%)")
print(f"\nNicht erkannte Techniken:")
for tech_id in sorted(gaps):
    if tech_id in technique_map:
        print(f"  {tech_id}: {technique_map[tech_id]['name']}")

Schritt 5: Gruppenübergreifender Technikvergleich

from attackcti import attack_client

lift = attack_client()

# Techniken über mehrere Gruppen hinweg vergleichen
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

# Gemeinsame und einzigartige Techniken finden
all_groups = list(group_techniques.keys())
common_to_all = set.intersection(*group_techniques.values())
print(f"\nTechniken, die allen {len(all_groups)} Gruppen gemeinsam sind: {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"\nEinzigartig für {gname}: {len(unique)} Techniken")

Validierungskriterien

• ATT&CK-Daten erfolgreich über TAXII-Server oder lokale Kopie abgefragt
• Bedrohungsakteur mit spezifischen Techniken und Verfahrensbeispielen zugeordnet
• ATT&CK Navigator Layer-JSON ist gültig und wird korrekt gerendert
• Erkennungslückenanalyse identifiziert nicht überwachte Techniken
• Gruppenübergreifender Vergleich zeigt gemeinsame und einzigartige TTPs
• Ausgabe ist für die Priorisierung der Erkennungsentwicklung umsetzbar

Referenzen

• MITRE ATT&CK
• ATT&CK Navigator
• attackcti Python-Bibliothek
• ATT&CK STIX-Daten
• ATT&CK-Gruppen