Native API

Réserve ou valide de la mémoire virtuelle avec paramètres étendus (nœud NUMA préféré, CFG, contraintes d'adresse).

Écrit un tampon de l'appelant dans l'espace d'adressage virtuel d'un processus cible.

Lit des octets de l'espace d'adressage virtuel d'un processus cible vers un tampon fourni par l'appelant.

Décommit ou libère une région de mémoire virtuelle dans un processus cible.

Récupère des informations sur les pages de l'espace d'adressage virtuel d'un processus cible.

Vide sur disque les pages modifiées d'une vue adossée à un fichier, équivalent à FlushViewOfFile.

Verrouille une région de mémoire virtuelle dans le working set du processus pour qu'aucune page ne soit paginée.

Libère un verrou de working set préalablement posé par NtLockVirtualMemory.

Applique une classe d'information à une liste de plages mémoire virtuelle : préchargement, priorité de page ou opt-in CFG.

Alloue des pages de mémoire physique pour Address Windowing Extensions (AWE).

Mappe des pages physiques allouées via AWE dans une fenêtre d'adresse virtuelle préalablement réservée.

Libère des pages physiques précédemment allouées via NtAllocateUserPhysicalPages, en les rendant au pool système.

Invalide le cache d'instructions sur une région d'un processus cible pour que du code fraîchement écrit puisse être exécuté.

Émet une barrière mémoire système sur chaque CPU exécutant des threads du processus courant.

Crée un objet section avec des paramètres étendus (nœud NUMA, contraintes d'adresse, pages physiques utilisateur).

Ouvre un handle vers un objet section nommé existant (mémoire partagée ou mapping d'image).

Étend une section existante adossée au pagefile ou à un fichier vers une taille maximale supérieure.

Récupère des métadonnées de base ou spécifiques à l'image d'un section object.

Syscall étendu de mapping de section (Windows 10 1809+) qui accepte des contraintes MEM_EXTENDED_PARAMETER.

Démappe une vue de section précédemment mappée de l'espace d'adressage d'un processus.

Détermine si deux vues mappées sont adossées au même fichier (test d'identité du file object).

Récupère l'ensemble des pages écrites dans une région MEM_WRITE_WATCH depuis la dernière réinitialisation.

Efface l'état de suivi d'écriture d'une région MEM_WRITE_WATCH sans récupérer les pages sales.

Crée un objet partition mémoire qui isole le working-set physique d'un groupe de processus.

Ouvre un objet partition mémoire existant par son nom et renvoie un handle pour gestion ou attachement de processus.

Interroge ou modifie une partition mémoire existante — ajout de mémoire, transfert de pages, configuration des memory-lists.

Syscall historique de création de thread nécessitant une INITIAL_TEB construite à la main ; remplacé par NtCreateThreadEx.

Place un appel de procédure asynchrone (APC) en mode utilisateur dans la file d'un thread cible.

Place un APC utilisateur dans la file d'un thread avec un objet réserve optionnel ou un flag special-user-APC pour livraison forcée.

Vérifie si le thread appelant a une alerte en attente et délivre, le cas échéant, les APC user-mode en file.

Restaure un CONTEXT CPU sur le thread courant et reprend l'exécution à CONTEXT.Rip.

Réveille un thread (identifié par son TID) parqué dans NtWaitForAlertByThreadId — la face noyau de WakeByAddressSingle.

Parque le thread appelant jusqu'à ce que NtAlertThreadByThreadId le réveille — la face noyau de WaitOnAddress.

Pré-alloue un reserve object noyau (APC ou completion) afin que les opérations futures ne puissent échouer sous pression mémoire.

Création de processus NT historique à partir d'un objet section préconstruit — prédécesseur de NtCreateProcessEx et NtCreateUserProcess.

Crée un nouveau processus en mode utilisateur et son thread initial à partir d'une image exécutable.

Crée un nouveau processus à partir d'un handle de section sans exécuter l'initialisation ntdll — brique du process hollowing.

Termine un processus cible et tous ses threads avec un code de sortie donné.

Suspend tous les threads d'un processus cible en incrémentant le compteur de suspension de chacun.

Décrémente le compteur de suspension de chaque thread d'un processus cible et relance ceux qui atteignent zéro.

Parcourt la liste des processus du noyau et retourne un handle vers le processus suivant.

Teste si un processus s'exécute dans un job object spécifique (ou un quelconque).

Ouvre un handle vers un thread existant identifié par CLIENT_ID avec les droits d'accès demandés.

Incrémente le compteur de suspension d'un thread cible, arrêtant son exécution.

Décrémente le compteur de suspension d'un thread, reprenant l'exécution lorsque le compteur atteint zéro.

Reprend un thread suspendu et l'alerte simultanément pour délivrer toute APC en attente.

Termine le thread spécifié avec le code de sortie fourni. Un handle NULL termine le thread courant.

Récupère le contexte des registres CPU (structure CONTEXT) d'un thread suspendu.

Définit le contexte des registres CPU d'un thread — primitive noyau derrière le détournement de thread et la redirection de shellcode.

Retourne un handle vers le thread suivant d'un processus cible en parcourant la liste de threads du noyau.

Ouvre le jeton d'accès associé à un processus et renvoie un handle vers celui-ci.

Active ou désactive des privilèges dans un jeton d'accès spécifié.

Récupère une classe d'information spécifiée sur un jeton d'accès.

Écrit une propriété d'un token d'accès — niveau d'intégrité, session id, owner, DACL par défaut, politique d'audit, token lié.

Crée une copie restreinte (filtrée) d'un token d'accès existant en désactivant des SID, supprimant des privilèges ou ajoutant des SID restreints.

Affecte le jeton bien connu ANONYMOUS LOGON au thread spécifié.

Fait impersonner par le thread serveur le contexte de sécurité du thread client.

Détermine si deux tokens accordent les mêmes accès — même utilisateur, mêmes groupes, mêmes SIDs restreints, mêmes privilèges.

Forge un token d'accès de toutes pièces avec utilisateur, groupes, privilèges, owner, DACL par défaut et source — protégé par SeCreateTokenPrivilege.

Dérive un token LowBox (AppContainer) à partir d'un token existant — fixe le SID de package et les capabilities qui régulent l'accès au broker IPC.

Effectue un contrôle d'accès d'un descripteur de sécurité contre un token d'impersonation, retournant le masque d'accès accordé.

Effectue un contrôle d'accès de sécurité contre un descripteur de sécurité en respectant une hiérarchie d'objets typés (OBJECT_TYPE_LIST).

Effectue un contrôle d'accès typé renvoyant une liste de résultats par type d'objet, sans écrire d'événements d'audit.

Vérifie si les privilèges listés dans un PRIVILEGE_SET sont activés dans un token d'impersonation.

Lit le résultat de niveau de signature mis en cache par Code Integrity, stocké comme attribut étendu NTFS sur un fichier.

Compare deux valeurs SE_SIGNING_LEVEL selon l'ordre de policy Code Integrity et indique si la première domine la seconde.

Effectue un contrôle d'accès standard et écrit une entrée d'alarme d'audit dans le journal Sécurité.

Effectue un contrôle d'accès typé et inscrit une entrée d'alarme d'audit dans le journal Sécurité.

Contrôle d'accès typé renvoyant une liste de résultats par type, tout en écrivant des entrées d'alarme d'audit dans le journal Sécurité.

Émet l'entrée du journal Sécurité associée à une ouverture audit-alarm antérieure, marquant la fermeture du handle.

Récupère une classe d'informations sur un processus — back-end universel de GetProcessInformation et cheval de bataille des vérifications anti-debug.

Modifie une classe d'état au niveau processus — auto-nettoyage anti-debug, enregistrement de plages CET, installation de politiques ACG/CIG, callbacks d'instrumentation.

Lit une propriété d'un thread via l'énumération THREADINFOCLASS — pointeur TEB, flag hide-from-debugger, temps, statut de sortie.

Définit une propriété d'un thread via l'énumération THREADINFOCLASS — notamment ThreadHideFromDebugger.

Récupère une classe d'informations à l'échelle du système — liste des processus, table des handles noyau, liste des pilotes chargés, état d'intégrité du code, et plus.

Setter noyau générique sélectionné par SYSTEM_INFORMATION_CLASS — porte d'entrée pour SystemDebugControl, chargement de pilotes GDI, etc.

Lève une « erreur dure » que le noyau achemine vers CSRSS pour affichage — ou, avec SeShutdownPrivilege et sévérité FATAL, déclenche un bugcheck immédiat (BSOD).

Interroge des informations de fichier par chemin sans handle ouvert, introduit dans Windows 10 RS5.

Crée un objet de profileur d'échantillonnage en mode noyau qui range le compteur de programme dans un histogramme.

Retourne la valeur actuelle du compteur de performance haute résolution et optionnellement sa fréquence.

Renvoie l'index zero-based du processeur logique sur lequel le thread appelant s'exécute actuellement.

Écrit un évènement user-mode dans une session ETW via un handle de trace enregistré.

IOCTL de contrôle multiplexé du sous-système ETW — démarrer, arrêter, interroger, vider les sessions et activer/désactiver les providers.

Crée un DebugObject noyau — le port par débogueur qui reçoit les événements des processus attachés.

Attache un DebugObject existant à un processus en cours — le côté noyau de DebugActiveProcess.

Détache un DebugObject d'un processus — le côté noyau de DebugActiveProcessStop.

Attend le prochain événement de débogage délivré à un debug object et retourne un DBGUI_WAIT_STATE_CHANGE.

Reprend l'exécution d'un thread débogué après un événement, avec un NTSTATUS de continuation.

Crée un objet d'événement de synchronisation, nommé ou non, et renvoie un handle.

Ouvre un handle vers un objet événement nommé existant.

Place un objet événement à l'état signalé, libérant les threads en attente.

Remet un objet événement à non-signalé et retourne son état signalé précédent.

Signale un événement, libère les threads en attente puis le réinitialise immédiatement à non-signalé.

Met un objet événement à l'état non-signalé sans retourner l'état précédent.

Attend qu'un objet dispatcher devienne signalé ou que le timeout optionnel expire.

Attend jusqu'à MAXIMUM_WAIT_OBJECTS objets dispatcher avec une sémantique WaitAny ou WaitAll.

Signale atomiquement un objet dispatcher et attend sur un autre en une transition unique sans course.

Crée un objet keyed event — primitive de synchronisation noyau légère appariant attentes et réveils par clé d'adresse virtuelle.

Bloque le thread appelant sur un keyed event jusqu'à ce qu'un autre thread libère la même paire (event, clé).

Réveille exactement un thread en attente sur la même paire (keyed event, clé), bloquant si aucun waiter n'est encore présent.

Crée ou ouvre un objet mutant (mutex) nommé ou anonyme et en prend éventuellement la propriété initiale.

Crée un objet timer noyau qui pourra ensuite être armé via NtSetTimer.

Annule un armement NtSetTimer en attente et indique si le timer était encore actif à l'annulation.

Crée un objet timer moderne haute résolution prenant en charge manual-reset et no-wake en un seul appel.

Arme un objet Timer2 avec un délai, une période optionnelle et un bloc T2_SET_PARAMETERS décrivant callback et flags.

Annule un objet Timer2 précédemment armé et indique s'il était encore en attente.

Suspend le thread appelant pendant un intervalle donné, éventuellement en état alertable.

Retourne l'heure système actuelle en intervalles de 100 ns depuis 1601-01-01 UTC.

Crée l'extrémité serveur d'un canal nommé dans l'espace de noms \Device\NamedPipe.

Crée le côté serveur d'un mailslot — un primitif IPC historique à sens unique, façon datagramme, accessible via \Device\Mailslot.

Crée un port de connexion ALPC côté serveur que les clients peuvent atteindre via NtAlpcConnectPort.

Établit une connexion client ALPC vers un port serveur nommé et échange un message initial.

Acceptation ALPC côté serveur — finalise une demande de connexion client en attente et renvoie un port de communication par client.

Envoie un message ALPC sur un port et attend optionnellement une réponse ou le prochain message entrant.

Interroge les métadonnées d'un port ALPC — processus propriétaire, statistiques de message, SID serveur, attributs de port.

Primitive d'impersonation principale d'un serveur ALPC — endosse le contexte de sécurité du client ayant envoyé un message.

Helper côté serveur qui ouvre un HANDLE vers le processus ayant envoyé un message ALPC donné.

Helper côté serveur qui ouvre un HANDLE vers le thread ayant envoyé un message ALPC donné.

Ferme proprement le côté client d'une connexion ALPC, signalant le serveur avant la libération du handle.

Libère un contexte SECURITY_QOS ALPC précédemment créé avec NtAlpcCreateSecurityContext.

Invalide un contexte SECURITY_QOS ALPC en cache sans libérer son slot de handle.

Crée un objet port LPC serveur nommé — la primitive d'écoute IPC historique pré-ALPC.

Connexion client à un port serveur LPC historique, équivalent pré-ALPC de NtAlpcConnectPort.

Acceptation côté serveur d'une demande de connexion LPC historique, avec mappage facultatif d'une vue partagée.

Envoie un message LPC fire-and-forget sur un port connecté — sans attendre de réponse.

Envoie une requête LPC synchrone et bloque jusqu'à la réponse du serveur — la primitive RPC historique.

Envoie une réponse sur un port LPC côté serveur à une requête reçue, sans attendre.

Primitive LPC côté serveur : répond atomiquement à la requête précédente et bloque pour la suivante.

Crée un job object — le conteneur noyau utilisé pour appliquer limites, comptabilité et politique de terminaison à un ensemble de processus.

Rattache un processus à un job object pour que les limites, la comptabilité et la politique de terminaison du job s'y appliquent.

Définit une politique ou une limite sur un job object via une des classes d'information JOBOBJECTINFOCLASS.

Récupère les informations de comptabilité, limites ou restrictions UI d'un job object.

Termine atomiquement chaque processus actuellement assigné à un job object.

Crée un port de complétion d'E/S — la file noyau qui sous-tend la livraison de travail du threadpool, la notification d'E/S asynchrone et (dans PoolParty) les items de travail injectés.

Poste un paquet de complétion sur un port de complétion d'E/S — le côté noyau de PostQueuedCompletionStatus et le vecteur de livraison des items forgés de PoolParty.

Défile un seul paquet de complétion d'un port de complétion d'E/S, bloquant jusqu'à disponibilité ou expiration du timeout.

Retire jusqu'à un nombre spécifié par l'appelant de paquets de complétion d'un port I/O completion en un seul syscall.

Annule chaque requête I/O en attente émise par le thread appelant sur un handle fichier.

Annule une requête I/O spécifique en attente sur un fichier, quel que soit le thread émetteur.

Annule un appel I/O synchrone qui bloque actuellement un autre thread.

Annule un wait-completion packet précédemment associé, supprimant la liaison à l'objet dispatcher.

Lie un wait-completion packet à un dispatcher object pour que son signal poste une entrée dans un IOCP.

Crée un objet worker factory noyau — la primitive de threadpool que l'injection PoolParty détourne pour exécuter du shellcode sans NtCreateThreadEx.

Signale à une worker factory d'arrêter la création de threads et indique combien de workers sont encore en attente.

Définit une classe de configuration sur une worker factory — y compris, dans certaines variantes PoolParty, la StartRoutine exécutée par les threads de travail.

Interroge la configuration et l'état d'exécution d'une worker factory, y compris la StartRoutine actuelle et le nombre de workers.

Signale au noyau qu'un worker de threadpool est prêt à recevoir du travail — composant du handshake interne ntdll!TppWorkerThread.

Demande au noyau de rendre au moins un worker disponible dans la factory — utilisé par le threadpool utilisateur pour réveiller le pool à la soumission de travail.

Bloque un worker de threadpool jusqu'à ce qu'un item soit disponible sur la file de complétion de la factory — la boucle chaude détournée par PoolParty.

Crée un nouvel objet de transaction KTM (Kernel Transaction Manager) pour encapsuler atomiquement des opérations NTFS.

Ouvre un objet de transaction KTM existant par nom ou par GUID d'unité de travail.

Valide une transaction KTM, persistant atomiquement sur disque toutes les modifications réalisées sous celle-ci.

Annule une transaction KTM en rejetant toutes les modifications réalisées sous celle-ci.

Alloue une nouvelle enclave (SGX ou VBS/VTL1) dans l'espace d'adressage d'un processus cible.

Finalise une enclave après chargement d'image — vérifie les signatures et la rend exécutable.

Transfère l'exécution du code hôte VTL0 vers une routine à l'intérieur d'une enclave initialisée.

Démantèle une enclave, libère sa mémoire VTL1 et signale les threads encore à l'intérieur.

Copie un buffer aligné page (code ou données) depuis la mémoire hôte VTL0 vers la plage VTL1 d'une enclave avant initialisation.

Ouvre une clé de registre existante — entrée noyau de RegOpenKeyEx, utilisée pour atteindre les ruches SAM, SECURITY et de persistance.

Supprime une clé de registre à la fermeture du handle — utilisé pour effacer la persistance et les artefacts d'audit après exécution.

Lit une valeur d'une clé de registre — primitive de collecte ciblée de credentials et de configurations.

Lit atomiquement plusieurs valeurs de registre d'une même clé en un seul syscall.

Renomme une clé de registre existante en place — pas de wrapper Win32, accessible uniquement via l'API NT.

Monte un fichier de ruche de registre sous une clé cible — le syscall derrière le chargement offline de SAM/SYSTEM.

Charge une ruche de registre dans l'arbre de configuration via un wrapper à 2 drapeaux autour de NtLoadKey.

Syscall moderne de chargement de ruche — sous-tend RegLoadKeyW, RegLoadAppKeyW et la virtualisation registre des AppContainers.

Écrase le contenu d'une clé de registre depuis un fichier ruche — remplace des sous-arbres en bloc.

Écrit une clé de registre vivante (avec sous-arbre) dans un fichier ruche — la face noyau du vol SAM/SECURITY.

Force l'écriture sur disque de toutes les modifications en attente d'une clé de registre.

Force la défragmentation / compactage du fichier source d'une ruche de registre chargée.

Enregistre une notification asynchrone pour les modifications d'une clé de registre et (optionnellement) son sous-arbre.

Enregistre une demande unique de notification qui se déclenche lorsque l'une de plusieurs clés de registre change.

Bloque temporairement toutes les écritures de registre du système, utilisé par VSS pour des snapshots cohérents.

Libère un gel précédent du registre pour reprendre les écritures ; contrepartie de NtFreezeRegistry.

Ferme un handle d'objet noyau (fichier, clé, événement, processus, thread, section, etc.).

Crée ou ouvre un fichier, répertoire, périphérique ou pipe nommé — premier appel disque de tout dropper.

Ouvre un handle vers un fichier ou un device existant — pendant léger sans création de NtCreateFile.

Lit des octets depuis un fichier, périphérique, pipe nommé ou section mappée vers un tampon utilisateur — primitive noyau derrière ReadFile.

Écrit des données dans un fichier, pipe ou périphérique ouvert — pendant noyau de NtCreateFile pour déposer un payload.

Supprime un fichier par chemin sans ouverture préalable de handle — primitive anti-forensique rare.

Définit des métadonnées de fichier via FILE_INFORMATION_CLASS — renommer, supprimer, allouer, fin de fichier…

Lit les métadonnées d'un fichier ouvert — timestamps, taille, EA, streams, points de reparse, etc.

Énumère un répertoire au niveau IRP — utilisé par les rootkits pour cacher des fichiers en altérant la liste retournée.

Envoie un IOCTL à un driver noyau — porte d'entrée user-mode de tout abus de primitive BYOVD.

Envoie des codes FSCTL à un système de fichiers — utilisé pour planter des reparse points, accéder aux ADS et abuser des jonctions.

Acquiert un verrou sur une plage d'octets d'un fichier ouvert, optionnellement exclusif et optionnellement asynchrone.

Libère un verrou de plage d'octets précédemment acquis sur un fichier ouvert.

Enregistre une demande de notification asynchrone des changements de fichiers dans un répertoire ouvert.

Notification étendue de changement de répertoire permettant de choisir la classe FILE_NOTIFY_INFORMATION retournée dans le buffer.

Récupère les propriétés filesystem et volume (label, taille, type de périphérique, attributs) du volume associé à un handle de fichier.

Modifie les propriétés volume modifiables — principalement le label — du volume associé à un handle de fichier.

Écrit les attributs étendus NTFS (EA) attachés à un handle de fichier.

Lit les attributs étendus NTFS (EA) depuis un handle de fichier, avec filtre/pagination optionnels.

Duplique un handle d'un processus source vers un processus cible, avec ajustement éventuel des accès ou fermeture de la source.

Renvoie des métadonnées sur un handle d'objet noyau : info de base, nom, type ou table de types système.

Définit des attributs de niveau handle (héritage, protection contre fermeture) sur un handle d'objet noyau.

Renvoie STATUS_SUCCESS lorsque deux handles désignent le même objet noyau sous-jacent.

Pose l'attribut OBJ_PERMANENT sur un objet noyau nommé pour qu'il survive après la fermeture du dernier handle.

Efface l'attribut OBJ_PERMANENT pour que l'objet noyau soit libéré dès la fermeture du dernier handle.

Crée un nouvel objet directory dans l'espace de noms de l'object manager Windows.

Ouvre un objet directory existant dans l'espace de noms de l'object manager Windows.

Énumère les entrées (nom + type) à l'intérieur d'un directory de l'object manager.

Crée un lien symbolique d'object manager d'un nom vers une chaîne cible NT arbitraire.

Ouvre un lien symbolique de l'object manager existant par son nom, renvoyant un handle pour interrogation ou suppression.

Ajoute (ou incrémente le refcount) d'une chaîne dans la table d'atomes globale du noyau et renvoie son ID 16 bits.

Recherche un atome global existant par son nom et renvoie son ID 16 bits sans incrémenter le refcount.

Décrémente le compteur de références d'un atome global et le supprime quand le compteur atteint zéro.

Renvoie des métadonnées sur un atome unique ou sur toute la table d'atomes globale — nom, refcount, pin count, compteurs d'usage.

Récupère un SECURITY_DESCRIPTOR auto-relatif depuis tout objet noyau exposé via un handle.

Écrit un résultat de niveau de signature mis en cache par Code Integrity dans un attribut étendu NTFS sur le fichier cible.

Enregistre une nouvelle BOOT_ENTRY dans la base de configuration de démarrage (BCD) et retourne son identifiant attribué.

Remplace une BOOT_ENTRY existante dans la base BCD par un nouveau descripteur, identifié par son ID.

Écrit l'ordre des tentatives de démarrage firmware — le tableau d'IDs BOOT_ENTRY que la plateforme tentera en séquence.

Lit le blob d'options de démarrage BCD du système — drapeaux debug, options de chargement OS, hyperviseur, test signing.

Lit la liste DriverOrder UEFI de la plateforme — l'ordre dans lequel les entrées Driver#### UEFI se chargent au démarrage.

Lit une variable d'environnement système BIOS/NV-RAM x86 héritée par nom (interface pré-UEFI).

Écrit une variable d'environnement système BIOS/NV-RAM x86 héritée (interface pré-UEFI).

Lit une variable UEFI identifiée par un couple (nom, GUID éditeur) et retourne ses données et attributs.

Déclenche la sérialisation du tampon de trace de démarrage — finalise les données de performance collectées au démarrage.

Achemine des requêtes de type débogueur noyau (R/W noyau, espace de contrôle, points d'arrêt, profileur) sélectionnées par l'enum SysDbgCommand.

Fait passer le système dans l'état d'alimentation demandé (veille, hibernation, fonctionnement).

Déclencheur d'arrêt mode noyau — éteint, redémarre ou arrête le système en un syscall.

Crée ou étend un fichier d'échange Windows au chemin NT demandé ; requiert SeCreatePagefilePrivilege.

Point d'entrée de contrôle NT Virtual DOS Machine — support DOS/Windows 16 bits, hors d'usage en x64.