Come si accumulano le rilocche della base PE?

Question

Attualmente non riesco a capire come si creano le rilocazioni della base PE.

ho capito non ci può essere più di una delocalizzazione, capisco anche perché e come questo è fatto, ma io proprio non capisco a livello di codice:

Quale delle seguenti affermazioni è vera (IMAGE_BASE_RELOCATION in 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]; 

O

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

O sono entrambi errati? Come devo effettuare il ciclo di tutte le riposizionazioni di base a livello di codice?

Attualmente ho questo codice, sembra non essere corretto da qualche parte:

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

Né opzioni indicato del tutto corretto/true.

Grazie tutorial su How to inject code in a PE file mostra che l'attuale IMAGE_BASE_RELOCATION struttura è:

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

Sezioni 4.2 e 5.6 di questo document descrivere la struttura. Lo SizeOfBlock-8 indica effettivamente il numero di WORD TypeOffset seguito dallo VirtualAddress e dallo SizeOfBlock.

Penso che ti interesserebbe anche la Tabella 7 del tutorial, che mostra la struttura dei blocchi dalla tabella di rilocazione. Copia e incolla la tabella qui per riferimento rapido.

Answer 2

da qualche codice .. aldo check out 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; 

}