NtEnumerateKey

Prototype

NTSTATUS NtEnumerateKey(
  HANDLE                KeyHandle,
  ULONG                 Index,
  KEY_INFORMATION_CLASS KeyInformationClass,
  PVOID                 KeyInformation,
  ULONG                 Length,
  PULONG                ResultLength
);

Arguments

IDs de syscalls par version de Windows

Stub du syscall

4C 8B D1            mov r10, rcx
B8 32 00 00 00      mov eax, 0x32
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

Énumération basée sur l'index : l'appelant boucle depuis `Index=0` jusqu'à `STATUS_NO_MORE_ENTRIES`. Ajouter ou supprimer une sous-clé pendant l'énumération décale les indices — les appelants robustes retentent l'index échoué ou capturent une liste de noms avant traitement. SSN `0x32` stable depuis Windows 7. `NtEnumerateKey` ne retourne que des sous-clés — pour les valeurs il faut `NtEnumerateValueKey` (syscall sœur de même forme).

Usage courant par les malwares

**Découverte de persistance (T1518 + T1012 + T1547.x)** — red et blue utilisent la même primitive, juste à des extrémités opposées de la kill chain. L'usage offensif intéressant est *l'énumération d'autorun avant plantation* : parcourir d'abord chaque clé d'auto-exécution standard pour trouver un nom inutilisé (évitement de collision) ou pour découvrir des entrées existantes que l'implant peut hijacker (remplacer le binaire d'un lanceur de tâche planifié installé mais rarement actif plutôt que créer une entrée qui serait la seule absente des baselines). Chemins canoniques : `\Registry\Machine\Software\Microsoft\Windows\CurrentVersion\Run`, `RunOnce`, `Explorer\Shell Folders`, `Image File Execution Options` (dont les sous-clés sont des *noms d'exécutables* — les énumérer trouve les opportunités de hijack IFEO debugger), `App Paths`, `\Services` (drivers Type=1, services own-process Type=16), `\Microsoft\Windows NT\CurrentVersion\Winlogon\Notify`. Les stealers énumèrent aussi `\Software\Microsoft\Windows NT\CurrentVersion\NetworkList\Profiles` pour découvrir les GUID des profils Wi-Fi avant de récupérer les PSK via `wlanapi`.

Opportunités de détection

Le volume d'`NtEnumerateKey` est gigantesque sur un hôte normal (refresh GPO, moteur ASR Defender, chaque expansion du namespace Explorer). Pas un signal primaire utile. Deux signaux dérivés marchent : (1) **énumération d'une clé sensible par un processus hors baseline** — alerter quand un process dont le hash d'image n'a jamais auparavant énuméré `\Microsoft\Windows NT\CurrentVersion\Image File Execution Options` le fait ; (2) **énumération suivie de SetValueKey** sur le même parent — les implants énumèrent typiquement pour éviter les collisions, puis écrivent. L'ETW Microsoft-Windows-Kernel-Registry porte les deux évènements avec des timestamps assez fins pour corréler. Les EDR enregistrant `CmRegisterCallbackEx` reçoivent les notifications `RegNtPreEnumerateKey`/`RegNtPostEnumerateKey` indépendamment de l'état des hooks user-mode. Requête de chasse : même PID émet ≥ 20 `NtEnumerateKey` sous `\Microsoft\Windows\CurrentVersion\Run*` plus un `NtSetValueKey` vers un frère dans une fenêtre de 2 s.

Exemples de syscalls directs

// hIfeo = handle to \Registry\Machine\Software\Microsoft\
//                  Windows NT\CurrentVersion\Image File Execution Options
for (ULONG i = 0;; ++i) {
    BYTE  buf[0x200];
    ULONG got = 0;
    NTSTATUS s = NtEnumerateKey(
        hIfeo, i,
        KeyBasicInformation,
        buf, sizeof(buf), &got);
    if (s == STATUS_NO_MORE_ENTRIES) break;
    if (!NT_SUCCESS(s)) continue;
    PKEY_BASIC_INFORMATION ki = (PKEY_BASIC_INFORMATION)buf;
    // ki->Name is the image name targetable by IFEO Debugger hijack
}

NtEnumerateKey PROC
    mov  r10, rcx
    mov  eax, 32h
    syscall
    ret
NtEnumerateKey ENDP

use ntapi::ntregapi::{NtEnumerateKey, KEY_BASIC_INFORMATION};
use winapi::shared::ntdef::HANDLE;

pub unsafe fn list_subkeys(h: HANDLE) -> Vec<String> {
    let mut names = Vec::new();
    let mut buf = vec![0u8; 0x400];
    for i in 0u32.. {
        let mut got = 0u32;
        let s = NtEnumerateKey(
            h, i, 0 /* KeyBasicInformation */,
            buf.as_mut_ptr() as *mut _, buf.len() as u32, &mut got);
        if s == 0x8000001A /* STATUS_NO_MORE_ENTRIES */ { break; }
        if s != 0 { continue; }
        let ki = &*(buf.as_ptr() as *const KEY_BASIC_INFORMATION);
        let name = core::slice::from_raw_parts(
            ki.Name.as_ptr(), (ki.NameLength / 2) as usize);
        names.push(String::from_utf16_lossy(name));
    }
    names
}

Mappings MITRE ATT&CK

• T1518Software Discoverymitre ↗
• T1012Query Registrymitre ↗
• T1547.001Boot or Logon Autostart Execution: Registry Run Keys / Startup Foldermitre ↗
• T1546.012Image File Execution Options Injectionmitre ↗