Einführung in die Treiberentwicklung von Windows Kernel in Rust
Inhalt
- Einführung
- Abhängigkeiten
- Entwicklung
- Konfiguration
- Umsetzung
- Bereitstellung und Test
- Zusammenfassung
- Referenzen
Einführung
Hallo! Schön, dass du hier bist. In diesem Beitrag erstellen wir einen winzigen Windows-Kernel-Treiber mit Rust. Ja, das Rust. Trendig, laut und tatsächlich nützlich.
Dieser Artikel bleibt auf der sicheren, grundlegenden Seite: Toolchain-Einrichtung, Verknüpfung mit dem WDK, no_std, ein minimaler Treiber-Einstiegspunkt und Kernel-Debug-Ausgabe über DbgPrint. Von hier aus können Sie mit legitimen nächsten Schritten wie der IOCTL-Verarbeitung, Geräteobjekten, IRP-Versandroutinen und der echten Treiberarchitektur fortfahren.
Wer Rust noch nicht kennt, ist trotzdem gut aufgehoben: Ich zeige auch ein vergleichbares C++-Beispiel. Sie benötigen lediglich Zeit, C/C++-Erfahrung und grundlegende Kenntnisse der Kernel-Modus-Entwicklung.
Warum Rust? Weil es eine Leistung liefern kann, die der von C/C++ nahe kommt, und gleichzeitig starke Garantien für die Speichersicherheit auf Sprachebene bietet. Viele große Organisationen investieren in speichersicheren Code und insbesondere in Rust, und das Rust-Ökosystem wird schnell mit stabilen Veröffentlichungen alle ca. 6 Wochen und einem separaten nächtlichen Kanal ausgeliefert.
⚠️ Ethik- und SicherheitshinweisKernel-Treiber laufen mit extremen Privilegien. Verwenden Sie diese Techniken nur zum Lernen, zur Forschung und zur legitimen Entwicklung.
Abhängigkeiten
Um mitzumachen (oder zu kopieren/einzufügen), installieren Sie:
- 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
Sie benötigen außerdem eine VM (VMWare, Hyper-V, VirtualBox, QEMU) mit Windows 10 x64 or Windows 11, Testsignierung aktiviertund Kernel-Debugging aktiviert.
Aktivieren Sie den Testmodus und das Kernel-Debugging und starten Sie dann neu:
⚠️ Führen Sie das Terminal als Administrator aus
# Enable Test Signing mode
bcdedit -set TESTSIGNING ON
# Enable kernel debugging
bcdedit /debug on
Entwicklung
Konfiguration
Erstellen Sie ein neues Rust-Bibliotheksprojekt:
cargo new hello-win-kernel --lib
Projektstruktur:
hello-win-kernel/
src/lib.rs
.gitignore
Cargo.toml
In Rust, main.rs ist der Einstiegspunkt für Binärdateien und lib.rs ist der Einstiegspunkt für Bibliotheken. Wir erstellen einen Treiber als dynamisches Bibliotheksartefakt.
Bearbeiten Cargo.toml:
- Fügen Sie ein hinzu
[lib]Abschnitt und Satzcrate-type = ["cdylib"]Daher erstellt Rust eine C-kompatible dynamische Bibliothek. - Set
panic = "abort"für Debug- und Release-Profile, um Abwickelverhalten zu vermeiden. - Hinzufügen
winregals Abhängigkeit aufbauen zum Lesen von WDK/Windows Kits-Pfaden aus der Registrierung 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"
Erstellen Sie eine rust-toolchain Datei im Projektstammverzeichnis, um Nightly zu erzwingen (wir benötigen beim Verknüpfen nur Nightly-Flags):
rust-toolchain
nightly
Fügen Sie ein Build-Skript hinzu, um WDK-Bibliotheken zu finden
Um einen Treiber zu erstellen, müssen wir eine Verknüpfung mit einigen WDK-Bibliotheken herstellen (z. B. ntoskrnl). Wir werden Bibliothekssuchpfade zur Erstellungszeit hinzufügen über build.rs.
Erstellen 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()
);
}
Linker-Konfiguration für einen Treiber-Build
Erstellen Sie eine .cargo Ordner und fügen Sie eine Konfigurationsdatei hinzu. Frachtstützen config.toml (bevorzugt) und älter 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",
]
Umsetzung
Rust liefert keine verwendbare Standardbibliothek im Kernel-Modus, daher deaktivieren wir sie mit #![no_std]. Wir implementieren außerdem einen benutzerdefinierten Panic-Handler und stellen einige Symbole bereit, um den MSVC-Linker in diesem minimalen Setup zu erfüllen.
Erstellen 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
}
Fügen Sie grundlegende Aliase vom Typ Windows hinzu:
src/types.rs
pub type NTSTATUS = u32;
pub type PCSTR = *const u8;
pub type PVOID = *mut core::ffi::c_void;
Fügen Sie eine minimale NTSTATUS-Konstante hinzu:
src/ntstatus.rs
use crate::types::*;
pub const STATUS_SUCCESS: NTSTATUS = 0x00000000;
Kernel-Debug-Ausgabe mit DbgPrint
Jetzt importieren wir DbgPrint from ntoskrnl und umschließen Sie es mit einem kleinen Makro, damit wir den Nullterminator nicht vergessen.
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)*) => {};
}
An diesem Punkt können Sie erfolgreich bauen. Als Nächstes automatisieren wir das Umbenennen/Signieren und das Testladen.
Bereitstellung und Test
Um einen Treiber in einer VM zu testen, müssen Sie normalerweise Folgendes tun:
- Bauen Sie die
.dllartifact - Benennen Sie es um in
.sys - Unterschreiben Sie es (Testzertifikat reicht für den Testmodus)
- Laden Sie es als Dienst und überprüfen Sie die Ausgabe
Wir automatisieren diese Schritte mit cargo-make.
Installieren Sie es:
cargo install cargo-make
Konfigurieren Sie den Werkzeugpfad Windows SDK.
Erstellen Sie eine Systemumgebungsvariable mit dem Namen WIN_SDK_TOOLS Verweisen Sie auf Ihren Tools-Ordner Windows SDK.
Schritte:
- Offen Erweiterte Systemeinstellungen anzeigen
- Gehe zu Fortgeschritten tab
- Klicken Sie Umgebungsvariablen
- Unter Systemvariablen, klicken Neu
- Nennen Sie es
WIN_SDK_TOOLS - Legen Sie den Wert auf den Werkzeugpfad Windows SDK fest
- Klicken Sie OK

Fügen Sie ein Cargo-Make-Skript hinzu
Erstellen makefile.toml im Projektstamm:
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"
]
Erstellen, umbenennen, signieren und bereitstellen:
cargo make deploy
Alles reinigen:
cargo make cleanup
Nur unterschreiben:
cargo make sign-driver
Testen Sie in einer Windows-VM
Stellen Sie sicher, dass Testsignierung und Kernel-Debugging aktiviert sind (und starten Sie neu, wenn Sie Einstellungen geändert haben):
bcdedit -set TESTSIGNING ON
bcdedit /debug on
Auf die VM kopieren:
bin/hello_win_kernel.sysbin/hello_win_kernel_cert.cer- Sysinternals
DebugView.exe
In DebugView:
- Aktivieren Erfassen
- Überprüfen Kernel erfassen
- Aktivieren Ausführliche Kernel-Ausgabe
Registrieren Sie den Fahrerdienst:
sc create hello_win_kernel binPath= "FullPath\hello_win_kernel.sys" type= kernel start= demand
Starten Sie es:
sc start hello_win_kernel
Wenn alles korrekt ist, zeigt DebugView Folgendes an:
[hello_win_kernel.sys] Hello, world!

C++-Vergleich (Hallo Weltfahrer)
Als Referenz finden Sie hier den minimalen äquivalenten Treibereintrag 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;
}
Zusammenfassung
Sie haben einen minimalen Windows-Kerneltreiber in Rust erstellt: nächtlich konfiguriert, mit WDK-Bibliotheken verknüpft, implementiert a no_std Einstiegspunkt und validierte Kernel-Ausgabe über DebugView. Rust kann sich in diesem Bereich heutzutage „manueller“ anfühlen als C/C++, bietet aber leistungsstarke Sicherheitstools auf Sprachebene, die die Einrichtungskosten wert sind.
Von hier aus sind die produktivsten nächsten Schritte legitime Treiberprimitive:
- Erstellen eines Geräteobjekts und einer symbolischen Verknüpfung
- Implementierung von IRP-Versandroutinen
- IOCTL-Kommunikation
- sichere Wrapper um den Kernel APIs
- Protokollierung und strukturierte Fehlerbehandlungsmuster für
no_std
Referenzen
- Cargo-Build-Skripte: https://doc.rust-lang.org/cargo/reference/build-scripts.html
- MSVC-Linker-Optionen: 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