Process Dump

Process Dump é uma ferramenta de linha de comando de engenharia reversa do Windows para despejar componentes de memória de malware de volta para o disco para análise. Muitas vezes, arquivos de malware são empacotados e ofuscados antes de serem executados para evitar scanners de AV, no entanto, quando esses arquivos são executados, eles frequentemente desempacotam ou injetam uma versão limpa do código do malware na memória. Uma tarefa comum para pesquisadores de malware ao analisar malware é despejar esse código desempacotado da memória de volta para o disco para varredura com produtos AV ou para análise com ferramentas de análise estática como o IDA.

Process Dump funciona para sistemas operacionais Windows de 32 e 64 bits e pode despejar componentes de memória de processos específicos ou de todos os processos atualmente em execução. Process Dump suporta a criação e uso de um banco de dados de hashes limpos, para que o despejo de todos os arquivos limpos, como kernel32.dll, possa ser ignorado. Seus principais recursos incluem:

Despeja código de um processo específico ou de todos os processos.
Encontra e despeja módulos ocultos que não estão carregados corretamente nos processos.
Encontra e despeja pedaços de código soltos mesmo que não estejam associados a um arquivo PE. Ele constrói um cabeçalho PE e uma tabela de importação para os pedaços.
Reconstrói importações usando uma abordagem agressiva.
Pode executar no modo de monitor de despejo de fechamento ('-closemon'), onde os processos serão pausados e despejados pouco antes de terminarem.
Multi-thread, então quando você está despejando todos os processos em execução, será bastante rápido.
Pode gerar um banco de dados de hashes limpos. Gere isso antes de uma máquina ser infectada com malware para que o Process Dump despeje apenas os novos componentes de malware maliciosos.

Estou mantendo uma versão compilada oficial no meu site aqui: https://split-code.com/processdump.html

Instalação

Você pode baixar a versão compilada mais recente do Process Dump aqui:

https://github.com/glmcdona/Process-Dump/releases

Compilando o código-fonte

Isso foi projetado para o Visual Studio 2019 e funciona com a edição gratuita Community. Basta abrir o arquivo do projeto com o VS2019 e compilar, deve ser fácil assim!

Argumentos da linha de comando

O Process dump pode ser usado para despejar todo o código desconhecido da memória (flag '-system'), despejar processos específicos ou executar em um modo de monitoramento que despeja todos os processos pouco antes de terminarem.

Antes do primeiro uso desta ferramenta, quando na estação de trabalho limpa, o banco de dados de hashes de exclusão limpos pode ser gerado por:

pd -db genquick
pd -db gen

Exemplo de uso:

pd -system
pd -pid 419
pd -pid 0x1a3
pd -pid 0x1a3 -a 0x401000 -o c:\dump\ -c c:\dump\test\clean.db
pd -p chrome.exe
pd -p "(?i).*chrome.*"
pd -closemon

Os argumentos da linha de comando podem ser agrupados da seguinte forma:

Opções Gerais de Despejo

Opções do Banco de Dados de Hashes Limpos

Opções de Saída

Opção	Descrição
-v	Modo detalhado onde mais detalhes serão impressos para depuração.
-nh	Nenhum cabeçalho é impresso na saída.

Opções Avançadas

Exemplos de Uso

Claro, aqui está uma versão mais simplificada das informações:

Uso em Sandbox

Ao usar o Process Dump em uma sandbox automatizada ou para pesquisa manual antimalware, as etapas a seguir podem ser úteis. Certifique-se de executar todos os comandos como Administrador em um ambiente limpo.

Construa o Banco de Dados de Hashes Limpos: Execute pd64.exe -db gen ou para um processo mais rápido e menos completo, use pd64.exe -db genquick. Dependendo da sua situação, você pode querer tirar um snapshot da sua VM após criar este banco de dados de hashes limpos para que não precise ser repetido toda vez.
Inicie o Monitor de Término do Process Dump: Mantenha pd64.exe -closemon em execução em segundo plano. Ele despejará todos os processos intermediários usados pelo malware.
Execute o Arquivo de Malware: Monitore a instalação do malware. pd64.exe despejará automaticamente qualquer processo que tentar fechar.
Despeje o Malware em Execução da Memória: Quando estiver pronto, use pd64.exe -system para despejar todos os processos.

Os componentes despejados serão encontrados no diretório de trabalho do pd64.exe. Para alterar o caminho de saída, use a flag -o.

Notas sobre a convenção de nomenclatura dos módulos despejados:

'hiddemodule' no nome do arquivo em vez do nome do módulo indica que o módulo não foi registrado corretamente no processo.
'codechunk' no nome do arquivo significa que é um despejo reconstruído de uma região executável solta. Isso pode ser, por exemplo, código injetado que não tinha um cabeçalho PE. Codechunks serão despejados duas vezes, uma vez com um cabeçalho x86 reconstruído e novamente com um cabeçalho x64 reconstruído.

Exemplos de nomes de arquivos de arquivos despejados

notepad_exe_PID2990_hiddenmodule_16B8ABB0000_x86.dll
notepad_exe_PID3b5c_notepad.exe_7FF6E6630000_x64.exe
notepad_exe_PID2c54_codechunk_17BD0000_x86.dll
notepad_exe_PID2c54_codechunk_17BD0000_x64.dll

Histórico de versões

Versão 2.1 (12 de fevereiro de 2017)

Corrigido um bug onde a última seção em alguns casos era preenchida com zeros. Agradecimentos ao megastupidmonkey por relatar este problema.
Corrigido um bug onde endereços de base de 64 bits eram truncados para um endereço de 32 bits. Agora mantém corretamente o endereço de base completo do módulo de 64 bits. Agradecimentos ao megastupidmonkey por relatar este problema.
Corrigido um problema onde o monitor de despejo de fechamento de processos travava csrss.exe.
Impediu que o Process Dump hooke seu próprio processo no modo de monitor de fechamento.

Versão 2.0 (18 de setembro de 2016)

Adicionada nova flag '-closemon' que executa o Process Dump em um modo de monitoramento. Ele pausará e despejará qualquer processo assim que ele fechar. Isso foi projetado para funcionar bem com sandboxes de análise de malware, para garantir o despejo do malware da memória antes que o processo malicioso feche.
Atualizado o Process Dump para ser multi-thread. Comandos que despejam ou obtêm hashes de vários processos executarão threads separadas por operação. O número padrão de threads é 16, o que acelera significativamente o processamento geral de despejo do Process Dump.
Atualizado o Process Dump para despejar pedaços de código não anexados encontrados na memória. Eles são identificados como regiões executáveis na memória que não estão anexadas a um módulo e não possuem cabeçalho PE. Também exige que o codechunk se refira a pelo menos 2 importações para ser considerado válido, a fim de reduzir ruído. Quando despejado, um cabeçalho PE é recriado junto com uma tabela de importação. Os code chunks são totalmente suportados pelo banco de dados de hashes limpos.
Adicionadas flags para controlar o caminho do arquivo para o banco de dados de hashes limpos, bem como a pasta de saída para arquivos despejados.
Correção na geração do banco de dados de hashes limpos a partir do caminho do usuário que estava causando uma falha.
Correção na flag '-g' que força a geração de cabeçalhos PE. Antes, mesmo se essa flag fosse definida, os despejos de sistema (-system) ignoravam essa flag ao despejar um processo.
Várias melhorias de desempenho.
Projeto atualizado para VS2015.

Versão 1.5 (21 de novembro de 2015)

Corrigido bug onde regiões de memória muito grandes faziam o Process Dump travar.
Corrigido bug onde alguns módulos em endereços altos não eram encontrados no Windows de 64 bits.
Mais informações de depuração agora são exibidas no modo Verbose.

Versão 1.4 (18 de abril de 2015)

Adicionada nova abordagem de reconstrução de importação agressiva. Agora corrige todos os DWORDs e QWORDs no módulo para a correspondência de exportação correspondente.
Adicionada flag '-a (endereço para despejar)' para despejar um endereço específico. Ele gerará cabeçalhos PE e construirá uma tabela de importação para o endereço.
Adicionada flag '-ni' para pular o novo algoritmo de reconstrução de importação.
Adicionada flag '-g' para forçar a geração de um novo cabeçalho PE mesmo que exista um ao despejar um módulo. Isso é bom se o cabeçalho PE estiver malformado, por exemplo.
Várias correções de bugs.

Versão 1.3 (10 de outubro de 2013)

Melhor tratamento de cabeçalhos PE com seções que especificam tamanhos e endereços virtuais inválidos.
Melhor metodologia de despejo de módulos para despejar seções virtuais em seções de disco.

Versão 1.1 (8 de abril de 2013)

Corrigido um problema de compatibilidade com o Windows XP.
Corrigido bug onde o process dump imprimia que estava despejando um módulo, mas não despejava realmente.
Implementada a flag de despejo '-pid'.

Versão 1.0 (2 de abril de 2013)

Lançamento inicial.

-system	Despeja todos os módulos que não correspondem ao banco de dados de hashes limpos de todos os processos acessíveis no diretório de trabalho.
-pid <pid>	Despeja todos os módulos que não correspondem ao banco de dados de hashes limpos do PID especificado no diretório de trabalho atual. Use um prefixo '0x' para especificar um PID hexadecimal.
-closemon	Executa no modo de monitor. Quando qualquer processo estiver terminando, o process dump primeiro despejará o processo.
-p <regex process name>	Despeja todos os módulos que não correspondem ao banco de dados de hashes limpos do nome do processo encontrado para corresponder ao filtro no PID especificado no diretório de trabalho atual.
-a <module base address>	Despeja um módulo no endereço base especificado do processo.
-o <path>	Define a pasta raiz de saída padrão para componentes despejados.

-db gen	Processa automaticamente algumas pastas comuns, bem como todos os processos atualmente em execução e adiciona os hashes de módulos encontrados ao banco de dados de hashes limpos. Ele adicionará todos os arquivos recursivamente em: `%WINDIR%`, `%HOMEPATH%`, `C:\Program Files\`, `C:\Program Files (x86)\`, bem como todos os módulos em todos os processos em execução. Esses hashes limpos serão adicionados ao arquivo `clean.hashes` no diretório do aplicativo. Durante comandos futuros de despejo de processos, esses módulos conhecidos não serão despejados. Recomenda-se executar este comando uma vez em um sistema limpo antes de usar a ferramenta para que não muitos módulos sejam despejados da memória.
-db genquick	O mesmo que acima, mas apenas adiciona os hashes de todos os módulos em todos os processos ao banco de dados de hashes limpos. Esta é uma maneira muito mais rápida de construir o banco de dados de hashes limpos, mas será menos completo.
-db add <dir>	Adiciona todos os arquivos no diretório especificado recursivamente ao banco de dados de hashes limpos.
-db rem <dir>	Remove todos os arquivos no diretório especificado recursivamente do banco de dados de hashes limpos.
-nr	Desabilita a recursão nos comandos de adicionar ou remover diretório do banco de dados de hashes.
-db clean	Limpa o banco de dados de hashes limpos.
-db ignore	Ignora o banco de dados de hashes limpos ao despejar um processo desta vez. Todos os módulos serão despejados mesmo se uma correspondência for encontrada.
-cdb <filepath>	Caminho completo do arquivo para o banco de dados de hashes limpos a ser usado nesta execução se você quiser substituir o padrão `clean.hashes`.
-edb <filepath>	Caminho completo do arquivo para o banco de dados de hashes de ponto de entrada a ser usado nesta execução.
-esdb <filepath>	Caminho completo do arquivo para o banco de dados de hashes curtos de ponto de entrada a ser usado nesta execução.

-g	Força a geração de cabeçalhos PE do zero, ignorando cabeçalhos existentes.
-eprec	Força o ponto de entrada a ser reconstruído, mesmo que um válido pareça existir.
-ni	Desabilita a reconstrução de importações.
-nc	Desabilita o despejo de regiões de código soltas.
-nt	Desabilita multithreading.
-nep	Desabilita o hash do ponto de entrada.
-t <thread count>	Define o número de threads a serem usados (padrão 16).

`pd64.exe -db genquick`	Construa rapidamente o banco de dados de módulos limpos com base nos processos em execução atualmente. O Process Dump em tarefas posteriores despejará apenas módulos não reconhecidos.
`pd64.exe -system`	Despeje todos os módulos e pedaços ocultos de todos os processos ignorando módulos limpos.
`pd64.exe -closemon`	Execute no modo de monitor de término. Isso despejará todos os processos quando eles tentarem terminar.
`pd64.exe -pid 0x18A`	Despeje módulos e pedaços ocultos de um ID de processo específico.
`pd64.exe -p .\chrome.\`	Despeje módulos e pedaços ocultos pelo nome do processo.
`pd64.exe -db gen`	Construa um banco de dados de hashes limpos de módulos conhecidos. Isso é usado para evitar despejar módulos bons conhecidos em tarefas posteriores.
`pd64.exe -pid 0x1a3 -a 0xffb4000`	Despeje código de um endereço específico no PID. Isso gerará dois arquivos para análise, com cabeçalhos PE reconstruídos de 32 bits e 64 bits: `notepad_exe_x64_hidden_FFB40000.exe` e `notepad_exe_x86_hidden_FFB40000.exe`.

Process-Dump

Mais Populares