From 6488b6e89dfe7b263834c09c6f50e9cb38bedd8c Mon Sep 17 00:00:00 2001 From: Kevin Janssen Date: Tue, 17 Nov 2026 14:12:18 +0100 Subject: [PATCH] Relax signed time evidence to five minutes with advancing lower bound; keep held evidence across failed refreshes (user decision, spec 1.32) --- Rust_RMM_Implementierungsspezifikation.md | 28 +++++- crates/agent-windows/src/runtime.rs | 10 +-- crates/agent-windows/src/signed_clock.rs | 9 +- crates/time-attestation/src/lib.rs | 104 +++++++++++++++------- docs/project-decisions.md | 12 ++- 5 files changed, 124 insertions(+), 39 deletions(-) diff --git a/Rust_RMM_Implementierungsspezifikation.md b/Rust_RMM_Implementierungsspezifikation.md index dc76908..1e7435f 100644 --- a/Rust_RMM_Implementierungsspezifikation.md +++ b/Rust_RMM_Implementierungsspezifikation.md @@ -1,6 +1,6 @@ # Rust RMM: Architektur und Implementierungsspezifikation -Version 1.31 · 2026-11-17 · Sprache: Deutsch +Version 1.32 · 2026-11-17 · Sprache: Deutsch **Zweck:** Vollständige, eigenständig nutzbare Grundlage für die Implementierung einer mandantenfähigen Plattform zur Inventarisierung, Überwachung und Fernadministration von Kundengeräten durch eine Coding-KI und ein Entwicklungsteam. @@ -74,6 +74,11 @@ Fehlschlag oder Nichtstart wird behauptet, kein Retry, keine neue Genehmigung. Der Abschluss hebt ausschließlich die Gerätesperre für neue, einzeln genehmigte Aufträge auf. Details Kapitel 0.2. +1.31 → 1.32 (2026-11-17): ausdrückliche Userentscheidung „Du kannst das harte +Zeitfenster auflockern … nimm das harte Zeitfenster gerne großzügiger an und +dokumentiere diese Entscheidung“: signierte Zeitbelege bleiben bis zu fünf +Minuten nach Empfang nutzbar (bisher 100 ms). Details Kapitel 0.3. + ## Inhaltsverzeichnis - [0 Auftrag und verbindliche Produktanforderungen](#0-auftrag-und-verbindliche-produktanforderungen) @@ -366,6 +371,27 @@ Mandantentrennung und WebUI-Plangenehmigung bleiben verbindlich. Deploymentdaten, offene Konfiguration und reale Nachweise: `docs/server-deployment.md`. Diese Entscheidung ist kein Deploymentnachweis. +### 0.3 Gelockertes Zeitfenster für signierte Zeitbelege (Version 1.32) + +Userentscheidung 2026-11-17. Die bisherige Gültigkeit eines empfangenen +signierten Zeitbelegs von 100 ms machte SYSTEM-Aufträge praktisch unmöglich: +Der Helper kann während einer Ausführung nicht auffrischen, und jeder kurz +veraltete Beleg beendete Sitzungen oder machte Versuche zu `unknown`. + +- Ein Beleg bleibt bis zu **fünf Minuten** nach Empfang nutzbar + (`MAX_RECEIVED_AGE_NS`). Die Grenze von einer Sekunde gilt weiterhin für den + signierten Umlauf selbst (Anfrage bis Antwort). +- Die untere Intervallgrenze läuft mit der seit Empfang am monotonen + Interrupt-Zähler gemessenen Zeit mit. Beide Grenzen enthalten alle + Erfassungsbudgets und einen Driftzuschlag von 0,1 %. Das Intervall bleibt + dadurch eng, die 2-Sekunden-Prüfung gegen die lokale Uhr bleibt wirksam. +- Ein fehlgeschlagener Auffrischversuch verwirft den gültigen Beleg nicht + mehr. Eine neue Anfrage ersetzt eine unbeantwortete; deren Nonce kann nie + nachträglich vervollständigt werden. +- Unverändert bleiben: Start- und Ablauffenster der Aufträge, maximale + Laufzeit, Signatur-, Bindungs- und Pinprüfungen, Abbruch bei + Generationswechsel, Diskontinuität oder Widerruf. + ### 0.2 Menschlicher Abschluss unbekannter Wirkung (Version 1.31) Userentscheidung 2026-11-17. Ein Job im Zustand `unknown` darf ausschließlich diff --git a/crates/agent-windows/src/runtime.rs b/crates/agent-windows/src/runtime.rs index 624611f..883ae30 100644 --- a/crates/agent-windows/src/runtime.rs +++ b/crates/agent-windows/src/runtime.rs @@ -782,9 +782,8 @@ impl Agent { Ok::<(), anyhow::Error>(()) } .await; - if result.is_err() { - let _ = own_clock.close_generation(generation); - } + // A failed refresh keeps the still-valid held evidence; the next + // begin supersedes the unanswered challenge (no late completion). tokio::time::sleep(mode.interval(result.is_ok())).await; } let _ = own_clock.close_generation(generation); @@ -810,9 +809,8 @@ impl Agent { Ok::<(), anyhow::Error>(()) } .await; - if result.is_err() { - let _ = time_helper.time_close(generation).await; - } + // HELPER_TIME_BUSY during a SYSTEM run or a lost reply keeps the + // helper's held evidence; generation end still closes it below. tokio::time::sleep(mode.interval(result.is_ok())).await; } let _ = time_helper.time_close(generation).await; diff --git a/crates/agent-windows/src/signed_clock.rs b/crates/agent-windows/src/signed_clock.rs index cc2447e..63f390c 100644 --- a/crates/agent-windows/src/signed_clock.rs +++ b/crates/agent-windows/src/signed_clock.rs @@ -875,7 +875,14 @@ mod installed { self.close(); anyhow::bail!("TIME_NATIVE_CONNECTION_CHANGED"); } - ensure!(self.pending.is_none(), "TIME_NATIVE_PENDING"); + // A newer challenge supersedes an unanswered one. Its nonce can never + // be completed later (no transparent retry); held evidence is kept. + if let Some(old) = self.pending.take() + && let Ok(mut state) = process().lock() + && state.active == Some(old.owner) + { + state.active = None; + } self.recheck()?; let mut state = process() .lock() diff --git a/crates/time-attestation/src/lib.rs b/crates/time-attestation/src/lib.rs index 006bb20..f375ce3 100644 --- a/crates/time-attestation/src/lib.rs +++ b/crates/time-attestation/src/lib.rs @@ -10,7 +10,13 @@ use uuid::Uuid; pub const ENDPOINT: &str = "https://discovery.ease-technologies.de/agent/v1/time-attestation"; pub const MAX_RTT_NS: u64 = 1_000_000_000; -pub const MAX_RECEIVED_AGE_NS: u64 = 100_000_000; +/// Held evidence stays usable for five minutes after receipt (operator +/// decision 2026-11-17, spec 1.32). The interval stays tight because its lower +/// bound advances with the monotonic counter time elapsed since receipt. +pub const MAX_RECEIVED_AGE_NS: u64 = 300_000_000_000; +/// Conservative counter-rate allowance against UTC for long-held evidence, +/// far above real guest timer drift (1000 ppm = 0.1 %). +pub const COUNTER_DRIFT_PPM: u64 = 1_000; pub const MAX_CAPTURE_ERROR_NS: u64 = 50_000_000; pub const MAX_SERVER_ERROR_NS: u64 = 500_000_000; pub const MAX_SYNC_AGE_NS: u64 = 3_600_000_000_000; @@ -410,6 +416,11 @@ impl Verifier { .interrupt_ns .checked_sub(evidence.received.interrupt_ns) .ok_or_else(|| anyhow::anyhow!("TIME_COUNTER"))?; + let rtt = evidence + .received + .interrupt_ns + .checked_sub(evidence.begin.interrupt_ns) + .ok_or_else(|| anyhow::anyhow!("TIME_COUNTER"))?; // Include every local capture/timer budget conservatively, never RTT/2. let delta = evidence .begin @@ -421,14 +432,16 @@ impl Verifier { // Use the same full qualified uncertainty for freshness as for UTC-U. // The begin budget is deliberately overcounted for receive age: no // endpoint or timer-underread allowance can disappear at either gate. - let upper_elapsed = elapsed + // The one-second bound applies to the signed round trip itself; the + // held evidence then ages against MAX_RECEIVED_AGE_NS. + let upper_rtt = rtt .checked_add(delta) .ok_or_else(|| anyhow::anyhow!("TIME_ERROR_OVERFLOW"))?; let upper_age = age .checked_add(delta) .ok_or_else(|| anyhow::anyhow!("TIME_ERROR_OVERFLOW"))?; ensure!( - upper_elapsed <= MAX_RTT_NS && upper_age <= MAX_RECEIVED_AGE_NS, + upper_rtt <= MAX_RTT_NS && upper_age <= MAX_RECEIVED_AGE_NS, "TIME_STALE_RESPONSE" ); ensure!( @@ -438,11 +451,20 @@ impl Verifier { .is_some_and(|v| v <= MAX_SYNC_AGE_NS), "TIME_SOURCE_AGE_AT_CHECK" ); - let lower = i128::from(p.captured_utc_ns) - i128::from(p.server_error_ns); + // The server captured before this verifier received the reply, so at + // least the counter time since receipt has passed since the capture. + // Both sides carry every capture budget plus the counter drift allowance. + let drift = |ns: u64| u128::from(ns) * u128::from(COUNTER_DRIFT_PPM) / 1_000_000; + let since_capture_min = u128::from(age) + .saturating_sub(u128::from(delta)) + .saturating_sub(drift(age)); + let lower = i128::from(p.captured_utc_ns) - i128::from(p.server_error_ns) + + i128::try_from(since_capture_min)?; let upper = i128::from(p.captured_utc_ns) + i128::from(p.server_error_ns) + i128::from(elapsed) - + i128::from(delta); + + i128::from(delta) + + i128::try_from(drift(elapsed.saturating_add(delta)))?; let wall = i128::from(checked.wall_utc_ns); ensure!( (wall - lower).abs().max((wall - upper).abs()) <= 2_000_000_000, @@ -537,11 +559,14 @@ mod tests { let result = v .finish(c, &signed, sample(70_000_000), || Ok(sample(80_000_000))) .unwrap(); - assert_eq!(result.lower_utc_ns(), T + 10_000_000); - assert_eq!(result.upper_utc_ns(), T + 113_000_000); + // Lower: capture - server error + (age 10 ms - 3 ms budgets - drift). + assert_eq!(result.lower_utc_ns(), T + 16_990_000); + // Upper: capture + server error + elapsed 80 ms + 3 ms + drift. + assert_eq!(result.upper_utc_ns(), T + 113_083_000); assert!(result.allows_start(T, T + 114_000_000)); assert!(!result.allows_start(T, T + 113_000_000)); - assert!(!result.allows_start(T + 11_000_000, T + 114_000_000)); + assert!(result.allows_start(T + 16_990_000, T + 114_000_000)); + assert!(!result.allows_start(T + 16_990_001, T + 114_000_000)); } #[test] fn updater_uses_own_role_image_nonce_and_preserves_legacy_context_bytes() { @@ -609,10 +634,13 @@ mod tests { let other = SigningKey::from_bytes(&rand::random()); signed = reply(&c, &other, server); } - 3 => checked = sample(MAX_RTT_NS + 1), + 3 => { + received = sample(MAX_RTT_NS + 1); + checked = sample(MAX_RTT_NS + 2); + } 4 => { received = sample(10_000_000); - checked = sample(110_000_001); + checked = sample(10_000_000 + MAX_RECEIVED_AGE_NS + 1); } 5 => { let mut p: Payload = serde_json::from_str(&signed.payload).unwrap(); @@ -690,8 +718,7 @@ mod tests { let next_reply = reply(&next, &key, server); let later = v.check_evidence(&evidence, sample(110_000_000)).unwrap(); assert!(later.upper_utc_ns() > initial.upper_utc_ns()); - assert!(v.check_evidence(&evidence, sample(167_000_000)).is_ok()); - assert!(v.check_evidence(&evidence, sample(167_000_001)).is_err()); + assert!(later.lower_utc_ns() > initial.lower_utc_ns()); assert_eq!( v.pending_nonce.as_deref(), Some(next.request().nonce.as_str()) @@ -702,19 +729,35 @@ mod tests { }) .unwrap(); assert!(v.check_evidence(&fresh, sample(200_000_000)).is_ok()); - assert!(v.check_evidence(&evidence, sample(201_000_000)).is_err()); - - // The one-second bound starts at the original challenge, even when - // the complete response itself was received less than100ms ago. - let c = v.begin(sample(300_000_000)).unwrap(); - let signed = reply(&c, &key, server); - let (evidence, _) = v - .finish_evidence(c, &signed, sample(1_240_000_000), || { - Ok(sample(1_250_000_000)) - }) - .unwrap(); - assert!(v.check_evidence(&evidence, sample(1_297_000_000)).is_ok()); - assert!(v.check_evidence(&evidence, sample(1_297_000_001)).is_err()); + // Held evidence ages only against its own receipt, up to five minutes, + // and its interval stays narrow because the lower bound advances. + let limit = 70_000_000 + MAX_RECEIVED_AGE_NS - 3_000_000; + let held = v.check_evidence(&evidence, sample(limit)).unwrap(); + assert!(held.upper_utc_ns() - held.lower_utc_ns() < 1_000_000_000); + assert_eq!( + v.check_evidence(&evidence, sample(limit + 1)) + .unwrap_err() + .to_string(), + "TIME_STALE_RESPONSE" + ); + // The one-second bound applies to the signed round trip itself. + for (index, (after, ok)) in [ + (MAX_RTT_NS - 3_000_000, true), + (MAX_RTT_NS - 3_000_000 + 1, false), + ] + .into_iter() + .enumerate() + { + let base = limit + (index as u64 + 1) * 10_000_000_000; + let c = v.begin(sample(base)).unwrap(); + let mut p: Payload = serde_json::from_str(&reply(&c, &key, server).payload).unwrap(); + p.captured_utc_ns = T + base as i64 + 20_000_000; + let signed = sign(&p, &key).unwrap(); + let result = v.finish_evidence(c, &signed, sample(base + after), || { + Ok(sample(base + after + 1)) + }); + assert_eq!(result.is_ok(), ok, "round trip {after}"); + } } #[test] fn challenge_freshness_includes_all_capture_budgets_at_one_second() { @@ -727,25 +770,26 @@ mod tests { begin.capture_error_ns = 7_000_000; let c = v.begin(begin).unwrap(); let signed = reply(&c, &key, server); - let mut received = sample(MAX_RTT_NS - delta - 1_000_000); + let mut received = sample(MAX_RTT_NS - delta + excess); received.capture_error_ns = 11_000_000; - let mut checked = sample(MAX_RTT_NS - delta + excess); + let mut checked = sample(MAX_RTT_NS - delta + excess + 10_000_000); checked.capture_error_ns = 13_000_000; let result = v.finish_evidence(c, &signed, received, || Ok(checked)); assert!(v.pending_nonce.is_none()); if excess == 0 { let (evidence, _) = result.unwrap(); assert!(v.check_evidence(&evidence, checked).is_ok()); - let mut later = sample(MAX_RTT_NS - delta + 1); + // A round trip completed within one second stays usable later. + let mut later = sample(MAX_RTT_NS - delta + 60_000_000_000); later.capture_error_ns = checked.capture_error_ns; - assert!(v.check_evidence(&evidence, later).is_err()); + assert!(v.check_evidence(&evidence, later).is_ok()); } else { assert_eq!(result.err().unwrap().to_string(), "TIME_STALE_RESPONSE"); } } } #[test] - fn receive_freshness_includes_all_capture_budgets_at_one_hundred_ms() { + fn receive_freshness_includes_all_capture_budgets_at_five_minutes() { let delta = 31_000_000; for excess in [0, 1] { let (mut v, key, server) = fixture(context(Role::SystemHelper)); diff --git a/docs/project-decisions.md b/docs/project-decisions.md index 82c92b9..1e8ab80 100644 --- a/docs/project-decisions.md +++ b/docs/project-decisions.md @@ -1,6 +1,16 @@ # Verbindliche Projektentscheidungen -Stand: **2026-11-17**, Spezifikation **1.31** (`Rust_RMM_Implementierungsspezifikation.md`). Die ausdrücklichen normativen Entscheidungen in Kapitel 0 haben Vorrang vor früheren Architekturannahmen. Version 1.6 ersetzt die lokale Servertopologie durch den dedizierten Internetserver; Version 1.7 präzisiert das Notebook als reinen Entwicklungsrechner; Version 1.8 erlaubt vorgezogene parallele Windows-Entwicklung. +Stand: **2026-11-17**, Spezifikation **1.32** (`Rust_RMM_Implementierungsspezifikation.md`). Die ausdrücklichen normativen Entscheidungen in Kapitel 0 haben Vorrang vor früheren Architekturannahmen. Version 1.6 ersetzt die lokale Servertopologie durch den dedizierten Internetserver; Version 1.7 präzisiert das Notebook als reinen Entwicklungsrechner; Version 1.8 erlaubt vorgezogene parallele Windows-Entwicklung. + +## Gelockertes Zeitfenster für Zeitbelege (Version 1.32) + +Userentscheidung 17. November 2026: „Du kannst das harte Zeitfenster +auflockern. Mir ist das nicht wichtig … nimm das harte Zeitfenster gerne +großzügiger an und dokumentiere diese Entscheidung.“ Signierte Zeitbelege +gelten jetzt bis fünf Minuten nach Empfang statt 100 ms; die untere +Intervallgrenze läuft mit, Driftzuschlag 0,1 %. Auffrischfehler verwerfen +gültige Belege nicht mehr. Auftragsfristen und alle Vertrauensprüfungen +bleiben unverändert. Details Spezifikation 0.3. ## Menschlicher Abschluss von unknown-Jobs (Version 1.31)