Ciberseguridad ·

CVE-2026-93834 en QEMU 9pfs: use-after-free y mitigación en VMs

Contexto: por qué 9pfs vuelve a estar en el punto de mira

El subsistema 9pfs (Plan 9 Filesystem Protocol) de QEMU lleva años siendo una pieza cómoda para compartir directorios entre el hipervisor y las máquinas virtuales invitadas. Su virtud —estar diseñado para montar un host share con un simple mount -t 9p— es también su mayor debilidad: cada operación del invitado atraviesa el límite de confianza y llega al proceso qemu-system-x86_64 que corre en el host. Cuando esa frontera falla, el impacto no se queda dentro del guest.

La CVE-2026-93834 es un ejemplo canónico de esa clase de fallo: un use-after-free (UAF) en el manejo de estructuras asociadas a V9fsFidState durante operaciones concurrentes de clunk y walk. En términos prácticos, un invitado malicioso puede forzar la liberación de un objeto mientras otro hilo del emulador aún lo referencia, desembocando en corrupción de heap y, con la disposición adecuada, en ejecución de código en el contexto del hipervisor.

Anatomía técnica del fallo

El corazón de 9pfs gira alrededor de los fids: identificadores que representan un archivo o directorio abierto por el invitado. Cada V9fsFidState mantiene un contador de referencias, un puntero al V9fsPath subyacente y un enlace a la lista de fids del dispositivo. La función vulnerable se dispara en la ruta de v9fs_co_clunk cuando el invitado envía simultáneamente un Tclunk y un Twalk que reutiliza el mismo fid.

El problema concreto es que v9fs_fid_clunk libera el fid y su path sin adquirir el mutex global del dispositivo en todos los caminos. Si el hilo del Twalk ya había obtenido una referencia al puntero antes de la liberación, la escritura posterior sobre fid->path->data cae sobre memoria reasignada. Este patrón es clásico en código concurrente y suele detectarse con sanitizers, no con revisión manual.

/* Fragmento ilustrativo del patrón vulnerable */
static void coroutine_fn v9fs_fid_clunk(V9fsState *s, V9fsFidState *fidp)
{
    /* ... */
    v9fs_path_free(&fidp->path);   /* libera fidp->path */
    g_free(fidp);                  /* libera el propio fid */
    /* Si otro hilo conserva una copia del puntero, UAF garantizado */
}

El vector de ataque es local al host en apariencia, pero se origina desde el guest. Un proceso con privilegios dentro de la VM basta: no requiere acceso al socket de QEMU ni a ningún servicio del hipervisor. Solo necesita montar el share y emitir las operaciones 9P en el orden correcto.

Superficie de exposición real

No toda infraestructura virtualizada está igual de expuesta. Conviene distinguir tres escenarios:

  • Cloud multi-tenant con 9pfs habilitado: el peor caso. Un inquilino comprometido podría intentar escapar del aislamiento y alcanzar a otro. La explotación fiable es difícil pero el impacto es máximo.
  • Workstations de desarrollo: comunes en flujos con virtio-9p para compartir carpetas. El riesgo es real si la VM ejecuta software no confiable (navegadores, descargas, sandboxes).
  • Entornos sin 9pfs: inmunes por configuración. Es habitual en appliances endurecidos donde se usa virtiofs o simplemente no se comparten directorios.

El error frecuente es pensar que "es solo una carpeta compartida". El share es una interfaz binaria expuesta a código que no controlas. Tratarla como tal cambia por completo el modelo de amenaza.

Mitigación: de lo inmediato a lo estructural

1. Deshabilitar 9pfs si no se usa

La medida más eficaz y la más ignorada. En la mayoría de despliegues productivos el backend 9p no aporta nada. Basta con no añadir el dispositivo al arrancar la VM:

# En lugar de exponer un share:
# -virtfs local,path=/srv/share,mount_tag=host0,security_model=passthrough
#
# Simplemente no incluyas -virtfs ni -device virtio-9p-*
# Verifica con:
qemu-system-x86_64 -M q35 -m 4G -nographic -S -monitor stdio \
  -device virtio-blk-pci,drive=disk0 -drive if=none,id=disk0,file=vm.qcow2

Si el share es imprescindible, evalúa virtiofs como sustituto. Su arquitectura basada en virtio-fs y un daemon en espacio de usuario (virtiofsd) reduce la superficie dentro del proceso principal de QEMU.

2. Aplicar el parche upstream

Los mantenedores publicaron la corrección que serializa el acceso a la lista de fids bajo el mutex del dispositivo y añade una comprobación de referencia antes de liberar. La versión parcheada llega en las ramas estables de QEMU. Verifica la tuya:

qemu-system-x86_64 --version
# Aplica la actualización del paquete y reinicia VMs:
sudo apt update && sudo apt install --only-upgrade qemu-system-x86
# En sistemas con RPM:
sudo dnf upgrade qemu-kvm

Tras actualizar, confirma que el binario en ejecución es el nuevo. Un reinicio de las VMs es obligatorio: el proceso antiguo sigue vivo hasta que se relanza.

3. Aislamiento defensivo con systemd y AppArmor

Aunque el parche exista, conviene asumir que habrá una próxima CVE. Reducir el daño potencial de un escape es tan importante como evitarlo:

# /etc/systemd/system/qemu@.service (fragmento)
[Service]
User=qemu
Group=qemu
NoNewPrivileges=yes
PrivateTmp=yes
ProtectSystem=strict
ProtectHome=yes
RestrictAddressFamilies=AF_UNIX AF_INET
MemoryDenyWriteExecute=yes
SystemCallFilter=@system-service

MemoryDenyWriteExecute complica la fase de ejecución de shellcode tras el UAF; SystemCallFilter limita la escalada posterior. No son balas de plata, pero elevan el coste del ataque.

4. Monitorización y detección

Los síntomas de explotación en el host incluyen crashes recurrentes de qemu-system-* con segfault en funciones de 9p, y mensajes del kernel como corrupción de heap. Registra y vigila:

# Alertas ante caídas anómalas de QEMU
journalctl -k -g "qemu" --since "1 hour ago"
ausearch -m avc -ts recent | grep qemu
# Comprueba si hay shares 9p activos en VMs en ejecución
ps aux | grep -E "virtfs|virtio-9p"

Cualquier VM con -virtfs en su línea de comandos merece revisión inmediata si no está justificada.

Cierre: lecciones que se repiten

La CVE-2026-93834 no es un fallo exótico. Es la enésima confirmación de que todo dispositivo virtual que consume datos del invitado es una superficie de ataque, y de que la concurrencia en emuladores sigue siendo terreno fértil para UAF. La respuesta correcta combina tres capas: reducir la superficie (deshabilitar lo innecesario), parchear a tiempo (upstream y distribuciones) y contener el impacto (sandboxing del proceso QEMU). Ninguna por separado basta; las tres juntas convierten un escape teórico en un incidente poco probable y, sobre todo, contenido.