El subsistema de bloqueo del Kernel de Linux ha vuelto a ser el foco de atención debido a una vulnerabilidad de severidad alta catalogada como CVE-2026-43499 (CVSS v3.1: 7.8). El fallo reside específicamente en la gestión de exclusión mutua en tiempo real (rtmutex), concretamente dentro de la función remove_waiter().

Este vector no solo impacta la estabilidad del sistema mediante condiciones de Denegación de Servicio (DoS), sino que, bajo escenarios específicos de manipulación de memoria, abre la puerta a la escalada local de privilegios (LPE) mediante primitivas de tipo Use-After-Free (UAF).

DETALLES DEL FALLO:

• ID: CVE-2026-43499
• Severidad: 7.8 / 10 (Alta)
• Componente afectado: Kernel de Linux (Subsistema de sincronización y mutex de tiempo real).
• Impacto potencial: Un atacante local con pocos privilegios podría aprovechar la corrupción de memoria para colapsar el sistema (Denegación de Servicio) o potencialmente escalar privilegios en la máquina.

Mecánica del Fallo: El Problema con current en remove_waiter()

La función remove_waiter() está diseñada originalmente para ser utilizada por las rutas de bloqueo lento (slowlock paths). En condiciones normales de ejecución, el waiter (el hilo que espera el bloqueo) coincide con el contexto del hilo de ejecución actual (current).

Sin embargo, el Kernel invoca esta misma función durante los procesos de reversión de bloqueo por proxy (proxy-lock rollback) en rt_mutex_start_proxy_lock(), llamamiento que es gatillado desde futex_requeue().

El Desajuste de Contexto

Cuando remove_waiter() es invocado vía futex_requeue(), el contexto cambia drásticamente: waiter::task ya no es equivalente a current.

A pesar de esto, la lógica previa del código seguía operando bajo la premisa de current para realizar la operación de eliminación de la cola (dequeue). Esto desencadenaba tres fallos estructurales en cascada:

1. Violación de Exclusión Mutua en rbtree: El dequeue del árbol binario auto-balanceable (rbtree) se ejecutaba sin que se mantuviera retenido el bloqueo de herencia de prioridad crítico (waiter::task::pi_lock).
2. Punteros Colgantes (Dangling Pointers): El estado pi_blocked_on de la tarea del waiter no se limpiaba de manera síncrona. Esto dejaba una referencia inválida apuntando a una estructura ya liberada en el stack o en el heap, preparando el escenario perfecto para un exploit Use-After-Free (UAF).
3. Desalineación de Prioridades: La función rt_mutex_adjust_prio_chain() calculaba las métricas sobre una tarea de waiter incorrecta, rompiendo el determinismo del programador de tiempo real (RT scheduler).

Código y Solución (El Parche)

El upstream patch enviado por los mantenedores del kernel (encabezado por Thomas Gleixner) corrige la vulnerabilidad de manera elegante. Se reemplazaron todas las operaciones dependientes de la macro implícita current dentro de remove_waiter() y subrutinas asociadas, forzando explícitamente el uso del puntero directo waiter::task.

// Representación conceptual del cambio en la lógica del Kernel
void remove_waiter(struct rt_mutex *lock, struct rt_mutex_waiter *waiter) {
-   /* Código vulnerable que operaba de manera implícita sobre current */
-   dequeue_rt_mutex(lock, current); 
+   /* Código corregido: Opera estrictamente sobre la estructura del waiter original */
+   raw_spin_lock(&waiter->task->pi_lock);
+   dequeue_rt_mutex(lock, waiter);
+   waiter->task->pi_blocked_on = NULL;
+   raw_spin_unlock(&waiter->task->pi_lock);
}

Adicionalmente, se corrigieron las referencias cruzadas en rt_mutex_adjust_prio_chain() para asegurar que cualquier ajuste en la cadena de inversión de prioridades se realice sobre el hilo legítimamente bloqueado.

Impacto y Mitigación

• Vector de Ataque: Local (AV:L). Requiere acceso previo al sistema (interfaz de línea de comandos o ejecución de binarios locales desprivilegiados).
• Complejidad: Baja (AC:L). No requiere condiciones de carrera extremadamente complejas una vez que el estado de futex ha sido alterado.
• Privilegios Requeridos: Bajos (PR:L). Cualquier usuario estándar del sistema puede ejecutar llamadas futex().

Remediación

Al tratarse de una vulnerabilidad a nivel de arquitectura de sincronización del núcleo, no existen mitigaciones viables a través de configuraciones de userspace (como sysctl) sin romper la funcionalidad de aplicaciones dependientes de subprocesos y futex (como entornos de bases de datos o servidores web de alto rendimiento).

La única solución definitiva es la actualización del Kernel. Las siguientes ramas estables de soporte a largo plazo (LTS) han incorporado los parches (backports):

• Ramas afectadas: Kernels desde la serie 2.6.39 en adelante.
• Versiones parcheadas estables: Asegurarse de actualizar a las últimas subversiones distribuidas por los vendors (RedHat, Debian, Ubuntu, SUSE) que apliquen los commits correspondientes a rtmutex: Use waiter::task instead of current in remove_waiter().