From 74402ef882155c7335bde11e90de82732ab22c94 Mon Sep 17 00:00:00 2001 From: Kevin Janssen Date: Sat, 14 Nov 2026 23:54:10 +0100 Subject: [PATCH] Add protected Windows time verifier with Linux-first guard evidence --- crates/agent-windows/src/lib.rs | 1 + crates/agent-windows/src/signed_clock.rs | 623 ++++++++++++++++++ .../windows_signed_clock_linux_acceptance.py | 312 +++++++++ docs/handover.md | 8 + docs/windows-signed-clock-source.md | 214 ++++++ 5 files changed, 1158 insertions(+) create mode 100644 crates/agent-windows/src/signed_clock.rs create mode 100644 deploy/windows_signed_clock_linux_acceptance.py create mode 100644 docs/windows-signed-clock-source.md diff --git a/crates/agent-windows/src/lib.rs b/crates/agent-windows/src/lib.rs index 064fa52..ff51846 100644 --- a/crates/agent-windows/src/lib.rs +++ b/crates/agent-windows/src/lib.rs @@ -27,6 +27,7 @@ pub mod package; pub mod process; #[cfg(windows)] pub mod service; +pub mod signed_clock; #[cfg(all(windows, feature = "system-helper"))] mod system_script; diff --git a/crates/agent-windows/src/signed_clock.rs b/crates/agent-windows/src/signed_clock.rs new file mode 100644 index 0000000..7ce2473 --- /dev/null +++ b/crates/agent-windows/src/signed_clock.rs @@ -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, + previous: Option, + epoch: u64, + exhausted: bool, + active: Option, + configuration: Option<(u64, String)>, + connection_generation: Option, +} +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 { + 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 { + 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, + pub calibrations: Vec, + } + 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> = OnceLock::new(); + static INCARNATION: OnceLock = OnceLock::new(); + fn process() -> &'static Mutex { + PROCESS.get_or_init(|| Mutex::new(Continuity::default())) + } + fn capture(base_error_ns: u64) -> Result { + #[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, + config_sha256: String, + boot_id: Uuid, + connection_generation: u64, + base_error_ns: u64, + pending: Option, + } + 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 { + 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::>>()?; + 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 { + 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( + &mut self, + bytes: &[u8], + consume: impl FnOnce(&Comparison) -> Result, + ) -> Result { + 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()); + } +} diff --git a/deploy/windows_signed_clock_linux_acceptance.py b/deploy/windows_signed_clock_linux_acceptance.py new file mode 100644 index 0000000..0d96e2a --- /dev/null +++ b/deploy/windows_signed_clock_linux_acceptance.py @@ -0,0 +1,312 @@ +#!/usr/bin/env python3 +"""Frozen three Windows clock guards on Linux only; ten other cases filtered; no updater service or Apply. + +Prepare copies the independently reviewed snapshot locally. Execute is one +root-only Cloud-VM fixture run. After any lost reply read the original case; +never execute it again or substitute another binary/source generation. +""" +import argparse +import base64 +import hashlib +import inspect +import json +import os +from pathlib import Path +import stat +import uuid + +import windows_msi_runtime_acceptance as support + +ROOT = Path(__file__).resolve().parents[1] +ACCESS_ROOT = ROOT.parent / 'rust-discovery' +QUALIFICATION = ROOT / 'devstate/windows-signed-clock/qualification-763baf69-10b1-4307-9c99-6942c0f8945f' +STATE = ROOT / 'devstate/windows-signed-clock-native-linux' +PROFILE = 'rmm.windows-signed-clock.three-linux-guards.v1' +RECEIPT_SHA = 'e013738caed2d8e02b98ffd1b41e47a80840c44d3dbf895e9a3952b4311ce927' +INPUTS_SHA = 'eb4609c5fca6a32ddb8ebf364775efdb59cd89f99a24b3b731212da08eac6a6e' +BINARY_SHA = '0896a3098f493b67b48e774de5cfe9bca682d2a19ff10971c62c9c7b9681ec14' +BINARY_BYTES = 3374576 +TESTS = sorted(['signed_clock::tests::bracket_uses_actual_capture_width_and_refuses_unqualified_or_backward_counters', 'signed_clock::tests::job_key_cannot_be_reintroduced_as_a_time_key_with_different_hex_case', 'signed_clock::tests::retained_process_fence_rejects_old_challenge_and_boot_substitution']) +ALL_TESTS = sorted(['event_log::tests::job_mapping_is_only_fixed_unprivileged_live_logs_with_exact_limits', 'event_log::tests::only_fixed_source_window_and_finite_limits_are_queryable', 'event_log::tests::serialized_byte_budget_includes_xml_escaping_and_metadata', 'journal::tests::bounded_existing_journal_preserves_identity_sequence_and_unacked_bytes', 'journal::tests::durable_reopen_ack_identity_and_single_process', 'journal::tests::migrates_original_passive_schema_without_rewriting_pending_envelopes', 'journal::tests::unsupported_page_size_is_refused_without_mutating_existing_data', 'package::tests::exit_code_never_substitutes_for_independent_postconditions_or_reboot_authority', 'package::tests::late_exit_or_postcondition_cannot_retroactively_succeed_or_retry', 'package::tests::upgrade_and_noop_need_independent_exact_products_family_and_payload', 'signed_clock::tests::bracket_uses_actual_capture_width_and_refuses_unqualified_or_backward_counters', 'signed_clock::tests::job_key_cannot_be_reintroduced_as_a_time_key_with_different_hex_case', 'signed_clock::tests::retained_process_fence_rejects_old_challenge_and_boot_substitution']) +AGENT_SHA = '0a7ad6eefaefda79ee80b6a41b2df904e9e7f50ae6ebeed01b98c25b6ce5c06f' +HELPER_SHA = '79442727c3ba31cda02a8bc0e67481f14db9f39fc07520a880a90b64f10f1eaf' + + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + + +def save_local(path, value): + support.save(path, value) + fd = os.open(path.parent, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW) + try: + os.fsync(fd) + finally: + os.close(fd) + + +def copy_exact(source, destination, digest, size): + metadata = source.lstat() + support.require(stat.S_ISREG(metadata.st_mode) and metadata.st_nlink == 1 + and metadata.st_uid in (0, os.getuid()) and not metadata.st_mode & 0o002 + and metadata.st_size == size and size <= 4 * 1024 * 1024, 'bounded regular frozen input') + raw = source.read_bytes() + support.require(sha(raw) == digest, 'frozen snapshot input hash') + destination.parent.mkdir(mode=0o700, parents=True, exist_ok=True) + support.private(destination.parent, True) + fd = os.open(destination, os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW | os.O_WRONLY, 0o600) + with os.fdopen(fd, 'wb') as stream: + stream.write(raw); stream.flush(); os.fsync(stream.fileno()) + fd = os.open(destination.parent, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW) + try: + os.fsync(fd) + finally: + os.close(fd) + + +def verify_case(folder): + value = support.load(folder / 'manifest.json') + support.require(value['profile'] == PROFILE and value['tests'] == TESTS and value['all_listed_tests'] == ALL_TESTS + and value['runner_sha256'] == sha(Path(__file__).read_bytes()) + and value['receipt_sha256'] == RECEIPT_SHA and value['binary_sha256'] == BINARY_SHA + and value['binary_bytes'] == BINARY_BYTES, 'same original reviewed manifest') + support.require(sha((folder / 'receipt.json').read_bytes()) == RECEIPT_SHA + and sha((folder / 'inputs.json').read_bytes()) == INPUTS_SHA, 'original qualification provenance') + source = support.load(folder / 'inputs.json') + support.require(len(source) == 184 and source == value['source_files'], 'exact frozen 184 compiler inputs') + for item in source: + path = Path(item['path']) + support.require(not path.is_absolute() and '..' not in path.parts, 'fixed snapshot relative path') + file = folder / 'source' / path + support.private(file) + support.require(file.stat().st_size == item['bytes'] and sha(file.read_bytes()) == item['sha256'], 'retained source freeze') + binary = folder / 'windows-clock-guard-tests'; support.private(binary) + support.require(binary.stat().st_size == BINARY_BYTES and sha(binary.read_bytes()) == BINARY_SHA, 'original qualified test bytes') + for path, digest in value['transport_sources'].items(): + support.require(sha((ROOT / path).read_bytes()) == digest, 'original strict transport source') + return value + + +def remote(p): + import base64 + import hashlib + import json + import os + from pathlib import Path + import selectors + import signal + import stat + import subprocess + import time + import uuid + + def require(ok, message): + if not ok: + raise RuntimeError(message) + + def enc(value): + return json.dumps(value, sort_keys=True, separators=(',', ':')).encode() + + def create(path, raw, mode=0o600): + fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, mode) + with os.fdopen(fd, 'wb') as stream: + stream.write(raw); stream.flush(); os.fsync(stream.fileno()) + fd = os.open(path.parent, os.O_DIRECTORY | os.O_RDONLY | os.O_NOFOLLOW) + try: + os.fsync(fd) + finally: + os.close(fd) + + def run(args, timeout=20): + # Keep the owned group leader unreaped until its entire group has been + # cleaned up. Its PID therefore cannot be recycled before killpg. + child = subprocess.Popen(args, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, + stderr=subprocess.PIPE, start_new_session=True, + env={'PATH': '/usr/bin:/bin', 'LC_ALL': 'C', 'HOME': '/nonexistent'}) + selector = selectors.DefaultSelector() + buffers = {'stdout': bytearray(), 'stderr': bytearray()} + deadline = time.monotonic() + timeout + try: + for stream, name in ((child.stdout, 'stdout'), (child.stderr, 'stderr')): + os.set_blocking(stream.fileno(), False); selector.register(stream, selectors.EVENT_READ, name) + while True: + require(time.monotonic() < deadline, 'owned native command timeout; read original case only') + for key, _ in selector.select(0.02): + raw = os.read(key.fileobj.fileno(), 4096) + if raw: + buffers[key.data].extend(raw) + require(len(buffers[key.data]) <= 65536, 'bounded native output') + else: + selector.unregister(key.fileobj) + ended = os.waitid(os.P_PID, child.pid, os.WEXITED | os.WNOHANG | os.WNOWAIT) + if ended is not None: + # Child remains a zombie until finally: no PID/group reuse. + os.killpg(child.pid, signal.SIGKILL) + for key in list(selector.get_map().values()): + while True: + try: + raw = os.read(key.fileobj.fileno(), 4096) + except BlockingIOError: + break + if not raw: + break + buffers[key.data].extend(raw) + require(len(buffers[key.data]) <= 65536, 'bounded native output') + code = ended.si_status if ended.si_code == os.CLD_EXITED else -ended.si_status + return code, bytes(buffers['stdout']), bytes(buffers['stderr']) + finally: + os.killpg(child.pid, signal.SIGKILL) + child.wait() + selector.close(); child.stdout.close(); child.stderr.close() + + def metadata_identity(value): + return (value.st_dev, value.st_ino, value.st_uid, value.st_gid, value.st_mode, + value.st_nlink, value.st_size, value.st_mtime_ns, value.st_ctime_ns) + + def hashed(path, maximum, process_image=False): + fd = os.open(path, os.O_RDONLY | os.O_CLOEXEC | (0 if process_image else os.O_NOFOLLOW)) + with os.fdopen(fd, 'rb') as stream: + before = os.fstat(stream.fileno()); require(stat.S_ISREG(before.st_mode) and before.st_size <= maximum, 'bounded witness file') + digest = hashlib.sha256(); total = 0 + while True: + raw = stream.read(32768) + if not raw: + break + total += len(raw); require(total <= maximum, 'bounded witness hash'); digest.update(raw) + after = os.fstat(stream.fileno()) + require(metadata_identity(before) == metadata_identity(after) and total == before.st_size, 'stable witness hash') + return before, digest.hexdigest() + + def witness(): + out = {'boot_id': Path('/proc/sys/kernel/random/boot_id').read_text().strip(), 'services': {}, 'files': {}} + release = dict(line.split('=', 1) for line in Path('/etc/os-release').read_text().splitlines() if '=' in line) + require(release.get('ID', '').strip('"') == 'ubuntu' and release.get('VERSION_ID', '').strip('"') == '24.04', 'fixed native Ubuntu24.04') + out['os'] = {'id': 'ubuntu', 'version': '24.04', 'machine': os.uname().machine, 'kernel': os.uname().release} + for name, uid, binary in ( + ('rmm-agent-remote.service', 993, p['agent_sha256']), + ('rmm-helper-cloud.service', 0, p['helper_sha256']), + ('rmm-full-maintenance-helper.service', 0, p['helper_sha256'])): + code, stdout, _ = run(['/usr/bin/systemctl', 'show', name, '-p', 'ActiveState', '-p', 'MainPID', '-p', 'UnitFileState', '-p', 'InvocationID']) + require(code == 0, 'existing service read') + service = dict(line.split('=', 1) for line in stdout.decode().splitlines()) + pid = int(service['MainPID']); require(service['ActiveState'] == 'active' and pid > 1, 'three existing services active') + proc = Path('/proc', str(pid)); birth = (proc / 'stat').read_text().rsplit(') ', 1)[1].split()[19] + ids = {line.split(':')[0]: line.split()[1:] for line in (proc / 'status').read_text().splitlines() if line.startswith(('Uid:', 'Gid:'))} + metadata, image = hashed(proc / 'exe', 256 * 1024 * 1024, process_image=True) + current = (proc / 'exe').stat() + require(ids['Uid'] == [str(uid)] * 4 and ids['Gid'] == ['984'] * 4 and image == binary + and (metadata.st_dev, metadata.st_ino) == (current.st_dev, current.st_ino) + and (proc / 'stat').read_text().rsplit(') ', 1)[1].split()[19] == birth, 'current generation/account/image') + out['services'][name] = dict(service, birth=birth, image=image, ids=ids) + code, stdout, _ = run(['/usr/bin/systemctl', 'show', 'rmm-apt-helper.service', '-p', 'ActiveState', '-p', 'UnitFileState']) + apt = dict(line.split('=', 1) for line in stdout.decode().splitlines()) + require(code == 0 and apt == {'ActiveState': 'inactive', 'UnitFileState': 'disabled'}, 'APT remains closed') + out['apt'] = apt + for name in ('/etc/rmm-remote/helper-general.json', '/etc/rmm-remote/helper-full-maintenance.json', + '/etc/rmm-remote/full-maintenance-helper-proof.json', '/etc/systemd/system/rmm-full-maintenance-helper.service'): + path = Path(name); metadata = path.lstat() + require(not path.is_symlink() and stat.S_ISREG(metadata.st_mode) and metadata.st_uid == 0 + and not metadata.st_mode & 0o022 and metadata.st_nlink == 1, 'protected known control') + current, digest = hashed(path, 65536) + require(metadata_identity(current) == metadata_identity(metadata), 'same known control file') + out['files'][name] = [metadata.st_dev, metadata.st_ino, metadata.st_uid, metadata.st_gid, metadata.st_mode, + metadata.st_size, metadata.st_mtime_ns, metadata.st_ctime_ns, digest] + for name in ('/var/lib/rmm-helper/consumption.sqlite', '/var/lib/rmm-helper/executor.lock', + '/var/lib/rmm-agent-remote/journal.sqlite', '/var/lib/rmm-agent-remote/consumption.sqlite'): + path = Path(name); metadata = path.lstat() + require(not path.is_symlink() and stat.S_ISREG(metadata.st_mode) and metadata.st_nlink == 1, 'existing state identity') + out['files'][name] = [metadata.st_dev, metadata.st_ino, metadata.st_uid, metadata.st_gid, metadata.st_mode] + return out + + require(os.geteuid() == 0 and os.uname().machine == 'x86_64', 'fixed Cloud Linux root contract fixtures') + ident = str(uuid.UUID(p['id'])); require(ident == p['id'], 'canonical original case') + folder = Path('/var/tmp') / ('rmm-windows-clock-guards-linux-' + ident) + if p['action'] == 'read': + metadata = folder.lstat() + require(stat.S_ISDIR(metadata.st_mode) and not folder.is_symlink() and metadata.st_uid == 0 + and stat.S_IMODE(metadata.st_mode) == 0o700, 'own original case only') + result = folder / 'result.json' + return {'read_only': True, 'id': ident, 'entered': (folder / 'entered.json').exists(), + 'result': json.loads(result.read_bytes()) if result.exists() else None, 'current_witness': witness()} + require(p['action'] == 'execute', 'one fixed time contract action') + os.umask(0o077); folder.mkdir(mode=0o700) + create(folder / 'intent.json', enc({key: value for key, value in p.items() if key != 'binary_b64'})) + require(len(p['binary_b64']) == 4499436, 'bounded binary transfer') + raw = base64.b64decode(p['binary_b64'], validate=True) + require(len(raw) == 3374576 and hashlib.sha256(raw).hexdigest() == p['binary_sha256'], 'fixed three-guard library binary') + binary = folder / 'windows-clock-guard-tests'; create(binary, raw, 0o700) + before = witness(); create(folder / 'before.json', enc(before)) + command = ['/usr/bin/setpriv', '--reuid=0', '--regid=0', '--clear-groups', '--no-new-privs', str(binary)] + code, stdout, stderr = run(command + ['--list', '--format', 'terse']) + create(folder / 'list.stdout', stdout); create(folder / 'list.stderr', stderr) + require(code == 0 and stderr == b'', 'native list succeeded') + lines = stdout.decode().splitlines() + require(len(lines) == 13 and sorted(line[:-6] for line in lines if line.endswith(': test')) == p['all_listed_tests'], 'exact full thirteen-test list before three targeted tests') + create(folder / 'entered.json', enc({'id': ident, 'run_once': True, 'time_ns': time.time_ns()})) + code, stdout, stderr = run(command + ['signed_clock::tests::', '--test-threads=1', '--nocapture']) + create(folder / 'run.stdout', stdout); create(folder / 'run.stderr', stderr) + after = witness(); create(folder / 'after.json', enc(after)) + require(before == after and code == 0 and stderr == b'' + and b'3 passed; 0 failed; 0 ignored; 0 measured; 10 filtered out' in stdout + and all((b'test ' + name.encode() + b' ... ok') in stdout for name in p['tests']), 'three native guards with ten filtered and retained target state') + receipt = dict(id=ident, profile=p['profile'], passed=3, ignored=0, filtered=10, listed=13, execution_uid=0, tests=p['tests'], + before=before, after=after, binary_sha256=p['binary_sha256'], source_receipt_sha256=p['receipt_sha256'], + source_manifest_sha256=p['manifest_sha256'], stdout_sha256=hashlib.sha256(stdout).hexdigest(), + no_rmm_jobs=True, no_apply=True, no_service_control=True) + create(folder / 'result.json', enc(receipt)); return receipt + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('action', choices=('prepare', 'execute', 'read')); parser.add_argument('--case') + args = parser.parse_args(); os.umask(0o077) + STATE.mkdir(mode=0o700, parents=True, exist_ok=True); support.private(STATE, True) + if args.action == 'prepare': + support.require(args.case is None, 'prepare one new local case') + receipt_path = QUALIFICATION / 'receipt.json'; support.private(receipt_path) + support.require(sha(receipt_path.read_bytes()) == RECEIPT_SHA, 'independently reviewed source receipt') + receipt = support.load(receipt_path); original = support.load(QUALIFICATION / 'inputs.json') + support.require(sha((QUALIFICATION / 'inputs.json').read_bytes()) == INPUTS_SHA + and receipt['inputs_sha256'] == INPUTS_SHA and len(original) == 184 + and receipt['kind'] == 'windows-signed-clock-source-qualification-v2' + and receipt['all_source_inputs_preserved'] is True + and receipt['independent_review']['source_sha256'] == '6b66612b7a53377c91bc8e41864ac8fb9393ad40b0a6a98aa6ce746fce091ddb' + and next(x for x in receipt['results'] if x['name'] == 'linux-three-targeted') == dict(name='linux-three-targeted',exit_code=0,passed=3,failed=0,ignored=0,filtered_other_crate_tests=10,tests=TESTS), 'reviewed three-guard qualification') + ident = str(uuid.uuid4()); folder = STATE / ident; folder.mkdir(mode=0o700) + copy_exact(receipt_path, folder / 'receipt.json', RECEIPT_SHA, receipt_path.stat().st_size) + copy_exact(QUALIFICATION / 'inputs.json', folder / 'inputs.json', INPUTS_SHA, (QUALIFICATION / 'inputs.json').stat().st_size) + paths = set() + for item in original: + path = Path(item['path']) + support.require(not path.is_absolute() and '..' not in path.parts and str(path) not in paths, 'unique fixed frozen input') + paths.add(str(path)); copy_exact(QUALIFICATION / 'source' / path, folder / 'source' / path, item['sha256'], item['bytes']) + binary = QUALIFICATION / 'qualified-linux-tests' + support.require(receipt['artifacts'][0] == dict(name='qualified-linux-tests', platform='linux', bytes=BINARY_BYTES, sha256=BINARY_SHA), 'fixed original linked artifact') + copy_exact(binary, folder / 'windows-clock-guard-tests', BINARY_SHA, BINARY_BYTES) + transports = {path: sha((ROOT / path).read_bytes()) for path in ('deploy/windows_msi_runtime_acceptance.py', 'deploy/vm_access_check.py')} + save_local(folder / 'manifest.json', dict(id=ident, profile=PROFILE, runner_sha256=sha(Path(__file__).read_bytes()), + receipt_sha256=RECEIPT_SHA, binary_sha256=BINARY_SHA, binary_bytes=BINARY_BYTES, + source_files=original, tests=TESTS, all_listed_tests=ALL_TESTS, transport_sources=transports)) + verify_case(folder) + print(json.dumps({'id': ident, 'prepared_locally': True})); return + support.require(args.case is not None, 'original --case required') + ident = str(uuid.UUID(args.case)); support.require(ident == args.case, 'same canonical original case') + folder = STATE / ident; support.private(folder, True); verify_case(folder) + payload = dict(id=ident, action=args.action, profile=PROFILE, tests=TESTS, all_listed_tests=ALL_TESTS, binary_sha256=BINARY_SHA, + receipt_sha256=RECEIPT_SHA, manifest_sha256=sha((folder / 'manifest.json').read_bytes()), + agent_sha256=AGENT_SHA, helper_sha256=HELPER_SHA) + if args.action == 'execute': + save_local(folder / 'execute-entered.json', {'once': True, 'no_retry': True}) + payload['binary_b64'] = base64.b64encode((folder / 'windows-clock-guard-tests').read_bytes()).decode() + code = 'import json\n' + inspect.getsource(remote) + '\nprint(json.dumps(remote(' + repr(payload) + ')))\n' + response = support.transport(support.access_settings(ACCESS_ROOT, 'linux'), 'python3 -', code.encode(), folder) + save_local(folder / (args.action + '-' + str(uuid.uuid4()) + '.json'), response) + if args.action == 'read' and response['result'] is not None: + support.require(response['result']['source_manifest_sha256'] == sha((folder / 'manifest.json').read_bytes()) + and response['current_witness'] == response['result']['after'], 'same-case retained native result') + print(json.dumps({'id': ident, 'action': args.action, 'passed': response.get('passed'), + 'complete': response.get('result') is not None if args.action == 'read' else True, 'read_only': args.action == 'read'})) + + +if __name__ == '__main__': + main() diff --git a/docs/handover.md b/docs/handover.md index 2ed65a0..31d95b7 100644 --- a/docs/handover.md +++ b/docs/handover.md @@ -1,5 +1,13 @@ # Übergabe — Linux-MVP abgeschlossen, Windows wird fortgesetzt +**Windows-Zeitguards Linux-first bestanden:** Originalfall6ea36dec, +volle13er-Liste geprüft, ausschließlich neue3Tests bestanden/10andere bewusst +gefiltert; separater Readback vollständig, bekannte Runtimezeugen erhalten. +Geschütztes Verifiermodul6b66612b unabhängig geprüft und lokal Windowsgelinkt; +[Nachweise und Grenzen](windows-signed-clock-source.md). +Keine Windowszeit-/Jobbereitschaft; Rohcapturequalifikation folgt separat. + + **Aktueller Zeitcodec-Endpunkt nativ geprüft:** Die Audiencekorrektur auf /agent/v1/time-attestation hat einen eigenen Linuxfall a22de8d2 mit4/4 und separatem vollständigem Readback; Originalfall2b282376 unverändert. diff --git a/docs/windows-signed-clock-source.md b/docs/windows-signed-clock-source.md new file mode 100644 index 0000000..eba06c2 --- /dev/null +++ b/docs/windows-signed-clock-source.md @@ -0,0 +1,214 @@ +# Windows: unabhängiger signierter Zeitvergleich, erster Quellenschnitt + +Stand2026-11-14, Spezifikation1.22. Der User hat diese alternative Trustsource +ausdrücklich angenommen; [Vertrag](windows-clock-attestation-proposal.md). +Dieser Schnitt implementiert den unabhängigen Windows-Verifier. Er ersetzt +noch keinen laufenden Agent/Helper und öffnet keine Windows-Jobfähigkeit. + +`crates/agent-windows/src/signed_clock.rs` ist additiv registriert. Sein +installierter Adapter wird ausschließlich unter Windows mit dem vorhandenen +`system-helper`-Feature gebaut; die zwei plattformneutralen Guardtests laufen +auch unter Linux. Die bestehende RPC-Clock und `ADAPTER_QUALIFIED=false` bleiben +unverändert. Kein neuer `SyncClock`, Cache, Netzwerkclient oder Jobpfad. + +## Tatsächliche Bindung und enge API + +Agent und SYSTEM-Helper öffnen jeweils selbst die geschützte bestehende +Helperkonfiguration, prüfen ihre tatsächliche eigene SCM-Prozessgeneration, +Token-/Dienstrolle und gehaltene Imageidentität mit dem vorhandenen PeerProof. +Ein Agent kann die Helperrolle dadurch nicht nur im Request behaupten. +Die vorhandene feste lesende CIM-Bootabfrage läuft unabhängig in jedem Prozess +vor Beginn der Challenge. Ihre potenziell längere Laufzeit wird nicht aus einem +bereits laufenden Einsekundenbudget versteckt. + +Der zusätzliche feste öffentliche Pinpfad ist +`C:\ProgramData\RustDiscoverySystem\time-attestation.json`, maximal16KiB. +Seine Datei und das geschützte Elternverzeichnis werden mit bestehenden +PinnedFiles und restriktiven ACL-/File-ID-/Reparseprüfungen gehalten. +Alle ursprünglichen Helperkonfigurationshandles bleiben ebenfalls erhalten. +Der Pin bindet die exakte bestehende Gerätebindung, Serverinstanz, Zeitkey- +Generation, bis zu acht Publickeys und genau eine Kalibrierungsreferenz je +Agent-/Helperimage. Nur SYSTEM/Administrators schreiben; die beiden +Dienst-SIDs dürfen lesen. Keine Keys aus einer Serverantwort oder Workerdatei. + +Ein anschließender enger Sourcefix verweigert zusätzlich jeden Zeitpublickey, +der nach tatsächlicher Hexdekodierung dem vorhandenen Jobpublickey entspricht. +Abweichende Groß-/Kleinschreibung umgeht die Rollentrennung nicht. Eine neue +gezielte Negativprobe prüft diesen Fall. Dieser Fix ist noch nicht Teil des +unten erhaltenen180-Input-Belegs; seine neue kohärente Qualifikation folgt nach +dem neuen gemeinsamen Agentpfad-/Linuxnachweis im184-Input-Nachtrag unten. + +Die Kalibrierung muss die tatsächliche Binary per SHA256 und einen separat +gewonnenen Qualifikationsbeleg binden. Das positive Grundfehlerbudget liegt +höchstens10ms je Capture. Dies ist **keine gemessene Genauigkeit**: Aktuell +existiert aus diesem Schritt kein bereitgestellter Pin oder Kalibrierungsbeleg. +Ein solches JSON darf nicht mit geratenen Werten als qualifiziert installiert +werden. Der dauerhafte monotone Konfigurationsweg über Prozessneustarts bleibt +vor Runtimeaktivierung gesondert zu provisionieren. Der Loader selbst sperrt +innerhalb desselben Prozesses niedrigere Generationen und unterschiedliche +Rawbytes bei gleicher Generation; er erzeugt kein neues Floorjournal. + +Eine zufällige Prozessinkarnation sowie ein prozessweit gehaltener Continuity- +Head bleiben unabhängig von Objektkonstruktoren erhalten. Höchstens eine +Challenge ist pro Prozess offen. Bootwechsel, rückwärts laufende Zähler, +Wallstep oder Schlafdifferenz über1s verwerfen sie. Überlauf erschöpft den Head +dauerhaft; ein weiterer Aufruf öffnet ihn nicht wieder. Erst eine neu erzeugte +Challenge nach einer beobachteten Diskontinuität ist verwendbar. + +Im anschließenden Reviewfix hält derselbe globale Head auch die höchste +Verbindungsgeneration: Ein neues Adapterobjekt mit höherer Generation +invalidiert alte offene Challenges, alte Objekte können keine neue Anfrage +unter ihrer niedrigeren Generation eröffnen. Ein Generationwechsel am +vorhandenen `begin` schließt dessen eigene alte Anfrage. Die gezielte +Continuityprobe ergänzt diese Negativfälle; auch dieser Fix gehört zum +folgenden neuen Quellenbeleg, nicht zum ursprünglichen180-Input-Snapshot. + +Der native Capture umfasst präzise Interruptzeit, Unbiasedzeit, Wallclock, +nochmals Unbiasedzeit und Interruptzeit. Beide präzisen Interruptgetter sind +gemäß Microsoft **VOID**-APIs; kein fingierter BOOL-Erfolg und keine optionale +Fallbackquelle. Zeitwerte sind100ns-Einheiten. Der gesamte gemessene Bracket +wird zusätzlich zum ausdrücklich qualifizierten Grundfehler konservativ +berechnet. Auflösung wird nicht mit Genauigkeit gleichgesetzt. +[Präzise Unbiasedzeit](https://learn.microsoft.com/en-us/windows/win32/api/realtimeapiset/nf-realtimeapiset-queryunbiasedinterrupttimeprecise), +[präzise Interruptzeit](https://learn.microsoft.com/en-us/windows/win32/api/realtimeapiset/nf-realtimeapiset-queryinterrupttimeprecise). + +`begin` liefert ausschließlich den gebundenen Transportrequest und hält die +opaque Challenge selbst. `complete(bytes, callback)` nimmt nur begrenzte +Antwortbytes entgegen, keine fremden Zeiten. Der Adapter erfasst Empfang +selbst vor dem JSON-Decode und die Schlussmessung nach der vollständigen +Signaturprüfung. Der gemeinsame Codec prüft Signatur, Originalrequest und +Kontext, vollen RTT,100ms-Empfangsalter und die ganze UTCspanne. Am Ende müssen +auch prozessweiter Owner und Epoch noch identisch sein. + +Nur der unmittelbar aufgerufene Callback erhält eine geliehene Comparison mit +der geprüften Spanne und der tatsächlich selbst beobachteten Windows-Wallclock. +Keine gespeicherte Comparison, kein Midpoint als angebliche lokale Uhr, keine +automatische neue Challenge nach einem Fehler. Abschluss/Abbruch konsumiert die +ursprüngliche Anfrage. Runtimeintegration muss diese API an ihre tatsächlichen +Start-/Syncgrenzen binden; sie wird hier nicht durch einen scalar `now()`-Stub +vorgetäuscht. Die bestehenden zusätzlichen Job-/WebUI-/Ledgergates bleiben nötig. + +## Tatsächlich lokal geprüft + +Eingefrorener Sourcefall30bb330a-d285-4d15-ab8d-8ce36a760524,180 Inputs; +Inputmanifest SHA256 +`7f56d21680a1345f514ac98fd187a3bea376414215ba1d5773f682690a8ae214`. +Windowsmodul SHA256 +`f1fed304ebda3f48f38aba38f8ad5e1811c566abd740dffce318f4b07beac3ca`. +Receipt SHA256 +`ad5e35ac1c63f0cbc8e3559c338b183ca5793e7219543a9f43794cc75542402b`. +Der vollständige private Snapshot und Logs bleiben unter gitignoriertem +`devstate/windows-signed-clock/qualification-30bb330a-d285-4d15-ab8d-8ce36a760524/`. + +Tatsächlich bestanden, ausschließlich Offline-Docker auf dem Entwicklungsrechner: + +- Zwei gezielte Linux-Guardtests: Bracketbudget/Counterfehler sowie erhaltener + Prozessfence, Bootsubstitution, Generation/Fork und erschöpfter Epochcounter. + 2bestanden,0failed/ignored;10 übrige Cratetests ausdrücklich herausgefiltert. +- Windows-GNU-Alltargetscheck sowie Clippy mit `-D warnings` für den + `system-helper`-Build. Erster Clippylauf verweigerte drei verschachtelte + if-Blöcke; diese wurden ohne Unterdrückung korrigiert und erneut geprüft. +- Windows-Lib-Testbinary tatsächlich gelinkt,75326709Byte, SHA256 + `29c037f6ca13fc91806312a16dde0923fcaa1d5a0d16d057362bf112f3875da6`. + **Nicht auf Windows ausgeführt**, kein nativer Testcount daraus abgeleitet. +- Formatcheck ausschließlich der neuen Moduldatei bestanden. + +Die relevanten Cargoaufrufe benutzen `--locked --offline`; Linux-Testfilter +`signed_clock::tests`, Windows `--target x86_64-pc-windows-gnu --features +system-helper --all-targets`. Das Linken verwendet `test --lib --no-run`. +Der eingefrorene gemeinsame Codec enthält zu diesem Zeitpunkt noch die alte +`/api/agent/v1/time-attestation`-Audience. Der geplante korrekte Agentpfad +`/agent/v1/time-attestation` benötigt einen neuen gemeinsamen Quellenbeleg; +dieser ursprüngliche Snapshot wird dafür nicht verändert. + +## Offene reale Nachweise + +Keine Cloud-Linux-Ausführung dieser beiden neuen Guardtests und keine native +Windowsausführung in diesem Schritt. Keine tatsächliche Timerkalibrierung, +Pinprovisionierung, Serverantwort im echten Geräte-mTLS-Kontext oder parallele +Agent-/SYSTEM-Roundtrips. Keine Runtime-/IPC-/HTTP-Anbindung und keine Wirkung. +Der Servercodec besitzt eigene getrennte Nachweise; diese qualifizieren nicht +automatisch den Windowsadapter. Zuerst Linux-first, dann unabhängig auf dem +Windowsgast prüfen. Erst danach kann eine gesonderte WebUI-genehmigte +Windows-Skript-/SYSTEM-Abnahme folgen. W32Time-Konfiguration, Dienste, +Geräteidentitäten, PKI und Journale wurden durch diese lokale Arbeit nicht +angefasst. + +## Aktueller kohärenter Nachtrag nach URI- und Reviewfix + +Der neue separate Fall763baf69-10b1-4307-9c99-6942c0f8945f bindet184 Inputs +einschließlich des gemeinsamen Codecs mit der korrigierten Audience +`/agent/v1/time-attestation`. Der ursprüngliche180-Input-Snapshot bleibt +unverändert. Der unabhängige Source-Review von updater_review meldete für das +aktuelle Windowsmodul PASS; dies ist ausdrücklich kein nativer Rollennachweis. + +Aktuelles Modul SHA256 +`6b66612b7a53377c91bc8e41864ac8fb9393ad40b0a6a98aa6ce746fce091ddb`, +Inputmanifest SHA256 +`eb4609c5fca6a32ddb8ebf364775efdb59cd89f99a24b3b731212da08eac6a6e`, +Receipt SHA256 +`e013738caed2d8e02b98ffd1b41e47a80840c44d3dbf895e9a3952b4311ce927`. +Private Belege: +`devstate/windows-signed-clock/qualification-763baf69-10b1-4307-9c99-6942c0f8945f/`. + +Tatsächlich lokal auf den eingefrorenen Bytes bestanden: + +- Release-Linux-Testbinary gebaut und dessen vollständige Liste von13 Tests + und0 Benchmarks geprüft. Nur die drei neuen `signed_clock::tests` ausgeführt: + **3bestanden,0failed/ignored,10 übrige Tests ausdrücklich herausgefiltert**. + Hinzugekommen ist die konkrete Job-/Zeitkey-Rollentrennung auch bei anderer + Hexschreibweise; der Fencetest prüft nun auch den Connectionhead. +- Windows-GNU-Alltargetscheck und Alltargets-Clippy mit `-D warnings` bestanden. +- Windows-Lib-Testbinary aus genau denselben184 Inputs tatsächlich gelinkt. +- Formatcheck der neuen Moduldatei bestanden; keine Unterdrückungen ergänzt. + +Der erste Windows-Linkversuch dieses Falls scheiterte ausschließlich lokal am +Schreibschutz der früher qualifizierten Testexe im wiederverwendeten Target. +Der frühere Pfad und SHA29c037f6 blieben erhalten. Der unveränderte neue +Sourcesnapshot wurde danach in einem neuen eigenen Windowstarget erfolgreich +gelinkt; der ursprüngliche Fehlerbericht bleibt101 und wird nicht überschrieben. +Keine Lockerung des Readers oder der alten Artefaktrechte. + +Die qualifizierte neue Linuxexe hat3374576Byte, SHA256 +`0896a3098f493b67b48e774de5cfe9bca682d2a19ff10971c62c9c7b9681ec14`. +Der Native-Operator muss zunächst exakt die vollständige13er-Liste verlangen +und anschließend ausschließlich die drei neuen Namen auswählen; kein erneutes +Ausführen der zehn alten Fälle oder Verschweigen ihrer Filterung. Dies ist der +vorbereitete Linux-first-Nachweis, **hier durch diesen Worker nicht auf der +Cloud-VM ausgeführt**. + +Die neue Windows-Testexe hat75360791Byte, SHA256 +`3421368eff990d197889da58aa09463e00eff40e1cfebfcfdf1e9b9382e10f03`. +Sie wurde hier nicht auf Windows ausgeführt. Bauen, Linken und Source-Review +eröffnen weiterhin keine Capability. Sämtliche zuvor genannten tatsächlichen +Timer-, Rollen-, Provisionierungs-, Transport- und Runtimegates bleiben offen. + + +## Tatsächlicher Linux-first-Nachweis der drei Guards + +Root führte den unabhängig geprüften Runner +`deploy/windows_signed_clock_linux_acceptance.py`, SHA256 +`70b029a441d27814f646a75cfb69ff9e5af356776027a7f836a252964a29aafd`, +im Originalfall `6ea36dec-254e-4a82-8d1c-c72a1f959ed2` auf der Cloud-Linux-VM +aus: **3bestanden,0ignored,10andere Tests gefiltert, Exit0**. +Die vollständige13er-Liste musste zuvor exakt stimmen. Separater lesender +Originalfall-Readback vollständig; bekannte drei RMM-Prozessgenerationen, +Kontrollbytes, Boot und DB-/Lock-Dateiidentitäten erhalten. Kein RMM-Job, +Produktzeitquery oder Dienststeuerung; Full weiter Autostart disabled. + +Tatsächlich prepare, einmal execute und read mit obigem Originalfall ausgeführt. +FallmanifestSHA256 +`cc83d7bc455dfaa2e0c7b0305b5713452a74ad0b60730c6058132a761aa5f157`; +ExecuteSHA256 +`0a86c11133bce801c86d3af8bd7e1eadfeacdf49456f4ae17291e7281b8ade1f`; +ReadbackSHA256 +`81138562175bf71bc14c0f5cf9ddc37b434c8d7751196b12c90140db5c29e9f1`. +Private184Inputs und ursprüngliche Qualifikationsbelege bleiben unverändert. + +Der veröffentlichte erste Modulstand entspricht exakt6b66612b. Die +`lib.rs`-Modulregistrierung wurde danach ausschließlich alphabetisch gemäß +rustfmt geordnet; die ursprünglichen Compilerinputs werden dadurch nicht +nachträglich geändert. Kein erneuter Semantiktest für diese reine Formatierung. +Nachfolgende Rohcapture-/Runtimeänderungen sind eigene Quellenstände und +werden durch diesen nativen Dreierbeleg nicht mitqualifiziert. Native Windows- +Timer und tatsächliche Zeitquelle bleiben weiter offen; Legacyclock bleibt zu.