Skip to content
KitploitKITPLOIT
OutilsBlog
Soumettre
OutilsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

··Flux·Contact·Confidentialité·© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
aegis — Pilote de protection des processus en mode noyau avec interface graphique utilisateur. | Kitploit
Outils/GitHubGitHub/tobiaskocur/aegis
Outils DéfensifsEscalade de PrivilègesExploitationApprentissage et ÉducationRed Teaming
GitHubtobiaskocur/aegis

aegis

Pilote de protection des processus en mode noyau avec interface graphique utilisateur.

Voir le dépôt
531il y a 8 moisVérifié par Kitploit

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →
Partager

Aegis

Pilote de protection de processus en mode noyau utilisant ObRegisterCallbacks pour retirer les permissions d'accès mémoire des handles. Implémentation de base qui intercepte la création de handles et supprime PROCESS_VM_READ/WRITE/OPERATION des tentatives d'accès non autorisées.

Capture d'écran de démonstration

GIF de démonstration

Remarque : Si le GIF ne s'anime pas, visualisez-le directement sur Imgur

Aperçu

Le pilote enregistre des callbacks OB à l'altitude 321123 et intercepte les opérations OB_OPERATION_HANDLE_CREATE et OB_OPERATION_HANDLE_DUPLICATE. Lorsqu'un processus tente d'ouvrir un handle vers une cible protégée, nous vérifions le nom du processus source par rapport à une liste blanche (explorer.exe, csrss.exe, svchost.exe, MsMpEng.exe, RuntimeBroker.exe) et retirons les droits d'accès s'il n'est pas autorisé.

L'implémentation actuelle repose sur une correspondance par nom utilisant PsGetProcessImageFileName (API non documentée). La liste de protection est gérée via une liste chaînée avec synchronisation par spinlock. Le thread de travail existe, mais la logique d'actualisation n'est pas encore implémentée.

Le composant mode utilisateur fournit une interface graphique ImGui pour ajouter des processus à la liste de protection. La communication s'effectue via des codes IOCTL sur le lien symbolique \\Device\\Aegis en utilisant le transfert METHOD_BUFFERED. Le pilote crée un lien symbolique de \\DosDevices\\Aegis vers \\Device\\Aegis afin que le mode utilisateur puisse y accéder via \\\\.\\Aegis.

Architecture

Noyau (km/) :

  • driver.c - DriverEntry, enregistrement OB, répartiteur IOCTL, création du périphérique/lien symbolique
  • protect_manager/ - Gestion de la liste des processus, thread de travail (logique d'actualisation en attente)

Mode utilisateur (um/) :

  • client.cpp - Boucle principale, rendu ImGui, gestion des fenêtres
  • gui/ - Configuration DirectX 11 + ImGui, polices personnalisées (Gilroy)
  • service_manager/ - Intégration SCM pour le chargement/déchargement du pilote
  • ioctl_manager/ - Wrapper DeviceIoControl pour la communication avec le pilote

Détails Techniques

Implémentation en Mode Noyau

  • Callbacks OB : Enregistrés à l'altitude 321123 (le standard tiers est 321000+, définie plus haut pour éviter les collisions)
  • Identification des processus : Utilise PsGetProcessImageFileName - API non documentée qui retourne uniquement le nom du fichier .exe (15 caractères max)
  • Sécurité des threads : Opérations KSPIN_LOCK au niveau DISPATCH_LEVEL (IRQL 2) pour éviter les conditions de course
  • Gestion de la mémoire :
    • NonPagedPool pour protect_manager (toujours en RAM, accès plus rapide, pool limité)
    • PagedPool pour les structures de processus individuelles (peut être paginé)
  • Thread de travail : Thread système avec KEVENT pour le traitement asynchrone (actuellement stub)
  • IOCTL : METHOD_BUFFERED pour une gestion sécurisée des buffers, type de périphérique 0x8000 (plage tiers)

Implémentation en Mode Utilisateur

  • Interface graphique : ImGui avec swapchain DirectX 11, style personnalisé
  • Chargement du pilote : API Service Control Manager, crée le service « AegisDriver » avec SERVICE_DEMAND_START
  • Communication : DeviceIoControl avec les codes IOCTL définis dans le fichier partagé ioctl.h
  • Gestion des erreurs : Affichage d'erreurs basique via MessageBox

Exemples de Code

Enregistrement du Callback OB :

root@kitploit:~
// Register OB callbacks for handle creation/duplication
OB_CALLBACK_REGISTRATION ob_registration = { 0 };
OB_OPERATION_REGISTRATION op_registration = { 0 };
RtlSecureZeroMemory(&ob_registration, sizeof(ob_registration));
RtlSecureZeroMemory(&op_registration, sizeof(op_registration));

op_registration.ObjectType = PsProcessType;
op_registration.Operations = OB_OPERATION_HANDLE_CREATE | OB_OPERATION_HANDLE_DUPLICATE;
// we care about duplication because smart hackers or malware, often do not create handles 
// but duplicate current ones to not arouse suspicion
op_registration.PreOperation = pre_open_process;

RtlInitUnicodeString(&ob_registration.Altitude, L"321123"); 
// 321000 is standard for 3rd party drivers, we set it a bit higher to not have collision

status = ObRegisterCallbacks(&ob_registration, &reg_handle);

Suppression des Droits d'Accès aux Handles :

root@kitploit:~
OB_PREOP_CALLBACK_STATUS pre_open_process(PVOID reg_context, POB_PRE_OPERATION_INFORMATION info)
{
    if (info->ObjectType == *PsProcessType) {
        PEPROCESS proc = (PEPROCESS)info->Object;
        char* process_name = (char*)PsGetProcessImageFileName(proc);
        
        // Lock list at DISPATCH_LEVEL to prevent BSOD
        KIRQL irql;
        KeAcquireSpinLock(&g_protect_manager->list_lock, &irql);
        
        // Check if process is in protection list
        for (entry = g_protect_manager->process_list.Flink; 
             entry != &g_protect_manager->process_list; 
             entry = entry->Flink) {
            pprocess proces = CONTAINING_RECORD(entry, process, entry);
            if (strcmp(proces->path, process_name) == 0) {
                // Check source process - allow system processes
                PEPROCESS source_process = IoGetCurrentProcess();
                char* source_name = (char*)PsGetProcessImageFileName(source_process);
                if (strcmp(source_name, "explorer.exe") == 0 || 
                    strcmp(source_name, "csrss.exe") == 0 || ...) {
                    KeReleaseSpinLock(&g_protect_manager->list_lock, irql);
                    return OB_PREOP_SUCCESS;
                }
                
                // Strip VM_READ, VM_WRITE, VM_OPERATION (0x1, 0x10, 0x20)
                // We don't set to 0 because it can cause bugs
                info->Parameters->CreateHandleInformation.DesiredAccess &= ~(0x1 | 0x10 | 0x20);
                KeReleaseSpinLock(&g_protect_manager->list_lock, irql);
                return OB_PREOP_SUCCESS;
            }
        }
        KeReleaseSpinLock(&g_protect_manager->list_lock, irql);
    }
    return OB_PREOP_SUCCESS;
}

Gestion de la Liste des Processus :

root@kitploit:~
NTSTATUS protect_manager_protect_process(pprotect_manager self, pprocess process)
{
    // KIRQL (Kernel Interrupt Request Level) 0-31 tells CPU to not disturb
    // 0 = PASSIVE_LEVEL, 2 = DISPATCH_LEVEL, 31 = HIGH_LEVEL
    KIRQL irql;
    
    // Acquire spinlock, raises IRQL to DISPATCH_LEVEL (2)
    // Locks the list so it doesn't change while we edit
    KeAcquireSpinLock(&self->list_lock, &irql);
    InsertTailList(&self->process_list, &process->entry);
    KeReleaseSpinLock(&self->list_lock, irql);
    
    // Signal worker thread to refresh
    self->refresh_needed = TRUE;
    KeSetEvent(&self->worker_event, 0, FALSE); // FALSE = auto revert IRQL
    return STATUS_SUCCESS;
}

Communication IOCTL en Mode Utilisateur :

root@kitploit:~
bool ioctl_manager::check(std::string name)
{
    // Open driver device via symlink \\\\.\\Aegis -> \\Device\\Aegis
    this->driver_object = CreateFile(this->path, GENERIC_READ | GENERIC_WRITE, 
                                      0, NULL, OPEN_EXISTING, 0, NULL);
    
    // Send process name to driver via IOCTL
    result = DeviceIoControl(this->driver_object, IOCTL_PROTECT_PID, 
                            (LPVOID)data.c_str(), data.size() + 1, 
                            NULL, 0, &bytes_returned, NULL);
    
    CloseHandle(this->driver_object); // don't forget to close handles
    return result;
}

Tout le code est abondamment commenté avec des explications sur les concepts du noyau, les niveaux IRQL, la gestion de la mémoire et les pièges potentiels. N'hésitez pas à consulter le code source - il est pédagogique et bien documenté.

Prérequis de Compilation

  • Visual Studio avec la charge de travail C++
  • Windows Driver Kit (WDK)
  • Signature de test activée (bcdedit /set testsigning on)

Sorties de compilation : km.sys (pilote) et um.exe (application mode utilisateur).

Problèmes Connus / Limitations

  • Aucune protection en mode noyau : Tout pilote KM peut contourner ce mécanisme en accédant directement à EPROCESS
  • Correspondance par nom uniquement : L'usurpation du nom de processus est possible, aucune validation du PID
  • Liste blanche codée en dur : La liste des processus système est incomplète et statique
  • Duplication de handles : Ne gère que OB_OPERATION_HANDLE_CREATE, des attaques par duplication sont possibles
  • Thread de travail incomplet : La logique d'actualisation dans protect_manager.c est vide
  • API obsolètes : Utilise ExAllocatePool au lieu de ExAllocatePool2

TODO

  • Implémentation DKOM : Masquage de processus en les retirant de PsActiveProcessHead, masquage du pilote en le retirant de PsLoadedModuleList
  • Protection des threads : Étendre les callbacks OB pour protéger les handles de threads
  • Protection basée sur le PID : Ajouter une validation de l'ID de processus au lieu de se fier uniquement aux noms
  • Fonctionnalité de déprotection : Ajouter un IOCTL pour retirer des processus de la liste de protection
  • Terminer le thread de travail : Implémenter la véritable logique d'actualisation de la liste des processus

Avertissement

À des fins pédagogiques uniquement. Utilise des API non documentées qui peuvent se casser avec les mises à jour de Windows. Nécessite une signature de test ou une signature de code appropriée pour s'exécuter.

Télécharger l’outil