diff --git a/Cargo.lock b/Cargo.lock index 0a0fade..4d37b60 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2249,6 +2249,7 @@ dependencies = [ "rmm-agent-core", "rmm-domain", "rmm-protocol", + "rmm-time-attestation", "rusqlite", "rustls", "rustls-pemfile", @@ -2373,6 +2374,20 @@ dependencies = [ "uuid", ] +[[package]] +name = "rmm-time-attestation" +version = "0.1.0" +dependencies = [ + "anyhow", + "ed25519-dalek", + "hex", + "rand 0.9.5", + "serde", + "serde_json", + "sha2 0.10.9", + "uuid", +] + [[package]] name = "rmm-updater" version = "0.1.0" diff --git a/Cargo.toml b/Cargo.toml index a253138..92fa8e0 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"] +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"] [workspace.package] version = "0.1.0" diff --git a/crates/agent-windows/Cargo.toml b/crates/agent-windows/Cargo.toml index 97f5e6c..3b0804c 100644 --- a/crates/agent-windows/Cargo.toml +++ b/crates/agent-windows/Cargo.toml @@ -31,6 +31,7 @@ uuid.workspace = true rmm-domain = { path = "../domain" } rmm-agent-core = { path = "../agent-core" } rmm-protocol = { path = "../protocol" } +rmm-time-attestation = { path = "../time-attestation" } rusqlite = { version = "0.32.1", features = ["bundled"] } fs2 = "0.4.3" rcgen = { version = "=0.14.10", default-features = false, features = ["crypto", "ring", "pem"] } diff --git a/crates/time-attestation/Cargo.toml b/crates/time-attestation/Cargo.toml new file mode 100644 index 0000000..15f7461 --- /dev/null +++ b/crates/time-attestation/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "rmm-time-attestation" +version.workspace = true +edition.workspace = true +license.workspace = true + +[dependencies] +anyhow.workspace = true +ed25519-dalek = "=2.2.0" +hex.workspace = true +rand.workspace = true +serde.workspace = true +serde_json.workspace = true +sha2.workspace = true +uuid.workspace = true diff --git a/crates/time-attestation/src/lib.rs b/crates/time-attestation/src/lib.rs new file mode 100644 index 0000000..6c16b33 --- /dev/null +++ b/crates/time-attestation/src/lib.rs @@ -0,0 +1,555 @@ +//! Independent online time comparison, never a sync lease or execution permit. +//! Nanoseconds are signed UTC Unix ns, intervals are unsigned ns. Callers must +//! hold their own native clock observations and protected context/pins. +use anyhow::{Result, ensure}; +use ed25519_dalek::{Signature, Signer, SigningKey, VerifyingKey}; +use serde::{Deserialize, Serialize}; +use sha2::{Digest, Sha256}; +use std::collections::BTreeMap; +use uuid::Uuid; + +pub const ENDPOINT: &str = "https://discovery.ease-technologies.de/api/agent/v1/time-attestation"; +pub const MAX_RTT_NS: u64 = 1_000_000_000; +pub const MAX_RECEIVED_AGE_NS: u64 = 100_000_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; +const DOMAIN: &[u8] = b"RMM-TIME-ATTESTATION/v1\0"; +const MAX_BYTES: usize = 8192; + +#[derive(Clone, Copy, Debug, Deserialize, Serialize, PartialEq, Eq)] +#[serde(rename_all = "snake_case")] +pub enum Role { + Agent, + SystemHelper, +} + +#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)] +#[serde(deny_unknown_fields)] +pub struct Context { + pub tenant_id: Uuid, + pub asset_id: Uuid, + pub agent_id: Uuid, + pub enrollment_generation: u64, + pub assignment_generation: u64, + pub connection_generation: u64, + pub windows_boot_id: Uuid, + pub verifier_incarnation: Uuid, + pub role: Role, + pub helper_image_sha256: Option, + pub binding_schema: u32, +} +impl Context { + pub fn validate(&self) -> Result<()> { + ensure!( + [ + self.tenant_id, + self.asset_id, + self.agent_id, + self.windows_boot_id, + self.verifier_incarnation + ] + .iter() + .all(|v| !v.is_nil()), + "TIME_CONTEXT_ID" + ); + ensure!( + self.enrollment_generation > 0 + && self.assignment_generation > 0 + && self.connection_generation > 0 + && self.binding_schema == 1, + "TIME_CONTEXT_GENERATION" + ); + match self.role { + Role::Agent => ensure!( + self.helper_image_sha256.is_none(), + "TIME_AGENT_HELPER_IMAGE" + ), + Role::SystemHelper => { + exact_hex(self.helper_image_sha256.as_deref().unwrap_or(""), 32)?; + } + } + Ok(()) + } +} +#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)] +#[serde(deny_unknown_fields)] +pub struct Request { + pub version: u32, + pub endpoint: String, + pub nonce: String, + pub context: Context, +} +impl Request { + pub fn validate(&self) -> Result<()> { + ensure!( + self.version == 1 && self.endpoint == ENDPOINT, + "TIME_REQUEST_PROFILE" + ); + exact_hex(&self.nonce, 32)?; + self.context.validate() + } + pub fn sha256(&self) -> Result { + self.validate()?; + Ok(hex::encode(Sha256::digest(serde_json::to_vec(self)?))) + } +} + +#[derive(Clone, Debug, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +pub struct Payload { + pub version: u32, + pub request_sha256: String, + pub server_instance: Uuid, + pub server_boot_id: Uuid, + pub key_id: String, + pub key_generation: u64, + pub captured_utc_ns: i64, + pub server_error_ns: u64, + pub source_sync_age_ns: u64, +} +#[derive(Clone, Debug, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +pub struct SignedAttestation { + /// Exact canonical JSON bytes (UTF-8); verification never normalizes input. + pub payload: String, + pub signature_hex: String, +} +fn exact_hex(value: &str, bytes: usize) -> Result<()> { + ensure!( + value.len() == bytes * 2 + && value + .bytes() + .all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b)), + "TIME_HEX_FORMAT" + ); + Ok(()) +} +fn validate_payload(p: &Payload) -> Result<()> { + ensure!( + p.version == 1 && !p.server_instance.is_nil() && !p.server_boot_id.is_nil(), + "TIME_SERVER_CONTEXT" + ); + ensure!( + !p.key_id.is_empty() + && p.key_id.len() <= 64 + && p.key_id + .bytes() + .all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'_') + && p.key_generation > 0, + "TIME_KEY_CONTEXT" + ); + exact_hex(&p.request_sha256, 32)?; + ensure!( + p.captured_utc_ns > 0 + && p.server_error_ns <= MAX_SERVER_ERROR_NS + && p.source_sync_age_ns <= MAX_SYNC_AGE_NS, + "TIME_SERVER_QUALITY" + ); + Ok(()) +} +/// Only server code which has independently qualified the native source may +/// construct/sign this payload. This codec is not a provider qualification. +pub fn sign(payload: &Payload, key: &SigningKey) -> Result { + validate_payload(payload)?; + let raw = serde_json::to_string(payload)?; + let mut message = DOMAIN.to_vec(); + message.extend_from_slice(raw.as_bytes()); + Ok(SignedAttestation { + payload: raw, + signature_hex: hex::encode(key.sign(&message).to_bytes()), + }) +} +/// Loaded through the verifier's protected configuration, never an HTTP reply. +pub struct Pins { + generation: u64, + server_instance: Uuid, + keys: BTreeMap, +} +impl Pins { + pub fn new( + generation: u64, + server_instance: Uuid, + keys: BTreeMap, + ) -> Result { + ensure!( + generation > 0 && !server_instance.is_nil() && !keys.is_empty() && keys.len() <= 8, + "TIME_PINS" + ); + let keys = keys + .into_iter() + .map(|(id, raw)| Ok((id, VerifyingKey::from_bytes(&raw)?))) + .collect::>()?; + Ok(Self { + generation, + server_instance, + keys, + }) + } +} +/// A native, locally captured observation; ns counters share one process's OS +/// clock domains. capture_error_ns must come from platform qualification. +#[derive(Clone, Copy, Debug)] +pub struct Sample { + pub wall_utc_ns: i64, + pub interrupt_ns: u64, + pub unbiased_ns: u64, + pub capture_error_ns: u64, +} +impl Sample { + fn validate(self) -> Result<()> { + ensure!( + self.wall_utc_ns > 0 && self.capture_error_ns <= MAX_CAPTURE_ERROR_NS, + "TIME_LOCAL_SAMPLE" + ); + Ok(()) + } +} +/// Opaque, noncloneable request authority: one attempt consumes it even when +/// signature/quality checks fail. A transported Request alone is no authority. +pub struct Challenge { + request: Request, + begin: Sample, + epoch: u64, + verifier_id: Uuid, +} +impl Challenge { + pub fn request(&self) -> &Request { + &self.request + } +} +/// Lives with the verifier process; callers must not reconstruct it to clear a +/// discontinuity. Native adapters additionally preserve the process-wide fence. +pub struct Verifier { + context: Context, + pins: Pins, + previous: Option, + epoch: u64, + pending_nonce: Option, + verifier_id: Uuid, +} +impl Verifier { + pub fn new(context: Context, pins: Pins) -> Result { + context.validate()?; + Ok(Self { + context, + pins, + previous: None, + epoch: 1, + pending_nonce: None, + verifier_id: Uuid::new_v4(), + }) + } + pub fn invalidate(&mut self) { + self.pending_nonce = None; + self.epoch = if self.epoch == 0 { + 0 + } else { + self.epoch.checked_add(1).unwrap_or(0) + }; + } + pub fn observe(&mut self, sample: Sample) -> Result<()> { + if let Err(error) = sample.validate() { + self.invalidate(); + return Err(error); + } + let continuous = self.previous.is_none_or(|p| { + match ( + sample.wall_utc_ns.checked_sub(p.wall_utc_ns), + sample.interrupt_ns.checked_sub(p.interrupt_ns), + sample.unbiased_ns.checked_sub(p.unbiased_ns), + ) { + (Some(w), Some(i), Some(u)) if w >= 0 => { + (w as u64).abs_diff(i) <= MAX_RTT_NS && i.abs_diff(u) <= MAX_RTT_NS + } + _ => false, + } + }); + self.previous = Some(sample); + if !continuous { + self.invalidate(); + } + ensure!(continuous, "TIME_DISCONTINUITY"); + Ok(()) + } + pub fn begin(&mut self, sample: Sample) -> Result { + self.observe(sample)?; + ensure!( + self.epoch > 0 && self.pending_nonce.is_none(), + "TIME_CHALLENGE_OUTSTANDING_OR_EXHAUSTED" + ); + let nonce: [u8; 32] = rand::random(); + let request = Request { + version: 1, + endpoint: ENDPOINT.into(), + nonce: hex::encode(nonce), + context: self.context.clone(), + }; + request.validate()?; + self.pending_nonce = Some(request.nonce.clone()); + Ok(Challenge { + request, + begin: sample, + epoch: self.epoch, + verifier_id: self.verifier_id, + }) + } + pub fn finish( + &mut self, + challenge: Challenge, + signed: &SignedAttestation, + received: Sample, + capture_checked: impl FnOnce() -> Result, + ) -> Result { + let owned = challenge.verifier_id == self.verifier_id + && self.pending_nonce.as_deref() == Some(challenge.request.nonce.as_str()) + && challenge.epoch == self.epoch + && challenge.request.context == self.context; + self.pending_nonce = None; + ensure!(owned, "TIME_CHALLENGE_NOT_OWNED"); + self.observe(received)?; + ensure!(signed.payload.len() <= MAX_BYTES, "TIME_PAYLOAD_LIMIT"); + let p: Payload = serde_json::from_str(&signed.payload)?; + ensure!( + serde_json::to_string(&p)? == signed.payload, + "TIME_NONCANONICAL_PAYLOAD" + ); + validate_payload(&p)?; + ensure!( + p.request_sha256 == challenge.request.sha256()? + && p.server_instance == self.pins.server_instance + && p.key_generation == self.pins.generation, + "TIME_BINDING" + ); + let key = self + .pins + .keys + .get(&p.key_id) + .ok_or_else(|| anyhow::anyhow!("TIME_KEY_NOT_PINNED"))?; + exact_hex(&signed.signature_hex, 64)?; + let signature = Signature::from_slice(&hex::decode(&signed.signature_hex)?)?; + let mut message = DOMAIN.to_vec(); + message.extend_from_slice(signed.payload.as_bytes()); + key.verify_strict(&message, &signature)?; + let checked = capture_checked()?; + self.observe(checked)?; + let elapsed = checked + .interrupt_ns + .checked_sub(challenge.begin.interrupt_ns) + .ok_or_else(|| anyhow::anyhow!("TIME_COUNTER"))?; + let age = checked + .interrupt_ns + .checked_sub(received.interrupt_ns) + .ok_or_else(|| anyhow::anyhow!("TIME_COUNTER"))?; + ensure!( + elapsed <= MAX_RTT_NS && age <= MAX_RECEIVED_AGE_NS, + "TIME_STALE_RESPONSE" + ); + // Include every local capture budget conservatively, never RTT/2. + let delta = challenge + .begin + .capture_error_ns + .checked_add(received.capture_error_ns) + .and_then(|d| d.checked_add(checked.capture_error_ns)) + .ok_or_else(|| anyhow::anyhow!("TIME_ERROR_OVERFLOW"))?; + ensure!(delta <= MAX_CAPTURE_ERROR_NS, "TIME_CAPTURE_BUDGET"); + ensure!( + p.source_sync_age_ns + .checked_add(elapsed) + .and_then(|v| v.checked_add(delta)) + .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); + let upper = i128::from(p.captured_utc_ns) + + i128::from(p.server_error_ns) + + i128::from(elapsed) + + i128::from(delta); + let wall = i128::from(checked.wall_utc_ns); + ensure!( + (wall - lower).abs().max((wall - upper).abs()) <= 2_000_000_000, + "TIME_LOCAL_WALL_OUTSIDE_BOUND" + ); + Ok(Interval { + lower_utc_ns: lower.try_into()?, + upper_utc_ns: upper.try_into()?, + }) + } +} +/// Fresh result only. Adapters must recapture/reverify for later use; this type +/// carries no lease, serialization or execution authorization. +#[derive(Debug)] +pub struct Interval { + lower_utc_ns: i64, + upper_utc_ns: i64, +} +impl Interval { + pub fn lower_utc_ns(&self) -> i64 { + self.lower_utc_ns + } + pub fn upper_utc_ns(&self) -> i64 { + self.upper_utc_ns + } + pub fn allows_start(&self, not_before_ns: i64, start_before_ns: i64) -> bool { + self.lower_utc_ns >= not_before_ns && self.upper_utc_ns < start_before_ns + } +} + +#[cfg(test)] +mod tests { + use super::*; + const T: i64 = 1_800_000_000_000_000_000; + fn sample(elapsed: u64) -> Sample { + Sample { + wall_utc_ns: T + elapsed as i64, + interrupt_ns: 10_000_000_000 + elapsed, + unbiased_ns: 9_000_000_000 + elapsed, + capture_error_ns: 1_000_000, + } + } + fn context(role: Role) -> Context { + Context { + tenant_id: Uuid::new_v4(), + asset_id: Uuid::new_v4(), + agent_id: Uuid::new_v4(), + enrollment_generation: 1, + assignment_generation: 1, + connection_generation: 2, + windows_boot_id: Uuid::new_v4(), + verifier_incarnation: Uuid::new_v4(), + role, + helper_image_sha256: (role == Role::SystemHelper).then(|| "ab".repeat(32)), + binding_schema: 1, + } + } + fn fixture(context: Context) -> (Verifier, SigningKey, Uuid) { + let key = SigningKey::from_bytes(&rand::random()); + let server = Uuid::new_v4(); + let pins = Pins::new( + 4, + server, + BTreeMap::from([("time1".into(), key.verifying_key().to_bytes())]), + ) + .unwrap(); + (Verifier::new(context, pins).unwrap(), key, server) + } + fn reply(c: &Challenge, key: &SigningKey, server: Uuid) -> SignedAttestation { + sign( + &Payload { + version: 1, + request_sha256: c.request().sha256().unwrap(), + server_instance: server, + server_boot_id: Uuid::new_v4(), + key_id: "time1".into(), + key_generation: 4, + captured_utc_ns: T + 20_000_000, + server_error_ns: 10_000_000, + source_sync_age_ns: 100_000_000_000, + }, + key, + ) + .unwrap() + } + #[test] + fn signed_roundtrip_uses_entire_rtt_and_strict_deadline_interval() { + let (mut v, key, server) = fixture(context(Role::SystemHelper)); + let c = v.begin(sample(0)).unwrap(); + let signed = reply(&c, &key, server); + 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); + 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)); + } + #[test] + fn tampering_wrong_role_nonce_key_and_delays_never_open() { + for mutation in 0..7 { + let (mut v, key, server) = fixture(context(Role::Agent)); + let c = v.begin(sample(0)).unwrap(); + let mut signed = reply(&c, &key, server); + let mut received = sample(70_000_000); + let mut checked = sample(80_000_000); + match mutation { + 0 => { + let mut bytes = hex::decode(&signed.signature_hex).unwrap(); + bytes[0] ^= 1; + signed.signature_hex = hex::encode(bytes); + } + 1 => { + let mut p: Payload = serde_json::from_str(&signed.payload).unwrap(); + p.request_sha256 = "cd".repeat(32); + signed = sign(&p, &key).unwrap(); + } + 2 => { + let other = SigningKey::from_bytes(&rand::random()); + signed = reply(&c, &other, server); + } + 3 => checked = sample(MAX_RTT_NS + 1), + 4 => { + received = sample(10_000_000); + checked = sample(110_000_001); + } + 5 => { + let mut p: Payload = serde_json::from_str(&signed.payload).unwrap(); + p.key_generation = 3; + signed = sign(&p, &key).unwrap(); + } + _ => signed.payload.push(' '), + } + assert!( + v.finish(c, &signed, received, || Ok(checked)).is_err(), + "mutation {mutation}" + ); + assert!(v.pending_nonce.is_none()); + } + let ctx = context(Role::Agent); + let (mut a, key, server) = fixture(ctx.clone()); + let (mut b, _, _) = fixture(ctx); + let ca = a.begin(sample(0)).unwrap(); + let signed = reply(&ca, &key, server); + let _cb = b.begin(sample(0)).unwrap(); + assert!( + b.finish(ca, &signed, sample(20_000_000), || Ok(sample(30_000_000))) + .is_err() + ); + } + #[test] + fn foreign_reply_cannot_reenable_an_older_own_challenge() { + let (mut a, key_a, server_a) = fixture(context(Role::Agent)); + let (mut b, key_b, server_b) = fixture(context(Role::Agent)); + let ca = a.begin(sample(0)).unwrap(); + let reply_a = reply(&ca, &key_a, server_a); + let old_b = b.begin(sample(0)).unwrap(); + let old_reply_b = reply(&old_b, &key_b, server_b); + assert!( + b.finish(ca, &reply_a, sample(10_000_000), || Ok(sample(20_000_000))) + .is_err() + ); + let _current_b = b.begin(sample(30_000_000)).unwrap(); + assert!( + b.finish(old_b, &old_reply_b, sample(40_000_000), || Ok(sample( + 50_000_000 + ))) + .is_err() + ); + } + #[test] + fn discontinuity_invalidates_outstanding_and_requires_new_challenge() { + let (mut v, key, server) = fixture(context(Role::SystemHelper)); + let c = v.begin(sample(0)).unwrap(); + let signed = reply(&c, &key, server); + let mut resumed = sample(2_000_000_000); + resumed.unbiased_ns = 9_000_000_000; + assert!(v.observe(resumed).is_err()); + assert!(v.finish(c, &signed, resumed, || Ok(resumed)).is_err()); + // A new post-discontinuity challenge is permitted, no old nonce reuse. + let c = v.begin(resumed).unwrap(); + let mut p: Payload = serde_json::from_str(&reply(&c, &key, server).payload).unwrap(); + p.captured_utc_ns = resumed.wall_utc_ns; + let signed = sign(&p, &key).unwrap(); + assert!(v.finish(c, &signed, resumed, || Ok(resumed)).is_ok()); + } +} diff --git a/deploy/time_attestation_linux_acceptance.py b/deploy/time_attestation_linux_acceptance.py new file mode 100644 index 0000000..70086a8 --- /dev/null +++ b/deploy/time_attestation_linux_acceptance.py @@ -0,0 +1,309 @@ +#!/usr/bin/env python3 +"""Frozen four Linux time-contract units only; 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/time-attestation-qualification/368c42aa-de32-41cd-85fe-c15637cd57a9' +STATE = ROOT / 'devstate/time-attestation-linux' +PROFILE = 'rmm.time-attestation.four-contract-units.v1' +RECEIPT_SHA = 'a50017a1a80042351a639ab2fa8f813435d7d40bd236331dd34f075e98cd09eb' +INPUTS_SHA = 'c01a21bfa09a77b7fa529b85931ac111d08f0dcce137e6aa86a9a22c2c35cf73' +BINARY_SHA = '0e06243dc6d9d502681fb62f755bf5267140a483f89ae61cd6a2e31201a85a13' +BINARY_BYTES = 1515200 +TESTS = sorted(['tests::foreign_reply_cannot_reenable_an_older_own_challenge', 'tests::signed_roundtrip_uses_entire_rtt_and_strict_deadline_interval', 'tests::discontinuity_invalidates_outstanding_and_requires_new_challenge', 'tests::tampering_wrong_role_nonce_key_and_delays_never_open']) +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 <= 2 * 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['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) == 4 and source == value['source_files'], 'exact frozen four codec 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 / 'time-contract-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-time-attestation-tests-' + 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']) == 2020268, 'bounded binary transfer') + raw = base64.b64decode(p['binary_b64'], validate=True) + require(len(raw) == 1515200 and hashlib.sha256(raw).hexdigest() == p['binary_sha256'], 'fixed four-unit binary') + binary = folder / 'time-contract-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) == 4 and sorted(line[:-6] for line in lines if line.endswith(': test')) == p['tests'], 'exact four tests before any run') + create(folder / 'entered.json', enc({'id': ident, 'run_once': True, 'time_ns': time.time_ns()})) + code, stdout, stderr = run(command + ['--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'4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out' in stdout + and all((b'test ' + name.encode() + b' ... ok') in stdout for name in p['tests']), 'four native units and retained target state') + receipt = dict(id=ident, profile=p['profile'], passed=4, ignored=0, filtered=0, 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) == 4 + and receipt['result'] == 'LOCAL_DEBUG_TIME4_PASS_RELEASE_LINKED' and receipt['tests'] == 4 + and receipt['skips'] == 0 and receipt['filters'] == 0, 'reviewed four-test 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-time-tests' + support.require(receipt['artifacts'][0] == dict(path='qualified-time-tests', bytes=BINARY_BYTES, sha256=BINARY_SHA), 'fixed original linked artifact') + copy_exact(binary, folder / 'time-contract-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, 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, 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 / 'time-contract-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 c412d33..680caf2 100644 --- a/docs/handover.md +++ b/docs/handover.md @@ -1,5 +1,13 @@ # Übergabe — Linux-MVP abgeschlossen, Windows wird fortgesetzt +**Signierter Zeitvergleich, erster tatsächlicher Linuxbeleg:** Gemeinsamer +Codec/Verifier nach Nonce-Replayfix im Originalfall2b282376 nativ4/4 bestanden, +separater Readback abgeschlossen, bekannte Runtimezeugen erhalten. +[Ergebnisse und klare Integrationsgrenzen](signed-time-contract-results.md). +Keine Server-/Windows-Zeitqualifikation oder Jobgateöffnung; Audiencepfad vor +Transportintegration noch an bestehenden /agent/v1-Vertrag angleichen. + + **Userentscheidung1.22:** Signierter unabhängiger Windows-Zeitvergleich mit festgelegtem Server ausdrücklich zur Umsetzung erlaubt; Agent und SYSTEM prüfen separat, fehlende Qualität sperrt. Normativ Kapitel0/Projektentscheidungen, diff --git a/docs/signed-time-contract-results.md b/docs/signed-time-contract-results.md new file mode 100644 index 0000000..fb282bc --- /dev/null +++ b/docs/signed-time-contract-results.md @@ -0,0 +1,81 @@ +# Signierter Zeitvergleich: gemeinsamer Prüfkern nativ auf Linux + +2026-11-14, Spezifikation1.22. Neuer gemeinsamer Codec/Verifier implementiert; +noch kein vertrauenswürdiger produktiver Zeitadapter oder Windowsjobgate. + +`rmm-time-attestation` bindet kanonische JSONbytes mit eigener Ed25519-Domäne, +geschützte Schlüsselgeneration/Serverinstanz, vollständigen Requesthash, +Geräte-/Boot-/Verbindungs-/Rollenbezug und eine pro Verifier gehaltene aktuelle +Nonce. Challenges sind nicht klonbar und werden auch bei Fehler verbraucht. +Der Verifier misst nach Signaturprüfung erneut über den nativen Caller. +Ganze RTT, drei Capturebudgets und Serverfehler gehen konservativ in die +UTCspanne ein; Startfristen müssen deren beide Grenzen erfüllen. Keine neue +Jobautorität, kein Synclease, kein Holdover und keine Uhrstellung. + +Das unabhängige Review fand einen echten Replayfehler: Nach fremder +Fehlerantwort konnte ein alter eigener Challenge unter einem neuen offenen +Slot akzeptiert werden. Der Fix hält die exakte aktuelle Nonce zusätzlich zu +Verifier-ID/Epoch/Context; ein gezielter Gegenfall prüft die gesamte Sequenz. +Der erste lokale Signatur-Negativtest konnte durch Ersetzen mit00 zufällig +unverändert bleiben; jetzt verändert XOR1 garantiert ein Signaturbyte. +Diese ursprünglichen Fehler werden nicht als erfolgreiche Prüfungen geführt. + +## Tatsächliche lokale und native Prüfungen + +Lokal debug4/4, keine Skips/Filter. Finale eingefrorene Quelle separat Release +gebaut und gelinkt, Clippy-Dwarnings und Formatcheck bestanden, Offlinebuilder +9a76ad3744eb. Qualifikationsreceipt SHA256 +`a50017a1a80042351a639ab2fa8f813435d7d40bd236331dd34f075e98cd09eb`. +Ein vorheriger Qualifikationsfall stoppte korrekt an `--locked`, als parallel +nur die neue Windows-Abhängigkeitskante ergänzt worden war. Nach deren enger +Lockdateiergänzung entstand ein neuer, vollständig bestandener lokaler Fall. +Keine alten Belege ersetzt, keine Abhängigkeitsversion geändert. + +Vier eingefrorene Inputs: Workspace-/Crate-Manifeste, Cargo.lock und Codecquelle. +Inputmanifest SHA256 +`c01a21bfa09a77b7fa529b85931ac111d08f0dcce137e6aa86a9a22c2c35cf73`. +Releaseexe1515200Byte, SHA256 +`0e06243dc6d9d502681fb62f755bf5267140a483f89ae61cd6a2e31201a85a13`. +Nur der gemeinsame Prüfkern, keine übrigen Workspacequellen qualifiziert. + +Der unabhängig geprüfte neue Runner +`deploy/time_attestation_linux_acceptance.py`, SHA256 +`7572171fee75b5e994253e8190871778e439f8575691256d644a405e23cdaac6`, +verlangt die exakte native Viererliste vor einem einzigen Lauf. Originalfall +`2b282376-5002-4a75-91e2-8928fa8688cd` auf der Cloud-Linux-VM: +**4/4,0ignored/filtered, Exit0**, separater lesender Rückabruf vollständig. + +Tatsächlich ausgeführte Originalbefehle: + +```sh +python3 deploy/time_attestation_linux_acceptance.py prepare +python3 deploy/time_attestation_linux_acceptance.py execute --case 2b282376-5002-4a75-91e2-8928fa8688cd +python3 deploy/time_attestation_linux_acceptance.py read --case 2b282376-5002-4a75-91e2-8928fa8688cd +``` + +Fallmanifest SHA256 +`60d306685fa8b37217cd973aa5ff19b3a520aaab9154eb3e77cc1450f802212c`; +Execute-Beleg SHA256 +`282a597183ed02f4c767407aa7ed94975f8e3571d56eaa6835bb9bbe429e8fb0`; +Readback SHA256 +`1156610d7b41d92b3f55932d3b39547c2e0f24ee906edf00fd43860419e952b5`. +Bekannte drei RMM-Prozessgenerationen, Boot, vier Kontrollbytebelege und +DB-/Lock-Dateiidentitäten blieben vor/nach sowie beim Readback gleich. +APT inaktiv/disabled, Full aktiv/Autostart disabled. Keine Dienststeuerung, +Produktzeitabfrage, RMM-Jobs, Dateitausche oder vollständige SQL-/PKI-Abnahme. +Die Tests erzeugen nur kurzlebige In-Memory-Signierschlüssel/Codecfixtures. + +## Offene Integration + +Der native Beleg prüft Codecbytes und Validatoren, keine Server-/Windows- +Zeitqualität oder komplette Runtime. Geschützte Pinprovisionierung, tatsächliche +Chrony-/Kernelquelle samt lokalem Signierbroker, mTLS-/SQL-Kontextprüfung, +unabhängiger Windows-Agent/SYSTEM-Timerbeleg und Jobintegration bleiben offen. +Der erste Codec bindet noch den provisorischen Audiencepfad +`/api/agent/v1/time-attestation`; vor Transportintegration muss er an den +bestehenden `/agent/v1/...`-Vertrag angeglichen und als neuer Quellenstand +geprüft werden. Keine zusätzliche öffentliche API-Wildcard vorsehen und den +ursprünglichen nativen Beleg dabei nicht nachträglich umetikettieren. + +Die unverbundene Windows-Slice-/Providerentwicklung parallel dazu eröffnet +keine Capability. Das Windows-MVP und der Selbstupdater sind nicht abgeschlossen.