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
+1
View File
@@ -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;
+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());
}
}
@@ -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()
+8
View File
@@ -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.
+214
View File
@@ -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.