Het ELF-bestandsformaat begrijpen

Van broncode naar binaire code

Programmeren begint met een slim idee hebben, de broncode schrijven in een programmeertaal naar keuze, bijvoorbeeld C, en de broncode opslaan in een bestand. Met behulp van een adequate compiler, bijvoorbeeld GCC, wordt uw broncode eerst vertaald naar objectcode. Uiteindelijk vertaalt de linker de objectcode naar een binair bestand dat de objectcode koppelt aan de bibliotheken waarnaar wordt verwezen. Dit bestand bevat de enkele instructies als machinecode die door de CPU worden begrepen en worden uitgevoerd zodra het gecompileerde programma wordt uitgevoerd.

Het hierboven genoemde binaire bestand volgt een specifieke structuur, en een van de meest voorkomende is ELF genaamd, de afkorting van Executable en Linkable Format. Het wordt veel gebruikt voor uitvoerbare bestanden, verplaatsbare objectbestanden, gedeelde bibliotheken en kerndumps.

Twintig jaar geleden - in 1999 - heeft het 86open-project ELF gekozen als het standaard binaire bestandsformaat voor Unix en Unix-achtige systemen op x86-processors. Gelukkig was het ELF-formaat eerder gedocumenteerd in zowel de System V Application Binary Interface als de Tool Interface Standard [4]. Dit feit heeft de overeenkomst over standaardisatie tussen de verschillende leveranciers en ontwikkelaars van op Unix gebaseerde besturingssystemen enorm vereenvoudigd.

De reden achter die beslissing was het ontwerp van ELF - flexibiliteit, uitbreidbaarheid en platformonafhankelijke ondersteuning voor verschillende endian-indelingen en adresgroottes. Het ontwerp van ELF is niet beperkt tot een specifieke processor, instructieset of hardware-architectuur. Voor een gedetailleerde vergelijking van uitvoerbare bestandsformaten, kijk hier [3].

Sindsdien wordt het ELF-formaat door verschillende besturingssystemen gebruikt. Dit omvat onder andere Linux, Solaris/Illumos, Free-, Net- en OpenBSD, QNX, BeOS/Haiku en Fuchsia OS [2]. Verder vind je het op mobiele apparaten met Android, Maemo of Meego OS/Sailfish OS en op gameconsoles zoals de PlayStation Portable, Dreamcast en Wii.

De specificatie verduidelijkt de bestandsnaamextensie voor ELF-bestanden niet. In gebruik is een verscheidenheid aan lettercombinaties, zoals: .axf, .bin, .elf, .O, .prx, .puffen, .ko, .dus en .mod, of geen.

De structuur van een ELF-bestand

Op een Linux-terminal geeft de commandant elf je een handige samenvatting over de structuur van een ELF-bestand:

Listing 1: De manpage van de ELF-structuur

$ man elf
ELF(5) Linux-programmeerhandleiding ELF(5)
NAAM
elf - formaat van Executable and Linking Format (ELF)-bestanden
KORTE INHOUD
#include
OMSCHRIJVING
Het header-bestand definieert het formaat van ELF uitvoerbaar binair
bestanden. Onder deze bestanden zijn normale uitvoerbare bestanden, verplaatsbaar
objectbestanden, kernbestanden en gedeelde bibliotheken.
Een uitvoerbaar bestand dat de ELF-bestandsindeling gebruikt, bestaat uit een ELF-header,
gevolgd door een programmakoptabel of een sectiekoptabel, of beide.
De ELF-header staat altijd op nulpunt van het bestand. Het programma
header-tabel en de offset van de sectie-headertabel in het bestand zijn
gedefinieerd in de ELF-header. De twee tabellen beschrijven de rest van de
bijzonderheden van het bestand.
…

Zoals je kunt zien aan de hand van de bovenstaande beschrijving, bestaat een ELF-bestand uit twee secties: een ELF-header en bestandsgegevens. De sectie bestandsgegevens kan bestaan uit een programmakoptabel die nul of meer segmenten beschrijft, een sectiekoptabel die nul of meer secties beschrijft, gevolgd door gegevens waarnaar wordt verwezen door items uit de programmakoptabel, en de sectiekoptabel. Elk segment bevat informatie die nodig is voor runtime-uitvoering van het bestand, terwijl secties belangrijke gegevens bevatten voor koppeling en verplaatsing. Figuur 1 illustreert dit schematisch.

De ELF-koptekst

De ELF-header is 32 bytes lang en identificeert het formaat van het bestand. Het begint met een reeks van vier unieke bytes die 0x7F zijn, gevolgd door 0x45, 0x4c en 0x46, wat zich vertaalt in de drie letters E, L en F. De header geeft onder andere aan of het een ELF-bestand is voor 32- of 64-bits formaat, weinig of big endianness gebruikt, de ELF-versie toont en ook voor welk besturingssysteem het bestand is gecompileerd om te kunnen samenwerken met de juiste toepassing binaire interface (ABI) en cpu-instructieset.

De hexdump van de binaire file touch ziet er als volgt uit:

.Lijst 2: De hexdump van het binaire bestand

$ hd /usr/bin/touch | hoofd -5
00000000 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00 |.ELF… |
00000010 02 00 3e 00 01 00 00 00 e3 25 40 00 00 00 00 00 |… >… %@… |
00000020 40 00 00 00 00 00 00 00 28 e4 00 00 00 00 00 00 |@… (… |
00000030 00 00 00 00 40 00 38 00 09 00 40 00 1b 00 1a 00 |[email protected]@… |
00000040 06 00 00 00 05 00 00 00 40 00 00 00 00 00 00 00 |[email protected]|

Debian GNU/Linux biedt het readelf-commando dat wordt geleverd in het GNU 'binutils'-pakket. Vergezeld van de switch -h (korte versie voor "-file-header") wordt de header van een ELF-bestand mooi weergegeven. Lijst 3 illustreert dit voor het commando touch.

.Lijst 3: De koptekst van een ELF-bestand weergeven

$ readelf -h /usr/bin/touch
ELF-kop:
Magie: 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00
Klasse: ELF64
Gegevens: complement van 2, little endian
Versie: 1 (huidig)
OS/ABI: UNIX - Systeem V
ABI-versie: 0
Type: EXEC (Uitvoerbaar bestand)
Machine: geavanceerde micro-apparaten X86-64
Versie: 0x1
Adres ingangspunt: 0x4025e3
Begin van programmakoppen: 64 (bytes in bestand)
Begin van sectiekoppen: 58408 (bytes in bestand)
Vlaggen: 0x0
Grootte van deze header: 64 (bytes)
Grootte van programmakoppen: 56 (bytes)
Aantal programmakoppen: 9
Grootte van sectiekoppen: 64 (bytes)
Aantal sectiekoppen: 27
Sectie header string tabel index: 26

De programmakop

De programmakop toont de segmenten die tijdens runtime worden gebruikt en vertelt het systeem hoe een procesafbeelding moet worden gemaakt. De header van Listing 2 laat zien dat het ELF-bestand uit 9 programmaheaders bestaat die elk een grootte van 56 bytes hebben, en de eerste header begint bij byte 64.

Nogmaals, de readelf-opdracht helpt om de informatie uit het ELF-bestand te extraheren. De schakelaar -l (afkorting van -programma-headers of -segmenten) onthult meer details zoals weergegeven in Listing 4.

.Lijst 4: Toon informatie over de programmakoppen

$ readelf -l /usr/bin/touch
Elf-bestandstype is EXEC (Uitvoerbaar bestand)
Ingangspunt 0x4025e3
Er zijn 9 programmakoppen, beginnend bij offset 64
Programmakoppen:
Type Offset VirtAddr PhysAddr
FileSiz MemSiz Flags Align
PHDR 0x0000000000000040 0x0000000000400040 0x0000000000400040
0x00000000000001f8 0x00000000000001f8 R E 8
INTERP 0x0000000000000238 0x000000000400238 0x000000000400238
0x000000000000001c 0x000000000000001c R 1
[Program-interpreter aanvragen: /lib64/ld-linux-x86-64.zo.2]
LADEN 0x0000000000000000 0x000000000000400000 0x000000000000400000
0x000000000000d494 0x000000000000d494 R E 200000
LADEN 0x000000000000de10 0x00000000000060de10 0x00000000000060de10
0x0000000000000524 0x0000000000000748 RW 200000
DYNAMISCH 0x000000000000de28 0x0000000060de28 0x00000000000060de28
0x00000000000001d0 0x00000000000001d0 RW 8
OPMERKING 0x0000000000000254 0x000000000000400254 0x000000000000400254
0x00000000000044 0x00000000000044 R 4
GNU_EH_FRAME 0x000000000000bc40 0x00000000000040bc40 0x000000000040bc40
0x00000000000003a4 0x00000000000003a4 R 4
GNU_STACK 0x000000000000000000 0x000000000000000000 0x000000000000000000
0x000000000000000000 0x000000000000000000 RW 10
GNU_RELRO 0x000000000000de10 0x0000000060de10 0x00000000060de10
0x00000000000001f0 0x00000000000001f0 R 1
Sectie naar segmenttoewijzing:
Segmentsecties…
00
01 .interp
02 .interp .Opmerking.ABI-tag .Opmerking.gnu.build-id .gnu.hasj .dynsym .dynstr .gnu.versie .gnu.version_r .rela.dyn .rela.plt .in het .plt .tekst .eindig .rodata .eh_frame_hdr .eh_frame
03 .init_array .fini_array .jcr .dynamisch .heb ik .heb ik.plt .gegevens .bss
04 .dynamisch
05 .Opmerking.ABI-tag .Opmerking.gnu.build-id
06 .eh_frame_hdr
07
08 .init_array .fini_array .jcr .dynamisch .heb ik

De sectiekop

Het derde deel van de ELF-structuur is de sectiekop. Het is bedoeld om de afzonderlijke secties van het binaire bestand op te sommen. De schakelaar -S (afkorting van -section-headers of -sections) geeft de verschillende headers weer. Wat betreft het aanraakcommando, er zijn 27 sectiekoppen en lijst 5 toont de eerste vier plus de laatste, alleen. Elke regel dekt de sectiegrootte, het sectietype en het adres en geheugenoffset.

.Listing 5: Sectiedetails onthuld door readelf

$ readelf -S /usr/bin/touch
Er zijn 27 sectiekoppen, beginnend bij offset 0xe428:
Sectiekoppen:
[Nr] Naam Type Adres Offset
Grootte EntSize Vlaggen Link Info Uitlijnen
[ 0] NULL 00000000000000 00000000
000000000000000000 00000000000000 0 0 0
[ 1] .interp PROGBITS 000000000400238 00000238
000000000000001c 000000000000000000 A 0 0 1
[ 2] .Opmerking.ABI-tag OPMERKING 0000000000400254 00000254
0000000000000020 000000000000000000 A 0 0 4
[ 3] .Opmerking.gnu.build-i OPMERKING 0000000000400274 00000274
…
…
[26] .shstrtab STRTAB 0000000000000000 0000e334
00000000000000ef 00000000000000 0 0 1
Sleutel tot vlaggen:
W (schrijven), A (alloc), X (uitvoeren), M (samenvoegen), S (strings), l (groot)
I (info), L (linkvolgorde), G (groep), T (TLS), E (exclusief), x (onbekend)
O (extra OS-verwerking vereist) o (OS-specifiek), p (processor-specifiek)

Hulpmiddelen om een ELF-bestand te analyseren

Zoals je misschien hebt opgemerkt uit de bovenstaande voorbeelden, is GNU/Linux uitgewerkt met een aantal handige tools die je helpen bij het analyseren van een ELF-bestand. De eerste kandidaat die we zullen bekijken, is het bestandshulpprogramma.

bestand geeft basisinformatie weer over ELF-bestanden, inclusief de instructiesetarchitectuur waarvoor de code in een verplaatsbaar, uitvoerbaar of gedeeld objectbestand is bedoeld. In lijst 6 staat dat /bin/touch een 64-bits uitvoerbaar bestand is volgens de Linux Standard Base (LSB), dynamisch gekoppeld en gebouwd voor de GNU/Linux-kernelversie 2.6.32.

.Lijst 6: Basisinformatie met behulp van bestand

$ bestand /bin/touch
/bin/touch: ELF 64-bit LSB uitvoerbaar, x86-64, versie 1 (SYSV), dynamisch gekoppeld, interpreter /lib64/l,
voor GNU/Linux 2.6.32, BuildID[sha1]=ec08d609e9e8e73d4be6134541a472ad0ea34502, gestript
$

De tweede kandidaat is zelf. Het geeft gedetailleerde informatie weer over een ELF-bestand. De lijst met schakelaars is relatief lang en omvat alle aspecten van het ELF-formaat. De schakelaar -n (afkorting van -notes) gebruiken Lijst 7 toont alleen de notitiesecties die bestaan in de bestandsaanraking - de ABI-versietag en de build-ID bitstring.

.Lijst 7: Geselecteerde secties van een ELF-bestand weergeven

$ readelf -n /usr/bin/touch
Aantekeningen weergeven gevonden bij bestandsoffset 0x00000254 met lengte 0x00000020:
Eigenaar Gegevensgrootte Beschrijving:
GNU 0x00000010 NT_GNU_ABI_TAG (ABI-versietag)
Besturingssysteem: Linux, ABI: 2.6.32
Aantekeningen weergeven die zijn gevonden bij bestandsoffset 0x00000274 met lengte 0x00000024:
Eigenaar Gegevensgrootte Beschrijving:
GNU 0x00000014 NT_GNU_BUILD_ID (unieke build-ID bitstring)
Build-ID: ec08d609e9e8e73d4be6134541a472ad0ea34502

Merk op dat onder Solaris en FreeBSD het hulpprogramma elfdump [7] overeenkomt met readelf. Vanaf 2019 is er sinds 2003 geen nieuwe release of update meer geweest.

Nummer drie is het pakket met de naam elfutils [6] dat puur beschikbaar is voor Linux. Het biedt alternatieve tools voor GNU Binutils en maakt het ook mogelijk ELF-bestanden te valideren. Merk op dat alle namen van de hulpprogramma's in het pakket beginnen met eu voor 'elf utils'.

Last but not least noemen we objdump mention. Deze tool is vergelijkbaar met readelf maar richt zich op objectbestanden. Het biedt een vergelijkbare reeks informatie over ELF-bestanden en andere objectformaten.

.Lijst 8: Bestandsinformatie geëxtraheerd door objdump

$ objdump -f /bin/touch
/bin/touch: bestandsformaat elf64-x86-64
architectuur: i386:x86-64, vlaggen 0x00000112:
EXEC_P, HAS_SYMS, D_PAGED
startadres 0x00000000004025e3
$

Er is ook een softwarepakket genaamd 'elfkickers' [9] dat tools bevat om de inhoud van een ELF-bestand te lezen en te manipuleren. Helaas is het aantal releases vrij laag, en daarom noemen we het maar, en laten we geen verdere voorbeelden zien.

Als ontwikkelaar kun je in plaats daarvan naar 'pax-utils' [10,11] kijken. Deze set hulpprogramma's biedt een aantal hulpmiddelen die helpen bij het valideren van ELF-bestanden. Als voorbeeld analyseert dumpelf het ELF-bestand en retourneert een C-headerbestand met de details - zie Afbeelding 2.

Conclusie

Dankzij een combinatie van slim ontwerp en uitstekende documentatie werkt het ELF-formaat erg goed, en is het na 20 jaar nog steeds in gebruik. De hierboven getoonde hulpprogramma's geven u inzicht in een ELF-bestand en laten u uitzoeken wat een programma doet. Dit zijn de eerste stappen voor het analyseren van software - happy hacking!

Links en referenties

[1] Uitvoerbaar en koppelbaar formaat (ELF), Wikipedia
[2] Fuchsia OS
[3] Vergelijking van uitvoerbare bestandsindelingen, Wikipedia
[4] Linux Foundation, gespecificeerde specificaties
[5] Ciro Santilli: ELF Hallo Wereld Zelfstudie
[6] elfutils Debian-pakket
[7] elfdump
[8] Michael Boelen: De 101 van ELF-bestanden op Linux: begrip en analyse
[9] elfkickers
[10] Geharde/PaX-hulpprogramma's
[11] pax-utils, Debian-pakket

Dankbetuigingen

De schrijver wil Axel Beckert bedanken voor zijn steun bij de voorbereiding van dit artikel.