StackRot (CVE-2023-3269): Vulnerabilità di escalation dei privilegi nel kernel Linux

(Exploit verificato tramite GitHub-CI)

È stato riscontrato un difetto nella gestione dell'espansione dello stack nel kernel Linux dalla versione 6.1 alla 6.4, noto come "Stack Rot". L'albero degli aceri (maple tree), responsabile della gestione delle aree di memoria virtuale, può subire la sostituzione di nodi senza acquisire correttamente il lock MM in scrittura, portando a problemi di use-after-free. Un utente locale senza privilegi potrebbe sfruttare questo difetto per compromettere il kernel ed elevare i propri privilegi.

Poiché StackRot è una vulnerabilità del kernel Linux individuata nel sottosistema di gestione della memoria, colpisce quasi tutte le configurazioni del kernel e richiede capacità minime per essere innescata. Va tuttavia notato che i nodi dell'albero degli aceri vengono liberati tramite callback RCU, ritardando la effettiva deallocazione della memoria fino al termine del periodo di grazia RCU. Di conseguenza, lo sfruttamento di questa vulnerabilità è considerato complesso.

Al meglio delle mie conoscenze, attualmente non esistono exploit pubblicamente disponibili che prendano di mira bug di use-after-free-by-RCU (UAFBR). Questo rappresenta il primo caso in cui bug UAFBR si sono dimostrati sfruttabili, anche in assenza delle impostazioni CONFIG_PREEMPT o CONFIG_SLAB_MERGE_DEFAULT. In particolare, questo exploit è stato dimostrato con successo nell'ambiente fornito da Google kCTF VRP (bzImage_upstream_6.1.25, config).

La vulnerabilità StackRot è presente nel kernel Linux dalla versione 6.1, quando la struttura dell'albero VMA è stata modificata da alberi rosso-neri ad alberi degli aceri.

Contesto

Ogni volta che la chiamata di sistema mmap() viene utilizzata per stabilire un mapping di memoria, il kernel crea una struttura chiamata vm_area_struct per rappresentare la corrispondente area di memoria virtuale (VMA). Questa struttura memorizza varie informazioni tra cui flag, proprietà e altri dettagli pertinenti relativi al mapping.```c struct vm_area_struct { long unsigned int vm_start; /* 0 8 / long unsigned int vm_end; / 8 8 / struct mm_struct * vm_mm; / 16 8 / pgprot_t vm_page_prot; / 24 8 / long unsigned int vm_flags; / 32 8 / union { struct { struct rb_node rb attribute((aligned(8))); / 40 24 / / --- cacheline 1 boundary (64 bytes) --- / long unsigned int rb_subtree_last; / 64 8 / } attribute((aligned(8))) shared attribute((aligned(8))); / 40 32 / struct anon_vma_name * anon_name; / 40 8 / } attribute((aligned(8))); / 40 32 / / --- cacheline 1 boundary (64 bytes) was 8 bytes ago --- / struct list_head anon_vma_chain; / 72 16 / struct anon_vma * anon_vma; / 88 8 / const struct vm_operations_struct * vm_ops; / 96 8 / long unsigned int vm_pgoff; / 104 8 / struct file * vm_file; / 112 8 / void * vm_private_data; / 120 8 / / --- cacheline 2 boundary (128 bytes) --- / atomic_long_t swap_readahead_info; / 128 8 / struct vm_userfaultfd_ctx vm_userfaultfd_ctx; / 136 0 */

    /* size: 136, cachelines: 3, members: 14 */
    /* forced alignments: 1 */
    /* last cacheline: 8 bytes */

} attribute((aligned(8)));

Successivamente, quando il kernel incontra page fault o altre chiamate di sistema
legate alla memoria, necessita di una ricerca rapida del VMA basata esclusivamente sull'indirizzo.
In precedenza, i VMA erano gestiti tramite alberi rosso-neri. Tuttavia, a partire
dalla versione 6.1 del kernel Linux, è avvenuta la migrazione agli alberi maple. [Maple
trees][mt] sono strutture dati ad albero B RCU-safe ottimizzate per memorizzare
intervalli non sovrapposti. Tuttavia, la loro natura intricata aggiunge complessità
al codebase e introduce la vulnerabilità StackRot.

 [mt]: https://docs.kernel.org/6.4/core-api/maple_tree.html

Alla base, un albero maple è composto da nodi maple. Sebbene la struttura dell'albero
possa essere complessa, è importante notare che questa complessità non ha nulla a che fare
con il bug StackRot. Pertanto, in questo articolo, si assume che
l'albero maple sia costituito da un solo nodo, cioè il nodo radice.

Questo nodo radice può contenere fino a 16 intervalli. Questi intervalli possono
rappresentare un gap o puntare a un VMA. Poiché anche i gap contano come intervalli, tutti
gli intervalli sono collegati sequenzialmente, risultando nella necessità di soli 15
punti finali, noti anche come pivot, all'interno della struttura del nodo. Si noti che
il punto finale più a sinistra e il punto finale più a destra sono omessi, poiché possono essere
recuperati dal nodo padre.```c
struct maple_range_64 {
        struct maple_pnode *       parent;               /*     0     8 */
        long unsigned int          pivot[15];            /*     8   120 */
        /* --- cacheline 2 boundary (128 bytes) --- */
        union {
                void *             slot[16];             /*   128   128 */
                struct {
                        void *     pad[15];              /*   128   120 */
                        /* --- cacheline 3 boundary (192 bytes) was 56 bytes ago --- */
                        struct maple_metadata meta;      /*   248     2 */
                };                                       /*   128   128 */
        };                                               /*   128   128 */