Hai un binario e vuoi sapere per quale architettura è compilato, da quali librerie dipende, se contiene informazioni di debug o quale versione minima di glibc richiede. Non vuoi eseguirlo, magari perché non ti fidi, e non hai i sorgenti. readelf legge la struttura interna del file e te lo dice.
Cos'è
readelf è un programma che mostra il contenuto dei file in formato ELF (Executable and Linkable Format), il formato usato su Linux per eseguibili, librerie condivise (.so) e file oggetto (.o). Fa parte del pacchetto binutils, che su Debian e Ubuntu si installa con sudo apt install binutils (di solito c'è già, se è presente un compilatore).
Cosa fa
Un file ELF è organizzato in parti: un'intestazione iniziale, le sezioni (.text per il codice, .rodata per i dati in sola lettura, .dynamic per le informazioni di collegamento...), i segmenti che il sistema carica in memoria e le tabelle dei simboli. readelf legge direttamente il file e stampa queste strutture, senza mai eseguire il programma. A differenza di ldd, quindi, è sicuro anche su file di cui non ci si fida.
Come si usa
$ readelf [opzioni] file...Senza opzioni non stampa nulla di utile: bisogna dire cosa mostrare. Gli output seguenti sono quelli reali del mio test su Ubuntu 24.04 (binutils 2.42), con un piccolo programma C che stampa "ciao". Alcuni sono accorciati o filtrati, e lo scrivo ogni volta. Su un sistema con locale italiano certe etichette possono essere tradotte.
Esempio 1: l'intestazione del file
$ readelf -h h | head -11
ELF Header:
Magic: 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00
Class: ELF64
Data: 2's complement, little endian
Version: 1 (current)
OS/ABI: UNIX - System V
ABI Version: 0
Type: DYN (Position-Independent Executable file)
Machine: Advanced Micro Devices X86-64
Version: 0x1
Entry point address: 0x1060-h mostra l'intestazione. I campi che interessano di più sono Class (32 o 64 bit), Machine (l'architettura: un binario per x86-64 non gira su ARM) e Type. Type distingue un eseguibile (DYN se è "position-independent", come la maggior parte oggi; EXEC per i vecchi eseguibili e per quelli statici), una libreria condivisa (DYN) e un file oggetto non ancora collegato (REL). Nel mio test il programma normale e /bin/ls risultano DYN, quello compilato con -static EXEC, il file .o REL.
Esempio 2: da quali librerie dipende
$ readelf -d h | grep NEEDED
0x0000000000000001 (NEEDED) Shared library: [libc.so.6]
$ readelf -d h | grep -E 'RUNPATH|RPATH'
0x000000000000001d (RUNPATH) Library runpath: [/opt/lib]-d mostra la sezione dinamica, dove ogni riga NEEDED è una libreria richiesta. È l'alternativa che non esegue nulla a ldd, ma mostra solo le dipendenze dirette, non quelle delle librerie a loro volta. La seconda riga viene da un binario che ho compilato apposta con un percorso di ricerca incorporato (-Wl,-rpath,/opt/lib): RUNPATH o RPATH sono cartelle in cui il loader cerca le librerie, prima di quelle di sistema. Su una libreria condivisa readelf -d mostra anche la riga SONAME, il nome con cui la libreria si presenta (lo usa ldconfig).
Esempio 3: l'interprete e i binari statici
$ readelf -l h | grep interpreter
[Requesting program interpreter: /lib64/ld-linux-x86-64.so.2]
$ readelf -l hs | grep -c INTERP
0
$ readelf -d hs
There is no dynamic section in this file.-l mostra i segmenti (program headers). Se c'è una riga con l'interpreter, il programma è dinamico e il kernel lo affiderà a quel loader. Il binario statico (hs, compilato con gcc -static) non ha né interprete né sezione dinamica: si vede subito perché ldd in quel caso risponde "not a dynamic executable".
Esempio 4: sezioni e informazioni di debug
$ readelf -S -W h | cut -c1-60 | sed -n 4,7p
[Nr] Name Type Address Of
[ 0] NULL 0000000000000000 00
[ 1] .interp PROGBITS 0000000000000318 00
[ 2] .note.gnu.property NOTE 0000000000000338 0
$ readelf -S -W hg | grep -c debug
6
$ readelf -S -W h | grep -c debug
0-S elenca le sezioni; -W (wide) evita che le righe vengano tagliate a 80 colonne, per questo qui le ho accorciate io con cut. Il conteggio di quelle che contengono "debug" è un modo rapido per capire se un binario porta le informazioni di debug: nel mio test il programma compilato con -g ne ha 6, quello senza nessuna. Nei binari di produzione di solito sono tolte (con strip) per risparmiare spazio.
Esempio 5: simboli e versione minima di glibc
$ readelf -W --dyn-syms h | tr -s ' ' | sed -n 3,6p
Num: Value Size Type Bind Vis Ndx Name
0: 0000000000000000 0 NOTYPE LOCAL DEFAULT UND
1: 0000000000000000 0 FUNC GLOBAL DEFAULT UND __libc_start_main@GLIBC_2.34 (2)
2: 0000000000000000 0 NOTYPE WEAK DEFAULT UND _ITM_deregisterTMCloneTable
$ readelf -W --dyn-syms h | grep -o 'GLIBC_[0-9.]*' | sort -u
GLIBC_2.2.5
GLIBC_2.34--dyn-syms stampa i simboli dinamici: le funzioni che il programma importa dalle librerie (colonna UND, "undefined", da cercare altrove) o che esporta. Il nome è seguito dalla versione della libreria richiesta, e questo permette di sapere quale glibc serve almeno: qui la 2.34. È utile prima di copiare un binario su un sistema più vecchio. Ho compresso gli spazi con tr -s per far stare le righe nella pagina. L'opzione -V fornisce le stesse informazioni in forma di tabella delle versioni richieste.
Esempio 6: compilatore e identificativo di build
$ readelf -p .comment h
String dump of section '.comment':
[ 0] GCC: (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0
$ readelf -n h | grep 'Build ID'
Build ID: 4407f83ba32a4784a6b44718ef2d4a6fcd993f24-p .comment stampa come testo il contenuto di una sezione: qui rivela con quale compilatore è stato prodotto il binario. -x .rodata fa lo stesso in esadecimale (nel mio test ho trovato la stringa ciao). -n mostra le note, tra cui il Build ID, un identificatore unico della compilazione che serve ad associare un eseguibile ai suoi simboli di debug. Il valore mostrato è quello del mio file di prova.
Esempio 7: uso negli script
#!/bin/bash
# Riassume un file ELF: tipo, architettura, interprete e librerie richieste
[ $# -ge 1 ] || { echo "Uso: $0 file..." >&2; exit 2; }
command -v readelf >/dev/null || { echo "readelf non trovato (binutils)" >&2; exit 3; }
rc=0
for f in "$@"; do
[ -f "$f" ] || { echo "$f: file inesistente" >&2; rc=1; continue; }
if ! hdr=$(readelf -h "$f" 2>/dev/null); then
echo "$f: non e' un file ELF" >&2; rc=1; continue
fi
tipo=$(echo "$hdr" | awk -F: '/Type:/ {print $2}' | awk '{print $1}')
arch=$(echo "$hdr" | awk -F: '/Machine:/ {print $2}' | xargs)
interp=$(readelf -l "$f" 2>/dev/null | awk -F': |]' '/interpreter/ {print $2}')
libs=$(readelf -d "$f" 2>/dev/null | awk -F'[][]' '/NEEDED/ {print $2}' | xargs)
echo "$f: $tipo, $arch"
echo " interprete: ${interp:--}"
echo " librerie: ${libs:--}"
done
exit $rcLo script stampa, per ogni file, tipo, architettura, interprete e librerie richieste. readelf -h esce con errore se il file non è un ELF, ed è proprio ciò che lo script usa per distinguere un binario da un file qualsiasi. Esce con 0 se tutto va bene, 1 se almeno un file è inesistente o non è un ELF, 2 senza argomenti e 3 se readelf manca. Nei miei test, con un binario dinamico, uno statico, un file oggetto, un file di testo, un percorso inesistente e /bin/ls, ha dato i risultati attesi: per /bin/ls ad esempio DYN, Advanced Micro Devices X86-64, interprete /lib64/ld-linux-x86-64.so.2 e librerie libselinux.so.1 libc.so.6. Si usa così: ./riassunto.sh /usr/local/bin/*.
Opzioni utili
-h: intestazione ELF (architettura, tipo, entry point).-l: segmenti (program headers), compreso l'interprete.-S: elenco delle sezioni.-d: sezione dinamica (NEEDED,SONAME,RUNPATH).-se--dyn-syms: tabella dei simboli e dei soli simboli dinamici.-V: versioni dei simboli richieste o fornite.-n: note (ad esempio il Build ID).-p sezione/-x sezione: contenuto di una sezione come testo / in esadecimale.-a: tutto quanto, con un output molto lungo.-W: righe larghe, senza troncamento a 80 colonne.
Attenzione a
- Funziona solo con file ELF. Su un file di testo, uno script o un eseguibile di un altro formato dà errore e codice 1. Nel mio test su un file di testo il messaggio era
Failed to read file's magic number. Uno script, ad esempio, non ha sezione dinamica: per sapere quale interprete usa si guarda la prima riga (lo shebang). - Mostra le dipendenze dirette.
readelf -dnon risolve le librerie né indica se esistono sul sistema: per questo serveldd. I due comandi si completano. - Un binario "strippato" ha meno informazioni. Senza sezioni di debug e senza tabella dei simboli completa,
-smostra poco. I simboli dinamici restano, perché servono al loader. - Stringhe e note sono dichiarazioni. Compilatore e Build ID dicono come il file si presenta, non garantiscono da dove venga. Non sono una verifica di autenticità.
- Output lungo e molto tecnico. Senza
-W, righe larghe vengono tagliate. Conviene filtrare congrep,headocut, specialmente con-se-Ssu programmi grandi. - Altre architetture.
readelfdi sistema è pensato per leggere ELF dell'architettura della macchina; con binari per altre architetture (ad esempio ARM) non l'ho provato.
Riepilogo
| Comando | Cosa fa |
|---|---|
readelf -h file | Mostra intestazione: architettura, tipo, entry point |
readelf -d file | grep NEEDED | Elenca le librerie richieste, senza eseguire |
readelf -l file | grep interpreter | Mostra il loader richiesto |
readelf -S -W file | Elenca le sezioni senza troncare le righe |
readelf -W --dyn-syms file | Simboli dinamici con versioni di glibc |
readelf -p .comment file | Mostra il compilatore usato |
readelf -n file | Mostra note, tra cui il Build ID |