NtCompareObjects

Prototype

NTSTATUS NtCompareObjects(
  HANDLE FirstObjectHandle,
  HANDLE SecondObjectHandle
);

Arguments

IDs de syscalls par version de Windows

Stub du syscall

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

Ajouté dans Windows 10 1507 pour fournir au user-mode un vrai test d'égalité sur les objets noyau. Avant ce syscall, le seul moyen fiable de savoir si deux handles aliasaient le même objet était une pile d'heuristiques faillibles (comparer les noms d'objets quand disponibles, comparer les PID pour des handles process, etc.). En interne `NtCompareObjects` résout les deux handles vers leur `_OBJECT_HEADER *` sous-jacent via `ObReferenceObjectByHandle`, teste l'égalité des pointeurs puis déréférence les deux. L'implémentation est dans `ObCompareObjectsForCommonSecurity`. Le retour est binaire : `STATUS_SUCCESS` (même objet), `STATUS_NOT_SAME_OBJECT` (objets différents), ou une variante usuelle `STATUS_INVALID_HANDLE`. Les types n'ont pas besoin de correspondre — comparer un handle `Process` à un handle `Token` renvoie simplement `STATUS_NOT_SAME_OBJECT`. Il n'y a *aucun* wrapper Win32 public ; le plus proche est `CompareObjectHandles` livré seulement via le Windows SDK sous forme d'inline ucrt qui appelle le `CompareObjectHandles` non documenté de `KernelBase.dll` (Win10 1809+).

Usage courant par les malwares

Faible signal malware. Utilisé à deux endroits où il apparaît : (1) du code d'introspection EDR qui veut confirmer qu'un handle dupliqué pointe toujours vers le même objet cible, et (2) certains designs d'implants (BOF Cobalt Strike, certaines extensions Sliver) l'utilisent comme check OPSEC léger avant, par exemple, d'appeler `NtDuplicateObject` sur un handle qu'ils soupçonnent déjà greffé par un processus contrôlé par EDR. C'est aussi un test pratique d'égalité handle-à-handle dans l'outillage post-exploitation qui parcourt la table de handles système (`NtQuerySystemInformation(SystemHandleInformation)`) et veut dédupliquer les aliases. Il ne *bypass* rien en soi — c'est une primitive utilisée par d'autres primitives.

Opportunités de détection

Aucun provider ETW n'émet de télémétrie par appel pour ce syscall et Sysmon ne l'expose pas. Les défenseurs n'alertent généralement pas sur `NtCompareObjects` car l'usage légitime est rare-mais-réel (KernelBase!CompareObjectHandles est appelé par des parties de `Win32k`, `ImmersiveShell` et `RuntimeBroker.exe`). Le seul moment où ça devient intéressant est quand un module non signé ou fraîchement chargé émet soudainement de nombreux `NtCompareObjects` en boucle serrée contre la table de handles système — ce pattern est la signature de handle-walk post-exploitation, mais l'appel lui-même est un mauvais indicateur primaire.

Exemples de syscalls directs

; Direct syscall stub for NtCompareObjects (SSN 0x9F on Win11 24H2 / Server 2025)
NtCompareObjects PROC
    mov  r10, rcx          ; syscall convention
    mov  eax, 9Fh          ; SSN — drifts; resolve dynamically for portability
    syscall
    ret
NtCompareObjects ENDP

// Walks a handle list and collapses entries that alias the same object —
// a common post-exploitation cleanup before reporting unique findings.
for (ULONG i = 0; i < count; ++i) {
    for (ULONG j = i + 1; j < count; ++j) {
        if (NtCompareObjects(handles[i], handles[j]) == STATUS_SUCCESS) {
            // aliased -> drop handles[j] from the result set
            handles[j] = NULL;
        }
    }
}

// Cargo: windows-sys = "0.59" (Win32_Foundation, Win32_System_Threading)
// CompareObjectHandles is a thin KernelBase wrapper over NtCompareObjects.
use windows_sys::Win32::Foundation::{CompareObjectHandles, HANDLE};

fn same_object(a: HANDLE, b: HANDLE) -> bool {
    unsafe { CompareObjectHandles(a, b) != 0 }
}

Mappings MITRE ATT&CK

• T1106Native APImitre ↗