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.

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 :

// 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 :

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 :

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 :

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