Add protected Windows time verifier with Linux-first guard evidence
Rust development slice / linux (push) Failing after 6s

This commit is contained in:
2026-11-14 23:54:10 +01:00
parent 0d98774478
commit 74402ef882
5 changed files with 1158 additions and 0 deletions
+623
View File
@@ -0,0 +1,623 @@
//! Independent signed time comparison for the Windows agent and SYSTEM helper.
//! This module does not implement SyncClock, advertise a capability, start a job,
//! change W32Time or replace the still-closed legacy NativeClock adapter.
#![cfg(any(test, all(windows, feature = "system-helper")))]
use anyhow::{Result, ensure};
use rmm_time_attestation::Sample;
use uuid::Uuid;
const SECOND_NS: u64 = 1_000_000_000;
const MAX_BASE_ERROR_NS: u64 = 10_000_000;
fn independent_time_key(time_key_hex: &str, job_key_hex: &str) -> Result<[u8; 32]> {
fn decode(value: &str) -> Result<[u8; 32]> {
ensure!(
value.len() == 64 && value.bytes().all(|byte| byte.is_ascii_hexdigit()),
"TIME_NATIVE_PUBLIC_KEY"
);
let mut raw = [0u8; 32];
for (index, byte) in raw.iter_mut().enumerate() {
*byte = u8::from_str_radix(&value[index * 2..index * 2 + 2], 16)?;
}
Ok(raw)
}
let time = decode(time_key_hex)?;
let job = decode(job_key_hex)?;
ensure!(time != job, "TIME_NATIVE_KEY_ROLE_REUSE");
Ok(time)
}
#[derive(Default)]
struct Continuity {
boot_id: Option<Uuid>,
previous: Option<Sample>,
epoch: u64,
exhausted: bool,
active: Option<Uuid>,
configuration: Option<(u64, String)>,
connection_generation: Option<u64>,
}
impl Continuity {
fn invalidate(&mut self) {
self.active = None;
match self.epoch.checked_add(1) {
Some(epoch) if !self.exhausted => self.epoch = epoch,
_ => self.exhausted = true,
}
}
fn observe(&mut self, boot_id: Uuid, sample: Sample) -> Result<()> {
let valid = !boot_id.is_nil()
&& !self.exhausted
&& self.boot_id.is_none_or(|old| old == boot_id)
&& sample.wall_utc_ns > 0
&& sample.capture_error_ns <= rmm_time_attestation::MAX_CAPTURE_ERROR_NS
&& self.previous.is_none_or(|old| {
match (
sample.wall_utc_ns.checked_sub(old.wall_utc_ns),
sample.interrupt_ns.checked_sub(old.interrupt_ns),
sample.unbiased_ns.checked_sub(old.unbiased_ns),
) {
(Some(wall), Some(interrupt), Some(unbiased)) if wall >= 0 => {
(wall as u64).abs_diff(interrupt) <= SECOND_NS
&& interrupt.abs_diff(unbiased) <= SECOND_NS
}
_ => false,
}
});
// Never adopt a different boot in a surviving process. A new adapter
// object cannot erase this process-wide identity/continuity history.
self.boot_id.get_or_insert(boot_id);
self.previous = Some(sample);
if !valid {
self.invalidate();
}
ensure!(valid, "TIME_NATIVE_DISCONTINUITY_OR_BOOT");
Ok(())
}
fn accept_configuration(&mut self, generation: u64, sha256: &str) -> Result<()> {
ensure!(
generation > 0 && !self.exhausted,
"TIME_NATIVE_CONFIGURATION_GENERATION"
);
if let Some((current, hash)) = &self.configuration {
ensure!(
generation >= *current && (generation != *current || hash == sha256),
"TIME_NATIVE_CONFIGURATION_ROLLBACK_OR_FORK"
);
if generation > *current {
self.invalidate();
}
}
self.configuration = Some((generation, sha256.into()));
Ok(())
}
fn accept_connection(&mut self, generation: u64) -> Result<()> {
ensure!(
generation > 0
&& !self.exhausted
&& self
.connection_generation
.is_none_or(|old| generation >= old),
"TIME_NATIVE_CONNECTION_ROLLBACK"
);
if self
.connection_generation
.is_some_and(|old| generation > old)
{
self.invalidate();
}
self.connection_generation = Some(generation);
Ok(())
}
fn require_connection(&self, generation: u64) -> Result<()> {
ensure!(
!self.exhausted && self.connection_generation == Some(generation),
"TIME_NATIVE_CONNECTION_CHANGED"
);
Ok(())
}
fn reserve(&mut self, owner: Uuid) -> Result<u64> {
ensure!(
!self.exhausted && !owner.is_nil() && self.active.is_none(),
"TIME_NATIVE_CHALLENGE_BUSY"
);
self.active = Some(owner);
Ok(self.epoch)
}
fn require_owner(&self, owner: Uuid, epoch: u64) -> Result<()> {
ensure!(
!self.exhausted && self.active == Some(owner) && self.epoch == epoch,
"TIME_NATIVE_CHALLENGE_INVALIDATED"
);
Ok(())
}
}
/// All three native clocks are read in one bracket. The qualified base error
/// is a protected installation input, never inferred from 100ns resolution.
fn bracket_sample(
wall_filetime: u64,
interrupt_before: u64,
interrupt_after: u64,
unbiased_before: u64,
unbiased_after: u64,
base_error_ns: u64,
) -> Result<Sample> {
const FILETIME_UNIX: u64 = 116_444_736_000_000_000;
ensure!(
base_error_ns > 0 && base_error_ns <= MAX_BASE_ERROR_NS,
"TIME_NATIVE_CALIBRATION_REQUIRED"
);
let width = interrupt_after
.checked_sub(interrupt_before)
.and_then(|value| value.checked_mul(100))
.ok_or_else(|| anyhow::anyhow!("TIME_NATIVE_CAPTURE_COUNTER"))?;
let unbiased_width = unbiased_after
.checked_sub(unbiased_before)
.and_then(|value| value.checked_mul(100))
.ok_or_else(|| anyhow::anyhow!("TIME_NATIVE_CAPTURE_COUNTER"))?;
ensure!(
width.abs_diff(unbiased_width) <= SECOND_NS,
"TIME_NATIVE_CAPTURE_SUSPEND"
);
let capture_error_ns = width
.checked_add(base_error_ns)
.ok_or_else(|| anyhow::anyhow!("TIME_NATIVE_CAPTURE_OVERFLOW"))?;
ensure!(
capture_error_ns <= rmm_time_attestation::MAX_CAPTURE_ERROR_NS,
"TIME_NATIVE_CAPTURE_BUDGET"
);
let wall_utc_ns = wall_filetime
.checked_sub(FILETIME_UNIX)
.and_then(|value| value.checked_mul(100))
.ok_or_else(|| anyhow::anyhow!("TIME_NATIVE_WALL_RANGE"))?
.try_into()?;
Ok(Sample {
wall_utc_ns,
interrupt_ns: interrupt_after
.checked_mul(100)
.ok_or_else(|| anyhow::anyhow!("TIME_NATIVE_COUNTER_RANGE"))?,
unbiased_ns: unbiased_after
.checked_mul(100)
.ok_or_else(|| anyhow::anyhow!("TIME_NATIVE_COUNTER_RANGE"))?,
capture_error_ns,
})
}
#[cfg(all(windows, feature = "system-helper"))]
mod installed {
use super::*;
use crate::helper_ipc::{self as ipc, PeerProof, PinnedFile};
use anyhow::Context as _;
use rmm_agent_core::auth::Binding;
use rmm_domain::jobs::hash;
use rmm_time_attestation::{
Challenge, Context, Interval, Pins, Request, Role, SignedAttestation, Verifier,
};
use serde::{Deserialize, Serialize};
use std::{
collections::BTreeMap,
io::Read,
path::Path,
sync::{Mutex, OnceLock},
};
pub const CONFIG_PATH: &str = r"C:\ProgramData\RustDiscoverySystem\time-attestation.json";
const PUBLIC_ROOT: &str = r"C:\ProgramData\RustDiscoverySystem";
const MAX_CONFIG_BYTES: usize = 16_384;
const MAX_REPLY_BYTES: usize = 16_384;
/// Provision only after an independent qualification of these actual
/// native APIs/platform/image. A file field is not a measured accuracy.
#[derive(Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct Calibration {
pub role: Role,
pub binary_sha256: String,
pub qualification_sha256: String,
pub base_error_ns: u64,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct Configuration {
pub schema_version: u32,
pub key_generation: u64,
pub server_instance: Uuid,
pub binding: Binding,
pub public_keys_hex: BTreeMap<String, String>,
pub calibrations: Vec<Calibration>,
}
fn digest(value: &str) -> bool {
value.len() == 64
&& value
.bytes()
.all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
}
static PROCESS: OnceLock<Mutex<Continuity>> = OnceLock::new();
static INCARNATION: OnceLock<Uuid> = OnceLock::new();
fn process() -> &'static Mutex<Continuity> {
PROCESS.get_or_init(|| Mutex::new(Continuity::default()))
}
fn capture(base_error_ns: u64) -> Result<Sample> {
#[link(name = "kernel32")]
unsafe extern "system" {
fn GetSystemTimePreciseAsFileTime(value: *mut u64);
fn QueryInterruptTimePrecise(value: *mut u64);
fn QueryUnbiasedInterruptTimePrecise(value: *mut u64);
}
let (mut ib, mut ia, mut ub, mut ua, mut wall) = (0, 0, 0, 0, 0);
// SAFETY: documented VOID kernel getters with valid aligned u64
// outputs. Windows 10+ is required; no optional API fallback exists.
unsafe {
QueryInterruptTimePrecise(&mut ib);
QueryUnbiasedInterruptTimePrecise(&mut ub);
GetSystemTimePreciseAsFileTime(&mut wall);
QueryUnbiasedInterruptTimePrecise(&mut ua);
QueryInterruptTimePrecise(&mut ia);
}
bracket_sample(wall, ib, ia, ub, ua, base_error_ns)
}
fn observed(boot: Uuid, base_error_ns: u64) -> Result<(Sample, u64)> {
let mut state = process()
.lock()
.map_err(|_| anyhow::anyhow!("TIME_NATIVE_STATE_POISONED"))?;
let value = match capture(base_error_ns) {
Ok(value) => value,
Err(error) => {
state.invalidate();
return Err(error);
}
};
state.observe(boot, value)?;
Ok((value, state.epoch))
}
struct Pending {
owner: Uuid,
epoch: u64,
challenge: Challenge,
}
/// Own-process role proof, protected held configuration, private challenge
/// and native timers. No constructor accepts agent-reported helper times.
pub struct SignedClock {
verifier: Verifier,
own_process: PeerProof,
files: Vec<PinnedFile>,
config_sha256: String,
boot_id: Uuid,
connection_generation: u64,
base_error_ns: u64,
pending: Option<Pending>,
}
impl SignedClock {
/// Connection generation is later confirmed by the independently
/// signed server response. It is never itself a ready/sync flag.
pub async fn open(role: Role, connection_generation: u64) -> Result<Self> {
ensure!(connection_generation > 0, "TIME_NATIVE_CONNECTION");
let (settings, mut files) = crate::helper_system::read_settings()?;
let own_pin = match role {
Role::Agent => &settings.agent,
Role::SystemHelper => &settings.helper,
};
own_pin.validate(role == Role::SystemHelper)?;
ipc::require_self(own_pin)?;
let own_process = PeerProof::for_service(
own_pin,
// SAFETY: this getter takes no arguments and returns own PID.
unsafe { windows_sys::Win32::System::Threading::GetCurrentProcessId() },
)?;
let readers = vec![
settings.agent.service_sid.clone(),
settings.helper.service_sid.clone(),
];
files.push(PinnedFile::open(
Path::new(PUBLIC_ROOT),
true,
&readers,
&[],
false,
)?);
let mut config_file =
PinnedFile::open(Path::new(CONFIG_PATH), false, &readers, &[], false)?;
ensure!(
config_file.file.metadata()?.len() <= MAX_CONFIG_BYTES as u64,
"TIME_NATIVE_CONFIG_SIZE"
);
let mut raw = Vec::new();
(&mut config_file.file)
.take(MAX_CONFIG_BYTES as u64 + 1)
.read_to_end(&mut raw)?;
ensure!(raw.len() <= MAX_CONFIG_BYTES, "TIME_NATIVE_CONFIG_SIZE");
let config: Configuration = serde_json::from_slice(&raw)?;
ensure!(
config.schema_version == 1
&& config.key_generation > 0
&& config.calibrations.len() == 2,
"TIME_NATIVE_CONFIG_PROFILE"
);
ensure!(
hash(&serde_json::to_vec(&config.binding)?)
== hash(&serde_json::to_vec(&settings.binding)?),
"TIME_NATIVE_DEVICE_BINDING"
);
for expected in [Role::Agent, Role::SystemHelper] {
let mut values = config
.calibrations
.iter()
.filter(|value| value.role == expected);
let value = values.next().context("TIME_NATIVE_CALIBRATION_MISSING")?;
ensure!(
values.next().is_none()
&& digest(&value.binary_sha256)
&& digest(&value.qualification_sha256)
&& value.base_error_ns > 0
&& value.base_error_ns <= MAX_BASE_ERROR_NS,
"TIME_NATIVE_CALIBRATION_PROFILE"
);
let pin = if expected == Role::Agent {
&settings.agent
} else {
&settings.helper
};
ensure!(
value.binary_sha256 == pin.binary_sha256,
"TIME_NATIVE_CALIBRATION_IMAGE"
);
}
let base_error_ns = config
.calibrations
.iter()
.find(|value| value.role == role)
.context("TIME_NATIVE_CALIBRATION_MISSING")?
.base_error_ns;
let keys = config
.public_keys_hex
.iter()
.map(|(id, key)| {
ensure!(digest(key), "TIME_NATIVE_PUBLIC_KEY");
let raw = independent_time_key(key, &settings.binding.public_key_hex)?;
Ok((id.clone(), raw))
})
.collect::<Result<BTreeMap<_, _>>>()?;
let pins = Pins::new(config.key_generation, config.server_instance, keys)?;
process()
.lock()
.map_err(|_| anyhow::anyhow!("TIME_NATIVE_STATE_POISONED"))?
.accept_configuration(config.key_generation, &hash(&raw))?;
// The existing fixed read-only native getter is independent in
// each process. It finishes BEFORE challenge/RTT timing begins.
let boot_id = Uuid::parse_str(&crate::native::boot_id().await?)?;
let context = Context {
tenant_id: settings.binding.tenant_id,
asset_id: settings.binding.asset_id,
agent_id: settings.binding.agent_id,
enrollment_generation: settings.binding.enrollment_generation,
assignment_generation: settings.binding.assignment_version,
connection_generation,
windows_boot_id: boot_id,
verifier_incarnation: *INCARNATION.get_or_init(Uuid::new_v4),
role,
helper_image_sha256: (role == Role::SystemHelper)
.then(|| own_pin.binary_sha256.clone()),
binding_schema: 1,
};
files.push(config_file);
let mut value = Self {
verifier: Verifier::new(context, pins)?,
own_process,
files,
config_sha256: hash(&raw),
boot_id,
connection_generation,
base_error_ns,
pending: None,
};
value.recheck()?;
process()
.lock()
.map_err(|_| anyhow::anyhow!("TIME_NATIVE_STATE_POISONED"))?
.accept_connection(connection_generation)?;
observed(boot_id, base_error_ns)?;
Ok(value)
}
fn recheck(&mut self) -> Result<()> {
self.own_process.check()?;
for file in &mut self.files {
file.check()?;
}
let config = self.files.last_mut().context("TIME_NATIVE_CONFIG_HELD")?;
ensure!(
config.sha256()? == self.config_sha256,
"TIME_NATIVE_CONFIG_CHANGED"
);
Ok(())
}
pub fn begin(&mut self, connection_generation: u64) -> Result<Request> {
if connection_generation != self.connection_generation {
self.close();
anyhow::bail!("TIME_NATIVE_CONNECTION_CHANGED");
}
ensure!(self.pending.is_none(), "TIME_NATIVE_PENDING");
self.recheck()?;
let mut state = process()
.lock()
.map_err(|_| anyhow::anyhow!("TIME_NATIVE_STATE_POISONED"))?;
state.require_connection(connection_generation)?;
let sample = match capture(self.base_error_ns) {
Ok(value) => value,
Err(error) => {
state.invalidate();
return Err(error);
}
};
state.observe(self.boot_id, sample)?;
let owner = Uuid::new_v4();
let epoch = state.reserve(owner)?;
let challenge = match self.verifier.begin(sample) {
Ok(value) => value,
Err(error) => {
state.invalidate();
return Err(error);
}
};
let request = challenge.request().clone();
self.pending = Some(Pending {
owner,
epoch,
challenge,
});
Ok(request)
}
/// Call immediately after this verifier receives the complete bounded
/// response. The helper's caller supplies bytes only, never timestamps.
/// All failures consume the original request; no transparent retry.
pub fn complete<T>(
&mut self,
bytes: &[u8],
consume: impl FnOnce(&Comparison) -> Result<T>,
) -> Result<T> {
let pending = self.pending.take().context("TIME_NATIVE_NO_CHALLENGE")?;
let result = (|| {
let (received, epoch) = observed(self.boot_id, self.base_error_ns)?;
ensure!(epoch == pending.epoch, "TIME_NATIVE_CHALLENGE_INVALIDATED");
ensure!(bytes.len() <= MAX_REPLY_BYTES, "TIME_NATIVE_REPLY_SIZE");
let signed: SignedAttestation = serde_json::from_slice(bytes)?;
self.recheck()?;
let mut checked = None;
let interval =
self.verifier
.finish(pending.challenge, &signed, received, || {
let (sample, epoch) = observed(self.boot_id, self.base_error_ns)?;
ensure!(epoch == pending.epoch, "TIME_NATIVE_CHALLENGE_INVALIDATED");
checked = Some(sample);
Ok(sample)
})?;
let mut state = process()
.lock()
.map_err(|_| anyhow::anyhow!("TIME_NATIVE_STATE_POISONED"))?;
state.require_owner(pending.owner, pending.epoch)?;
state.active = None;
let comparison = Comparison {
interval,
wall_utc_ns: checked.context("TIME_NATIVE_FINAL_SAMPLE")?.wall_utc_ns,
};
drop(state);
consume(&comparison)
})();
if result.is_err() {
self.verifier.invalidate();
if let Ok(mut state) = process().lock()
&& state.active == Some(pending.owner)
{
state.invalidate();
}
}
result
}
pub fn close(&mut self) {
self.verifier.invalidate();
if let Some(pending) = self.pending.take()
&& let Ok(mut state) = process().lock()
&& state.active == Some(pending.owner)
{
state.invalidate();
}
}
}
impl Drop for SignedClock {
fn drop(&mut self) {
self.close();
}
}
/// Borrowed only inside the completion callback, never returned as a
/// storable clock/lease/permit. Runtime callers must retain all job gates.
pub struct Comparison {
interval: Interval,
wall_utc_ns: i64,
}
impl Comparison {
pub fn interval(&self) -> &Interval {
&self.interval
}
pub fn wall_utc_ns(&self) -> i64 {
self.wall_utc_ns
}
}
}
#[cfg(all(windows, feature = "system-helper"))]
pub use installed::{CONFIG_PATH, Calibration, Comparison, Configuration, SignedClock};
#[cfg(test)]
mod tests {
use super::*;
fn sample(ns: u64) -> Sample {
Sample {
wall_utc_ns: 1_800_000_000_000_000_000 + ns as i64,
interrupt_ns: 10_000_000_000 + ns,
unbiased_ns: 9_000_000_000 + ns,
capture_error_ns: 1_000_000,
}
}
#[test]
fn job_key_cannot_be_reintroduced_as_a_time_key_with_different_hex_case() {
assert_eq!(
independent_time_key(&"ab".repeat(32), &"AB".repeat(32))
.unwrap_err()
.to_string(),
"TIME_NATIVE_KEY_ROLE_REUSE"
);
assert!(independent_time_key(&"ab".repeat(32), &"cd".repeat(32)).is_ok());
assert!(independent_time_key(&"ab".repeat(32), "not-a-provisioned-job-key").is_err());
}
#[test]
fn bracket_uses_actual_capture_width_and_refuses_unqualified_or_backward_counters() {
let wall = 116_444_736_000_000_000 + 18_000_000_000_000_000;
let result = bracket_sample(wall, 100, 120, 90, 110, 1_000_000).unwrap();
assert_eq!(result.wall_utc_ns, 1_800_000_000_000_000_000);
assert_eq!(result.capture_error_ns, 1_002_000);
assert!(bracket_sample(wall, 100, 99, 90, 110, 1_000_000).is_err());
assert!(bracket_sample(wall, 100, 120, 90, 89, 1_000_000).is_err());
assert!(bracket_sample(wall, 100, 120, 90, 110, 0).is_err());
assert!(bracket_sample(wall, 0, 500_000, 0, 500_000, 1_000_000).is_err());
}
#[test]
fn retained_process_fence_rejects_old_challenge_and_boot_substitution() {
let boot = Uuid::new_v4();
let owner = Uuid::new_v4();
let mut state = Continuity::default();
state.accept_configuration(4, "one-config").unwrap();
state.accept_connection(3).unwrap();
assert!(state.accept_configuration(3, "old-config").is_err());
assert!(state.accept_configuration(4, "different-config").is_err());
state.accept_configuration(4, "one-config").unwrap();
state.observe(boot, sample(0)).unwrap();
let original_epoch = state.reserve(owner).unwrap();
assert!(state.reserve(Uuid::new_v4()).is_err());
let mut resumed = sample(2_000_000_000);
resumed.unbiased_ns = 9_000_000_000;
assert!(state.observe(boot, resumed).is_err());
assert!(state.require_owner(owner, original_epoch).is_err());
// A caller reconstructing its verifier still sees this retained state.
state.observe(boot, resumed).unwrap();
let next = Uuid::new_v4();
let epoch = state.reserve(next).unwrap();
assert!(epoch > original_epoch);
state.require_owner(next, epoch).unwrap();
state.accept_connection(4).unwrap();
assert!(state.require_owner(next, epoch).is_err());
assert!(state.require_connection(3).is_err());
assert!(state.accept_connection(3).is_err());
state.require_connection(4).unwrap();
assert!(state.observe(Uuid::new_v4(), resumed).is_err());
assert!(state.require_owner(next, epoch).is_err());
state.epoch = u64::MAX;
state.invalidate();
assert!(state.exhausted);
state.invalidate();
assert!(state.exhausted);
assert!(state.reserve(Uuid::new_v4()).is_err());
}
}