Windows Kernel Développeur sur Rust. Introduction.

Windows Kernel Développeur sur Rust. Introduction.

Introduction au développement de pilotes Windows Kernel dans Rust

Contenu

  • Introduction
  • Dépendances
  • Développement
    • Configuration
    • Mise en œuvre
  • Déploiement et tests
  • Résumé
  • Références

Introduction

Salut ! Heureux que tu sois là. Dans cet article, nous allons créer un petit pilote de noyau Windows en utilisant Rust. Oui, ce Rust. Tendance, bruyant et réellement utile.

Cet article reste sur le côté sûr et fondamental : configuration de la chaîne d'outils, liaison avec le WDK, no_std, un point d'entrée minimal du pilote et une sortie de débogage du noyau via DbgPrint. À partir de là, vous pouvez passer aux étapes suivantes légitimes telles que la gestion IOCTL, les objets de périphérique, les routines de répartition IRP et l'architecture réelle des pilotes.

Si vous ne connaissez pas encore Rust, tout ira bien : je vais également montrer un exemple comparable de C++. Tout ce dont vous avez besoin est du temps, une expérience C/C++ et une compréhension de base du développement en mode noyau.

Pourquoi Rust ? Parce qu'il peut offrir des performances proches du C/C++ tout en offrant de fortes garanties de sécurité mémoire au niveau du langage. De nombreuses grandes organisations investissent dans du code sécurisé en mémoire et dans Rust en particulier, et l'écosystème Rust est livré rapidement avec des versions stables toutes les environ 6 semaines et un canal nocturne séparé.

⚠️ Note d'éthique et de sécuritéLes pilotes du noyau fonctionnent avec des privilèges extrêmes. Utilisez ces techniques uniquement à des fins d’apprentissage, de recherche et de développement légitime.

Dépendances

Pour suivre (ou copier/coller), installez :

Vous aurez également besoin d'une VM (VMWare, Hyper-V, VirtualBox, QEMU) avec Windows 10 x64 or Windows 11, signature de test activéeet le débogage du noyau est activé.

Activez le mode test et le débogage du noyau, puis redémarrez :

⚠️ Exécutez le terminal en tant qu'administrateur

# Enable Test Signing mode
bcdedit -set TESTSIGNING ON

# Enable kernel debugging
bcdedit /debug on

Développement

Configuration

Créez un nouveau projet de bibliothèque Rust :

cargo new hello-win-kernel --lib

Structure du projet :

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

Dans Rust, main.rs est le point d'entrée pour les binaires, et lib.rs est le point d'entrée des bibliothèques. Nous allons créer un pilote en tant qu'artefact de bibliothèque dynamique.

Modifier Cargo.toml:

  • Ajouter un [lib] section et ensemble crate-type = ["cdylib"] donc Rust produit une bibliothèque dynamique compatible C.
  • Ensemble panic = "abort" pour les profils de débogage et de publication afin d'éviter le comportement de déroulement.
  • Ajouter winreg comme un créer une dépendance pour lire les chemins des kits WDK/Windows à partir du registre dans 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"

Créer un rust-toolchain fichier à la racine du projet pour forcer la nuit (nous avons besoin d'indicateurs uniquement la nuit lors de la liaison) :

rust-toolchain

nightly

Ajouter un script de build pour localiser les bibliothèques WDK

Pour créer un pilote, nous devons établir un lien avec certaines bibliothèques WDK (par exemple, ntoskrnl). Nous ajouterons des chemins de recherche de bibliothèque au moment de la construction via build.rs.

Créer build.rs:

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

Configuration de l'éditeur de liens pour une version de pilote

Créer un .cargo dossier et ajoutez un fichier de configuration. Supports de chargement config.toml (de préférence) et plus 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",
]

Mise en œuvre

Rust ne fournit pas de bibliothèque standard utilisable en mode noyau, nous la désactivons donc avec #![no_std]. Nous implémentons également un gestionnaire de panique personnalisé et fournissons quelques symboles pour satisfaire l'éditeur de liens MSVC dans cette configuration minimale.

Cré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
}

Ajoutez des alias de type Windows de base :

src/types.rs

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

Ajoutez une constante NTSTATUS minimale :

src/ntstatus.rs

use crate::types::*;

pub const STATUS_SUCCESS: NTSTATUS = 0x00000000;

Sortie de débogage du noyau avec DbgPrint

Maintenant, nous allons importer DbgPrint from ntoskrnl et enveloppez-le avec une petite macro pour ne pas oublier le terminateur nul.

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

À ce stade, vous pouvez construire avec succès. Ensuite, nous automatiserons le renommage/la signature et le chargement des tests.

Déploiement et tests

Pour tester un pilote dans une VM, vous devez généralement :

  1. Construire le .dll artifact
  2. Renommez-le en .sys
  3. Signez-le (un certificat de test suffit pour le mode test)
  4. Chargez-le en tant que service et vérifiez la sortie

Nous automatiserons ces étapes avec cargo-make.

Installez-le :

cargo install cargo-make

Configurer le chemin des outils Windows SDK

Créez une variable d'environnement système nommée WIN_SDK_TOOLS pointant vers votre dossier d'outils Windows SDK.

Étapes :

  1. Ouvert Afficher les paramètres système avancés
  2. Aller à Avancé tab
  3. Cliquez Variables d'environnement
  4. Sous Variables système, cliquez Nouveau
  5. Nommez-le WIN_SDK_TOOLS
  6. Définissez la valeur sur le chemin des outils Windows SDK
  7. Cliquez OK

Env.gif

Ajouter un script cargo-make

Créer makefile.toml à la racine du projet :

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"
]

Créez, renommez, signez et déployez :

cargo make deploy

Nettoyez tout :

cargo make cleanup

Signer seulement :

cargo make sign-driver

Tester dans une VM Windows

Assurez-vous que la signature des tests et le débogage du noyau sont activés (et redémarrez si vous avez modifié les paramètres) :

bcdedit -set TESTSIGNING ON
bcdedit /debug on

Copier sur la VM :

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

Dans DebugView :

  • Activer Capturer
  • Vérifier Capturer le noyau
  • Activer Sortie détaillée du noyau

dbgview.png Res.gif Enregistrez le service de chauffeur :

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

Démarrez-le :

sc start hello_win_kernel

Si tout est correct, DebugView affichera :

[hello_win_kernel.sys] Hello, world!

sc_start.png

Comparaison C++ (hello world driver)

Pour référence, voici l'entrée de pilote équivalente minimale dans 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;
}

Résumé

Vous avez construit un pilote de noyau Windows minimal dans Rust : configuré la nuit, lié aux bibliothèques WDK, implémenté un no_std point d'entrée et sortie du noyau validée via DebugView. Rust peut sembler plus « manuel » que C/C++ dans cet espace aujourd'hui, mais il offre de puissants outils de sécurité au niveau du langage qui valent le coût d'installation.

À partir de là, les prochaines étapes les plus productives sont primitives de pilote légitimes:

  • création d'un objet appareil et d'un lien symbolique
  • implémenter des routines de répartition IRP
  • Communication IOCTL
  • wrappers sécurisés autour du noyau APIs
  • modèles de journalisation et de gestion structurée des erreurs pour no_std

Références

  1. Scripts de construction de cargaison : https://doc.rust-lang.org/cargo/reference/build-scripts.html
  2. Options de l'éditeur de liens MSVC : https://learn.microsoft.com/cpp/build/reference/linker-options?view=msvc-170
  3. Téléchargement du WDK : https://learn.microsoft.com/windows-hardware/drivers/download-the-wdk
  4. Suite Sysinternals : https://learn.microsoft.com/sysinternals/downloads/sysinternals-suite
Retour aux blogs

Contacter

Démarrer la conversation

Quelques lignes claires suffisent. Décrivez le système, la pression et la décision bloquée. Ou écrivez directement à midgard@stofu.io.

0 / 10000
Aucun fichier choisi