79% frente al 51%: los neobancos independientes quedan atrás en seguridad de aplicaciones. Leer el informe

Análisis a fondo

Análisis a fondo

Falla del llavero del kernel de Linux: root local sin corrección

Una falla del arreglo asociativo del kernel de Linux permite a un usuario local ser root; la corrección no está fusionada.

Resumen

  • Un usuario local sin privilegios puede corromper el arreglo asociativo de un llavero y obtener capacidades de root en los kernels de Linux que llevan el código original. El investigador Daniel Wade publicó un exploit funcional el 2026-11-15.
  • Todo kernel desde el commit 3cb989501c26 (2013-09-24) está afectado en principio. El kernel principal 7.4-rc3 y todas las ramas estables verificadas todavía llevan el código vulnerable el 2026-11-16.
  • No hay identificador CVE ni puntuación CVSS asignados. No se conoce explotación en el mundo real y la falla no está en el catálogo KEV de CISA al 2026-11-16.
  • Ningún kernel publicado incluye la corrección. Aplique el commit 48691075b0ad si compila su propio kernel. Restrinja también los sockets AF_ALG sin privilegios, lo que según el investigador elimina el oráculo de heap que necesita la cadena publicada.

¿Estoy afectado?

Todas estas condiciones deben cumplirse para que un equipo esté expuesto:

  • El kernel en ejecución se compiló a partir de un código que no contiene el commit 48691075b0ad. El 2026-11-16 eso incluía el kernel principal 7.4-rc3 y todas las versiones de las ramas estables de la tabla.
  • El kernel se compiló con el subsistema de llaveros (CONFIG_KEYS), que es el valor predeterminado en las distribuciones de propósito general.
  • Un atacante puede ejecutar código como usuario local sin privilegios en el equipo. No hacen falta capacidades, espacios de nombres de usuario ni grupos especiales.
  • Los sockets AF_ALG sin privilegios están disponibles, y el exploit publicado los usa como oráculo de heap. Bloquearlos eleva el coste de esta cadena, pero no corrige la falla.

La falla está en lib/assoc_array.c, el arreglo asociativo genérico que el código de llaveros bajo security/keys/ usa para almacenar claves. Todo kernel que lleve ese archivo y CONFIG_KEYS está afectado en principio. El exploit público está escrito para una imagen de kernel concreta. Otra compilación puede necesitar otro ajuste, pero el estado corrupto del árbol no depende de la compilación.

Rama Versiones afectadas Versión corregida
kernel principal 7.4-rc3 y anteriores Ninguna el 2026-11-16
7.3.y 7.3.4 y anteriores Ninguna el 2026-11-16
6.18.y 6.18.63 y anteriores Ninguna el 2026-11-16
6.12.y 6.12.117 y anteriores Ninguna el 2026-11-16
6.6.y 6.6.162 y anteriores Ninguna el 2026-11-16
6.1.y 6.1.192 y anteriores Ninguna el 2026-11-16
5.15.y 5.15.225 y anteriores Ninguna el 2026-11-16
5.10.y 5.10.274 y anteriores Ninguna el 2026-11-16
4.19.y Todas las versiones Ninguna el 2026-11-16

Cada extremo de rama de la tabla se verificó el 2026-11-16: todos declaran todavía excised_meta[1], el arreglo que agranda la corrección. Los kernels de las distribuciones requieren el registro de cambios del proveedor, porque un proveedor puede incluir el commit sin cambiar la cadena de versión.

Compruebe el kernel en ejecución:

uname -r

Para un kernel que compile usted mismo, compruebe si la corrección está en el árbol. El primer comando muestra el commit de la corrección si está presente; el segundo muestra [2] cuando el encabezado corregido está en su sitio y [1] cuando no:

git -C /path/to/linux log --oneline --all --grep="assoc_array: don't chain a new shortcut"
grep -n 'excised_meta' include/linux/assoc_array_priv.h

Compruebe si un usuario sin privilegios puede abrir un socket AF_ALG. Ejecute este comando como el usuario sin privilegios, no como root:

python3 - <<'PY'
import socket
s = socket.socket(socket.AF_ALG, socket.SOCK_SEQPACKET, 0)
print("AF_ALG is available to this user")
s.close()
PY

¿Cómo lo corrijo?

No existe una actualización de kernel de ningún proveedor. La corrección es un parche de dos archivos, registrado en un árbol del kernel pero no fusionado en el kernel principal. La corrección consiste, por tanto, en aplicarlo usted mismo o esperar a su distribución.

  1. Si compila su propio kernel, aplique el commit 48691075b0ad, o haga cherry-pick sobre su rama, y recompile. El commit modifica include/linux/assoc_array_priv.h y lib/assoc_array.c.
  2. Si usa un kernel de distribución, siga el aviso de seguridad del proveedor. Ninguna distribución había publicado un kernel corregido el 2026-11-16.
  3. Donde no pueda aplicar el parche, restrinja el acceso sin privilegios a la interfaz de sockets AF_ALG. El investigador lo recomienda porque la cadena publicada usa AF_ALG como oráculo de heap. Contrapartida: eleva el coste de esta cadena concreta, pero el código de los llaveros sigue siendo accesible y la falla sigue abierta.
  4. Trate el acceso de shell local en un equipo sin corregir como equivalente a root. Contrapartida: es un control operativo, no una corrección, y no ayuda contra un atacante que ya tiene una cuenta.

La corrección cierra el estado que crea el exploit. No elimina el BUG_ON() de assoc_array_apply_edit(), que sigue siendo una protección contra un árbol mal formado.

¿Cuál es la causa raíz?

El arreglo asociativo suponía que un atajo siempre lleva a un nodo. Una eliminación seguida de una inserción podía instalar un atajo detrás de otro. El recorrido y la contabilidad de la edición no manejan ese estado.

lib/assoc_array.c es un árbol radix protegido por RCU. Un nodo tiene 16 ranuras. Un atajo comprime una rama con un solo ocupante en un salto y almacena los bits de índice saltados en línea. La garantía de diseño es que el padre de un atajo siempre es un nodo, nunca otro atajo. El primer atajo habría absorbido los bits del segundo.

La eliminación puede romper esa garantía. Cuando el subárbol bajo un atajo se reduce lo suficiente, assoc_array_delete() lo colapsa en un solo nodo bajo el atajo. Un nodo simple ocupa entonces el lugar del destino del atajo.

La inserción puede después colocar un atajo detrás de ese atajo. Cuando las hojas de un nodo lleno y la nueva clave comparten el segmento del nodo, assoc_array_insert_into_terminal_node() reemplaza el nodo por un atajo llamando a assoc_array_insert_shortcut(). Si el nodo es a su vez el destino de un atajo, el nuevo atajo se instala como next_node del anterior.

El código vulnerable fija el puntero hacia atrás del nuevo atajo en el puntero hacia atrás del nodo, que es el atajo anterior:

new_s0->back_pointer = node->back_pointer;
new_s0->parent_slot = node->parent_slot;
new_s0->next_node = assoc_array_node_to_ptr(new_n0);

Entonces fallan dos cosas. assoc_array_walk() sigue un atajo leyendo shortcut->next_node. Cuando ese puntero es otro atajo, el recorrido lo trata como un nodo e indexa los bits saltados como una ranura. Un lector sigue entonces un puntero desde el nivel equivocado del árbol.

Por separado, assoc_array_apply_edit() recorre los punteros hacia atrás para ajustar nr_leaves_on_branch. Sigue el back_pointer de un atajo y comprueba que el resultado sea un nodo:

if (assoc_array_ptr_is_shortcut(ptr)) {
    shortcut = assoc_array_ptr_to_shortcut(ptr);
    ptr = shortcut->back_pointer;
    if (!ptr)
        break;
}
BUG_ON(!assoc_array_ptr_is_node(ptr));

Con dos atajos encadenados, ptr es un atajo y la comprobación se dispara. El hilo que inserta muere en el BUG del kernel. Un lector que ya recorría el árbol en ese momento sobrevive y procesa la estructura corrupta.

El disparador es pequeño. El commit de la corrección da la receta. Hacen falta dieciséis claves que coinciden en los bits 0 a 11. También hace falta una que diverge en el bit 8 y luego se elimina, y una última que vuelve a unirse a las dieciséis. Son dieciocho inserciones y una eliminación, seguidas de la llamada final a add_key().

¿Cómo se explota?

Un usuario local lleva el llavero al estado roto con dieciocho inserciones de claves y una eliminación, y luego gana una carrera contra el hilo que se bloquea.

  1. El atacante se ejecuta como usuario local sin privilegios y crea un llavero con add_key() y keyctl().
  2. El atacante realiza las dieciocho inserciones y la eliminación que describe el commit de la corrección. La eliminación colapsa el subárbol bajo un atajo en un solo nodo.
  3. La llamada final a add_key() encuentra el nodo lleno y la nueva clave compartiendo el segmento del nodo. assoc_array_insert_shortcut() reemplaza el nodo por un atajo, y como el nodo ya era el destino de un atajo, el nuevo atajo queda detrás del anterior.
  4. El hilo que inserta llega a assoc_array_apply_edit() y dispara el BUG_ON(). El kernel mata ese hilo. El exploit ha dejado un segundo hilo en key_link, que recorre el mismo árbol, así que el lector sobrevive.
  5. El lector trata una asignación controlada por el atacante como una struct key. La cadena coloca el puntero user de la clave falsa ocho bytes antes de una struct cred real. La contabilidad de cuotas de claves por UID del kernel escribe entonces en las palabras de capacidad de la credencial.
  6. La escritura fija los 32 bits bajos de cred->cap_effective, que incluyen CAP_DAC_OVERRIDE y CAP_SETUID. El proceso conserva su identificador de usuario original pero ya puede leer archivos reservados a root.
  7. El exploit llama a setresuid(0, 0, 0) y execve() para lanzar un shell root. El kernel concede el conjunto completo de capacidades en execve porque el identificador de usuario efectivo es 0.

La prueba de concepto pública registra el bloqueo en la inserción:

kernel BUG at lib/assoc_array.c:1387!
assoc_array_apply_edit+0x221/0x230
 __key_link+0x51/0x80
 __key_instantiate_and_link+0xc0/0x140
 __key_create_or_update+0x51a/0x580
 key_create_or_update+0x14/0x30
 __se_sys_add_key+0x1d0/0x240

El exploit es un artefacto de laboratorio. Está compilado para la imagen endurecida kernelCTF 7.2-rc5 de Google y necesita la imagen correspondiente y un initramfs de tipo kernelCTF, que el repositorio no incluye.

La corrección se escribió el 11 de octubre de 2026 y se registró en un árbol del kernel el 13 de octubre de 2026. El exploit público apareció el 15 de noviembre de 2026, 35 días después de escribirse la corrección.

Cronología desde la corrección escrita el 11 de octubre de 2026 hasta el exploit público del 15 de noviembre
Figura 1: De la corrección escrita el 11 de octubre de 2026 al exploit público del 15 de noviembre de 2026, 35 días. Fuente: commit de la corrección y repositorio del exploit, verificados el 16 de noviembre de 2026

¿Cómo se desarrolla el ataque?

Un usuario local lleva el arreglo asociativo del llavero a un estado de atajo detrás de otro atajo. Un lector concurrente sobrevive al bloqueo del hilo que inserta, y la contabilidad de cuotas del kernel se convierte en una escritura de capacidad.

flowchart LR A["Usuario local sin privilegios"] --> B["18 llamadas add_key(), una eliminación
y luego un add_key() final"] B --> C["atajo detrás de un atajo
sin comprobación de ese estado"] C --> D["assoc_array_apply_edit()
el BUG_ON mata al hilo que inserta"] C --> E["lector en key_link()
recorre el árbol roto"] E --> F["struct key falsa
alias de una struct cred"] F --> G["escritura de la cuota de claves
fija CapEff"] G --> H["CAP_SETUID y luego setresuid(0)
shell root"]

¿Qué puede hacer un atacante?

El impacto demostrado es una escalada de privilegios local a root. El exploit necesita una cuenta local sin privilegios, ninguna capacidad, ningún espacio de nombres de usuario y ningún grupo especial. No necesita una posición de red.

La primera etapa es una escalada de capacidades, no un cambio de identificador de usuario. El proceso conserva uid 1000 y obtiene CapEff=00000000ffffffff, los 32 bits bajos del contador de cuota aliaseado. CAP_DAC_OVERRIDE en ese conjunto hace legibles archivos reservados a root.

La segunda etapa usa CAP_SETUID para llamar a setresuid(0,0,0) y execve(), momento en que el kernel concede el conjunto completo y el proceso es root.

Las cifras de fiabilidad son las del investigador, medidas en la única imagen fijada con dos vCPU. La compilación de shell root tuvo éxito 7 veces de 8; la de lectura de bandera, 14 de 20.

Los fallos son la carrera en sí, no una primitiva ausente. Otra compilación del kernel tiene un comportamiento de asignación distinto, así que no se espera que el mismo binario funcione sin cambios.

No se demuestra ninguna ruta remota. La falla se alcanza mediante operaciones locales del llavero, y la cadena publicada exige ejecución de código local. No se conoce explotación en el mundo real y ninguna fuente informa de un compromiso.

¿Por qué funciona la corrección?

El parche hace que el nuevo atajo reemplace también al atajo situado delante del nodo, de modo que el árbol nunca contiene un atajo que lleve a otro atajo.

    new_s0->back_pointer = node->back_pointer;
    new_s0->parent_slot = node->parent_slot;
+
+   /* A shortcut has to lead to a node, so a node at the end of a shortcut
+    * is replaced together with that shortcut.  The new one holds the index
+    * key from the root, so it covers what the old one did.
+    */
+   if (node->back_pointer &&
+       assoc_array_ptr_is_shortcut(node->back_pointer)) {
+       struct assoc_array_shortcut *above =
+           assoc_array_ptr_to_shortcut(node->back_pointer);
+
+       new_s0->back_pointer = above->back_pointer;
+       new_s0->parent_slot = above->parent_slot;
+       edit->excised_meta[1] = node->back_pointer;
+   }
    new_s0->next_node = assoc_array_node_to_ptr(new_n0);
    new_n0->back_pointer = assoc_array_shortcut_to_ptr(new_s0);
    new_n0->parent_slot = 0;

El nuevo atajo hereda el puntero hacia atrás y la ranura padre del anterior, así que se instala donde estaba el anterior. El atajo anterior se registra en la segunda ranura de excised_meta, que es la razón del cambio de excised_meta[1] a excised_meta[2].

El atajo anterior se elimina en la misma edición. El recorrido llega así siempre a un nodo, y la contabilidad de la edición nunca ve un atajo donde espera un nodo.

El parche cubre la ruta de inserción que crea el estado. Solo hay una implementación de assoc_array en el kernel, así que no hay una segunda copia que corregir. El BUG_ON() permanece como protección.

¿Cómo compruebo si estuve comprometido?

No se publican indicadores de compromiso y no se conoce explotación en el mundo real. El único observable público es el BUG del kernel de un intento fallido.

Busque la comprobación en el registro del kernel. Una coincidencia significa que la inserción vulnerable se ejecutó y que el hilo que insertaba murió; no demuestra que la escritura de capacidad haya funcionado:

dmesg -T | grep -i "assoc_array"

Busque en el registro de auditoría un proceso no root que haya llamado a setresuid(0) o haya obtenido capacidades que no tenía antes. La escritura de capacidad no deja ningún archivo. Por tanto, trate como sospechoso un equipo donde un usuario sin privilegios podía ejecutar el exploit. También es sospechoso un shell root que aparece sin una entrada de inicio de sesión correspondiente.

Un intento que falla antes del BUG puede no dejar rastro. La ausencia de una entrada de registro no demuestra que el equipo no haya sido objetivo.

Cronología

  • 2013-09-24: el commit 3cb989501c26 añade la implementación genérica del arreglo asociativo.
  • 2026-10-11: Linus Torvalds escribe la corrección.
  • 2026-10-13: la corrección se registra en un árbol del kernel.
  • 2026-11-15: Daniel Wade publica el exploit.
  • 2026-11-16: el kernel principal 7.4-rc3 y las ramas estables todavía llevan el código vulnerable.

Preguntas frecuentes

¿Hay un CVE?

No. No hay identificador CVE ni puntuación CVSS asignados al 2026-11-16. El commit de la corrección, el repositorio del exploit y el análisis del investigador forman el registro público.

¿Afecta a mi distribución?

Sí, en principio. Todo kernel de distribución compilado a partir de un árbol sin el commit 48691075b0ad lleva la falla. Ninguna distribución había publicado un kernel corregido el 2026-11-16, así que consulte el aviso de seguridad del proveedor en lugar de la cadena de versión.

¿Es fiable el exploit?

En el objetivo publicado, sí. El investigador informa de 7 shells root en 8 ejecuciones y 14 lecturas de bandera en 20 en la imagen kernelCTF 7.2-rc5 con dos vCPU. Necesita esa imagen y ese initramfs; otra compilación necesita otro ajuste.

¿Puede usarlo un atacante remoto?

No se demuestra ninguna ruta remota. El exploit necesita una cuenta local sin privilegios, y la falla se alcanza mediante operaciones locales del llavero.

¿Bloquear AF_ALG corrige la falla?

No. Elimina el oráculo de heap que usa la cadena publicada, lo que el investigador recomienda, pero el código de los llaveros sigue siendo accesible y la falla sigue. Solo el parche del kernel la cierra.

¿Qué urgencia tiene?

No hay explotación en el mundo real y el exploit es un artefacto de laboratorio. Aun así, un usuario local en un equipo sin corregir puede convertirse en root. Corrija sus propios kernels o restrinja el acceso local mientras espera una actualización de la distribución.

Referencias

  • Commit de la corrección, «assoc_array: don't chain a new shortcut onto an existing one», https://github.com/torvalds/linux/commit/48691075b0adc590a6831390723e3603dfca76fc (verificado el 16 de noviembre de 2026)
  • Commit de introducción, «Add a generic associative array implementation», https://github.com/torvalds/linux/commit/3cb989501c26 (verificado el 16 de noviembre de 2026)
  • Repositorio del exploit y análisis técnico, Daniel Wade, https://github.com/Rat5ak/ASSOC_ARRAY_SHORTCUT-CHAIN-EoP (verificado el 16 de noviembre de 2026)
  • lib/assoc_array.c en v7.4-rc3, https://github.com/gregkh/linux/blob/v7.4-rc3/lib/assoc_array.c (verificado el 16 de noviembre de 2026)
  • include/linux/assoc_array_priv.h en v7.4-rc3, https://github.com/gregkh/linux/blob/v7.4-rc3/include/linux/assoc_array_priv.h (verificado el 16 de noviembre de 2026)
  • Cyber Kendra, «Unpatched Linux Kernel Keyring Flaw Gives Local Root», https://www.cyberkendra.com/2026/11/linux-kernel-assoc-array-keyring-root-exploit.html (verificado el 16 de noviembre de 2026)
  • Catálogo Known Exploited Vulnerabilities de CISA, https://www.cisa.gov/known-exploited-vulnerabilities-catalog (verificado el 16 de noviembre de 2026)
  • CVE-2016-7914, una falla anterior en la misma función, https://www.cve.org/CVERecord?id=CVE-2016-7914 (verificado el 16 de noviembre de 2026)
  • CVE-2017-12193, otra falla anterior en la misma función, https://www.cve.org/CVERecord?id=CVE-2017-12193 (verificado el 16 de noviembre de 2026)