Descripción
En el Linux kernel se ha resuelto la siguiente vulnerabilidad: ceph: bound num_export_targets array for mds info v2/v3 ceph_mdsmap_decode() en fs/ceph/mdsmap.c lee num_export_targets de cada registro de información por MDS y avanza el cursor de decodificación en num_export_targets * sizeof(u32) sin comprobar antes que queden esos bytes. La única comprobación de límite superior que detecta un cursor desbocado (*p > info_end) está condicionada a info_v >= 4, porque info_end queda en NULL para info_v 2 y 3. Cuando el monitor envía un mapa MDS cuya versión de información por MDS es 2 o 3 con un num_export_targets sobredimensionado, el cursor se desplaza más allá del búfer front del mensaje y el bucle posterior de export-targets llama a ceph_decode_32() sin comprobación sobre memoria fuera de límites. Un cliente del kernel procesa CEPH_MSG_MDS_MAP desde su sesión con el monitor (net/ceph/mon_client.c lo despacha; fs/ceph/super.c lo enruta a ceph_mdsc_handle_mdsmap(), que fija end al límite del búfer front y llama a ceph_mdsmap_decode()). Por lo tanto, un monitor malicioso o comprometido, o un atacante en la ruta de una sesión de mensajería sin firma o sin cifrado, puede provocar una lectura fuera de límites en el kernel del cliente; en x86_64 con KASAN se reporta como una lectura fuera de límites en slab en ceph_mdsmap_decode(). Los valores decodificados terminan en el arreglo interno info->export_targets[], por lo que la consecuencia es una lectura fuera de límites en el kernel, no una filtración de información hacia el atacante. Impacto: un monitor de Ceph malicioso o comprometido que envíe un mapa MDS con una versión de información por MDS de 2 o 3 y un campo num_export_targets sobredimensionado provoca una lectura fuera de límites en el kernel del cliente CephFS. Se agrega un ceph_decode_need() para el arreglo export-targets antes de avanzar el cursor, de modo que el límite se aplique para todo info_v >= 2, no solo para info_v >= 4. Esto replica el patrón de conteo y verificación ya usado para m_data_pg_pools más adelante en la misma función. Se calcula la cantidad de bytes de export-targets con size_mul() y se reutiliza esa longitud verificada al avanzar el cursor, de modo que la multiplicación de num_export_targets controlada por el atacante falle de forma segura ante un desbordamiento, en lugar de depender de la protección posterior de kcalloc().
Qué hacer
Revisa si usas el producto afectado y en qué versión, y aplica la actualización o la mitigación que indique el aviso del fabricante. CISA no ha confirmado que se esté explotando; si eso cambia, esta ficha pasa a «explotada» y te avisamos en el boletín.
Versiones afectadas
- Linux Afectadas: d463a43d69f4af85887671d76182437775fd1631 y anteriores a a6eaf7bd229d0940ba8f126c684a663a680abef1 · d463a43d69f4af85887671d76182437775fd1631 y anteriores a 0c4bcc3ba7291d383b82ce1c2fe324f69a42da2d · d463a43d69f4af85887671d76182437775fd1631 y anteriores a 55a06b32438c222765138727d0a8164b103e8f0d · d463a43d69f4af85887671d76182437775fd1631 y anteriores a eb3e1a1cb1634c76d59c5a9cb1a026fc69d40911 · d463a43d69f4af85887671d76182437775fd1631 y anteriores a 3bf7dba8dba9a05774b846affec61a3624ddba38 · d463a43d69f4af85887671d76182437775fd1631 y anteriores a 58c2d3e954c13694ef6e820a5e9456461bb9e7df · d463a43d69f4af85887671d76182437775fd1631 y anteriores a 332c444f4dc6fa1e8b8637c9e82d29e97f768656 · d463a43d69f4af85887671d76182437775fd1631 y anteriores a a3eb169ee297aa99670ba927c659990bd1e453f3
- Linux Afectadas: 4.7 No afectadas: 5.10.273 · 5.15.221 · 6.1.188 · 6.6.157 · 6.12.109 · 6.18.50
Según el registro de la vulnerabilidad en CVE.org, tal como lo publicó el fabricante. Confirma tu versión exacta en el aviso del fabricante.
Referencias
- Referencia en git.kernel.orggit.kernel.org/stable/c/a6eaf7bd229d0940ba8f126c684a663a680abef1
- Referencia en git.kernel.orggit.kernel.org/stable/c/0c4bcc3ba7291d383b82ce1c2fe324f69a42da2d
- Referencia en git.kernel.orggit.kernel.org/stable/c/55a06b32438c222765138727d0a8164b103e8f0d
- Referencia en git.kernel.orggit.kernel.org/stable/c/eb3e1a1cb1634c76d59c5a9cb1a026fc69d40911
- Referencia en git.kernel.orggit.kernel.org/stable/c/3bf7dba8dba9a05774b846affec61a3624ddba38
- Referencia en git.kernel.orggit.kernel.org/stable/c/58c2d3e954c13694ef6e820a5e9456461bb9e7df
- Referencia en git.kernel.orggit.kernel.org/stable/c/332c444f4dc6fa1e8b8637c9e82d29e97f768656
- Referencia en git.kernel.orggit.kernel.org/stable/c/a3eb169ee297aa99670ba927c659990bd1e453f3
Ver el texto original en inglés (CVE.org)
ceph: bound num_export_targets array for mds info v2/v3
In the Linux kernel, the following vulnerability has been resolved: ceph: bound num_export_targets array for mds info v2/v3 ceph_mdsmap_decode() in fs/ceph/mdsmap.c reads num_export_targets from each per-mds info record and advances the decode cursor by num_export_targets * sizeof(u32) without first checking that many bytes remain. The only upper-bound check that catches a runaway cursor (*p > info_end) is gated on info_v >= 4, because info_end is left NULL for info_v 2 and 3. When the monitor sends an MDS map whose per-mds info version is 2 or 3 with an oversized num_export_targets, the cursor moves past the message front buffer and the later export-targets loop calls the unchecked ceph_decode_32() on out-of-bounds memory. A kernel client processes CEPH_MSG_MDS_MAP from its monitor session (net/ceph/mon_client.c dispatches it; fs/ceph/super.c routes it to ceph_mdsc_handle_mdsmap(), which sets end to the front buffer bound and calls ceph_mdsmap_decode()). A malicious or compromised monitor, or an on-path attacker on an unsigned/unencrypted messenger session, can therefore drive an out-of-bounds read in the client kernel; on x86_64 with KASAN it is reported as a slab-out-of-bounds read in ceph_mdsmap_decode(). The decoded values land in the internal info->export_targets[] array, so the consequence is a kernel out-of-bounds read, not an information leak to the attacker. Impact: a malicious or compromised Ceph monitor sending an MDS map with a per-mds info version of 2 or 3 and an oversized num_export_targets field triggers an out-of-bounds read in the CephFS client kernel. Add a ceph_decode_need() for the export-targets array before advancing the cursor, so the bound is enforced for every info_v >= 2, not only info_v >= 4. This mirrors the count-then-need idiom already used for m_data_pg_pools later in the same function. Compute the export-targets byte count with size_mul() and reuse that checked length when advancing the cursor, so the attacker-controlled num_export_targets multiplication fails closed on overflow rather than relying on the later kcalloc() guard.