NtLoadDriver

Prototype

NTSTATUS NtLoadDriver(
  PUNICODE_STRING DriverServiceName
);

Arguments

IDs de syscalls par version de Windows

Stub du syscall

4C 8B D1            mov r10, rcx
B8 0E 01 00 00      mov eax, 0x10E
F6 04 25 08 03 FE 7F 01   test byte ptr [0x7FFE0308], 1
75 03               jne short +3
0F 05               syscall
C3                  ret
CD 2E               int 2Eh
C3                  ret

Notes non documentées

Syscall à un seul argument qui prend le **chemin registre NT** vers la clé service du driver — *pas* un chemin filesystem vers le .sys. Le noyau lit `ImagePath`, `Type`, `Start`, `Group` et d'autres entrées de cette clé, charge l'image avec `MmLoadSystemImage`, appelle `DriverEntry`, puis insère le driver dans `PsLoadedModuleList`. L'appelant doit détenir `SeLoadDriverPrivilege` (par défaut : Administrators, Print Operators) et le privilège doit être **activé** dans le token du thread — c'est l'unique prérequis dur. Le SSN dérive beaucoup entre builds (0xF5 → 0x10E), résolution dynamique obligatoire. Les drivers chargés ainsi le sont en *demand-start* (Type=3), ce qui apparaît différemment en télémétrie PnP que les services `Start=2` (auto) que le SCM monte au boot.

Usage courant par les malwares

La porte d'entrée **BYOVD (Bring Your Own Vulnerable Driver)** — le syscall vers lequel toute attaque kernel sur Windows moderne converge. Chaîne complète : (1) déposer le driver vulnérable mais signé Microsoft (RTCore64.sys, gdrv.sys, mhyprot2.sys, dbutil_2_3.sys, procexp152.sys, kprocesshacker.sys, etc.) sur disque ; (2) créer la clé service sous `\Registry\Machine\System\CurrentControlSet\Services\<RandomName>` avec `ImagePath=\??\C:\path\drv.sys`, `Type=1`, `Start=3` (soit par NtSetValueKey directement, soit par `OpenSCManager`+`CreateServiceW` qui est plus bruyant) ; (3) activer `SeLoadDriverPrivilege` via `NtAdjustPrivilegesToken` ; (4) appeler NtLoadDriver avec le chemin de la clé service ; (5) ouvrir `\\.\<DeviceName>` et envoyer des IOCTL via `NtDeviceIoControlFile`. Le même syscall sert aussi à **l'installation de rootkit (T1014)** — Necurs, FU, TDL3/4, GrayFish d'Equation chargeaient tous leurs composants noyau par cette voie. La persistance légitime via driver de service (T1543.003) utilise le même appel, mais en passant par le SCM.

Opportunités de détection

**Télémétrie de chargement de driver à plus forte fidélité sur Windows**, et le syscall le plus surveillé par les EDR. Sources : (a) **Microsoft-Windows-Kernel-PnP** ETW (`{9C205A39-1250-487D-ABD7-E831C6290539}`) émet un évènement de load avec chemin image, détails de signature et processus chargeur ; (b) **Sysmon Event ID 6 (DriverLoad)** — image, hash, statut signé/non signé, signataire ; (c) **Évènement Security 4673/4674** quand `SeLoadDriverPrivilege` est exercé ; (d) **PsSetLoadImageNotifyRoutine** se déclenche pour *chaque* image chargée, drivers inclus, et alimente tout EDR moderne. La Vulnerable Driver Blocklist Microsoft (`HVCI` + policy Code Integrity `SiPolicy.p7b`, activée par défaut depuis Windows 11 22H2 et Server 2022) bloque par hash les familles BYOVD publiques avant chargement ; LOLDrivers.io maintient la liste communautaire. Chasses : tout appel NtLoadDriver par un processus vivant depuis moins de 60 s ; tout driver chargé depuis hors `%SystemRoot%\System32\drivers` ; tout driver dont le signataire figure sur LOLDrivers ; toute clé service créée moins de 5 minutes avant NtLoadDriver. La règle ASR Microsoft Defender `Block abuse of exploited vulnerable signed drivers` (D1E49AAC-8F56-4280-B9BA-993A6D77406C) bloque activement le catalogue.

Exemples de syscalls directs

// 1) Caller has already enabled SeLoadDriverPrivilege in its token.
// 2) Service registry entry has been written under HKLM\SYSTEM\CurrentControlSet\Services\Evil:
//      ImagePath = \??\C:\Users\Public\rtcore64.sys
//      Type      = 1            (kernel driver)
//      Start     = 3            (demand)
//      ErrorCtrl = 1

UNICODE_STRING svc;
RtlInitUnicodeString(&svc,
    L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\Evil");

NTSTATUS s = NtLoadDriver(&svc);
// On success the driver's DriverEntry has run and \\.\RTCore64 is now openable.

; SSN heavily build-dependent. Always resolve dynamically for portable code.
NtLoadDriver PROC
    mov  r10, rcx
    mov  eax, 10Eh         ; Win11 24H2
    syscall
    ret
NtLoadDriver ENDP

// Cargo: ntapi = "0.4", winapi = { version = "0.3", features = ["ntdef","ntsecapi"] }
use ntapi::ntpsapi::NtCurrentProcess;
use ntapi::ntrtl::RtlInitUnicodeString;
use winapi::shared::ntdef::{HANDLE, UNICODE_STRING};

extern "system" {
    fn NtLoadDriver(name: *mut UNICODE_STRING) -> i32;
    fn NtOpenProcessToken(p: HANDLE, da: u32, t: *mut HANDLE) -> i32;
    fn NtAdjustPrivilegesToken(
        t: HANDLE, dis: u8, n: *mut u8, len: u32,
        prev: *mut u8, ret: *mut u32) -> i32;
}

pub unsafe fn byovd_load(service_key_nt_path: *const u16) -> i32 {
    // 1) enable SeLoadDriverPrivilege in our own token (token plumbing omitted)
    // 2) issue the load
    let mut us: UNICODE_STRING = core::mem::zeroed();
    RtlInitUnicodeString(&mut us, service_key_nt_path);
    NtLoadDriver(&mut us)
}

Mappings MITRE ATT&CK

• T1068Exploitation for Privilege Escalationmitre ↗
• T1543.003Create or Modify System Process: Windows Servicemitre ↗
• T1014Rootkitmitre ↗
• T1562.001Impair Defenses: Disable or Modify Toolsmitre ↗