Analizzatore di tabelle di importazione PE

Analizzatore di tabelle di importazione PE

Il formato PE (Portable Executable).

Il formato Portable Executable (PE) è il formato file standard utilizzato da Windows per gli eseguibili come .exe and .dll. È stato introdotto con Windows NT (1993) ed è diventato il layout unificato per entrambi 32 bit e 64 bit programmi. Una solida conoscenza degli aspetti interni di PE è un prerequisito per creare strumenti di sicurezza su Windows, inclusi motori antivirus, analizzatori statici, programmi di decompressione e utilità di risposta agli incidenti.

PE in breve

Un tipico file PE contiene:

  • Intestazione DOS (IMAGE_DOS_HEADER) per compatibilità legacy e per individuare l'intestazione NT.
  • Intestazioni NT (IMAGE_NT_HEADERS32/64), che includono:
    • IMAGE_FILE_HEADER
    • IMAGE_OPTIONAL_HEADER32/64 (il nome è storico, è effettivamente obbligatorio per le immagini PE)
  • Tabella delle sezioni (serie di IMAGE_SECTION_HEADER)
  • Sezioni come .text, .rdata, .data, .rsrc, ecc
  • Directory di dati (importazione, esportazione, risorse, rilocazioni, debug, TLS, ...) La maggior parte delle strutture e costanti relative a PE sono dichiarate in WinNT.h.

IMAGE_DOS_HEADER

IMAGE_DOS_HEADER è una struttura legacy per la compatibilità con MS-DOS. In pratica, i due campi più importanti sono:

  • e_magicFirma che identifica l'intestazione DOS. Per i file PE deve essere 0x5A4D che corrisponde ad ASCII "MZ" (IMAGE_DOS_SIGNATURE).
  • e_lfanewOffset del file (dall'inizio del file) al file Intestazioni 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

Storia della firma "MZ".

All'inizio degli anni '80, MS-DOS necessitava di un metodo semplice per distinguere i file eseguibili da altri tipi di file. Il "numero magico" MZ è stato scelto e scritto all'inizio degli eseguibili. Oggi questa firma rimane come parte della compatibilità PE. È memorizzato in IMAGE_DOS_HEADER.e_magic as 0x5A4D.

IMAGE_NT_HEADERS (32 e 64)

Le intestazioni NT sono state introdotte con Windows NT per standardizzare il caricamento degli eseguibili. Ci sono due forme:

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 descrive l'immagine ad alto livello: architettura, numero di sezioni, timestamp e attributi. Documentazione 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;

Campi chiave:

  • MachineArchitettura CPU target (ad esempio IMAGE_FILE_MACHINE_I386, IMAGE_FILE_MACHINE_AMD64).
  • NumberOfSectionsConteggio delle intestazioni di sezione che seguono.
  • TimeDateStampSecondi dell'epoca UNIX. Utile per il debug, il controllo delle versioni, il triage.
  • SizeOfOptionalHeaderDimensione della struttura dell'intestazione opzionale.
  • CharacteristicsBandiere come:
    • IMAGE_FILE_EXECUTABLE_IMAGE
    • IMAGE_FILE_DLL
    • IMAGE_FILE_32BIT_MACHINE
    • IMAGE_FILE_DEBUG_STRIPPED

IMAGE_OPTIONAL_HEADER (32 e 64)

Nonostante il nome, questa intestazione è essenziale. Contiene informazioni sul layout della memoria, punto di ingresso, allineamenti, sottosistema e file DataDirectory matrice. Documentazione Microsoft:

IMAGE_SECTION_HEADER

Un PE è suddiviso in sections, ciascuno descritto da IMAGE_SECTION_HEADER. Le sezioni sono le unità di mappatura fondamentali utilizzate dal caricatore e dall'utensileria. Documentazione 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)

Nomi tipici delle sezioni:

  • .text codice eseguibile
  • .rdata dati di sola lettura
  • .data dati scrivibili inizializzati
  • .bss dati non inizializzati (spesso solo virtuali)
  • .rsrc risorse Immagini dall'articolo:
  • Section header overview
  • Sections in a file
  • Section characteristics

Indirizzo virtuale e indirizzo fisico (offset del file)

In un PE, molti campi sono espressi come RVA (Indirizzo virtuale relativo). RVA è un indirizzo relativo alla base del modulo in memoria. Sul disco, i dati si trovano da offset dei file.Se devi accedere a qualcosa sul disco utilizzando un RVA, devi convertirlo utilizzando una traduzione RVA-to-file-offset (spesso chiamata rva2offset).RVA vs file offset

Importazioni

Quando un eseguibile dipende da funzioni esterne (ad esempio from user32.dll o DLL di terze parti), elenca tali dipendenze nel file Importa directory.Il caricatore Windows risolve le importazioni al momento del caricamento e riempie il file Tabella degli indirizzi di importazione (IAT) con puntatori a funzioni reali. I compilatori in genere generano chiamate indirette tramite IAT.Import table concept

IMAGE_IMPORT_DIRECTORY (tabella directory di importazione)

La directory di importazione è una sequenza di IMAGE_IMPORT_DESCRIPTOR strutture. Ogni descrittore descrive una DLL importata.

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;

Visualizzazione dall'articolo:

  • OriginalFirstThunk/FirstThunk tables
  • Imported function name strings

Come funziona la chiamata di importazione

Tipiche chiamate di output del compilatore attraverso una cella che il caricatore riempie una volta:

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

IAT callIl caricatore deve solo scrivere l'indirizzo della funzione una volta nello IAT e il codice continua a chiamare attraverso di esso.

C++ analizzatore di tabelle di importazione (x86 + x64)

Di seguito è riportato un approccio compatto e pratico:

  • Convalida l'intestazione DOS e la firma PE
  • Rileva l'architettura da IMAGE_FILE_HEADER.Machine
  • Individuare sezioni e directory di dati
  • Converti RVA in offset file (rva2offset)
  • Cammina IMAGE_IMPORT_DESCRIPTOR entries
  • Per ogni funzione importata, rileva l'importazione per nome e l'importazione per ordinale

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

Importa l'idea principale della camminata

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

Il progetto dell'articolo lo implementa in un formato pronto per l'uso, incluso il supporto x86 e x64.

Strumenti utilizzati

Qual è il prossimo passo?

Passaggi successivi suggeriti nell'articolo originale:

  • Costruisci un modulo di hashing fuzzy
  • Discutere liste nere e liste bianche
  • Espandi gli strumenti relativi all'analisi e all'analisi PE. Contatti dall'articolo: articoli@stofu.io
Torniamo IA blog

Contatti

Inizia la conversazione

Bastano poche righe chiare. Descrivi il sistema, la pressione e la decisione bloccata. Oppure scrivi direttamente a midgard@stofu.io.

0 / 10000
Nessun file selezionato