Windows Kernel Desarrollador en Rust. Introducción.

Windows Kernel Desarrollador en Rust. Introducción.

Introducción al desarrollo de controladores Windows Kernel en Rust

Contenido

  • Introducción
  • Dependencias
  • Desarrollo
    • Configuración
    • Implementación
  • Implementación y pruebas
  • Resumen
  • Referencias

Introducción

¡Hola! Me alegra que estés aquí. En esta publicación crearemos un pequeño controlador de kernel Windows usando Rust. Sí, ese Rust. Moderno, ruidoso y realmente útil.

Este artículo se centra en la seguridad y los fundamentos: configuración de la cadena de herramientas, vinculación con el WDK, no_std, un punto de entrada mínimo del controlador y salida de depuración del kernel a través de DbgPrint. Desde aquí puede pasar a los siguientes pasos legítimos, como el manejo de IOCTL, los objetos del dispositivo, las rutinas de envío de IRP y la arquitectura del controlador real.

Si aún no conoces Rust, igual estarás bien: también mostraré un ejemplo C++ comparable. Todo lo que necesita es tiempo, experiencia en C/C++ y conocimientos básicos del desarrollo en modo kernel.

¿Por qué Rust? Porque puede ofrecer un rendimiento cercano a C/C++ al mismo tiempo que proporciona sólidas garantías de seguridad de la memoria a nivel de lenguaje. Muchas organizaciones grandes están invirtiendo en código seguro para la memoria y Rust en particular, y el ecosistema Rust se envía rápidamente con lanzamientos estables cada ~6 semanas y un canal nocturno separado.

⚠️ Nota de ética y seguridadLos controladores del kernel funcionan con privilegios extremos. Utilice estas técnicas únicamente para aprendizaje, investigación y desarrollo legítimo.

Dependencias

Para seguir (o copiar/pegar), instale:

También querrás una VM (VMWare, Hyper-V, VirtualBox, QEMU) con Windows 10 x64 or Windows 11, firma de prueba habilitaday la depuración del kernel habilitada.

Habilite el modo de prueba y la depuración del kernel, luego reinicie:

⚠️ Ejecute la terminal como Administrador

# Enable Test Signing mode
bcdedit -set TESTSIGNING ON

# Enable kernel debugging
bcdedit /debug on

Desarrollo

Configuración

Cree un nuevo proyecto de biblioteca Rust:

cargo new hello-win-kernel --lib

Estructura del proyecto:

hello-win-kernel/
  src/lib.rs
  .gitignore
  Cargo.toml

En Rust, main.rs es el punto de entrada para los binarios, y lib.rs es el punto de entrada para las bibliotecas. Construiremos un controlador como un artefacto de biblioteca dinámica.

Editar Cargo.toml:

  • Añadir un [lib] sección y conjunto crate-type = ["cdylib"] entonces Rust produce una biblioteca dinámica compatible con C.
  • conjunto panic = "abort" tanto para perfiles de depuración como de versión para evitar el comportamiento de desenredado.
  • Añadir winreg como un construir dependencia para leer las rutas de los kits WDK/Windows desde el registro en build.rs.

carga.toml

[package]
name = "hello-win-kernel"
version = "0.1.0"
edition = "2021"

[lib]
path = "src/lib.rs"
crate-type = ["cdylib"]

[profile.dev]
panic = "abort"

[profile.release]
panic = "abort"

[build-dependencies]
winreg = "0.50.0"

Crear un rust-toolchain archivo en la raíz del proyecto para forzar el uso nocturno (necesitamos indicadores solo nocturnos durante la vinculación):

rust-toolchain

nightly

Agregue un script de compilación para ubicar las bibliotecas WDK

Para crear un controlador, necesitamos vincularlo a algunas bibliotecas WDK (por ejemplo, ntoskrnl). Agregaremos rutas de búsqueda de biblioteca en el momento de la compilación a través de build.rs.

crear build.rs:

construir.rs

extern crate winreg;

use std::env::var;
use std::error::Error;
use std::fmt;
use std::path::{Path, PathBuf};
use winreg::enums::*;
use winreg::RegKey;

const WIN_KITS_KEY: &str = r"SOFTWARE\Microsoft\Windows Kits\Installed Roots";

#[derive(Debug)]
struct BuildError {
    msg: String,
}

impl Error for BuildError {}

impl fmt::Display for BuildError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "BuildError: {}", self.msg)
    }
}

fn get_windows_kits_dir() -> Result<PathBuf, BuildError> {
    let hklm = RegKey::predef(HKEY_LOCAL_MACHINE);
    match hklm.open_subkey(WIN_KITS_KEY) {
        Ok(key) => match key.get_value::<String, _>("KitsRoot10") {
            Ok(dir) => Ok(dir.into()),
            Err(_) => Err(BuildError {
                msg: format!("Cannot get value: {}", WIN_KITS_KEY),
            }),
        },
        Err(_) => Err(BuildError {
            msg: format!("Cannot open subkey: {}", WIN_KITS_KEY),
        }),
    }
}

fn get_km_dir(windows_kits_dir: &PathBuf) -> Result<PathBuf, BuildError> {
    match Path::new(windows_kits_dir).join("lib").read_dir() {
        Ok(read_dir) => {
            match read_dir
                .filter_map(|dir| dir.ok())
                .map(|dir| dir.path())
                .filter(|dir| {
                    dir.components()
                        .last()
                        .and_then(|c| c.as_os_str().to_str())
                        .map(|c| c.starts_with("10.") && dir.join("km").is_dir())
                        .unwrap_or(false)
                })
                .max()
                .ok_or_else(|| format!("Cannot find a valid km dir in `{:?}`", windows_kits_dir))
            {
                Ok(max_lib_dir) => Ok(max_lib_dir.join("km")),
                Err(msg) => Err(BuildError { msg }),
            }
        }
        Err(_) => Err(BuildError {
            msg: format!("Cannot read dir: {:?}", windows_kits_dir),
        }),
    }
}

fn main() {
    let windows_kits_dir = get_windows_kits_dir().unwrap();
    let km_dir = get_km_dir(&windows_kits_dir).unwrap();

    let target = var("TARGET").unwrap();
    let arch = if target.contains("x86_64") {
        "x64"
    } else if target.contains("i686") {
        "x86"
    } else {
        panic!("Only x64 and x86 are supported!");
    };

    let wdk_lib_dir = km_dir.join(arch);

    println!(
        "cargo:rustc-link-search=native={}",
        wdk_lib_dir.to_str().unwrap()
    );
}

Configuración del vinculador para una compilación de controlador

Crear un .cargo carpeta y agregue un archivo de configuración. Soportes de carga config.toml (preferido) y mayores config.

.carga/config.toml

[build]
target = "x86_64-pc-windows-msvc"

rustflags = [
  # Pre-link args (nightly-only via -Z)
  "-Z", "pre-link-arg=/NOLOGO",
  "-Z", "pre-link-arg=/NXCOMPAT",
  "-Z", "pre-link-arg=/NODEFAULTLIB",
  "-Z", "pre-link-arg=/SUBSYSTEM:NATIVE",
  "-Z", "pre-link-arg=/DRIVER",
  "-Z", "pre-link-arg=/DYNAMICBASE",
  "-Z", "pre-link-arg=/INCREMENTAL:NO",
  "-Z", "pre-link-arg=/MANIFEST:NO",
  "-Z", "pre-link-arg=/PDBALTPATH:none",

  # Post-link args
  "-C", "link-arg=/OPT:REF,ICF",
  "-C", "link-arg=/ENTRY:driver_entry",
  "-C", "link-arg=/MERGE:.edata=.rdata",
  "-C", "link-arg=/MERGE:.rustc=.data",
  "-C", "link-arg=/INTEGRITYCHECK",
]

Implementación

Rust no incluye una biblioteca estándar utilizable en modo kernel, por lo que la desactivamos con #![no_std]. También implementamos un controlador de pánico personalizado y proporcionamos un par de símbolos para satisfacer el vinculador MSVC en esta configuración mínima.

crear src/lib.rs:

src/lib.rs

#![no_std]

mod dbg;
mod ntstatus;
mod types;

use ntstatus::*;
use types::*;

// Fixes linker expectations in some configurations.
#[no_mangle]
pub extern "system" fn __CxxFrameHandler3(
    _: *mut u8,
    _: *mut u8,
    _: *mut u8,
    _: *mut u8,
) -> i32 {
    0
}

// Fixes linker expectations. Floating-point is generally discouraged in kernel drivers.
#[export_name = "_fltused"]
static _FLTUSED: i32 = 0;

// Panic handler (no std, no unwinding)
#[cfg(not(test))]
#[panic_handler]
fn panic(_info: &core::panic::PanicInfo) -> ! {
    loop {}
}

// Driver entry point
#[no_mangle]
pub extern "system" fn driver_entry(_driver: PVOID, _path: PVOID) -> NTSTATUS {
    kd_print!("Hello, world!\n");
    STATUS_SUCCESS
}

Agregue alias de tipo básico Windows:

src/tipos.rs

pub type NTSTATUS = u32;
pub type PCSTR = *const u8;
pub type PVOID = *mut core::ffi::c_void;

Agregue una constante NTSTATUS mínima:

src/ntstatus.rs

use crate::types::*;

pub const STATUS_SUCCESS: NTSTATUS = 0x00000000;

Salida de depuración del kernel con DbgPrint

Ahora importaremos DbgPrint from ntoskrnl y envuélvalo con una pequeña macro para no olvidarnos del terminador nulo.

src/dbg.rs

use crate::types::*;

#[link(name = "ntoskrnl")]
extern "C" {
    #[allow(dead_code)]
    pub fn DbgPrint(format: PCSTR, ...) -> NTSTATUS;
}

#[macro_export]
#[cfg(debug_assertions)]
macro_rules! kd_print {
    ($string: expr) => {
        unsafe {
            $crate::dbg::DbgPrint(concat!("[hello_win_kernel.sys] ", $string, "\0").as_ptr())
        }
    };

    ($string: expr, $($x:tt)*) => {
        unsafe {
            $crate::dbg::DbgPrint(
                concat!("[hello_win_kernel.sys] ", $string, "\0").as_ptr(),
                $($x)*
            )
        }
    };
}

#[macro_export]
#[cfg(not(debug_assertions))]
macro_rules! kd_print {
    ($string: expr) => {};
    ($string: expr, $($x:tt)*) => {};
}

En este punto puedes construir con éxito. A continuación, automatizaremos el cambio de nombre/firma y probaremos la carga.

Implementación y pruebas

Para probar un controlador en una VM, normalmente necesita:

  1. Construye el .dll artifact
  2. cambiarle el nombre a .sys
  3. Fírmelo (el certificado de prueba es suficiente para el modo de prueba)
  4. Cárguelo como un servicio y verifique el resultado.

Automatizaremos estos pasos con cargo-make.

Instálalo:

cargo install cargo-make

Configurar la ruta de las herramientas Windows SDK

Cree una variable de entorno del sistema llamada WIN_SDK_TOOLS apuntando a su carpeta de herramientas Windows SDK.

Pasos:

  1. Abierto Ver configuración avanzada del sistema
  2. Ir a Avanzado tab
  3. Haga clic Variables de entorno
  4. bajo variables del sistema, haga clic Nuevo
  5. Nómbralo WIN_SDK_TOOLS
  6. Establezca el valor en la ruta de herramientas Windows SDK
  7. Haga clic OK

Env.gif

Agregar un script de creación de carga

crear makefile.toml en la raíz del proyecto:

makefile.toml

[env.development]
TARGET_PATH = "target/x86_64-pc-windows-msvc/debug"

[env.release]
TARGET_PATH = "target/x86_64-pc-windows-msvc/release"
BUILD_FLAGS = "--release"

[tasks.build-driver]
script = [
  "cargo build %BUILD_FLAGS%"
]

[tasks.rename-driver]
dependencies = ["build-driver"]
ignore_errors = true
script = [
  "cd %TARGET_PATH%",
  "rename hello_win_kernel.dll hello_win_kernel.sys"
]

[tasks.sign-driver]
dependencies = ["build-driver", "rename-driver"]
script = [
  ""%WIN_SDK_TOOLS%\\makecert.exe" -r -pe -ss PrivateCertStore -n "CN=hello_win_kernel_cert" hello_win_kernel_cert.cer",
  ""%WIN_SDK_TOOLS%\\signtool.exe" sign /fd sha256 /v /s PrivateCertStore /n "hello_win_kernel_cert" /t http://timestamp.digicert.com /a %TARGET_PATH%/hello_win_kernel.sys"
]

[tasks.deploy]
dependencies = ["sign-driver"]
script = [
  "mkdir bin",
  "move hello_win_kernel_cert.cer bin\\hello_win_kernel_cert.cer",
  "move %TARGET_PATH%\\hello_win_kernel.sys bin\\hello_win_kernel.sys"
]

[tasks.cleanup]
script = [
  "rmdir /s /q bin",
  "cargo clean"
]

Cree, cambie el nombre, firme e implemente:

cargo make deploy

Limpiar todo:

cargo make cleanup

Sólo firmar:

cargo make sign-driver

Prueba en una máquina virtual Windows

Asegúrese de que la firma de prueba y la depuración del kernel estén habilitadas (y reinicie si cambió la configuración):

bcdedit -set TESTSIGNING ON
bcdedit /debug on

Copie a la VM:

  • bin/hello_win_kernel.sys
  • bin/hello_win_kernel_cert.cer
  • Sistemas internos DebugView.exe

En vista de depuración:

  • Habilitar Capturar
  • comprobar Capturar núcleo
  • Habilitar Salida detallada del kernel

dbgview.png Res.gif Registre el servicio de conductor:

sc create hello_win_kernel binPath= "FullPath\hello_win_kernel.sys" type= kernel start= demand

Empiece:

sc start hello_win_kernel

Si todo es correcto, DebugView mostrará:

[hello_win_kernel.sys] Hello, world!

sc_start.png

Comparación de C++ (hola mundo, conductor)

Como referencia, aquí está la entrada del controlador equivalente mínimo en C++:

#include <wdm.h>

extern "C" {
    DRIVER_INITIALIZE DriverEntry;
}

#ifdef ALLOC_PRAGMA
#pragma alloc_text(INIT, DriverEntry)
#endif

_Use_decl_annotations_
NTSTATUS DriverEntry([[maybe_unused]] PDRIVER_OBJECT DriverObject,
                     [[maybe_unused]] PUNICODE_STRING RegistryPath)
{
    DbgPrint("[hello-win-kernel-cpp.sys] Hello, World!\n");
    return STATUS_SUCCESS;
}

Resumen

Ha creado un controlador de kernel Windows mínimo en Rust: configurado todas las noches, vinculado a bibliotecas WDK, implementado un no_std punto de entrada y salida del kernel validada a través de DebugView. Rust puede parecer más “manual” que C/C++ en este espacio hoy en día, pero ofrece poderosas herramientas de seguridad a nivel de lenguaje que valen el costo de instalación.

A partir de aquí, los próximos pasos más productivos son primitivas de controlador legítimas:

  • crear un objeto de dispositivo y un enlace simbólico
  • implementar rutinas de despacho IRP
  • comunicación IOCTL
  • envoltorios seguros alrededor del kernel APIs
  • registro y patrones estructurados de manejo de errores para no_std

Referencias

  1. Scripts de construcción de carga: https://doc.rust-lang.org/cargo/reference/build-scripts.html
  2. Opciones del vinculador MSVC: https://learn.microsoft.com/cpp/build/reference/linker-options?view=msvc-170
  3. Descarga de WDK: https://learn.microsoft.com/windows-hardware/drivers/download-the-wdk
  4. Suite Sysinternals: https://learn.microsoft.com/sysinternals/downloads/sysinternals-suite
Volver a blogs

Contacto

Iniciar la conversación

Bastan unas pocas líneas claras. Cuéntanos qué sistema es, qué presión hay y qué decisión está bloqueada. O escribe directamente a midgard@stofu.io.

0 / 10000
Ningún archivo seleccionado