Vulnerabilidades

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: nvmet: corrige una pérdida de memoria en nvmet_auth_set_key Al cambiar los secretos de dhchap, también debemos liberar los secretos antiguos. Queja de kmemleak: -- objeto sin referencia 0xffff8c7f44ed8180 (tamaño 64): comm "check", pid 7304, jiffies 4295686133 (edad 72034.246s) volcado hexadecimal (primeros 32 bytes): 44 48 48 43 2d 31 3a 30 30 3a 4c 64 4c 4f 64 71 DHHC-1:00:LdLOdq 79 56 69 67 77 48 55 32 6d 5a 59 4c 7a 35 59 38 yVigwHU2mZYLz5Y8 backtrace: [<00000000b6fc5071>] kstrdup+0x2e/0x60 [<00000000f0f4633f>] 0xffffffffc0e07ee6 [<0000000053006c05>] 0xffffffffc0dff783 [<00000000419ae922>] configfs_write_iter+0xb1/0x120 [<000000008183c424>] vfs_write+0x2be/0x3c0 [<000000009005a2a5>] ksys_write+0x5f/0xe0 [<00000000cd495c89>] do_syscall_64+0x38/0x90 [<00000000f2a84ac5>] entry_SYSCALL_64_after_hwframe+0x63/0xcd

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: net: dsa: no filtrar almacenamiento propiedad del etiquetador al desvincular el controlador del conmutador. En la confirmación inicial dc452a471dba ("net: dsa: introducir almacenamiento propiedad del etiquetador para datos privados y compartidos"), teníamos una llamada a tag_ops->disconnect(dst) emitida desde dsa_tree_free(), que se llama en el momento del desmontaje del árbol. Había problemas con la conexión a un árbol de conmutadores como un todo, por lo que esto se modificó para conectarse a conmutadores individuales dentro del árbol. En este proceso, tag_ops->disconnect(ds) se hizo para que se llamara solo desde switch.c (notificadores entre chips emitidos como resultado de cambios dinámicos de protocolo de etiqueta), pero la ruta de código normal para el desmontaje del controlador no se reemplazó con nada. Resuelva este problema añadiendo una función que haga lo contrario de dsa_switch_setup_tag_protocol(), que se llama desde el punto equivalente en dsa_switch_teardown(). El posicionamiento aquí también asegura que no tendremos ningún use-after-free en las operaciones del protocolo de etiquetado (*rcv), ya que la secuencia de desmontaje es la siguiente: dsa_tree_teardown -> dsa_tree_teardown_master -> dsa_master_teardown -> anula el ajuste master->dsa_ptr, lo que hace que no haya más paquetes que coincidan con el controlador de tipo de paquete ETH_P_XDSA -> dsa_tree_teardown_ports -> dsa_port_teardown -> dsa_slave_destroy -> anula el registro de los dispositivos de red DSA, incluso hay un synchronize_net() en unregister_netdevice_many() -> dsa_tree_teardown_switches -> dsa_switch_teardown -> dsa_switch_teardown_tag_protocol -> finalmente libera el almacenamiento propiedad del etiquetador

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: netfs: Se corrigen las llamadas xas_retry() faltantes en la iteración de un xarray. netfslib realiza la iteración de un xarray en varios lugares bajo el bloqueo de lectura de la RCU. *Debería* llamar a xas_retry() como primer paso dentro del bucle y ejecutar "continue" si devuelve verdadero en caso de que el rastreador de xarrays haya pasado un valor especial que indique que el recorrido debe rehacerse desde la raíz. [*] Se puede solucionar añadiendo las comprobaciones de reintento faltantes. [*] Me pregunto si esto debería hacerse dentro de xas_find(), xas_next_node() y similares, pero me han dicho que no es un cambio sencillo de implementar. Esto puede causar un error como el que se muestra a continuación. Observe la dirección del error: se trata de un valor interno (|0x2) devuelto por xarray. ERROR: desreferencia de puntero NULL del núcleo, dirección: 0000000000000402 ... RIP: 0010:netfs_rreq_unlock+0xef/0x380 [netfs] ... Seguimiento de llamadas: netfs_rreq_assess+0xa6/0x240 [netfs] netfs_readpage+0x173/0x3b0 [netfs] ? init_wait_var_entry+0x50/0x50 filemap_read_page+0x33/0xf0 filemap_get_pages+0x2f2/0x3f0 filemap_read+0xaa/0x320 ? do_filp_open+0xb2/0x150 ? rmqueue+0x3be/0xe10 ceph_read_iter+0x1fe/0x680 [ceph] ? new_sync_read+0x115/0x1a0 new_sync_read+0x115/0x1a0 vfs_read+0xf3/0x180 ksys_read+0x5f/0xe0 do_syscall_64+0x38/0x90 entry_SYSCALL_64_after_hwframe+0x44/0xae Changes: ======== ver #2) - Se cambió un int sin signo a un size_t para reducir la probabilidad de un desbordamiento según la sugerencia de Willy. - Se agregó un parche adicional para corregir las matemáticas.

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: net/x25: Se corrige la fuga de skb en x25_lapb_receive_frame(). x25_lapb_receive_frame() usa skb_copy() para obtener una copia privada de skb. El nuevo skb debe liberarse en la ruta de gestión de errores de skb de tamaño insuficiente/fragmentado. De lo contrario, se produce una fuga de memoria.

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: ftrace: Corregir la desreferencia de puntero nulo en ftrace_add_mod() @ftrace_mod se asigna mediante kzalloc(), por lo que ambos miembros {prev,next} de @ftrace_mode->list son NULL, no es un estado válido para llamar a list_del(). Si kstrdup() para @ftrace_mod->{func|module} falla, va a la etiqueta @out_free y llama a free_ftrace_mod() para destruir @ftrace_mod, entonces list_del() escribirá prev->next y next->prev, donde ocurre la desreferencia de puntero nulo. ERROR: desreferencia de puntero NULL del kernel, dirección: 0000000000000008 Oops: 0002 [#1] PREEMPT SMP NOPTI Call Trace: ftrace_mod_callback+0x20d/0x220 ? Pánico del kernel: no se sincroniza: Excepción fatal Por lo tanto, llame a INIT_LIST_HEAD() para inicializar el miembro de la lista para corregir este problema.

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: netdevsim: Se corrige la pérdida de memoria de nsim_dev->fa_cookie. kmemleak informa de este problema: objeto sin referencia 0xffff8881bac872d0 (tamaño 8): comm "sh", pid 58603, jiffies 4481524462 (edad 68,065 s) volcado hexadecimal (primeros 8 bytes): 04 00 00 00 de ad be ef ........ backtrace: [<00000000c80b8577>] __kmalloc+0x49/0x150 [<000000005292b8c6>] nsim_dev_trap_fa_cookie_write+0xc1/0x210 [netdevsim] [<0000000093d78e77>] escritura de proxy completo+0xf3/0x180 [<000000005a662c16>] escritura de vfs+0x1c5/0xaf0 [<000000007aabf84a>] escritura de ksys+0xed/0x1c0 [<000000005f1d2e47>] llamada al sistema_64+0x3b/0x90 [<000000006001c6ec>] entrada_SYSCALL_64_after_hwframe+0x63/0xcd El problema ocurre en los siguientes escenarios: nsim_dev_trap_fa_cookie_write() kmalloc() fa_cookie nsim_dev->fa_cookie = fa_cookie .. nsim_drv_remove(): La fa_cookie bloqueada en nsim_dev_trap_fa_cookie_write() no se libera. Para solucionarlo, añada kfree(nsim_dev->fa_cookie) a nsim_drv_remove().

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: s390: evitar el uso de un registro global para current_stack_pointer. El commit 30de14b1884b ("s390: current_stack_pointer no debería ser una función") convirtió current_stack_pointer en una variable de registro global, como en muchas otras arquitecturas. Desafortunadamente, en s390, se descubre un antiguo error de gcc corregido solo desde gcc-9.1 [commit 3ad7fed1cc87 de gcc ("S/390: Corrección de PR89775. Se eliminaron las instrucciones de guardado/restauración de Stackpointer")] y se ha retroportado a gcc-8.4 y posteriores. Debido a este error, las versiones de gcc anteriores a la 8.4 generan código defectuoso que provoca corrupciones en la pila. La versión mínima actual de gcc requerida para compilar el kernel es la 5.1. No es posible corregir todas las versiones antiguas de gcc, por lo que se puede solucionar este problema evitando el uso de la variable de registro global para current_stack_pointer.

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: net: lan966x: Se corrige un posible error de referencia nulo (PTR) en lan966x_stats_init(). Lan966x_stats_init() llama a create_singlethread_workqueue() y no verifica el valor ret, lo que puede devolver NULL. Podría ocurrir un error de referencia nulo (PTR): lan966x_stats_init() create_singlethread_workqueue() # Falló, lan966x->stats_queue es NULL. queue_delayed_work() queue_delayed_work_on(). __queue_delayed_work() # Advertencia, pero continúe. __queue_work() # Acceso a wq->flags, PTR-deref nulo. Verifique el valor ret y devuelva -ENOMEM si es NULL.

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: net: microchip: sparx5: Se corrige un posible null-ptr-deref en sparx_stats_init() y sparx5_start(). sparx_stats_init() llama a create_singlethread_workqueue() y no comprueba el valor ret, lo que puede devolver NULL. Y puede ocurrir un null-ptr-deref: sparx_stats_init() create_singlethread_workqueue() # falló, sparx5->stats_queue es NULL queue_delayed_work() queue_delayed_work_on() __queue_delayed_work() # advertencia aquí, pero continúe __queue_work() # acceso a wq->flags, null-ptr-deref Compruebe el valor ret y devuelva -ENOMEM si es NULL. Así como sparx5_start().

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: rastreo: Se corrige la ejecución donde se pueden llamar los eprobes antes del evento. El indicador que indica al evento que llame a sus desencadenadores después de leer el evento se establece para los eprobes después de habilitarlos. Esto provoca una ejecución donde el eprobe puede activarse al inicio del evento cuando la información del registro es nula. El eprobe entonces desreferencia el registro nulo, causando un error de puntero de kernel nulo. Pruebe si hay un registro nulo para evitar que esto suceda.

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: rastreo: Se corrige el acceso a memoria no autorizado en register_synth_event(). En register_synth_event(), si set_synth_event_print_fmt() falla, se invocarán trace_remove_event_call() y unregister_trace_event(), lo que significa que trace_event_call llamará a __unregister_trace_event() dos veces. Como resultado, la segunda anulación del registro provocará el acceso a memoria no autorizado. register_synth_event set_synth_event_print_fmt falló trace_remove_event_call event_remove si call->event.funcs entonces __unregister_trace_event (primera llamada) unregister_trace_event __unregister_trace_event (segunda llamada) Corrija el error evitando llamar al segundo __unregister_trace_event() verificando si se llama al primero. Fallo de protección general, probablemente por dirección no canónica 0xfbd59c0000000024: 0000 [#1] SMP KASAN PTI KASAN: tal vez acceso a memoria salvaje en el rango [0xdead000000000120-0xdead000000000127] CPU: 0 PID: 3807 Comm: modprobe No contaminado 6.1.0-rc1-00186-g76f33a7eedb4 #299 Nombre del hardware: QEMU Standard PC (i440FX + PIIX, 1996), BIOS rel-1.15.0-0-g2dd4b9b3f840-prebuilt.qemu.org 04/01/2014 RIP: 0010:unregister_trace_event+0x6e/0x280 Código: 00 fc ff df 4c 89 ea 48 c1 ea 03 80 3c 02 00 0f 85 0e 02 00 00 48 b8 00 00 00 00 00 fc ff df 4c 8b 63 08 4c 89 e2 48 c1 ea 03 <80> 3c 02 00 0f 85 e2 01 00 00 49 89 2c 24 48 85 ed 74 28 e8 7a 9b RSP: 0018:ffff88810413f370 EFLAGS: 00010a06 RAX: dffffc0000000000 RBX: ffff888105d050b0 RCX: 0000000000000000 RDX: 1bd5a00000000024 RSI: ffff888119e276e0 RDI: ffffffff835a8b20 RBP: muerto000000000100 R08: 0000000000000000 R09: ffffbfff0913481 R10: ffffffff8489a407 R11: ffffbfff0913480 R12: muerto000000000122 R13: ffff888105d050b8 R14: 0000000000000000 R15: ffff888105d05028 FS: 00007f7823e8d540(0000) GS:ffff888119e00000(0000) knlGS:000000000000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 00007f7823e7ebec CR3: 000000010a058002 CR4: 0000000000330ef0 DR0: 0000000000000000 DR1: 0000000000000000 DR2: 00000000000000000 DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400 Rastreo de llamadas: __create_synth_event+0x1e37/0x1eb0 create_or_delete_synth_event+0x110/0x250 synth_event_run_command+0x2f/0x110 test_gen_synth_cmd+0x170/0x2eb [synth_event_gen_test] synth_event_gen_test_init+0x76/0x9bc [synth_event_gen_test] do_one_initcall+0xdb/0x480 do_init_module+0x1cf/0x680 load_module+0x6a50/0x70a0 __do_sys_finit_module+0x12f/0x1c0 do_syscall_64+0x3f/0x90 entry_SYSCALL_64_after_hwframe+0x63/0xcd

En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: rastreo: Se corrige la fuga de memoria en test_gen_synth_cmd() y test_empty_synth_event(). Test_gen_synth_cmd() solo libera búfer en la ruta de fallo, por lo que el búfer se filtrará aunque no haya fallo. Se ha añadido kfree(buf) para evitar la fuga de memoria. La misma razón y solución se aplican en test_empty_synth_event(). objeto sin referencia 0xffff8881127de000 (size 2048): comm "modprobe", pid 247, jiffies 4294972316 (age 78.756s) hex dump (first 32 bytes): 20 67 65 6e 5f 73 79 6e 74 68 5f 74 65 73 74 20 gen_synth_test 20 70 69 64 5f 74 20 6e 65 78 74 5f 70 69 64 5f pid_t next_pid_ backtrace: [<000000004254801a>] kmalloc_trace+0x26/0x100 [<0000000039eb1cf5>] 0xffffffffa00083cd [<000000000e8c3bc8>] 0xffffffffa00086ba [<00000000c293d1ea>] do_one_initcall+0xdb/0x480 [<00000000aa189e6d>] do_init_module+0x1cf/0x680 [<00000000d513222b>] load_module+0x6a50/0x70a0 [<000000001fd4d529>] __do_sys_finit_module+0x12f/0x1c0 [<00000000b36c4c0f>] do_syscall_64+0x3f/0x90 [<00000000bbf20cf3>] entry_SYSCALL_64_after_hwframe+0x63/0xcd unreferenced object 0xffff8881127df000 (size 2048): comm "modprobe", pid 247, jiffies 4294972324 (age 78.728s) hex dump (first 32 bytes): 20 65 6d 70 74 79 5f 73 79 6e 74 68 5f 74 65 73 empty_synth_tes 74 20 20 70 69 64 5f 74 20 6e 65 78 74 5f 70 69 t pid_t next_pi backtrace: [<000000004254801a>] kmalloc_trace+0x26/0x100 [<00000000d4db9a3d>] 0xffffffffa0008071 [<00000000c31354a5>] 0xffffffffa00086ce [<00000000c293d1ea>] do_one_initcall+0xdb/0x480 [<00000000aa189e6d>] do_init_module+0x1cf/0x680 [<00000000d513222b>] load_module+0x6a50/0x70a0 [<000000001fd4d529>] __do_sys_finit_module+0x12f/0x1c0 [<00000000b36c4c0f>] do_syscall_64+0x3f/0x90 [<00000000bbf20cf3>] entry_SYSCALL_64_after_hwframe+0x63/0xcd