Red team / Blue team et CTF mindset

Cadre légal et éthique

Les techniques offensives décrites dans ce chapitre sont présentées dans un cadre pédagogique strict. Toute simulation d’adversaire en dehors d’un environnement de test ou sans autorisation écrite est illégale. Les exercices Red team / Blue team sont réalisés avec le consentement et souvent la participation active de la direction de sécurité de l’organisation cible. Ce chapitre vise à comprendre les TTPs (Tactiques, Techniques et Procédures) pour améliorer les capacités défensives.

L’approche Red team / Blue team simule des scénarios d’attaque réalistes pour évaluer la posture de sécurité d’une organisation de manière holistique — en testant non seulement les contrôles techniques, mais aussi les processus de détection, de réponse à incident, et la réactivité humaine des équipes de sécurité.

Show code cell source

Hide code cell source

import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
import matplotlib.dates as mdates
import numpy as np
import pandas as pd
import seaborn as sns
import re
from datetime import datetime, timedelta

Red team, Blue team, Purple team

Rôles et objectifs

Équipe	Rôle	Objectif principal	Livrables
Red team	Attaquant simulé	Compromettre des objectifs définis sans être détecté	Rapport d’attaque, preuves de compromission, TTPs utilisées
Blue team	Défenseur	Détecter, contenir et éradiquer les activités malveillantes	Timeline de détection, lacunes identifiées, améliorations
Purple team	Facilitateur	Maximiser le transfert de connaissances entre Red et Blue	Matrice de couverture ATT&CK, plan d’amélioration priorisé

Timeline d’un exercice Red team

Un exercice Red team complet s’étale typiquement sur 4 à 12 semaines selon la complexité :

• Semaine 1–2 : pré-engagement (périmètre, objectifs, règles), reconnaissance

• Semaine 3–4 : accès initial et établissement de la persistance

• Semaine 5–8 : mouvement latéral, escalade de privilèges, pivoting

• Semaine 9–10 : atteinte des objectifs définis (crown jewels)

• Semaine 11–12 : débrief, rapport, session Purple team

Différence avec le pentest classique

Un pentest classique cible l’exhaustivité des vulnérabilités dans un périmètre défini. Un exercice Red team est objectif-centrique : l’équipe peut ignorer des vulnérabilités si elles ne servent pas l’objectif, et simule délibérément les TTPs d’un adversaire spécifique (APT, groupe cybercriminel) pour tester la détection.

CTF — Capture The Flag

Les compétitions CTF sont des défis de sécurité structurés en catégories, permettant aux praticiens de développer des compétences offensives dans un cadre légal et ludique.

Catégories principales

Web : exploitation d’applications web (injections, IDOR, logique métier, SSTI). Souvent la catégorie la plus accessible.

Cryptographie : attaques sur des implémentations cryptographiques défectueuses — padding oracle, RSA faible (e petit, common modulus), ECB penguin, timing attacks.

Pwn / Binary exploitation : exploitation de binaires natifs — buffer overflow, format string, heap exploitation (use-after-free, double-free), ROP chains.

Forensics : analyse de captures réseau (pcap), images disque, dumps mémoire, stéganographie, récupération de données.

Reverse engineering : décompilation de binaires, analyse de malware, cracking de protection logicielle.

Misc : défis inclassables — OSINT, stégano, jails (Python/bash escape), quiz culturel sécurité.

Plateformes

Plateforme	Type	Public cible
HackTheBox	Labs + CTF	Intermédiaire à expert
TryHackMe	Apprentissage guidé	Débutant à intermédiaire
PicoCTF	CTF annuel	Étudiants, débutants
Root-Me	Challenges permanents	Tous niveaux, forte communauté FR
CTFtime	Agrégateur	Calendrier des CTF mondiaux

Kill chain et MITRE ATT&CK

Lockheed Martin Cyber Kill Chain

La kill chain modélise les 7 phases d’une attaque ciblée :

1. Reconnaissance : collecte d’informations sur la cible (OSINT, scan)

2. Weaponization : création de l’arme (exploit + payload = weaponized dropper)

3. Delivery : vecteur de livraison (phishing, watering hole, USB, supply chain)

4. Exploitation : déclenchement de l’exploit sur la cible

5. Installation : persistance (backdoor, RAT, webshell)

6. Command & Control (C2) : canal de communication avec l’attaquant

7. Actions on Objectives : exfiltration, sabotage, ransomware, pivoting

MITRE ATT&CK

MITRE ATT&CK est une base de connaissances des TTPs observées dans des attaques réelles, organisée en 14 tactiques et plus de 400 techniques/sous-techniques.

Les 14 tactiques couvrent l’intégralité du cycle de vie d’une attaque :

TA0043 Reconnaissance → TA0042 Resource Development → TA0001 Initial Access
→ TA0002 Execution → TA0003 Persistence → TA0004 Privilege Escalation
→ TA0005 Defense Evasion → TA0006 Credential Access → TA0007 Discovery
→ TA0008 Lateral Movement → TA0009 Collection → TA0011 C2
→ TA0010 Exfiltration → TA0040 Impact

Techniques Red team (conceptuelles)

Persistance

Les techniques de persistance permettent à l’attaquant de maintenir l’accès après un redémarrage ou une déconnexion.

Cron jobs (Linux) : ajout d’une entrée dans /etc/cron.d/ ou crontab -e pour exécuter périodiquement un reverse shell. ATT&CK : T1053.003.

Startup scripts : modification de ~/.bashrc, ~/.profile, /etc/rc.local. ATT&CK : T1546.004.

Scheduled tasks (Windows) : création via schtasks /create ou WMI event subscription. ATT&CK : T1053.005.

Registry Run Keys : HKCU\Software\Microsoft\Windows\CurrentVersion\Run. ATT&CK : T1547.001.

Mouvement latéral

Pass-the-Hash (PtH) : réutilisation du hash NTLM d’un utilisateur sans connaître le mot de passe en clair. Exploite le protocole NTLM qui accepte le hash directement comme preuve d’identité. ATT&CK : T1550.002.

Pass-the-Ticket (PtT) : vol et réutilisation d’un ticket Kerberos (TGT ou TGS) extrait de la mémoire LSASS. ATT&CK : T1550.003.

Remote execution : WMI (wmic), WinRM (Enter-PSSession), PsExec, SMB exec. ATT&CK : T1021.

Élévation de privilèges (Linux)

Binaires SUID : un binaire avec le bit SUID exécute avec les privilèges de son propriétaire (root). Si un tel binaire est exploitable (ex. find, vim, python3 avec SUID), il permet d’obtenir un shell root.

Sudo misconfiguration : sudo -l liste les commandes exécutables sans mot de passe. Une entrée (ALL) NOPASSWD: /usr/bin/python3 permet d’exécuter du code Python en tant que root.

Kernel exploits : exploitation de vulnérabilités du noyau Linux (Dirty COW, Dirty Pipe, PwnKit) pour une élévation locale de privilèges.

Blue team — Détection des TTPs

IoC et IoA

Indicators of Compromise (IoC) : artefacts observables indiquant qu’une compromission a eu lieu — hash de fichier malveillant, adresse IP C2, nom de domaine, clé de registre modifiée.

Indicators of Attack (IoA) : comportements observés en temps réel indiquant une attaque en cours — processus injectant dans d’autres processus, connexions réseau inhabituelles, escalade de privilèges, exécution de commandes encodées base64.

Les IoA sont plus robustes que les IoC : un attaquant peut changer un hash ou une IP, mais difficilement son comportement fondamental.

Corrélation et détection

La détection efficace des TTPs ATT&CK repose sur l’agrégation de sources de logs : EDR (Endpoint Detection & Response), SIEM, pare-feu, DNS, authentification. Chaque technique ATT&CK peut être mappée à des sources de données spécifiques.

YARA

YARA est un langage de règles permettant de décrire des patterns (chaînes de caractères, expressions régulières, conditions binaires) pour classifier des fichiers suspects ou de la mémoire.

Syntaxe YARA — Exemples (non exécutables)

Ces règles YARA sont données à titre illustratif. Elles ne doivent être utilisées que dans le contexte d’une analyse de sécurité autorisée.

rule DetectMimikatz {
    meta:
        author = "Exemple pédagogique"
        description = "Détection de chaînes Mimikatz dans un binaire"
    strings:
        $s1 = "sekurlsa::logonpasswords" ascii wide
        $s2 = "lsadump::dcsync" ascii wide
        $s3 = "privilege::debug" ascii wide
        $hex1 = { 4D 69 6D 69 6B 61 74 7A }  // "Mimikatz" en hex
    condition:
        2 of ($s*) or $hex1
}

rule SuspiciousPowerShell {
    meta:
        description = "Commandes PowerShell suspectes encodées"
    strings:
        $enc  = "-EncodedCommand" nocase
        $b64  = /[A-Za-z0-9+\/]{50,}={0,2}/
        $iex  = "Invoke-Expression" nocase
        $dl   = "DownloadString" nocase
    condition:
        $enc or ($b64 and ($iex or $dl))
}

```{code-cell} python
# Moteur YARA simplifié en Python
# Évaluation de règles sur des chaînes de bytes synthétiques

import re
from dataclasses import dataclass, field
from typing import List, Callable

@dataclass
class RegleYara:
    """Représentation simplifiée d'une règle YARA."""
    nom: str
    description: str
    strings: dict  # {nom: pattern_str ou bytes}
    condition: Callable  # fonction qui prend un dict {nom: liste_de_matchs}

def evaluer_regle(regle: RegleYara, donnees: bytes) -> dict:
    """Évalue une règle YARA sur des données binaires."""
    matchs = {}
    for nom_str, pattern in regle.strings.items():
        if isinstance(pattern, bytes):
            occurrences = [m.start() for m in re.finditer(re.escape(pattern), donnees)]
        else:
            occurrences = [m.start() for m in re.finditer(pattern.encode("latin-1", errors="ignore"),
                                                           donnees, re.IGNORECASE)]
        matchs[nom_str] = occurrences

    declenche = regle.condition(matchs)
    return {
        "regle": regle.nom,
        "description": regle.description,
        "declenche": declenche,
        "matchs": {k: v for k, v in matchs.items() if v},
    }

# Définition des règles
regles = [
    RegleYara(
        nom="DetectMimikatz",
        description="Détection de chaînes Mimikatz dans un binaire",
        strings={
            "$s1": "sekurlsa::logonpasswords",
            "$s2": "lsadump::dcsync",
            "$s3": "privilege::debug",
            "$hex_mimikatz": b"Mimikatz",
        },
        condition=lambda m: (
            sum(1 for k in ["$s1", "$s2", "$s3"] if m.get(k)) >= 2
            or bool(m.get("$hex_mimikatz"))
        ),
    ),
    RegleYara(
        nom="SuspiciousPowerShell",
        description="Commandes PowerShell avec encodage base64 suspect",
        strings={
            "$enc":  "-EncodedCommand",
            "$iex":  "Invoke-Expression",
            "$down": "DownloadString",
        },
        condition=lambda m: bool(m.get("$enc")) or (
            bool(m.get("$iex")) and bool(m.get("$down"))
        ),
    ),
    RegleYara(
        nom="WebShellPHP",
        description="Webshell PHP avec eval + base64",
        strings={
            "$eval":   "eval(",
            "$b64dec": "base64_decode",
            "$system": "system(",
            "$exec":   "exec(",
        },
        condition=lambda m: bool(m.get("$eval")) and bool(m.get("$b64dec")),
    ),
]

# Échantillons synthétiques à analyser
echantillons = [
    {
        "nom": "binaire_propre.exe",
        "donnees": b"MZ\x90\x00\x03\x00\x00\x00 normal application binary data hello world",
    },
    {
        "nom": "mimikatz_suspect.exe",
        "donnees": b"MZ binary... sekurlsa::logonpasswords ... lsadump::dcsync ... credential dumping",
    },
    {
        "nom": "ps_encode.ps1",
        "donnees": b"powershell -EncodedCommand JABjAG0AZAA... network payload",
    },
    {
        "nom": "shell.php",
        "donnees": b"<?php eval(base64_decode('cGFzc3dvcmQ=')); ?> webshell content",
    },
    {
        "nom": "mimikatz_full.exe",
        "donnees": b"Mimikatz utility sekurlsa::logonpasswords lsadump::dcsync privilege::debug dump",
    },
    {
        "nom": "script_admin.ps1",
        "donnees": b"Invoke-Expression (New-Object Net.WebClient).DownloadString('http://internal/script.ps1')",
    },
]

print("=" * 65)
print("     MOTEUR YARA SIMPLIFIÉ — RÉSULTATS D'ANALYSE")
print("=" * 65)

resultats_globaux = []

for echantillon in echantillons:
    print(f"\n[FICHIER] {echantillon['nom']}")
    alertes = []
    for regle in regles:
        res = evaluer_regle(regle, echantillon["donnees"])
        if res["declenche"]:
            print(f"  [ALERTE] Règle déclenchée : {res['regle']}")
            print(f"           Description : {res['description']}")
            matchs_affiches = {k: len(v) for k, v in res["matchs"].items()}
            print(f"           Matchs : {matchs_affiches}")
            alertes.append(res["regle"])
        resultats_globaux.append({
            "fichier": echantillon["nom"],
            "regle": res["regle"],
            "alerte": res["declenche"],
        })
    if not alertes:
        print("  [OK] Aucune règle déclenchée")

# Visualisation
df_res = pd.DataFrame(resultats_globaux)
pivot = df_res.pivot(index="fichier", columns="regle", values="alerte").astype(int)

sns.set_theme(style="whitegrid", palette="muted", font_scale=1.0)
fig, ax = plt.subplots(figsize=(10, 5))
sns.heatmap(
    pivot,
    annot=True,
    fmt="d",
    cmap="RdYlGn",
    linewidths=0.5,
    ax=ax,
    vmin=0, vmax=1,
    cbar_kws={"label": "0 = propre / 1 = alerte"},
)
ax.set_title("Moteur YARA simplifié — Matrice fichiers × règles", fontsize=12, pad=10)
ax.set_xlabel("Règle YARA")
ax.set_ylabel("Fichier analysé")
plt.show()

print(f"\nTotal alertes : {df_res['alerte'].sum()} / {len(df_res)} évaluations")

Atomic Red Team

Atomic Red Team (Red Canary) est une bibliothèque de tests atomiques mappés aux techniques MITRE ATT&CK. Chaque test est auto-contenu et reproductible, permettant aux équipes Blue de valider leur couverture de détection.

Commandes Atomic Red Team (non exécutables — environnement Windows/Linux requis)

Ces commandes illustrent la structure des tests Atomic Red Team. Elles ne doivent être exécutées que sur des systèmes de test isolés, avec autorisation.

# Installation
Install-Module -Name invoke-atomicredteam
Import-Module invoke-atomicredteam

# Lister les tests disponibles pour T1003 (OS Credential Dumping)
Invoke-AtomicTest T1003 -ShowDetailsBrief

# Exécuter un test spécifique
Invoke-AtomicTest T1053.003 -TestNumbers 1  # Cron persistence

# Vérifier les prérequis sans exécuter
Invoke-AtomicTest T1059.001 -CheckPrereqs

# Nettoyage après test
Invoke-AtomicTest T1053.003 -TestNumbers 1 -Cleanup

```{code-cell} python
# Simulation de campagne d'attaque avec kill chain
# Visualisation Gantt colorée par tactique MITRE ATT&CK

TACTIQUES_COULEURS = {
    "Reconnaissance":          "#3498db",
    "Initial Access":          "#e74c3c",
    "Execution":               "#e67e22",
    "Persistence":             "#9b59b6",
    "Privilege Escalation":    "#c0392b",
    "Defense Evasion":         "#1abc9c",
    "Credential Access":       "#f39c12",
    "Discovery":               "#2ecc71",
    "Lateral Movement":        "#d35400",
    "Collection":              "#8e44ad",
    "Command & Control":       "#2980b9",
    "Exfiltration":            "#27ae60",
}

campagne = [
    # (tactique, technique, t_debut_jours, duree_jours)
    ("Reconnaissance",       "T1595 - Scan actif Nmap",            0,  1),
    ("Reconnaissance",       "T1589 - OSINT LinkedIn/crt.sh",      0,  2),
    ("Initial Access",       "T1566 - Spear phishing (PDF)",        2,  1),
    ("Execution",            "T1059 - PowerShell obfusqué",         3,  1),
    ("Persistence",          "T1053 - Scheduled task",              3,  2),
    ("Defense Evasion",      "T1027 - Obfuscation binaire",         4,  2),
    ("Credential Access",    "T1003 - LSASS dump (Mimikatz)",       5,  1),
    ("Discovery",            "T1018 - Remote system discovery",     5,  2),
    ("Privilege Escalation", "T1068 - Kernel exploit",              6,  1),
    ("Lateral Movement",     "T1550 - Pass-the-Hash",               7,  2),
    ("Lateral Movement",     "T1021 - WMI remote exec",             8,  1),
    ("Collection",           "T1005 - Local data staged",           9,  2),
    ("Command & Control",    "T1071 - C2 via HTTPS",                4, 10),
    ("Exfiltration",         "T1048 - Exfil DNS tunelling",        11,  2),
]

date_debut = datetime(2024, 3, 1)

sns.set_theme(style="whitegrid", palette="muted", font_scale=1.0)
fig, ax = plt.subplots(figsize=(14, 8))

noms_activites = [t[1] for t in campagne]
y_positions    = range(len(campagne))

for i, (tactique, technique, t_debut, duree) in enumerate(campagne):
    couleur = TACTIQUES_COULEURS.get(tactique, "#7f8c8d")
    debut_dt = date_debut + timedelta(days=t_debut)
    fin_dt   = debut_dt + timedelta(days=duree)
    ax.barh(i, (fin_dt - debut_dt).days, left=mdates.date2num(debut_dt),
            height=0.6, color=couleur, alpha=0.85, edgecolor="white", linewidth=0.8)
    ax.text(mdates.date2num(debut_dt) + (fin_dt - debut_dt).days / 2,
            i, f"J{t_debut}", ha="center", va="center", fontsize=7, color="white", fontweight="bold")

ax.set_yticks(list(y_positions))
ax.set_yticklabels(noms_activites, fontsize=8)
ax.xaxis_date()
ax.xaxis.set_major_formatter(mdates.DateFormatter("%d %b"))
ax.xaxis.set_major_locator(mdates.DayLocator(interval=2))
plt.setp(ax.get_xticklabels(), rotation=30, ha="right")
ax.set_xlabel("Date (simulation)")
ax.set_title("Campagne Red team simulée — Kill chain ATT&CK (Gantt)", fontsize=13, pad=12)
ax.invert_yaxis()

# Légende tactiques
patches_legende = [
    mpatches.Patch(color=c, label=t)
    for t, c in TACTIQUES_COULEURS.items()
    if t in {tact for tact, _, _, _ in campagne}
]
ax.legend(handles=patches_legende, loc="lower right", fontsize=8,
          title="Tactique ATT&CK", title_fontsize=9,
          bbox_to_anchor=(1.0, 0.0), ncol=1)

plt.show()

# Heatmap couverture de détection Red/Blue par tactique MITRE ATT&CK

tactiques_mitre = [
    "Reconnaissance",
    "Resource Development",
    "Initial Access",
    "Execution",
    "Persistence",
    "Privilege Escalation",
    "Defense Evasion",
    "Credential Access",
    "Discovery",
    "Lateral Movement",
    "Collection",
    "Command & Control",
    "Exfiltration",
    "Impact",
]

sources_detection = [
    "EDR / Endpoint",
    "SIEM / Logs",
    "Réseau / NDR",
    "IAM / AuthLogs",
    "DNS / Proxy",
]

# 0=Aucune, 1=Faible, 2=Moyenne, 3=Haute
# Matrice réaliste représentant une organisation avec EDR déployé mais NDR partiel
couverture = np.array([
    # EDR  SIEM  Net   IAM   DNS
    [0,    1,    1,    0,    2],   # Reconnaissance
    [0,    0,    0,    0,    0],   # Resource Development
    [2,    2,    2,    3,    1],   # Initial Access
    [3,    3,    1,    1,    0],   # Execution
    [3,    3,    0,    1,    0],   # Persistence
    [3,    2,    0,    2,    0],   # Privilege Escalation
    [2,    2,    1,    0,    0],   # Defense Evasion
    [3,    3,    0,    3,    0],   # Credential Access
    [2,    2,    1,    1,    1],   # Discovery
    [2,    2,    2,    2,    1],   # Lateral Movement
    [2,    2,    1,    0,    2],   # Collection
    [1,    1,    2,    0,    3],   # Command & Control
    [1,    1,    2,    0,    3],   # Exfiltration
    [3,    3,    1,    1,    0],   # Impact
])

labels_couverture = {0: "Aucune", 1: "Faible", 2: "Moyenne", 3: "Haute"}
cmap_couv = plt.cm.get_cmap("RdYlGn", 4)

sns.set_theme(style="whitegrid", palette="muted", font_scale=1.0)
fig, ax = plt.subplots(figsize=(10, 9))
im = sns.heatmap(
    couverture,
    xticklabels=sources_detection,
    yticklabels=tactiques_mitre,
    cmap="RdYlGn",
    vmin=0, vmax=3,
    annot=True,
    fmt="d",
    linewidths=0.5,
    ax=ax,
    cbar_kws={"ticks": [0, 1, 2, 3], "label": "Niveau de couverture"},
)

cbar = ax.collections[0].colorbar
cbar.set_ticklabels(["Aucune", "Faible", "Moyenne", "Haute"])

ax.set_title("Couverture de détection Blue team\npar tactique MITRE ATT&CK × source de log", fontsize=12, pad=12)
ax.set_xlabel("Source de détection")
ax.set_ylabel("Tactique MITRE ATT&CK")

# Annotation du score global par tactique
for i, row in enumerate(couverture):
    score_row = np.mean(row)
    ax.text(len(sources_detection) + 0.15, i + 0.5,
            f"{score_row:.1f}", va="center", fontsize=8, color="#555555")

plt.show()

# Résumé des lacunes de détection
print("\nTactiques avec couverture insuffisante (moyenne < 1.5) :")
for i, tact in enumerate(tactiques_mitre):
    moy = np.mean(couverture[i])
    if moy < 1.5:
        print(f"  - {tact:<30} (score moyen : {moy:.1f}/3.0)")

/tmp/ipykernel_19723/2135721730.py:49: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed in 3.11. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap()`` or ``pyplot.get_cmap()`` instead.
  cmap_couv = plt.cm.get_cmap("RdYlGn", 4)

Tactiques avec couverture insuffisante (moyenne < 1.5) :
  - Reconnaissance                 (score moyen : 0.8/3.0)
  - Resource Development           (score moyen : 0.0/3.0)
  - Persistence                    (score moyen : 1.4/3.0)
  - Privilege Escalation           (score moyen : 1.4/3.0)
  - Defense Evasion                (score moyen : 1.0/3.0)
  - Discovery                      (score moyen : 1.4/3.0)
  - Collection                     (score moyen : 1.4/3.0)
  - Command & Control              (score moyen : 1.4/3.0)
  - Exfiltration                   (score moyen : 1.4/3.0)

Résumé

1. Red / Blue / Purple team : le Red team simule des adversaires réalistes avec des objectifs définis ; le Blue team assure la détection et la réponse ; le Purple team maximise le transfert de connaissances entre les deux pour améliorer la couverture de détection.

2. CTF : les compétitions Capture The Flag (HackTheBox, TryHackMe, Root-Me, PicoCTF) offrent un cadre légal et structuré pour développer des compétences offensives à travers six catégories principales (web, crypto, pwn, forensics, reverse, misc).

3. Kill chain et ATT&CK : la kill chain de Lockheed Martin décrit les 7 phases d’une attaque ciblée ; MITRE ATT&CK les enrichit avec plus de 400 techniques/sous-techniques documentées depuis des attaques réelles et mappées à des sources de détection.

4. Techniques Red team : la persistance (cron, tâches planifiées), le mouvement latéral (pass-the-hash, pass-the-ticket) et l’élévation de privilèges (SUID, sudo misconfiguration, kernel exploits) sont les trois piliers de la post-exploitation.

5. IoC vs IoA : les indicateurs de compromission (IoC) identifient des artefacts post-incident ; les indicateurs d’attaque (IoA) détectent les comportements en temps réel et sont plus robustes car l’attaquant peut changer ses IoC mais difficilement ses comportements fondamentaux.

6. YARA : le langage de règles YARA permet de classifier des fichiers et de la mémoire selon des patterns de strings, hex et conditions logiques. Un moteur simplifié peut être implémenté en Python pour valider des règles sur des corpus synthétiques.

7. Atomic Red Team : bibliothèque de tests atomiques mappés ATT&CK permettant aux équipes Blue de valider leur couverture de détection de manière reproductible et systématique.