Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
aegis — Driver di protezione dei processi in modalità kernel con interfaccia utente GUI | Kitploit
Strumenti/GitHubGitHub/tobiaskocur/aegis
Strumenti DifensiviEscalation di PrivilegiExploitApprendimento e FormazioneRed Teaming
GitHubtobiaskocur/aegis

aegis

Driver di protezione dei processi in modalità kernel con interfaccia utente GUI

Vedi Repository
5313010 mesi faRevisionato da Kitploit
Condividi

Aegis

Driver di protezione dei processi in modalità kernel che utilizza ObRegisterCallbacks per rimuovere i permessi di accesso alla memoria dagli handle. Implementazione di base che intercetta la creazione degli handle e rimuove PROCESS_VM_READ/WRITE/OPERATION dai tentativi di accesso non autorizzati.

Demo Screenshot

Demo GIF

Nota: Se la GIF non si anima, visualizzala direttamente su Imgur

Panoramica

Il driver registra callback OB all'altitudine 321123 e intercetta le operazioni OB_OPERATION_HANDLE_CREATE e OB_OPERATION_HANDLE_DUPLICATE. Quando un processo tenta di aprire un handle verso un target protetto, controlliamo il nome del processo sorgente rispetto a una whitelist (explorer.exe, csrss.exe, svchost.exe, MsMpEng.exe, RuntimeBroker.exe) e rimuoviamo i diritti di accesso se non è consentito.

L'implementazione attuale utilizza un matching basato sul nome tramite PsGetProcessImageFileName (API non documentata). La lista di protezione è gestita tramite una lista concatenata con sincronizzazione spinlock. Esiste un thread worker, ma la logica di aggiornamento non è ancora implementata.

Il componente in modalità utente fornisce un'interfaccia ImGui per aggiungere processi alla lista di protezione. La comunicazione avviene tramite codici IOCTL sul symlink \\Device\\Aegis usando il trasferimento METHOD_BUFFERED. Il driver crea un symlink da \\DosDevices\\Aegis a \\Device\\Aegis in modo che la modalità utente possa accedervi tramite \\\\.\\Aegis.

Architettura

Kernel (km/):

  • driver.c - DriverEntry, registrazione OB, dispatcher IOCTL, creazione device/symlink
  • protect_manager/ - Gestione lista processi, thread worker (logica di aggiornamento in sospeso)

Modalità utente (um/):

  • client.cpp - Loop principale, rendering ImGui, gestione finestre
  • gui/ - Configurazione DirectX 11 + ImGui, font personalizzati (Gilroy)
  • service_manager/ - Integrazione SCM per caricamento/scaricamento driver
  • ioctl_manager/ - Wrapper DeviceIoControl per comunicazione con driver

Dettagli Tecnici

Implementazione in Modalità Kernel

  • Callback OB: Registrate con altitudine 321123 (lo standard di terze parti è 321000+, impostato più alto per evitare collisioni)
  • Identificazione processo: Utilizza PsGetProcessImageFileName - API non documentata che restituisce solo il nome del file .exe (massimo 15 caratteri)
  • Sicurezza dei thread: Operazioni KSPIN_LOCK a DISPATCH_LEVEL (IRQL 2) per prevenire condizioni di competizione
  • Gestione memoria:
    • NonPagedPool per protect_manager (sempre in RAM, accesso più veloce, pool limitato)
    • PagedPool per le strutture dei singoli processi (possono essere messe in pagina)
  • Thread worker: Thread di sistema con KEVENT per elaborazione asincrona (attualmente stub)
  • IOCTL: METHOD_BUFFERED per la gestione sicura del buffer, tipo dispositivo 0x8000 (range terze parti)

Implementazione in Modalità Utente

  • GUI: ImGui con swapchain DirectX 11, stili personalizzati
  • Caricamento driver: API Service Control Manager, crea il servizio "AegisDriver" con SERVICE_DEMAND_START
  • Comunicazione: DeviceIoControl con codici IOCTL definiti in ioctl.h condiviso
  • Gestione errori: Visualizzazione base degli errori tramite MessageBox

Esempi di Codice

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

Rimozione accesso handle:

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

Gestione lista processi:

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

Comunicazione IOCTL in modalità utente:

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

Tutto il codice è accuratamente commentato con spiegazioni sui concetti del kernel, i livelli IRQL, la gestione della memoria e le potenziali insidie. Sentiti libero di consultare il sorgente: è educativo e ben documentato.

Requisiti di Build

Scarica lo strumento

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Il toolkit OSINT definitivo: grafo di indagine, punteggio di affidabilità, famiglie di alias, mappa, timeline e report. 49 moduli, oltre 400 siti, nessuna chiave API richiesta.

    790
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # App di esecuzione con un tocco GhostLock (CVE-2026-43499)

    508
  • 3

    ARTEX

    baarai/artex

    Piattaforma di penetration testing autonoma multi-agente basata su LLM con agenti planner/worker, grafi di asset e di esplorazione, registrazione del traffico MITM e retesting delle vulnerabilità.

    435
  • 4

    redforge

    cybersecurity91/redforge

    Toolkit red team lato browser con 102 strumenti offline per ricognizione, generazione di payload, attacchi alle credenziali, crittografia, codifica e reportistica dell'engagement.

    346
  • 5

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Il sistema d'azione per la cybersecurity nativa AI—dove l'intento diventa esecuzione governata, le evidenze diventano memoria operativa, e ogni operazione migliora la successiva.

    263
  • 6

    looking-glass

    anonghosty/looking-glass

    Piattaforma CSIRT che importa i report di Shadowserver in MongoDB e li riproduce come mappe interattive, analisi, risultati, avvisi e dashboard executive.

    260

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →