Windows Kernel Dev på Rust. Intro.

Windows Kernel Dev på Rust. Intro.

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:

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 set crate-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 winreg som en bygga ett beroende för att läsa WDK/Windows Kitsvägar från registret 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"

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:

  1. Bygg .dll artifact
  2. Byt namn på den till .sys
  3. Signera det (testcertifikat räcker för testläge)
  4. 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:

  1. Öppna Visa avancerade systeminställningar
  2. Gå till Avancerat tab
  3. Klicka Miljövariabler
  4. Under Systemvariabler, klicka Nytt
  5. Namnge det WIN_SDK_TOOLS
  6. Ställ in värdet på verktygssökvägen Windows SDK
  7. Klicka OK

Env.gif

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

I DebugView:

  • Aktivera Fånga
  • Kontrollera Fånga kärnan
  • Aktivera Utförlig kärnutdata

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

sc_start.png

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

  1. Lastbyggnadsskript: https://doc.rust-lang.org/cargo/reference/build-scripts.html
  2. MSVC länkalternativ: https://learn.microsoft.com/cpp/build/reference/linker-options?view=msvc-170
  3. WDK nedladdning: https://learn.microsoft.com/windows-hardware/drivers/download-the-wdk
  4. Sysinternals Suite: https://learn.microsoft.com/sysinternals/downloads/sysinternals-suite
Tillbaka till bloggar

Kontakta

Starta konversationen

Några tydliga rader räcker. Beskriv systemet, pressen och beslutet som har fastnat. Eller skriv direkt till midgard@stofu.io.

0 / 10000
Ingen fil har valts