NtNotifyChangeMultipleKeys

Prototype

NTSTATUS NtNotifyChangeMultipleKeys(
  HANDLE             MasterKeyHandle,
  ULONG              Count,
  OBJECT_ATTRIBUTES *SubordinateObjects,
  HANDLE             Event,
  PIO_APC_ROUTINE    ApcRoutine,
  PVOID              ApcContext,
  PIO_STATUS_BLOCK   IoStatusBlock,
  ULONG              CompletionFilter,
  BOOLEAN            WatchTree,
  PVOID              Buffer,
  ULONG              BufferSize,
  BOOLEAN            Asynchronous
);

Arguments

IDs de syscalls par version de Windows

Stub du syscall

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

Frère multi-clés de `NtNotifyChangeKey`. Il n'existe pas de wrapper Win32 — l'API `RegNotifyChangeKeyValue` ne surveille qu'une seule clé. La fonction est utilisée en interne par le configuration manager (CM) Windows pour coordonner les notifications sur des segments de ruche liés, et par quelques snap-ins MMC. Le noyau parcourt la liste `SubordinateObjects`, ouvre chaque clé et enregistre un unique CM_NOTIFY_BLOCK qui signale quand *l'une quelconque* d'entre elles change — l'IO_STATUS_BLOCK ne dit pas laquelle a déclenché ; l'appelant doit re-requêter chaque clé pour découvrir le delta. Malgré son usage étroit, il est exporté par ntdll sur tous les builds depuis NT 4.0 avec une liste de paramètres stable.

Usage courant par les malwares

**Rarement vu dans le malware** — presque tout module de monitoring de persistance ou d'anti-cleanup qui veut surveiller la registry utilise le plus simple `NtNotifyChangeKey` (ou RegNotifyChangeKeyValue) contre une seule Run key. Les rares abus documentés combinent Multiple Keys avec `WatchTree=TRUE` pour surveiller toute la famille `HKLM\Software\Microsoft\Windows\CurrentVersion\Run`, `RunOnce`, `Image File Execution Options` et `Winlogon` sous un seul APC, afin que l'implant réinstalle toute entrée de persistance dès qu'un EDR ou un sysadmin en supprime une. Comme il n'y a pas de wrapper Win32, l'appel lui-même ressort un peu plus dans les stacks que la variante mono-clé.

Opportunités de détection

Le signal télémétrique ici est sensiblement plus fort que pour `NtNotifyChangeKey` justement parce que le logiciel usermode légitime ne l'appelle quasiment jamais — c'est largement un chemin interne au CM. ETW Microsoft-Windows-Kernel-Registry expose la création de requêtes de notify registry ; couplé avec la stack par thread de l'EDR, un processus non-système qui fait cet appel est suspect en soi. Sysmon Event ID 12/13/14 (RegistryEvent) rapporte les changements eux-mêmes, pas l'enregistrement de surveillance — les défenseurs qui corrèlent les patterns watch-puis-restore sur un même TID attrapent typiquement les boucles de restauration de persistance. Pivot défensif utile : identifier les processus qui détiennent un handle sur une clé de la famille Run plus un notify async en cours ; recouper avec le chemin d'image et le signataire.

Exemples de syscalls directs

; Direct syscall stub for NtNotifyChangeMultipleKeys (SSN 0x124 on Win11 24H2)
NtNotifyChangeMultipleKeys PROC
    mov  r10, rcx          ; syscall convention
    mov  eax, 124h         ; SSN — varies per build
    syscall
    ret
NtNotifyChangeMultipleKeys ENDP

// Implant module: re-install Run entry whenever any Run-family key is touched.
// Uses NtNotifyChangeMultipleKeys so a single APC covers Run + RunOnce + Winlogon.
#include <windows.h>
#include <winternl.h>

typedef NTSTATUS (NTAPI *pNtNotifyChangeMultipleKeys)(
    HANDLE, ULONG, POBJECT_ATTRIBUTES, HANDLE,
    PIO_APC_ROUTINE, PVOID, PIO_STATUS_BLOCK,
    ULONG, BOOLEAN, PVOID, ULONG, BOOLEAN);

VOID PersistenceWatch(HANDLE hRunKey,
                     POBJECT_ATTRIBUTES extras, ULONG nExtras) {
    pNtNotifyChangeMultipleKeys p = (pNtNotifyChangeMultipleKeys)
        GetProcAddress(GetModuleHandleA("ntdll.dll"),
                       "NtNotifyChangeMultipleKeys");
    HANDLE hEvt = CreateEventW(NULL, FALSE, FALSE, NULL);
    IO_STATUS_BLOCK iosb;
    for (;;) {
        NTSTATUS s = p(hRunKey, nExtras, extras, hEvt, NULL, NULL, &iosb,
            REG_NOTIFY_CHANGE_LAST_SET | REG_NOTIFY_CHANGE_NAME,
            TRUE,      // WatchTree
            NULL, 0,
            TRUE);     // Asynchronous
        if (s != STATUS_PENDING && s < 0) break;
        WaitForSingleObject(hEvt, INFINITE);
        ReinstallAllPersistence(); // re-write our Run values
    }
}

// Defensive use case: watch HKLM\SAM and HKLM\SECURITY together so a
// monitoring agent flushes its credential-policy cache in one wake-up.
#include <windows.h>
#include <winternl.h>

VOID PolicyWatcher(HANDLE hSam, HANDLE hSec) {
    OBJECT_ATTRIBUTES extras[1] = { 0 }; // SAM is master, SECURITY is subordinate
    UNICODE_STRING secPath; RtlInitUnicodeString(&secPath,
        L"\\Registry\\Machine\\Security");
    InitializeObjectAttributes(&extras[0], &secPath, OBJ_CASE_INSENSITIVE, NULL, NULL);

    IO_STATUS_BLOCK iosb;
    NtNotifyChangeMultipleKeys(hSam, 1, extras, NULL,
        &OnPolicyChange, NULL, &iosb,
        REG_NOTIFY_CHANGE_LAST_SET, TRUE,
        NULL, 0, TRUE);
}

Mappings MITRE ATT&CK

• T1547.001Registry Run Keys / Startup Foldermitre ↗
• T1112Modify Registrymitre ↗
• T1106Native APImitre ↗