Windows Kernel Dev på Rust. Intro.

Windows Kernel Dev på Rust. Intro.

Introduksjon til Windows Kernel Driverutvikling i Rust

Innhold

  • Introduksjon
  • Avhengigheter
  • Utvikling
    • Konfigurasjon
    • Implementering
  • Utplassering og testing
  • Sammendrag
  • Referanser

Introduksjon

Hei! Glad du er her. I dette innlegget bygger vi en liten Windows kjernedriver ved å bruke Rust. Ja, den Rust. Trendy, høyt og faktisk nyttig.

Denne artikkelen holder seg på den sikre, grunnleggende siden: verktøykjedeoppsett, kobling mot WDK, no_std, et minimalt driverinngangspunkt og kjernefeilsøkingsutgang via DbgPrint. Herfra kan du gå videre til legitime neste trinn som IOCTL-håndtering, enhetsobjekter, IRP-utsendelsesrutiner og ekte driverarkitektur.

Hvis du ikke kjenner Rust ennå, går det fortsatt bra: Jeg viser også et sammenlignbart C++-eksempel. Alt du trenger er tid, C/C++ erfaring og grunnleggende forståelse av kjernemodusutvikling.

Hvorfor Rust? Fordi den kan levere ytelse nær C/C++ samtidig som den gir sterke minnesikkerhetsgarantier på språknivå. Mange store organisasjoner investerer i minnesikker kode og Rust spesielt, og Rust-økosystemet sendes raskt med stabile utgivelser hver ~6 uke og en separat nattlig kanal.

⚠️ Etikk og sikkerhetsmerknadKjernedrivere kjører med ekstreme privilegier. Bruk disse teknikkene kun for læring, forskning og legitim utvikling.

Avhengigheter

For å følge med (eller kopiere/lime inn), installer:

Du vil også ha en VM (VMWare, Hyper-V, VirtualBox, QEMU) med Windows 10 x64 or Windows 11, testsignering aktivert, og kjernefeilsøking aktivert.

Aktiver testmodus og kjernefeilsøking, og start deretter på nytt:

⚠️ Kjør terminalen som administrator

# Enable Test Signing mode
bcdedit -set TESTSIGNING ON

# Enable kernel debugging
bcdedit /debug on

Utvikling

Konfigurasjon

Opprett et nytt Rust bibliotekprosjekt:

cargo new hello-win-kernel --lib

Prosjektstruktur:

hello-win-kernel/
  src/lib.rs
  .gitignore
  Cargo.toml

I Rust, main.rs er inngangspunktet for binærfiler, og lib.rs er inngangspunktet for bibliotekene. Vi bygger en driver som en dynamisk bibliotekartefakt.

Rediger Cargo.toml:

  • Legg til en [lib] seksjon og sett crate-type = ["cdylib"] så Rust produserer et C-kompatibelt dynamisk bibliotek.
  • Sett panic = "abort" for både feilsøkings- og utgivelsesprofiler for å unngå å slappe av.
  • Legg til winreg som en bygge avhengighet for å lese WDK/Windows Setter stier fra registeret i 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"

Lag en rust-toolchain fil i prosjektroten for å tvinge frem nattlig (vi trenger flagg kun nattlig under kobling):

rust-toolchain

nightly

Legg til et byggeskript for å finne WDK-biblioteker

For å bygge en driver må vi koble til noen WDK-biblioteker (f.eks. ntoskrnl). Vi legger til biblioteksøkestier ved byggetid via build.rs.

Opprett 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()
    );
}

Koblingskonfigurasjon for en driverbygging

Lag en .cargo mappe og legg til en konfigurasjonsfil. Lastestøtter config.toml (foretrukket) og eldre 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",
]

Implementering

Rust sender ikke et brukbart standardbibliotek i kjernemodus, så vi deaktiverer det med #![no_std]. Vi implementerer også en tilpasset panikkbehandler og gir et par symboler for å tilfredsstille MSVC-linkeren i dette minimale oppsettet.

Opprett 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
}

Legg til grunnleggende Windows typealiaser:

src/types.rs

pub type NTSTATUS = u32;
pub type PCSTR = *const u8;
pub type PVOID = *mut core::ffi::c_void;

Legg til en minimal NTSTATUS konstant:

src/ntstatus.rs

use crate::types::*;

pub const STATUS_SUCCESS: NTSTATUS = 0x00000000;

Kjernefeilsøkingsutgang med DbgPrint

Nå skal vi importere DbgPrint from ntoskrnl og pakk den inn med en liten makro slik at vi ikke glemmer nullterminatoren.

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)*) => {};
}

På dette tidspunktet kan du bygge vellykket. Deretter automatiserer vi omdøping/signering og testinnlasting.

Utplassering og testing

For å teste en driver i en VM, må du vanligvis:

  1. Bygg .dll artifact
  2. Gi det nytt navn til .sys
  3. Signer den (testsertifikat er nok for testmodus)
  4. Last den inn som en tjeneste og bekreft utdata

Vi automatiserer disse trinnene med cargo-make.

Installer det:

cargo install cargo-make

Konfigurer Windows SDK verktøybane

Opprett en systemmiljøvariabel kalt WIN_SDK_TOOLS peker på Windows SDK verktøymappen.

Trinn:

  1. Åpne Se avanserte systeminnstillinger
  2. Gå til Avansert tab
  3. Klikk Miljøvariabler
  4. Under Systemvariabler, klikk Nytt
  5. Gi det et navn WIN_SDK_TOOLS
  6. Sett verdien til Windows SDK verktøybanen
  7. Klikk OK

Env.gif

Legg til et lasteromsskript

Opprett makefile.toml i prosjektroten:

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, gi nytt navn, signer og distribuer:

cargo make deploy

Rengjør alt:

cargo make cleanup

Kun tegn:

cargo make sign-driver

Test i en Windows VM

Sørg for at testsignering og kjernefeilsøking er aktivert (og start på nytt hvis du endret innstillinger):

bcdedit -set TESTSIGNING ON
bcdedit /debug on

Kopier til VM:en:

  • bin/hello_win_kernel.sys
  • bin/hello_win_kernel_cert.cer
  • Sysinternals DebugView.exe

I DebugView:

  • Aktiver Fangst
  • Sjekk Fang kjernen
  • Aktiver Utførlig kjerneutgang

dbgview.png Res.gif Registrer sjåførtjenesten:

sc create hello_win_kernel binPath= "FullPath\hello_win_kernel.sys" type= kernel start= demand

Start det:

sc start hello_win_kernel

Hvis alt er riktig, vil DebugView vise:

[hello_win_kernel.sys] Hello, world!

sc_start.png

C++ sammenligning (hello world driver)

For referanse, her er minimum tilsvarende driveroppføring 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;
}

Sammendrag

Du har bygget en minimal Windows-kjernedriver i Rust: konfigurert nattlig, koblet mot WDK-biblioteker, implementert en no_std inngangspunkt og validert kjerneutgang via DebugView. Rust kan føles mer "manuell" enn C/C++ på dette området i dag, men det tilbyr kraftige sikkerhetsverktøy på språknivå som er verdt installasjonskostnadene.

Herfra er de mest produktive neste trinnene legitime sjåførprimitiver:

  • opprette et enhetsobjekt og symbolsk lenke
  • implementere IRP-utsendelsesrutiner
  • IOCTL-kommunikasjon
  • trygge omslag rundt kjernen APIs
  • logging og strukturerte feilhåndteringsmønstre for no_std

Referanser

  1. Lastebyggingsskript: https://doc.rust-lang.org/cargo/reference/build-scripts.html
  2. Alternativer for MSVC-linker: https://learn.microsoft.com/cpp/build/reference/linker-options?view=msvc-170
  3. WDK nedlasting: https://learn.microsoft.com/windows-hardware/drivers/download-the-wdk
  4. Sysinternals Suite: https://learn.microsoft.com/sysinternals/downloads/sysinternals-suite
Tilbake til blogger

Kontakt

Start samtalen

Noen tydelige linjer er nok. Beskriv systemet, presset og beslutningen som står fast. Eller skriv direkte til midgard@stofu.io.

0 / 10000
Ingen fil er valgt