Introduzione allo sviluppo dei driver Windows Kernel in Rust
Contenuto
- Introduzione
- Dipendenze
- Sviluppo
- Configurazione
- Attuazione
- Distribuzione e test
- Riepilogo
- Riferimenti
Introduzione
Ciao! Sono contento che tu sia qui. In questo post creeremo un piccolo driver del kernel Windows utilizzando Rust. Sì, quello Rust. Alla moda, rumoroso e davvero utile.
Questo articolo rimane sul lato sicuro e fondamentale: configurazione della toolchain, collegamento al WDK, no_std, un punto di ingresso minimo del driver e output di debug del kernel tramite DbgPrint. Da qui puoi passare IA passaggi successivi legittimi come la gestione IOCTL, gli oggetti del dispositivo, le routine di invio IRP e l'architettura dei driver reali.
Se non conosci ancora Rust, starai comunque bene: mostrerò anche un esempio C++ comparabile. Tutto ciò di cui hai bisogno è tempo, esperienza in C/C++ e una conoscenza di base dello sviluppo in modalità kernel.
Perché Rust? Perché può fornire prestazioni vicine al C/C++ fornendo allo stesso tempo forti garanzie di sicurezza della memoria a livello di linguaggio. Molte grandi organizzazioni stanno investendo in codice memory-safe e in Rust in particolare, e l'ecosistema Rust viene distribuito rapidamente con rilasci stabili ogni circa 6 settimane e un canale notturno separato.
⚠️ Nota su etica e sicurezzaI driver del kernel vengono eseguiti con privilegi estremi. Utilizzare queste tecniche solo per l'apprendimento, la ricerca e lo sviluppo legittimo.
Dipendenze
Per seguire (o copiare/incollare), installare:
- Rust: https://www.rust-lang.org/tools/install
- Windows SDK: https://developer.microsoft.com/windows/downloads/windows-sdk/
- Windows WDK: https://learn.microsoft.com/windows-hardware/drivers/download-the-wdk
- Suite Sysinternals (DebugView): https://learn.microsoft.com/sysinternals/downloads/sysinternals-suite
Avrai bisogno anche di una VM (VMWare, Hyper-V, VirtualBox, QEMU). Windows 10x64 or Windows 11, firma di prova abilitatae il debug del kernel è abilitato.
Abilita la modalità test e il debug del kernel, quindi riavvia:
⚠️ Esegui il terminale come amministratore
# Enable Test Signing mode
bcdedit -set TESTSIGNING ON
# Enable kernel debugging
bcdedit /debug on
Sviluppo
Configurazione
Crea un nuovo progetto di libreria Rust:
cargo new hello-win-kernel --lib
Struttura del progetto:
hello-win-kernel/
src/lib.rs
.gitignore
Cargo.toml
In Rust, main.rs è il punto di ingresso per i file binari e lib.rs è il punto di ingresso per le biblioteche. Costruiremo un driver come artefatto di libreria dinamica.
Modifica Cargo.toml:
- Aggiungi un
[lib]sezione e insiemecrate-type = ["cdylib"]quindi Rust produce una libreria dinamica compatibile con C. - Impostato
panic = "abort"sia per i profili di debug che per quelli di rilascio per evitare comportamenti di rimozione. - Aggiungi
winregcome a creare dipendenza per leggere i percorsi dei kit WDK/Windows dal registro inbuild.rs.
Carico.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"
Crea un rust-toolchain file nella root del progetto per forzare la notte (abbiamo bisogno di flag solo notturni durante il collegamento):
rust-toolchain
nightly
Aggiungi uno script di build per individuare le librerie WDK
Per creare un driver, dobbiamo collegarci ad alcune librerie WDK (ad esempio, ntoskrnl). Aggiungeremo percorsi di ricerca della libreria in fase di creazione tramite build.rs.
Crea build.rs:
build.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()
);
}
Configurazione del linker per una build di driver
Crea un .cargo cartella e aggiungi un file di configurazione. Supporti per il carico config.toml (preferito) e più vecchi config.
.cargo/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",
]
Attuazione
Rust non fornisce una libreria standard utilizzabile in modalità kernel, quindi la disabilitiamo con #![no_std]. Implementiamo anche un gestore di panico personalizzato e forniamo un paio di simboli per soddisfare il linker MSVC in questa configurazione minima.
Crea 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
}
Aggiungi alias di tipo Windows di base:
src/types.rs
pub type NTSTATUS = u32;
pub type PCSTR = *const u8;
pub type PVOID = *mut core::ffi::c_void;
Aggiungi una costante NTSTATUS minima:
src/ntstatus.rs
use crate::types::*;
pub const STATUS_SUCCESS: NTSTATUS = 0x00000000;
Output di debug del kernel con DbgPrint
Ora importeremo DbgPrint from ntoskrnl e avvolgilo con una piccola macro in modo da non dimenticare il terminatore null.
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)*) => {};
}
A questo punto puoi costruire con successo. Successivamente automatizzeremo la ridenominazione/firma e testeremo il caricamento.
Distribuzione e test
Per testare un driver in una VM, in genere è necessario:
- Costruisci il
.dllartifact - Rinominarlo in
.sys - Firmalo (per la modalità test è sufficiente il certificato di prova)
- Caricalo come servizio e verifica l'output
Automatizzeremo questi passaggi con cargo-make.
Installalo:
cargo install cargo-make
Configurare il percorso degli strumenti Windows SDK.
Crea una variabile di ambiente di sistema denominata WIN_SDK_TOOLS che punta alla cartella degli strumenti Windows SDK.
Passaggi:
- Aperto Visualizza le impostazioni avanzate del sistema
- Vai a Avanzato tab
- Fare clic Variabili d'ambiente
- Sotto Variabili di sistema, fare clic Nuovo
- Nominalo
WIN_SDK_TOOLS - Impostare il valore sul percorso degli strumenti Windows SDK.
- Fare clic OK

Aggiungi uno script per la creazione del carico
Crea makefile.toml nella radice del progetto:
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"
]
Crea, rinomina, firma e distribuisci:
cargo make deploy
Pulisci tutto:
cargo make cleanup
Solo firmare:
cargo make sign-driver
Prova in una VM Windows.
Assicurati che la firma del test e il debug del kernel siano abilitati (e riavvia se hai modificato le impostazioni):
bcdedit -set TESTSIGNING ON
bcdedit /debug on
Copia sulla VM:
bin/hello_win_kernel.sysbin/hello_win_kernel_cert.cer- Sysinternals
DebugView.exe
Nella visualizzazione debug:
- Abilita Cattura
- Controlla Cattura il kernel
- Abilita Output del kernel dettagliato
Registra il servizio autista:
sc create hello_win_kernel binPath= "FullPath\hello_win_kernel.sys" type= kernel start= demand
Inizialo:
sc start hello_win_kernel
Se tutto è corretto, DebugView mostrerà:
[hello_win_kernel.sys] Hello, world!

Confronto C++ (ciao driver mondiale)
Per riferimento, ecco la voce del driver equivalente minimo in 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;
}
Riepilogo
Hai creato un driver del kernel Windows minimo in Rust: configurato di notte, collegato alle librerie WDK, implementato un no_std punto di ingresso e output del kernel convalidato tramite DebugView. Rust può sembrare più "manuale" di C/C++ in questo ambito oggi, ma offre potenti strumenti di sicurezza a livello di linguaggio che valgono il costo di installazione.
Da qui, i passi successivi più produttivi sono primitive dei driver legittimi:
- creando un oggetto dispositivo e un collegamento simbolico
- implementazione delle routine di invio IRP
- Comunicazione IOCTL
- wrapper sicuri attorno al kernel APIs
- modelli di registrazione e gestione strutturata degli errori per
no_std
Riferimenti
- Script di costruzione del carico: https://doc.rust-lang.org/cargo/reference/build-scripts.html
- Opzioni del linker MSVC: https://learn.microsoft.com/cpp/build/reference/linker-options?view=msvc-170
- Scarica WDK: https://learn.microsoft.com/windows-hardware/drivers/download-the-wdk
- Suite Sysinternals: https://learn.microsoft.com/sysinternals/downloads/sysinternals-suite