Comment trouver le décalage de la section d'en-tête de la table des chaînes d'un elfe de fichier?

Je dois écrire un programme C qui permet d'imprimer un fichier ELF. Je vais avoir du mal à déterminer où la section en-tête de tableau de chaînes est.

Disons que j'ai un fichier qui m'a donné le résultat suivant avec:

readelf -h

ELF Header:
  Magic:   7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 
  Class:                             ELF32
  Data:                              2's complement, little endian
  Version:                           1 (current)
  OS/ABI:                            UNIX - System V
  ABI Version:                       0
  Type:                              REL (Relocatable file)  
  Machine:                           Intel 80386
  Version:                           0x1
  Entry point address:               0x0
  Start of program headers:          0 (bytes into file)
  Start of section headers:          17636 (bytes into file)
  Flags:                             0x0
  Size of this header:               52 (bytes)
  Size of program headers:           0 (bytes)
  Number of program headers:         0
  Size of section headers:           40 (bytes)
  Number of section headers:         23
  Section header string table index: 20

et avec:

readelf -S:

There are 23 section headers, starting at offset 0x44e4:
Section Headers:
[Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al
[ 0]                   NULL            00000000 000000 000000 00      0   0  0
[ 1] .text             PROGBITS        00000000 000034 000028 00  AX  0   0  4
[ 2] .rel.text         REL             00000000 0049d0 000018 08     21   1  4
[ 3] .data             PROGBITS        00000000 00005c 000000 00  WA  0   0  4
[ 4] .bss              NOBITS          00000000 00005c 000000 00  WA  0   0  4
[ 5] .rodata           PROGBITS        00000000 00005c 00000a 00   A  0   0  1
[ 6] .debug_info       PROGBITS        00000000 000066 00008f 00      0   0  1
[ 7] .rel.debug_info   REL             00000000 0049e8 0000b0 08     21   6  4
[ 8] .debug_abbrev     PROGBITS        00000000 0000f5 000041 00      0   0  1
[ 9] .debug_loc        PROGBITS        00000000 000136 000038 00      0   0  1
[10] .debug_aranges    PROGBITS        00000000 00016e 000020 00      0   0  1
[11] .rel.debug_arange REL             00000000 004a98 000010 08     21  10  4
[12] .debug_line       PROGBITS        00000000 00018e 0001b3 00      0   0  1
[13] .rel.debug_line   REL             00000000 004aa8 000008 08     21  12  4
[14] .debug_macinfo    PROGBITS        00000000 000341 003fb9 00      0   0  1
[15] .debug_str        PROGBITS        00000000 0042fa 0000bf 01  MS  0   0  1
[16] .comment          PROGBITS        00000000 0043b9 00002b 01  MS  0   0  1
[17] .note.GNU-stack   PROGBITS        00000000 0043e4 000000 00      0   0  1
[18] .eh_frame         PROGBITS        00000000 0043e4 000038 00   A  0   0  4
[19] .rel.eh_frame     REL             00000000 004ab0 000008 08     21  18  4
[20] .shstrtab         STRTAB          00000000 00441c 0000c5 00      0   0  1
[21] .symtab           SYMTAB          00000000 00487c 000130 10     22  16  4
[22] .strtab           STRTAB          00000000 0049ac 000021 00      0   0  1
Key to Flags:
W (write), A (alloc), X (execute), M (merge), S (strings)
I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)
O (extra OS processing required) o (OS specific), p (processor specific)

Comment pourrais-je être en mesure de calculer l'emplacement de la section d'en-tête de la table des chaînes?

Si vous avez trouvé dans ghex, ne pouvez-vous pas voir le décalage en regardant l'adresse dans le fichier là où vous l'avez trouvé? Je ne suis pas familier avec elle, mais quand je l'ai googlé une capture d'écran a suggéré l'adresse de l'affichage dans le fichier est dans la colonne de gauche.

InformationsquelleAutor user2263413 | 2013-04-13

c elf linux

C'est ce que je fais:

#pragma pack(push,1)
typedef struct
{
uint8  e_ident[16];
uint16 e_type;
uint16 e_machine;
uint32 e_version;
uint32 e_entry;
uint32 e_phoff;
uint32 e_shoff;
uint32 e_flags;
uint16 e_ehsize;
uint16 e_phentsize;
uint16 e_phnum;
uint16 e_shentsize;
uint16 e_shnum;
uint16 e_shstrndx;
} Elf32Hdr;
typedef struct
{
uint32 sh_name;
uint32 sh_type;
uint32 sh_flags;
uint32 sh_addr;
uint32 sh_offset;
uint32 sh_size;
uint32 sh_link;
uint32 sh_info;
uint32 sh_addralign;
uint32 sh_entsize;
} Elf32SectHdr;
#pragma pack(pop)
{
FILE* ElfFile = NULL;
char* SectNames = NULL;
Elf32Hdr elfHdr;
Elf32SectHdr sectHdr;
uint idx;
//...
//read ELF header
fread(&elfHdr, 1, sizeof elfHdr, ElfFile);
//read section name string table
//first, read its header
fseek(ElfFile, elfHdr.e_shoff + elfHdr.e_shstrndx * sizeof sectHdr, SEEK_SET);
fread(&sectHdr, 1, sizeof sectHdr, ElfFile);
//next, read the section, string data
SectNames = malloc(sectHdr.sh_size);
fseek(ElfFile, sectHdr.sh_offset, SEEK_SET);
fread(SectNames, 1, sectHdr.sh_size, ElfFile);
//read all section headers
for (idx = 0; idx < elfHdr.e_shnum; idx++)
{
const char* name = "";
fseek(ElfFile, elfHdr.e_shoff + idx * sizeof sectHdr, SEEK_SET);
fread(&sectHdr, 1, sizeof sectHdr, ElfFile);
//print section name
if (sectHdr.sh_name);
name = SectNames + sectHdr.sh_name;
printf("%2u %s\n", idx, name);
}
//...
}

InformationsquelleAutor Alexey Frunze

4

Ici est de savoir comment vous arrivez dans la section chaîne de nom de table:
- La e_shstrndx domaine de l'ELFE Exécutable de l'en-Tête (EHDR) spécifie l'index de la section d'en-tête de la table d'entrée décrivant le tableau de chaînes contenant les noms de section.
- La e_shentsize domaine de la EHDR spécifie la taille en octets de chaque en-tête de section d'entrée de la table.
- La e_shoff domaine de la EHDR spécifie le fichier de décalage du début de la section en-tête de tableau.
Ainsi l'entrée d'en-tête de la table de chaîne sera à l'offset du fichier:
```
header_table_entry_offset = (e_shentsize * e_shstrndx) + e_shoff
```
Selon l'ELFE de la classe de l'objet, cet en-tête d'entrée de la table sera soit un Elf32_Shdr ou un Elf64_Shdr. Notez que le fichier de la représentation de l'en-tête d'entrée de la table peut être différente de sa représentation en mémoire sur l'ordinateur hôte que votre programme est en cours d'exécution sur.

La sh_offset champ dans l'en-tête d'entrée de spécifier le fichier de démarrage décalage de la chaîne de la table, tandis que le sh_size champ de spécifier sa taille.

En savoir plus: Le "libelf par Exemple" tutoriel couvre l'ELFE Exécutable en-Tête et ELFE de la Section d'en-Tête de la Table dans une plus grande profondeur.

InformationsquelleAutor jkoshy
2

Il semble que celui que vous voulez, c'est STRTAB, qui a un décalage de 0x441c (ligne [20]). Les en-têtes commencent 17636 octets dans le fichier (selon
```
Start of section headers:          17636 (bytes into file)
```
Donc je vais deviner que votre chaîne de table commence à 17636 + 17436 = 35072 octets à partir du début du fichier.

Je pourrais être complètement faux, mais c'est là que je commencerais. Savez-vous comment utiliser od ou un utilitaire pour faire un dump de fichier octets?
- Non, les décalages sont absolus.
- Ensuite, la chaîne de la table serait à 17436 octets dans le fichier? Il devrait être facile à vérifier si l'un de ces est correct.
InformationsquelleAutor Floris

Vous devez vous connecter pour publier un commentaire.