analyse-des-ttp-d-acteurs-de-menace-avec-mitre-attack

Analyse des TTP d'Acteurs de Menace avec MITRE ATT&CK

Aperçu

MITRE ATT&CK est une base de connaissances accessible mondialement regroupant les tactiques, techniques et procédures (TTP) des adversaires basées sur des observations réelles. Cette compétence couvre la cartographie systématique du comportement des acteurs de menace vers le framework ATT&CK, la construction de cartes de chaleur de couverture technique à l'aide d'ATT&CK Navigator, l'identification des lacunes de détection et la production de rapports de renseignement exploitables qui lient les IOC observés à des techniques adverses spécifiques dans les matrices Enterprise, Mobile et ICS.

Quand l'Utiliser

• Lors d'enquêtes sur des incidents de sécurité nécessitant l'analyse des TTP d'acteurs de menace avec MITRE ATT&CK
• Lors de la construction de règles de détection ou de requêtes de chasse aux menaces pour ce domaine
• Lorsque les analystes SOC ont besoin de procédures structurées pour ce type d'analyse
• Lors de la validation de la couverture de surveillance de sécurité pour des techniques d'attaque connexes

Prérequis

• Python 3.9+ avec les bibliothèques mitreattack-python, attackcti, stix2
• MITRE ATT&CK Navigator (déploiement web ou local)
• Compréhension de la structure de la matrice ATT&CK : Tactiques, Techniques, Sous-techniques
• Accès à des rapports de renseignement sur les menaces ou à MISP/OpenCTI pour les données d'acteurs de menace
• Familiarité avec les objets STIX 2.1 Attack Pattern

Concepts Clés

Structure de la Matrice ATT&CK

La matrice ATT&CK Enterprise organise le comportement des adversaires en 14 Tactiques (le « pourquoi ») contenant des Techniques (le « comment ») et des Sous-techniques (implémentations spécifiques). Chaque technique est associée à des sources de données, détections, atténuations et exemples de procédures réelles provenant de groupes de menace observés.

Profils de Groupes de Menace

ATT&CK catalogue plus de 140 groupes de menace (ex. APT28, APT29, Lazarus Group, FIN7) avec une documentation d'utilisation des techniques. Chaque profil de groupe comprend des alias, les secteurs ciblés, les campagnes associées, les logiciels utilisés et les correspondances de techniques avec des détails au niveau des procédures.

ATT&CK Navigator

ATT&CK Navigator est un outil web permettant de créer des visualisations personnalisées de la matrice ATT&CK. Les analystes créent des calques (fichiers JSON) qui annotent les techniques avec des scores, couleurs, commentaires et métadonnées pour visualiser la couverture des acteurs de menace, les capacités de détection ou les évaluations de risque.

Flux de Travail

Étape 1 : Interroger les Données ATT&CK par Programmation

from attackcti import attack_client
import json

# Initialiser le client ATT&CK (interroge le serveur TAXII de MITRE)
lift = attack_client()

# Obtenir toutes les techniques Enterprise
enterprise_techniques = lift.get_enterprise_techniques()
print(f"Total des techniques Enterprise : {len(enterprise_techniques)}")

# Obtenir tous les groupes de menace
groups = lift.get_groups()
print(f"Total des groupes de menace : {len(groups)}")

# Obtenir un groupe spécifique par nom
apt29 = [g for g in groups if 'APT29' in g.get('name', '')]
if apt29:
    group = apt29[0]
    print(f"Groupe : {group['name']}")
    print(f"Alias : {group.get('aliases', [])}")
    print(f"Description : {group.get('description', '')[:200]}")

Étape 2 : Mapper un Acteur de Menace aux Techniques ATT&CK

from attackcti import attack_client

lift = attack_client()

# Obtenir les techniques utilisées par APT29
apt29_techniques = lift.get_techniques_used_by_group("G0016")  # ID du groupe 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 utilise {len(technique_map)} techniques :")
for tid, info in sorted(technique_map.items()):
    print(f"  {tid}: {info['name']} [{', '.join(info['tactics'])}]")

Étape 3 : Générer un Calque pour ATT&CK Navigator

import json

def create_navigator_layer(group_name, technique_map, description=""):
    """Générer un calque JSON pour ATT&CK Navigator d'un groupe de menace."""
    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",  # Rouge pour les techniques observées
            "comment": info["description"][:200],
            "enabled": True,
            "score": 100,
            "metadata": [
                {"name": "group", "value": group_name},
            ],
        })

    layer = {
        "name": f"Couverture TTP de {group_name}",
        "versions": {
            "attack": "16.1",
            "navigator": "5.1.0",
            "layer": "4.5",
        },
        "domain": "enterprise-attack",
        "description": description or f"Techniques attribuées à {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": "Technique observée", "color": "#ff6666"},
            {"label": "Non observée", "color": "#ffffff"},
        ],
        "showTacticRowBackground": True,
        "tacticRowBackground": "#dddddd",
        "selectTechniquesAcrossTactics": True,
        "selectSubtechniquesWithParent": False,
        "selectVisibleTechniques": False,
    }

    return layer


# Générer et sauvegarder le calque
layer = create_navigator_layer("APT29", technique_map, "Analyse des TTP d'APT29 (Cozy Bear)")
with open("apt29_navigator_layer.json", "w") as f:
    json.dump(layer, f, indent=2)
print("[+] Calque Navigator sauvegardé dans apt29_navigator_layer.json")

Étape 4 : Identifier les Lacunes de Détection

from attackcti import attack_client

lift = attack_client()

# Obtenir toutes les techniques avec leurs sources de données
all_techniques = lift.get_enterprise_techniques()

# Construire une carte de couverture des sources de données
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)

# Comparer les techniques de l'acteur avec les détections disponibles
detected_techniques = {"T1059", "T1071", "T1566"}  # Exemple : techniques détectables
actor_techniques = set(technique_map.keys())

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

print(f"\n=== Analyse des Lacunes de Détection pour APT29 ===")
print(f"Techniques de l'acteur : {len(actor_techniques)}")
print(f"Détectées : {len(covered)} ({len(covered)/len(actor_techniques)*100:.0f}%)")
print(f"Lacunes : {len(gaps)} ({len(gaps)/len(actor_techniques)*100:.0f}%)")
print(f"\nTechniques non détectées :")
for tech_id in sorted(gaps):
    if tech_id in technique_map:
        print(f"  {tech_id}: {technique_map[tech_id]['name']}")

Étape 5 : Comparaison Inter-Groupes des Techniques

from attackcti import attack_client

lift = attack_client()

# Comparer les techniques de plusieurs groupes
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

# Trouver les techniques communes et uniques
all_groups = list(group_techniques.keys())
common_to_all = set.intersection(*group_techniques.values())
print(f"\nTechniques communes à tous les {len(all_groups)} groupes : {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"\nUniques à {gname} : {len(unique)} techniques")

Critères de Validation

• Données ATT&CK interrogées avec succès via le serveur TAXII ou une copie locale
• Acteur de menace mappé à des techniques spécifiques avec des exemples de procédures
• Calque JSON ATT&CK Navigator valide et s'affiche correctement
• Analyse des lacunes de détection identifie les techniques non surveillées
• Comparaison inter-groupes révèle les TTP partagées et uniques
• Résultat exploitable pour la priorisation de l'ingénierie de détection

Références

• MITRE ATT&CK
• ATT&CK Navigator
• Bibliothèque Python attackcti
• Données STIX ATT&CK
• Groupes ATT&CK