Salta al contenuto principale

readelf: leggere dentro un file eseguibile ELF

Inviato da tuxsa il

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 $rc

Lo 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).
  • -s e --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 -d non risolve le librerie né indica se esistono sul sistema: per questo serve ldd. I due comandi si completano.
  • Un binario "strippato" ha meno informazioni. Senza sezioni di debug e senza tabella dei simboli completa, -s mostra 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 con grep, head o cut, specialmente con -s e -S su programmi grandi.
  • Altre architetture. readelf di sistema è pensato per leggere ELF dell'architettura della macchina; con binari per altre architetture (ad esempio ARM) non l'ho provato.

Riepilogo

ComandoCosa fa
readelf -h fileMostra intestazione: architettura, tipo, entry point
readelf -d file | grep NEEDEDElenca le librerie richieste, senza eseguire
readelf -l file | grep interpreterMostra il loader richiesto
readelf -S -W fileElenca le sezioni senza troncare le righe
readelf -W --dyn-syms fileSimboli dinamici con versioni di glibc
readelf -p .comment fileMostra il compilatore usato
readelf -n fileMostra note, tra cui il Build ID