key-vault 1.0.0

Enterprise-grade key management vault for Rust. 9-layer defense-in-depth: fragmentation, decoy bytes, codex transform, mlock + zeroize, constant-time ops, security monitoring. Pluggable key fetchers (TPM, keychain, file, env). Sub-microsecond access. REPS-compliant.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

//! `VirtualLock` / `VirtualUnlock` backend for Windows.

use windows_sys::Win32::System::Memory::{VirtualLock, VirtualUnlock};

/// Attempt to lock `len` bytes starting at `ptr` into RAM.
///
/// # Safety
///
/// `ptr` must point to a live allocation of at least `len` bytes that will
/// remain valid until a matching [`unlock_pages`] call. `len` must be
/// non-zero (the empty case is filtered upstream).
pub(super) unsafe fn lock_pages(ptr: *const u8, len: usize) -> bool {
    // SAFETY: `VirtualLock` is a Win32 API that pins the pages backing the
    // given range into the working set. The pointer/length pair are passed
    // straight through; the kernel rejects invalid ranges rather than
    // corrupting state.
    let ok = unsafe { VirtualLock(ptr as *mut core::ffi::c_void, len) };
    ok != 0
}

/// Release the lock on `len` bytes starting at `ptr`.
///
/// # Safety
///
/// Same invariants as [`lock_pages`]. The result is ignored — failure to
/// unlock is not actionable from `Drop`.
pub(super) unsafe fn unlock_pages(ptr: *const u8, len: usize) {
    // SAFETY: pointer/length come from the same allocation that was
    // successfully `VirtualLock`'d, by Drop-order invariant.
    let _ = unsafe { VirtualUnlock(ptr as *mut core::ffi::c_void, len) };
}