NativeMirror

NativeMirror é uma implementação independente em Object Pascal da funcionalidade do PE-sieve, adaptada do PE-sieve de hasherezade. Ele examina a memória de processos, detecta código modificado ou injetado e faz dump de arquivos PE.

A implementação usa APIs nativas do Delphi e o NativePe como seu motor de PE. Pode ser usada diretamente como uma biblioteca Delphi, através de sua CLI, ou através de uma interface DLL compatível com o PE-sieve. Todas as três compartilham o mesmo núcleo do scanner. O alvo de compatibilidade é o comportamento externamente observável do PE-sieve 0.4.1.5; a equivalência comportamental completa não foi estabelecida.

Requisitos

• Windows e Delphi 12, com suporte aos compiladores Win32 e Win64.
• NativePe: biblioteca de PE necessária. Coloque-a ao lado do NativeMirror como ../NativePe, ou ajuste os caminhos de busca do Delphi.
• NativeASM: backend opcional de desmontagem para Win64. O projeto NativeMirrorScan.NativeAsm.dproj habilita USE_NATIVEASM. Sem ele, o NativeMirror usa o fallback Delphi/LDE. Ajuste o caminho de busca do NativeASM para a sua instalação.
• Python 3 com o lançador py do Windows: necessário para a etapa pós-build da DLL e para os testes em Python. Os scripts usam a biblioteca padrão do Python.
• DUnitX: necessário para compilar os executores de teste do Delphi. Disponibilize suas units no caminho de busca do Delphi.
• CMake e Visual Studio 2022 com ferramentas C++: necessários apenas para os testes de contrato da DLL.

Algumas configurações de projeto contêm caminhos de dependências locais. Verifique os caminhos de busca antes de compilar em outra máquina.

Compilação

Abra NativeMirror.groupproj no Delphi e selecione o projeto, a plataforma e a configuração necessários.

Projeto	Saída
tools/NativeMirrorScan/NativeMirrorScan.dproj	NativeMirrorScan.exe
tools/NativeMirrorDll/pe-sieve.dproj	pe-sieve.dll
tests/ScannerIntegration/NativeMirrorTestTarget.dproj	Alvo de teste Win64
tests/ScannerIntegration/NativeMirrorTestTarget32.dproj	Alvo de teste Win32
tests/ScannerIntegration/NativeMirrorScannerTests.dproj	Executor de testes do scanner Win64
tests/HollowsHunterIntegration/NativeMirrorHollowsHunterTests.dproj	Executor de testes do HollowsHunter Win64

Compile a CLI e a DLL para Win32 e Win64 conforme necessário. Compile ambos os alvos de teste antes de executar os testes de integração. Compile os executores de teste para Win64.

As saídas vão para bin/<Platform>/<Config>. Os exemplos abaixo usam Debug. As units compiladas vão para dcu/. Mantenha os executáveis fora de tools/.

Executar o scanner

Execute estes comandos a partir da raiz do projeto. Substitua 1234 pelo ID do processo a ser examinado.

.\bin\Win64\Debug\NativeMirrorScan.exe /help
.\bin\Win64\Debug\NativeMirrorScan.exe /pid 1234
.\bin\Win64\Debug\NativeMirrorScan.exe /pid 1234 /json /quiet /ofilter 2
.\bin\Win64\Debug\NativeMirrorScan.exe /pid 1234 /dir output

/ofilter 2 desativa a saída de dump. /dir output seleciona o diretório de saída para relatórios e dumps. Use o executável Win32 em bin/Win32/Debug quando necessário. O acesso ao processo alvo depende das suas permissões do Windows.

Usar diretamente a partir do Delphi

Adicione src/ e os seus subdiretórios de unidades, juntamente com NativePe, ao caminho de pesquisa do seu projeto. Chame ScanAndDump com TNativeMirrorOptions. A biblioteca é compilada na sua aplicação; esta utilização não requer nem NativeMirrorScan.exe nem pe-sieve.dll. O Python só é necessário para a compilação separada da DLL e para os testes em Python.

Este exemplo de consola analisa o PID 1234 e imprime o seu relatório como JSON:

program ScanExample;

{$APPTYPE CONSOLE}

uses
  System.JSON,
  NativeMirror.Core.Types,
  NativeMirror.Core.Options,
  NativeMirror.Core.Engine;

var
  Options: TNativeMirrorOptions;
  Report: TNativeMirrorReportEx;
  Json: TJSONObject;
begin
  Options := TNativeMirrorOptions.Default;
  Options.Pid := 1234;
  Options.Quiet := True;
  Options.OutputFilter := nmOutNoDir;
  Report := ScanAndDump(Options);
  try
    Json := Report.ToJson(Options.ResultsFilter, Options.JsonLevel);
    try
      Writeln(Json.ToJSON);
    finally
      Json.Free;
    end;
  finally
    Report.Free;
  end;
end.

Substitua o PID pelo seu alvo. nmOutNoDir desativa arquivos de relatório e dumps. Inspecione Report.ErrorReport para erros de varredura e Report.ScanReport para resultados da varredura. O chamador é o proprietário do relatório retornado e deve liberá-lo.

Arquivos em bin

Baixe pe-sieve32.exe e pe-sieve64.exe das versões do PE-sieve. Os scripts de comparação existentes usam os executáveis v0.4.1.1. Coloque ambos em bin/Win64/Debug; os scripts de teste Win64 procuram seu scanner de referência lá. O executável 32 é a referência Win32 original, embora esteja armazenado junto com as ferramentas de teste Win64.

Uma configuração Debug se parece com isto:

bin/
  Win64/Debug/
    NativeMirrorScan.exe
    pe-sieve.dll
    pe-sieve.dll.exports.json
    pe-sieve32.exe
    pe-sieve64.exe
    NativeMirrorTestTarget.exe
    NativeMirrorScannerTests.exe
    NativeMirrorHollowsHunterTests.exe
    hollows_hunter.exe
  Win32/Debug/
    NativeMirrorScan.exe
    pe-sieve.dll
    pe-sieve.dll.exports.json
    NativeMirrorTestTarget32.exe

NativeMirror produz a CLI, a DLL, os registros de exportação, os targets e os executores de teste. Os executáveis PE-sieve e HollowsHunter são downloads separados. O HollowsHunter só é necessário para o seu teste de integração ou para uso manual da DLL.

HollowsHunter: use a build da DLL

Baixe hollows_hunter64_dll.zip, v0.4.1.1 a partir das releases do HollowsHunter. Use o pacote da DLL. Com uma arquitetura de host e um contrato de API compatíveis, a pe-sieve.dll finalizada do NativeMirror substitui a DLL original do PE-sieve usada pelo HollowsHunter. O executável estático autônomo não pode usar uma DLL substituta. O teste de integração fornecido cobre o host DLL Win64 v0.4.1.1.

Para uma execução manual, copie o hollows_hunter.exe do pacote para bin/Win64/Debug, ao lado da pe-sieve.dll compilada pelo NativeMirror. Não copie a DLL original do pacote sobre a DLL do NativeMirror. Tanto o host quanto a DLL devem ser Win64.

.\bin\Win64\Debug\hollows_hunter.exe /pid 1234 /quiet /hooks /ofilter 2 /json /report 7

Para a comparação automatizada, extraia o EXE e a DLL originais inalterados do mesmo pacote para:

tests/HollowsHunterIntegration/fixtures/Win64/pe-sieve-C/
  hollows_hunter.exe
  pe-sieve.dll
  manifest.json

Mantenha o manifest.json existente. Ele registra as versões esperadas e os hashes SHA-256. O runner verifica esses arquivos, copia o mesmo host para diretórios de referência e NativeMirror separados, e testa cada DLL contra processos de teste controlados. Ele não baixa arquivos nem sobrescreve a build em bin.

Por que a build da DLL usa Python

O PE-sieve exporta PESieve_version como um valor de dados de 32 bits. Para a versão 0.4.1.5, esse valor é 0x00040105. Um chamador espera que o endereço de exportação aponte para esses quatro bytes, em vez de para uma função que retorna o número.

O compilador/linker Delphi 12 usado por este projeto não exporta a variável diretamente através da cláusula exports. A DLL, portanto, contém o valor de versão marcado e inicialmente exporta uma função auxiliar sob o nome exigido.

Após a vinculação, o evento pós-build do projeto executa:

py tools/NativeMirrorDll/finalize_exports.py bin/Win64/Debug/pe-sieve.dll