Analisador de tabela de importação PE

Analisador de tabela de importação PE

O formato Executável Portátil (PE)

O formato Portable Executable (PE) é o formato de arquivo padrão usado pelo Windows para executáveis como .exe and .dll. Foi introduzido com Windows NT (1993) e se tornou o layout unificado para ambos 32 bits e 64 bits programas.Um conhecimento sólido dos componentes internos do PE é um pré-requisito para a construção de ferramentas de segurança no Windows, incluindo mecanismos antivírus, analisadores estáticos, desempacotadores e utilitários de resposta a incidentes.

PE em resumo

Um arquivo PE típico contém:

  • Cabeçalho DOS (IMAGE_DOS_HEADER) para compatibilidade herdada e para localizar o cabeçalho NT.
  • Cabeçalhos NT (IMAGE_NT_HEADERS32/64), que incluem:
    • IMAGE_FILE_HEADER
    • IMAGE_OPTIONAL_HEADER32/64 (o nome é histórico, é efetivamente obrigatório para imagens PE)
  • Tabela de seção (matriz de IMAGE_SECTION_HEADER)
  • Seções como .text, .rdata, .data, .rsrc, etc.
  • Diretórios de dados (importação, exportação, recursos, relocações, depuração, TLS,…) A maioria das estruturas e constantes relacionadas ao PE são declaradas em WinNT.h.

IMAGE_DOS_HEADER

IMAGE_DOS_HEADER é uma estrutura legada para compatibilidade com MS-DOS. Na prática, os dois campos mais importantes são:

  • e_magicAssinatura que identifica o cabeçalho do DOS. Para arquivos PE deve ser 0x5A4D que corresponde a ASCII "MZ" (IMAGE_DOS_SIGNATURE).
  • e_lfanewDeslocamento do arquivo (do início do arquivo) até o Cabeçalhos NT (IMAGE_NT_HEADERS).
typedef struct _IMAGE_DOS_HEADER {
  WORD  e_magic;    // 0x5A4D ("MZ")
  WORD  e_cblp;
  WORD  e_cp;
  WORD  e_crlc;
  WORD  e_cparhdr;
  WORD  e_minalloc;
  WORD  e_maxalloc;
  WORD  e_ss;
  WORD  e_sp;
  WORD  e_csum;
  WORD  e_ip;
  WORD  e_cs;
  WORD  e_lfarlc;
  WORD  e_ovno;
  WORD  e_res[4];
  WORD  e_oemid;
  WORD  e_oeminfo;
  WORD  e_res2[10];
  DWORD e_lfanew;   // offset of IMAGE_NT_HEADERS
} IMAGE_DOS_HEADER, *PIMAGE_DOS_HEADER;

MZ and e_lfanew

História da assinatura "MZ"

No início da década de 1980, o MS-DOS precisava de um método simples para distinguir arquivos executáveis de outros tipos de arquivos. O “número mágico” MZ foi escolhido e escrito no início dos executáveis. Hoje essa assinatura permanece como parte da compatibilidade do PE. Está armazenado em IMAGE_DOS_HEADER.e_magic as 0x5A4D.

IMAGE_NT_HEADERS (32 e 64)

Os cabeçalhos do NT foram introduzidos com Windows NT para padronizar o carregamento de executáveis. Existem duas formas:

typedef struct _IMAGE_NT_HEADERS32 {
  DWORD Signature;
  IMAGE_FILE_HEADER FileHeader;
  IMAGE_OPTIONAL_HEADER32 OptionalHeader;
} IMAGE_NT_HEADERS32, *PIMAGE_NT_HEADERS32;
typedef struct _IMAGE_NT_HEADERS64 {
  DWORD Signature;
  IMAGE_FILE_HEADER FileHeader;
  IMAGE_OPTIONAL_HEADER64 OptionalHeader;
} IMAGE_NT_HEADERS64, *PIMAGE_NT_HEADERS64;

NT headers layout

IMAGE_FILE_HEADER

IMAGE_FILE_HEADER descreve a imagem em alto nível: arquitetura, número de seções, carimbo de data/hora e atributos. Documentação da Microsoft:

typedef struct _IMAGE_FILE_HEADER {
  WORD  Machine;
  WORD  NumberOfSections;
  DWORD TimeDateStamp;
  DWORD PointerToSymbolTable;
  DWORD NumberOfSymbols;
  WORD  SizeOfOptionalHeader;
  WORD  Characteristics;
} IMAGE_FILE_HEADER, *PIMAGE_FILE_HEADER;

Campos principais:

  • MachineArquitetura alvo CPU (por exemplo IMAGE_FILE_MACHINE_I386, IMAGE_FILE_MACHINE_AMD64).
  • NumberOfSectionsContagem de cabeçalhos de seção a seguir.
  • TimeDateStampSegundos da época UNIX. Útil para depuração, controle de versão e triagem.
  • SizeOfOptionalHeaderTamanho da estrutura de cabeçalho opcional.
  • CharacteristicsBandeiras como:
    • IMAGE_FILE_EXECUTABLE_IMAGE
    • IMAGE_FILE_DLL
    • IMAGE_FILE_32BIT_MACHINE
    • IMAGE_FILE_DEBUG_STRIPPED

IMAGE_OPTIONAL_HEADER (32 e 64)

Apesar do nome, este cabeçalho é essencial. Ele contém informações de layout de memória, ponto de entrada, alinhamentos, subsistema e o Diretório de dados matriz. Documentação da Microsoft:

IMAGE_SECTION_HEADER

Um PE é dividido em sections, cada um descrito por IMAGE_SECTION_HEADER. As seções são as unidades de mapeamento fundamentais usadas pela carregadeira e pelas ferramentas. Documentação da Microsoft:

#pragma pack(push, 1)
typedef struct _IMAGE_SECTION_HEADER {
  BYTE  Name[IMAGE_SIZEOF_SHORT_NAME];  // 8
  union {
    DWORD PhysicalAddress;
    DWORD VirtualSize;
  } Misc;
  DWORD VirtualAddress;
  DWORD SizeOfRawData;
  DWORD PointerToRawData;
  DWORD PointerToRelocations;
  DWORD PointerToLinenumbers;
  WORD  NumberOfRelocations;
  WORD  NumberOfLinenumbers;
  DWORD Characteristics;
} IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER;
#pragma pack(pop)

Nomes de seção típicos:

  • .text código executável
  • .rdata dados somente leitura
  • .data dados graváveis inicializados
  • .bss dados não inicializados (geralmente apenas virtuais)
  • .rsrc recursos Imagens do artigo:
  • Section header overview
  • Sections in a file
  • Section characteristics

VirtualAddress vs PhysicalAddress (deslocamento de arquivo)

Em um PE, muitos campos são expressos como RVA (Endereço virtual relativo). RVA é um endereço relativo à base do módulo na memória. No disco, os dados são localizados por deslocamentos de arquivo.Se você precisar acessar algo no disco usando um RVA, deverá convertê-lo usando uma tradução RVA para deslocamento de arquivo (geralmente chamada rva2offset).RVA vs file offset

Importações

Quando um executável depende de funções externas (por exemplo, de user32.dll ou DLLs de terceiros), ele lista essas dependências no arquivo Diretório de importação.O carregador Windows resolve as importações no momento do carregamento e preenche o Tabela de Endereços de Importação (IAT) com ponteiros de função reais. Os compiladores normalmente geram chamadas indiretas por meio do IAT.Import table concept

IMAGE_IMPORT_DIRECTORY (tabela de diretório de importação)

O diretório de importação é uma sequência de IMAGE_IMPORT_DESCRIPTOR estruturas. Cada descritor descreve uma DLL importada.

typedef struct _IMAGE_IMPORT_DESCRIPTOR {
  union {
    DWORD Characteristics;        // 0 for terminating null import descriptor
    DWORD OriginalFirstThunk;     // RVA to unbound IAT (lookup table)
  } DUMMYUNIONNAME;
  DWORD TimeDateStamp;
  DWORD ForwarderChain;
  DWORD Name;                    // RVA to DLL name
  DWORD FirstThunk;              // RVA to IAT (addresses after binding)
} IMAGE_IMPORT_DESCRIPTOR;

Visualização do artigo:

  • OriginalFirstThunk/FirstThunk tables
  • Imported function name strings

Como funciona a chamada de importação

Chamadas típicas de saída do compilador por meio de uma célula que o carregador preenche uma vez:

; x86
call dword ptr [_cell_with_address_of_function]
; x64
call qword ptr [_cell_with_address_of_function]

IAT callO carregador só precisa escrever o endereço da função uma vez no IAT, e o código continua chamando por meio dele.

C++ analisador de tabela de importação (x86 + x64)

Abaixo está uma abordagem compacta e prática:

  • Valide o cabeçalho DOS e a assinatura PE
  • Detectar arquitetura de IMAGE_FILE_HEADER.Machine
  • Localize seções e diretórios de dados
  • Converter RVA em deslocamentos de arquivo (rva2offset)
  • Caminhar IMAGE_IMPORT_DESCRIPTOR entries
  • Para cada função importada, detecte importação por nome versus importação por ordinal

Repositório completo: https://github.com/SToFU-Systems/DSAVE

alignUp

DWORD alignUp(DWORD value, DWORD align) {
  DWORD mod = value % align;
  return value + (mod ? (align - mod) : 0);
}

rva2offset

static constexpr int64_t kRvaError = -1;
int64_t rva2offset(const IMAGE_NTPE_DATA& ntpe, DWORD rva) {
  try {
    PIMAGE_SECTION_HEADER sec = ntpe.sectionDirectories;
    // If rva is inside headers, return as-is
    if (!ntpe.fileHeader->NumberOfSections || rva < sec->VirtualAddress) {
      return rva;
    }
    for (uint32_t i = 0; i < ntpe.fileHeader->NumberOfSections; i++, sec++) {
      DWORD secEnd = alignUp(sec->Misc.VirtualSize, ntpe.SecAlign) + sec->VirtualAddress;
      if (sec->VirtualAddress <= rva && secEnd > rva) {
        return (int64_t)rva - sec->VirtualAddress + sec->PointerToRawData;
      }
    }
  } catch (...) {
  }
  return kRvaError;
}

Importe a ideia central da caminhada

// Pseudocode outline
// 1) Find DataDirectory[IMPORT].VirtualAddress
// 2) Convert RVA -> file offset
// 3) Walk IMAGE_IMPORT_DESCRIPTOR until Name == 0
// 4) For each descriptor, walk thunk table until entry == 0
// 5) If high-bit set -> ordinal, else -> name (IMAGE_IMPORT_BY_NAME)

O projeto do artigo implementa isso em um formato pronto para uso, incluindo suporte para x86 e x64.

Ferramentas usadas

O que vem a seguir

Próximas etapas sugeridas no artigo original:

  • Construa um módulo de hash difuso
  • Discuta listas negras e listas brancas
  • Expanda as ferramentas de análise e análise de PE Contatos do artigo: articles@stofu.io
Voltar aos blogs

Contato

Comece a conversa

Algumas linhas claras bastam. Descreva o sistema, a pressão e a decisão que está bloqueada. Ou escreva diretamente para midgard@stofu.io.

0 / 10000
Nenhum arquivo escolhido