Windows Kernel Entwickler auf Rust. Einführung.

Windows Kernel Entwickler auf Rust. Einführung.

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:

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 Satz crate-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 winreg als Abhängigkeit aufbauen zum Lesen von WDK/Windows Kits-Pfaden aus der Registrierung in build.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:

  1. Bauen Sie die .dll artifact
  2. Benennen Sie es um in .sys
  3. Unterschreiben Sie es (Testzertifikat reicht für den Testmodus)
  4. 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:

  1. Offen Erweiterte Systemeinstellungen anzeigen
  2. Gehe zu Fortgeschritten tab
  3. Klicken Sie Umgebungsvariablen
  4. Unter Systemvariablen, klicken Neu
  5. Nennen Sie es WIN_SDK_TOOLS
  6. Legen Sie den Wert auf den Werkzeugpfad Windows SDK fest
  7. Klicken Sie OK

Env.gif

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.sys
  • bin/hello_win_kernel_cert.cer
  • Sysinternals DebugView.exe

In DebugView:

  • Aktivieren Erfassen
  • Überprüfen Kernel erfassen
  • Aktivieren Ausführliche Kernel-Ausgabe

dbgview.png Res.gif 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!

sc_start.png

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

  1. Cargo-Build-Skripte: https://doc.rust-lang.org/cargo/reference/build-scripts.html
  2. MSVC-Linker-Optionen: https://learn.microsoft.com/cpp/build/reference/linker-options?view=msvc-170
  3. WDK-Download: https://learn.microsoft.com/windows-hardware/drivers/download-the-wdk
  4. Sysinternals-Suite: https://learn.microsoft.com/sysinternals/downloads/sysinternals-suite
Zurück zu Blogs

Kontakt

Gespräch starten

Ein paar klare Zeilen reichen. Beschreiben Sie das System, den Druck und die Entscheidung, die feststeckt. Oder schreiben Sie direkt an midgard@stofu.io.

0 / 10000
Keine Datei ausgewählt