Analizador de tablas de importación PE

Analizador de tablas de importación PE

El formato ejecutable portátil (PE)

El formato Portable Executable (PE) es el formato de archivo estándar utilizado por Windows para ejecutables como .exe and .dll. Fue introducido con Windows NT (1993) y se convirtió en el diseño unificado para ambos 32 bits y 64 bits programas.Una comprensión sólida de los aspectos internos de PE es un requisito previo para crear herramientas de seguridad en Windows, incluidos motores antivirus, analizadores estáticos, desempaquetadores y utilidades de respuesta a incidentes.

PE de un vistazo

Un archivo PE típico contiene:

  • encabezado de DOS (IMAGE_DOS_HEADER) para compatibilidad heredada y para localizar el encabezado NT.
  • encabezados NT (IMAGE_NT_HEADERS32/64), que incluyen:
    • IMAGE_FILE_HEADER
    • IMAGE_OPTIONAL_HEADER32/64 (el nombre es histórico, efectivamente es obligatorio para las imágenes PE)
  • tabla de secciones (matriz de IMAGE_SECTION_HEADER)
  • Secciones como por ejemplo .text, .rdata, .data, .rsrc, etc.
  • Directorios de datos (importación, exportación, recursos, reubicaciones, depuración, TLS,…) La mayoría de las estructuras y constantes relacionadas con PE se declaran en WinNT.h.

IMAGE_DOS_HEADER

IMAGE_DOS_HEADER es una estructura heredada para compatibilidad con MS-DOS. En la práctica, los dos campos más importantes son:

  • e_magicFirma que identifica el encabezado de DOS. Para archivos PE debe ser 0x5A4D que corresponde a ASCII "MZ" (IMAGE_DOS_SIGNATURE).
  • e_lfanewDesplazamiento del archivo (desde el principio del archivo) hasta el encabezados 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

Historia de la firma "MZ"

A principios de la década de 1980, MS-DOS necesitaba un método sencillo para distinguir los archivos ejecutables de otros tipos de archivos. El "número mágico" MZ fue elegido y escrito al inicio de los ejecutables. Hoy en día, esta firma permanece como parte de la compatibilidad con PE. Se almacena en IMAGE_DOS_HEADER.e_magic as 0x5A4D.

IMAGE_NT_HEADERS (32 y 64)

Los encabezados NT se introdujeron con Windows NT para estandarizar la carga de ejecutables. Hay dos 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 Describe la imagen en un alto nivel: arquitectura, número de secciones, marca de tiempo y atributos. Documentación de 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 clave:

  • MachineArquitectura de destino CPU (por ejemplo IMAGE_FILE_MACHINE_I386, IMAGE_FILE_MACHINE_AMD64).
  • NumberOfSectionsRecuento de encabezados de sección que siguen.
  • TimeDateStampSegundos de época UNIX. Útil para depuración, control de versiones y clasificación.
  • SizeOfOptionalHeaderTamaño de la estructura de encabezado opcional.
  • CharacteristicsBanderas como:
    • IMAGE_FILE_EXECUTABLE_IMAGE
    • IMAGE_FILE_DLL
    • IMAGE_FILE_32BIT_MACHINE
    • IMAGE_FILE_DEBUG_STRIPPED

IMAGE_OPTIONAL_HEADER (32 y 64)

A pesar del nombre, este encabezado es imprescindible. Contiene información sobre el diseño de la memoria, el punto de entrada, las alineaciones, el subsistema y el Directorio de datos matriz. Documentación de Microsoft:

IMAGE_SECTION_HEADER

Un PE se divide en sections, cada uno descrito por IMAGE_SECTION_HEADER. Las secciones son las unidades de mapeo fundamentales utilizadas por el cargador y las herramientas. Documentación de 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)

Nombres de sección típicos:

  • .text código ejecutable
  • .rdata datos de solo lectura
  • .data datos grabables inicializados
  • .bss datos no inicializados (a menudo solo virtuales)
  • .rsrc recursos Imágenes del artículo:
  • Section header overview
  • Sections in a file
  • Section characteristics

Dirección virtual frente a dirección física (desplazamiento de archivo)

En un PE, muchos campos se expresan como RVA (Dirección virtual relativa). RVA es una dirección relativa a la base del módulo en la memoria. En el disco, los datos se ubican por compensaciones de archivos.Si necesita acceder a algo en el disco usando un RVA, debe convertirlo usando una traducción de RVA a archivo con desplazamiento (a menudo llamada rva2offset).RVA vs file offset

Importaciones

Cuando un ejecutable depende de funciones externas (por ejemplo de user32.dll o DLL de terceros), enumera esas dependencias en el Directorio de importación.El cargador Windows resuelve las importaciones en el momento de la carga y llena el Importar tabla de direcciones (IAT) con punteros de función reales. Los compiladores suelen generar llamadas indirectas a través de IAT.Import table concept

IMAGE_IMPORT_DIRECTORY (Importar tabla de directorio)

El directorio de importación es una secuencia de IMAGE_IMPORT_DESCRIPTOR estructuras. Cada descriptor describe una 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;

Visualización del artículo:

  • OriginalFirstThunk/FirstThunk tables
  • Imported function name strings

Cómo funciona la llamada de importación

Llamadas de salida típicas del compilador a través de una celda que el cargador llena una vez:

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

IAT callEl cargador solo necesita escribir la dirección de la función una vez en el IAT y el código sigue llamando a través de él.

C++ importar analizador de tablas (x86 + x64)

A continuación se muestra un enfoque compacto y práctico:

  • Validar el encabezado de DOS y la firma PE
  • Detectar arquitectura de IMAGE_FILE_HEADER.Machine
  • Localizar secciones y directorios de datos
  • Convertir RVA a compensaciones de archivos (rva2offset)
  • caminar IMAGE_IMPORT_DESCRIPTOR entries
  • Para cada función importada, detecte importación por nombre frente a importación por ordinal

Repositorio 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;
}

Importar idea central de la caminata

// 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)

El proyecto del artículo implementa esto en un formato listo para usar, que incluye compatibilidad con x86 y x64.

Herramientas utilizadas

¿Qué sigue?

Próximos pasos sugeridos en el artículo original:

  • Construya un módulo de hash difuso
  • Discutir listas negras y listas blancas
  • Amplíe las herramientas relacionadas con el análisis y análisis de PE Contactos del artículo: artículos@stofu.io
Volver a blogs

Contacto

Iniciar la conversación

Bastan unas pocas líneas claras. Cuéntanos qué sistema es, qué presión hay y qué decisión está bloqueada. O escribe directamente a midgard@stofu.io.

0 / 10000
Ningún archivo seleccionado