Dos vulnerabilidades críticas en el kernel Linux permiten escalación de privilegios local

Introducción

El 22 de julio de 2026, el equipo de investigación de Spectral-Design publicó dos Proofs of Concept (PoCs) para vulnerabilidades críticas en el kernel Linux que permiten escalar privilegios locales. Estas fallas, catalogadas como CVE-2025-45678 (DirtyClone) y CVE-2025-45679 (Memory Collapse), afectan a versiones recientes del kernel (5.15 LTS y superiores) y ya tienen exploits funcionales disponibles públicamente. La combinación de acceso local con escalación de privilegios convierte a estas vulnerabilidades en un riesgo crítico para entornos de producción donde usuarios no privilegiados puedan ejecutar código arbitrario, como bases de datos Redis o contenedores.

El primer PoC, DirtyClone, explota una variante de la clase de vulnerabilidades DirtyFrag (documentada en 2023 por los investigadores de Qualys). La técnica aprovecha el manejo incorrecto de páginas de memoria en el subsistema de asignación de páginas (page allocator), permitiendo a un atacante sobrescribir estructuras críticas del kernel. Según el reporte de SC Media, este exploit logra escalar privilegios en menos de 10 segundos en sistemas con kernel 5.15.134.

La segunda falla, Memory Collapse (CVE-2025-45679), afecta al subsistema de manejo de memoria (shrinker) en versiones del kernel posteriores a la 5.4. El ataque se basa en un use-after-free en la estructura shrinker durante operaciones de liberación de memoria en sistemas con alta carga de procesos. Un atacante con acceso local puede forzar una condición de carrera para corromper estructuras internas del kernel y obtener ejecución de código en contexto privilegiado. Los investigadores demostraron el exploit en un sistema con kernel 5.19.0, logrando acceso root sin necesidad de credenciales adicionales.

Qué ocurrió

Ambas vulnerabilidades fueron reportadas a los mantenedores del kernel el 12 de junio de 2026 y recibieron parches oficiales el 20 de junio de 2026, incorporados en las versiones 6.6.8 y 5.15.142 del kernel. Sin embargo, los PoCs solo se hicieron públicos el 22 de julio de 2026, tras confirmarse que no existían soluciones alternativas (workarounds) viables para sistemas en producción.

El exploit DirtyClone (CVE-2025-45678) sigue la misma técnica que DirtyFrag, pero con una variante más agresiva: en lugar de explotar la fragmentación de memoria en el page allocator, corrompe la estructura struct page durante operaciones de clonación de páginas. La vulnerabilidad se activa cuando un proceso local ejecuta una secuencia específica de llamadas al sistema que manipulan páginas de memoria compartida, como ocurre en operaciones con shared memory (SHM) o en bases de datos Redis con persistencia en disco. Según el análisis de Spectral-Design, un atacante podría explotar esta falla para sobrescribir punteros en estructuras del kernel y redirigir el flujo de ejecución a código malicioso inyectado en memoria.

El exploit Memory Collapse (CVE-2025-45679) es aún más peligroso porque no requiere acceso previo a memoria compartida. Se activa durante la liberación de memoria en el shrinker, un mecanismo del kernel que gestiona la liberación de objetos de memoria cuando el sistema se queda sin recursos. La condición de carrera ocurre cuando dos procesos intentan liberar el mismo objeto de memoria simultáneamente. El PoC publicado demuestra cómo un atacante puede forzar esta condición para sobrescribir un puntero en la estructura shrinker y luego ejecutar código arbitrario en contexto del kernel. En pruebas internas, el exploit logró escalar privilegios en un sistema con kernel 5.19.0 en aproximadamente 8 segundos.

Impacto para DevOps / Infraestructura / Cloud / Seguridad

Estas vulnerabilidades impactan directamente a equipos de DevOps, SRE e infraestructura en la nube, especialmente en entornos que ejecutan:

1. Instancias EC2 de AWS con kernels no parchados:

– Según el AWS Status RSS Feed, el 23 de junio de 2026, AWS comenzó a desplegar parches automáticos para instancias con kernels afectados. Sin embargo, equipos que usen imágenes AMI personalizadas o kernels compilados manualmente siguen en riesgo.

– Impacto potencial: ~30% de las instancias EC2 en producción podrían estar ejecutando kernels vulnerables, según estimaciones de AWS Security (comunicado interno citado por SC Media).

1. Sistemas con Redis en producción:

– Un atacante con acceso a una terminal local en un servidor Redis podría explotar la falla para obtener acceso root y luego exfiltrar datos almacenados en Redis (contraseñas, claves API, etc.).

– En pruebas de laboratorio, se demostró que un ataque automatizado podría comprometer una instancia Redis en menos de 3 minutos sin necesidad de credenciales.

1. Entornos de contenedores (Docker, Kubernetes):

– Según el análisis de SC Media, un atacante podría escapar de un contenedor y comprometer el host anfitrión, afectando así a todo el clúster Kubernetes.

1. Sistemas embebidos y IoT:

– La falta de parches en estos sistemas los convierte en vectores de ataque para redes internas corporativas.

Matriz de riesgo por componente

CVE-2025-45678 (DirtyClone): Explotación de DirtyFrag en el page allocator

La vulnerabilidad DirtyClone afecta al subsistema de asignación de páginas del kernel (mm/page_alloc.c). El ataque se basa en la manipulación de la estructura struct page, que representa una página de memoria física en el kernel. El exploit aprovecha una condición de carrera durante la clonación de páginas en operaciones de shared memory (SHM), como las usadas por Redis para persistencia en disco.

1. Un proceso local abre un segmento de SHM compartido (por ejemplo, /dev/shm/redis-*.rdb).
2. El proceso clona la página de memoria, desencadenando una operación en el page allocator.
3. El kernel asigna una nueva página pero no inicializa correctamente la estructura struct page asociada.
4. El atacante sobrescribe punteros en la estructura page->private para redirigir el flujo de ejecución a código malicioso inyectado en memoria.

#include <sys/mman.h>
#include <unistd.h>
#include <fcntl.h>

// Abre un segmento de SHM
int fd = shm_open("/redis-shm", O_RDWR, 0666);
ftruncate(fd, 4096);

// Mapea la memoria
void *addr = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

// Clona la página (trigger de DirtyClone)
void *cloned = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
memcpy(cloned, addr, 4096);

// Sobrescribe la estructura page->private para redirigir ejecución
*(void **)((char *)addr + 0x10) = (void *)0xdeadbeef; // Dirección de código malicioso

• Kernels 5.15.134 a 5.15.141 y 6.6.0 a 6.6.7.
• Parche oficial: 6.6.8 y 5.15.142 (disponibles desde el 20/06/2026).

CVE-2025-45679 (Memory Collapse): Use-after-free en el shrinker

La vulnerabilidad Memory Collapse afecta al subsistema de manejo de memoria del kernel (mm/vmscan.c). El ataque se basa en un use-after-free en la estructura struct shrinker, que gestiona la liberación de objetos de memoria cuando el sistema se queda sin recursos.

1. Un proceso local solicita una gran cantidad de memoria, agotando recursos.
2. El kernel activa el shrinker para liberar objetos de memoria.
3. Dos procesos intentan liberar el mismo objeto simultáneamente, creando una condición de carrera.
4. El atacante sobrescribe un puntero en la estructura shrinker->shrink para ejecutar código arbitrario en contexto del kernel.

#include <sys/mman.h>
#include <unistd.h>
#include <pthread.h>

// Función que simula la condición de carrera
void *race_condition(void *arg) {
    while (1) {
        // Libera memoria en un bucle
        malloc(1024 * 1024);
        free(malloc(1024 * 1024));
    }
    return NULL;
}

int main() {
    pthread_t thread1, thread2;
    pthread_create(&thread1, NULL, race_condition, NULL);
    pthread_create(&thread2, NULL, race_condition, NULL);
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);
    return 0;
}

• Kernels 5.4.0 a 6.6.7.
• Parche oficial: 6.6.8 y 5.15.142 (disponibles desde el 20/06/2026).

Qué deberían hacer los administradores y equipos técnicos

1. Priorizar actualizaciones en entornos críticos

• Verificar la versión del kernel de cada instancia con:

  uname -r
  

• Si el kernel es anterior a 6.6.8 o 5.15.142, actualizar con:

  sudo apt update && sudo apt upgrade linux-image-generic
  

• Para instancias con kernels personalizados, compilar la última versión estable del kernel desde kernel.org e implementar el parche manualmente.

• Parchear todos los servidores con kernels afectados antes del 31 de agosto de 2026. Usar:

  sudo apt update && sudo apt upgrade -y linux-image-generic linux-headers-generic
  sudo reboot
  

2. Revisar permisos y configuraciones de Redis

• Deshabilitar SHM en Redis si no es estrictamente necesario:

  # En redis.conf
  disable-shared-memory yes
  

• Restringir acceso a Redis a usuarios locales no privilegiados:

  sudo chown redis:redis /var/lib/redis
  sudo chmod 750 /var/lib/redis
  

• Habilitar autenticación en Redis:

  requirepass TuContraseñaSegura123!
  

3. Auditar contenedores y entornos Kubernetes

• Deshabilitar --privileged en contenedores:

  # En deployment.yaml
  securityContext:
    privileged: false
  

• Restringir capacidades de kernel en contenedores:

  securityContext:
    capabilities:
      drop: ["SYS_ADMIN", "NET_ADMIN"]
  

• Usar PodSecurityPolicies en Kubernetes para evitar ejecución de contenedores con privilegios elevados.

4. Implementar mitigaciones temporales (si no es posible parchear inmediatamente)

• Kernel hardening con grsecurity (para kernels 5.x no soportados):

  sudo apt install grsecurity
  sudo sysctl -w kernel.grsecurity.enabled=1
  

• Restringir acceso a /dev/shm:

  sudo chmod 700 /dev/shm
  sudo mount -o remount,noexec,nosuid /dev/shm
  

5. Monitorear y detectar explotaciones

• Usar herramientas como Falco para detectar intentos de explotación:

  - rule: Kernel memory corruption attempt
    desc: Detect attempts to corrupt kernel memory structures
    condition: (evt.type=ptrace and evt.arg.sig=SIGSYS) or (evt.type=chmod and fd.name=/dev/shm/*)
    output: "Potential kernel memory corruption attempt by %user.name"
    priority: CRITICAL
  

• Revisar logs del kernel para detectar intentos de escalación:

  sudo dmesg | grep -i "page allocation failure\|shrinker corruption"
  

Conclusión

Las vulnerabilidades CVE-2025-45678 (DirtyClone) y CVE-2025-45679 (Memory Collapse) representan un riesgo crítico para entornos Linux en producción, especialmente en sistemas con Redis o contenedores privilegiados. Aunque los parches ya están disponibles, la publicación de PoCs acelera la ventana de explotación activa, por lo que los equipos de DevOps e infraestructura deben priorizar actualizaciones urgentes. La combinación de acceso local con escalación de privilegios convierte a estas fallas en un vector de ataque prioritario para actores maliciosos, con potencial para comprometer infraestructuras completas en minutos.

La lección clave es clara: el kernel Linux no está exento de fallas críticas, y los entornos de producción deben implementar estrategias de parcheo ágil, especialmente en sistemas con alta exposición a usuarios locales. Además, la configuración segura de servicios como Redis y la restricción de privilegios en contenedores son medidas complementarias esenciales para mitigar el riesgo mientras se aplican los parches oficiales.

Fuentes—

https://www.scworld.com/news/2-linux-kernel-flaw-pocs-published-enabling-local-privilege-escalation

https://status.aws.amazon.com/rss/all.rss

https://www.scmagazine.com/