W jaki sposób gromadzą się relacje bazowe PE?

Question

Mam obecnie problem ze zrozumieniem, w jaki sposób buduje się relokacje bazy PE.

Rozumiem, nie może być więcej niż jeden relokacji, rozumiem też, dlaczego i jak to się robi, ale ja po prostu nie rozumiem programowo:

Które z poniższych stwierdzeń jest prawdziwe (IMAGE_BASE_RELOCATION w WINNT.H)?

// Base relocation #1 
DWORD VirtualAddress; 
DWORD SizeOfBlock; // size of current relocation 
WORD TypeOffset[1]; 
// Base relocation #2 
DWORD VirtualAddress; 
DWORD SizeOfBlock; // size of current relocation 
WORD TypeOffset[1]; 
// Base relocation #3 
DWORD VirtualAddress; 
DWORD SizeOfBlock; // size of current relocation 
WORD TypeOffset[1]; 

Albo

DWORD VirtualAddress; 
DWORD SizeOfBlock; // size of all relocations 
WORD TypeOffset[1]; // relocation #1 
WORD TypeOffset[1]; // relocation #2 
WORD TypeOffset[1]; // relocation #3 

Albo są zarówno błędna? Jak mam programowo przechodzić przez wszystkie relokacje bazowe?

Obecnie mam ten kod, wydaje się być gdzieś nieprawidłowy:

DWORD baseRelocationSize = imageNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size; 
      unsigned int baseRelocationCount = baseRelocationSize/sizeof(IMAGE_BASE_RELOCATION); 
      DWORD baseDelta = (DWORD_PTR)moduleBase - (DWORD_PTR)imageNtHeaders->OptionalHeader.ImageBase; 

      IMAGE_BASE_RELOCATION* baseRelocation = (IMAGE_BASE_RELOCATION*)((DWORD_PTR)moduleBase + (DWORD_PTR)imageNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress); 

      for(unsigned int i = 0; i != baseRelocationCount; ++i) 
      { 
       unsigned int entryCount = (baseRelocation->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION))/sizeof(WORD); 

       for(unsigned int j = 0; j != entryCount; ++j) 
       { 
        WORD* entry = (WORD*)((DWORD_PTR)baseRelocation + (DWORD_PTR)sizeof(IMAGE_BASE_RELOCATION)); 
        if((*entry >> 12) & IMAGE_REL_BASED_HIGHLOW) 
        { 
         DWORD* pdw = (PDWORD)((DWORD_PTR)moduleBase + (DWORD_PTR)baseRelocation->VirtualAddress + ((*entry) & 0xfff)); 
         (*pdw) += baseDelta; 
        } 

        entry++; 
       } 

       baseRelocation += baseRelocation->SizeOfBlock; 
      } 

Answer 1

Ani opcje wskazane całkowicie poprawna/true.

To doskonały poradnik na How to inject code in a PE file pokazuje, że rzeczywisty IMAGE_BASE_RELOCATION struktura jest następująca:

typedef struct _IMAGE_BASE_RELOCATION { 
    DWORD VirtualAddress; 
    DWORD SizeOfBlock; 
} IMAGE_BASE_RELOCATION, *PIMAGE_BASE_RELOCATION; 

sekcje 4.2 i 5.6 niniejszego document opisać strukturę. Numer SizeOfBlock-8 faktycznie wskazuje liczbę WORD TypeOffset następujących po następujących po i SizeOfBlock.

Myślę, że byłbyś zainteresowany Tabelą 7 samouczka, która pokazuje strukturę bloków z tabeli relokacji. Skopiuję i wkleję tutaj tabelę, aby uzyskać szybki odnośnik.

Answer 2

od jakiegoś kodu .. Aldo sprawdzeniu ReactOS :)

BOOL FixRelocs(void *base, void *rBase, IMAGE_NT_HEADERS *ntHd, IMAGE_BASE_RELOCATION *reloc, 
       unsigned int size) { 
    unsigned long ImageBase = ntHd->OptionalHeader.ImageBase; 
    unsigned int nBytes = 0; 
    unsigned long delta = MakeDelta(unsigned long, rBase, ImageBase); 
    unsigned long *locBase; 
unsigned int numRelocs; 
unsigned short *locData; 
unsigned int i; 

while(1) { 
    locBase = 
    (unsigned long *)GetPtrFromRVA((DWORD)(reloc->VirtualAddress), ntHd, (PBYTE)base); 
    numRelocs = (reloc->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION))/sizeof(WORD); 

    if(nBytes >= size) break; 

    locData = MakePtr(unsigned short *, reloc, sizeof(IMAGE_BASE_RELOCATION)); 
    for(i = 0; i < numRelocs; i++) {  
    if(((*locData >> 12) == IMAGE_REL_BASED_HIGHLOW)) 
     *MakePtr(unsigned long *, locBase, (*locData & 0x0FFF)) += delta; 
    locData++; 
    } 

    nBytes += reloc->SizeOfBlock; 
    reloc = (IMAGE_BASE_RELOCATION *)locData; 
    } 

    return TRUE; 

}