Les solutions de détection et réponse pour terminaux (EDR) au sein des infrastructures professionnelles s'appuient principalement sur l'analyse comportementale des processus, l'inspection des segments de mémoire et l'interception des appels d'API. Lorsqu'un logiciel malveillant tente une injection de code (process injection) dans un processus système légitime, les agents EDR repèrent habituellement l'anomalie en surveillant des fonctions Win32 bien connues telles que CreateRemoteThread, QueueUserAPC ou SetThreadContext.

Cependant, la publication de la technique d'attaque PoolParty a mis en lumière une vulnérabilité conceptuelle majeure dans la surveillance des postes clients. En manipulant directement les structures internes du sous-système de pools de threads natif de Windows (Thread Pool), un attaquant peut faire exécuter du code arbitraire au sein de processus de confiance—tels que svchost.exe, explorer.exe ou lsass.exe—sans jamais créer de nouveau thread et sans déclencher les alertes du noyau. L'examen approfondi du mécanisme de PoolParty montre pourquoi le contrôle sur l'hôte doit impérativement s'accompagner d'un cloisonnement réseau étanche en Couche 3.

+--------------------------------------------------------------------------+
|          INJECTION CONVENTIONNELLE VS ÉVASION DE DÉTECTION POOLPARTY     |
+--------------------------------------------------------------------------+
|  INJECTION CLASSIQUE (Détectée par les crochets d'API et sondes EDR) :   |
|  Processus malveillant ──> VirtualAllocEx ──> WriteProcessMemory         |
|                        ──> CreateRemoteThread / QueueUserAPC             |
|                            │                                             |
|                            ▼                                             |
|  [Sonde noyau EDR : PsSetCreateThreadNotifyRoutine / Crochets API]       |
|  ==> Alerte déclenchée : Création anormale d'un thread distant identifiée|
+--------------------------------------------------------------------------+
|  TECHNIQUE POOLPARTY (Furtivité totale face aux sondes de l'EDR) :       |
|  Processus malveillant ──> OpenProcess ──> Écriture du shellcode         |
|                        ──> Insertion d'une tâche dans le Thread Pool     |
|                            (Utilisation de TpPostWork, TpSetTimer, etc.) |
|                            │                                             |
|                            ▼                                             |
|  Le thread ouvrier existant du processus cible exécute le shellcode      |
|  ==> Zéro création de thread ; l'EDR considère l'exécution légitime      |
+--------------------------------------------------------------------------+

Architecture du sous-système Windows Thread Pool dans l'espace utilisateur

Pour gérer efficacement des opérations asynchrones sans subir le coût prohibitif de la création et de la destruction répétées de threads, le système d'exploitation Windows intègre une gestion de pools de threads en mode utilisateur régie par ntdll.dll.

Ce sous-système s'articule autour de plusieurs structures névralgiques :

  1. Fabriques de threads (TpWorkerFactory) : Objets noyau non documentés chargés de coordonner un groupe de threads d'exécution qui prélèvent des tâches associées à un port de complétion d'E/S (IoCompletion).
  2. Éléments de travail (TP_WORK) : Structures renfermant un pointeur vers une fonction de rappel (callback) et un paramètre de contexte arbitraire (PVOID). Les applications soumettent ces tâches via la fonction TpPostWork.
  3. Minuteurs (TP_TIMER) : Objets rattachés aux files d'attente de minuteurs du noyau. À l'échéance du délai fixé, un thread ouvrier dépile l'objet et active sa fonction de rappel.
  4. Objets d'attente (TP_WAIT) : Liés à des primitives de synchronisation système (comme des descripteurs d'événements). Lorsque le descripteur passe à l'état signalé, le pool mobilise un thread ouvrier disponible.
  5. Complétions d'E/S et messages ALPC (TP_IO, TP_ALPC) : Abstractions déclenchant des fonctions asynchrones à la fin d'opérations sur disque, réseau ou lors de messages interprocessus ALPC.

La quasi-totalité des services système et des logiciels d'arrière-plan exploitant les pools de threads, ces structures de données sont présentes en permanence dans l'espace d'adressage des processus hôtes.

La matrice d'attaque PoolParty : Huit vecteurs d'exécution furtive

L'innovation de PoolParty réside dans l'exploitation d'une asymétrie de détection : les solutions de sécurité surveillent les instanciations de threads, mais n'inspectent pas les files d'attente de tâches des pools existants. En écrivant le shellcode en mémoire et en manipulant les pointeurs de la file du pool, l'assaillant amène le thread légitime à exécuter la charge hostile.

+--------------------------------------------------------------------------+
|                  VECTEURS D'INJECTION DE LA MATRICE POOLPARTY            |
+--------------------------------------------------------------------------+
|  Variante de l'attaque Structure cible             Mécanisme d'activation|
+--------------------------------------------------------------------------+
|  Détournement de routine Bloc de contrôle          Remplacement du       |
|  Worker Factory Start  `TpWorkerFactory`           pointeur de départ    |
|                                                                          |
|  Injection dans la     Structure `TP_TASK` de la   Postage direct dans le|
|  file Worker Factory   file d'attente de l'usine   port IoCompletion     |
|                                                                          |
|  Insertion d'élément   Structure de rappel         Appel à `TpPostWork`  |
|  de travail (TP_WORK)  `TP_WORK` en mémoire        activant le thread    |
|                                                                          |
|  Détournement de       Objet `TP_TIMER` dans la    Expiration du minuteur|
|  minuteur (TP_TIMER)   liste des temporisateurs    exécutant le shellcode|
|                                                                          |
|  Signalisation d'objet Objet `TP_WAIT` lié à un    Signalement du handle |
|  d'attente (TP_WAIT)   handle d'événement          déclenchant le thread |
|                                                                          |
|  Falsification de      File d'attente de           Simulation d'une fin  |
|  paquets I/O (TP_IO)   complétion `TP_IO`          d'opération d'E/S     |
|                                                                          |
|  Transmission de       Structure de communication  Envoi d'un message    |
|  messages (TP_ALPC)    ALPC du processus           activant la routine   |
|                                                                          |
|  Notification d'objet  File de notification du     Changement d'état d'un|
|  de tâche (TP_JOB)     port de complétion `TP_JOB` processus déclencheur|
+--------------------------------------------------------------------------+

Mécanisme d'insertion dans la file d'attente Worker Factory

Dans une variante courante, l'attaquant prend pour cible l'objet TpWorkerFactory associé au processus convoité :

  1. L'attaquant obtient un handle sur le processus cible avec les droits PROCESS_VM_WRITE et PROCESS_VM_OPERATION.
  2. Il injecte le shellcode dans une plage mémoire réservée du processus cible.
  3. Il identifie le handle de la fabrique de threads ouvriers en consultant la table des descripteurs via NtQueryInformationProcess.
  4. À l'aide de la routine non exportée NtSetInformationWorkerFactory, il manipule la file d'attente pour y insérer une fausse structure TP_TASK dont l'adresse pointe sur le shellcode.
  5. Un thread ouvrier inoccupé géré par le système d'exploitation prélève cette tâche en la considérant comme un travail d'entretien interne et l'exécute avec les privilèges du processus cible.

L'exécution étant prise en charge par un thread préexistant, la fonction de notification PsSetCreateThreadNotifyRoutine ne relève aucune anomalie. L'EDR reste aveugle à l'attaque.

L'usurpation de processus : Communications C2 sous couverture système

La gravité de l'attaque PoolParty se révèle pleinement lors de l'établissement des liaisons réseau. Lorsqu'une charge hostile s'exécute dans un conteneur système comme svchost.exe, elle hérite de la réputation réseau de ce service.

+--------------------------------------------------------------------------+
|            USURPATION DE FLUX RÉSEAU APRÈS INJECTION POOLPARTY           |
+--------------------------------------------------------------------------+
|  Processus compromis : C:\Windows\System32\svchost.exe (PID : 1420)      |
|         │                                                                |
|         ▼  (Émission d'une liaison réseau vers le serveur C2 externe)    |
|  [Pare-feu local de l'hôte / Antivirus traditionnel]                     |
|  - Vérification du chemin de l'exécutable : "svchost.exe"                |
|  - Vérification de la signature : "Microsoft Windows Publisher" (VALIDE) |
|  - Verdict : AUTORISER LA CONNEXION (Composant système approuvé)         |
|         │                                                                |
|         ▼  (Exfiltration d'identifiants, réception d'ordres hostiles)    |
|  Infrastructure de commande et contrôle (C2) de l'attaquant              |
+--------------------------------------------------------------------------+

Sur la plupart des terminaux, les pare-feux locaux autorisent svchost.exe à établir des connexions sortantes vers Internet afin d'assurer les mises à jour logicielles (Windows Update), les vérifications de certificats (CRL) ou la synchronisation de l'heure (NTP).

Les attaquants exploitent cette configuration pour transmettre des balises périodiques (beacons) et exfiltrer des données confidentielles sous couvert du trafic système habituel.

La réponse en Couche 3 : Enclave réseau chiffrée avec WireGuard

Dès lors que la surveillance interne au système d'exploitation peut être trompée au niveau de la mémoire, la sécurité du système d'information doit s'appuyer sur une politique de filtrage réseau externe et déterministe. La mise en place d'un tunnel WireGuard en Couche 3 apporte une isolation complète.

+--------------------------------------------------------------------------+
|      ARCHITECTURE DE DÉFENSE EN COUCHE 3 AVEC PASSERELLE WIREGUARD       |
+--------------------------------------------------------------------------+
|                                                                          |
|   Poste client Windows (Processus svchost.exe compromis par PoolParty)   |
|   - Tente d'ouvrir un flux TCP vers un C2 externe sur le port 8443       |
|                 │                                                        |
|                 ▼                                                        |
|   [Pilote WFP / Adaptateur virtuel WireGuard wg0 sur le terminal]        |
|   - Redirige obligatoirement tout flux sortant vers l'adaptateur wg0     |
|   - Bloque immédiatement tout paquet tentant d'éviter wg0 (Kill Switch)  |
|                 │                                                        |
|                 ▼ (Tunnel chiffré ChaCha20-Poly1305 : UDP/51820)         |
|   +------------------------------------------------------------------+   |
|   |         Passerelle de sécurité WireGuard (Linux / nftables)      |   |
|   |                                                                  |   |
|   |   Règles de sécurité :                                           |   |
|   |   - Filtrage strict des sorties (Default-Deny Egress)            |   |
|   |   - Réacheminement DNS vers le résolveur local Unbound           |   |
|   |   - Neutralisation des domaines C2 hostiles par Sinkhole         |   |
|   |   - Rejet des ports inhabituels (4444, 8080, 8443)               |   |
|   +------------------------------------------------------------------+   |
|         │                                        │                       |
|         ▼ (Autorisé : Flux professionnel vérifié)▼ (BLOQUÉ PAR SINKHOLE) |
|   Services cloud d'entreprise homologués   Serveur de commande hostile   |
+--------------------------------------------------------------------------+

1. Assujettissement d'interface par Windows Filtering Platform (WFP)

Sur le poste client, une politique WFP liée à l'interface WireGuard (wg0) impose une contrainte stricte :

  • Liaison d'interface obligatoire : Tout paquet IP émis par un processus—y compris svchost.exe—est orienté vers l'interface virtuelle wg0.
  • Mécanisme d'arrêt d'urgence (Kill Switch) : Les flux cherchant à s'échapper directement par l'adaptateur Ethernet ou Wi-Fi physique sont rejetés au niveau de la couche transport (FWPM_LAYER_OUTBOUND_TRANSPORT_V4).
  • Verrouillage cryptographique : Le code malveillant ne peut modifier la table de routage pour échapper à la surveillance réseau.

2. Filtrage des sorties et politique de refus par défaut

Sur la passerelle WireGuard centrale, la règle par défaut est le refus strict des flux sortants (Default-Deny). Les connexions émises par un processus corrompu sont bloquées :

# Règles nftables pour le sous-réseau des postes WireGuard (10.10.0.0/24)
# Rejet des ports de destination non autorisés prisés par les outils de C2
nft add rule inet filter forward ip saddr 10.10.0.0/24 tcp dport { 4444, 8080, 8443, 9001 } drop

# Redirection impérative de l'ensemble des requêtes DNS vers le serveur local
nft add rule inet nat prerouting iifname "wg0" udp dport 53 redirect to 53
nft add rule inet nat prerouting iifname "wg0" tcp dport 53 redirect to 53

# Autorisation réservée aux flux métiers pré-identifiés et aux sessions établies
nft add rule inet filter forward ct state established,related accept
nft add rule inet filter forward ip saddr 10.10.0.0/24 oifname "wan" accept

3. Résolution DNS récursive dédiée et neutralisation par Sinkhole

Les infrastructures hostiles s'appuient fréquemment sur des noms de domaine dynamiques. Dans une architecture WireGuard cloisonnée, les postes n'ont pas la possibilité d'interroger directement des serveurs DNS publics externes.

Les requêtes sont traitées par un résolveur récursif Unbound interne intégrant des listes de réputation. Si le processus compromis tente de résoudre un domaine hostile, le résolveur répond immédiatement par NXDOMAIN ou dirige la requête vers une adresse nulle (0.0.0.0), interrompant le canal de communication avant toute fuite de données.

Comparaison des niveaux de protection : Hôte vs Couche 3

L'exploitation des failles de type PoolParty met en évidence les limites d'une défense cantonnée au poste client :

Critère d'évaluation Agent EDR classique sur l'hôte Architecture réseau WireGuard Couche 3
Méthode de contrôle Analyse des appels d'API et des créations de thread Routage déterministe et authentification par clés
Résistance à PoolParty Vulnérable ; n'inspecte pas les files de threads Étanche ; analyse les paquets réels sur le réseau
Usurpation de processus Fait confiance à la signature de svchost.exe Applique le modèle Zero Trust sans distinction
Canal de contrôle C2 Tolère les flux des exécutables système légitimes Bloqué par les politiques de filtrage de la passerelle
Protection anti-fuite Dépend de l'intégrité de l'agent local Assurée à l'extérieur du poste compromis

L'apparition de PoolParty rappelle une vérité fondamentale en ingénierie de sécurité : lorsqu'un système d'exploitation ne peut plus garantir la légitimité de ses propres processus, seule une barrière cryptographique réseau indépendante en Couche 3 préserve la sécurité du réseau d'entreprise.

Téléchargez VPNRice.