Vulnerabilidades

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: net: dsa: tabla de enrutamiento libre en caso de fallo de sondeo. Si "complete" es verdadero en dsa_tree_setup(), significa que somos el último conmutador del árbol que está sondeando correctamente, y deberíamos estar configurando todos los conmutadores desde nuestra ruta de sondeo. Una vez que "complete" es verdadero, dsa_tree_setup_cpu_ports() o cualquier función posterior puede fallar. Si esto ocurre, toda la configuración del árbol queda en el limbo: los primeros N-1 conmutadores han finalizado el sondeo correctamente (sin hacer nada más que asignar memoria persistente en dst->ports del árbol, y quizás en dst->rtable), y el conmutador N no ha podido sondear, finalizando el proceso de configuración del árbol antes de que el usuario pueda ver nada tangible. Si el conmutador N no puede sondear, su memoria (puertos) se liberará y se eliminará de dst->ports. Sin embargo, los elementos dst->rtable que apuntan a sus puertos, tal como los creó dsa_link_touch(), permanecerán allí y darán lugar a un use-after-free si se desreferencian. Si dsa_tree_setup_switches() devuelve -EPROBE_DEFER, lo cual es completamente posible porque es donde está ds->ops->setup(), obtenemos un informe de kasan como este: ===================================================================== ERROR: KASAN: slab-use-after-free en mv88e6xxx_setup_upstream_port+0x240/0x568 Lectura de tamaño 8 en la dirección ffff000004f56020 por la tarea kworker/u8:3/42 Rastreo de llamadas: __asan_report_load8_noabort+0x20/0x30 mv88e6xxx_setup_upstream_port+0x240/0x568 mv88e6xxx_setup+0xebc/0x1eb0 dsa_register_switch+0x1af4/0x2ae0 mv88e6xxx_register_switch+0x1b8/0x2a8 mv88e6xxx_probe+0xc4c/0xf60 mdio_probe+0x78/0xb8 really_probe+0x2b8/0x5a8 __driver_probe_device+0x164/0x298 driver_probe_device+0x78/0x258 __device_attach_driver+0x274/0x350 Allocated by task 42: __kasan_kmalloc+0x84/0xa0 __kmalloc_cache_noprof+0x298/0x490 dsa_switch_touch_ports+0x174/0x3d8 dsa_register_switch+0x800/0x2ae0 mv88e6xxx_register_switch+0x1b8/0x2a8 mv88e6xxx_probe+0xc4c/0xf60 mdio_probe+0x78/0xb8 really_probe+0x2b8/0x5a8 __driver_probe_device+0x164/0x298 driver_probe_device+0x78/0x258 __device_attach_driver+0x274/0x350 Freed by task 42: __kasan_slab_free+0x48/0x68 kfree+0x138/0x418 dsa_register_switch+0x2694/0x2ae0 mv88e6xxx_register_switch+0x1b8/0x2a8 mv88e6xxx_probe+0xc4c/0xf60 mdio_probe+0x78/0xb8 really_probe+0x2b8/0x5a8 __driver_probe_device+0x164/0x298 driver_probe_device+0x78/0x258 __device_attach_driver+0x274/0x350 La forma más sencilla de corregir el error es eliminar la tabla de enrutamiento en su totalidad. dsa_tree_setup_routing_table() no tiene problemas para regenerarla incluso si eliminamos enlaces entre puertos distintos a los del switch N, ya que dsa_link_touch() primero comprueba si el par de puertos ya existe en dst->rtable, y la asigna en caso contrario. La eliminación completa de la tabla de enrutamiento ya existe en dsa_tree_teardown(), por lo que se debe refactorizar en una función que también pueda llamarse desde la ruta de error de configuración del árbol. En mi análisis de la confirmación responsable, es la que añadió elementos dsa_link a dst->rtable. Antes de eso, cada switch tenía su propia ds->rtable, que se libera cuando el switch falla al sondear. Sin embargo, el árbol es potencialmente memoria persistente.

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: lib/iov_iter: corrección para aumentar el recuento de referencias de folios no slab. Al probar el montaje basado en archivos EROFS sobre v9fs en qemu, se detectó un problema con el UAF de folio. La comprobación de integridad de la página informa el siguiente seguimiento de llamadas. La causa principal es que las páginas en bvec se fusionan en un límite de folio. Se debe aumentar el recuento de referencias de todos los folios no slab para garantizar que p9_relas_pages pueda colocarlos correctamente. ERROR: Estado de página incorrecto en proceso md5sum pfn:18300 página: refcount:0 mapcount:0 mapping:00000000d5ad8e4e índice:0x60 pfn:0x18300 encabezado: orden:0 mapcount:0 entire_mapcount:0 nr_pages_mapped:0 pincount:0 aops:z_erofs_aops ino:30b0f dentry name(?):"GoogleExtServicesCn.apk" indicadores: 0x100000000000041(locked|head|node=0|zone=1) sin procesar: 0100000000000041 muerto000000000100 muerto000000000122 ffff888014b13bd0 sin procesar: 0000000000000060 0000000000000020 00000000ffffffff 0000000000000000 cabeza: 0100000000000041 muerto000000000100 muerto000000000122 ffff888014b13bd0 cabeza: 0000000000000060 0000000000000020 00000000ffffffff 000000000000000 cabeza: 010000000000000 000000000000000 ffffffffffffffff 00000000000000000 encabezado: 0000000000000010 0000000000000000 00000000ffffffff 0000000000000000 página volcada porque: PAGE_FLAGS_CHECK_AT_FREE indicador(es) establecido(s) Seguimiento de llamada: dump_stack_lvl+0x53/0x70 bad_page+0xd4/0x220 __free_pages_ok+0x76d/0xf30 __folio_put+0x230/0x320 p9_release_pages+0x179/0x1f0 p9_virtio_zc_request+0xa2a/0x1230 p9_client_zc_rpc.constprop.0+0x247/0x700 p9_client_read_once+0x34d/0x810 p9_client_read+0xf3/0x150 v9fs_issue_read+0x111/0x360 netfs_unbuffered_read_iter_locked+0x927/0x1390 netfs_unbuffered_read_iter+0xa2/0xe0 vfs_iocb_iter_read+0x2c7/0x460 erofs_fileio_rq_submit+0x46b/0x5b0 z_erofs_runqueue+0x1203/0x21e0 z_erofs_readahead+0x579/0x8b0 read_pages+0x19f/0xa70 page_cache_ra_order+0x4ad/0xb80 filemap_readahead.isra.0+0xe7/0x150 filemap_get_pages+0x7aa/0x1890 filemap_read+0x320/0xc80 vfs_read+0x6c6/0xa30 ksys_read+0xf9/0x1c0 do_syscall_64+0x9e/0x1a0 entry_SYSCALL_64_after_hwframe+0x71/0x79

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: isofs: Impedir el uso de fid demasiado pequeño. syzbot informó de una lectura fuera de los límites de slab en isofs_fh_to_parent. [1] El valor de handle_bytes pasado por el programa de reproducción es igual a 12. En handle_to_path(), solo se asignan 12 bytes de memoria para el miembro de la estructura file_handle->f_handle, lo que provoca un acceso fuera de los límites al acceder al miembro parent_block de la estructura isofs_fid en isofs, ya que acceder a parent_block requiere al menos 16 bytes de f_handle. Aquí, fh_len se utiliza para confirmar indirectamente que el valor de handle_bytes es mayor que 3 antes de acceder a parent_block. [1] ERROR: KASAN: slab fuera de los límites en isofs_fh_to_parent+0x1b8/0x210 fs/isofs/export.c:183 Lectura de tamaño 4 en la dirección ffff0000cc030d94 por la tarea syz-executor215/6466 CPU: 1 UID: 0 PID: 6466 Comm: syz-executor215 No contaminado 6.14.0-rc7-syzkaller-ga2392f333575 #0 Nombre del hardware: Google Google Compute Engine/Google Compute Engine, BIOS Google 02/12/2025 Call trace: show_stack+0x2c/0x3c arch/arm64/kernel/stacktrace.c:466 (C) __dump_stack lib/dump_stack.c:94 [inline] dump_stack_lvl+0xe4/0x150 lib/dump_stack.c:120 print_address_description mm/kasan/report.c:408 [inline] print_report+0x198/0x550 mm/kasan/report.c:521 kasan_report+0xd8/0x138 mm/kasan/report.c:634 __asan_report_load4_noabort+0x20/0x2c mm/kasan/report_generic.c:380 isofs_fh_to_parent+0x1b8/0x210 fs/isofs/export.c:183 exportfs_decode_fh_raw+0x2dc/0x608 fs/exportfs/expfs.c:523 do_handle_to_path+0xa0/0x198 fs/fhandle.c:257 handle_to_path fs/fhandle.c:385 [inline] do_handle_open+0x8cc/0xb8c fs/fhandle.c:403 __do_sys_open_by_handle_at fs/fhandle.c:443 [inline] __se_sys_open_by_handle_at fs/fhandle.c:434 [inline] __arm64_sys_open_by_handle_at+0x80/0x94 fs/fhandle.c:434 __invoke_syscall arch/arm64/kernel/syscall.c:35 [inline] invoke_syscall+0x98/0x2b8 arch/arm64/kernel/syscall.c:49 el0_svc_common+0x130/0x23c arch/arm64/kernel/syscall.c:132 do_el0_svc+0x48/0x58 arch/arm64/kernel/syscall.c:151 el0_svc+0x54/0x168 arch/arm64/kernel/entry-common.c:744 el0t_64_sync_handler+0x84/0x108 arch/arm64/kernel/entry-common.c:762 el0t_64_sync+0x198/0x19c arch/arm64/kernel/entry.S:600 Allocated by task 6466: kasan_save_stack mm/kasan/common.c:47 [inline] kasan_save_track+0x40/0x78 mm/kasan/common.c:68 kasan_save_alloc_info+0x40/0x50 mm/kasan/generic.c:562 poison_kmalloc_redzone mm/kasan/common.c:377 [inline] __kasan_kmalloc+0xac/0xc4 mm/kasan/common.c:394 kasan_kmalloc include/linux/kasan.h:260 [inline] __do_kmalloc_node mm/slub.c:4294 [inline] __kmalloc_noprof+0x32c/0x54c mm/slub.c:4306 kmalloc_noprof include/linux/slab.h:905 [inline] handle_to_path fs/fhandle.c:357 [inline] do_handle_open+0x5a4/0xb8c fs/fhandle.c:403 __do_sys_open_by_handle_at fs/fhandle.c:443 [inline] __se_sys_open_by_handle_at fs/fhandle.c:434 [inline] __arm64_sys_open_by_handle_at+0x80/0x94 fs/fhandle.c:434 __invoke_syscall arch/arm64/kernel/syscall.c:35 [inline] invoke_syscall+0x98/0x2b8 arch/arm64/kernel/syscall.c:49 el0_svc_common+0x130/0x23c arch/arm64/kernel/syscall.c:132 do_el0_svc+0x48/0x58 arch/arm64/kernel/syscall.c:151 el0_svc+0x54/0x168 arch/arm64/kernel/entry-common.c:744 el0t_64_sync_handler+0x84/0x108 arch/arm64/kernel/entry-common.c:762 el0t_64_sync+0x198/0x19c arch/arm64/kernel/entry.S:600

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: ksmbd: se corrige el error "use-after-free" en __smb2_lease_break_noti(). Se mueve tcp_transport libre a ksmbd_conn_free. Si se hace referencia a la conexión ksmbd al finalizar el subproceso del servidor ksmbd, no se liberará, pero sí se liberará conn->tcp_transport. __smb2_lease_break_noti puede ejecutarse asincrónicamente cuando se desconecta la conexión. __smb2_lease_break_noti llama a ksmbd_conn_write, lo que puede causar un error "use-after-free" cuando conn->ksmbd_transport ya está liberado.

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: ksmbd: se corrige el error "use-after-free" en smb_break_all_levII_oplock(). Existe una zona en smb_break_all_levII_oplock que puede causar problemas de velocidad al desbloquear en medio del bucle. Este parche utiliza un bloqueo de lectura para proteger todo el bucle.

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: ksmbd: corrige la advertencia de __kernel_write_iter [ 2110.972290] ------------[ cortar aquí ]------------ [ 2110.972301] ADVERTENCIA: CPU: 3 PID: 735 en fs/read_write.c:599 __kernel_write_iter+0x21b/0x280 Este parche no permite escribir en el directorio.

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: ksmbd: Se corrige el puntero colgante en krb_authenticate. krb_authenticate libera sess->user y no establece el puntero en NULL. Llama a ksmbd_krb5_authenticate para reinicializar sess->user, pero es posible que esta función no lo retorne. Si esto ocurre, smb2_sess_setup, que llama a krb_authenticate, accederá a la memoria liberada cuando utilice posteriormente sess->user.

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: virtiofs: añadir comprobación del nombre de la fuente en el contexto del sistema de archivos. En ciertos escenarios, por ejemplo, durante las pruebas fuzz, el nombre de la fuente puede ser nulo, lo que podría provocar un pánico del kernel. Por lo tanto, se debe añadir una comprobación adicional del nombre de la fuente.

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: RDMA/cma: Se corrige el fallo de la cola de trabajo en cma_netevent_work_handler. La estructura rdma_cm_id tiene el miembro "struct work_struct net_work", que se reutiliza para encolar cma_netevent_work_handler()s en cma_wq. El fallo [1] puede ocurrir si se realizan varias llamadas a cma_netevent_callback() en rápida sucesión, lo que encola aún más cma_netevent_work_handler()s para el mismo rdma_cm_id, sobrescribiendo cualquier elemento de trabajo previamente en cola que se haya programado para ejecutarse. Es decir, no hay garantía de que el elemento de trabajo en cola se ejecute entre dos llamadas sucesivas a cma_netevent_callback() y el segundo INIT_WORK sobrescribiría el primer elemento de trabajo (para el mismo rdma_cm_id), a pesar de obtener id_table_lock durante la encola. Además, el análisis drgn [2] indica que es probable que el elemento de trabajo se haya sobrescrito. Para solucionarlo, mueva INIT_WORK() a __rdma_create_id(), de modo que no compita con ninguna queue_work() existente ni con su subproceso de trabajo. [1] Pila de fallos recortada: =============================================== ERROR: desreferencia de puntero NULL del núcleo, dirección: 000000000000008 kworker/u256:6 ... 6.12.0-0... Cola de trabajo: cma_netevent_work_handler [rdma_cm] (rdma_cm) RIP: 0010:process_one_work+0xba/0x31a Seguimiento de llamadas: worker_thread+0x266/0x3a0 kthread+0xcf/0x100 ret_from_fork+0x31/0x50 ret_from_fork_asm+0x1a/0x30 ============================================= [2] drgn crash analysis: >>> trace = prog.crashed_thread().stack_trace() >>> trace (0) crash_setup_regs (./arch/x86/include/asm/kexec.h:111:15) (1) __crash_kexec (kernel/crash_core.c:122:4) (2) panic (kernel/panic.c:399:3) (3) oops_end (arch/x86/kernel/dumpstack.c:382:3) ... (8) process_one_work (kernel/workqueue.c:3168:2) (9) process_scheduled_works (kernel/workqueue.c:3310:3) (10) worker_thread (kernel/workqueue.c:3391:4) (11) kthread (kernel/kthread.c:389:9) Line workqueue.c:3168 for this kernel version is in process_one_work(): 3168 strscpy(worker->desc, pwq->wq->name, WORKER_DESC_LEN); >>> trace[8]["work"] *(struct work_struct *)0xffff92577d0a21d8 = { .data = (atomic_long_t){ .counter = (s64)536870912, <=== Note }, .entry = (struct list_head){ .next = (struct list_head *)0xffff924d075924c0, .prev = (struct list_head *)0xffff924d075924c0, }, .func = (work_func_t)cma_netevent_work_handler+0x0 = 0xffffffffc2cec280, } Suspicion is that pwq is NULL: >>> trace[8]["pwq"] (struct pool_workqueue *) In process_one_work(), pwq is assigned from: struct pool_workqueue *pwq = get_work_pwq(work); and get_work_pwq() is: static struct pool_workqueue *get_work_pwq(struct work_struct *work) { unsigned long data = atomic_long_read(&work->data); if (data & WORK_STRUCT_PWQ) return work_struct_pwq(data); else return NULL; } WORK_STRUCT_PWQ is 0x4: >>> print(repr(prog['WORK_STRUCT_PWQ'])) Object(prog, 'enum work_flags', value=4) But work->data is 536870912 which is 0x20000000. So, get_work_pwq() returns NULL and we crash in process_one_work(): 3168 strscpy(worker->desc, pwq->wq->name, WORKER_DESC_LEN); =============================================

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: drm/amd/pm: Impide la división por cero. El usuario puede establecer cualquier valor de velocidad. Si la velocidad es superior a UINT_MAX/8, es posible la división por cero. Encontrada por el Centro de Verificación de Linux (linuxtesting.org) con SVACE.

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: drm/amd/pm: Impide la división por cero. El usuario puede establecer cualquier valor de velocidad. Si la velocidad es superior a UINT_MAX/8, es posible la división por cero. Encontrada por el Centro de Verificación de Linux (linuxtesting.org) con SVACE.

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: drm/amd/pm/smu11: Impide la división por cero. El usuario puede establecer cualquier valor de velocidad. Si la velocidad es superior a UINT_MAX/8, es posible la división por cero. Encontrada por el Centro de Verificación de Linux (linuxtesting.org) con SVACE. (Seleccionada de la confirmación da7dc714a8f8e1c9fc33c57cd63583779a3bef71)