Comment sont-PE de la Base de Délocalisations, de construire?

Je suis actuellement de la difficulté à comprendre comment PE de la Base de Délocalisations sont à construire.

Je comprends il peut y avoir plus d'une réinstallation, je comprends aussi pourquoi et comment cela est fait, mais je ne comprends pas par programmation:

Lequel des énoncés suivants est vrai (IMAGE_BASE_RELOCATION dans 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];

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

Ou les deux sont incorrectes? Comment dois-je faire une boucle par tous les délocalisations par programmation?

Actuellement, j'ai ce code, semble être incorrect quelque part:

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

C'est une question difficile, non?
Les délocalisations sont ridicule, personne ne semble connaître la bonne façon de les gérer.
avez-vous comprendre cela?

OriginalL'auteur John Smith | 2013-07-02

17

Ni les options que vous avez indiqué tout à fait correct/vrai.

Cet excellent tutoriel sur Comment injecter du code dans un fichier PE montre que le IMAGE_BASE_RELOCATION la structure est:
```
typedef struct _IMAGE_BASE_RELOCATION {
  DWORD   VirtualAddress;
  DWORD   SizeOfBlock;
} IMAGE_BASE_RELOCATION, *PIMAGE_BASE_RELOCATION;
```
Les Sections 4.2 et 5.6 de la présente document décrire la structure. Le SizeOfBlock-8 indique combien de WORD TypeOffset suivre après la VirtualAddress et SizeOfBlock.

Je pense que vous pourriez également être intéressé dans le Tableau 7 du tutoriel, qui montre la structure des blocs de la relocalisation de la table. Je vais copier-coller le tableau de référence rapide.

C'est juste parfait. Une dernière question, comment savez-vous combien de blocs il y a?
Le nombre de bloc n'est pas écrit nulle part. Ce que je fais est d'aller en bloc par bloc, jusqu'à ce que l'adresse est égale à imageNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress + imageNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size à ce point, vous savez que vous êtes à la fin de la .reloc section
Juste pour être sur à 100%, quand vous dites "The SizeOfBlock-8 actually indicates how many WORD TypeOffset follow after the VirtualAddress and SizeOfBlock" vous devriez dire "The (SizeOfBlock-8) / sizeof(WORD) actually indicates how many WORD TypeOffset follow after the VirtualAddress and SizeOfBlock". Corrigez-moi si je me trompe.

OriginalL'auteur Benny

de code.. aldo découvrez 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;

}

OriginalL'auteur Mike Guidry

Vous devez vous connecter pour publier un commentaire.