Windows Kernel Ontwikkelaar op Rust. Intro.

Windows Kernel Ontwikkelaar op Rust. Intro.

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:

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 instellen crate-type = ["cdylib"] dus Rust produceert een C-compatibele dynamische bibliotheek.
  • Instellen panic = "abort" voor zowel debug- als releaseprofielen om afwikkelgedrag te voorkomen.
  • Toevoegen winreg als een afhankelijkheid opbouwen voor het lezen van WDK/Windows Kits-paden vanuit het register 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"

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:

  1. Bouw de .dll artifact
  2. Hernoem het naar .sys
  3. Onderteken het (testcertificaat is voldoende voor testmodus)
  4. 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:

  1. Openen Bekijk geavanceerde systeeminstellingen
  2. Ga naar Geavanceerd tab
  3. Klik Omgevingsvariabelen
  4. Onder Systeemvariabelen, klik Nieuw
  5. Noem het WIN_SDK_TOOLS
  6. Stel de waarde in op het gereedschapspad Windows SDK.
  7. Klik OK

Env.gif

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

In DebugView:

  • Inschakelen Vastleggen
  • Controleer Kernel vastleggen
  • Inschakelen Uitgebreide kerneluitvoer

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

sc_start.png

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

  1. Cargo-build-scripts: https://doc.rust-lang.org/cargo/reference/build-scripts.html
  2. MSVC-linkeropties: 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
Terug naar Blogs

Contact

Begin het gesprek

Een paar heldere regels zijn genoeg. Beschrijf het systeem, de druk en de beslissing die vastzit. Of mail direct naar midgard@stofu.io.

0 / 10000
Geen bestand gekozen