Processo Herpaderping

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.

Resumo

Geralmente, um produto de segurança age na criação de processos registrando um callback no Kernel do Windows (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 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.

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, 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 ocorrerá aqui.
   • Como ocultamos o conteúdo do que está executando, a inspeção nesse momento resultará em atribuição incorreta.

@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.

Aprofundando

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

Mergulho Técnico Detalhado

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:

Podemos ver as diferenças aqui. Embora Herpaderping seja indiscutivelmente mais ruidoso que Doppelganging, no sentido de que os bits maliciosos realmente atingem o disco, vimos que os produtos de segurança ainda são incapazes de detectar Herpaderping.

Possível Solução

Não há uma correção clara aqui. Parece razoável que impedir que uma seção de imagem seja mapeada/armazenada em cache quando há acesso de gravação ao arquivo deve fechar a brecha. No entanto, isso pode ou não ser uma solução prática.

Outra opção pode ser descarregar as alterações no arquivo para a seção de imagem em cache se ela ainda não foi mapeada em um processo. No entanto, como o mapeamento no novo processo ocorre em NtCreateProcess, isso provavelmente não é uma solução viável.

Do ponto de vista da detecção, não há uma boa maneira de identificar os bits reais que foram mapeados; a inspeção em IRP_MJ_CLEANUP ou em um callback registrado em PsSetCreateProcessNotifyRoutineEx resulta em atribuição incorreta, pois os bits no disco foram alterados; você teria que reconstruir o arquivo a partir da seção que foi criada. Vale a pena notar aqui que há um novo callback no Windows 10 que você pode registrar para PsSetCreateProcessNotifyRoutineEx2; no entanto, ele sofre do mesmo problema do callback anterior: é chamado quando a thread inicial é executada, não quando o objeto de processo é criado. A Microsoft adicionou PsSetCreateThreadNotifyRoutineEx, que é chamado quando a thread inicial é inserida se registrado com PsCreateThreadNotifyNonSystem, ao contrário de quando está prestes a começar a execução (como fazia o callback antigo). Estender PSCREATEPROCESSNOTIFYTYPE para ser chamado quando o objeto de processo é criado também não ajudará; vimos na seção Aprofundando que o objeto de seção de imagem é armazenado em cache na chamada NtCreateSection, não em NtCreateProcess.

Não podemos identificar facilmente o que foi executado. Resta-nos tentar detectar o comportamento exploratório pelo ator; deixo a descoberta dos indicadores de comportamento como exercício para o leitor.

Plataformas Conhecidas Afetadas

Abaixo está uma lista de produtos e SOs Windows que foram testados em (31/08/2020). Os testes foram realizados com um binário conhecido como malicioso.

Divulgação Responsável

Esta vulnerabilidade foi divulgada ao Microsoft Security Response Center (MSRC) em 17/07/2020 e um caso foi aberto pelo MSRC em 22/07/2020. O MSRC concluiu sua investigação em 25/08/2020 e determinou que as descobertas são válidas, mas não atendem ao seu critério para manutenção imediata. Neste momento, o caso deles está encerrado, sem resolução, e marcado para revisão futura, sem prazo.

Discordamos da gravidade deste bug; isso foi comunicado ao MSRC em 27/08/2020.

1. Existem vulnerabilidades semelhantes nesta classe (Hollowing e Doppelganging).
2. A vulnerabilidade demonstra que derrota recursos de segurança inerentes ao SO (Windows Defender).
3. A vulnerabilidade permite que um ator obtenha execução de código arbitrário.
4. O usuário não é notificado da execução de código não intencional.
5. As informações do processo apresentadas ao usuário não refletem com precisão o que está sendo executado.
6. As facilidades para identificar com precisão o processo não são intuitivas ou estão incorretas, mesmo a partir do kernel.

Fonte

Este repositório contém uma ferramenta para exercitar o método Herpaderping de ofuscação de processos. O uso é o seguinte:

Process Herpaderping Tool - Copyright (c) Johnny Shaw
ProcessHerpaderping.exe SourceFile TargetFile [ReplacedWith] [Options...]
Usage:
  SourceFile               Source file to execute.
  TargetFile               Target file to execute the source from.
  ReplacedWith             File to replace the target with. Optional,
                           default overwrites the binary with a pattern.
  -h,--help                Prints tool usage.
  -d,--do-not-wait         Does not wait for spawned process to exit,
                           default waits.
  -l,--logging-mask number Specifies the logging mask, defaults to full
                           logging.
                               0x1   Successes
                               0x2   Informational
                               0x4   Warnings
                               0x8   Errors
                               0x10  Contextual
  -q,--quiet               Runs quietly, overrides logging mask, no title.
  -r,--random-obfuscation  Uses random bytes rather than a pattern for
                           file obfuscation.
  -e,--exclusive           Target file is created with exclusive access and
                           the handle is held open as long as possible.
                           Without this option the handle has full share
                           access and is closed as soon as possible.
  -u,--do-not-flush-file   Does not flush file after overwrite.
  -c,--close-file-early    Closes file before thread creation (before the
                           process notify callback fires in the kernel).
                           Not valid with "--exclusive" option.
  -k,--kill                Terminates the spawned process regardless of
                           success or failure, this is useful in some
                           automation environments. Forces "--do-not-wait
                           option.

Clonagem e Compilação

O repositório usa submódulos; após clonar, certifique-se de inicializar e atualizar os submódulos. Os arquivos de projeto são direcionados ao Visual Studio 2019.

git clone https://github.com/jxy-s/herpaderping.git
cd .\herpaderping\
git submodule update --init --recursive
MSBuild .\herpaderping.sln

Créditos

Os seguintes são usados sem modificação. Créditos aos seus autores.

• Windows Implementation Libraries (WIL)
  Uma biblioteca C++ somente de cabeçalho criada para facilitar a vida dos desenvolvedores no Windows por meio de interfaces C++ legíveis e type-safe para padrões comuns de codificação do Windows.
• Process Hacker Native API Headers
  Coleção de arquivos de cabeçalho da API nativa. Reunidos a partir de arquivos de cabeçalho da Microsoft e arquivos de símbolo, além de muita engenharia reversa e suposições.