StackRot (CVE-2023-3269): vulnerabilidad de escalada de privilegios en el kernel de Linux

(Exploit verificado por GitHub-CI)

Se encontró una falla en el manejo de la expansión de la pila en el kernel de Linux 6.1 hasta 6.4, también conocida como "Stack Rot". El árbol maple, responsable de gestionar las áreas de memoria virtual, puede someterse a un reemplazo de nodos sin adquirir correctamente el bloqueo de escritura MM, lo que provoca problemas de use-after-free. Un usuario local sin privilegios podría utilizar esta falla para comprometer el kernel y escalar sus privilegios.

Dado que StackRot es una vulnerabilidad del kernel de Linux que se encuentra en el subsistema de gestión de memoria, afecta a casi todas las configuraciones del kernel y requiere capacidades mínimas para activarse. Sin embargo, cabe señalar que los nodos maple se liberan mediante callbacks de RCU, lo que retrasa la desasignación real de memoria hasta después del período de gracia de RCU. En consecuencia, explotar esta vulnerabilidad se considera un desafío.

Hasta donde yo sé, actualmente no hay exploits disponibles públicamente dirigidos a errores de use-after-free por RCU (UAFBR). Esta es la primera vez que se demuestra que los errores UAFBR son explotables, incluso sin la presencia de las opciones CONFIG_PREEMPT o CONFIG_SLAB_MERGE_DEFAULT. Cabe destacar que este exploit se ha demostrado con éxito en el entorno proporcionado por Google kCTF VRP (bzImage_upstream_6.1.25, config).

La vulnerabilidad StackRot ha estado presente en el kernel de Linux desde la versión 6.1, cuando la estructura del árbol VMA se cambió de árboles rojo-negro a árboles maple.

Antecedentes

Siempre que se utiliza la llamada al sistema mmap() para establecer una asignación de memoria, el kernel genera una estructura llamada vm_area_struct para representar el área de memoria virtual (VMA) correspondiente. Esta estructura almacena diversa información, incluidas banderas, propiedades y otros detalles pertinentes relacionados con la asignación.```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)));

Posteriormente, cuando el kernel encuentra fallos de página u otras llamadas al sistema relacionadas con la memoria, necesita una búsqueda rápida del VMA basada únicamente en la dirección. Anteriormente, los VMA se gestionaban mediante árboles rojo-negro. Sin embargo, a partir de la versión 6.1 del kernel de Linux, se produjo la migración a los árboles maple. Los [árboles maple][mt] son estructuras de datos B-tree seguras para RCU, optimizadas para almacenar rangos no superpuestos. No obstante, su naturaleza intrincada añade complejidad al código base e introduce la vulnerabilidad StackRot.

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

En esencia, un árbol maple está compuesto por nodos maple. Si bien la estructura del árbol puede ser compleja, es importante señalar que esta complejidad no tiene nada que ver con el error StackRot. Por lo tanto, a lo largo de este artículo se asume que el árbol maple consta de un solo nodo, es decir, el nodo raíz.

Este nodo raíz puede contener hasta 16 intervalos. Estos intervalos pueden representar un hueco o apuntar a un VMA. Como los huecos también cuentan como intervalos, todos los intervalos están conectados secuencialmente, lo que da lugar a la necesidad de solo 15 puntos finales, también conocidos como pivotes, dentro de la estructura del nodo. Tenga en cuenta que el punto final más a la izquierda y el punto final más a la derecha se omiten, ya que se pueden recuperar del 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 */