Vulnerabilidades

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: smb: cliente: corregir NULL ptr deref en crypto_aead_setkey() Ni SMB3.0 ni SMB3.02 admiten el contexto de negociación de cifrado, por lo que cuando se establece el indicador SMB2_GLOBAL_CAP_ENCRYPTION en la respuesta de negociación, el cliente utiliza AES-128-CCM como cifrado predeterminado. Consulte MS-SMB2 3.3.5.4. el commit b0abcd65ec54 ("smb: cliente: corregir UAF en descifrado asíncrono") agregó una comprobación @server->cipher_type para llamar condicionalmente a smb3_crypto_aead_allocate(), pero esa comprobación siempre sería falsa ya que @server->cipher_type no está configurado para SMB3.02. Corrija el siguiente splat de KASAN configurando también @server->cipher_type para SMB3.02. mount.cifs //srv/share /mnt -o vers=3.02,seal,... ERROR: KASAN: null-ptr-deref en crypto_aead_setkey+0x2c/0x130 Lectura de tamaño 8 en la dirección 0000000000000020 por la tarea mount.cifs/1095 CPU: 1 UID: 0 PID: 1095 Comm: mount.cifs No contaminado 6.12.0 #1 Nombre del hardware: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.16.3-3.fc41 04/01/2014 Rastreo de llamadas: dump_stack_lvl+0x5d/0x80 ? crypto_aead_setkey+0x2c/0x130 kasan_report+0xda/0x110 ? crypto_aead_setkey+0x2c/0x130 crypto_aead_setkey+0x2c/0x130 crypt_message+0x258/0xec0 [cifs] ? __asan_memset+0x23/0x50 ? __pfx_crypt_message+0x10/0x10 [cifs] ? mark_lock+0xb0/0x6a0 ? hlock_class+0x32/0xb0 ? mark_lock+0xb0/0x6a0 smb3_init_transform_rq+0x352/0x3f0 [cifs] ? lock_acquire.part.0+0xf4/0x2a0 smb_send_rqst+0x144/0x230 [cifs] ? __pfx_smb_send_rqst+0x10/0x10 [cifs] ? hlock_class+0x32/0xb0 ? smb2_setup_request+0x225/0x3a0 [cifs] ? __pfx_cifs_compound_last_callback+0x10/0x10 [cifs] compuesto_send_recv+0x59b/0x1140 [cifs] ? __pfx_compound_send_recv+0x10/0x10 [cifs] ? __create_object+0x5e/0x90 ? hlock_class+0x32/0xb0 ? __pfx_SMB2_tcon+0x10/0x10 [cifs] ? bloqueo_adquirir.parte.0+0xf4/0x2a0 ? bloqueo_adquirir+0xc6/0x120 ? _get_xid+0x16/0xd0 [cifs] ? cifs_get_smb_ses+0xcdd/0x10a0 [cifs] cifs_get_smb_ses+0xcdd/0x10a0 [cifs] ? __pfx_cifs_get_smb_ses+0x10/0x10 [cifs] ? cifs_get_tcp_session+0xaa0/0xca0 [cifs] cifs_mount_get_session+0x8a/0x210 [cifs] dfs_mount_share+0x1b0/0x11d0 [cifs] ? __pfx___lock_acquire+0x10/0x10 ? __pfx_dfs_mount_share+0x10/0x10 [cifs] ? bloqueo_adquirir.parte.0+0xf4/0x2a0 ? bloqueo_retenido_encontrar+0x8a/0xa0 ? clase_bloqueo_h+0x32/0xb0 ? liberación_bloqueo+0x203/0x5d0 montaje_cifs+0xb3/0x3d0 [cifs] ? intento_bloqueo_giro_sin_bloqueo+0xc6/0x120 ? montaje_cifs_pfx+0x10/0x10 [cifs] ? bloqueo_adquirir+0x3f/0x90 ? montaje_nls_encontrar+0x16/0xa0 ? banderas_mnt_actualizar_smb3+0x372/0x3b0 [cifs] cifs_smb3_hacer_montar+0x1e2/0xc80 [cifs] ? __pfx_vfs_parse_fs_string+0x10/0x10 ? __pfx_cifs_smb3_do_mount+0x10/0x10 [cifs] smb3_get_tree+0x1bf/0x330 [cifs] vfs_get_tree+0x4a/0x160 path_mount+0x3c1/0xfb0 ? kasan_quarantine_put+0xc7/0x1d0 ? __pfx_path_mount+0x10/0x10 ? kmem_cache_free+0x118/0x3e0 ? user_path_at+0x74/0xa0 __x64_sys_mount+0x1a6/0x1e0 ? __pfx___x64_sys_mount+0x10/0x10 ? marcar_bloqueos_retenidos+0x1a/0x90 hacer_llamada_al_sistema_64+0xbb/0x1d0 entrada_SYSCALL_64_después_de_hwframe+0x77/0x7f

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: ALSA: pcm: Agregar comprobación NULL de cordura para el controlador de errores mmap predeterminado Un controlador podría permitir el acceso a mmap antes de inicializar su runtime->dma_area correctamente. Agregue una comprobación NULL adecuada antes de pasar a virt_to_page() para evitar un pánico.

En el núcleo de Linux, se ha resuelto la siguiente vulnerabilidad: um: vector: No utilizar drvdata en la versión El archivo drvdata no está disponible en la versión. Simplemente usemos contenedor_of() para obtener la instancia vector_device. De lo contrario, eliminar un dispositivo vectorial provocará un bloqueo: RIP: 0033:vector_device_release+0xf/0x50 RSP: 00000000e187bc40 EFLAGS: 00010202 RAX: 0000000060028f61 RBX: 00000000600f1baf RCX: 00000000620074e0 RDX: 000000006220b9c0 RSI: 0000000060551c80 RDI: 0000000000000000 RBP: 00000000e187bc50 R08: 00000000603ad594 R09: 00000000e187bb70 R10: 000000000000135a R11: 00000000603ad422 R12: 00000000623ae028 R13: 000000006287a200 R14: 0000000062006d30 R15: 00000000623700b6 Pánico del núcleo: no se sincroniza: error de segmentación sin mm CPU: 0 UID: 0 PID: 16 Comm: kworker/0:1 No contaminado 6.12.0-rc6-g59b723cd2adb #1 Cola de trabajo: eventos mc_work_proc Pila: 60028f61 623ae028 e187bc80 60276fcd 6220b9c0 603f5820 623ae028 00000000 e187bcb0 603a2bcd 623ae000 62370010 Rastreo de llamadas: [<60028f61>] ? vector_device_release+0x0/0x50 [<60276fcd>] device_release+0x70/0xba [<603a2bcd>] kobject_put+0xba/0xe7 [<60277265>] put_device+0x19/0x1c [<60281266>] platform_device_put+0x26/0x29 [<60281e5f>] platform_dispositivo_unregister+0x2c/0x2e [<60029422>] vector_remove+0x52/0x58 [<60031316>] ? mconsole_reply+0x0/0x50 [<600310c8>] mconsole_remove+0x160/0x1cc [<603b19f4>] ? strlen+0x0/0x15 [<60066611>] ? __dequeue_entity+0x1a9/0x206 [<600666a7>] ? set_next_entity+0x39/0x63 [<6006666e>] ? set_next_entity+0x0/0x63 [<60038fa6>] ? um_set_signals+0x0/0x43 [<6003070c>] mc_work_proc+0x77/0x91 [<60057664>] proceso_trabajos_programados+0x1b3/0x2dd [<60055f32>] ? asignar_trabajo+0x0/0x58 [<60057f0a>] subproceso_trabajador+0x1e9/0x293 [<6005406f>] ? establecer_pf_trabajador+0x0/0x64 [<6005d65d>] ? guardar_irq_local_arch+0x0/0x2d [<6005d748>] ? salir_kthread+0x0/0x3a [<60057d21>] ? subproceso_de_trabajo+0x0/0x293 [<6005dbf1>] subproceso_de_trabajo+0x126/0x12b [<600219c5>] nuevo_controlador_de_subprocesos+0x85/0xb6

En el núcleo de Linux, se ha resuelto la siguiente vulnerabilidad: um: net: No utilizar drvdata en la versión El archivo drvdata no está disponible en la versión. Simplemente usemos Container_of() para obtener la instancia de Uml_net. De lo contrario, eliminar un dispositivo de red provocará un bloqueo: RIP: 0033:net_device_release+0x10/0x6f RSP: 00000000e20c7c40 EFLAGS: 00010206 RAX: 000000006002e4e7 RBX: 00000000600f1baf RCX: 00000000624074e0 RDX: 0000000062778000 RSI: 0000000060551c80 RDI: 00000000627af028 RBP: 00000000e20c7c50 R08: 00000000603ad594 R09: 00000000e20c7b70 R10: 000000000000135a R11: 00000000603ad422 R12: 0000000000000000 R13: 0000000062c7af00 R14: 0000000062406d60 R15: 00000000627700b6 Pánico del núcleo: no se sincroniza: error de segmentación sin mm CPU: 0 UID: 0 PID: 29 Comm: kworker/0:2 No contaminado 6.12.0-rc6-g59b723cd2adb #1 Cola de trabajo: eventos mc_work_proc Pila: 627af028 62c7af00 e20c7c80 60276fcd 62778000 603f5820 627af028 00000000 e20c7cb0 603a2bcd 627af000 62770010 Seguimiento de llamadas: [<60276fcd>] device_release+0x70/0xba [<603a2bcd>] kobject_put+0xba/0xe7 [<60277265>] put_device+0x19/0x1c [<60281266>] platform_device_put+0x26/0x29 [<60281e5f>] platform_device_unregister+0x2c/0x2e [<6002ec9c>] net_remove+0x63/0x69 [<60031316>] ? mconsole_reply+0x0/0x50 [<600310c8>] mconsole_remove+0x160/0x1cc [<60087d40>] ? __remove_hrtimer+0x38/0x74 [<60087ff8>] ? hrtimer_try_to_cancel+0x8c/0x98 [<6006b3cf>] ? dl_server_stop+0x3f/0x48 [<6006b390>] ? dl_server_stop+0x0/0x48 [<600672e8>] ? dequeue_entities+0x327/0x390 [<60038fa6>] ? um_set_signals+0x0/0x43 [<6003070c>] mc_work_proc+0x77/0x91 [<60057664>] proceso_trabajos_programados+0x1b3/0x2dd [<60055f32>] ? asignar_trabajo+0x0/0x58 [<60057f0a>] subproceso_trabajador+0x1e9/0x293 [<6005406f>] ? establecer_pf_trabajador+0x0/0x64 [<6005d65d>] ? guardar_irq_local_arch+0x0/0x2d [<6005d748>] ? salir_kthread+0x0/0x3a [<60057d21>] ? subproceso_de_trabajo+0x0/0x293 [<6005dbf1>] subproceso_de_trabajo+0x126/0x12b [<600219c5>] nuevo_controlador_de_subprocesos+0x85/0xb6

En el núcleo de Linux, se ha resuelto la siguiente vulnerabilidad: um: ubd: No utilizar drvdata en la versión El archivo drvdata no está disponible en la versión. Simplemente usemos contenedor_of() para obtener la instancia ubd. De lo contrario, eliminar un dispositivo ubd provocará un bloqueo: RIP: 0033:blk_mq_free_tag_set+0x1f/0xba RSP: 00000000e2083bf0 EFLAGS: 00010246 RAX: 000000006021463a RBX: 0000000000000348 RCX: 0000000062604d00 RDX: 0000000004208060 RSI: 00000000605241a0 RDI: 0000000000000348 RBP: 00000000e2083c10 R08: 0000000062414010 R09: 00000000601603f7 R10: 000000000000133a R11: 000000006038c4bd R12: 0000000000000000 R13: 0000000060213a5c R14: 0000000062405d20 R15: 00000000604f7aa0 Pánico del núcleo: no se sincroniza: error de segmentación sin mm CPU: 0 PID: 17 Comm: kworker/0:1 No contaminado 6.8.0-rc3-00107-gba3f67c11638 #1 Cola de trabajo: eventos mc_work_proc Pila: 00000000 604f7ef0 Rastreo de llamadas: [<6002c776>] ubd_device_release+0x21/0x55 [<6002c755>] ? ubd_device_release+0x0/0x55 [<600e47ff>] ? mconsole_reply+0x0/0x50 [<6002b926>] mconsole_remove+0x160/0x1cc [<6002bbbc>] ? __schedule+0x0/0x3ed [<60033761>] ? um_set_signals+0x0/0x43 [<6002af6a>] mc_work_proc+0x77/0x91 [<600520b4>] proceso_trabajos_programados+0x1af/0x2c3 [<6004ede3>] ? asignar_trabajo+0x0/0x58 [<600527a1>] subproceso_trabajador+0x2f7/0x37a [<6004ee3b>] ? establecer_pf_trabajador+0x0/0x64 [<6005765d>] ? guardar_irq_local_arch+0x0/0x2d [<60058e07>] ? salir_kthread+0x0/0x3a [<600524aa>] ? subproceso_de_trabajo+0x0/0x37a [<60058f9f>] subproceso_de_trabajo+0x130/0x135 [<6002068e>] nuevo_controlador_de_subprocesos+0x85/0xb6

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: nvme-fabrics: se corrige el fallo del kernel al apagar el controlador La operación de mantenimiento de conexión de nvme, que se ejecuta a intervalos periódicos, podría colarse mientras se apaga un controlador de red. Esto puede provocar una ejecución entre la ruta del código de destrucción de la cola de administración del controlador de red (invocada mientras se apaga el controlador) y el despachador de cola hw/hctx llamado desde la operación de puesta en cola de solicitudes asincrónicas de mantenimiento de conexión de nvme. Esta ejecución podría provocar el bloqueo del kernel que se muestra a continuación: Rastreo de llamada: autoremove_wake_function+0x0/0xbc (no confiable) __blk_mq_sched_dispatch_requests+0x114/0x24c blk_mq_sched_dispatch_requests+0x44/0x84 blk_mq_run_hw_queue+0x140/0x220 nvme_keep_alive_work+0xc8/0x19c [nvme_core] process_one_work+0x200/0x4e0 worker_thread+0x340/0x504 kthread+0x138/0x140 start_kernel_thread+0x14/0x18 Al apagar el controlador de estructura, si la solicitud de mantenimiento de conexión de nvme se cuela, se eliminará. Luego se invoca la función nvme_keep_alive_end_io para gestionar el final de la operación keep-alive que disminuye el admin->q_usage_counter y, asumiendo que esta es la última/única solicitud en la cola de administración, entonces el admin->q_usage_counter se convierte en cero. Si eso sucede, entonces la operación de destrucción de cola blk-mq (blk_mq_destroy_queue()) que podría estar ejecutándose simultáneamente en otra CPU (ya que esta es la ruta del código de apagado del controlador) reenviaría el progreso y eliminaría la cola de administración. Entonces, ahora a partir de este punto en adelante no se supone que accedamos a los recursos de la cola de administración. Sin embargo, el problema aquí es que el hilo de keep-alive de nvme que ejecuta la operación de despacho de cola hw/hctx aún no ha terminado su trabajo y, por lo tanto, aún podría acceder potencialmente al recurso de la cola de administración mientras que la cola de administración ya se había eliminado y eso causa el bloqueo anterior. El fallo del kernel anterior es una regresión causada por los cambios implementados en el commit a54a93d0e359 ("nvme: move stopping keep-alive into nvme_uninit_ctrl()"). Lo ideal sería detener el keep-alive antes de destruir la cola de administración y liberar el conjunto de etiquetas de administración para que no se introduzca durante la operación de apagado. Sin embargo, eliminamos la operación de detención de keep-alive del comienzo de la ruta del código de apagado del controlador en el commit a54a93d0e359 ("nvme: move stopping keep-alive into nvme_uninit_ctrl()") y la agregamos bajo nvme_uninit_ctrl() que se ejecuta muy tarde en la ruta del código de apagado después de que se destruye la cola de administración y se elimina su conjunto de etiquetas. Por lo tanto, este cambio creó la posibilidad de que el keep-alive se introduzca e interfiera con la operación de apagado y cause el fallo del kernel observado. Para solucionar el fallo observado, decidimos mover nvme_stop_keep_alive() de nvme_uninit_ctrl() a nvme_remove_admin_tag_set(). Este cambio garantizaría que no avancemos el progreso ni eliminemos la cola de administración hasta que la operación de mantenimiento de la actividad finalice (si está en curso) o se cancele, y eso ayudaría a contener la condición de ejecución explicada anteriormente y, por lo tanto, evitar el fallo. Mover nvme_stop_keep_alive() a nvme_remove_admin_tag_set() en lugar de agregar nvme_stop_keep_alive() al comienzo de la ruta del código de apagado del controlador en nvme_stop_ctrl(), como era el caso antes de el commit a54a93d0e359 ("nvme: mover la operación de mantenimiento de la actividad de detención a nvme_uninit_ctrl()"), ayudaría a ahorrar un sitio de llamada de nvme_stop_keep_alive().

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: smb: Durante el desmontaje, asegurarse de que todas las instancias de directorio en caché eliminen su dentry El proceso de desmontaje (cifs_kill_sb() llamando a close_all_cached_dirs()) puede competir con varias operaciones de directorio en caché, lo que en última instancia da como resultado que no se eliminen los dentries y estos ERRORES del kernel: ERROR: Dentry ffff88814f37e358{i=1000000000080,n=/} todavía en uso (2) [desmontaje de cifs cifs] VFS: Inodos ocupados después del desmontaje de cifs (cifs) ------------[ corte aquí ]------------ ¡ERROR del kernel en fs/super.c:661! Esto sucede cuando un cfid está en proceso de desinfección y se ha eliminado de la lista cfids->entries, lo que incluye: - Recibir una interrupción de arrendamiento del servidor - La reconexión del servidor activa invalidate_all_cached_dirs(), que elimina todos los cfids de la lista - El hilo de la lavandería decide hacer caducar un cfid antiguo. Para resolver estos problemas, se elimina el dentry en el trabajo en cola realizado en una cola de trabajo cfid_put_wq recién agregada, y close_all_cached_dirs() vacía esa cola de trabajo después de eliminar todos los dentries de los que tiene conocimiento. Esta es una cola de trabajo global (en lugar de tener un alcance de montaje), pero el trabajo en cola es mínimo. El trabajo de desinfección final para limpiar un cfid se realiza a través del trabajo en cola en la cola de trabajo serverclose_wq; esto se hace por separado de la eliminación de los dentries para que close_all_cached_dirs() no bloquee ninguna operación del servidor. Se espera que ambos trabajos en cola se invoquen con una referencia cfid y una referencia tcon para evitar que esos objetos se liberen mientras el trabajo está en curso. Mientras estamos aquí, agregue un bloqueo adecuado a close_all_cached_dirs() y un bloqueo alrededor de la liberación de cfid->dentry.

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: bloque: corregir uaf para flush rq mientras se itera etiquetas blk_mq_clear_flush_rq_mapping() no se llama durante la sonda scsi, al verificar blk_queue_init_done(). Sin embargo, QUEUE_FLAG_INIT_DONE se borra en del_gendisk por el commit aec89dc5d421 ("bloque: mantener q_usage_counter en modo atómico después de del_gendisk"), por lo tanto, para discos como scsi, seguir blk_mq_destroy_queue() tampoco borrará el flush rq de tags->rqs[], debido al siguiente uaf que nuestro syzkaller encuentra para v6.6: ===================================================================== ERROR: KASAN: slab-use-after-free en blk_mq_find_and_get_req+0x16e/0x1a0 block/blk-mq-tag.c:261 Lectura de tamaño 4 en la dirección ffff88811c969c20 por la tarea kworker/1:2H/224909 CPU: 1 PID: 224909 Comm: kworker/1:2H No contaminado 6.6.0-ga836a5060850 #32 Cola de trabajo: kblockd blk_mq_timeout_work Seguimiento de llamadas: __dump_stack lib/dump_stack.c:88 [en línea] dump_stack_lvl+0x91/0xf0 lib/dump_stack.c:106 print_address_description.constprop.0+0x66/0x300 mm/kasan/report.c:364 print_report+0x3e/0x70 mm/kasan/report.c:475 kasan_report+0xb8/0xf0 mm/kasan/report.c:588 blk_mq_find_and_get_req+0x16e/0x1a0 bloque/blk-mq-tag.c:261 bt_iter bloque/blk-mq-tag.c:288 [en línea] __sbitmap_for_each_set include/linux/sbitmap.h:295 [en línea] sbitmap_for_each_set include/linux/sbitmap.h:316 [en línea] bt_for_each+0x455/0x790 bloque/blk-mq-tag.c:325 blk_mq_queue_tag_busy_iter+0x320/0x740 bloque/blk-mq-tag.c:534 blk_mq_timeout_work+0x1a3/0x7b0 bloque/blk-mq.c:1673 proceso_uno_trabajo+0x7c4/0x1450 kernel/workqueue.c:2631 proceso_trabajos_programados kernel/workqueue.c:2704 [en línea] subproceso_trabajador+0x804/0xe40 kernel/workqueue.c:2785 subproceso_k+0x346/0x450 kernel/kthread.c:388 ret_de_bifurcación+0x4d/0x80 arch/x86/kernel/process.c:147 ret_de_bifurcación_asm+0x1b/0x30 arch/x86/entry/entry_64.S:293 Asignado por la tarea 942: pila_guardada_kasan+0x22/0x50 mm/kasan/common.c:45 kasan_set_track+0x25/0x30 mm/kasan/common.c:52 ____kasan_kmalloc mm/kasan/common.c:374 [en línea] __kasan_kmalloc mm/kasan/common.c:383 [en línea] __kasan_kmalloc+0xaa/0xb0 mm/kasan/common.c:380 kasan_kmalloc include/linux/kasan.h:198 [en línea] __do_kmalloc_node mm/slab_common.c:1007 [en línea] __kmalloc_node+0x69/0x170 mm/slab_common.c:1014 kmalloc_node include/linux/slab.h:620 [en línea] kzalloc_node include/linux/slab.h:732 [en línea] blk_alloc_flush_queue+0x144/0x2f0 bloque/blk-flush.c:499 blk_mq_alloc_hctx+0x601/0x940 bloque/blk-mq.c:3788 blk_mq_alloc_and_init_hctx+0x27f/0x330 bloque/blk-mq.c:4261 blk_mq_realloc_hw_ctxs+0x488/0x5e0 bloque/blk-mq.c:4294 blk_mq_init_allocated_queue+0x188/0x860 bloque/blk-mq.c:4350 blk_mq_init_queue_data bloque/blk-mq.c:4166 [en línea] blk_mq_init_queue+0x8d/0x100 block/blk-mq.c:4176 scsi_alloc_sdev+0x843/0xd50 drivers/scsi/scsi_scan.c:335 scsi_probe_and_add_lun+0x77c/0xde0 drivers/scsi/scsi_scan.c:1189 __scsi_scan_target+0x1fc/0x5a0 drivers/scsi/scsi_scan.c:1727 scsi_scan_channel drivers/scsi/scsi_scan.c:1815 [en línea] scsi_scan_channel+0x14b/0x1e0 drivers/scsi/scsi_scan.c:1791 scsi_scan_host_selected+0x2fe/0x400 drivers/scsi/scsi_scan.c:1844 scsi_scan+0x3a0/0x3f0 drivers/scsi/scsi_sysfs.c:151 store_scan+0x2a/0x60 drivers/scsi/scsi_sysfs.c:191 dev_attr_store+0x5c/0x90 drivers/base/core.c:2388 sysfs_kf_write+0x11c/0x170 fs/sysfs/file.c:136 kernfs_fop_write_iter+0x3fc/0x610 fs/kernfs/file.c:338 call_write_iter include/linux/fs.h:2083 [en línea] new_sync_write+0x1b4/0x2d0 fs/read_write.c:493 vfs_write+0x76c/0xb00 fs/read_write.c:586 ksys_write+0x127/0x250 fs/read_write.c:639 do_syscall_x64 arch/x86/entry/common.c:51 [en línea] do_syscall_64+0x70/0x120 arch/x86/entry/common.c:81 entry_SYSCALL_64_after_hwframe+0x78/0xe2 Liberado por la tarea 244687: kasan_save_stack+0x22/0x50 mm/kasan/common.c:45 kasan_set_track+0x25/0x30 mm/kasan/common.c:52 kasan_save_free_info+0x2b/0x50 mm/kasan/generic.c:522 ____kasan_slab_free mm/kasan/common.c:236 --truncado---

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: ubifs: authentication: Fix use-after-free en ubifs_tnc_end_commit Después de una inserción en TNC, el árbol podría dividirse y hacer que un nodo cambie su `znode->parent`. Una eliminación adicional de otros nodos en el árbol (que también podría liberar los nodos), el `znode->cparent` del nodo mencionado anteriormente aún podría apuntar a un nodo liberado. Este `znode->cparent` puede no actualizarse al hacer que los nodos se comprometan en `ubifs_tnc_start_commit()`. Esto podría desencadenar un use-after-free al acceder a `znode->cparent` en `write_index()` en `ubifs_tnc_end_commit()`. Esto se puede activar ejecutando rm -f /etc/test-file.bin dd if=/dev/urandom of=/etc/test-file.bin bs=1M count=60 conv=fsync en un bucle y con `CONFIG_UBIFS_FS_AUTHENTICATION`. KASAN luego informa: ERROR: KASAN: use-after-free en ubifs_tnc_end_commit+0xa5c/0x1950 Escritura de tamaño 32 en la dirección ffffff800a3af86c por la tarea ubifs_bgt0_20/153 Rastreo de llamadas: dump_backtrace+0x0/0x340 show_stack+0x18/0x24 dump_stack_lvl+0x9c/0xbc print_address_description.constprop.0+0x74/0x2b0 kasan_report+0x1d8/0x1f0 kasan_check_range+0xf8/0x1a0 memcpy+0x84/0xf4 ubifs_tnc_end_commit+0xa5c/0x1950 Asignado por la tarea 401: kasan_save_stack+0x38/0x70 __kasan_kmalloc+0x8c/0xd0 __kmalloc+0x34c/0x5bc tnc_insert+0x140/0x16a4 ubifs_tnc_add+0x370/0x52c ubifs_jnl_write_data+0x5d8/0x870 do_writepage+0x36c/0x510 ubifs_writepage+0x190/0x4dc __writepage+0x58/0x154 escritura_caché_páginas+0x394/0x830 do_writepages+0x1f0/0x5b0 filemap_fdatawrite_wbc+0x170/0x25c intervalo_de_escritura_y_espera_de_archivo+0x140/0x190 ubifs_fsync+0xe8/0x290 intervalo_de_fsync_vfs+0xc0/0x1e4 do_fsync+0x40/0x90 __arm64_sys_fsync+0x34/0x50 invocar_llamada_al_sistema.constprop.0+0xa8/0x260 do_el0_svc+0xc8/0x1f0 el0_svc+0x34/0x70 el0t_64_sync_handler+0x108/0x114 el0t_64_sync+0x1a4/0x1a8 Liberado por la tarea 403: kasan_save_stack+0x38/0x70 kasan_set_track+0x28/0x40 kasan_set_free_info+0x28/0x4c __kasan_slab_free+0xd4/0x13c kfree+0xc4/0x3a0 tnc_delete+0x3f4/0xe40 ubifs_tnc_remove_range+0x368/0x73c ubifs_tnc_remove_ino+0x29c/0x2e0 ubifs_jnl_delete_inode+0x150/0x260 ubifs_evict_inode+0x1d4/0x2e4 El `memcpy()` ofensivo en `ubifs_copy_hash()` tiene un use-after-free cuando un nodo se convierte en raíz en TNC pero aún tiene un `cparent` para un nodo ya liberado. Más específicamente, considere la siguiente TNC: zroot // zp1 // zn Insertar un nuevo nodo `zn_new` con una clave menor que `zn` activará una división en `tnc_insert()` si `zp1` está lleno: zroot / \ / \ zp1 zp2 / \ / \ zn_new zn `zn->parent` ahora se ha movido a `zp2`, *pero* `zn->cparent` todavía apunta a `zp1`. Ahora, considere una eliminación de todos los nodos _excepto_ `zn`. Justo cuando `tnc_delete()` está a punto de eliminar `zroot` y `zp2`: zroot \ \ zp2 \ \ zn `zroot` y `zp2` se liberan y el árbol colapsa: zn `zn` ahora se convierte en el nuevo `zroot`. `get_znodes_to_commit()` ahora solo encontrará `zn`, el nuevo `zroot`, y `write_index()` verificará su `znode->cparent` que apunta erróneamente al `zp1` ya liberado. Por lo tanto, `ubifs_copy_hash()` se llama erróneamente con `znode->cparent->zbranch[znode->iip].hash` que activa el use-after-free. Solucione esto configurando explícitamente `znode->cparent` en `NULL` en `get_znodes_to_commit()` para el nodo raíz. La búsqueda de los nodos sucios ---truncada---

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: ubi: fastmap: corrige nombres de caché de slab duplicados al adjuntar Desde el commit 4c39529663b9 ("slab: Advertir sobre nombres de caché duplicados cuando DEBUG_VM=y"), se pueden detectar los nombres de caché de slab duplicados y se emite una ADVERTENCIA del kernel. En el proceso de conexión rápida de UBI, alloc_ai() podría invocarse dos veces con el mismo nombre de caché de losa 'ubi_aeb_slab_cache', lo que activará los siguientes mensajes de advertencia: kmem_cache con el nombre 'ubi_aeb_slab_cache' ya existe ADVERTENCIA: CPU: 0 PID: 7519 en mm/slab_common.c:107 __kmem_cache_create_args+0x100/0x5f0 Módulos vinculados en: ubi(+) nandsim [última descarga: nandsim] CPU: 0 UID: 0 PID: 7519 Comm: modprobe Tainted: G 6.12.0-rc2 RIP: 0010:__kmem_cache_create_args+0x100/0x5f0 Rastreo de llamadas: __kmem_cache_create_args+0x100/0x5f0 alloc_ai+0x295/0x3f0 [ubi] ubi_attach+0x3c3/0xcc0 [ubi] ubi_attach_mtd_dev+0x17cf/0x3fa0 [ubi] ubi_init+0x3fb/0x800 [ubi] do_init_module+0x265/0x7d0 __x64_sys_finit_module+0x7a/0xc0 El problema se puede reproducir fácilmente cargando el dispositivo UBI mediante fastmap con CONFIG_DEBUG_VM=y. Arréglelo utilizando diferentes nombres de losa para los invocadores de alloc_ai().

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: NFSv4.0: Se corrige un problema de use-after-free en la función open() asincrónica Yang Erkun informa que cuando dos subprocesos abren archivos al mismo tiempo y se ven obligados a abortar antes de que se vea una respuesta, la llamada a nfs_release_seqid() en nfs4_opendata_free() puede dar como resultado un use-after-free del puntero a la tarea rpc inactiva del otro subproceso. La solución es garantizar que si la llamada RPC se aborta antes de que se complete la llamada a nfs_wait_on_sequence(), entonces debemos llamar a nfs_release_seqid() en nfs4_open_release() antes de que se libere la rpc_task.

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: SUNRPC: asegúrese de que la entrada de caché esté activa antes de cache_show La función `c_show` se llamó con protección de RCU. Esto solo garantiza que `cp` no se liberará. Por lo tanto, el recuento de referencia para `cp` puede caer a cero, lo que activará una advertencia de use-after-free de refcount cuando se llame a `cache_get`. Para resolver este problema, use `cache_get_rcu` para asegurarse de que `cp` permanezca activo. ------------[ cortar aquí ]------------ refcount_t: adición en 0; use-after-free. ADVERTENCIA: CPU: 7 PID: 822 en lib/refcount.c:25 refcount_warn_saturate+0xb1/0x120 CPU: 7 UID: 0 PID: 822 Comm: cat No contaminado 6.12.0-rc3+ #1 Nombre del hardware: PC estándar QEMU (i440FX + PIIX, 1996), BIOS 1.16.1-2.fc37 01/04/2014 RIP: 0010:refcount_warn_saturate+0xb1/0x120 Seguimiento de llamadas: c_show+0x2fc/0x380 [sunrpc] seq_read_iter+0x589/0x770 seq_read+0x1e5/0x270 proc_reg_read+0xe1/0x140 vfs_read+0x125/0x530 ksys_read+0xc1/0x160 hacer_syscall_64+0x5f/0x170 entrada_SYSCALL_64_después_hwframe+0x76/0x7e