Vulnerabilidad en kernel de Linux (CVE-2024-39488)

En el kernel de Linux, se resolvió la siguiente vulnerabilidad: arm64: asm-bug: agregue .align 2 al final de __BUG_ENTRY Cuando CONFIG_DEBUG_BUGVERBOSE=n, no agregamos los bytes de relleno necesarios a las entradas de bug_table y, como resultado, la última entrada en una tabla de errores se ignorará, lo que podría provocar un pánico inesperado(). Todas las entradas anteriores en la tabla se manejarán correctamente. La ABI arm64 requiere que los campos de estructura de hasta 8 bytes estén alineados de forma natural, con relleno agregado dentro de una estructura de modo que la estructura esté adecuadamente alineada dentro de las matrices. Cuando CONFIG_DEBUG_BUGVERPOSE=y, el diseño de una entrada de error es: struct bug_entry { firmado int bug_addr_disp; // 4 bytes firmados int file_disp; // Línea corta sin firmar de 4 bytes; // 2 bytes de banderas cortas sin firmar; // 2 bytes } ... con 12 bytes en total, que requieren una alineación de 4 bytes. Cuando CONFIG_DEBUG_BUGVERBOSE=n, el diseño de una entrada de error es: struct bug_entry { firmado int bug_addr_disp; // 4 bytes de banderas cortas sin firmar; // 2 bytes < relleno implícito > // 2 bytes } ... con 8 bytes en total, con 6 bytes de datos y 2 bytes de relleno final, que requieren un alineamiento de 4 bytes. Cuando creamos un bug_entry en el ensamblado, alineamos el inicio de la entrada a 4 bytes, lo que implícitamente maneja el relleno de cualquier entrada anterior. Sin embargo, no alineamos el final de la entrada, por lo que cuando CONFIG_DEBUG_BUGVERBOSE=n, la entrada final carece de los bytes de relleno finales. Para la imagen principal del kernel, esto no es un problema ya que find_bug() no depende de los bytes de relleno finales cuando se buscan entradas: for (bug = __start___bug_table; bug < __stop___bug_table; ++bug) if (bugaddr == bug_addr(bug )) error de devolución; Sin embargo, para los módulos, module_bug_finalize() depende de los bytes finales al calcular el número de entradas: mod->num_bugs = sechdrs[i].sh_size / sizeof(struct bug_entry); ... y como la última entrada_error carece de los bytes de relleno necesarios, esta entrada no se contará, p.e. en el caso de una sola entrada: sechdrs[i].sh_size == 6 sizeof(struct bug_entry) == 8; sechdrs[i].sh_size / sizeof(struct bug_entry) == 0; En consecuencia, module_find_bug() perderá la última entrada de error cuando lo haga: for (i = 0; i < mod->num_bugs; ++i, ++bug) if (bugaddr == bug_addr(bug)) goto out; ... lo que puede provocar pánico en el kenrel debido a un error no controlado. Esto se puede demostrar con el siguiente módulo: static int __init buginit(void) { WARN(1, "hello\n"); devolver 0; } vacío estático __exit bugexit(void) { } module_init(buginit); module_exit(salida de error); MODULE_LICENSE("GPL"); ... lo que provocará un pánico en el kernel cuando se cargue: ------------[ cortar aquí ]------------ hola Excepción inesperada de BRK en el kernel en EL1 Error interno: Controlador BRK: 00000000f2000800 [#1] PREEMPT Módulos SMP vinculados en: hello(O+) CPU: 0 PID: 50 Comm: insmod Tainted: G O 6.9.1 #8 Nombre de hardware: linux,dummy-virt (DT) pstate: 60400005 ( nZCv daif +PAN -UAO -TCO -DIT -SSBS BTYPE=--) pc: ---truncado---