Processo Herpaderping

[][png.HerpaderpIcon] O Process Herpaderping é um método de obscurecer as intenções de um processo modificando o conteúdo em disco após a imagem ter sido mapeada. Isso resulta em um comportamento curioso por parte dos produtos de segurança e do próprio SO.

![][png.mimioogle]

![][gif.SurivDemo]

Resumo

Geralmente, um produto de segurança age na criação de processos registrando um callback no Kernel do Windows ([PsSetCreateProcessNotifyRoutineEx][msdn.PsSetCreateProcessNotifyRoutineEx]). Nesse ponto, um produto de segurança pode inspecionar o arquivo que foi usado para mapear o executável e determinar se esse processo deve ser autorizado a executar. Esse callback do kernel é invocado quando a thread inicial é inserida, não quando o objeto de processo é criado.

Por causa disso, um ator pode criar e mapear um processo, modificar o conteúdo do arquivo e, em seguida, criar a thread inicial. Um produto que faz inspeção no callback de criação veria o conteúdo modificado. Além disso, alguns produtos usam uma abordagem de varredura na escrita que consiste em monitorar as gravações de arquivos. Uma otimização familiar aqui é registrar que o arquivo foi escrito e adiar a inspeção real até que [IRP_MJ_CLEANUP][msdn.IRP_MJ_CLEANUP] ocorra (por exemplo, o handle do arquivo é fechado). Assim, um ator usando um fluxo de trabalho escrever -> mapear -> modificar -> executar -> fechar irá subverter a varredura na escrita que depende apenas da inspeção em [IRP_MJ_CLEANUP][msdn.IRP_MJ_CLEANUP].

Para abusar dessa convenção, primeiro escrevemos um binário em um arquivo alvo no disco. Em seguida, mapeamos uma imagem do arquivo alvo e a fornecemos ao SO para usar na criação do processo. O SO gentilmente mapeia o binário original para nós. Usando o handle de arquivo existente, e antes de criar a thread inicial, modificamos o conteúdo do arquivo alvo para obscurecer ou falsificar o arquivo que está por trás da imagem. Algum tempo depois, criamos a thread inicial para iniciar a execução do binário original. Finalmente, fecharemos o handle do arquivo alvo. Vamos percorrer isso passo a passo:

1. Escrever o binário alvo no disco, mantendo o handle aberto. Isso é o que será executado na memória.
2. Mapear o arquivo como uma seção de imagem ([NtCreateSection][msdn.NtCreateSection], [SEC_IMAGE][msdn.SEC_IMAGE]).
3. Criar o objeto de processo usando o handle da seção (NtCreateProcessEx).
4. Usando o mesmo handle do arquivo alvo, obscurecer o arquivo em disco.
5. Criar a thread inicial no processo (NtCreateThreadEx).
   • Nesse ponto, o callback de criação de processo no kernel será disparado. O conteúdo em disco não corresponde ao que foi mapeado. A inspeção do arquivo nesse momento resultará em atribuição incorreta.
6. Fechar o handle. [IRP_MJ_CLEANUP][msdn.IRP_MJ_CLEANUP] ocorrerá aqui.
   • Como ocultamos o conteúdo do que está executando, a inspeção nesse momento resultará em atribuição incorreta.

![][svg.StateDiagram]

@startuml
hide empty description

[*] --> CreateFile
CreateFile --> FileHandle
FileHandle --> Write
FileHandle --> NtCreateSection
Write -[hidden]-> NtCreateSection
NtCreateSection --> SectionHandle
SectionHandle --> NtCreateProcessEx
FileHandle --> Modify
NtCreateProcessEx -[hidden]-> Modify
NtCreateProcessEx --> NtCreateThreadEx
Modify -[hidden]-> NtCreateThreadEx
NtCreateThreadEx --> [*]
FileHandle --> CloseFile
NtCreateThreadEx -[hidden]-> CloseFile
NtCreateThreadEx --> PspCallProcessNotifyRoutines
PspCallProcessNotifyRoutines -[hidden]-> [*]
CloseFile --> IRP_MJ_CLEANUP
IRP_MJ_CLEANUP -[hidden]-> [*]
PspCallProcessNotifyRoutines --> Inspect
PspCallProcessNotifyRoutines -[hidden]-> CloseFile 
IRP_MJ_CLEANUP --> Inspect
Inspect -[hidden]-> [*]

CreateFile : Create target file, keep handle open.
Write : Write source payload into target file.
Modify : Obscure the file on disk.
NtCreateSection : Create section using file handle.
NtCreateProcessEx : Image section for process is mapped and cached in file object.
NtCreateThreadEx : The cached section is used.
NtCreateThreadEx : Process notify routines fire in kernel.
Inspect : The contents on disk do not match what was executed. 
Inspect : Inspection of the file at this point will result in incorrect attribution.
@enduml

Comportamento

Você verá na demonstração abaixo que CMD.exe é usado como alvo de execução. A primeira execução sobrescreve os bytes no disco com um padrão. A segunda execução sobrescreve CMD.exe com ProcessHacker.exe. A ferramenta Herpaderping corrige o binário para se parecer o máximo possível com ProcessHacker.exe, mantendo até mesmo a assinatura original. Observe as múltiplas execuções do mesmo binário e como o processo se apresenta para o usuário em comparação com o que está no arquivo em disco.

![][gif.ProcessHerpaderp]

![][png.procmon]

Aprofundando

Observamos o comportamento e parte disso pode ser surpreendente. Vamos tentar explicar esse comportamento.

[Mergulho Técnico Detalhado][md.DivingDeeper]

Histórico e Motivação

Ao projetar produtos para proteger plataformas Windows, muitos engenheiros nessa área (eu incluso) caíram em noções preconcebidas sobre como o SO lida com dados. Nesse cenário, alguns podem esperar que o arquivo no disco permaneça "travado" quando o processo é criado. Você não pode excluir o arquivo. Você não pode escrever nele. Mas você pode renomeá-lo. Visto aqui, sob as condições certas, você pode de fato escrever nele. Mantenha-se vigilante sobre suas suposições, sempre questione-as e faça sua pesquisa.

A motivação para esta pesquisa surgiu ao descobrir como fazer análise quando um arquivo é escrito. Com um conhecimento prévio pesquisando sobre Process Hollowing e Doppelganging, eu teorizei que isso poderia ser possível. O objetivo é fornecer melhor segurança. Você não pode criar uma fechadura melhor sem primeiro entender como quebrar a antiga.

Técnicas Semelhantes

Herpaderping é semelhante a Hollowing e Doppelganging, no entanto, existem algumas diferenças importantes:

Process Hollowing

O Process Hollowing envolve modificar a seção mapeada antes do início da execução, o que abstratamente se parece com: mapear -> modificar seção -> executar. Esse fluxo de trabalho resulta em que o fluxo de execução pretendido do processo Hollowed diverge para código não intencional. Doppelganging pode ser considerado uma forma de Hollowing. No entanto, Hollowing, na minha opinião, está mais próximo de injeção, pois Hollowing geralmente envolve uma escrita explícita no código já mapeado. Isso difere do Herpaderping, onde não há seções modificadas.

Process Doppelganging

O Process Doppelganging está mais próximo do Herpaderping. Doppelganging abusa de operações de arquivo transacionadas e geralmente envolve estas etapas: transacionar -> escrever -> mapear -> reverter -> executar. Nesse fluxo de trabalho, o SO criará a seção de imagem e considerará as transações, então a seção de imagem em cache acaba sendo o que você escreveu na transação. O SO corrigiu essa técnica. Bem, eles corrigiram a falha que causava. Talvez considerem isso um uso "legal" de uma transação. Felizmente, o Windows Defender detecta a técnica Doppelganging. Doppelganging difere do Herpaderping porque Herpaderping não depende de operações de arquivo transacionadas. E o Defender não detecta Herpaderping.

Comparação

Para referência, as técnicas generalizadas: