Introduktion till Windows Kernel Drivrutinsutveckling i Rust
Innehåll
- Introduktion
- Beroenden
- Utveckling
- Konfiguration
- Genomförande
- Implementering och testning
- Sammanfattning
- Referenser
Introduktion
Hej! Kul att du är här. I det här inlägget bygger vi en liten Windows kärndrivrutin med hjälp av Rust. Ja, den där Rust. Trendigt, högljutt och faktiskt användbart.
Den här artikeln förblir på den säkra, grundläggande sidan: installation av verktygskedja, länkning mot WDK, no_std, en minimal ingångspunkt för drivrutinen och kärnfelsökningsutgång via DbgPrint. Härifrån kan du gå vidare till legitima nästa steg som IOCTL-hantering, enhetsobjekt, IRP-utskickningsrutiner och riktig drivrutinsarkitektur.
Om du inte känner till Rust än, kommer du fortfarande att klara dig: Jag visar också ett jämförbart C++-exempel. Allt du behöver är tid, erfarenhet av C/C++ och grundläggande förståelse för utveckling av kärnläge.
Varför Rust? Eftersom den kan leverera prestanda nära C/C++ samtidigt som den ger starka minnessäkerhetsgarantier på språknivå. Många stora organisationer investerar i minnessäker kod och Rust i synnerhet, och ekosystemet Rust levereras snabbt med stabila utsläpp var ~6:e vecka och en separat nattlig kanal.
⚠️ Etik & säkerhetsanvisningKärndrivrutiner kör med extrema privilegier. Använd dessa tekniker endast för lärande, forskning och legitim utveckling.
Beroenden
För att följa med (eller kopiera/klistra in), installera:
- 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
Du vill också ha en virtuell dator (VMWare, Hyper-V, VirtualBox, QEMU) med Windows 10 x64 or Windows 11, testsignering aktiverad, och kärnfelsökning aktiverad.
Aktivera testläge och kärnfelsökning och starta sedan om:
⚠️ Kör terminalen som administratör
# Enable Test Signing mode
bcdedit -set TESTSIGNING ON
# Enable kernel debugging
bcdedit /debug on
Utveckling
Konfiguration
Skapa ett nytt Rust biblioteksprojekt:
cargo new hello-win-kernel --lib
Projektets struktur:
hello-win-kernel/
src/lib.rs
.gitignore
Cargo.toml
I Rust, main.rs är ingångspunkten för binärer, och lib.rs är ingångspunkten för bibliotek. Vi bygger en drivrutin som en dynamisk biblioteksartefakt.
Redigera Cargo.toml:
- Lägg till en
[lib]sektion och setcrate-type = ["cdylib"]så Rust producerar ett C-kompatibelt dynamiskt bibliotek. - Ställ in
panic = "abort"för både felsöknings- och släppprofiler för att undvika avvecklingsbeteende. - Lägg till
winregsom en bygga ett beroende för att läsa WDK/Windows Kitsvägar från registret ibuild.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"
Skapa en rust-toolchain fil i projektroten för att tvinga fram nattlig (vi behöver flaggor endast nattliga under länkning):
rust-toolchain
nightly
Lägg till ett byggskript för att hitta WDK-bibliotek
För att bygga en drivrutin måste vi länka mot vissa WDK-bibliotek (t.ex. ntoskrnl). Vi lägger till bibliotekssökvägar vid byggtid via build.rs.
Skapa 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()
);
}
Länkkonfiguration för en drivrutinsbyggnad
Skapa en .cargo mapp och lägg till en konfigurationsfil. Laststöd config.toml (föredraget) och äldre 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",
]
Genomförande
Rust skickar inte ett användbart standardbibliotek i kärnläge, så vi inaktiverar det med #![no_std]. Vi implementerar också en anpassad panikhanterare och tillhandahåller ett par symboler för att tillfredsställa MSVC-länken i denna minimala inställning.
Skapa 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
}
Lägg till grundläggande Windows typalias:
src/types.rs
pub type NTSTATUS = u32;
pub type PCSTR = *const u8;
pub type PVOID = *mut core::ffi::c_void;
Lägg till en minimal NTSTATUS konstant:
src/ntstatus.rs
use crate::types::*;
pub const STATUS_SUCCESS: NTSTATUS = 0x00000000;
Felsökning av kärnan med DbgPrint
Nu ska vi importera DbgPrint from ntoskrnl och slå in det med ett litet makro så att vi inte glömmer nollterminatorn.
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)*) => {};
}
Vid det här laget kan du bygga framgångsrikt. Därefter kommer vi att automatisera namnbyte/signering och testladdning.
Implementering och testning
För att testa en drivrutin i en virtuell dator behöver du vanligtvis:
- Bygg
.dllartifact - Byt namn på den till
.sys - Signera det (testcertifikat räcker för testläge)
- Ladda den som en tjänst och verifiera utdata
Vi kommer att automatisera dessa steg med cargo-make.
Installera det:
cargo install cargo-make
Konfigurera Windows SDK verktygssökväg
Skapa en systemmiljövariabel med namnet WIN_SDK_TOOLS pekar på din Windows SDK verktygsmapp.
Steg:
- Öppna Visa avancerade systeminställningar
- Gå till Avancerat tab
- Klicka Miljövariabler
- Under Systemvariabler, klicka Nytt
- Namnge det
WIN_SDK_TOOLS - Ställ in värdet på verktygssökvägen Windows SDK
- Klicka OK

Lägg till ett manus för lasttillverkning
Skapa makefile.toml i projektroten:
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"
]
Bygg, byt namn, signera och distribuera:
cargo make deploy
Rengör allt:
cargo make cleanup
Endast tecken:
cargo make sign-driver
Testa i en Windows virtuell dator
Se till att testsignering och kärnfelsökning är aktiverade (och starta om om du ändrade inställningarna):
bcdedit -set TESTSIGNING ON
bcdedit /debug on
Kopiera till VM:n:
bin/hello_win_kernel.sysbin/hello_win_kernel_cert.cer- Sysinternals
DebugView.exe
I DebugView:
- Aktivera Fånga
- Kontrollera Fånga kärnan
- Aktivera Utförlig kärnutdata
Registrera förartjänsten:
sc create hello_win_kernel binPath= "FullPath\hello_win_kernel.sys" type= kernel start= demand
Starta det:
sc start hello_win_kernel
Om allt är korrekt kommer DebugView att visa:
[hello_win_kernel.sys] Hello, world!

C++ jämförelse (hello world driver)
För referens, här är den minsta motsvarande drivrutinposten i 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;
}
Sammanfattning
Du har byggt en minimal Windows kärndrivrutin i Rust: konfigurerad varje natt, länkad mot WDK-bibliotek, implementerad en no_std ingångspunkt och validerad kärnutdata via DebugView. Rust kan kännas mer "manuell" än C/C++ i detta utrymme idag, men det erbjuder kraftfulla säkerhetsverktyg på språknivå som är värda installationskostnaden.
Härifrån är de mest produktiva nästa stegen legitima förarprimitiver:
- skapa ett enhetsobjekt och en symbolisk länk
- implementera IRP-rutiner
- IOCTL kommunikation
- säkra omslag runt kärnan APIs
- loggning och strukturerade felhanteringsmönster för
no_std
Referenser
- Lastbyggnadsskript: https://doc.rust-lang.org/cargo/reference/build-scripts.html
- MSVC länkalternativ: https://learn.microsoft.com/cpp/build/reference/linker-options?view=msvc-170
- WDK nedladdning: https://learn.microsoft.com/windows-hardware/drivers/download-the-wdk
- Sysinternals Suite: https://learn.microsoft.com/sysinternals/downloads/sysinternals-suite