¿Cómo se PE Reubicación Base construir?

Actualmente estoy teniendo problemas para entender cómo PE Reubicación Base se acumulan.

Entiendo que puede haber más de una reubicación, entiendo también por qué y cómo se hace, pero yo no entiendo programación:

Cuál de las siguientes es verdadera (IMAGE_BASE_RELOCATION en 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 son incorrectos? ¿Cómo debo bucle a través de todos los reubicación base programática?

Actualmente tengo este código, parece ser incorrecto en algún lugar:

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;
            } 
  • Que es complicado, ¿verdad?
  • Traslados son ridículas, nadie parece saber la forma correcta de manejar.
  • ¿que esta cifra fuera?
InformationsquelleAutor John Smith | 2013-07-02

2 Kommentare

  1. 18

    Ninguna de las opciones indicadas todo correcto, lo verdadero.

    Este excelente tutorial en Cómo inyectar código en un archivo PE muestra que la actual IMAGE_BASE_RELOCATION estructura es:

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

    La sección 5.2 de este Microsoft Portable Ejecutable y Objeto Común de Especificación de Formato de Archivo describir la estructura. El SizeOfBlock-8 realidad indica cuántas WORD TypeOffset seguir después de la VirtualAddress y SizeOfBlock.

    Creo que también estaría interesado en el cuadro 7 del tutorial, que muestra la estructura de los bloques de la tabla de reubicación. Voy a copiar y pegar la tabla de aquí para referencia rápida.

    ¿Cómo se PE Reubicación Base construir?

    • Esto es perfecto. Una última pregunta, ¿cómo saber cuántas manzanas hay?
    • El número de bloque no está escrito en ninguna parte. Yo lo que hago es ir a bloque a bloque hasta la actual dirección es igual a imageNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress + imageNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size en este punto, usted sabe que usted está en el final de la .reloc sección
    • Sólo para estar al 100%, cuando dices "The SizeOfBlock-8 actually indicates how many WORD TypeOffset follow after the VirtualAddress and SizeOfBlock" debe decir "The (SizeOfBlock-8) / sizeof(WORD) actually indicates how many WORD TypeOffset follow after the VirtualAddress and SizeOfBlock". Me corrija si estoy equivocado.
  2. 4

    de código.. aldo retirar 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;
    
    }
    

Kommentieren Sie den Artikel

Bitte geben Sie Ihren Kommentar ein!
Bitte geben Sie hier Ihren Namen ein

Pruebas en línea