Il developer zecoxao ha condiviso su X una porzione di codice evidenziando una vulnerabilità critica nel sistema operativo SceKernel, utilizzato da Sony all’interno della console PlayStation 4 e PlayStation 5.

Il codice, pubblicato su Pastebin, è un Proof of Concept (PoC) che dimostra un bug nella funzione aio_multi_delete(), portando a un problema di tipo Double Free.

https://t.co/ZatXCnBVbY

— Jose Coixao (@notnotzecoxao) April 22, 2025

SceKernel è il kernel (il cuore del sistema operativo) utilizzato da Sony per le sue console, come PlayStation 4, PlayStation 5, PlayStation Vita e altre.

Il prefisso “Sce” sta per Sony Computer Entertainment, e il kernel gestisce operazioni di basso livello, come la gestione delle operazioni asincrone di input/output (AIO), che permettono di leggere o scrivere dati (es. su disco o memoria) senza bloccare il thread principale.

Il bug è stato identificato nella funzione aio_multi_delete(), parte del sistema AIO di SceKernel, e riguarda una vulnerabilità di tipo Double Free.

Il PoC condiviso da zecoxao dimostra come questa vulnerabilità possa essere sfruttata, creando una race condition (condizione di gara) che può causare instabilità del sistema o consentire l’esecuzione di codice malevolo.

Il titolo del PoC descrive il problema: “La gestione impropria dei blocchi (locking) in aio_multi_delete() porta a un Double Free”.

AIO (Asynchronous I/O):

Le operazioni AIO consentono di gestire richieste di lettura (READ) o scrittura (WRITE) in modo asincrono, migliorando le prestazioni su dispositivi che eseguono molte operazioni I/O.

Ad esempio, un gioco PS4 potrebbe usare AIO per caricare texture senza interrompere il gameplay. Il codice definisce funzioni come:

• aio_submit_cmd(): Invia richieste AIO (es. lettura o scrittura).
• aio_multi_wait(): Aspetta il completamento delle richieste.
• aio_multi_delete(): Cancella le richieste AIO.

Double Free:

• Un Double Free si verifica quando una porzione di memoria viene liberata due volte. Questo può causare:
  • Corruzione della memoria: Dati importanti vengono sovrascritti.
  • Crash del sistema: Il kernel potrebbe terminare il processo o bloccarsi.
  • Vulnerabilità di sicurezza: Un attaccante potrebbe sfruttare il bug per manipolare la memoria ed eseguire codice non autorizzato (es. homebrew o exploit per jailbreak).

Improper Locking:

• Il problema deriva da una mancanza di sincronizzazione (locking) nella funzione aio_multi_delete(). Quando più thread tentano di cancellare la stessa richiesta AIO contemporaneamente, la memoria associata a quella richiesta viene liberata più volte, causando il Double Free.
• Un locking adeguato (es. usando mutex o semafori) avrebbe prevenuto questo problema, assicurando che un solo thread alla volta possa cancellare una richiesta.

Funzionamento

Il codice condiviso da zecoxao è un programma dimostrativo che crea una race condition per sfruttare il bug. Ecco un’analisi dettagliata del funzionamento:

Definizioni di Base:

• Il codice definisce costanti per i comandi AIO:
  • SCE_KERNEL_AIO_CMD_READ (0x001): Per operazioni di lettura.
  • SCE_KERNEL_AIO_CMD_WRITE (0x002): Per operazioni di scrittura.
  • SCE_KERNEL_AIO_CMD_MULTI (0x1000): Flag per gestire più richieste contemporaneamente.
• Definisce una struttura SceKernelAioRWRequest per rappresentare una richiesta AIO, con parametri come:
  • fd (file descriptor): Identificatore del file.
  • buf (buffer): Area di memoria per i dati.
  • offset e nbyte: Posizione e dimensione dei dati da leggere/scrivere.
• Definisce funzioni come aio_submit_cmd(), aio_multi_wait(), e aio_multi_delete() per gestire le richieste AIO.

Setup della Race Condition:

• Il programma crea tre richieste AIO (num_reqs = 3) e usa un array di ID (ids) per identificarle.
• Utilizza una barriera di sincronizzazione (pthread_barrier_t) per coordinare due thread: il thread principale e un thread secondario (race_thread).

Invio delle Richieste AIO:

• Con aio_submit_cmd(), il programma invia tre richieste di scrittura (SCE_KERNEL_AIO_CMD_WRITE) con priorità alta (SCE_KERNEL_AIO_PRIORITY_HIGH) e il flag SCE_KERNEL_AIO_CMD_MULTI.
• Aspetta che tutte le richieste siano completate con aio_multi_wait() in modalità SCE_KERNEL_AIO_WAIT_AND (aspetta tutte le richieste).

Creazione della Race Condition:

• Il thread principale e il thread secondario (race_func) tentano di cancellare la stessa richiesta AIO (ids[which_req]) contemporaneamente, usando aio_multi_delete().
• La barriera (pthread_barrier_wait) sincronizza i thread per eseguire la cancellazione nello stesso momento, creando una race condition.

Verifica del Double Free:

• Se il bug è presente, la memoria associata alla richiesta AIO viene liberata due volte (Double Free).
• Il programma controlla gli errori restituiti (race_errs):
  • Se entrambi i thread restituiscono 0 (nessun errore), il Double Free è avvenuto senza essere rilevato.
  • Se un thread restituisce SCE_KERNEL_ERROR_ESRCH (0x80020003, “risorsa non trovata”), significa che un thread ha cancellato la richiesta prima dell’altro, evitando il Double Free.
• Se il Double Free avviene, il programma stampa: “Double Free achieved!”.

Loop di Tentativi:

• Il programma ripete il processo 100 volte (for (int i = 0; i < 100; i++)) per aumentare le probabilità di sfruttare la race condition, dato che il successo dipende dal timing dei thread.

Ultimi sviluppi