Windows Kernel Desenvolvedor em Rust. Introdução.

Windows Kernel Desenvolvedor em Rust. Introdução.

Introdução ao Windows Kernel Desenvolvimento de driver em Rust

Conteúdo

  • Introdução
  • Dependências
  • Desenvolvimento
    • Configuração
    • Implementação
  • Implantação e testes
  • Resumo
  • Referências

Introdução

Olá! Que bom que você está aqui. Neste post vamos construir um pequeno driver de kernel Windows usando Rust. Sim, isso Rust. Moderno, barulhento e realmente útil.

Este artigo permanece no lado seguro e fundamental: configuração do conjunto de ferramentas, vinculação ao WDK, no_std, um ponto de entrada mínimo do driver e saída de depuração do kernel via DbgPrint. A partir daqui, você pode passar para as próximas etapas legítimas, como manipulação de IOCTL, objetos de dispositivo, rotinas de despacho de IRP e arquitetura de driver real.

Se você ainda não conhece Rust, ainda assim estará bem: também mostrarei um exemplo C++ comparável. Tudo que você precisa é de tempo, experiência em C/C++ e conhecimento básico de desenvolvimento em modo kernel.

Por que Rust? Porque ele pode oferecer desempenho próximo ao C/C++ ao mesmo tempo em que fornece fortes garantias de segurança de memória no nível da linguagem. Muitas grandes organizações estão investindo em código seguro para memória e Rust em particular, e o ecossistema Rust é enviado rapidamente com lançamentos estáveis ​​a cada aproximadamente 6 semanas e um canal noturno separado.

⚠️ Nota de ética e segurançaOs drivers do kernel são executados com privilégios extremos. Use essas técnicas apenas para aprendizado, pesquisa e desenvolvimento legítimo.

Dependências

Para acompanhar (ou copiar/colar), instale:

Você também vai querer uma VM (VMWare, Hyper-V, VirtualBox, QEMU) com Windows 10x64 or Windows 11, assinatura de teste ativadae depuração do kernel habilitada.

Ative o modo de teste e a depuração do kernel e reinicie:

⚠️ Execute o terminal como Administrador

# Enable Test Signing mode
bcdedit -set TESTSIGNING ON

# Enable kernel debugging
bcdedit /debug on

Desenvolvimento

Configuração

Crie um novo projeto de biblioteca Rust:

cargo new hello-win-kernel --lib

Estrutura do projeto:

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

Em Rust, main.rs é o ponto de entrada para binários, e lib.rs é a porta de entrada para bibliotecas. Construiremos um driver como um artefato de biblioteca dinâmica.

Editar Cargo.toml:

  • Adicione um [lib] seção e conjunto crate-type = ["cdylib"] então Rust produz uma biblioteca dinâmica compatível com C.
  • Definir panic = "abort" para perfis de depuração e liberação para evitar comportamento de desenrolamento.
  • Adicionar winreg como um construir dependência para ler os caminhos dos kits WDK/Windows do registro em build.rs.

Carga.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"

Crie um rust-toolchain arquivo na raiz do projeto para forçar todas as noites (precisamos de sinalizadores somente noturnos durante a vinculação):

rust-toolchain

nightly

Adicione um script de construção para localizar bibliotecas WDK

Para construir um driver, precisamos vincular algumas bibliotecas WDK (por exemplo, ntoskrnl). Adicionaremos caminhos de pesquisa de biblioteca no momento da construção via build.rs.

Criar build.rs:

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

Configuração do vinculador para uma compilação de driver

Crie um .cargo pasta e adicione um arquivo de configuração. Suportes de carga config.toml (preferencial) e mais antigo 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",
]

Implementação

Rust não fornece uma biblioteca padrão utilizável no modo kernel, então nós a desabilitamos com #![no_std]. Também implementamos um manipulador de pânico personalizado e fornecemos alguns símbolos para satisfazer o vinculador MSVC nesta configuração mínima.

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

Adicione aliases básicos do tipo Windows:

src/types.rs

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

Adicione uma constante NTSTATUS mínima:

src/ntstatus.rs

use crate::types::*;

pub const STATUS_SUCCESS: NTSTATUS = 0x00000000;

Saída de depuração do kernel com DbgPrint

Agora vamos importar DbgPrint from ntoskrnl e envolva-o com uma pequena macro para não esquecermos o terminador nulo.

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

Neste ponto você pode construir com sucesso. A seguir, automatizaremos a renomeação/assinatura e o carregamento de teste.

Implantação e testes

Para testar um driver em uma VM, normalmente você precisa:

  1. Construa o .dll artifact
  2. Renomeie-o para .sys
  3. Assine (o certificado de teste é suficiente para o modo de teste)
  4. Carregue-o como um serviço e verifique a saída

Automatizaremos essas etapas com cargo-make.

Instale:

cargo install cargo-make

Configurar o caminho das ferramentas Windows SDK

Crie uma variável de ambiente do sistema chamada WIN_SDK_TOOLS apontando para sua pasta de ferramentas Windows SDK.

Etapas:

  1. Abrir Ver configurações avançadas do sistema
  2. Vá para Avançado tab
  3. Clique Variáveis de ambiente
  4. Abaixo Variáveis do sistema, clique Novo
  5. Dê um nome WIN_SDK_TOOLS
  6. Defina o valor para o caminho de ferramentas Windows SDK
  7. Clique OK

Env.gif

Adicione um script de criação de carga

Criar makefile.toml na raiz do projeto:

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

Crie, renomeie, assine e implante:

cargo make deploy

Limpe tudo:

cargo make cleanup

Assine apenas:

cargo make sign-driver

Teste em uma VM Windows

Certifique-se de que a assinatura de teste e a depuração do kernel estejam habilitadas (e reinicie se você alterou as configurações):

bcdedit -set TESTSIGNING ON
bcdedit /debug on

Copie para a VM:

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

No DebugView:

  • Habilitar Capturar
  • Verifique Capturar Kernel
  • Habilitar Saída detalhada do kernel

dbgview.png Res.gif Registre o serviço de motorista:

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

Comece:

sc start hello_win_kernel

Se tudo estiver correto, o DebugView mostrará:

[hello_win_kernel.sys] Hello, world!

sc_start.png

C++ comparação (olá mundo driver)

Para referência, aqui está a entrada mínima equivalente do driver em 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;
}

Resumo

Você construiu um driver de kernel mínimo Windows em Rust: configurado todas as noites, vinculado a bibliotecas WDK, implementado um no_std ponto de entrada e saída validada do kernel via DebugView. Rust pode parecer mais “manual” do que C/C++ neste espaço hoje, mas oferece ferramentas poderosas de segurança em nível de linguagem que valem o custo de configuração.

A partir daqui, os próximos passos mais produtivos são primitivos de driver legítimos:

  • criando um objeto de dispositivo e link simbólico
  • implementando rotinas de despacho IRP
  • Comunicação IOCTL
  • wrappers seguros em torno do kernel APIs
  • registro e padrões estruturados de tratamento de erros para no_std

Referências

  1. Scripts de construção de carga: https://doc.rust-lang.org/cargo/reference/build-scripts.html
  2. Opções do vinculador MSVC: https://learn.microsoft.com/cpp/build/reference/linker-options?view=msvc-170
  3. Baixar WDK: https://learn.microsoft.com/windows-hardware/drivers/download-the-wdk
  4. Suíte Sysinternals: https://learn.microsoft.com/sysinternals/downloads/sysinternals-suite
Voltar aos blogs

Contato

Comece a conversa

Algumas linhas claras bastam. Descreva o sistema, a pressão e a decisão que está bloqueada. Ou escreva diretamente para midgard@stofu.io.

0 / 10000
Nenhum arquivo escolhido