Agents IA pour le SOC : Triage Automatisé des Alertes

Figure 1 - Architecture SOC augmenté par IA avec les cinq couches fonctionnelles et le workflow de triage automatisé Pour approfondir, consultez Top 10 des Attaques.

Cette architecture place l'agent IA comme couche intermédiaire entre le SIEM et le SOAR. L'agent ne remplace ni l'un ni l'autre : il consomme les alertes du SIEM, les enrichit via les APIs CTI, applique son raisonnement, puis déclenche les actions appropriées dans le SOAR ou escalade vers un analyste humain. Cette approche garantit une intégration progressive, sans rupture avec l'existant.

Votre organisation est-elle prête à faire face aux attaques basées sur l'IA ?

3Triage Automatisé : De l'Alerte à l'Incident

Le pipeline de triage est le coeur de l'agent SOC. Il reçoit une alerte brute du SIEM et doit produire une décision structurée : vrai positif, faux positif, ou nécessite investigation humaine. Ce processus s'appuie sur le pattern ReAct (Reasoning + Acting) qui alterne phases de réflexion et appels d'outils.

Le pipeline ReAct de triage

L'agent de triage implémente un graphe d'état LangGraph avec les noeuds suivants : parsing de l'alerte, extraction des observables (IOCs), enrichissement parallèle, analyse de contexte, scoring de risque, et décision finale. Chaque noeud produit un état intermédiaire persisté, permettant le replay et l'audit.

from typing import TypedDict, Annotated, Literal
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
import operator

# État du pipeline de triage
class TriageState(TypedDict):
    alert_raw: dict          # Alerte brute du SIEM
    observables: Annotated[list, operator.add]  # IOCs extraits
    enrichments: dict       # Résultats CTI
    mitre_mapping: list     # Techniques ATT&CK
    risk_score: float       # Score 0-100
    classification: str     # VP / FP / NEEDS_REVIEW
    severity: str           # critical/high/medium/low
    reasoning: str          # Explication de la décision
    actions: list           # Actions SOAR à exécuter

llm = ChatOpenAI(model="gpt-4o", temperature=0)

# Noeud 1 : Extraction des observables
def extract_observables(state: TriageState) -> dict:
    alert = state["alert_raw"]
    prompt = f"""Extrais tous les IOCs de cette alerte SIEM:
    {alert}
    Retourne: IPs, domaines, hashes, URLs, users, hosts."""
    response = llm.invoke(prompt)
    return {"observables": parse_iocs(response.content)}

# Noeud 2 : Enrichissement multi-sources
def enrich_observables(state: TriageState) -> dict:
    results = {}
    for ioc in state["observables"]:
        results[ioc["value"]] = {
            "virustotal": query_vt(ioc),
            "abuseipdb": query_abuseipdb(ioc),
            "shodan": query_shodan(ioc),
            "greynoise": query_greynoise(ioc),
        }
    return {"enrichments": results}

# Noeud 3 : Mapping MITRE ATT&CK
def map_mitre(state: TriageState) -> dict:
    prompt = f"""Associe cette alerte aux techniques MITRE ATT&CK:
    Alerte: {state['alert_raw']['rule_name']}
    Enrichissements: {state['enrichments']}
    Retourne les technique IDs et tactiques."""
    response = llm.invoke(prompt)
    return {"mitre_mapping": parse_mitre(response.content)}

# Noeud 4 : Décision de classification
def classify_alert(state: TriageState) -> dict:
    prompt = f"""Tu es un analyste SOC L2 expert.
    Alerte: {state['alert_raw']}
    IOCs enrichis: {state['enrichments']}
    MITRE: {state['mitre_mapping']}

    Classifie: TRUE_POSITIVE, FALSE_POSITIVE, NEEDS_REVIEW
    Assigne une sévérité: critical, high, medium, low
    Score de risque: 0-100
    Explique ton raisonnement."""
    response = llm.invoke(prompt)
    return parse_classification(response.content)

# Construction du graphe
graph = StateGraph(TriageState)
graph.add_node("extract", extract_observables)
graph.add_node("enrich", enrich_observables)
graph.add_node("mitre", map_mitre)
graph.add_node("classify", classify_alert)

graph.set_entry_point("extract")
graph.add_edge("extract", "enrich")
graph.add_edge("enrich", "mitre")
graph.add_edge("mitre", "classify")
graph.add_edge("classify", END)

triage_agent = graph.compile()

Classification et scoring de risque

Le scoring de risque combine plusieurs signaux pondérés pour produire un score composite sur 100. Les facteurs incluent : la réputation des IOCs (score VirusTotal, AbuseIPDB confidence score), la criticité de l'asset touché (serveur de production vs poste de développement), l'historique d'alertes similaires sur les 30 derniers jours, le mapping MITRE ATT&CK (les techniques associées à des APT connus reçoivent un bonus de score), et le contexte temporel (une connexion RDP à 3h du matin depuis un pays inhabituel pèse plus lourd que le même événement en heures ouvrées).

Outils et ressources complementaires

Les seuils de classification sont configurables par organisation : typiquement, un score supérieur à 75 déclenche une classification vrai positif critique avec escalade immédiate, entre 50 et 75 l'alerte est classée vrai positif à investiguer, entre 25 et 50 elle est marquée nécessite revue humaine, et en dessous de 25 elle est considérée faux positif et auto-clôturée avec journalisation complète du raisonnement.

4Agent d'Enrichissement Contextuel

L'enrichissement est l'étape qui transforme une alerte brute en intelligence actionnable. Un agent d'enrichissement contextuel ne se contente pas de requêter des APIs de threat intelligence : il construit un graphe de relations entre les observables, évalue la fiabilité de chaque source, et produit un résumé synthétique exploitable par l'analyste ou par l'agent de qualification en aval.

Enrichissement multi-sources

L'agent d'enrichissement orchestre des requêtes parallèles vers plusieurs sources complémentaires. Pour une adresse IP suspecte, le pipeline d'enrichissement interroge simultanément : VirusTotal (détections par moteurs AV, résolutions DNS historiques, certificats SSL associés), AbuseIPDB (score de confiance d'abus, catégories de rapport, ISP), Shodan (ports ouverts, bannières de services, vulnérabilités CVE), GreyNoise (classification bruit Internet vs ciblé), WHOIS (date d'enregistrement du domaine, registrar, pays), et MISP/OpenCTI (corrélation avec des campagnes connues et des IOCs communautaires).

import asyncio
from typing import Dict, List
from langchain.tools import tool

@tool
async def enrich_ip(ip: str) -> Dict:
    """Enrichit une IP via toutes les sources CTI."""
    tasks = [
        query_virustotal_ip(ip),
        query_abuseipdb(ip),
        query_shodan_host(ip),
        query_greynoise(ip),
        query_whois(ip),
        query_misp_search(ip),
    ]
    results = await asyncio.gather(*tasks, return_exceptions=True)
    
    return {
        "ip": ip,
        "virustotal": results[0] if not isinstance(results[0], Exception) else None,
        "abuseipdb": results[1] if not isinstance(results[1], Exception) else None,
        "shodan": results[2] if not isinstance(results[2], Exception) else None,
        "greynoise": results[3] if not isinstance(results[3], Exception) else None,
        "whois": results[4] if not isinstance(results[4], Exception) else None,
        "misp": results[5] if not isinstance(results[5], Exception) else None,
    }

@tool
def build_relation_graph(enrichments: Dict) -> Dict:
    """Construit un graphe de relations IP-Domaine-Cert-ASN."""
    graph = {"nodes": [], "edges": []}
    
    # IP -> Domaines (résolution DNS)
    for resolution in enrichments["virustotal"].get("resolutions", []):
        graph["nodes"].append({"type": "domain", "value": resolution["hostname"]})
        graph["edges"].append({"from": enrichments["ip"], "to": resolution["hostname"], "type": "resolves_to"})
    
    # Domaine -> Certificat SSL
    for cert in enrichments["virustotal"].get("ssl_certificates", []):
        graph["nodes"].append({"type": "certificate", "value": cert["thumbprint"]})
        graph["edges"].append({"from": cert["subject"], "to": cert["thumbprint"], "type": "has_cert"})
    
    # IP -> ASN
    asn = enrichments["shodan"].get("asn", "unknown")
    graph["nodes"].append({"type": "asn", "value": asn})
    graph["edges"].append({"from": enrichments["ip"], "to": asn, "type": "belongs_to"})
    
    return graph

Scoring de risque dynamique

Le scoring dynamique agrège les signaux de toutes les sources avec des pondérations adaptatives. Contrairement à un score statique basé sur des seuils fixes, l'agent ajuste les poids en fonction du contexte. Par exemple, le score AbuseIPDB a plus de poids pour une alerte de type brute force que pour une alerte de data exfiltration. Le score VirusTotal est prépondérant pour les alertes impliquant des hashes de fichiers. GreyNoise permet de distinguer le bruit Internet des attaques ciblées : une IP classifiée comme "benign scanner" par GreyNoise verra son score de menace réduit, tandis qu'une IP "unknown" associée à des détections VirusTotal positives sera fortement pondérée. Pour approfondir, consultez IA et Automatisation RH : Screening CV et Compliance.

Perspectives et evolution

Le graphe de relations enrichit encore la décision. Si une IP suspecte résout vers un domaine enregistré il y a moins de 7 jours, hébergé sur un ASN connu pour l'hébergement bulletproof, avec un certificat Let's Encrypt auto-signé, ces signaux corrélés augmentent significativement le score de risque même si chaque indicateur individuel resterait en zone grise.

5Qualification et Escalade Intelligente

La qualification est la phase décisionnelle où l'agent transforme son analyse en actions concrètes. Il ne suffit pas de classifier une alerte en vrai ou faux positif : l'agent doit décider du niveau d'escalade, générer un ticket structuré, proposer des actions de containment, et déclencher les playbooks SOAR appropriés.

Décision automatisée et playbooks dynamiques

L'agent de qualification implémente une matrice de décision contextuelle qui dépasse les simples seuils de score. Pour chaque classification, il évalue un ensemble de règles de business logic spécifiques à l'organisation :

• ▹Assets critiques : toute alerte impliquant un contrôleur de domaine, un serveur de base de données de production, ou un système SCADA est automatiquement escaladée en priorité P1, indépendamment du score de risque.
• ▹Utilisateurs VIP : les comptes C-Level, les administrateurs de domaine et les comptes de service critiques déclenchent une escalade L2 systématique avec notification SMS.
• ▹Corrélation temporelle : si 5+ alertes impliquant le même host ou le même utilisateur sont détectées en moins de 15 minutes, l'agent déclenche un playbook de containment préventif (isolation réseau) en attendant la validation L2.
• ▹Kill chain progression : si l'agent détecte une progression dans la kill chain ATT&CK (reconnaissance, puis accès initial, puis mouvement latéral), il agrège les alertes en un incident unique et escalade avec le contexte complet de la chaîne d'attaque.

Génération automatique de tickets et escalade contextuelle

Lorsqu'un incident est confirmé, l'agent génère automatiquement un ticket ITSM structuré dans ServiceNow, Jira Service Management ou GLPI. Le ticket inclut : le résumé de l'alerte, les IOCs enrichis, le mapping MITRE ATT&CK, le score de risque, les actions de containment recommandées, et le raisonnement complet de l'agent. L'escalade vers les analystes L2/L3 est accompagnée d'un briefing contextuel généré par le LLM, qui résume en langage naturel les éléments clés et les hypothèses d'investigation à privilégier.

Mise en oeuvre et bonnes pratiques