Salta al contenuto principale

objdump: disassemblare e ispezionare un binario

Inviato da tuxsa il

Hai un eseguibile e vuoi capire cosa fa una sua funzione, senza i sorgenti. Oppure vuoi verificare cosa ha prodotto il compilatore da una riga di C, o sapere quali simboli contiene un file oggetto. objdump mostra il codice macchina in forma leggibile (assembly) e molto altro, senza eseguire il file.

Cos'è

objdump è uno strumento del pacchetto binutils (si installa con sudo apt install binutils, spesso già presente). Legge file oggetto, librerie ed eseguibili, in formato ELF su Linux, e ne mostra il contenuto. È il fratello maggiore di readelf: readelf descrive la struttura del file; objdump in più sa disassemblare, cioè tradurre i byte del codice nelle istruzioni del processore.

Cosa fa

Con objdump si può: leggere le istruzioni di una funzione, affiancare al codice macchina le righe di sorgente corrispondenti (se il binario ha le informazioni di debug), elencare le sezioni e i simboli, vedere le rilocazioni di un file oggetto e scaricare in esadecimale il contenuto di una sezione. Non esegue mai il programma.

Come si usa

$ objdump [opzioni] file...

Senza opzioni non stampa nulla di utile: bisogna indicare cosa mostrare. Gli esempi usano un programma C di prova, h.c, con una funzione quadruplo e un main che la chiama, compilato su Ubuntu 24.04 per x86-64 (binutils 2.42). Gli output sono reali; ho tolto qualche riga vuota o di contorno, e dove serve lo scrivo. Nell'output originale i campi sono separati da tabulazioni: qui le ho sostituite con spazi.

Esempio 1: informazioni generali e sezioni

$ objdump -f h
h:     file format elf64-x86-64
architecture: i386:x86-64, flags 0x00000150:
HAS_SYMS, DYNAMIC, D_PAGED
start address 0x0000000000001060

$ objdump -p h | grep NEEDED
  NEEDED               libc.so.6

$ objdump -h h | sed -n 4,6p | cut -c1-70
Sections:
Idx Name          Size      VMA               LMA               File off  Algn
  0 .interp       0000001c  0000000000000318  0000000000000318  00000318  2**0

-f riassume il formato, l'architettura e l'indirizzo di partenza; -p mostra i "private headers", tra cui le librerie richieste (NEEDED); -h elenca le sezioni con dimensione e indirizzo (qui solo le prime righe). Sono informazioni che dà anche readelf, con un formato diverso.

Esempio 2: disassemblare una funzione

$ objdump -d --no-show-raw-insn --disassemble=quadruplo h
0000000000001149 <quadruplo>:
    1149:   endbr64
    114d:   push   %rbp
    114e:   mov    %rsp,%rbp
    1151:   mov    %edi,-0x4(%rbp)
    1154:   mov    -0x4(%rbp),%eax
    1157:   shl    $0x2,%eax
    115a:   pop    %rbp
    115b:   ret

-d disassembla le sezioni con codice; --disassemble=nome limita l'output a una sola funzione (altrimenti escono centinaia di righe anche per un programma minuscolo). --no-show-raw-insn toglie la colonna con i byte esadecimali, per leggere meglio. Nell'output reale compaiono anche le intestazioni delle altre sezioni (.init, .plt...) e la sezione .fini, che ho omesso. Si riconosce l'argomento che arriva nel registro %edi e la moltiplicazione per 4, che il compilatore ha trasformato in uno scorrimento di 2 bit (shl $0x2). Questo è codice compilato senza ottimizzazioni (-O0): con ottimizzazioni sarebbe diverso.

Esempio 3: sintassi Intel e chiamate tra funzioni

$ objdump -d -M intel --no-show-raw-insn --disassemble=quadruplo h
    1151:   mov    DWORD PTR [rbp-0x4],edi
    1154:   mov    eax,DWORD PTR [rbp-0x4]
    1157:   shl    eax,0x2

$ objdump -d --no-show-raw-insn --disassemble=main h | grep call
    1169:   call   1149 <quadruplo>
    117f:   call   1050 <printf@plt>

Per default objdump usa la sintassi AT&T (mov origine,destinazione, registri con %). Con -M intel passa alla sintassi Intel, che molti trovano più leggibile (mov destinazione,origine). Il primo comando l'ho abbreviato alle tre righe centrali. Filtrare con grep call è un modo rapido per vedere quali funzioni ne chiamano altre: qui main chiama quadruplo e printf (tramite la tabella @plt, il meccanismo per le funzioni di libreria).

Esempio 4: affiancare il codice sorgente

$ objdump -d -S --no-show-raw-insn --disassemble=quadruplo h
0000000000001149 <quadruplo>:
#include <stdio.h>
int quadruplo(int x){return x*4;}
    1149:   endbr64
    114d:   push   %rbp
    114e:   mov    %rsp,%rbp
    ...

-S intercala il sorgente alle istruzioni, ma funziona solo se il binario è stato compilato con -g e se il file sorgente è ancora disponibile nello stesso percorso. Nel mio test ha mostrato le righe del sorgente sopra l'inizio della funzione. Ho accorciato l'output con "...". Con ottimizzazioni attive la corrispondenza tra righe e istruzioni è meno lineare.

Esempio 5: simboli e binari "strippati"

$ objdump -t h | grep -E 'quadruplo|main'
0000000000001149 g     F .text  0000000000000013              quadruplo
000000000000115c g     F .text  000000000000002f              main

$ objdump -t hs
hs:     file format elf64-x86-64

SYMBOL TABLE:
no symbols

-t stampa la tabella dei simboli: nome, indirizzo, dimensione e sezione (F indica una funzione). Il secondo comando è su una copia del programma a cui ho tolto i simboli con strip: la tabella è vuota e --disassemble=quadruplo non troverebbe nulla. Restano i simboli dinamici, cioè le funzioni importate dalle librerie, che si vedono con -T. Per i programmi C++ -C traduce i nomi "storpiati" dal compilatore: nel mio test _Z1fi diventa f(int).

Esempio 6: rilocazioni in un file oggetto

$ objdump -dr --no-show-raw-insn h.o | grep -E 'call|R_X86' | cut -c1-70
  20:   call   25 <main+0x12>
            21: R_X86_64_PLT32  quadruplo-0x4
  36:   call   3b <main+0x28>
            37: R_X86_64_PLT32  printf-0x4

In un file .o non ancora collegato, gli indirizzi delle funzioni esterne non sono noti: dopo ogni call l'indirizzo è un segnaposto, e -r mostra le rilocazioni, cioè le istruzioni che il linker dovrà completare. Qui il compilatore ha lasciato da sistemare i riferimenti a quadruplo e printf.

Esempio 7: contenuto di una sezione in esadecimale

$ objdump -s -j .rodata h
h:     file format elf64-x86-64

Contents of section .rodata:
 2000 01000200 25640a00                    ....%d..

-s scarica il contenuto delle sezioni in esadecimale con a destra la versione testuale; -j sezione la limita a una sola. Nella sezione .rodata si ritrova la stringa di formato %d\n usata da printf. Lo stesso comando su .comment mostra il compilatore con cui è stato prodotto il binario.

Esempio 8: uso negli script

#!/bin/bash
# Mostra il disassemblato di una funzione di un binario (sintassi Intel)
[ $# -eq 2 ] || { echo "Uso: $0 binario funzione" >&2; exit 2; }
command -v objdump >/dev/null || { echo "objdump non trovato (binutils)" >&2; exit 3; }
[ -f "$1" ] || { echo "$1: file inesistente" >&2; exit 1; }
out=$(objdump -d -M intel --no-show-raw-insn --disassemble="$2" "$1" 2>/dev/null) \
    || { echo "$1: formato non riconosciuto" >&2; exit 1; }
echo "$out" | sed -n "/<$2>:/,/^\$/p" | grep -q . || {
    echo "$2: funzione non trovata (binario senza simboli?)" >&2; exit 1; }
echo "$out" | sed -n "/<$2>:/,/^\$/p"

Lo script prende un binario e il nome di una funzione e ne stampa il disassemblato in sintassi Intel, senza le sezioni circostanti. Esce con 0 se trova la funzione, 1 se il file non esiste, non è riconosciuto o la funzione non c'è, 2 con un numero di argomenti sbagliato e 3 se objdump manca. Si usa così: ./fn.sh h quadruplo. Nel mio test ha funzionato con la funzione presente, con la versione "strippata" del binario, con una funzione inesistente, con un file di testo e con un percorso inesistente. Il nome della funzione viene usato in un'espressione di sed: va bene per nomi semplici come quelli del C, non per nomi con caratteri speciali.

Opzioni utili

  • -d: disassembla le sezioni di codice. -D disassembla tutte le sezioni, anche i dati (utile per forzare, ma l'output ha poco senso sui dati).
  • --disassemble=simbolo: solo la funzione indicata.
  • -M intel: sintassi Intel invece di AT&T.
  • --no-show-raw-insn: toglie i byte esadecimali accanto alle istruzioni.
  • -S: affianca il sorgente (serve -g in compilazione).
  • -t / -T: tabella dei simboli / dei soli simboli dinamici. -C per i nomi C++.
  • -h, -f, -p: sezioni, riepilogo del file, intestazioni private (librerie richieste).
  • -r: mostra le rilocazioni (utile con -d sui file .o).
  • -s e -j sezione: contenuto delle sezioni in esadecimale, limitato a una.
  • --start-address=INDIRIZZO e --stop-address=INDIRIZZO: disassembla solo un intervallo.

Attenzione a

  • Il disassemblato dipende dal compilatore e dalle ottimizzazioni. Lo stesso C produce codice diverso con -O0 e -O2. Quello che si legge non è il sorgente originale, ma una sua traduzione.
  • Servono i simboli per trovare le funzioni per nome. Su un binario "strippato" --disassemble=nome non trova nulla: bisogna disassemblare per intervallo di indirizzi o partire dall'indirizzo di partenza (-f).
  • Disassemblare non è eseguire. objdump non lancia il file, quindi si può usare anche su un binario sospetto. Non dice però cosa farà, e leggere assembly richiede esperienza.
  • L'output è lunghissimo. Anche un programma di 3 righe produce molte righe di disassemblato se si usa -d senza limitarlo. Meglio --disassemble=funzione o un filtro con grep, sed e head.
  • È legato all'architettura. Il objdump di sistema, per il suo processore, può non riconoscere binari di altre architetture (ad esempio ARM): non l'ho provato.
  • Dati scambiati per istruzioni. Con -D o con intervalli sbagliati i dati vengono disassemblati come se fossero codice, e l'output sembra sensato ma non lo è.

Riepilogo

ComandoCosa fa
objdump -f fileMostra formato, architettura e indirizzo di partenza
objdump -d --disassemble=f fileDisassembla la funzione f
objdump -d -M intel fileDisassembla con sintassi Intel
objdump -d -S fileDisassembla affiancando il sorgente (con -g)
objdump -t fileElenca i simboli
objdump -T fileElenca i simboli dinamici
objdump -dr file.oDisassembla mostrando le rilocazioni
objdump -s -j .rodata fileScarica una sezione in esadecimale