From 2dfd791aa5703f42f0258d17bc9b5f6c9d71337f Mon Sep 17 00:00:00 2001 From: Kevin Janssen Date: Sun, 15 Nov 2026 00:45:05 +0100 Subject: [PATCH] Add isolated time broker and raw Windows capture with Linux evidence --- Cargo.lock | 16 + Cargo.toml | 2 +- .../examples/signed_clock_capture.rs | 343 ++++++++ crates/agent-windows/src/signed_clock.rs | 305 ++++++- crates/server/Cargo.toml | 2 + crates/server/src/agent_time.rs | 159 ++++ crates/server/src/main.rs | 2 + crates/time-broker-linux/Cargo.toml | 16 + crates/time-broker-linux/src/lib.rs | 10 + crates/time-broker-linux/src/main.rs | 12 + crates/time-broker-linux/src/native.rs | 752 ++++++++++++++++++ deploy/windows_raw_clock_linux_acceptance.py | 314 ++++++++ docs/handover.md | 9 + docs/server-time-broker.md | 166 ++++ docs/windows-signed-clock-capture.md | 197 +++++ 15 files changed, 2275 insertions(+), 30 deletions(-) create mode 100644 crates/agent-windows/examples/signed_clock_capture.rs create mode 100644 crates/server/src/agent_time.rs create mode 100644 crates/time-broker-linux/Cargo.toml create mode 100644 crates/time-broker-linux/src/lib.rs create mode 100644 crates/time-broker-linux/src/main.rs create mode 100644 crates/time-broker-linux/src/native.rs create mode 100644 deploy/windows_raw_clock_linux_acceptance.py create mode 100644 docs/server-time-broker.md create mode 100644 docs/windows-signed-clock-capture.md diff --git a/Cargo.lock b/Cargo.lock index bb67ec4..80fec54 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2357,6 +2357,7 @@ dependencies = [ "rmm-oidc-auth", "rmm-persistence", "rmm-protocol", + "rmm-time-attestation", "rmm-updater", "rmm-updater-handoff", "rustls", @@ -2388,6 +2389,21 @@ dependencies = [ "uuid", ] +[[package]] +name = "rmm-time-broker-linux" +version = "0.1.0" +dependencies = [ + "anyhow", + "ed25519-dalek", + "hex", + "libc", + "rmm-time-attestation", + "rmm-time-source-linux", + "serde", + "serde_json", + "uuid", +] + [[package]] name = "rmm-time-source-linux" version = "0.1.0" diff --git a/Cargo.toml b/Cargo.toml index 43d0b3b..fdae001 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,7 +1,7 @@ [workspace] resolver = "2" exclude = ["crates/oidc-auth"] -members = ["crates/domain", "crates/protocol", "crates/persistence", "crates/server", "crates/agent-linux", "crates/agent-core", "crates/agent-windows", "crates/agent", "crates/privileged-helper", "crates/updater", "crates/updater-handoff", "crates/updater-linux", "crates/updater-worker", "crates/time-attestation", "crates/time-source-linux"] +members = ["crates/domain", "crates/protocol", "crates/persistence", "crates/server", "crates/agent-linux", "crates/agent-core", "crates/agent-windows", "crates/agent", "crates/privileged-helper", "crates/updater", "crates/updater-handoff", "crates/updater-linux", "crates/updater-worker", "crates/time-attestation", "crates/time-source-linux", "crates/time-broker-linux"] [workspace.package] version = "0.1.0" diff --git a/crates/agent-windows/examples/signed_clock_capture.rs b/crates/agent-windows/examples/signed_clock_capture.rs new file mode 100644 index 0000000..e7d343d --- /dev/null +++ b/crates/agent-windows/examples/signed_clock_capture.rs @@ -0,0 +1,343 @@ +//! Fixed, temporary SCM capture probe. It never installs a service or opens an +//! RMM store, key/pin, network endpoint, W32Time, job or clock setter. +#[cfg(all(windows, feature = "system-helper"))] +mod probe { + use anyhow::{Context, Result, ensure}; + use rmm_agent_windows::{helper_ipc as ipc, signed_clock}; + use rmm_domain::jobs::hash; + use serde::Serialize; + use std::{ + fs::OpenOptions, + io::Write, + mem::{size_of, zeroed}, + os::windows::{ + fs::OpenOptionsExt, + io::{AsRawHandle, FromRawHandle, OwnedHandle}, + }, + path::{Path, PathBuf}, + ptr, + sync::{ + OnceLock, + atomic::{AtomicUsize, Ordering}, + }, + }; + use windows_sys::Win32::{ + Foundation::*, + Security::*, + Storage::FileSystem::*, + System::{Services::*, Threading::*}, + }; + const BASE: &str = r"C:\ProgramData\RustDiscoverySignedClockCapture"; + const LS: &str = "RmmSignedClockCaptureLocalService"; + const SYSTEM: &str = "RmmSignedClockCaptureSystem"; + static CASE: OnceLock = OnceLock::new(); + static ROLE: OnceLock = OnceLock::new(); + static STATUS: AtomicUsize = AtomicUsize::new(0); + static STAGE: AtomicUsize = AtomicUsize::new(0); + #[derive(Clone, Copy)] + enum Role { + LocalService, + System, + } + impl Role { + fn name(self) -> &'static str { + match self { + Self::LocalService => LS, + Self::System => SYSTEM, + } + } + fn tag(self) -> &'static str { + match self { + Self::LocalService => "local-service", + Self::System => "system", + } + } + fn user(self) -> &'static str { + match self { + Self::LocalService => "S-1-5-19", + Self::System => "S-1-5-18", + } + } + } + fn wide(value: &str) -> Vec { + value.encode_utf16().chain(Some(0)).collect() + } + fn owned(value: HANDLE) -> Result { + ensure!( + !value.is_null() && value != INVALID_HANDLE_VALUE, + "CAPTURE_NATIVE_HANDLE" + ); + // SAFETY: only uniquely owned handles returned by successful APIs enter. + Ok(unsafe { OwnedHandle::from_raw_handle(value) }) + } + #[derive(Serialize)] + struct TokenReport { + user_sid: &'static str, + service_sid_sha256: String, + elevation_flag: u32, + elevation_type: i32, + } + fn token(role: Role) -> Result { + let mut thread = ptr::null_mut(); + // SAFETY: valid output pointer, query only, no impersonation is created. + if unsafe { OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, 1, &mut thread) } != 0 { + let _thread = owned(thread)?; + anyhow::bail!("CAPTURE_IMPERSONATION_FORBIDDEN"); + } + ensure!( + unsafe { GetLastError() } == ERROR_NO_TOKEN, + "CAPTURE_THREAD_TOKEN" + ); + let mut raw = ptr::null_mut(); + ensure!( + unsafe { OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &mut raw) } != 0, + "CAPTURE_PROCESS_TOKEN" + ); + let handle = owned(raw)?; + let sid = ipc::service_sid(role.name())?; + ipc::verify_token(handle.as_raw_handle(), role.user(), &sid)?; + let mut elevation: TOKEN_ELEVATION = unsafe { zeroed() }; + let mut count = 0; + ensure!( + unsafe { + GetTokenInformation( + handle.as_raw_handle(), + TokenElevation, + ptr::addr_of_mut!(elevation).cast(), + size_of::() as u32, + &mut count, + ) + } != 0 + && count as usize == size_of::(), + "CAPTURE_ELEVATION" + ); + let mut kind: TOKEN_ELEVATION_TYPE = 0; + ensure!( + unsafe { + GetTokenInformation( + handle.as_raw_handle(), + TokenElevationType, + ptr::addr_of_mut!(kind).cast(), + size_of::() as u32, + &mut count, + ) + } != 0 + && count as usize == size_of::() + && (1..=3).contains(&kind), + "CAPTURE_ELEVATION_TYPE" + ); + Ok(TokenReport { + user_sid: role.user(), + service_sid_sha256: hash(sid.as_bytes()), + elevation_flag: elevation.TokenIsElevated, + elevation_type: kind, + }) + } + fn create(path: &Path, bytes: &[u8]) -> Result<()> { + ensure!(bytes.len() <= 16384, "CAPTURE_REPORT_LIMIT"); + let mut file = OpenOptions::new() + .write(true) + .create_new(true) + .share_mode(FILE_SHARE_READ) + .custom_flags(FILE_FLAG_OPEN_REPARSE_POINT) + .open(path)?; + let mut info: BY_HANDLE_FILE_INFORMATION = unsafe { zeroed() }; + ensure!( + unsafe { GetFileInformationByHandle(file.as_raw_handle(), &mut info) } != 0 + && info.dwFileAttributes + & (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT) + == 0 + && info.nNumberOfLinks == 1, + "CAPTURE_NEW_FILE_IDENTITY" + ); + file.write_all(bytes)?; + file.sync_all()?; + Ok(()) + } + fn execute() -> Result<()> { + let role = *ROLE.get().context("CAPTURE_ROLE")?; + let case = *CASE.get().context("CAPTURE_CASE")?; + STAGE.store(10, Ordering::SeqCst); + let token = token(role)?; + let role_sid = ipc::service_sid(role.name())?; + // Both fixed fixture SIDs may read the common case directory. Only the + // selected fixture SID may write its own role subdirectory. + let readers = vec![ipc::service_sid(LS)?, ipc::service_sid(SYSTEM)?]; + let root = PathBuf::from(BASE); + let case_root = root.join(case.to_string()); + let output = case_root.join(role.tag()); + let image_path = case_root.join("SignedClockCapture.exe"); + ensure!( + std::env::current_exe()? == image_path, + "CAPTURE_FIXED_IMAGE_PATH" + ); + let mut held = vec![ + ipc::PinnedFile::open(&root, true, &readers, &[], false)?, + ipc::PinnedFile::open(&case_root, true, &readers, &[], false)?, + ipc::PinnedFile::open(&output, true, &readers, &[role_sid], false)?, + ]; + let mut image = ipc::PinnedFile::open(&image_path, false, &readers, &[], false)?; + let image_sha256 = image.sha256()?; + let image_file = image.identity; + held.push(image); + for name in ["intent.json", "report.json", "end.json"] { + ensure!(!output.join(name).exists(), "CAPTURE_CASE_ALREADY_ENTERED"); + } + let pid = unsafe { GetCurrentProcessId() }; + let (mut born, mut ended, mut kernel, mut user) = ( + unsafe { zeroed() }, + unsafe { zeroed() }, + unsafe { zeroed() }, + unsafe { zeroed() }, + ); + ensure!( + unsafe { + GetProcessTimes( + GetCurrentProcess(), + &mut born, + &mut ended, + &mut kernel, + &mut user, + ) + } != 0, + "CAPTURE_PROCESS_BIRTH" + ); + let born = (u64::from(born.dwHighDateTime) << 32) | u64::from(born.dwLowDateTime); + STAGE.store(20, Ordering::SeqCst); + // Fixed existing read-only CIM boot getter, BEFORE the 250ms sampling + // budget; never a caller script or a substitute process-start identity. + let runtime = tokio::runtime::Builder::new_current_thread() + .enable_all() + .build()?; + let boot = uuid::Uuid::parse_str(&runtime.block_on(rmm_agent_windows::native::boot_id())?)?; + ensure!( + !boot.is_nil() && born > 0 && pid > 0, + "CAPTURE_NATIVE_IDENTITY" + ); + create( + &output.join("intent.json"), + &serde_json::to_vec( + &serde_json::json!({"schema_version":1,"case_id":case,"role":role.tag(),"pid":pid,"process_birth_filetime":born,"image_sha256":image_sha256,"boot_id":boot,"calibrated":false,"clock_authority":false,"no_repeat":true,"maximum_samples":128,"maximum_capture_ns":250000000}), + )?, + )?; + STAGE.store(30, Ordering::SeqCst); + let result = (|| { + let captures = signed_clock::diagnostic_capture_series()?; + STAGE.store(40, Ordering::SeqCst); + let current_token = token_role_recheck(role, &token)?; + for file in &mut held { + file.check()?; + } + let report = serde_json::to_vec( + &serde_json::json!({"schema_version":1,"case_id":case,"role":role.tag(),"calibrated":false,"clock_authority":false,"read_only_clock":true,"token":current_token,"pid":pid,"process_birth_filetime":born,"image_sha256":image_sha256,"image_file":image_file,"boot_id":boot,"capture":captures}), + )?; + ensure!(report.len() <= 16384, "CAPTURE_REPORT_LIMIT"); + create(&output.join("report.json"), &report)?; + Ok::<_, anyhow::Error>(hash(&report)) + })(); + let end = serde_json::to_vec( + &serde_json::json!({"schema_version":1,"case_id":case,"role":role.tag(),"success":result.is_ok(),"stage":STAGE.load(Ordering::SeqCst),"report_sha256":result.as_ref().ok(),"calibrated":false,"clock_authority":false,"no_repeat":true}), + )?; + create(&output.join("end.json"), &end)?; + result?; + STAGE.store(50, Ordering::SeqCst); + Ok(()) + } + fn token_role_recheck(role: Role, original: &TokenReport) -> Result { + let current = token(role)?; + ensure!( + serde_json::to_vec(¤t)? == serde_json::to_vec(original)?, + "CAPTURE_TOKEN_CHANGED" + ); + Ok(current) + } + fn status(state: u32, error: u32) { + let handle = STATUS.load(Ordering::SeqCst) as SERVICE_STATUS_HANDLE; + if handle.is_null() { + return; + } + let value = SERVICE_STATUS { + dwServiceType: SERVICE_WIN32_OWN_PROCESS, + dwCurrentState: state, + dwControlsAccepted: 0, + dwWin32ExitCode: error, + dwServiceSpecificExitCode: if error == 1066 { + STAGE.load(Ordering::SeqCst) as u32 + } else { + 0 + }, + dwCheckPoint: 0, + dwWaitHint: 10000, + }; + // SAFETY: this handle is returned by SCM for this own temporary service. + unsafe { SetServiceStatus(handle, &value) }; + } + unsafe extern "system" fn control( + _: u32, + _: u32, + _: *mut std::ffi::c_void, + _: *mut std::ffi::c_void, + ) -> u32 { + 0 + } + unsafe extern "system" fn service_main(_: u32, _: *mut *mut u16) { + let Some(role) = ROLE.get().copied() else { + return; + }; + let name = wide(role.name()); + let handle = + unsafe { RegisterServiceCtrlHandlerExW(name.as_ptr(), Some(control), ptr::null_mut()) }; + if handle.is_null() { + return; + } + STATUS.store(handle as usize, Ordering::SeqCst); + status(SERVICE_RUNNING, 0); + let result = execute(); + status(SERVICE_STOPPED, if result.is_ok() { 0 } else { 1066 }); + } + pub fn dispatch() -> Result<()> { + let args: Vec<_> = std::env::args().collect(); + ensure!( + args.len() == 4 && args[1] == "--service", + "CAPTURE_FIXED_ARGUMENTS" + ); + let case = uuid::Uuid::parse_str(&args[2])?; + ensure!( + case.get_version_num() == 4 && case.to_string() == args[2], + "CAPTURE_CANONICAL_UUID" + ); + let role = match args[3].as_str() { + "local-service" => Role::LocalService, + "system" => Role::System, + _ => anyhow::bail!("CAPTURE_FIXED_ROLE"), + }; + CASE.set(case) + .map_err(|_| anyhow::anyhow!("CAPTURE_ALREADY_DISPATCHED"))?; + ROLE.set(role) + .map_err(|_| anyhow::anyhow!("CAPTURE_ALREADY_DISPATCHED"))?; + let mut name = wide(role.name()); + let table = [ + SERVICE_TABLE_ENTRYW { + lpServiceName: name.as_mut_ptr(), + lpServiceProc: Some(service_main), + }, + SERVICE_TABLE_ENTRYW { + lpServiceName: ptr::null_mut(), + lpServiceProc: None, + }, + ]; + ensure!( + unsafe { StartServiceCtrlDispatcherW(table.as_ptr()) } != 0, + "CAPTURE_SCM_ONLY" + ); + Ok(()) + } +} +#[cfg(all(windows, feature = "system-helper"))] +fn main() -> anyhow::Result<()> { + probe::dispatch() +} +#[cfg(not(all(windows, feature = "system-helper")))] +fn main() -> anyhow::Result<()> { + anyhow::bail!("Windows system-helper build required; no diagnostic clock fallback") +} diff --git a/crates/agent-windows/src/signed_clock.rs b/crates/agent-windows/src/signed_clock.rs index 7ce2473..8e29495 100644 --- a/crates/agent-windows/src/signed_clock.rs +++ b/crates/agent-windows/src/signed_clock.rs @@ -148,18 +148,13 @@ fn bracket_sample( 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 width = raw_widths( + interrupt_before, + interrupt_after, + unbiased_before, + unbiased_after, + )? + .0; let capture_error_ns = width .checked_add(base_error_ns) .ok_or_else(|| anyhow::anyhow!("TIME_NATIVE_CAPTURE_OVERFLOW"))?; @@ -184,6 +179,215 @@ fn bracket_sample( }) } +fn raw_widths(ib: u64, ia: u64, ub: u64, ua: u64) -> Result<(u64, u64)> { + let width = ia + .checked_sub(ib) + .and_then(|value| value.checked_mul(100)) + .ok_or_else(|| anyhow::anyhow!("TIME_NATIVE_CAPTURE_COUNTER"))?; + let unbiased_width = ua + .checked_sub(ub) + .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" + ); + Ok((width, unbiased_width)) +} +/// Private raw capture, not a Sample and never clock authority. +#[derive(Clone, Copy)] +struct RawCapture { + wall: u64, + ib: u64, + ub: u64, + ua: u64, + ia: u64, +} +impl RawCapture { + fn widths(self) -> Result<(u64, u64)> { + ensure!( + self.wall > 116_444_736_000_000_000 && self.ib > 0 && self.ub > 0, + "TIME_NATIVE_RAW_RANGE" + ); + raw_widths(self.ib, self.ia, self.ub, self.ua) + } + fn row(self) -> [u64; 5] { + [self.wall, self.ib, self.ub, self.ua, self.ia] + } +} +/// Fixed read-only getter sequence shared by installed and diagnostic paths. +#[cfg(windows)] +fn raw_capture() -> Result { + #[link(name = "kernel32")] + unsafe extern "system" { + fn GetSystemTimePreciseAsFileTime(value: *mut u64); + fn QueryInterruptTimePrecise(value: *mut u64); + fn QueryUnbiasedInterruptTimePrecise(value: *mut u64); + } + let mut value = RawCapture { + wall: 0, + ib: 0, + ub: 0, + ua: 0, + ia: 0, + }; + // SAFETY: documented VOID getters write valid aligned u64 outputs. These + // Windows10+ imports have no optional fallback or caller-selected target. + unsafe { + QueryInterruptTimePrecise(&mut value.ib); + QueryUnbiasedInterruptTimePrecise(&mut value.ub); + GetSystemTimePreciseAsFileTime(&mut value.wall); + QueryUnbiasedInterruptTimePrecise(&mut value.ua); + QueryInterruptTimePrecise(&mut value.ia); + } + value.widths()?; + Ok(value) +} +const RAW_SAMPLES: usize = 128; +const RAW_BUDGET_NS: u64 = 250_000_000; +/// Numeric observations only. No Deserialize, calibrated Sample conversion or +/// readiness flag; a report cannot open SignedClock or bypass its pin loader. +#[derive(serde::Serialize)] +pub struct CaptureDiagnostics { + schema_version: u32, + calibrated: bool, + clock_authority: bool, + columns_100ns: [&'static str; 5], + samples_100ns: Vec<[u64; 5]>, + sample_count: u32, + elapsed_monotonic_ns: u64, + elapsed_interrupt_ns: u64, + max_bracket_ns: u64, + max_internal_interrupt_unbiased_difference_ns: u64, + max_wall_interrupt_difference_ns: u64, + max_interrupt_unbiased_difference_ns: u64, +} +struct RawSeries { + first: Option, + previous: Option, + rows: Vec<[u64; 5]>, + max_bracket_ns: u64, + max_internal_delta_ns: u64, + max_wall_delta_ns: u64, + max_unbiased_delta_ns: u64, +} +impl RawSeries { + fn new() -> Self { + Self { + first: None, + previous: None, + rows: Vec::with_capacity(RAW_SAMPLES), + max_bracket_ns: 0, + max_internal_delta_ns: 0, + max_wall_delta_ns: 0, + max_unbiased_delta_ns: 0, + } + } + fn push(&mut self, value: RawCapture) -> Result<()> { + ensure!(self.rows.len() < RAW_SAMPLES, "TIME_RAW_SAMPLE_LIMIT"); + let (width, unbiased_width) = value.widths()?; + ensure!(width <= RAW_BUDGET_NS, "TIME_RAW_CAPTURE_BUDGET"); + if let Some(previous) = self.previous { + let wall = value + .wall + .checked_sub(previous.wall) + .and_then(|v| v.checked_mul(100)) + .ok_or_else(|| anyhow::anyhow!("TIME_RAW_WALL_BACKWARD"))?; + let interrupt = value + .ia + .checked_sub(previous.ia) + .and_then(|v| v.checked_mul(100)) + .ok_or_else(|| anyhow::anyhow!("TIME_RAW_INTERRUPT_BACKWARD"))?; + let unbiased = value + .ua + .checked_sub(previous.ua) + .and_then(|v| v.checked_mul(100)) + .ok_or_else(|| anyhow::anyhow!("TIME_RAW_UNBIASED_BACKWARD"))?; + ensure!( + value.ib >= previous.ia && value.ub >= previous.ua, + "TIME_RAW_COUNTER_ORDER" + ); + self.max_wall_delta_ns = self.max_wall_delta_ns.max(wall.abs_diff(interrupt)); + self.max_unbiased_delta_ns = + self.max_unbiased_delta_ns.max(interrupt.abs_diff(unbiased)); + ensure!( + wall.abs_diff(interrupt) <= SECOND_NS && interrupt.abs_diff(unbiased) <= SECOND_NS, + "TIME_RAW_DISCONTINUITY" + ); + } + self.first.get_or_insert(value); + self.previous = Some(value); + self.max_bracket_ns = self.max_bracket_ns.max(width); + self.max_internal_delta_ns = self + .max_internal_delta_ns + .max(width.abs_diff(unbiased_width)); + self.rows.push(value.row()); + Ok(()) + } + fn finish(self, elapsed_monotonic_ns: u64) -> Result { + ensure!( + self.rows.len() == RAW_SAMPLES && elapsed_monotonic_ns <= RAW_BUDGET_NS, + "TIME_RAW_INCOMPLETE_OR_EXPIRED" + ); + let first = self + .first + .ok_or_else(|| anyhow::anyhow!("TIME_RAW_EMPTY"))?; + let last = self + .previous + .ok_or_else(|| anyhow::anyhow!("TIME_RAW_EMPTY"))?; + let elapsed_interrupt_ns = last + .ia + .checked_sub(first.ib) + .and_then(|v| v.checked_mul(100)) + .ok_or_else(|| anyhow::anyhow!("TIME_RAW_COUNTER_RANGE"))?; + ensure!( + elapsed_interrupt_ns <= RAW_BUDGET_NS, + "TIME_RAW_INTERRUPT_BUDGET" + ); + Ok(CaptureDiagnostics { + schema_version: 1, + calibrated: false, + clock_authority: false, + columns_100ns: [ + "wall_filetime", + "interrupt_before", + "unbiased_before", + "unbiased_after", + "interrupt_after", + ], + samples_100ns: self.rows, + sample_count: RAW_SAMPLES as u32, + elapsed_monotonic_ns, + elapsed_interrupt_ns, + max_bracket_ns: self.max_bracket_ns, + max_internal_interrupt_unbiased_difference_ns: self.max_internal_delta_ns, + max_wall_interrupt_difference_ns: self.max_wall_delta_ns, + max_interrupt_unbiased_difference_ns: self.max_unbiased_delta_ns, + }) + } +} +/// Exactly128 bounded captures, spaced at fixed1ms target offsets. A missed +/// 250ms own-monotonic budget aborts; no sleep/time-setting API is used. +#[cfg(windows)] +pub fn diagnostic_capture_series() -> Result { + let started = std::time::Instant::now(); + let budget = std::time::Duration::from_nanos(RAW_BUDGET_NS); + let mut series = RawSeries::new(); + for index in 0..RAW_SAMPLES { + let due = std::time::Duration::from_millis(index as u64); + loop { + let elapsed = started.elapsed(); + ensure!(elapsed <= budget, "TIME_RAW_MONOTONIC_BUDGET"); + if elapsed >= due { + break; + } + std::hint::spin_loop(); + } + series.push(raw_capture()?)?; + } + series.finish(started.elapsed().as_nanos().try_into()?) +} + #[cfg(all(windows, feature = "system-helper"))] mod installed { use super::*; @@ -239,24 +443,10 @@ mod installed { 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) + let raw = raw_capture()?; + bracket_sample(raw.wall, raw.ib, raw.ia, raw.ub, raw.ua, base_error_ns) } + fn observed(boot: Uuid, base_error_ns: u64) -> Result<(Sample, u64)> { let mut state = process() .lock() @@ -560,6 +750,63 @@ mod tests { capture_error_ns: 1_000_000, } } + fn raw(index: u64) -> RawCapture { + RawCapture { + wall: 134_444_736_000_000_000 + index * 10_000, + ib: 10_000_000 + index * 10_000, + ia: 10_000_010 + index * 10_000, + ub: 9_000_000 + index * 10_000, + ua: 9_000_008 + index * 10_000, + } + } + #[test] + fn raw_capture_denies_backward_wall_counters_and_incomplete_or_expired_series() { + let mut series = RawSeries::new(); + series.push(raw(0)).unwrap(); + assert!( + series + .push(RawCapture { + wall: raw(0).wall - 1, + ..raw(1) + }) + .is_err() + ); + let mut series = RawSeries::new(); + series.push(raw(0)).unwrap(); + assert!( + series + .push(RawCapture { + ia: raw(0).ia - 1, + ib: raw(0).ib - 1, + ..raw(1) + }) + .is_err() + ); + assert!(RawSeries::new().finish(0).is_err()); + let mut series = RawSeries::new(); + for index in 0..RAW_SAMPLES as u64 { + series.push(raw(index)).unwrap(); + } + assert!(series.finish(RAW_BUDGET_NS + 1).is_err()); + } + #[test] + fn complete_raw_report_is_bounded_non_authoritative_and_keeps_actual_brackets() { + let mut series = RawSeries::new(); + for index in 0..RAW_SAMPLES as u64 { + series.push(raw(index)).unwrap(); + } + assert!(series.push(raw(RAW_SAMPLES as u64)).is_err()); + let report = series.finish(128_000_000).unwrap(); + assert_eq!(report.sample_count, 128); + assert_eq!(report.max_bracket_ns, 1000); + assert_eq!(report.elapsed_interrupt_ns, 127_001_000); + assert_eq!(report.max_internal_interrupt_unbiased_difference_ns, 200); + let value = serde_json::to_value(&report).unwrap(); + assert_eq!(value["calibrated"], false); + assert_eq!(value["clock_authority"], false); + assert!(value.get("capture_error_ns").is_none()); + assert!(serde_json::to_vec(&report).unwrap().len() < 16384); + } #[test] fn job_key_cannot_be_reintroduced_as_a_time_key_with_different_hex_case() { assert_eq!( diff --git a/crates/server/Cargo.toml b/crates/server/Cargo.toml index 4a4616d..1e19715 100644 --- a/crates/server/Cargo.toml +++ b/crates/server/Cargo.toml @@ -37,3 +37,5 @@ futures-util.workspace = true libc = "0.2" rmm-updater-handoff = { path = "../updater-handoff" } + +rmm-time-attestation = { path = "../time-attestation" } diff --git a/crates/server/src/agent_time.rs b/crates/server/src/agent_time.rs new file mode 100644 index 0000000..52d6ee7 --- /dev/null +++ b/crates/server/src/agent_time.rs @@ -0,0 +1,159 @@ +//! Passive protocol clock material only: never a sync decision or job grant. +//! Context comes from current mTLS identity + locked tenant installation row. +use axum::{ + Extension, Json, Router, + body::Bytes, + extract::{DefaultBodyLimit, State}, + http::{HeaderMap, StatusCode}, + routing::post, +}; +use rmm_time_attestation::{Request, SignedAttestation}; +use sqlx::Row; +use std::{os::unix::fs::MetadataExt, sync::OnceLock, time::Duration}; +use tokio::{ + io::{AsyncReadExt, AsyncWriteExt}, + net::UnixStream, + sync::Semaphore, +}; + +const SOCKET: &str = "/run/rmm-time-source/broker.sock"; +const MAX_FRAME: usize = 8192; +static QUERIES: OnceLock = OnceLock::new(); + +pub(crate) fn gateway_routes(routes: Router) -> Router { + routes.route( + "/agent/v1/time-attestation", + post(attest).layer(DefaultBodyLimit::max(MAX_FRAME)), + ) +} +fn protected_socket() -> anyhow::Result<(u64, u64)> { + use anyhow::ensure; + for path in ["/run", "/run/rmm-time-source"] { + let m = std::fs::symlink_metadata(path)?; + ensure!( + m.is_dir() && !m.file_type().is_symlink() && m.uid() == 0 && m.mode() & 0o022 == 0, + "TIME_BROKER_DIRECTORY" + ); + } + let m = std::fs::symlink_metadata(SOCKET)?; + use std::os::unix::fs::FileTypeExt; + ensure!( + m.file_type().is_socket() + && m.uid() == 0 + && m.gid() == 10001 + && m.nlink() == 1 + && m.mode() & 0o7777 == 0o660, + "TIME_BROKER_SOCKET" + ); + Ok((m.dev(), m.ino())) +} +async fn broker(request: &Request) -> anyhow::Result { + use anyhow::ensure; + let owned = protected_socket()?; + let mut connection = UnixStream::connect(SOCKET).await?; + let peer = connection.peer_cred()?; + // A host broker is in an ancestor PID namespace: Linux may report PID0 + // (or the wrapper may omit it) to this container. Authorization instead + // requires the kernel-mapped root UID, protected root-owned socket inode, + // and the verifier's independently pinned end-to-end time signature. + // Userns remapping is not compensated: unmapped UID/socket ownership denies. + ensure!(peer.uid() == 0, "TIME_BROKER_PEER"); + ensure!(protected_socket()? == owned, "TIME_BROKER_REPLACED"); + let raw = serde_json::to_vec(request)?; + ensure!( + !raw.is_empty() && raw.len() <= MAX_FRAME, + "TIME_REQUEST_SIZE" + ); + connection + .write_all(&(u32::try_from(raw.len())?).to_be_bytes()) + .await?; + connection.write_all(&raw).await?; + connection.shutdown().await?; + let length = connection.read_u32().await? as usize; + ensure!(length > 0 && length <= MAX_FRAME, "TIME_RESPONSE_SIZE"); + let mut raw = vec![0; length]; + connection.read_exact(&mut raw).await?; + let mut extra = [0; 1]; + ensure!( + connection.read(&mut extra).await? == 0, + "TIME_RESPONSE_TRAILING" + ); + ensure!(protected_socket()? == owned, "TIME_BROKER_REPLACED"); + let response: SignedAttestation = serde_json::from_slice(&raw)?; + ensure!( + serde_json::to_vec(&response)? == raw, + "TIME_RESPONSE_NONCANONICAL" + ); + // The independent verifier checks the signature, protected key and whole + // challenge. This root-peer transport is not an OS/helper attestation. + let payload: rmm_time_attestation::Payload = serde_json::from_str(&response.payload)?; + ensure!( + payload.request_sha256 == request.sha256()?, + "TIME_RESPONSE_REQUEST" + ); + Ok(response) +} +async fn attest( + State(s): State, + Extension(peer): Extension, + headers: HeaderMap, + bytes: Bytes, +) -> Result, StatusCode> { + tokio::time::timeout(Duration::from_millis(500), issue(&s, peer, headers, bytes)) + .await + .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)? +} +async fn issue( + s: &crate::State, + peer: crate::Peer, + headers: HeaderMap, + bytes: Bytes, +) -> Result, StatusCode> { + let (tenant, agent) = crate::agent_http::identity(s, peer).await?; + if headers.get("content-type").and_then(|v| v.to_str().ok()) != Some("application/json") { + return Err(StatusCode::UNSUPPORTED_MEDIA_TYPE); + } + let request: Request = serde_json::from_slice(&bytes).map_err(|_| StatusCode::BAD_REQUEST)?; + request.validate().map_err(|_| StatusCode::BAD_REQUEST)?; + let c = &request.context; + if c.tenant_id != tenant || c.agent_id != agent { + return Err(StatusCode::FORBIDDEN); + } + let _slot = QUERIES + .get_or_init(|| Semaphore::new(4)) + .try_acquire() + .map_err(|_| StatusCode::TOO_MANY_REQUESTS)?; + let mut tx = rmm_persistence::tenant_tx(&s.pool, tenant) + .await + .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; + // No sync_ready precondition: the independent time check is needed before + // the first signed reconciliation, including its strictly negative paths. + let row = sqlx::query("SELECT asset_id,enrollment_generation,assignment_version,connection_generation,connection_boot_id,capabilities FROM agent_installations WHERE tenant_id=$1 AND agent_id=$2 AND revoked_at IS NULL FOR SHARE") + .bind(tenant).bind(agent).fetch_optional(&mut *tx).await + .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?.ok_or(StatusCode::FORBIDDEN)?; + let same = row.get::("asset_id") == c.asset_id + && u64::try_from(row.get::("enrollment_generation")).ok() + == Some(c.enrollment_generation) + && u64::try_from(row.get::("assignment_version")).ok() + == Some(c.assignment_generation) + && u64::try_from(row.get::("connection_generation")).ok() + == Some(c.connection_generation) + && row.get::, _>("connection_boot_id") == Some(c.windows_boot_id) + && row + .get::("capabilities") + .as_array() + .is_some_and(|v| v.iter().any(|v| v.as_str() == Some("windows.base/1"))); + if !same { + return Err(StatusCode::CONFLICT); + } + // Hold the shared installation lock through this bounded local query: + // revoke/reassignment/connection changes cannot race the signing moment. + let response = tokio::time::timeout(Duration::from_millis(300), broker(&request)) + .await + .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)? + .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; + tx.commit() + .await + .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; + Ok(Json(response)) +} diff --git a/crates/server/src/main.rs b/crates/server/src/main.rs index 35c3893..e9746f6 100644 --- a/crates/server/src/main.rs +++ b/crates/server/src/main.rs @@ -1,6 +1,7 @@ mod agent_artifacts; mod agent_http; mod agent_service; +mod agent_time; mod agent_update_health; mod agent_update_policy; mod agent_updates; @@ -163,6 +164,7 @@ async fn main() -> Result<()> { if role.gateway() { routes = agent_updates::gateway_routes(routes); routes = agent_update_health::gateway_routes(routes); + routes = agent_time::gateway_routes(routes); routes = routes .route("/agent/v1/enroll", post(gateway::enroll)) .route("/agent/v1/messages", post(agent_http::messages)) diff --git a/crates/time-broker-linux/Cargo.toml b/crates/time-broker-linux/Cargo.toml new file mode 100644 index 0000000..6df0f35 --- /dev/null +++ b/crates/time-broker-linux/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "rmm-time-broker-linux" +version.workspace = true +edition.workspace = true +license.workspace = true + +[dependencies] +anyhow.workspace = true +libc = "0.2" +ed25519-dalek = "=2.2.0" +hex.workspace = true +serde.workspace = true +serde_json.workspace = true +uuid.workspace = true +rmm-time-source-linux = { path = "../time-source-linux" } +rmm-time-attestation = { path = "../time-attestation" } diff --git a/crates/time-broker-linux/src/lib.rs b/crates/time-broker-linux/src/lib.rs new file mode 100644 index 0000000..c3f4a89 --- /dev/null +++ b/crates/time-broker-linux/src/lib.rs @@ -0,0 +1,10 @@ +//! Fixed local, root-only signing broker. HTTP/mTLS/SQL context authorization is +//! the trusted unprivileged server's responsibility, never inferred here. +#[cfg(target_os = "linux")] +mod native; +#[cfg(target_os = "linux")] +pub use native::run; +#[cfg(not(target_os = "linux"))] +pub fn run() -> anyhow::Result<()> { + anyhow::bail!("TIME_BROKER_LINUX_REQUIRED") +} diff --git a/crates/time-broker-linux/src/main.rs b/crates/time-broker-linux/src/main.rs new file mode 100644 index 0000000..e682996 --- /dev/null +++ b/crates/time-broker-linux/src/main.rs @@ -0,0 +1,12 @@ +fn main() { + // This fixed executable has no configuration/path/command arguments. + if std::env::args_os().len() != 1 { + eprintln!("TIME_BROKER_NO_ARGUMENTS"); + std::process::exit(2); + } + if rmm_time_broker_linux::run().is_err() { + // Never format configuration, request, key material or nested errors. + eprintln!("TIME_BROKER_STOPPED"); + std::process::exit(1); + } +} diff --git a/crates/time-broker-linux/src/native.rs b/crates/time-broker-linux/src/native.rs new file mode 100644 index 0000000..e28ee95 --- /dev/null +++ b/crates/time-broker-linux/src/native.rs @@ -0,0 +1,752 @@ +use anyhow::{Context, Result, ensure}; +use ed25519_dalek::SigningKey; +use rmm_time_attestation::{Payload, Request, SignedAttestation}; +use rmm_time_source_linux::{NativeTimeSource, QualifiedSample}; +use serde::Deserialize; +use std::{ + collections::BTreeSet, + ffi::CString, + fs::File, + io::{Read, Write}, + mem, + os::fd::{AsRawFd, FromRawFd, OwnedFd, RawFd}, + os::unix::{fs::MetadataExt, net::UnixStream}, +}; +use uuid::Uuid; + +const ROOT: &str = "/run/rmm-time-source"; +const SOCKET: &str = "/run/rmm-time-source/broker.sock"; +const MAX_BYTES: usize = 8192; +const DEADLINE_NS: u64 = 250_000_000; +const CAPTURE_NS: u64 = 10_000_000; +const MAX_ERROR_NS: u64 = 500_000_000; +const MAX_AGE_NS: u64 = 3_600_000_000_000; + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct Configuration { + schema_version: u32, + server_instance: Uuid, + key_id: String, + key_generation: u64, + signing_key_hex: String, + forbidden_public_keys: Vec, + expected_server_uid: u32, + server_gid: u32, +} +struct Signer { + key: SigningKey, + server_instance: Uuid, + key_id: String, + generation: u64, + server_gid: u32, + _root: OwnedFd, + _file: OwnedFd, + file_state: FileState, +} +#[derive(Clone, Copy, PartialEq, Eq)] +struct FileState { + identity: Identity, + length: u64, + mtime: i64, + mtime_ns: i64, + ctime: i64, + ctime_ns: i64, +} +fn file_state(file: &OwnedFd) -> Result { + let metadata = File::from(file.try_clone()?).metadata()?; + Ok(FileState { + identity: identity(file.as_raw_fd())?, + length: metadata.len(), + mtime: metadata.mtime(), + mtime_ns: metadata.mtime_nsec(), + ctime: metadata.ctime(), + ctime_ns: metadata.ctime_nsec(), + }) +} +#[derive(Clone, Copy, PartialEq, Eq)] +struct Identity { + dev: u64, + ino: u64, + uid: u32, + gid: u32, + mode: u32, + links: u64, +} +fn fd(value: i32) -> Result { + if value < 0 { + return Err(std::io::Error::last_os_error().into()); + } + // SAFETY: each caller supplies a new descriptor. + Ok(unsafe { OwnedFd::from_raw_fd(value) }) +} +fn openat(dir: RawFd, name: &str, flags: i32) -> Result { + let name = CString::new(name)?; + fd(unsafe { + libc::openat( + dir, + name.as_ptr(), + flags | libc::O_CLOEXEC | libc::O_NOFOLLOW, + ) + }) +} +fn identity(descriptor: RawFd) -> Result { + let mut st = mem::MaybeUninit::::uninit(); + ensure!( + unsafe { libc::fstat(descriptor, st.as_mut_ptr()) } == 0, + "BROKER_FSTAT" + ); + let st = unsafe { st.assume_init() }; + Ok(Identity { + dev: st.st_dev, + ino: st.st_ino, + uid: st.st_uid, + gid: st.st_gid, + mode: st.st_mode, + links: st.st_nlink, + }) +} +fn directory(path: &str) -> Result { + ensure!( + path.starts_with('/') && !path.contains(".."), + "BROKER_FIXED_DIRECTORY" + ); + let mut current = openat(libc::AT_FDCWD, "/", libc::O_RDONLY | libc::O_DIRECTORY)?; + let valid = + |m: Identity| m.uid == 0 && m.mode & libc::S_IFMT == libc::S_IFDIR && m.mode & 0o022 == 0; + ensure!( + valid(identity(current.as_raw_fd())?), + "BROKER_ROOT_PROTECTION" + ); + for part in path.split('/').filter(|v| !v.is_empty()) { + current = openat( + current.as_raw_fd(), + part, + libc::O_RDONLY | libc::O_DIRECTORY, + )?; + ensure!( + valid(identity(current.as_raw_fd())?), + "BROKER_DIRECTORY_PROTECTION" + ); + } + Ok(current) +} +fn bound_directory(path: &str, held: &OwnedFd) -> Result<()> { + ensure!( + identity(directory(path)?.as_raw_fd())? == identity(held.as_raw_fd())?, + "BROKER_DIRECTORY_CHANGED" + ); + Ok(()) +} +fn exact_hex(value: &str) -> Result<[u8; 32]> { + ensure!( + value.len() == 64 + && value + .bytes() + .all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b)), + "BROKER_KEY_FORMAT" + ); + let bytes = hex::decode(value)?; + bytes + .try_into() + .map_err(|_| anyhow::anyhow!("BROKER_KEY_LENGTH")) +} +fn key(configuration: &Configuration) -> Result { + ensure!( + configuration.schema_version == 1 + && !configuration.server_instance.is_nil() + && configuration.key_generation > 0 + && configuration.expected_server_uid == 10001 + && configuration.server_gid == 10001 + && !configuration.key_id.is_empty() + && configuration.key_id.len() <= 64 + && configuration + .key_id + .bytes() + .all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'_') + && (1..=32).contains(&configuration.forbidden_public_keys.len()), + "BROKER_CONFIGURATION" + ); + let signer = SigningKey::from_bytes(&exact_hex(&configuration.signing_key_hex)?); + let own = signer.verifying_key().to_bytes(); + let mut seen = BTreeSet::new(); + for forbidden in &configuration.forbidden_public_keys { + let public = exact_hex(forbidden)?; + ensure!( + seen.insert(public) && public != own, + "BROKER_KEY_ROLE_REUSE_OR_DUPLICATE" + ); + } + Ok(signer) +} +impl Signer { + fn open() -> Result { + let root = directory("/etc/rmm-time-source")?; + let file = openat(root.as_raw_fd(), "signer.json", libc::O_RDONLY)?; + let info = identity(file.as_raw_fd())?; + ensure!( + info.uid == 0 + && info.mode & libc::S_IFMT == libc::S_IFREG + && info.mode & 0o7777 == 0o600 + && info.links == 1, + "BROKER_SIGNER_PROTECTION" + ); + let initial_state = file_state(&file)?; + let before = File::from(file.try_clone()?).metadata()?; + ensure!(before.len() <= MAX_BYTES as u64, "BROKER_SIGNER_SIZE"); + let mut raw = Vec::new(); + File::from(file.try_clone()?) + .take(MAX_BYTES as u64 + 1) + .read_to_end(&mut raw)?; + ensure!(raw.len() <= MAX_BYTES, "BROKER_SIGNER_SIZE"); + let after = File::from(file.try_clone()?).metadata()?; + ensure!( + before.len() == after.len() + && before.mtime() == after.mtime() + && before.mtime_nsec() == after.mtime_nsec() + && before.ctime() == after.ctime() + && before.ctime_nsec() == after.ctime_nsec(), + "BROKER_SIGNER_READ_CHANGED" + ); + ensure!( + raw.len() as u64 == before.len(), + "BROKER_SIGNER_READ_LENGTH" + ); + ensure!( + file_state(&file)? == initial_state, + "BROKER_SIGNER_READ_IDENTITY_CHANGED" + ); + let state = initial_state; + let configuration: Configuration = serde_json::from_slice(&raw)?; + let key = key(&configuration)?; + let result = Self { + key, + server_instance: configuration.server_instance, + key_id: configuration.key_id, + generation: configuration.key_generation, + server_gid: configuration.server_gid, + _root: root, + _file: file, + file_state: state, + }; + result.recheck()?; + Ok(result) + } + fn recheck(&self) -> Result<()> { + bound_directory("/etc/rmm-time-source", &self._root)?; + let current = openat(self._root.as_raw_fd(), "signer.json", libc::O_RDONLY)?; + let held = identity(self._file.as_raw_fd())?; + ensure!( + file_state(&self._file)? == self.file_state && file_state(¤t)? == self.file_state, + "BROKER_SIGNER_CONTENT_IDENTITY_CHANGED" + ); + ensure!( + held == identity(current.as_raw_fd())? + && held.uid == 0 + && held.mode & 0o7777 == 0o600 + && held.links == 1, + "BROKER_SIGNER_CHANGED" + ); + // Contents are immutable for this process. Root rotation requires stop, + // independently provisioned new configuration and a fresh instance. + Ok(()) + } +} + +#[derive(Clone, Copy)] +struct Clock { + mono: u64, + end: u64, + boot: u64, + utc: i64, +} +fn clock_ns(which: libc::clockid_t) -> Result { + let mut value = mem::MaybeUninit::::uninit(); + ensure!( + unsafe { libc::clock_gettime(which, value.as_mut_ptr()) } == 0, + "BROKER_CLOCK" + ); + let value = unsafe { value.assume_init() }; + ensure!( + value.tv_sec >= 0 && (0..1_000_000_000).contains(&value.tv_nsec), + "BROKER_CLOCK_RANGE" + ); + Ok(i128::from(value.tv_sec) * 1_000_000_000 + i128::from(value.tv_nsec)) +} +fn capture() -> Result { + let mono = u64::try_from(clock_ns(libc::CLOCK_MONOTONIC)?)?; + let boot = u64::try_from(clock_ns(libc::CLOCK_BOOTTIME)?)?; + let utc = i64::try_from(clock_ns(libc::CLOCK_REALTIME)?)?; + let end = u64::try_from(clock_ns(libc::CLOCK_MONOTONIC)?)?; + ensure!( + end >= mono && end - mono <= CAPTURE_NS && utc > 0, + "BROKER_CAPTURE_WINDOW" + ); + Ok(Clock { + mono, + end, + boot, + utc, + }) +} +fn boot_id() -> Result { + let raw = std::fs::read_to_string("/proc/sys/kernel/random/boot_id")?; + let id = Uuid::parse_str(raw.trim())?; + ensure!(!id.is_nil(), "BROKER_BOOT_ID"); + Ok(id) +} +fn continuity(sample: &QualifiedSample, now: Clock) -> Result<()> { + let mono = now + .mono + .checked_sub(sample.captured_monotonic_ns()) + .context("BROKER_MONOTONIC_BACKWARD")?; + let boot = now + .boot + .checked_sub(sample.sampled_boottime_ns()) + .context("BROKER_BOOTTIME_BACKWARD")?; + let wall = now + .utc + .checked_sub(sample.captured_utc_ns()) + .context("BROKER_UTC_OVERFLOW")?; + let tolerance = CAPTURE_NS + .checked_add(now.end - now.mono) + .context("BROKER_WINDOW_OVERFLOW")?; + ensure!( + wall >= 0 + && mono.abs_diff(boot) <= tolerance + && mono.abs_diff(wall as u64) <= tolerance + && boot_id()? == sample.server_boot_id(), + "BROKER_CLOCK_DISCONTINUITY" + ); + Ok(()) +} +#[derive(Clone, Copy)] +struct Deadline { + mono: u64, + boot: u64, +} +fn deadline(start: Clock) -> Result { + Ok(Deadline { + mono: start + .mono + .checked_add(DEADLINE_NS) + .context("BROKER_DEADLINE_OVERFLOW")?, + boot: start + .boot + .checked_add(DEADLINE_NS) + .context("BROKER_DEADLINE_OVERFLOW")?, + }) +} +fn budget_at(end: Deadline, mono: u64, boot: u64) -> Result { + Ok(remaining(end.mono, mono)?.min(remaining(end.boot, boot)?)) +} +fn budget(end: Deadline) -> Result { + budget_at( + end, + u64::try_from(clock_ns(libc::CLOCK_MONOTONIC)?)?, + u64::try_from(clock_ns(libc::CLOCK_BOOTTIME)?)?, + ) +} +fn remaining(end: u64, now: u64) -> Result { + let left = end.checked_sub(now).context("BROKER_DEADLINE")?; + ensure!(left > 0, "BROKER_DEADLINE"); + Ok(left) +} +fn padded_quality(error: u64, age: u64, capture_mono: u64, end: u64) -> Result<(u64, u64)> { + let padding = end + .checked_sub(capture_mono) + .and_then(|v| v.checked_add(2 * CAPTURE_NS)) + .context("BROKER_QUALITY_OVERFLOW")?; + let error = error + .checked_add(padding) + .context("BROKER_ERROR_OVERFLOW")?; + let age = age.checked_add(padding).context("BROKER_AGE_OVERFLOW")?; + ensure!( + error <= MAX_ERROR_NS && age <= MAX_AGE_NS, + "BROKER_QUALITY_LIMIT" + ); + Ok((error, age)) +} +fn wait(fd: RawFd, event: i16, end: Deadline) -> Result<()> { + let left = budget(end)?; + let timeout = libc::timespec { + tv_sec: (left / 1_000_000_000) as _, + tv_nsec: (left % 1_000_000_000) as _, + }; + let mut p = libc::pollfd { + fd, + events: event, + revents: 0, + }; + ensure!( + unsafe { libc::ppoll(&mut p, 1, &timeout, std::ptr::null()) } == 1 + && p.revents & event != 0 + && p.revents & (libc::POLLERR | libc::POLLNVAL) == 0, + "BROKER_IO_TIMEOUT" + ); + Ok(()) +} +fn exact_read(stream: &mut UnixStream, mut raw: &mut [u8], end: Deadline) -> Result<()> { + while !raw.is_empty() { + wait(stream.as_raw_fd(), libc::POLLIN, end)?; + let got = stream.read(raw)?; + ensure!(got > 0, "BROKER_FRAME_EOF"); + raw = &mut raw[got..]; + } + Ok(()) +} +fn parse_request(raw: &[u8]) -> Result { + ensure!( + !raw.is_empty() && raw.len() <= MAX_BYTES, + "BROKER_FRAME_SIZE" + ); + let request: Request = serde_json::from_slice(raw)?; + request.validate()?; + ensure!( + serde_json::to_vec(&request)? == raw, + "BROKER_NONCANONICAL_REQUEST" + ); + Ok(request) +} +fn frame_length(header: [u8; 4]) -> Result { + let len = u32::from_be_bytes(header) as usize; + ensure!((1..=MAX_BYTES).contains(&len), "BROKER_FRAME_SIZE"); + Ok(len) +} +fn read_request(stream: &mut UnixStream, end: Deadline) -> Result { + let mut header = [0; 4]; + exact_read(stream, &mut header, end)?; + let length = frame_length(header)?; + let mut raw = vec![0; length]; + exact_read(stream, &mut raw, end)?; + // A pipelined/extra byte already supplied with this request is malformed. + // The protocol grants exactly one request; the stream is always closed. + let mut byte = [0u8; 1]; + let peek = unsafe { + libc::recv( + stream.as_raw_fd(), + byte.as_mut_ptr().cast(), + 1, + libc::MSG_PEEK | libc::MSG_DONTWAIT, + ) + }; + ensure!(peek <= 0, "BROKER_EXTRA_FRAME"); + if peek < 0 { + ensure!( + std::io::Error::last_os_error().kind() == std::io::ErrorKind::WouldBlock, + "BROKER_FRAME_PEEK" + ); + } + parse_request(&raw) +} +fn write_reply(stream: &mut UnixStream, signed: &SignedAttestation, end: Deadline) -> Result<()> { + let raw = serde_json::to_vec(signed)?; + ensure!(raw.len() <= MAX_BYTES, "BROKER_REPLY_BOUND"); + let mut frame = Vec::with_capacity(raw.len() + 4); + frame.extend_from_slice(&(raw.len() as u32).to_be_bytes()); + frame.extend_from_slice(&raw); + let mut rest = frame.as_slice(); + while !rest.is_empty() { + wait(stream.as_raw_fd(), libc::POLLOUT, end)?; + let got = stream.write(rest)?; + ensure!(got > 0, "BROKER_REPLY_EOF"); + rest = &rest[got..]; + } + budget(end)?; + Ok(()) +} +fn peer(stream: &UnixStream, gid: u32) -> Result<()> { + let mut credential = mem::MaybeUninit::::uninit(); + let mut length = mem::size_of::() as libc::socklen_t; + ensure!( + unsafe { + libc::getsockopt( + stream.as_raw_fd(), + libc::SOL_SOCKET, + libc::SO_PEERCRED, + credential.as_mut_ptr().cast(), + &mut length, + ) + } == 0 + && length as usize == mem::size_of::(), + "BROKER_PEERCRED" + ); + let credential = unsafe { credential.assume_init() }; + ensure!( + credential.pid > 1 && credential.uid == 10001 && credential.gid == gid, + "BROKER_SERVER_IDENTITY" + ); + Ok(()) +} + +struct Listener { + fd: OwnedFd, + root: OwnedFd, + own: Option, +} +impl Listener { + fn current(&self) -> Result { + let name = CString::new("broker.sock")?; + let mut st = mem::MaybeUninit::::uninit(); + ensure!( + unsafe { + libc::fstatat( + self.root.as_raw_fd(), + name.as_ptr(), + st.as_mut_ptr(), + libc::AT_SYMLINK_NOFOLLOW, + ) + } == 0, + "BROKER_SOCKET_STAT" + ); + let st = unsafe { st.assume_init() }; + Ok(Identity { + dev: st.st_dev, + ino: st.st_ino, + uid: st.st_uid, + gid: st.st_gid, + mode: st.st_mode, + links: st.st_nlink, + }) + } + fn open(gid: u32) -> Result { + let root = directory(ROOT)?; + let fd = + fd(unsafe { libc::socket(libc::AF_UNIX, libc::SOCK_STREAM | libc::SOCK_CLOEXEC, 0) })?; + let mut result = Self { + fd, + root, + own: None, + }; + let mut addr: libc::sockaddr_un = unsafe { mem::zeroed() }; + addr.sun_family = libc::AF_UNIX as _; + for (to, from) in addr.sun_path.iter_mut().zip(SOCKET.bytes()) { + *to = from as _; + } + let length = + (mem::offset_of!(libc::sockaddr_un, sun_path) + SOCKET.len() + 1) as libc::socklen_t; + bound_directory(ROOT, &result.root)?; + ensure!( + unsafe { + libc::bind( + result.fd.as_raw_fd(), + (&addr as *const libc::sockaddr_un).cast(), + length, + ) + } == 0, + "BROKER_BIND_ONCE" + ); + let own = result.current()?; + ensure!( + own.uid == 0 && own.mode & libc::S_IFMT == libc::S_IFSOCK && own.links == 1, + "BROKER_SOCKET_IDENTITY" + ); + result.own = Some(own); + let name = CString::new("broker.sock")?; + ensure!( + unsafe { + libc::fchownat( + result.root.as_raw_fd(), + name.as_ptr(), + 0, + gid, + libc::AT_SYMLINK_NOFOLLOW, + ) + } == 0, + "BROKER_SOCKET_GROUP" + ); + ensure!( + unsafe { libc::fchmodat(result.root.as_raw_fd(), name.as_ptr(), 0o660, 0) } == 0, + "BROKER_SOCKET_MODE" + ); + let updated = result.current()?; + ensure!( + updated.dev == own.dev + && updated.ino == own.ino + && updated.uid == 0 + && updated.gid == gid + && updated.mode & 0o7777 == 0o660 + && updated.links == 1, + "BROKER_SOCKET_READY" + ); + result.own = Some(updated); + result.recheck()?; + ensure!( + unsafe { libc::listen(result.fd.as_raw_fd(), 4) } == 0, + "BROKER_LISTEN" + ); + Ok(result) + } + fn recheck(&self) -> Result<()> { + bound_directory(ROOT, &self.root)?; + ensure!(Some(self.current()?) == self.own, "BROKER_SOCKET_CHANGED"); + Ok(()) + } + fn accept(&self) -> Result { + self.recheck()?; + let accepted = fd(unsafe { + libc::accept4( + self.fd.as_raw_fd(), + std::ptr::null_mut(), + std::ptr::null_mut(), + libc::SOCK_CLOEXEC | libc::SOCK_NONBLOCK, + ) + })?; + Ok(UnixStream::from(accepted)) + } +} +impl Drop for Listener { + fn drop(&mut self) { + // No adoption, restart cleanup or retry: only this exact own inode. + if let Some(own) = self.own.take() + && bound_directory(ROOT, &self.root).is_ok() + && self.current().ok() == Some(own) + && let Ok(name) = CString::new("broker.sock") + { + unsafe { libc::unlinkat(self.root.as_raw_fd(), name.as_ptr(), 0) }; + } + } +} + +pub fn run() -> Result<()> { + ensure!(unsafe { libc::geteuid() } == 0, "BROKER_ROOT_REQUIRED"); + let signer = Signer::open()?; + let mut source = NativeTimeSource::open()?; + let listener = Listener::open(signer.server_gid)?; + loop { + let mut stream = listener.accept()?; + let start = capture()?; + let end = deadline(start)?; + let _ = handle(&signer, &mut source, &mut stream, end); + // Drop closes every connection after exactly one attempt, including + // malformed/unauthenticated input. Errors never disclose internals. + } +} +fn handle( + signer: &Signer, + source: &mut NativeTimeSource, + stream: &mut UnixStream, + end: Deadline, +) -> Result<()> { + peer(stream, signer.server_gid)?; + let request = read_request(stream, end)?; + signer.recheck()?; + budget(end)?; + let sample = source.sample()?; + let before = capture()?; + continuity(&sample, before)?; + budget_at(end, before.end, before.boot)?; + let (error, age) = padded_quality( + sample.server_error_ns(), + sample.source_sync_age_ns(), + sample.captured_monotonic_ns(), + end.mono, + )?; + let payload = Payload { + version: 1, + request_sha256: request.sha256()?, + server_instance: signer.server_instance, + server_boot_id: sample.server_boot_id(), + key_id: signer.key_id.clone(), + key_generation: signer.generation, + captured_utc_ns: sample.captured_utc_ns(), + server_error_ns: error, + source_sync_age_ns: age, + }; + let signed = rmm_time_attestation::sign(&payload, &signer.key)?; + let after = capture()?; + continuity(&sample, after)?; + budget_at(end, after.end, after.boot)?; + signer.recheck()?; + write_reply(stream, &signed, end) +} + +#[cfg(test)] +mod tests { + use super::*; + fn configuration() -> Configuration { + Configuration { + schema_version: 1, + server_instance: Uuid::from_bytes([1; 16]), + key_id: "time-v1".into(), + key_generation: 1, + signing_key_hex: hex::encode([42u8; 32]), + forbidden_public_keys: vec![hex::encode( + SigningKey::from_bytes(&[43; 32]).verifying_key().to_bytes(), + )], + expected_server_uid: 10001, + server_gid: 10001, + } + } + #[test] + fn signer_cannot_reuse_protected_forbidden_key_or_change_server_identity() { + let mut config = configuration(); + let signer = key(&config).unwrap(); + config.forbidden_public_keys = vec![hex::encode(signer.verifying_key().to_bytes())]; + assert!(key(&config).is_err()); + config.forbidden_public_keys.clear(); + assert!(key(&config).is_err()); + let mut config = configuration(); + config.server_gid = 0; + assert!(key(&config).is_err()); + let mut config = configuration(); + config.expected_server_uid = 0; + assert!(key(&config).is_err()); + } + fn request() -> Request { + use rmm_time_attestation::{Context, ENDPOINT, Role}; + Request { + version: 1, + endpoint: ENDPOINT.into(), + nonce: "ab".repeat(32), + context: Context { + tenant_id: Uuid::from_bytes([1; 16]), + asset_id: Uuid::from_bytes([2; 16]), + agent_id: Uuid::from_bytes([3; 16]), + enrollment_generation: 1, + assignment_generation: 1, + connection_generation: 1, + windows_boot_id: Uuid::from_bytes([4; 16]), + verifier_incarnation: Uuid::from_bytes([5; 16]), + role: Role::Agent, + helper_image_sha256: None, + binding_schema: 1, + }, + } + } + #[test] + fn frame_requires_exact_small_canonical_request_before_native_work() { + let request = request(); + let raw = serde_json::to_vec(&request).unwrap(); + assert!(parse_request(&raw).is_ok()); + let mut spaced = vec![b' ']; + spaced.extend_from_slice(&raw); + assert!(parse_request(&spaced).is_err()); + assert!(frame_length(0u32.to_be_bytes()).is_err()); + assert!(frame_length(8193u32.to_be_bytes()).is_err()); + assert_eq!(frame_length(8192u32.to_be_bytes()).unwrap(), 8192); + let mut unknown = serde_json::to_value(&request).unwrap(); + unknown["extra"] = true.into(); + assert!(parse_request(&serde_json::to_vec(&unknown).unwrap()).is_err()); + } + #[test] + fn whole_deadline_and_pre_sign_reservation_never_extend_quality_bounds() { + let end = Deadline { + mono: 100, + boot: 200, + }; + assert!(budget_at(end, 99, 201).is_err()); + assert!(budget_at(end, 101, 199).is_err()); + assert_eq!(budget_at(end, 99, 198).unwrap(), 1); + assert!(remaining(100, 100).is_err()); + assert!(remaining(100, 101).is_err()); + assert_eq!(remaining(100, 99).unwrap(), 1); + let (error, age) = padded_quality(10_000_000, 1_000_000_000, 100, 200).unwrap(); + assert_eq!(error, 30_000_100); + assert_eq!(age, 1_020_000_100); + assert!(padded_quality(MAX_ERROR_NS, 0, 100, 200).is_err()); + assert!(padded_quality(0, MAX_AGE_NS, 100, 200).is_err()); + assert!(padded_quality(0, 0, 200, 100).is_err()); + assert!(padded_quality(u64::MAX, 0, 0, 1).is_err()); + } +} diff --git a/deploy/windows_raw_clock_linux_acceptance.py b/deploy/windows_raw_clock_linux_acceptance.py new file mode 100644 index 0000000..74bd902 --- /dev/null +++ b/deploy/windows_raw_clock_linux_acceptance.py @@ -0,0 +1,314 @@ +#!/usr/bin/env python3 +"""Frozen five Windows raw 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/raw-capture-qualification-6bcd72a7-6de7-48e6-9e9b-3ad2cd3d9b09' +STATE = ROOT / 'devstate/windows-raw-clock-native-linux' +PROFILE = 'rmm.windows-clock.raw-five-linux-guards.v1' +RECEIPT_SHA = 'ba9ba8d88ed71952dd8dc803f2e38d5da72edeae392818cd320c6fd532ac7f4d' +INPUTS_SHA = '2d21da4d137d2efd48cb2679fb791a9055839b042373d0f38c5af8d9ea8c5a8c' +BINARY_SHA = 'dceee96d9e58d8b5c3606c724b4d390c2eea6472bf33d317e7a5a9102c0c5e06' +BINARY_BYTES = 3404432 +TESTS = sorted(['signed_clock::tests::bracket_uses_actual_capture_width_and_refuses_unqualified_or_backward_counters', 'signed_clock::tests::complete_raw_report_is_bounded_non_authoritative_and_keeps_actual_brackets', 'signed_clock::tests::job_key_cannot_be_reintroduced_as_a_time_key_with_different_hex_case', 'signed_clock::tests::raw_capture_denies_backward_wall_counters_and_incomplete_or_expired_series', '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::complete_raw_report_is_bounded_non_authoritative_and_keeps_actual_brackets', 'signed_clock::tests::job_key_cannot_be_reintroduced_as_a_time_key_with_different_hex_case', 'signed_clock::tests::raw_capture_denies_backward_wall_counters_and_incomplete_or_expired_series', '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) == 190 and source == value['source_files'], 'exact frozen 190 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-raw-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']) == 4539244, 'bounded binary transfer') + raw = base64.b64decode(p['binary_b64'], validate=True) + require(len(raw) == 3404432 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) == 15 and sorted(line[:-6] for line in lines if line.endswith(': test')) == p['all_listed_tests'], 'exact full fifteen-test list before five 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'5 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']), 'five native guards with ten filtered and retained target state') + receipt = dict(id=ident, profile=p['profile'], passed=5, ignored=0, filtered=10, listed=15, 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) == 190 + and receipt['kind'] == 'windows-signed-clock-raw-capture-source-qualification' + and receipt['all_frozen_source_inputs_preserved'] is True + and receipt['calibrated'] is False and receipt['clock_authority'] is False + and receipt['readonly_capabilities_sha256'] == '91c75ba877764345b3267731f3880580d02a72df40420479e3c4b76d37064982' + and receipt['module_sha256'] == 'd9dd843db7c17ac4c8f242c9f20063c2a7ce6ad11d3c75826516a22dc5e7685e' + and next(x for x in receipt['results'] if x['name'] == 'linux-five-targeted') == dict(name='linux-five-targeted',exit_code=0,passed=5,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', 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 56bd8e7..dadd4a6 100644 --- a/docs/handover.md +++ b/docs/handover.md @@ -1,5 +1,14 @@ # Übergabe — Linux-MVP abgeschlossen, Windows wird fortgesetzt +**Rohcapturequellen Linux-first bestanden, noch keine Windowsuhr:** dcef489d, +volle15er-Liste, neue5Guards bestanden/10andere gefiltert, separater Rückabruf +vollständig. [Belege](windows-signed-clock-capture.md). Broker3lokaleGuards, +ServerrouteCheck/Clippy und unabhängige Quellenreviews bestanden. Noch kein +echter Broker-/Chrony-/mTLS-/Windows-Zeitaustausch oder Jobgate. Der +Host→Container-PID0-Integrationsfehler ist sourcekorrigiert, reale +UID-/Namespacesprobe offen. [Brokergrenzen](server-time-broker.md). + + **Linux-Providerunits nativ bestanden:** fe3f5082,4/4/keineSkips/Filter, separater Rückabruf vollständig; bekannte Runtimezeugen erhalten. Nur eigene Socket-/Parser-/Zeitbracketfixtures, keine tatsächliche Chrony-/Kernelquery. diff --git a/docs/server-time-broker.md b/docs/server-time-broker.md new file mode 100644 index 0000000..f9b600b --- /dev/null +++ b/docs/server-time-broker.md @@ -0,0 +1,166 @@ +# Lokaler Linux-Zeitsignierbroker + +Dieser neue Quellpfad trennt den privilegierten, fest begrenzten Zeitprovider +und Zeitsignierschlüssel vom unprivilegierten HTTP-Server. Er ist kein Job- +executor und erteilt keine WebUI-Freigabe, Capability oder TrustedClock-Lease. +Noch kein realer Brokerstart, Schlüsselsetup, Bootstrap oder Zieltest wurde +durch diesen Implementierungsauftrag ausgeführt. Lokale Prüfungen und native +Abnahmen werden getrennt nach tatsächlichem Lauf dokumentiert. + +Das feste Executable akzeptiert keine Argumente. `run()` benötigt einen Root- +Prozess, eröffnet eine einzige fest gepinnte `NativeTimeSource` und verarbeitet +Verbindungen seriell am Unix-Streamsocket +`/run/rmm-time-source/broker.sock`, Listenbacklog4. Kein Internetlistener, +frei wählbarer Pfad/Befehl, IPC-Adminbefehl, dynamischer Interpreter, Jobgrant, +Zeitsetter oder automatisches Provisionieren. Cross-OS bleibt unsupported. + +## Geschütztes Provisionierungsprofil + +Voraussetzungen, **kein ausgeführter Bootstrap**: Geschützte root-eigene +Verzeichnisancestry ohne Symlinks und ohne Gruppen-/Fremdschreibrecht. +`/etc/rmm-time-source/signer.json` regulär root0600, ein Link, höchstens8KiB, +striktes JSON-Schema1 mit diesen Feldern: + +- `server_instance`: nichtleere UUID des festen Servers. +- `key_id` und `key_generation`: eigenes Zeitkey-IDprofil und positive Generation. +- `signing_key_hex`: genau32Bytes privater Ed25519-Zeitschlüssel als64kleine Hexzeichen. +- `forbidden_public_keys`:1–32 eindeutige konkrete öffentliche Fremdrollenschlüssel. +- `expected_server_uid` und `server_gid`: beide ausschließlich10001. + +Keine Schlüsselwerte in Chat, Logs, Receipts oder Git ablegen. Der Broker gibt +bei Prozessfehlern nur eine feste generische Fehlermeldung aus. Config und +Signer besitzen keine Debug-Ausgabe. Root muss den echten Jobsigner sowie +alle bekannten Update-/Health-/TLS-Ed25519-Rollen in die geschützte Verbotsliste +aufnehmen. Der Broker vergleicht dekodierte32Bytewerte mit seinem abgeleiteten +Timepublickey und verweigert jede Wiederverwendung. Eine nichtleere beliebige +Liste beweist allein nicht, dass der Operator alle tatsächlichen Fremdrollen +korrekt erfasst hat. Die Schlüsseldomäne des Codecs bleibt getrennt. + +Gehaltene Datei-/Verzeichnis-FDs, Device/Inode/Konto/Modus/Linkzahl sowie +Länge/mtime/ctime werden kontrolliert. Rootrotation verändert keine laufende +Instanz stillschweigend: sie braucht den gesonderten geschützten Betriebsweg, +Stop und eine neue Brokerinstanz. Kein automatisches Übernehmen neuer Pins. +Die tatsächlichen Prozess-/Image-/PIDpins der Chrony-Instanz gehören separat +zum [nativen Provider](server-time-source.md). Neustart/Boot/Daemonwechsel +brauchen eine neue unabhängig geprüfte Rootprovisionierung; der Broker erfindet +keine Qualität aus einem Autostart oder dem bloßen Vorhandensein der Datei. + +Der Runtimeparent muss für das Serverkonto traversierbar und root-write-only +sein. Der einmalig erzeugte Socket wird root:10001 mit Modus0660 gesetzt, seine gehaltene +Identität nachgeprüft und erst dann auf Listen geschaltet. `SO_PEERCRED` muss +kernelbestätigt PID>1 und UID/GID10001 liefern. Das entspricht dem tatsächlichen +Compose-Profil10001:10001; keine Fallbackidentität. Cleanup entfernt ausschließlich +den exakt selbst erzeugten Namen/Inode per `unlinkat` am gehaltenen Parent-FD. +Ein nach hartem Prozessabbruch verbliebener Socket blockiert den Neustart; +keine automatische Adoption, Entfernung oder Wiederholung auf unklarem Stand. + +Die Rootdiensthärtung ist ein eigenes Operatorarbeitspaket. Für den lesenden +Zugriff auf das Image einer Chrony-Instanz mit anderer UID kann auf dem realen +Server `CAP_SYS_PTRACE` nötig sein. Daraus folgen keine neuen Codepfade für +`ptrace`, `process_vm_*` oder beliebige Prozessdaten. `CAP_SYS_TIME` ist für die +verwendeten ausschließlich lesenden `adjtimex(modes=0)`-Abfragen nicht nötig. +Keine Dienstunit oder Capabilityänderung wurde hier ausgeführt. + +## Fester Draht- und Zeitvertrag + +Genau eine Anfrage pro Verbindung:4Byte Big-Endian-Länge und1–8192Bytes +kanonisches JSON des bestehenden `Request`-Codecs. Unbekannte/duplizierte +Felder, nichtkanonische Bytes, falscher Endpunkt/Rollen-/Bindingschemawert, +zusätzliche bereits angelieferte Bytes oder unvollständige Frames verweigern +vor dem Provider-/Signaturpfad. Danach genau eine analog gerahmte +`SignedAttestation`-Antwort und Verbindungsende. Ein fehlgeschlagener Versuch +wird nicht intern wiederholt. Gesamtes Lese-/Signier-/Schreibbudget250ms, +gemessen mit eigener Monoton- und BOOTTIME; IO arbeitet nonblocking mit verbleibender +Gesamtfrist, nicht mit verlängerbaren Einzelreadtimeouts. Suspend während +des Reads eröffnet nach Resume kein neues Restbudget. + +Vor **jeder** Signatur erfolgt `source.sample()`: tatsächliche gepinnte +Chrony-/Kernel-/Clockprüfung, keine gespeicherte Qualität. Der Payload enthält +nur den kanonischen AnfragesHA und geschützten Server-/Keykontext zusammen mit +dem tatsächlich privat konstruierten Sample. Nach der Probe liest der Broker +selbst REALTIME/MONOTONIC/BOOTTIME und Boot-ID; Rücksprung, Suspend-/Wallclock- +abweichung oder falscher Boot verweigern. Gemessene Erfassungsfenster sind keine +physikalische Timerkalibrierung. + +Das UTCcapture bleibt das ursprüngliche Sample. Die Restzeit bis zur festen +250ms-Gesamtfrist, die bereits seit Samplecapture vergangene Zeit und beide +höchstens10ms-Erfassungsfenster werden vor Signierung konservativ in Fehler- +und Quellaltersobergrenze reserviert. Über500ms Fehler oder1h Quellalter +verweigert. Nach Ed25519-Signierung folgen eigene neue Clock-/Boot-/Frist- +prüfung und erneute geschützte Configprüfung vor Antwort. Kein nachträgliches +Verlängern der Frist und keine kostenlose neue Anfrage/Nonce/Jobberechtigung. +Der unabhängige Empfänger muss weiterhin vollständigen RTT, eigene Capture- +unsicherheit und strikte Deadlinegrenzen prüfen. Es gibt kein Holdover. + +Der Broker authentisiert ausschließlich das lokale Serverkonto. Tenant, +Geräteidentität/mTLS, aktueller Connection-/Enrollment-/Assignmentkontext und +SQLautorisierung sind Pflichten der separaten Serverroute. Eine vom Server +weitergeleitete Helperrolle behauptet keine native Helperprozessattestierung +auf der Serverseite; deren unabhängiger Proof bleibt lokal beim Helper. + +## Tatsächlich lokal geprüft + +Im vorhandenen Offline-Buildimage +`sha256:9a76ad3744ebfdddae96ca10001ce8291c1b332fb54c8df5eea0e8e999ac6fc6`, +UID1000, Quellmount read-only, eigenes `devstate/broker-target`: + +- `cargo test --locked --offline -p rmm-time-broker-linux --all-targets`: + 3Guardtests bestanden,0fehlgeschlagen,0ignoriert,0gefiltert. Die Tests prüfen + synthetische Keyrollen, kanonische Frames und Frist-/Qualitätsüberläufe; + keine echten Schlüsseldateien, Root- oder Provideraufrufe. +- `cargo clippy --locked --offline -p rmm-time-broker-linux --all-targets -- -D warnings`: + bestanden nach Entfernung eines unnötigen `Ok(...?)`; keine Unterdrückung. +- Gezielte `rustfmt --edition2024 --check --config skip_children=true`-Prüfung + der drei eigenen Rustdateien: bestanden. + +Release-Link und ausführbares Brokerbinary werden getrennt mit ihren +exakten Hashes im privaten lokalen Qualifikationsfall festgehalten. Ein Build +oder synthetischer Guardtest ist kein echter IPC-/Signier-/Providerlauf. + +## Offene tatsächliche Gates + +Unabhängiger Quellenreview und native Prüfungen sind separat auszuweisen. Tatsächliche Providerqualität, sichere Schlüssel-/ +Pinprovisionierung, Diensthärtung, Rootbrokerstart auf Linux, mTLS-/SQLroute, +unabhängige Windows-Agent-/SYSTEM-Abnahme und Runtime-/Deadlineintegration +bleiben eigene Gates. Kein Notebook-RMM-Dienst, kein Zielreboot, keine neue +Freigabe- oder Ledgerstrecke folgt aus diesem Quellencheckpoint. + + +## Unabhängiger Review und Serverroute + +Brokerquelle unabhängig geprüft. Privater QualifikationsreceiptSHA256 +`0bc10b7e52ebfc06894eaf38fb070ac6dc14e973940e71c9e03faa9af6fdd409` +bindet13Inputs, tatsächliche lokale3/3Guardtests, Clippy/Fmt sowie +Release-Unitlink und ausführbares Brokerbinary. Keine echte Providerquery, +Schlüsselprovisionierung oder Brokerdienst durch diese Prüfungen. + +Die neue Gatewayroute `/agent/v1/time-attestation` erhält8KiB Größenlimit, +prüft gültiges Geräte-mTLS und die aktuelle gesperrte Tenantinstallationszeile: +Agent/Asset, Enrollment-/Assignment-/Connectiongeneration, Windowsboot und +Windowscapability. Ein bereits fertiger SignedSync wird nicht verlangt, um den +initialen Clock-/Synczyklus zu vermeiden. Die geteilte Installationssperre bleibt +während der begrenzten lokalen Brokeranfrage erhalten; keine Job-/Grant-/ +Outbox- oder Readyänderung. Nur Nonce-/Kontext-/Zeitmaterial wird zurückgegeben. + +Der Container authentisiert den Hostbroker über Kernel-UID0 und den festen +root-eigenen Socket/Inode. Eine Host-PID ist in der eigenen Container- +PIDnamespace nicht sichtbar und kann als0 erscheinen; die erste zusätzliche +PID>1-Prüfung hätte legitime Anfragen blockiert und wurde nach unabhängiger +Analyse entfernt. [Kernel-Credentialabbildung](https://github.com/torvalds/linux/blob/master/net/core/sock.c). +Kein pid:host, privilegierter Container oder UIDremap-Fallback. Unmapped UID/ +abweichender Dateibesitz bleibt deny. Der tatsächliche Namespace-/UIDbeleg ist +vor Deployment noch auszuführen; Endverifier prüfen weiterhin ihren separat +provisionierten Zeitschlüssel und die ganze Originalchallenge. + +Route unabhängig sourcegeprüft; lokales Servercheck und Alltargets-Clippy mit +-Dwarnings nach Namespacekorrektur bestanden. Der erste UID1000-Compilerlauf +stoppte an einem nicht lesbaren bereits vorhandenen Registrycachefile(fnv); +getrennter privater Servertarget/UID0 im unveränderten read-only Offlinecontainer +bestand ohne Rechteaufweichung oder Änderung alter Artefakte. Keine neuen +Server-/DB-/mTLS-Integrationstests oder Produktionsbereitstellung behaupten. + +Die500ms betreffen die Issuefunktion einschließlich Auth-/DBphase; die +Axum-Bytesextraktion liegt davor und ist nur größenbegrenzt. Vier gleichzeitige +Anfragen werden nach der ersten Authquery begrenzt, der lokale Brokerteil auf +300ms. Keine globale TCP-Bodyfrist oder Obergrenze aller Authqueries behaupten. +Detaillierte öffentliche Endpunktlast-/Bodyzeitlimits bleiben späterer Betrieb. diff --git a/docs/windows-signed-clock-capture.md b/docs/windows-signed-clock-capture.md new file mode 100644 index 0000000..2da44c8 --- /dev/null +++ b/docs/windows-signed-clock-capture.md @@ -0,0 +1,197 @@ +# Windows: begrenzte Rohbeobachtung der präzisen Uhrgetter + +Stand2026-11-15, Spezifikation1.22. Dieser getrennte Schnitt bereitet die +tatsächliche Timerbewertung des [signierten Zeitvergleichs](windows-clock-attestation-proposal.md) +vor. **Kein Calibrationpin, kein TrustedClock, keine Jobfähigkeit.** Der frühere +6b66612b-Quellenschnitt und sein184-Input-Snapshot bleiben unverändert erhalten. + +## Gemeinsame Getterfolge, keine alternative Clockautorität + +`signed_clock.rs` verwendet jetzt genau eine private `raw_capture`-Funktion für +installierten Verifier und Diagnose. Ihre feste Reihenfolge ist: + +1. `QueryInterruptTimePrecise` vor der Wallclock; +2. `QueryUnbiasedInterruptTimePrecise` davor; +3. `GetSystemTimePreciseAsFileTime`; +4. `QueryUnbiasedInterruptTimePrecise` danach; +5. `QueryInterruptTimePrecise` danach. + +Alle drei APIs sind dokumentierte VOID-Getter. Auf Windows10+ wird ihr +Vorhandensein vorausgesetzt; kein optionaler Lookup, fremder Zielprozess oder +Fallback. Null-/ungültige Werte und rückläufige Getterintervalle verweigern. +[Unbiasedgetter](https://learn.microsoft.com/en-us/windows/win32/api/realtimeapiset/nf-realtimeapiset-queryunbiasedinterrupttimeprecise), +[Interruptgetter](https://learn.microsoft.com/en-us/windows/win32/api/realtimeapiset/nf-realtimeapiset-queryinterrupttimeprecise). + +Nur der installierte Verifier darf die privaten Rohwerte über seinen bisherigen +`bracket_sample`-Pfad mit einem tatsächlich qualifizierten geschützten +Grundfehlerbudget zu einem `Sample` machen. Der Diagnosepfad hat kein solches +Budget und erzeugt kein `Sample`, keine Signatur, Clockinstanz oder Lease. +Er ruft weder den Konfigurationskonstruktor noch eine Ersatzfreigabe auf. +Der Getterrefactor verändert keine Key-, Nonce-, Continuity-, Connection- oder +WebUI-Grenze. Zusätzliche rohe Rangeguards verweigern lediglich. + +Die Diagnose verwendet exakt128 Captures mit festen nominalen1ms-Zielabständen. +Sie wartet nur mit `spin_loop` und eigener `std::time::Instant`-Beobachtung, +höchstens250ms für die Erhebung. Auch die tatsächlich gelesene gesamte +Interruptspanne darf250ms nicht überschreiten. Rückwärtswerte, eine beobachtete +Diskontinuität über1s, unvollständige Serie oder überschrittenes Budget brechen +ab. Ein Schedulerstillstand wird nach Wiederzuteilung als überschrittenes Budget +verweigert; daraus wird keine präzise Prozess-Endegarantie abgeleitet. + +Der kompakte Rohbericht enthält fünf100ns-Spalten je Zeile: Wallclock-FILETIME, +Interrupt vorher, Unbiased vorher/nachher, Interrupt nachher. Er meldet +tatsächliche Bracketbreite und maximale beobachtete Wall-/Interrupt- sowie +Interrupt-/Unbiaseddifferenzen, Stichprobenzahl und beide verstrichenen Spannen. +`calibrated=false` und `clock_authority=false` bleiben fest. Es gibt keine +Deserialisierung als Clockbeleg und keine Caller-Samples in der nativen API. +Der vollständige Diagnosebericht einschließlich Prozessmetadaten bleibt +höchstens16KiB; keine Host-/Benutzernamen, Peers, Schlüssel oder Kundendaten. + +## Enges eigenes SCM-Fixtureprofil + +Das neue Example `examples/signed_clock_capture.rs` installiert oder konfiguriert +keinen Dienst. Nur ein gesonderter Native-Operator darf nach Source-/Binaryreview +die beiden fest benannten temporären OWN_PROCESS-/Demand-Start-Fixtures anlegen: + +- `RmmSignedClockCaptureLocalService` unter LocalService/SID19; +- `RmmSignedClockCaptureSystem` unter LocalSystem/SID18. + +Beide benötigen ihre eingeschaltete eigene Dienst-SID. Sie werden getrennt +gestartet und beobachtet. Der Prozess prüft tatsächlichen Account und aktivierte +eigene Dienst-SID mit der bestehenden Tokenprüfung; Threadimpersonation, +unbekannter Account und aktivierte Administratorgruppe bei SID19 verweigern. +Elevationflag und Elevationtyp sind separate unverfälschte numerische Angaben. +Ein Administratorprozess kann keinen LocalService-Nachweis ersetzen. + +Feste, **geplante und hier nicht ausgeführte** Argumentform: + +```text +SignedClockCapture.exe --service local-service +SignedClockCapture.exe --service system +``` + +Kein frei wählbarer Dienstname, Pfad, Programm, Skript oder anderer Modus. +Der Prozess startet ausschließlich über den SCM-Dispatcher, meldet nur seinen +eigenen Running-/Stopped-Status und akzeptiert keine Fremddienststeuerung. + +Der Operator muss vorab genau diesen eigenen Case vorbereiten: +`C:\ProgramData\RustDiscoverySignedClockCapture\`. Darin liegt exakt +`SignedClockCapture.exe`; der tatsächlich laufende Imagepfad muss dazu passen. +Basis, Case und Image gehören SYSTEM/Administrators und gewähren höchstens den +beiden festen Fixture-SIDs Lesen. `local-service` und `system` sind getrennte +Unterverzeichnisse; nur die jeweilige eigene Fixture-SID darf dort zusätzlich +schreiben. Keine allgemeine LocalService-/Users-Schreibfreigabe. Beide +Fixture-SIDs müssen für die gemeinsame Leserprüfung auflösbar sein; deshalb +beide Definitionen vor der ersten Probe vorbereiten, keine automatische Anlage +durch den Worker. Reparse, fremde ACLs oder ersetzte gehaltene File-IDs sperren. + +Jeder Rollenlauf erzeugt ausschließlich seine neuen `intent.json`, `report.json` +und `end.json`. Vorhandene Marker verweigern Wiederholung. Dateien werden +create-only mit Reparse-/Linkprüfung geschrieben und geflusht. Gehaltene +Verzeichnisse und Image bleiben erhalten. Nach verlorenem Reply ausschließlich +denselben Originalfall lesen; kein Löschen, Überschreiben oder erneuter Start +zur Umgehung eines unklaren Laufs. Fehlender Endbeleg ist kein Erfolg. + +Der Bericht bindet PID, native Prozessgeburt, Imagehash/File-ID und unabhängig +gewonnene Boot-ID. Die bestehende feste lesende CIM-Bootabfrage läuft vor dem +250ms-Erhebungsbudget; kein Benutzer-/Modellskript. Keine RMM-Konfiguration, +PKI, Journale, Consumption, Helperpins oder tatsächlichen RMM-Dienste werden +geöffnet oder geändert. W32Time wird weder abgefragt noch gesteuert. Es gibt +keinen Netzwerkclient und keine neue RMM-Nachricht oder Capability. + +## Nachweise und Grenzen + +Erster lokaler Vorbereitungslauf: fünf gezielte gemeinsame Guardtests bestanden, +zehn übrige Cratetests ausdrücklich herausgefiltert. GNU-Alltargetscheck und +Clippy mit `-D warnings` bestanden. Dies war eine schnelle Sourceprüfung vor +dem folgenden eingefrorenen Artefaktbeleg, kein nativer Timer- oder Rollennachweis. +Der folgende eingefrorene Artefaktbeleg ergänzt diese Vorprüfung. Eine VM-Aktion +wurde durch diesen Sourceworker nicht ausgeführt. + +Eine konsistente128er-Serie belegt nur diese Beobachtungen unter dem aktuellen +OS-/Hypervisorvertrag. Sie liefert **keine absolute physikalische Genauigkeit** +und keinen bewiesenen Grundfehler durch die größte gemessene Bracketbreite. +Auflösung ist keine Genauigkeit; QPC/Interrupt/Wallclock sind zudem keine +vollständig unabhängigen physikalischen Quellen. Korrektes Verhalten von +Windows-Kernel und Hypervisor bleibt eine ausdrücklich genannte Annahme. +Das erforderliche Grundfehler-Assessment, die geschützte Pinprovisionierung, +reale getrennte Agent-/SYSTEM-Signatur-Roundtrips und Runtime-/Deadlineintegration +bleiben eigene offene MVP-Schritte. Auch eine erfolgreiche temporäre +LocalService-/SYSTEM-Probe ist kein Nachweis der produktiven RMM-Dienstrollen. + + +## Eingefrorener aktueller Source- und Artefaktbeleg + +Neuer eigener Fall6bcd72a7-6de7-48e6-9e9b-3ad2cd3d9b09 bindet190 Inputs. +Der alte184-Input-Fall763baf69 bleibt unverändert. Modul SHA256 +`d9dd843db7c17ac4c8f242c9f20063c2a7ce6ad11d3c75826516a22dc5e7685e`, +Example SHA256 +`23f7c8d832bf9042fb89226729aa1cfe2a65ad33b76cda15cc69f8995d5834d0`. +Inputmanifest SHA256 +`2d21da4d137d2efd48cb2679fb791a9055839b042373d0f38c5af8d9ea8c5a8c`, +Receipt SHA256 +`ba9ba8d88ed71952dd8dc803f2e38d5da72edeae392818cd320c6fd532ac7f4d`. + +Tatsächlich lokal mit den eingefrorenen Quellen und festgelegten Offlineimages: + +- Linux-Release-Lib-Testbinary gelinkt; komplette Liste exakt15 Tests, + 0 Benchmarks. Nur die fünf `signed_clock::tests` ausgeführt:5bestanden, + 0failed/ignored;10 übrige Cratetests ausdrücklich herausgefiltert. +- Windows-GNU-Releaseprobe mit `--features system-helper --example + signed_clock_capture --target x86_64-pc-windows-gnu --release` gelinkt. +- Windows-GNU-Alltargets-Clippy mit `-D warnings` bestanden. +- Formatcheck ausschließlich von Modul und neuem Example bestanden. + +Linuxexe `qualified-linux-tests`:3404432Byte, SHA256 +`dceee96d9e58d8b5c3606c724b4d390c2eea6472bf33d317e7a5a9102c0c5e06`. +Windowsprobe `SignedClockCapture.exe`:8566784Byte, SHA256 +`601c27a43fb67c662f926f9dc289a23a5c31c7e27f62901a77fc9ceaafaea7fb`. +Beide Artefakte exklusiv kopiert und auf0500 begrenzt; private Quell-/Belegdateien +0600, Verzeichnisse0700. Keine älteren qualifizierten Binaries überschrieben. + +Der separat lesbare Capabilitymanifest `readonly-capabilities.json` bindet +Binaries, feste Service-/Konten-/Pfadformen, Clockgetter, eigene Prozess-/ +Bootmetadaten, create-only-Ausgaben, Limits und ausdrücklich fehlende +Netzwerk-/RMM-/Zeitsetter-/Fremddienstoperationen. SHA256 +`91c75ba877764345b3267731f3880580d02a72df40420479e3c4b76d37064982`. +Das beschreibt aufgerufene Operationen; ein SYSTEM-Prozess wird damit nicht zur +Sandbox. Unabhängiger Review und Native-Operator müssen diesen konkreten +Quellen-/Binärstand vor Zielaufruf prüfen. + +Sämtliche Rohbelege bleiben gitignoriert unter +`devstate/windows-signed-clock/raw-capture-qualification-6bcd72a7-6de7-48e6-9e9b-3ad2cd3d9b09/`. +**Nicht durch diesen Worker ausgeführt:** neuer Cloud-Linux-Guardlauf, +LocalService-/SYSTEM-Probe auf Windows, Kalibrierung, Zeitpins, signierter +Serveraustausch oder irgendein RMM-Job. Die vollständige Windows-/MVP-Abnahme +bleibt offen; nächster Schritt ist der getrennte Linux-first-/Windowsnachweis. + + +## Tatsächlicher Linux-first-Nachweis des Rohcapture-Quellenstands + +2026-11-15. Neuer unabhängig geprüfter Runner +`deploy/windows_raw_clock_linux_acceptance.py`, SHA256 +`fa0454839b263acc49285a76e468b908b23f3194f9c663d706f5cc01869bb6c4`, +bindet190Originalinputs und das neue Releasebinary. Vor einem einmaligen Lauf +muss die volle15er-Liste exakt stimmen; ausgeführt wird ausschließlich der +feste `signed_clock::tests::`-Filter. + +Originalfall `dcef489d-2a24-47cc-b3ca-6628545cdacf`: tatsächlich prepare, +ein execute und separater read auf der Cloud-Linux-VM. **5bestanden,0ignored, +10andere Tests gefiltert, Exit0**, Rückabruf vollständig. Bekannte RMM- +Prozessgenerationen, Kontrollbytes, Boot und DB-/Lock-Identitäten erhalten. +Keine RMM-Jobs, W32Time-/Produktzeitabfrage, Dienste oder Produktdateien geändert. + +FallmanifestSHA256 +`3a646b8bdab36ef0185c3a1f68d94bdd6ee541ad00d59c2e1fdebe35c3501549`; +ExecuteSHA256 +`1c53605e2db930f4e8328ff030726c4fecec9e10bbc24aa13284f90249962c36`; +ReadbackSHA256 +`91a750e4de266f5effccbd418a680c1ba4f5e0aff5082489fc021922bdfcafa3`. +Der ursprüngliche Dreierbeleg bleibt historisch unverändert. Keine aktuelle +Gesamtworkspace- oder Windows-Kernelqualifikation aus diesem Linuxlauf ableiten. + +Unabhängiger Quellenreview des d9dd843d-/23f7c8d8-Standes bestanden. Das +Erfassungsbudget250ms gilt ausdrücklich nur für die128Getteraufnahmen; +CIM-Bootlesung und eigener Dienst-/Imagebootstrap sind vorgelagert und brauchen +einen separaten Operatorwatchdog samt tatsächlichem Exitbeleg. Noch keine +Windowsausführung, physikalische Zeitkalibrierung oder Root-/SYSTEMjobfreigabe.