PE Baz Yerleşimleri nasıl oluşur?

Question

Şu anda PE Base Relocations'ın nasıl kurulduğunu anlamakta zorlanıyorum. Daha bir tehcir o zaman, ben de neden ve nasıl bu yapılır anlıyorum, ama sadece programlı bunu anlamıyorum orada olabileceğini anlıyoruz

: winnt.h içinde doğrudur Aşağıdakilerden hangisi

(IMAGE_BASE_RELOCATION)?

// 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]; 

Ya

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

Veya her ikisi yanlıştır? Tüm temel yer değiştirmelerden program aracılığıyla nasıl dönmeliyim?

Şu anda bu kodu var, bir yerde yanlış gibi görünüyor: Bazı koddan

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

Ne seçenekleri ReactOS göz atın.

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

Bölüm 4.2 ve bu document 5.6 yapısını açıklar:

How to inject code in a PE file üzerindeki bu mükemmel öğretici gerçek IMAGE_BASE_RELOCATION yapısı olduğunu göstermektedir. SizeOfBlock-8 aslında VirtualAddress ve SizeOfBlock'dan sonra kaç tane WORD TypeOffset izler olduğunu gösterir.

Ayrıca, yerleştirme tablosundaki blokların yapısını gösteren, öğreticinin Tablo 7 ile de ilgileneceğinizi düşünüyorum. Tabloyu hızlı referans için buraya kopyalayıp yapıştırırım.

Answer 2

.. aldo :) true/tamamen doğru belirtilen

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; 

}