Dal codice sorgente al codice binario
La programmazione inizia con l'avere un'idea intelligente e scrivere il codice sorgente in un linguaggio di programmazione di tua scelta, ad esempio C, e salvare il codice sorgente in un file. Con l'aiuto di un compilatore adeguato, ad esempio GCC, il codice sorgente viene prima tradotto in codice oggetto. Infine, il linker traduce il codice oggetto in un file binario che collega il codice oggetto con le librerie di riferimento. Questo file contiene le singole istruzioni come codice macchina che vengono comprese dalla CPU e vengono eseguite non appena viene eseguito il programma compilato.
Il file binario sopra menzionato segue una struttura specifica e uno dei più comuni si chiama ELF che abbrevia il formato eseguibile e collegabile. È ampiamente utilizzato per file eseguibili, file oggetto rilocabili, librerie condivise e core dump.
Vent'anni fa, nel 1999, il progetto 86open ha scelto ELF come formato di file binario standard per sistemi Unix e Unix-like su processori x86. Fortunatamente, il formato ELF era stato precedentemente documentato sia nell'interfaccia binaria dell'applicazione System V, sia nel Tool Interface Standard [4]. Questo fatto ha enormemente semplificato l'accordo sulla standardizzazione tra i diversi fornitori e sviluppatori di sistemi operativi basati su Unix.
La ragione alla base di tale decisione è stata la progettazione di ELF: flessibilità, estensibilità e supporto multipiattaforma per diversi formati endian e dimensioni degli indirizzi. Il design di ELF non si limita a uno specifico processore, set di istruzioni o architettura hardware. Per un confronto dettagliato dei formati di file eseguibili, dai un'occhiata qui [3].
Da allora, il formato ELF è utilizzato da diversi sistemi operativi. Tra gli altri, questo include Linux, Solaris/Illumos, Free, Net e OpenBSD, QNX, BeOS/Haiku e Fuchsia OS [2]. Inoltre, lo troverai su dispositivi mobili con sistema operativo Android, Maemo o Meego OS/Sailfish, nonché su console di gioco come PlayStation Portable, Dreamcast e Wii.
La specifica non chiarisce l'estensione del nome file per i file ELF. In uso è una varietà di combinazioni di lettere, come .axf, .bin, .elf, .o, .prx, .puff, .ko, .so e .mod o nessuna.
La struttura di un file ELF
Su un terminale Linux, il comando man elf fornisce un pratico riepilogo sulla struttura di un file ELF:
Listato 1: La manpage della struttura ELF
$ uomo undiciELF(5) Manuale del programmatore Linux ELF(5)
NOME
elf - formato dei file Executable and Linking Format (ELF)
SINOSSI
#includere
DESCRIZIONE
Il file di intestazione definisce il formato del binario eseguibile ELF
File. Tra questi file ci sono normali file eseguibili, rilocabili
file oggetto, file core e librerie condivise.
Un file eseguibile che utilizza il formato file ELF è costituito da un'intestazione ELF,
seguito da una tabella di intestazione del programma o da una tabella di intestazione di sezione o da entrambe.
L'intestazione ELF è sempre all'offset zero del file. Il programma
la tabella di intestazione e l'offset della tabella di intestazione della sezione nel file sono
definito nell'intestazione ELF. Le due tabelle descrivono il resto del
particolarità del file.
...
Come puoi vedere dalla descrizione sopra, un file ELF è composto da due sezioni: un'intestazione ELF e i dati del file. La sezione dati del file può consistere in una tabella di intestazione del programma che descrive zero o più segmenti, una tabella di intestazione di sezione che descrive zero o più sezioni, seguita dai dati a cui fanno riferimento le voci della tabella di intestazione del programma e la tabella di intestazione della sezione. Ogni segmento contiene le informazioni necessarie per l'esecuzione del file in fase di esecuzione, mentre le sezioni contengono dati importanti per il collegamento e il riposizionamento. La figura 1 lo illustra schematicamente.
L'intestazione ELF
L'intestazione ELF è lunga 32 byte e identifica il formato del file. Inizia con una sequenza di quattro byte univoci che sono 0x7F seguiti da 0x45, 0x4c e 0x46 che si traduce nelle tre lettere E, L e F. Tra gli altri valori, l'intestazione indica anche se si tratta di un file ELF per 32 o Formato a 64 bit, utilizza little o big endianness, mostra la versione ELF e per quale sistema operativo è stato compilato il file per interagire con l'interfaccia binaria dell'applicazione (ABI) e il set di istruzioni della CPU corretti.
Il dump esadecimale del tocco del file binario ha il seguente aspetto:
.Listato 2: il dump esadecimale del file binario
$ hd /usr/bin/touch | testa -500000000 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 | [e-mail protetta] @.....|
0000004 06 00 00 00 05 00 00 00 40 00 00 00 00 00 00 00 | [e-mail protetta] |
Debian GNU/Linux offre il comando readelf fornito nel pacchetto GNU 'binutils'. Accompagnato dallo switch -h (versione abbreviata per –file-header) mostra piacevolmente l'intestazione di un file ELF. Il Listato 3 illustra questo per il comando touch.
.Listato 3: Visualizzazione dell'intestazione di un file ELF
$ readelf -h /usr/bin/touchIntestazione ELF:
Magia: 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00
Classe: ELF64
Dati: complemento a 2, little endian
Versione: 1 (attuale)
Sistema operativo / ABI: UNIX - Sistema V
Versione ABI: 0
Tipo: EXEC (file eseguibile)
Macchina: Micro dispositivi avanzati X86-64
Versione: 0x1
Indirizzo del punto di ingresso: 0x4025e3
Intestazioni di inizio del programma: 64 (byte nel file)
Inizio delle intestazioni di sezione: 58408 (byte nel file)
Bandiere: 0x0
Dimensione di questa intestazione: 64 (byte)
Dimensione delle intestazioni del programma: 56 (byte)
Numero di intestazioni del programma: 9
Dimensione delle intestazioni di sezione: 64 (byte)
Numero di intestazioni di sezione: 27
Indice della tabella delle stringhe di intestazione della sezione: 26
L'intestazione del programma
L'intestazione del programma mostra i segmenti utilizzati in fase di esecuzione e indica al sistema come creare un'immagine di processo. L'intestazione del Listato 2 mostra che il file ELF è composto da 9 intestazioni di programma che hanno una dimensione di 56 byte ciascuna e la prima intestazione inizia dal byte 64.
Anche in questo caso, il comando readelf aiuta a estrarre le informazioni dal file ELF. L'opzione -l (abbreviazione di –program-headers o –segments) rivela maggiori dettagli come mostrato nel Listato 4.
.Listato 4: visualizzare le informazioni sulle intestazioni del programma
$ readelf -l /usr/bin/touchIl tipo di file Elf è EXEC (file eseguibile)
Punto di ingresso 0x4025e3
Ci sono 9 intestazioni di programma, a partire dall'offset 64
Intestazioni del programma:
Tipo Offset VirtAddr PhysAddr
FileSiz MemSiz Flags Align
PHDR 0x00000000000000040 0x00000000000400040 0x00000000000400040
0x000000000000001f8 0x000000000000001f8 R E 8
INTERP 0x000000000000238 0x00000000000400238 0x00000000000400238
0x000000000000001c 0x000000000000001c R 1
[Richiesta dell'interprete del programma: /lib64/ld-linux-x86-64.so.2]
CARICA 0x0000000000000000 0x00000000000400000 0x00000000000400000
0x000000000000d494 0x000000000000d494 R E 200000
CARICO 0x000000000000de10 0x000000000060de10 0x000000000060de10
0x0000000000000524 0x0000000000000748 RW 200000
DINAMICO 0x000000000000de28 0x000000000060de28 0x000000000060de28
0x000000000000001d0 0x000000000000001d0 RW 8
NOTA 0x000000000000254 0x00000000000400254 0x00000000000400254
0x00000000000000044 0x00000000000000044 R 4
GNU_EH_FRAME 0x000000000000bc40 0x000000000040bc40 0x000000000040bc40
0x000000000000003a4 0x000000000000003a4 R 4
GNU_STACK 0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000000 0x0000000000000000 RW 10
GNU_RELRO 0x000000000000de10 0x000000000060de10 0x000000000060de10
0x000000000000001f0 0x000000000000001f0 R 1
Mappatura da sezione a segmento:
Sezioni di segmento...
00
01 .interp
02 .interp .note.ABI-tag .note.gnu.build-id .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn .rela.plt .init .plt .text .fini . rodata .eh_frame_hdr .eh_frame
03 .init_array .fini_array .jcr .dynamic .got .got.plt .data .bss
04 .dinamico
05 .note.ABI-tag .note.gnu.build-id
06 .eh_frame_hdr
07
08 .init_array .fini_array .jcr .dynamic .got
L'intestazione della sezione
La terza parte della struttura ELF è l'intestazione della sezione. Ha lo scopo di elencare le singole sezioni del binario. L'opzione -S (abbreviazione di –section-headers o –section) elenca le diverse intestazioni. Per quanto riguarda il comando touch, ci sono 27 intestazioni di sezione e il Listato 5 mostra solo le prime quattro più l'ultima. Ogni riga copre la dimensione della sezione, il tipo di sezione, nonché il suo indirizzo e l'offset di memoria.
.Listato 5: dettagli della sezione rivelati da readelf
$ readelf -S /usr/bin/touchCi sono 27 intestazioni di sezione, a partire dall'offset 0xe428:
Intestazioni di sezione:
[Nr] Nome Tipo Indirizzo Offset
Dimensione EntSize Flags Link Info Align
[ 0] NULL 0000000000000000 00000000
0000000000000000 0000000000000000 0 0 0
[1] .interp PROGBITS 0000000000400238 00000238
000000000000001c 0000000000000000 A 0 0 1
[2] .nota.Tag ABI NOTA 0000000000400254 00000254
00000000000000020 0000000000000000 A 0 0 4
[ 3] .note.gnu.build-i NOTA 0000000000400274 00000274
...
...
[26] .shstrtab STRTAB 0000000000000000 0000e334
000000000000000ef 0000000000000000 0 0 1
Legenda delle bandiere:
W (scrittura), A (alloc), X (esecuzione), M (unione), S (stringhe), l (grande)
I (info), L (ordine dei collegamenti), G (gruppo), T (TLS), E (escludi), x (sconosciuto)
O (elaborazione aggiuntiva del sistema operativo richiesta) o (specifico del sistema operativo), p (specifico del processore)
Strumenti per analizzare un file ELF
Come avrai notato dagli esempi sopra, GNU/Linux è arricchito con una serie di strumenti utili che ti aiutano ad analizzare un file ELF. Il primo candidato a cui daremo un'occhiata è l'utilità file.
file visualizza le informazioni di base sui file ELF, inclusa l'architettura del set di istruzioni per cui è destinato il codice in un file oggetto rilocabile, eseguibile o condiviso. Nel listato 6 ti dice che /bin/touch è un file eseguibile a 64 bit che segue la Linux Standard Base (LSB), collegato dinamicamente e costruito per il kernel GNU/Linux versione 2.6.32.
.Listato 6: Informazioni di base utilizzando il file
$ file /bin/touch/bin/touch: eseguibile ELF LSB a 64 bit, x86-64, versione 1 (SYSV), linkato dinamicamente, interprete /lib64/l,
per GNU/Linux 2.6.32, BuildID[sha1]=ec08d609e9e8e73d4be6134541a472ad0ea34502, rimosso
$
Il secondo candidato è riletto. Visualizza informazioni dettagliate su un file ELF. L'elenco delle opzioni è relativamente lungo e copre tutti gli aspetti del formato ELF. Utilizzo dell'opzione -n (abbreviazione di –notes) Il Listato 7 mostra solo le sezioni delle note che esistono nel file touch: il tag della versione ABI e la stringa di bit dell'ID build.
.Listato 7: Visualizza le sezioni selezionate di un file ELF
$ readelf -n /usr/bin/touchVisualizzazione delle note trovate nell'offset del file 0x000000254 con lunghezza 0x0000020:
Proprietario Dimensione dati Descrizione
GNU 0x0000010 NT_GNU_ABI_TAG (tag versione ABI)
Sistema operativo: Linux, ABI: 2.6.32
Visualizzazione delle note trovate nell'offset del file 0x000000274 con lunghezza 0x00000024:
Proprietario Dimensione dati Descrizione
GNU 0x00000014 NT_GNU_BUILD_ID (stringa di bit ID build univoca)
ID build: ec08d609e9e8e73d4be6134541a472ad0ea34502
Nota che sotto Solaris e FreeBSD, l'utility elfdump [7] corrisponde a readelf. A partire dal 2019, non c'è stata una nuova versione o aggiornamento dal 2003.
Il numero tre è il pacchetto chiamato elfutils [6] che è disponibile esclusivamente per Linux. Fornisce strumenti alternativi a GNU Binutils e consente anche di convalidare i file ELF. Nota che tutti i nomi delle utilità fornite nel pacchetto iniziano con eu per 'elf utils'.
Ultimo ma non meno importante menzioneremo objdump. Questo strumento è simile a readelf ma si concentra sui file oggetto. Fornisce una gamma simile di informazioni sui file ELF e altri formati di oggetti.
.Listato 8: informazioni sul file estratte da objdump
$ objdump -f /bin/touch/bin/touch: formato file elf64-x86-64
architettura: i386:x86-64, flag 0x00000112:
EXEC_P, HAS_SYMS, D_PAGED
indirizzo iniziale 0x0000000000004025e3
$
Esiste anche un pacchetto software chiamato 'elfkickers' [9] che contiene strumenti per leggere il contenuto di un file ELF e per manipolarlo. Sfortunatamente, il numero di versioni è piuttosto basso, ed è per questo che lo menzioniamo e non mostriamo ulteriori esempi.
Come sviluppatore potresti invece dare un'occhiata a 'pax-utils' [10,11]. Questo insieme di utilità fornisce una serie di strumenti che aiutano a convalidare i file ELF. Ad esempio, dumpelf analizza il file ELF e restituisce un file di intestazione C contenente i dettagli – vedere la Figura 2.
Conclusione
Grazie a una combinazione di design intelligente e documentazione eccellente, il formato ELF funziona molto bene ed è ancora in uso dopo 20 anni. Le utilità mostrate sopra consentono una visione approfondita di un file ELF e consentono di capire cosa sta facendo un programma. Questi sono i primi passi per analizzare il software: buon hacking!
Link e riferimenti
- [1] Formato eseguibile e collegabile (ELF), Wikipedia
- [2] Fucsia OS
- [3] Confronto tra formati di file eseguibili, Wikipedia
- [4] Linux Foundation, specifiche di riferimento
- [5] Ciro Santilli: ELF Hello World Tutorial
- [6] elfutils pacchetto Debian
- [7] elfdump
- [8] Michael Boelen: I 101 file ELF su Linux: comprensione e analisi
- [9] elfkickers
- [10] Utilità Hardened/PaX
- [undici] pax-utils, pacchetto Debian
Ringraziamenti
Chi scrive desidera ringraziare Axel Beckert per il suo supporto nella preparazione di questo articolo.