Inleiding tot Windows Kernel Ontwikkeling van stuurprogramma's in Rust
Inhoud
- Invoering
- Afhankelijkheden
- Ontwikkeling
- Configuratie
- Implementatie
- Implementatie en testen
- Samenvatting
- Referenties
Invoering
Hallo! Fijn dat je er bent. In dit bericht zullen we een klein Windows kernelstuurprogramma bouwen met behulp van Rust. Ja, dat Rust. Trendy, luid en eigenlijk nuttig.
Dit artikel blijft aan de veilige, fundamentele kant: toolchain-setup, koppeling met de WDK, no_std, een minimaal ingangspunt voor het stuurprogramma en uitvoer voor kernelfoutopsporing via DbgPrint. Vanaf hier kunt u doorgaan met legitieme volgende stappen, zoals IOCTL-afhandeling, apparaatobjecten, IRP-verzendingsroutines en echte driverarchitectuur.
Als je Rust nog niet kent, komt alles goed: ik zal ook een vergelijkbaar C++ voorbeeld laten zien. Het enige wat je nodig hebt is tijd, C/C++-ervaring en basiskennis van ontwikkeling in de kernelmodus.
Waarom Rust? Omdat het prestaties kan leveren die dicht bij C/C++ liggen en tegelijkertijd sterke geheugenveiligheidsgaranties biedt op taalniveau. Veel grote organisaties investeren in geheugenveilige code en Rust in het bijzonder, en het Rust-ecosysteem wordt snel verzonden met stabiele releases elke ~6 weken en een apart nachtelijk kanaal.
⚠️ Ethiek en veiligheidsnotaKernelstuurprogramma's werken met extreme privileges. Gebruik deze technieken alleen voor leren, onderzoek en legitieme ontwikkeling.
Afhankelijkheden
Om mee te volgen (of om te kopiëren/plakken), installeert u:
- 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
- Sysinternals-suite (DebugView): https://learn.microsoft.com/sysinternals/downloads/sysinternals-suite
Je hebt ook een VM (VMWare, Hyper-V, VirtualBox, QEMU) nodig Windows 10 x64 or Windows 11, testondertekening ingeschakelden kernel-foutopsporing ingeschakeld.
Schakel de testmodus en kernelfoutopsporing in en start vervolgens opnieuw op:
⚠️ Voer de terminal uit als beheerder
# Enable Test Signing mode
bcdedit -set TESTSIGNING ON
# Enable kernel debugging
bcdedit /debug on
Ontwikkeling
Configuratie
Maak een nieuw Rust bibliotheekproject:
cargo new hello-win-kernel --lib
Projectstructuur:
hello-win-kernel/
src/lib.rs
.gitignore
Cargo.toml
In Rust, main.rs is het toegangspunt voor binaire bestanden, en lib.rs is het toegangspunt voor bibliotheken. We bouwen een driver als een dynamisch bibliotheekartefact.
Bewerken Cargo.toml:
- Voeg een toe
[lib]sectie en instellencrate-type = ["cdylib"]dus Rust produceert een C-compatibele dynamische bibliotheek. - Instellen
panic = "abort"voor zowel debug- als releaseprofielen om afwikkelgedrag te voorkomen. - Toevoegen
winregals een afhankelijkheid opbouwen voor het lezen van WDK/Windows Kits-paden vanuit het register inbuild.rs.
Cargo.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"
Maak een rust-toolchain bestand in de hoofdmap van het project om nightly te forceren (we hebben alleen-nightly-vlaggen nodig tijdens het koppelen):
rust-toolchain
nightly
Voeg een buildscript toe om WDK-bibliotheken te vinden
Om een stuurprogramma te bouwen, moeten we een koppeling maken met een aantal WDK-bibliotheken (bijvoorbeeld ntoskrnl). We voegen tijdens het bouwen bibliotheekzoekpaden toe via build.rs.
Creëer build.rs:
bouw.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()
);
}
Linkerconfiguratie voor een driverbuild
Maak een .cargo map en voeg een configuratiebestand toe. Ladingsteunen config.toml (bij voorkeur) en ouder 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",
]
Implementatie
Rust levert geen bruikbare standaardbibliotheek in kernelmodus, dus schakelen we deze uit met #![no_std]. We implementeren ook een aangepaste paniekhandler en bieden een aantal symbolen om aan de MSVC-linker te voldoen in deze minimale opstelling.
Creëer 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
}
Voeg standaard aliassen van het type Windows toe:
src/types.rs
pub type NTSTATUS = u32;
pub type PCSTR = *const u8;
pub type PVOID = *mut core::ffi::c_void;
Voeg een minimale NTSTATUS-constante toe:
src/ntstatus.rs
use crate::types::*;
pub const STATUS_SUCCESS: NTSTATUS = 0x00000000;
Kernel debug-uitvoer met DbgPrint
Nu gaan we importeren DbgPrint from ntoskrnl en wikkel het met een kleine macro, zodat we de nulterminator niet vergeten.
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)*) => {};
}
Op dit punt kunt u met succes bouwen. Vervolgens automatiseren we het hernoemen/ondertekenen en het testen van het laden.
Implementatie en testen
Als u een stuurprogramma in een VM wilt testen, moet u doorgaans het volgende doen:
- Bouw de
.dllartifact - Hernoem het naar
.sys - Onderteken het (testcertificaat is voldoende voor testmodus)
- Laad het als een service en verifieer de uitvoer
We automatiseren deze stappen met cargo-make.
Installeer het:
cargo install cargo-make
Configureer het gereedschapspad Windows SDK.
Maak een systeemomgevingsvariabele met de naam WIN_SDK_TOOLS wijzend naar de map Windows SDK tools.
Stappen:
- Openen Bekijk geavanceerde systeeminstellingen
- Ga naar Geavanceerd tab
- Klik Omgevingsvariabelen
- Onder Systeemvariabelen, klik Nieuw
- Noem het
WIN_SDK_TOOLS - Stel de waarde in op het gereedschapspad Windows SDK.
- Klik OK

Voeg een cargo-make-script toe
Creëer makefile.toml in de projectroot:
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"
]
Bouwen, hernoemen, ondertekenen en implementeren:
cargo make deploy
Maak alles schoon:
cargo make cleanup
Alleen ondertekenen:
cargo make sign-driver
Test in een Windows VM
Zorg ervoor dat testondertekening en kernelfoutopsporing zijn ingeschakeld (en start opnieuw op als u de instellingen hebt gewijzigd):
bcdedit -set TESTSIGNING ON
bcdedit /debug on
Kopiëren naar de VM:
bin/hello_win_kernel.sysbin/hello_win_kernel_cert.cer- Sysinternals
DebugView.exe
In DebugView:
- Inschakelen Vastleggen
- Controleer Kernel vastleggen
- Inschakelen Uitgebreide kerneluitvoer
Registreer de chauffeursservice:
sc create hello_win_kernel binPath= "FullPath\hello_win_kernel.sys" type= kernel start= demand
Begin ermee:
sc start hello_win_kernel
Als alles correct is, toont DebugView:
[hello_win_kernel.sys] Hello, world!

C++ vergelijking (hallo wereldbestuurder)
Ter referentie: hier is de minimale equivalente driverinvoer 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;
}
Samenvatting
Je hebt een minimale Windows kerneldriver gebouwd in Rust: elke nacht geconfigureerd, gekoppeld aan WDK-bibliotheken, een no_std toegangspunt en gevalideerde kerneluitvoer via DebugView. Rust kan op dit gebied vandaag de dag meer “handmatig” aanvoelen dan C/C++, maar het biedt krachtige veiligheidstools op taalniveau die de instelkosten waard zijn.
Vanaf hier volgen de meest productieve volgende stappen legitieme stuurprogramma-primitieven:
- het maken van een apparaatobject en een symbolische link
- IRP-verzendingsroutines implementeren
- IOCTL-communicatie
- veilige wrappers rond de kernel APIs
- logboekregistratie en gestructureerde foutafhandelingspatronen voor
no_std
Referenties
- Cargo-build-scripts: https://doc.rust-lang.org/cargo/reference/build-scripts.html
- MSVC-linkeropties: https://learn.microsoft.com/cpp/build/reference/linker-options?view=msvc-170
- WDK-download: https://learn.microsoft.com/windows-hardware/drivers/download-the-wdk
- Sysinternals-suite: https://learn.microsoft.com/sysinternals/downloads/sysinternals-suite