Bajo nivel · C++

De Ring 3 a Ring 0: qué pasa cuando tu código cruza la frontera del kernel

En esta página
  1. Un viaje que haces miles de veces por segundo
  2. Qué es un anillo de privilegio
  3. Cruzar la frontera: qué es una syscall
  4. ¿Cuánto cuesta cruzar?
  5. Ring 0 no perdona: por qué un fallo ahí es distinto
  6. Las defensas que protegen esa frontera hoy
  7. Por qué te debería importar aunque no escribas drivers

Un viaje que haces miles de veces por segundo#

Guardas un archivo. Pulsas Ctrl+S, tu editor pide escribir en disco y, en microsegundos, el archivo está a salvo. Parece un paso trivial.

No lo es. En ese instante la CPU ha cambiado de mundo: ha dejado de ejecutar el código de tu editor, un programa sin privilegios que no puede tocar el disco directamente, y ha pasado a ejecutar código del kernel del sistema operativo, que puede hacerlo todo. Después ha vuelto, como si nada. Y eso ocurre miles de veces por segundo en cualquier ordenador que uses.

Esa frontera tiene nombre: el salto de Ring 3 a Ring 0. Entenderla explica por qué tu navegador puede colgarse sin arrastrar al resto del sistema, por qué un driver defectuoso produce una pantalla azul, y por qué en julio de 2024 millones de ordenadores con Windows dejaron de arrancar a la vez.

Qué es un anillo de privilegio#

x86 define cuatro niveles de privilegio, numerados del 0 al 3 y dibujados tradicionalmente como anillos concéntricos. Cuanto más bajo el número, más poder tiene el código que se ejecuta ahí.

En una frase

Ring 0 es donde vive el kernel y tiene acceso total al hardware. Ring 3 es donde viven tus aplicaciones y solo pueden pedirle cosas al kernel.

La CPU sabe en qué anillo está gracias al CPL (Current Privilege Level), guardado en los dos bits más bajos del registro de segmento de código. No hace falta consultar ninguna tabla externa: cada instrucción lleva pegada la pregunta de si quien la ejecuta tiene permiso para hacerlo.

Puedes comprobarlo tú mismo. Este programa lee el registro CS y se queda con esos dos bits:

cpl.cpp
// g++ -std=c++20 cpl.cpp -o cpl   (Linux x86-64)
#include <cstdint>
#include <format>
#include <iostream>

int main() {
    std::uint16_t cs;
    asm volatile("mov %%cs, %0" : "=r"(cs));
    std::cout << std::format("CS = {:#06x}  ->  CPL = {}\n", cs, cs & 3);
}
salida
$ ./cpl
CS = 0x0033  ->  CPL = 3

CPL 3: tu programa, como todos, vive en el anillo exterior.

¿Por qué casi nadie usa los anillos 1 y 2? Por dos razones prácticas: el sistema de memoria por páginas solo distingue dos niveles (usuario y supervisor, un único bit), así que separar en más niveles no añade protección real de memoria; y un kernel que solo usa dos niveles se porta mucho mejor a otras arquitecturas como ARM o RISC-V, donde el sistema operativo también trabaja con dos: usuario y kernel (los niveles extra quedan para el hipervisor o el firmware).

Ring 3 — modo usuarioRing 0 — modo kernel
Quién vive ahíTus aplicacionesEl kernel y sus drivers
Memoria que veSolo la de su propio procesoToda la memoria del sistema
Instrucciones privilegiadasProhibidasPermitidas
Acceso al hardwareSiempre mediado por el kernelDirecto
Si algo falla ahíSe cierra el procesoCae el sistema entero

Esa última fila es la que de verdad importa, y volvemos a ella al final.

Cruzar la frontera: qué es una syscall#

Si tu programa no puede tocar el disco, ¿cómo llega a escribir un archivo? Pidiéndoselo al kernel. Esa petición se llama system call (syscall), y es la única puerta legítima entre los dos mundos.

Lo interesante es que tu programa no decide a dónde salta. Si pudiera elegir la dirección exacta, cualquier aplicación podría intentar ejecutar código arbitrario en Ring 0. En su lugar, durante el arranque el kernel configura un registro especial de la CPU con la dirección exacta de su propio punto de entrada. Cuando el programa ejecuta la instrucción de syscall, la CPU siempre salta ahí, nunca a otro sitio. Es una puerta con una sola cerradura, y la llave la tiene el kernel, no el programa que llama.

El recorrido, simplificado, es siempre el mismo:

  1. Tu programa prepara los parámetros de la llamada y ejecuta la instrucción de syscall.
  2. La CPU cambia el CPL de 3 a 0 y salta al punto de entrada fijado por el kernel. Lo primero que hace el kernel al llegar es cambiar a su propia pila: la de usuario no es de fiar.
  3. El kernel valida los parámetros —nunca se fía de lo que venga de Ring 3— y ejecuta la operación real.
  4. El kernel devuelve el control, la CPU vuelve el CPL a 3, y tu programa continúa como si no hubiera pasado nada.

El paso 3 es la clave de toda la seguridad del sistema: cada syscall es un punto donde el kernel decide si confía en ti o no. Ahí se comprueban permisos de archivo, cuotas de memoria, límites del proceso... Es la frontera donde vive buena parte de la seguridad de un sistema operativo.

Normalmente esto lo hace la biblioteca estándar por ti (std::cout acaba llamando a write()), pero no tiene nada de mágico. Así se ve una syscall hecha a mano, sin pasar por ninguna biblioteca:

syscall.cpp
// write(1, msg, len) sin pasar por libc   (Linux x86-64)
#include <cstddef>
#include <string_view>

static long raw_write(int fd, const void* buf, std::size_t len) {
    long ret;
    asm volatile(
        "syscall"
        : "=a"(ret)                              // resultado en rax
        : "a"(1L), "D"(fd), "S"(buf), "d"(len)   // rax = 1 = SYS_write
        : "rcx", "r11", "memory");               // pisa rcx y r11
    return ret;
}

int main() {
    constexpr std::string_view msg = "Ring 3 -> Ring 0 -> Ring 3\n";
    raw_write(1, msg.data(), msg.size());
}

Fíjate en la línea de rcx y r11: al ejecutar syscall, la CPU guarda ahí la dirección de retorno y los flags para poder volver después. Es la prueba de que el salto lo controla el hardware, no tu programa. Y el número 1 no es una dirección, es un índice: le dices al kernel qué quieres, nunca a dónde saltar.

¿Cuánto cuesta cruzar?#

Cambiar de anillo no es gratis: hay que cambiar de pila, guardar y restaurar registros y, con las mitigaciones modernas, a veces hasta cambiar de tablas de páginas. Puedes medirlo:

coste.cpp
// g++ -std=c++20 -O2 coste.cpp -o coste   (Linux x86-64)
#include <chrono>
#include <format>
#include <iostream>
#include <unistd.h>
#include <sys/syscall.h>

int main() {
    using clock = std::chrono::steady_clock;
    constexpr int N = 1'000'000;

    auto t0 = clock::now();
    for (int i = 0; i < N; ++i)
        syscall(SYS_getppid);   // ida y vuelta al kernel
    auto t1 = clock::now();

    std::chrono::duration<double, std::nano> ns = t1 - t0;
    std::cout << std::format("{:.0f} ns por syscall\n", ns.count() / N);
}

Según tu CPU y las mitigaciones activas, verás del orden de decenas a cientos de nanosegundos por viaje. Una llamada a una función normal cuesta alrededor de un nanosegundo. Por eso el software de alto rendimiento intenta cruzar la frontera las menos veces posibles: agrupa escrituras, usa buffers y, en los casos extremos, APIs como io_uring que permiten encolar muchas operaciones con muy pocas syscalls.

Curiosidad

El propio reloj que usa el programa para medir (std::chrono::steady_clock, que por debajo llama a clock_gettime()) casi nunca entra en el kernel. Linux mapea en cada proceso una pequeña zona llamada vDSO con código y datos del kernel de solo lectura, para que las llamadas más frecuentes, como leer la hora, se resuelvan sin cruzar la frontera.

Ring 0 no perdona: por qué un fallo ahí es distinto#

En Ring 3, un fallo de memoria (leer donde no debes, por ejemplo) normalmente solo mata tu proceso. El sistema operativo lo detecta, libera sus recursos y sigue funcionando con total normalidad.

Lo mismo pasa si intentas hacer algo reservado a Ring 0. La instrucción hlt, que detiene la CPU hasta la siguiente interrupción, es una de ellas:

hlt.cpp
// g++ hlt.cpp -o hlt   (Linux x86-64)
#include <iostream>

int main() {
    // std::endl vacía el buffer: la línea sale antes de morir
    std::cout << "Intentando 'hlt' desde Ring 3..." << std::endl;
    asm volatile("hlt");
    std::cout << "Esto nunca se imprime.\n";
}
salida
$ ./hlt
Intentando 'hlt' desde Ring 3...
Segmentation fault (core dumped)

La CPU compara el CPL con el nivel que exige la instrucción, ve que es 3 y lanza una excepción de protección general (#GP). El kernel la recibe, ve que viene de un proceso de usuario y lo termina. El resto del sistema ni se entera. Esa es la red de seguridad de Ring 3.

Si lo compilas en Windows (con MinGW, por ejemplo), el resultado es el mismo con otro nombre: el proceso termina con el código 0xC0000096, STATUS_PRIVILEGED_INSTRUCTION.

En Ring 0 no hay esa red de seguridad. El kernel es el que decide qué hacer cuando algo va mal, así que si el fallo ocurre dentro del propio kernel —o en un driver, que se ejecuta con los mismos privilegios— no queda nadie por encima para contenerlo. La respuesta habitual es parar la máquina antes de que el daño se extienda: eso es una pantalla azul en Windows (BSOD) o un kernel panic en Linux. No es una decisión torpe del sistema operativo: es la única opción segura que le queda.

Esto se agrava porque los drivers suelen ejecutarse a un IRQL (nivel de interrupción) elevado, donde ni siquiera se permite acceder a memoria paginable ni tomar ciertos tipos de bloqueo. Un error que en modo usuario sería un simple crash, en modo kernel puede ser un fallo mucho más profundo.

Caso real

En julio de 2024, una actualización de contenido del sensor de CrowdStrike Falcon —un driver que se carga en Ring 0 en Windows— hizo que el driver leyera memoria fuera de los límites válidos al procesar un nuevo archivo de configuración. El resultado no fue un simple error de la aplicación: fueron pantallas azules en cadena en millones de máquinas en todo el mundo, muchas de ellas en aeropuertos, hospitales y bancos. El incidente es el ejemplo más citado de por qué el software que corre en Ring 0 exige un nivel de rigor muy distinto al del software de usuario.

Las defensas que protegen esa frontera hoy#

Windows y Linux no confían en que "el kernel nunca falla". Han ido añadiendo capas de defensa, cada una pensada para un tipo distinto de fallo o ataque:

  • SMEP (Supervisor Mode Execution Prevention): impide que el kernel ejecute código que esté en páginas de memoria marcadas como de usuario. Sin esto, un fallo que redirigiera la ejecución del kernel hacia datos de un proceso normal sería mucho más peligroso.
  • SMAP (Supervisor Mode Access Prevention): el equivalente para lectura y escritura. El kernel no puede tocar memoria de usuario por accidente ni sin pasar por rutinas explícitas que saben que están manejando datos no confiables.
  • KASLR (Kernel Address Space Layout Randomization): coloca el kernel en una dirección de memoria distinta en cada arranque, para que un atacante que conozca un fallo no pueda asumir dónde está el código o los datos que quiere alcanzar.
  • KPTI (Kernel Page Table Isolation): separa casi por completo las tablas de páginas del kernel de las de cada proceso de usuario. Se introdujo de forma masiva tras Meltdown (2018), un fallo de ejecución especulativa que permitía a código en Ring 3 leer memoria del kernel que no debía ver. Si al ejecutar coste.cpp te salen números más altos de lo esperado, KPTI es uno de los sospechosos: cada cruce implica cambiar de tablas de páginas.
  • Firma de drivers: en Windows moderno, un driver no puede cargarse en Ring 0 si no está firmado digitalmente por un certificado válido para ese propósito. No es burocracia: es la última puerta antes de dejar entrar código nuevo al anillo que no perdona.

Ninguna de estas defensas hace que Ring 0 sea "seguro" en un sentido absoluto. Lo que hacen es encarecer muchísimo convertir un fallo cualquiera en algo explotable, y eso, en la práctica, es la diferencia entre un incidente contenido y uno catastrófico.

Por qué te debería importar aunque no escribas drivers#

Casi ningún desarrollador escribe código de kernel en su día a día, y sin embargo esta frontera te afecta constantemente:

  • Cada vez que un antivirus, un sistema de detección de intrusiones o una herramienta de monitorización dice "requiere un componente de kernel", está pidiendo vivir en Ring 0, con todo lo que eso implica si algo sale mal.
  • Las tecnologías de virtualización basada en seguridad de Windows (VBS) y HVCI usan un nivel todavía más privilegiado que Ring 0 —el hipervisor— precisamente para poder vigilar al propio kernel desde fuera. Ese anillo, informalmente llamado Ring -1, tiene su propia entrada.
  • Todo el cloud moderno —máquinas virtuales, contenedores con aislamiento reforzado— se apoya en esta misma jerarquía de privilegios llevada un nivel más abajo.
Nota personal

Lo aprendí por las malas escribiendo un hipervisor académico como driver de kernel para Windows. Lo primero que descubres en Ring 0 es que tu C++ deja de ser C++: sin excepciones, sin RTTI, sin STL, y cada reserva de memoria sale de un pool no paginable que tú eliges a conciencia, porque un error ahí no lanza una excepción: reinicia la máquina. Lo segundo me costó más: Windows se negó a cargar mi driver, firmado y con el modo de pruebas activado. Averiguar por qué me obligó a entender cuántas capas tiene la cadena de integridad del kernel (Secure Boot, el tipo de certificado, la integridad de memoria…) y a trabajar siempre en una máquina virtual de pruebas. Desde entonces veo esa firma como lo que es: la puerta que evita que cualquiera entre en el anillo que no perdona.

La próxima vez que tu editor guarde un archivo sin que lo notes, ya sabes lo que ha pasado por debajo: tu código ha cruzado la frontera más vigilada del sistema operativo, y ha vuelto justo a tiempo para que ni te dieras cuenta.

Referencias

  1. Intel® 64 and IA-32 Architectures Software Developer's ManualsIntel · intel.com
  2. syscall(2) — Linux manual pageman7.org · man7.org
  3. Page Table Isolation (PTI)Linux kernel documentation · docs.kernel.org

Compartir

Sigue leyendo

Bajo nivel

Anatomía de un driver de Windows: del DriverEntry al IRP

Qué pasa dentro de un driver de Windows: DriverEntry, IRQL, el viaje de un IRP, la tabla de dispatch, los IOCTL y por qué un spinlock mal usado tumba el sistema. Con código real.

· 12 min

Bajo nivel · Parte 3

Ring -2: SMI, SMRAM y RSM, cómo el firmware toma la CPU por debajo del hipervisor

Qué hay por debajo del hipervisor: System Management Mode, el código del firmware que se ejecuta a escondidas del sistema, y cómo comprobar desde C++ qué protecciones declara tu firmware.

· 12 min

¿Tu proyecto necesita ir por debajo de la capa de aplicación?

Software de sistemas, rendimiento y seguridad en Windows y Linux: diagnóstico, herramientas a medida y revisión de código de bajo nivel.

Hablemos→

Comentarios

Para comentar necesitas una cuenta de GitHub. Los comentarios se guardan en GitHub Discussions (SoftDryzz/blog-comments) y se moderan: no se publican enlaces promocionales.