From 7fd17272d564569cb86dc73c8f2c388314550a9c Mon Sep 17 00:00:00 2001 From: Kevin Janssen Date: Tue, 17 Nov 2026 15:56:18 +0100 Subject: [PATCH] Integrate signed agent catalog, tenant enrollment and HTTPS installers --- Cargo.lock | 1 + crates/agent-windows/Cargo.toml | 5 + .../examples/helper_peer_controls.rs | 4 + .../examples/windows_quiescent_stop.rs | 532 +++++++ .../examples/windows_sync_diagnostic.rs | 47 + .../examples/windows_updater_bootstrap.rs | 245 ++++ .../src/bin/rmm-updater-windows.rs | 25 + .../agent-windows/src/certificate_rotation.rs | 68 +- crates/agent-windows/src/helper_ipc.rs | 59 +- crates/agent-windows/src/helper_runtime.rs | 481 ++++++- crates/agent-windows/src/helper_system.rs | 338 +++-- crates/agent-windows/src/lib.rs | 45 + crates/agent-windows/src/main.rs | 7 + crates/agent-windows/src/reboot.rs | 279 ++++ crates/agent-windows/src/release_platform.rs | 14 + crates/agent-windows/src/release_service.rs | 459 ++++++ .../src/release_service_switch.ps1 | 28 + crates/agent-windows/src/runtime.rs | 423 +++++- crates/agent-windows/src/service.rs | 9 +- crates/agent-windows/src/signed_clock.rs | 263 +++- .../agent-windows/src/system_capabilities.rs | 327 ++++- crates/agent-windows/src/update_admission.rs | 670 +++++++++ crates/agent-windows/src/update_cache.rs | 221 +++ crates/agent-windows/src/update_control.rs | 1254 +++++++++++++++++ .../agent-windows/src/update_control_ipc.rs | 301 ++++ crates/agent-windows/src/update_download.rs | 111 ++ crates/agent-windows/src/update_ipc.rs | 419 ++++++ .../src/update_native/control_fence.rs | 417 ++++++ .../agent-windows/src/update_native/fence.rs | 230 +++ .../agent-windows/src/update_native/files.rs | 217 ++- crates/agent-windows/src/update_native/mod.rs | 7 + .../src/update_native/services.rs | 492 ++++++- .../src/update_native/transition.rs | 6 +- .../src/update_observation_runtime.rs | 57 + crates/agent-windows/src/update_observer.rs | 89 ++ crates/agent-windows/src/update_original.rs | 196 +++ crates/agent-windows/src/update_owned.rs | 830 +++++++++++ crates/agent-windows/src/update_record.rs | 354 +++++ crates/agent-windows/src/update_state.rs | 727 ++++++++++ .../src/update_time_transport.rs | 164 +++ crates/agent-windows/src/update_trust.rs | 627 +++++++++ crates/agent-windows/src/update_worker.rs | 799 +++++++++++ crates/agent/src/agent_update_health.rs | 2 +- crates/domain/examples/agent_update_golden.rs | 4 +- crates/domain/src/agent_update.rs | 4 +- crates/domain/src/inventory_document.rs | 7 +- crates/server/src/agent_service.rs | 7 +- crates/server/src/agent_update_health.rs | 2 +- crates/server/src/agent_updates.rs | 158 ++- crates/server/src/api.rs | 4 +- crates/server/src/bootstrap/install.ps1 | 205 +++ crates/server/src/bootstrap/install.sh | 7 + crates/server/src/bootstrap/lifecycle.py | 400 ++++++ crates/server/src/bootstrap/mod.rs | 88 ++ crates/server/src/jobs.rs | 25 +- crates/server/src/update_artifact_store.rs | 2 +- crates/server/src/windows_echo_probe.rs | 2 +- crates/updater-worker/src/main.rs | 5 + crates/updater/Cargo.toml | 1 + crates/updater/src/bootstrap.rs | 45 + crates/updater/src/lib.rs | 3 + crates/updater/src/manifest.rs | 2 + deploy/server-bootstrap-ingress.conf | 40 + deploy/server-bootstrap-ingress.service | 22 + deploy/server.releases.compose.yaml | 22 + migrations/0024_enrollment_bootstrap.sql | 22 + tools/agent_release.py | 257 ++++ tools/dev_agent_release.py | 97 ++ web/src/agent-updates.ts | 2 +- web/src/main.tsx | 27 +- 70 files changed, 12982 insertions(+), 327 deletions(-) create mode 100644 crates/agent-windows/examples/windows_quiescent_stop.rs create mode 100644 crates/agent-windows/examples/windows_sync_diagnostic.rs create mode 100644 crates/agent-windows/examples/windows_updater_bootstrap.rs create mode 100644 crates/agent-windows/src/bin/rmm-updater-windows.rs create mode 100644 crates/agent-windows/src/reboot.rs create mode 100644 crates/agent-windows/src/release_platform.rs create mode 100644 crates/agent-windows/src/release_service.rs create mode 100644 crates/agent-windows/src/release_service_switch.ps1 create mode 100644 crates/agent-windows/src/update_admission.rs create mode 100644 crates/agent-windows/src/update_cache.rs create mode 100644 crates/agent-windows/src/update_control.rs create mode 100644 crates/agent-windows/src/update_control_ipc.rs create mode 100644 crates/agent-windows/src/update_download.rs create mode 100644 crates/agent-windows/src/update_ipc.rs create mode 100644 crates/agent-windows/src/update_native/control_fence.rs create mode 100644 crates/agent-windows/src/update_observation_runtime.rs create mode 100644 crates/agent-windows/src/update_observer.rs create mode 100644 crates/agent-windows/src/update_original.rs create mode 100644 crates/agent-windows/src/update_owned.rs create mode 100644 crates/agent-windows/src/update_record.rs create mode 100644 crates/agent-windows/src/update_state.rs create mode 100644 crates/agent-windows/src/update_time_transport.rs create mode 100644 crates/agent-windows/src/update_trust.rs create mode 100644 crates/agent-windows/src/update_worker.rs create mode 100644 crates/server/src/bootstrap/install.ps1 create mode 100644 crates/server/src/bootstrap/install.sh create mode 100644 crates/server/src/bootstrap/lifecycle.py create mode 100644 crates/server/src/bootstrap/mod.rs create mode 100644 crates/updater/src/bootstrap.rs create mode 100644 deploy/server-bootstrap-ingress.conf create mode 100644 deploy/server-bootstrap-ingress.service create mode 100644 deploy/server.releases.compose.yaml create mode 100644 migrations/0024_enrollment_bootstrap.sql create mode 100755 tools/agent_release.py create mode 100755 tools/dev_agent_release.py diff --git a/Cargo.lock b/Cargo.lock index 6097c6e..0de8b23 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2458,6 +2458,7 @@ dependencies = [ "anyhow", "ed25519-dalek", "hex", + "rmm-domain", "serde", "serde_json", "sha2 0.10.9", diff --git a/crates/agent-windows/Cargo.toml b/crates/agent-windows/Cargo.toml index dec224e..5860a4a 100644 --- a/crates/agent-windows/Cargo.toml +++ b/crates/agent-windows/Cargo.toml @@ -13,6 +13,11 @@ name = "rmm-helper-windows" path = "src/bin/rmm-helper-windows.rs" required-features = ["system-helper"] +[[bin]] +name = "rmm-updater-windows" +path = "src/bin/rmm-updater-windows.rs" +required-features = ["system-helper"] + [dependencies] anyhow.workspace = true base64 = "=0.22.1" diff --git a/crates/agent-windows/examples/helper_peer_controls.rs b/crates/agent-windows/examples/helper_peer_controls.rs index bfcb529..f99242a 100644 --- a/crates/agent-windows/examples/helper_peer_controls.rs +++ b/crates/agent-windows/examples/helper_peer_controls.rs @@ -7,6 +7,10 @@ #[path = "../src/helper_ipc.rs"] pub mod helper_ipc; #[cfg(all(windows, feature = "system-helper"))] +pub mod update_admission { pub use rmm_agent_windows::update_admission::Accepted; } +#[cfg(all(windows, feature = "system-helper"))] +pub mod update_observer { pub use rmm_agent_windows::update_observer::{Request,Response}; } +#[cfg(all(windows, feature = "system-helper"))] pub use rmm_agent_windows::SERVICE_NAME; #[cfg(all(windows, feature = "system-helper"))] mod platform { diff --git a/crates/agent-windows/examples/windows_quiescent_stop.rs b/crates/agent-windows/examples/windows_quiescent_stop.rs new file mode 100644 index 0000000..392068f --- /dev/null +++ b/crates/agent-windows/examples/windows_quiescent_stop.rs @@ -0,0 +1,532 @@ +//! One reviewed development bootstrap: normal stop of the exact old agent, +//! while an existing SQLite reservation excludes a new Sync/permit journal +//! commit. No job, approval, SQL row change, helper stop, reset or force kill. +#[cfg(all(windows, feature = "system-helper"))] +mod platform { + use anyhow::{Context, Result, ensure}; + use prost::Message; + use rmm_agent_core::{ + auth::{Binding, Outcome, Request}, + crypto::DalekVerifier, + helper_reconcile::SignedResponse, + reconcile::{Channel, verify_response_with}, + }; + use rmm_agent_windows::{ + helper_ipc::{self as ipc, PeerProof, PinnedFile}, + native, + }; + use rmm_domain::{jobs::hash, reconciliation::ReconcileDecisionPayload}; + use rmm_protocol::{SyncRequest, SyncResponse,Envelope,Payload}; + use rusqlite::{Connection, OpenFlags}; + use serde_json::json; + use std::{ + fs::{File, OpenOptions}, + io::{Read, Write}, + mem::{size_of, zeroed}, + os::windows::fs::OpenOptionsExt, + path::Path, + ptr, + time::{Duration, Instant}, + }; + use uuid::Uuid; + use windows_sys::Win32::{ + Foundation::*, Security::*, Storage::FileSystem::*, System::Services::*, + }; + const AGENT: &str = "9651b2e518b315029cebfa432261a57f0a305aeddde29c56ac22a5ccbc417b32"; + const HELPER: &str = "59675a3cbb3a5d213fc764f38379d6b81baaf9d47a7124470cc2767d4985763e"; + const PIN: &str = "9d46dffe88f565b8b04554335d9669f5c83211b32419908a579b1cd4560443ec"; + const SETTINGS: &str = "4c073cd3d4badb09d8c0f1c270b4cee9df533df416550f68bf3e336e3da7673c"; + const CONFIG: &str = "5cd4cb9802d0dd20b961de7e3cd4e5874a1e9a72fc57b577e075e2d2918baac6"; + const CASE: &str = "c6c80ac4-a52e-4b69-8170-466bcf52049d"; + const JOB: &str = "0a50aae9-a784-4535-b62f-ef24c301d546"; + const ATTEMPT: &str = "78295f74-4565-459a-87b0-641a8b95feec"; + const AGENT_STATE: &str = r"C:\ProgramData\RustDiscovery\state"; + const HELPER_STATE: &str = r"C:\ProgramData\RustDiscoverySystem\state"; + struct Handle(SC_HANDLE); + impl Drop for Handle { + fn drop(&mut self) { + unsafe { + CloseServiceHandle(self.0); + } + } + } + fn admin() -> Result<()> { + let mut sid = [0usize; 16]; + let mut len = std::mem::size_of_val(&sid) as u32; + let mut member = 0; + ensure!( + unsafe { + CreateWellKnownSid( + WinBuiltinAdministratorsSid, + ptr::null_mut(), + sid.as_mut_ptr().cast(), + &mut len, + ) + } != 0 + && unsafe { + CheckTokenMembership(ptr::null_mut(), sid.as_mut_ptr().cast(), &mut member) + } != 0 + && member != 0, + "QUIESCENT_ADMIN_REQUIRED" + ); + Ok(()) + } + fn service(stop:bool) -> Result { + let manager = + Handle(unsafe { OpenSCManagerW(ptr::null(), ptr::null(), SC_MANAGER_CONNECT) }); + ensure!(!manager.0.is_null(), "QUIESCENT_SCM_MANAGER"); + let h = Handle(unsafe { + OpenServiceW( + manager.0, + ipc::wide(rmm_agent_windows::SERVICE_NAME).as_ptr(), + SERVICE_QUERY_STATUS | SERVICE_QUERY_CONFIG | if stop {SERVICE_STOP}else{0}, + ) + }); + ensure!(!h.0.is_null(), "QUIESCENT_SCM_AGENT"); + Ok(h) + } + fn status(h: &Handle) -> Result { + let mut s = unsafe { zeroed() }; + let mut n = 0; + ensure!( + unsafe { + QueryServiceStatusEx( + h.0, + SC_STATUS_PROCESS_INFO, + (&mut s as *mut SERVICE_STATUS_PROCESS).cast(), + size_of::() as u32, + &mut n, + ) + } != 0, + "QUIESCENT_SCM_STATUS" + ); + Ok(s) + } + fn protected(path: &Path, readers: &[String], expected: &str) -> Result<(PinnedFile, Vec)> { + let mut file = PinnedFile::open(path, false, readers, &[], false)?; + ensure!( + file.file.metadata()?.len() <= 65536, + "QUIESCENT_PUBLIC_FILE_LIMIT" + ); + let mut raw = Vec::new(); + (&mut file.file).take(65537).read_to_end(&mut raw)?; + ensure!( + raw.len() <= 65536 && hash(&raw) == expected, + "QUIESCENT_PUBLIC_HASH" + ); + file.check()?; + Ok((file, raw)) + } + fn hold_agent(path: &Path) -> Result { + native::private_path(path, false)?; + Ok(OpenOptions::new() + .read(true) + .share_mode(FILE_SHARE_READ | FILE_SHARE_WRITE) + .custom_flags(FILE_FLAG_OPEN_REPARSE_POINT) + .open(path)?) + } + fn check_id(file: &File, path: &Path) -> Result<()> { + let actual = hold_agent(path)?; + ensure!( + ipc::file_identity(file)? == ipc::file_identity(&actual)?, + "QUIESCENT_DATABASE_REPLACED" + ); + Ok(()) + } + fn receipt(dir: &Path, name: &str, value: &serde_json::Value) -> Result<()> { + let bytes = serde_json::to_vec(value)?; + ensure!(bytes.len() <= 16384, "QUIESCENT_RECEIPT_LIMIT"); + let path = dir.join(name); + let mut f = OpenOptions::new() + .write(true) + .create_new(true) + .share_mode(FILE_SHARE_READ) + .custom_flags(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_WRITE_THROUGH) + .open(&path)?; + f.write_all(&bytes)?; + f.sync_all()?; + drop(f); + let mut read = PinnedFile::open(&path, false, &[], &[], false)?; + ensure!(read.sha256()? == hash(&bytes), "QUIESCENT_RECEIPT_READBACK"); + Ok(()) + } + struct Idle { + decision: Uuid, + checkpoint: u64, + helper_checkpoint: u64, + request_sha256: String, + response_sha256: String, + original_echo_job: Uuid, + pending_request:Option, + pending_request_sha256:Option, + } + fn idle( + db: &Connection, + consumption: &Connection, + helper: &Connection, + intents: &Connection, + binding: &Binding, + ) -> Result { + let (journal,checkpoint,generation,last,pending,helper_id,helper_cp,fault):(String,u64,u64,String,Option,String,u64,Option)=db.query_row("SELECT journal_id,checkpoint,generation,last_decision,pending_request,helper_id,helper_checkpoint,fault FROM reconcile_meta WHERE id=1",[],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?,r.get(3)?,r.get(4)?,r.get(5)?,r.get(6)?,r.get(7)?)))?; + ensure!(fault.is_none(),"QUIESCENT_AGENT_FAULT"); + let (helper_journal, helper_last, helper_fault,helper_agent_cp): (String, String, Option,u64) = helper + .query_row( + "SELECT journal_id,last_decision,fault,agent_checkpoint FROM helper_sync_meta WHERE id=1", + [], + |r| Ok((r.get(0)?, r.get(1)?, r.get(2)?,r.get(3)?)), + )?; + ensure!( + helper_fault.is_none() && helper_last == last && helper_journal == helper_id, + "QUIESCENT_HELPER_HEAD_DIFFERS" + ); + let (raw_response, raw_request, applied_cp): (Vec, Vec, u64) = helper.query_row( + "SELECT response,request,checkpoint FROM helper_sync_decisions WHERE decision_id=?1", + [&last], + |r| Ok((r.get(0)?, r.get(1)?, r.get(2)?)), + )?; + ensure!( + applied_cp == helper_cp, + "QUIESCENT_HELPER_APPLIED_CHECKPOINT" + ); + let signed: SignedResponse = serde_json::from_slice(&raw_response)?; + let parsed: ReconcileDecisionPayload = serde_json::from_slice(&signed.decision_bytes)?; + let (agent_request, agent_response): (Vec, Vec) = db.query_row( + "SELECT request,response FROM reconcile_requests WHERE id=?1", + [parsed.request_id.to_string()], + |r| Ok((r.get(0)?, r.get(1)?)), + )?; + let response = SyncResponse::decode(agent_response.as_slice())?; + let request = SyncRequest::decode(agent_request.as_slice())?; + ensure!( + raw_request == agent_request + && signed.decision_bytes == response.decision_bytes + && signed.signature == response.signature, + "QUIESCENT_RAW_SIGNED_CONTROL_DIFFERS" + ); + let verified = verify_response_with( + &DalekVerifier, + binding, + &request, + &Channel { + connection_generation: parsed.connection_generation, + boot_id: parsed.boot_id, + }, + &response, + parsed.issued_at, + )?; + ensure!( + verified.decision_id.to_string() == last + && verified.journal_id.to_string() == journal + && verified.checkpoint == helper_agent_cp + && verified.checkpoint<=checkpoint + && verified.connection_generation<=generation + && verified.helper_journal_id.map(|id| id.to_string()) == Some(helper_id.clone()) + && verified.helper_checkpoint == helper_cp + && verified.ready + && verified.helper_ready + && verified.reason == "CONSISTENT", + "QUIESCENT_SIGNED_HEAD_BINDING" + ); + let pending_request=if let Some(id)=pending.as_ref() { + let (request_raw,envelope_raw,row_generation,response):(Vec,Vec,u64,Option>)=db.query_row("SELECT request,envelope,generation,response FROM reconcile_requests WHERE id=?1",[id],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?,r.get(3)?)))?; + ensure!(response.is_none() && request_raw.len()<=rmm_domain::MAX_MESSAGE && envelope_raw.len()<=rmm_domain::MAX_MESSAGE,"QUIESCENT_ONLY_UNRESPONDED_CONTROL"); + let request=SyncRequest::decode(request_raw.as_slice())?; + let envelope=Envelope::decode(envelope_raw.as_slice())?; + ensure!(request.encode_to_vec()==request_raw && envelope.encode_to_vec()==envelope_raw + && request.request_id==*id && request.journal_id==journal && request.checkpoint==checkpoint + && request.previous_decision_id==last && request.helper_previous_decision_id==last + && request.helper_journal_id==helper_id && request.helper_checkpoint>=helper_cp + && request.assignment_version==binding.assignment_version && request.journal_complete + && request.durable_message_ids.is_empty() && request.attempts.len()==2 + && row_generation==generation && envelope.connection_generation==generation + && envelope.agent_id==binding.agent_id.to_string() && envelope.enrollment_generation==binding.enrollment_generation + && envelope.boot_id==verified.boot_id.to_string() && envelope.sequence==checkpoint + && rmm_protocol::valid_envelope(&envelope,&binding.agent_id.to_string(),generation) + && matches!(envelope.payload,Some(Payload::SyncRequest(ref body)) if body==&request),"QUIESCENT_PENDING_CONTROL_BINDING"); + Some(request) + }else { + ensure!(verified.checkpoint==checkpoint && verified.connection_generation==generation,"QUIESCENT_WITHOUT_PENDING_EXACT_HEAD"); + None + }; + let busy:bool=db.query_row("SELECT EXISTS(SELECT 1 FROM job_attempts WHERE state IN ('requesting','running','verifying','unknown','awaiting_reboot'))",[],|r|r.get(0))?; + ensure!(!busy, "QUIESCENT_EFFECT_PENDING"); + let (scope, original) = rmm_agent_windows::echo_probe::archive(db, binding)? + .context("QUIESCENT_ECHO_ARCHIVE_MISSING")?; + ensure!( + rmm_agent_windows::echo_completion::installed(db, binding, &scope, &original)?, + "QUIESCENT_ECHO_COMPLETION_MISSING" + ); + let (total,echo,pending_new):(u64,u64,u64)=db.query_row("SELECT count(*),sum(job=?1 AND attempt=?2 AND state='succeeded'),sum(job=?3 AND attempt=?4 AND state IN ('accepted','expired') AND grant_id='') FROM job_attempts",rusqlite::params![scope.job_id.to_string(),scope.attempt_id.to_string(),JOB,ATTEMPT],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?)))?; + ensure!( + total == 2 && echo == 1 && pending_new == 1, + "QUIESCENT_EXPECTED_TWO_JOB_HISTORY" + ); + if let Some(request)=&pending_request { + let echo=request.attempts.iter().filter(|r|r.job_id==scope.job_id.to_string() && r.attempt_id==scope.attempt_id.to_string()).collect::>(); + let new=request.attempts.iter().filter(|r|r.job_id==JOB && r.attempt_id==ATTEMPT).collect::>(); + ensure!(echo.len()==1 && new.len()==1,"QUIESCENT_PENDING_EXPECTED_ATTEMPTS"); + let old=echo[0];let new=new[0]; + let old_grant:String=db.query_row("SELECT grant_id FROM job_attempts WHERE job=?1 AND attempt=?2",rusqlite::params![scope.job_id.to_string(),scope.attempt_id.to_string()],|r|r.get(0))?; + ensure!(old.state=="succeeded" && old.consumption=="consumed" && old.grant_id==old_grant + && !old.grant_id.is_empty() && old.job_payload_hash==scope.job_payload_hash && old.update_handoff_bytes.is_empty() + && matches!(new.state.as_str(),"accepted"|"expired") && new.consumption=="unconsumed" && new.grant_id.is_empty() + && new.update_handoff_bytes.is_empty(),"QUIESCENT_PENDING_NO_NEW_EFFECT"); + } + let (total, new): (u64, u64) = consumption.query_row( + "SELECT count(*),COALESCE(sum(job=?1 OR attempt=?2),0) FROM consumed", + [JOB, ATTEMPT], + |r| Ok((r.get(0)?, r.get(1)?)), + )?; + ensure!(total == 1 && new == 0, "QUIESCENT_CONSUMPTION_CHANGED"); + let (start,outcome,finished):(Vec,Vec,Vec)=consumption.query_row("SELECT e.start,e.outcome,c.result FROM consumed c JOIN execution_evidence e USING(grant_id) WHERE c.job=?1 AND c.attempt=?2",rusqlite::params![scope.job_id.to_string(),scope.attempt_id.to_string()],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?)))?; + let start: serde_json::Value = serde_json::from_slice(&start)?; + let request: Request = serde_json::from_value(start["request"].clone())?; + let at = serde_json::from_value(start["reserved_at"].clone())?; + let (job, _) = binding.verify_with(&request, at, &DalekVerifier)?; + let o: Outcome = serde_json::from_slice(&outcome)?; + ensure!( + scope.matches_job(&job) + && o.state == "succeeded" + && o.evidence["postconditions_passed"] == true + && outcome == finished, + "QUIESCENT_ORIGINAL_ECHO_EVIDENCE" + ); + ensure!( + helper.query_row("SELECT count(*) FROM consumed", [], |r| r.get::<_, u64>(0))? == 0 + && intents.query_row("SELECT count(*) FROM system_intents", [], |r| r + .get::<_, u64>(0))? + == 0, + "QUIESCENT_HELPER_WORK_PRESENT" + ); + Ok(Idle { + decision: verified.decision_id, + checkpoint, + helper_checkpoint: helper_cp, + request_sha256: hash(&raw_request), + response_sha256: hash(&raw_response), + original_echo_job: scope.job_id, + pending_request:pending, + pending_request_sha256:pending_request.as_ref().map(|r|hash(&r.encode_to_vec())), + }) + } + fn safe_error(error:&anyhow::Error)->serde_json::Value { + for cause in error.chain() { + let text=cause.to_string(); + if text.starts_with("QUIESCENT_") && text.bytes().all(|b|b.is_ascii_uppercase()||b==b'_') {return json!({"code":text});} + if let Some(sql)=cause.downcast_ref::() { + return match sql { + rusqlite::Error::SqliteFailure(code,_)=>json!({"code":"SQLITE_FAILURE","sqlite_code":format!("{:?}",code.code),"extended_code":code.extended_code}), + rusqlite::Error::QueryReturnedNoRows=>json!({"code":"SQLITE_NO_ROWS"}), + rusqlite::Error::InvalidColumnIndex(index)=>json!({"code":"SQLITE_COLUMN_INDEX","index":index}), + rusqlite::Error::InvalidColumnType(index,column,_)=>json!({"code":"SQLITE_COLUMN_TYPE","index":index,"column":column}), + _=>json!({"code":"SQLITE_READ_FAILED"}), + }; + } + } + json!({"code":"SIGNED_OR_ARCHIVED_EVIDENCE_CHECK_FAILED"}) + } + fn safe_metadata(db:&Connection,consumed:&Connection,helper:&Connection,intents:&Connection)->Result { + let agent=db.query_row("SELECT checkpoint,generation,last_decision,pending_request,helper_checkpoint,fault IS NOT NULL FROM reconcile_meta WHERE id=1",[],|r|Ok(json!({ + "checkpoint":r.get::<_,u64>(0)?,"generation":r.get::<_,u64>(1)?,"last_decision":r.get::<_,Option>(2)?,"pending_request":r.get::<_,Option>(3)?,"helper_checkpoint":r.get::<_,u64>(4)?,"fault_present":r.get::<_,bool>(5)?})))?; + let helper_meta=helper.query_row("SELECT checkpoint,generation,last_decision,fault IS NOT NULL,agent_checkpoint FROM helper_sync_meta WHERE id=1",[],|r|Ok(json!({ + "current_capture_checkpoint":r.get::<_,u64>(0)?,"generation":r.get::<_,u64>(1)?,"last_decision":r.get::<_,Option>(2)?,"fault_present":r.get::<_,bool>(3)?,"agent_checkpoint":r.get::<_,u64>(4)?})))?; + let mut q=db.prepare("SELECT job,attempt,state,grant_id<>'' FROM job_attempts ORDER BY job LIMIT 8")?; + let jobs=q.query_map([],|r|Ok(json!({"job_id":r.get::<_,String>(0)?,"attempt_id":r.get::<_,String>(1)?,"state":r.get::<_,String>(2)?,"grant_present":r.get::<_,bool>(3)?})))?.collect::>>()?; + let counts=json!({"events":db.query_row("SELECT count(*) FROM events",[],|r|r.get::<_,u64>(0))?,"job_events":db.query_row("SELECT count(*) FROM job_events",[],|r|r.get::<_,u64>(0))?, + "agent_consumed":consumed.query_row("SELECT count(*) FROM consumed",[],|r|r.get::<_,u64>(0))?,"agent_execution_evidence":consumed.query_row("SELECT count(*) FROM execution_evidence",[],|r|r.get::<_,u64>(0))?, + "helper_consumed":helper.query_row("SELECT count(*) FROM consumed",[],|r|r.get::<_,u64>(0))?,"helper_intents":intents.query_row("SELECT count(*) FROM system_intents",[],|r|r.get::<_,u64>(0))?}); + Ok(json!({"agent":agent,"helper":helper_meta,"jobs":jobs,"counts":counts})) + } + pub fn run() -> Result<()> { + let args=std::env::args().skip(1).collect::>(); + let read_only=args==["--read-idle-check"]; + ensure!(read_only || args==["--stop-known-idle-agent"],"QUIESCENT_ARGUMENTS"); + admin()?; + let bootstrap = PinnedFile::open( + Path::new(r"C:\ProgramData\RustDiscoveryBootstrap"), + true, + &[], + &[], + false, + )?; + let dir = bootstrap.path.join(format!("quiescent-stop-{CASE}")); + let mut dir_guard=if read_only {None}else{ + std::fs::create_dir(&dir)?; + Some(PinnedFile::open(&dir,true,&[],&[],false)?) + }; + let readers = [ + ipc::service_sid(rmm_agent_windows::SERVICE_NAME)?, + ipc::service_sid(ipc::HELPER_SERVICE)?, + ]; + let (mut pin_guard, raw) = protected( + Path::new(r"C:\ProgramData\RustDiscoverySystem\agent-pin.json"), + &readers, + PIN, + )?; + let pin: ipc::Pin = serde_json::from_slice(&raw)?; + pin.validate()?; + ensure!( + pin.agent.binary_sha256 == AGENT && pin.helper.binary_sha256 == HELPER, + "QUIESCENT_EXACT_PAIR" + ); + let (mut settings_guard, _) = protected( + Path::new(r"C:\ProgramData\RustDiscoverySystem\helper.json"), + &readers, + SETTINGS, + )?; + let (mut config_guard, raw) = protected( + Path::new(r"C:\ProgramData\RustDiscovery\config.json"), + &[readers[0].clone()], + CONFIG, + )?; + let cfg: serde_json::Value = serde_json::from_slice(&raw)?; + ensure!( + cfg["enable_jobs"] == true + && cfg.get("windows_echo_probe_only").is_none_or(|v|v==false) + && cfg["state_directory"] == AGENT_STATE, + "QUIESCENT_EXACT_CONFIGURATION" + ); + let agent_service = service(!read_only)?; + let before = status(&agent_service)?; + ensure!( + before.dwCurrentState == SERVICE_RUNNING, + "QUIESCENT_AGENT_NOT_RUNNING" + ); + let mut peer = PeerProof::for_service(&pin.agent, before.dwProcessId)?; + let helper_manager=Handle(unsafe{OpenSCManagerW(ptr::null(),ptr::null(),SC_MANAGER_CONNECT)}); + ensure!(!helper_manager.0.is_null(),"QUIESCENT_HELPER_SCM_MANAGER"); + let helper_service=Handle(unsafe{OpenServiceW(helper_manager.0,ipc::wide(ipc::HELPER_SERVICE).as_ptr(),SERVICE_QUERY_STATUS|SERVICE_QUERY_CONFIG)}); + ensure!(!helper_service.0.is_null(),"QUIESCENT_HELPER_SCM"); + let helper_before=status(&helper_service)?; + ensure!(helper_before.dwCurrentState==SERVICE_RUNNING,"QUIESCENT_HELPER_NOT_RUNNING"); + let mut helper_peer=PeerProof::for_service(&pin.helper,helper_before.dwProcessId)?; + // Keep original journal/sidecar names and ledger against replacement. + let journal_path = Path::new(AGENT_STATE).join("telemetry.sqlite"); + let journal_file = hold_agent(&journal_path)?; + let _wal = hold_agent(&Path::new(AGENT_STATE).join("telemetry.sqlite-wal"))?; + let _shm = hold_agent(&Path::new(AGENT_STATE).join("telemetry.sqlite-shm"))?; + let consumption_path = Path::new(AGENT_STATE).join("consumption.sqlite"); + let consumption_file = hold_agent(&consumption_path)?; + let helper_writer = ipc::service_sid(ipc::HELPER_SERVICE)?; + let mut helper_file = PinnedFile::open_read_shared( + &Path::new(HELPER_STATE).join("ledger.sqlite"), + false, + &[], + std::slice::from_ref(&helper_writer), + )?; + let mut intent_file = PinnedFile::open_read_shared( + Path::new(r"C:\ProgramData\RustDiscoverySystem\agent-intents\system-intents.sqlite"), + false, + &[], + &[readers[0].clone()], + )?; + let db = Connection::open_with_flags(&journal_path, if read_only {OpenFlags::SQLITE_OPEN_READ_ONLY}else{OpenFlags::SQLITE_OPEN_READ_WRITE})?; + db.busy_timeout(Duration::from_millis(20))?; + let consumed = + Connection::open_with_flags(&consumption_path, OpenFlags::SQLITE_OPEN_READ_ONLY)?; + let helper = + Connection::open_with_flags(&helper_file.path, OpenFlags::SQLITE_OPEN_READ_ONLY)?; + let intents = + Connection::open_with_flags(&intent_file.path, OpenFlags::SQLITE_OPEN_READ_ONLY)?; + if read_only { + let mut observations=Vec::new(); + for _ in 0..10 { + db.execute_batch("BEGIN")?;helper.execute_batch("BEGIN")?; + let checked=idle(&db,&consumed,&helper,&intents,&pin.binding); + let metadata=safe_metadata(&db,&consumed,&helper,&intents)?; + let error=checked.as_ref().err().map(safe_error); + helper.execute_batch("ROLLBACK")?;db.execute_batch("ROLLBACK")?; + observations.push(json!({"observed_at":chrono::Utc::now(),"idle_check_passed":checked.is_ok(),"error":error,"metadata":metadata})); + std::thread::sleep(Duration::from_millis(100)); + } + peer.check()?;helper_peer.check()?; + println!("{}",serde_json::to_string(&json!({"schema_version":1,"mode":"read_idle_check","read_only":true,"quiescence_reservation_held":false,"stop_requested":false,"case_created":false,"sql_data_changed":false,"samples":observations}))?); + return Ok(()); + } + let until = Instant::now() + Duration::from_secs(30); + let locked = loop { + if Instant::now() >= until { + anyhow::bail!("QUIESCENT_HEAD_NOT_OBSERVED_NO_STOP"); + } + if db.execute_batch("BEGIN IMMEDIATE").is_err() { + std::thread::sleep(Duration::from_millis(25)); + continue; + } + helper.execute_batch("BEGIN")?; + let value = idle(&db, &consumed, &helper, &intents, &pin.binding); + helper.execute_batch("ROLLBACK")?; + match value { + Ok(value) => break value, + Err(_) => { + db.execute_batch("ROLLBACK")?; + std::thread::sleep(Duration::from_millis(25)); + } + } + }; + // All final observations occur while new agent writes remain excluded. + peer.check()?; + helper_peer.check()?; + pin_guard.check()?; + settings_guard.check()?; + config_guard.check()?; + dir_guard.as_mut().context("QUIESCENT_CASE_GUARD")?.check()?; + check_id(&journal_file, &journal_path)?; + check_id(&consumption_file, &consumption_path)?; + helper_file.check()?; + intent_file.check()?; + let current = status(&agent_service)?; + ensure!( + current.dwCurrentState == SERVICE_RUNNING && current.dwProcessId == before.dwProcessId, + "QUIESCENT_ORIGINAL_PROCESS_CHANGED" + ); + receipt( + &dir, + "stop-intent.json", + &json!({"schema_version":1,"case_id":CASE,"observed_at":chrono::Utc::now(),"agent_sha256":AGENT,"helper_sha256":HELPER,"pin_sha256":PIN,"config_sha256":CONFIG, + "agent_pid":before.dwProcessId,"journal_file_id":ipc::file_identity(&journal_file)?,"consumption_file_id":ipc::file_identity(&consumption_file)?,"helper_ledger_file_id":helper_file.identity,"decision_id":locked.decision, + "checkpoint":locked.checkpoint,"helper_applied_checkpoint":locked.helper_checkpoint,"signed_request_sha256":locked.request_sha256,"signed_helper_response_sha256":locked.response_sha256,"original_echo_job":locked.original_echo_job, + "pending_job":JOB,"pending_control_request":locked.pending_request,"pending_control_request_sha256":locked.pending_request_sha256,"new_grants":0,"helper_consumptions":0,"helper_intents":0,"sql_data_changed":false,"agent_journal_immediate_reservation_held":true,"stop_service_only":rmm_agent_windows::SERVICE_NAME,"force_kill":false}), + )?; + let mut returned: SERVICE_STATUS = unsafe { zeroed() }; + let stop_ok = + unsafe { ControlService(agent_service.0, SERVICE_CONTROL_STOP, &mut returned) } != 0; + let error = if stop_ok { + None + } else { + Some(unsafe { GetLastError() }) + }; + let wait = Instant::now() + Duration::from_secs(125); + let mut final_status = status(&agent_service)?; + while stop_ok && final_status.dwCurrentState != SERVICE_STOPPED && Instant::now() < wait { + std::thread::sleep(Duration::from_millis(50)); + final_status = status(&agent_service)?; + } + let stopped = stop_ok && final_status.dwCurrentState == SERVICE_STOPPED; + helper_peer.check()?; + // Still held through the confirmed stop (or bounded honest failure). + check_id(&journal_file, &journal_path)?; + check_id(&consumption_file, &consumption_path)?; + receipt( + &dir, + "stop-result.json", + &json!({"schema_version":1,"case_id":CASE,"observed_at":chrono::Utc::now(),"normal_stop_requested_once":stop_ok,"native_error":error,"stopped":stopped,"state":final_status.dwCurrentState,"pid":final_status.dwProcessId, + "sql_data_changed":false,"job_executed":false,"helper_stopped":false,"reset":false,"force_kill":false,"reservation_held_until_observation":true}), + )?; + db.execute_batch("ROLLBACK")?; + ensure!(stopped, "QUIESCENT_STOP_UNCONFIRMED_NO_FORCE"); + println!("{{\"case_id\":\"{CASE}\",\"stopped\":true,\"sql_data_changed\":false}}"); + Ok(()) + } +} +#[cfg(all(windows, feature = "system-helper"))] +fn main() { + if let Err(error) = platform::run() { + eprintln!("{}", error); + std::process::exit(1); + } +} +#[cfg(not(all(windows, feature = "system-helper")))] +fn main() { + eprintln!("Windows SYSTEM-helper SDK bootstrap only"); + std::process::exit(1); +} diff --git a/crates/agent-windows/examples/windows_sync_diagnostic.rs b/crates/agent-windows/examples/windows_sync_diagnostic.rs new file mode 100644 index 0000000..c8676b4 --- /dev/null +++ b/crates/agent-windows/examples/windows_sync_diagnostic.rs @@ -0,0 +1,47 @@ +//! Administrator bootstrap metadata READ ONLY. Never stops a service, opens a +//! writable SQLite connection, repairs history, reads keys, or executes jobs. +#[cfg(windows)] +mod native { + use anyhow::{Result,ensure}; + use prost::Message; + use rusqlite::{Connection,OpenFlags}; + use serde_json::{Value,json}; + use std::{path::Path,time::Duration}; + use windows_sys::Win32::{Foundation::CloseHandle,Security::{GetTokenInformation,TOKEN_ELEVATION,TOKEN_QUERY,TokenElevation},System::Threading::{GetCurrentProcess,OpenProcessToken}}; + fn db(path:&str)->Result{ensure!(Path::new(path).is_file(),"SYNC_DIAGNOSTIC_FILE_MISSING");let db=Connection::open_with_flags(path,OpenFlags::SQLITE_OPEN_READ_ONLY|OpenFlags::SQLITE_OPEN_NO_MUTEX)?;db.busy_timeout(Duration::from_millis(500))?;Ok(db)} + fn requests(db:&Connection)->Result{ + let mut stmt=db.prepare("SELECT id,generation,length(request),response IS NOT NULL,request FROM reconcile_requests ORDER BY rowid DESC LIMIT 2")?; + let rows=stmt.query_map([],|r|Ok((r.get::<_,String>(0)?,r.get::<_,u64>(1)?,r.get::<_,u64>(2)?,r.get::<_,bool>(3)?,r.get::<_,Vec>(4)?)))?.collect::>>()?; + Ok(json!(rows.into_iter().map(|(id,generation,bytes,response,raw)|{ + let decoded=rmm_protocol::SyncRequest::decode(raw.as_slice()).ok(); + json!({"request_id":id,"generation":generation,"request_bytes":bytes,"response_present":response,"decoded":decoded.map(|r|json!({"request_id":r.request_id,"checkpoint":r.checkpoint,"previous_decision_id":r.previous_decision_id,"helper_checkpoint":r.helper_checkpoint}))}) + }).collect::>())) + } + fn sample()->Result{ + let agent=db(r"C:\ProgramData\RustDiscovery\state\telemetry.sqlite")?; + let helper=db(r"C:\ProgramData\RustDiscoverySystem\state\ledger.sqlite")?; + let meta=agent.query_row("SELECT checkpoint,generation,last_decision,pending_request,helper_checkpoint,fault FROM reconcile_meta WHERE id=1",[],|r|Ok(json!({"checkpoint":r.get::<_,u64>(0)?,"generation":r.get::<_,u64>(1)?,"last_decision":r.get::<_,Option>(2)?,"pending_request":r.get::<_,Option>(3)?,"helper_checkpoint":r.get::<_,u64>(4)?,"fault":r.get::<_,Option>(5)?})))?; + let helper_meta=helper.query_row("SELECT checkpoint,generation,last_decision,agent_checkpoint,fault FROM helper_sync_meta WHERE id=1",[],|r|Ok(json!({"checkpoint":r.get::<_,u64>(0)?,"generation":r.get::<_,u64>(1)?,"last_decision":r.get::<_,Option>(2)?,"agent_checkpoint":r.get::<_,u64>(3)?,"fault":r.get::<_,Option>(4)?})))?; + let mut stmt=helper.prepare("SELECT decision_id,checkpoint,length(response),length(request) FROM helper_sync_decisions ORDER BY rowid DESC LIMIT 2")?; + let decisions=stmt.query_map([],|r|Ok(json!({"decision_id":r.get::<_,String>(0)?,"checkpoint":r.get::<_,u64>(1)?,"response_bytes":r.get::<_,u64>(2)?,"request_bytes":r.get::<_,u64>(3)?})))?.collect::>>()?; + let mut stmt=agent.prepare("SELECT job,attempt,state,grant_id<>'' FROM job_attempts ORDER BY job LIMIT 8")?; + let jobs=stmt.query_map([],|r|Ok(json!({"job_id":r.get::<_,String>(0)?,"attempt_id":r.get::<_,String>(1)?,"state":r.get::<_,String>(2)?,"grant_present":r.get::<_,bool>(3)?})))?.collect::>>()?; + Ok(json!({"agent":meta,"requests":requests(&agent)?,"helper":helper_meta,"helper_decisions":decisions,"jobs":jobs})) + } + fn error(e:&anyhow::Error)->Value { + for cause in e.chain(){if let Some(sql)=cause.downcast_ref::(){return match sql {rusqlite::Error::SqliteFailure(code,_)=>json!({"code":"SQLITE_FAILURE","sqlite_code":format!("{:?}",code.code),"extended_code":code.extended_code}),rusqlite::Error::InvalidColumnType(index,column,_)=>json!({"code":"SQLITE_COLUMN_TYPE","index":index,"column":column}),rusqlite::Error::QueryReturnedNoRows=>json!({"code":"SQLITE_NO_ROWS"}),_=>json!({"code":"SQLITE_READ_FAILED"})};}} + json!({"code":"READ_DIAGNOSTIC_FAILED"}) + } + pub fn run()->Result<()> { + ensure!(std::env::args().count()==1,"SYNC_DIAGNOSTIC_NO_ARGUMENTS"); + let mut token=std::ptr::null_mut();ensure!(unsafe{OpenProcessToken(GetCurrentProcess(),TOKEN_QUERY,&mut token)}!=0,"SYNC_DIAGNOSTIC_TOKEN"); + let mut elevation=TOKEN_ELEVATION{TokenIsElevated:0};let mut size=0; + let okay=unsafe{GetTokenInformation(token,TokenElevation,&mut elevation as *mut _ as *mut _,std::mem::size_of::() as u32,&mut size)};unsafe{CloseHandle(token)}; + ensure!(okay!=0&&elevation.TokenIsElevated!=0,"SYNC_DIAGNOSTIC_ADMIN"); + let mut samples=vec![]; + for _ in 0..3 {samples.push(sample().unwrap_or_else(|e|json!({"error":error(&e)})));std::thread::sleep(Duration::from_millis(100));} + println!("{}",serde_json::to_string(&json!({"schema_version":1,"read_only":true,"utc":chrono::Utc::now(),"samples":samples}))?);Ok(()) + } +} +#[cfg(windows)]fn main(){if native::run().is_err(){eprintln!("SYNC_DIAGNOSTIC_FAILED");std::process::exit(1);}} +#[cfg(not(windows))]fn main(){eprintln!("Windows only");std::process::exit(1);} diff --git a/crates/agent-windows/examples/windows_updater_bootstrap.rs b/crates/agent-windows/examples/windows_updater_bootstrap.rs new file mode 100644 index 0000000..489c4b7 --- /dev/null +++ b/crates/agent-windows/examples/windows_updater_bootstrap.rs @@ -0,0 +1,245 @@ +//! Administrative typed metadata only; no writes, effects, jobs, or readiness. +#[cfg(all(windows, feature = "system-helper"))] +mod sdk { + use anyhow::{Result, ensure}; + use rmm_agent_windows::{helper_ipc as ipc, helper_system, signed_clock, update_state}; + use rmm_domain::{ + agent_update::{ReleaseEnvelope, ReleaseManifest, UpdateKeyringFile}, + agent_update_provisioning::{HealthKeyPin, InstalledReleaseRecord, LocalUpdatePolicy}, + jobs::hash, + }; + use serde::Deserialize; + use std::io::Read; + #[derive(Deserialize)] + #[serde(tag = "operation", rename_all = "snake_case", deny_unknown_fields)] + enum Input { + ReadMetadata { + updater_sha256: Option, + }, + RenderPair { + settings: Vec, + agent_sha256: String, + helper_sha256: String, + }, + RenderUpdaterClock { + pair_profile: Vec, + updater_sha256: String, + policy_sha256: String, + service_configuration_sha256: String, + qualification_sha256: String, + }, + CanonicalRelease { + manifest: ReleaseManifest, + }, + CanonicalRecord { + record: InstalledReleaseRecord, + }, + CanonicalPolicy { + policy: Box, + }, + ValidatePublicBundle { + record: Vec, + policy: Vec, + keyring: Vec, + health_pin: Vec, + }, + ValidateRelease { + envelope: ReleaseEnvelope, + }, + } + fn bytes(raw: Vec) -> serde_json::Value { + serde_json::json!({"sha256":hash(&raw),"bytes":raw}) + } + fn read_metadata(updater_sha256: Option) -> Result { + use rmm_agent_core::helper_reconcile::BootSource; + use rmm_agent_windows::update_native::{Budget, Role, files, services}; + let boot = helper_system::WindowsBoot::capture()?; + let budget = Budget::new( + &boot, + boot.current_boot()?, + std::time::Duration::from_secs(30), + )?; + let (settings, _held) = helper_system::read_settings()?; + let mut running = + services::Running::observe([settings.agent.clone(), settings.helper.clone()], &budget)?; + let retained = update_state::RetainedSet::bootstrap_metadata()?; + let mut observed = Vec::new(); + for role in [ + Role::Agent, + Role::Helper, + Role::Settings, + Role::Pin, + Role::TimeProfile, + ] { + observed.push(serde_json::json!({"role":role,"proof":files::observe(role,&budget)?})); + } + let updater = if let Some(sha) = updater_sha256 { + ensure!(ipc::digest(&sha), "BOOTSTRAP_UPDATER_IMAGE"); + let pin = ipc::PeerPin { + service_name: rmm_agent_windows::update_ipc::SERVICE.into(), + service_sid: ipc::service_sid(rmm_agent_windows::update_ipc::SERVICE)?, + user_sid: "S-1-5-18".into(), + binary: rmm_agent_windows::update_ipc::BINARY.into(), + binary_sha256: sha, + }; + let readers = [pin.service_sid.clone()]; + let mut image = ipc::PinnedFile::open(&pin.binary, false, &readers, &[], false)?; + ensure!( + image.sha256()? == pin.binary_sha256, + "BOOTSTRAP_REGISTERED_UPDATER_IMAGE" + ); + let definition = services::updater_bootstrap_definition(&pin)?; + image.check()?; + Some( + serde_json::json!({"pin":pin,"configuration_sha256":hash(&serde_json::to_vec(&definition)?),"configuration":definition,"running_not_qualified":true}), + ) + } else { + None + }; + running.check(&budget)?; + Ok( + serde_json::json!({"schema_version":1,"read_only":true,"boot_id":boot.current_boot()?, + "binding":settings.binding,"services":running.proofs(),"files":observed,"retained":retained, + "reader_contract_sha256":hash(update_state::READER_CONTRACT),"updater":updater, + "readiness_created":false,"target_mutated":false,"qualification_created":false}), + ) + } + fn run(input: Input) -> Result { + Ok(match input { + Input::ReadMetadata { updater_sha256 } => read_metadata(updater_sha256)?, + Input::RenderPair { + settings, + agent_sha256, + helper_sha256, + } => { + ensure!( + ipc::digest(&agent_sha256) && ipc::digest(&helper_sha256), + "BOOTSTRAP_PAIR_DIGESTS" + ); + let mut s: helper_system::Settings = serde_json::from_slice(&settings)?; + s.validate()?; + s.agent.binary_sha256 = agent_sha256; + s.helper.binary_sha256 = helper_sha256; + s.validate()?; + let raw = serde_json::to_vec(&s)?; + let pin = s.pin()?; + ensure!(pin.policy_sha256 == hash(&raw), "BOOTSTRAP_CANONICAL_PAIR"); + serde_json::json!({"settings":bytes(raw),"pin":bytes(serde_json::to_vec(&pin)?),"shape_only":true}) + } + Input::RenderUpdaterClock { + pair_profile, + updater_sha256, + policy_sha256, + service_configuration_sha256, + qualification_sha256, + } => { + ensure!( + [ + &updater_sha256, + &policy_sha256, + &service_configuration_sha256, + &qualification_sha256 + ] + .iter() + .all(|s| ipc::digest(s)), + "BOOTSTRAP_UPDATER_CLOCK_DIGESTS" + ); + let profile: signed_clock::Configuration = serde_json::from_slice(&pair_profile)?; + let signed_clock::Configuration::TrustedOs(p) = profile else { + anyhow::bail!("BOOTSTRAP_EXPLICIT_ACTIVE_GUEST_PROFILE_REQUIRED") + }; + ensure!( + p.schema_version == 2 + && p.trusted_os_active_guest.qualifications.len() == 2 + && p.trusted_os_active_guest.qualifications[0].role + == rmm_time_attestation::Role::Agent + && p.trusted_os_active_guest.qualifications[1].role + == rmm_time_attestation::Role::SystemHelper, + "BOOTSTRAP_ORIGINAL_PAIR_PROFILE" + ); + let mut guest = p.trusted_os_active_guest; + guest.qualifications = vec![signed_clock::RoleQualification { + role: rmm_time_attestation::Role::Updater, + binary_sha256: updater_sha256, + qualification_sha256, + }]; + let new = signed_clock::UpdaterConfiguration { + schema_version: 3, + key_generation: p.key_generation, + server_instance: p.server_instance, + binding: p.binding, + public_keys_hex: p.public_keys_hex, + updater_policy_sha256: policy_sha256, + updater_service_configuration_sha256: service_configuration_sha256, + trusted_os_active_guest: guest, + }; + serde_json::json!({"profile":bytes(serde_json::to_vec(&new)?),"shape_only":true,"qualification_created":false}) + } + Input::CanonicalRelease { manifest } => { + ensure!(manifest.validate(), "BOOTSTRAP_RELEASE_SHAPE"); + bytes(serde_json::to_vec(&manifest)?) + } + Input::CanonicalRecord { record } => bytes(record.bytes().map_err(anyhow::Error::msg)?), + Input::CanonicalPolicy { policy } => { + ensure!( + policy.validate() && policy.schema_version == 2, + "BOOTSTRAP_WINDOWS_POLICY_SHAPE" + ); + bytes(serde_json::to_vec(&policy)?) + } + Input::ValidateRelease { envelope } => { + let decoded = envelope.decode().map_err(anyhow::Error::msg)?; + serde_json::json!({"manifest":decoded.manifest,"manifest_sha256":hash(&decoded.payload_bytes),"shape_only_not_signature_verified":true}) + } + Input::ValidatePublicBundle { + record, + policy, + keyring, + health_pin, + } => { + let installed = + InstalledReleaseRecord::from_bytes(&record).map_err(anyhow::Error::msg)?; + let (policy, policy_sha256) = + LocalUpdatePolicy::from_bytes(&policy).map_err(anyhow::Error::msg)?; + let keys: UpdateKeyringFile = serde_json::from_slice(&keyring)?; + let health: HealthKeyPin = serde_json::from_slice(&health_pin)?; + ensure!( + keys.validate() + && health.validate() + && policy.schema_version == 2 + && policy.initial_record_sha256 == hash(&record) + && policy.initial_activation_floor == installed.activation_floor, + "BOOTSTRAP_WINDOWS_PUBLIC_BUNDLE_SHAPE" + ); + serde_json::json!({"record_sha256":hash(&record),"policy_sha256":policy_sha256,"keyring_sha256":hash(&keyring),"health_pin_sha256":hash(&health_pin),"shape_only_not_signature_verified":true}) + } + }) + } + pub fn main() -> Result<()> { + let mut raw = Vec::new(); + std::io::stdin() + .take(512 * 1024 + 1) + .read_to_end(&mut raw)?; + ensure!( + !raw.is_empty() && raw.len() <= 512 * 1024, + "BOOTSTRAP_METADATA_FRAME_LIMIT" + ); + println!( + "{}", + serde_json::to_string(&run(serde_json::from_slice(&raw)?)?)? + ); + Ok(()) + } +} +#[cfg(all(windows, feature = "system-helper"))] +fn main() { + if sdk::main().is_err() { + eprintln!("WINDOWS_BOOTSTRAP_METADATA_FAILED"); + std::process::exit(1) + } +} +#[cfg(not(all(windows, feature = "system-helper")))] +fn main() { + eprintln!("Windows/system-helper required; no operation executed"); + std::process::exit(2) +} diff --git a/crates/agent-windows/src/bin/rmm-updater-windows.rs b/crates/agent-windows/src/bin/rmm-updater-windows.rs new file mode 100644 index 0000000..60ac0ae --- /dev/null +++ b/crates/agent-windows/src/bin/rmm-updater-windows.rs @@ -0,0 +1,25 @@ +//! Stable updater is installed separately from the two mutable code roles. +#[cfg(windows)] +fn main() -> anyhow::Result<()> { + let mut args = std::env::args_os().skip(1); + match args.next().as_deref() { + None => rmm_agent_windows::update_worker::dispatch(), + Some(flag) if flag == "--release-service" && args.next().is_none() => { + rmm_agent_windows::release_service::dispatch() + } + Some(flag) if flag == "--verify-bootstrap" => { + let release = rmm_updater::verify_bootstrap_files( + rmm_agent_windows::release_platform::VERIFY, + &args.collect::>(), + )?; + println!("{}", serde_json::to_string(release.manifest())?); + Ok(()) + } + _ => anyhow::bail!("unrecognized Windows updater arguments"), + } +} +#[cfg(not(windows))] +fn main() { + eprintln!("Windows stable updater requires a Windows target"); + std::process::exit(1); +} diff --git a/crates/agent-windows/src/certificate_rotation.rs b/crates/agent-windows/src/certificate_rotation.rs index 91dbdef..7e6fdf7 100644 --- a/crates/agent-windows/src/certificate_rotation.rs +++ b/crates/agent-windows/src/certificate_rotation.rs @@ -1,6 +1,7 @@ //! Passive TLS renewal. SQLite commits only public CSR/certificate/version data; //! private keys stay in immutable, protected files outside the telemetry WAL. -//! The caller must retain the existing exclusive agent-state journal lock. +//! Mutation/current callers retain the exclusive agent-state journal lock. +//! `read_only_current` is the bounded, snapshot-only stable-updater exception. use anyhow::{Context, Result, ensure}; use rcgen::{CertificateParams, DnType, KeyPair}; use rusqlite::{Connection, OptionalExtension, params}; @@ -119,6 +120,48 @@ impl RotationStore { private_key_pem: key, }) } + /// Independent stable-updater mTLS read ONLY. This cannot initialize, + /// rotate, acknowledge, alter selectors, enroll or allocate a generation. + /// Concurrent rotation may make transport fail; it never selects a key + /// from another device or treats old TLS as an execution/sync lease. + pub fn read_only_current( + &self, + db: &Connection, + keys: &impl KeyFiles, + now: i64, + ) -> Result { + ensure!( + unsafe { rusqlite::ffi::sqlite3_db_readonly(db.handle(), c"main".as_ptr()) } == 1 + && db.query_row("PRAGMA query_only", [], |r| r.get::<_, bool>(0))? + && !db.query_row("PRAGMA trusted_schema", [], |r| r.get::<_, bool>(0))?, + "ROTATION_READ_ONLY_CONNECTION_REQUIRED" + ); + let tx = db.unchecked_transaction()?; + for table in ["tls_rotation", "tls_versions"] { + ensure!( + tx.query_row( + "SELECT type FROM sqlite_master WHERE name=?1", + [table], + |r| r.get::<_, String>(0) + )? == "table", + "ROTATION_SELECTOR_MUST_BE_TABLE" + ); + } + let (version, _) = self.selector(&tx)?; + let length: u64 = tx.query_row( + "SELECT length(certificate) FROM tls_versions WHERE version=?1", + [version.to_string()], + |r| r.get(0), + )?; + ensure!(length > 0 && length <= 32768, "ROTATION_CERTIFICATE_LIMIT"); + let identity = self.current(&tx, keys, now)?; + ensure!( + self.selector(&tx)?.0 == version, + "ROTATION_READ_ONLY_SNAPSHOT_CHANGED" + ); + tx.commit()?; + Ok(identity) + } fn verify(&self, pem: &[u8], key: &[u8], now: i64) -> Result<(i64, i64)> { ensure!( pem.len() <= 32768 && key.len() <= 16384, @@ -590,6 +633,29 @@ mod tests { .unwrap() } #[test] + fn updater_tls_snapshot_requires_read_only_handle_and_preserves_selector() { + let (db, keys, store, _, cert) = setup(); + db.execute_batch("PRAGMA trusted_schema=OFF;PRAGMA query_only=ON") + .unwrap(); + assert!(store.read_only_current(&db, &keys, now()).is_err()); + db.execute_batch("PRAGMA query_only=OFF").unwrap(); + let path = std::env::temp_dir().join(format!("rmm-tls-read-{}.sqlite", Uuid::new_v4())); + db.execute("VACUUM INTO ?1", [path.to_str().unwrap()]) + .unwrap(); + let read = + Connection::open_with_flags(&path, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY).unwrap(); + assert!(store.read_only_current(&read, &keys, now()).is_err()); + read.execute_batch("PRAGMA query_only=ON;PRAGMA trusted_schema=OFF") + .unwrap(); + let before = store.selector(&read).unwrap(); + let identity = store.read_only_current(&read, &keys, now()).unwrap(); + assert_eq!(identity.certificate_pem, cert.as_bytes()); + assert_eq!(identity.private_key_pem, keys.read(Uuid::nil()).unwrap()); + assert_eq!(store.selector(&read).unwrap(), before); + drop(read); + std::fs::remove_file(path).unwrap(); + } + #[test] fn active_idle_admission_is_atomic_retained_and_cannot_adopt_legacy_pending() { let (mut db, keys, store, _, _) = setup(); let witness = b"exact independently checked idle context"; diff --git a/crates/agent-windows/src/helper_ipc.rs b/crates/agent-windows/src/helper_ipc.rs index 3d01f33..88e1729 100644 --- a/crates/agent-windows/src/helper_ipc.rs +++ b/crates/agent-windows/src/helper_ipc.rs @@ -36,8 +36,8 @@ pub const PIPE_NAME: &str = r"\\.\pipe\RustDiscovery-System-v2"; pub const TIME_PIPE_NAME: &str = r"\\.\pipe\RustDiscovery-System-Time-v1"; const FRAME_TAG: [u8; 8] = *b"RDPIPC02"; const DRAIN_TAG: [u8; 8] = *b"RDPACK02"; -const FRAME_HEADER_LEN: usize = 12; -const DRAIN_RECEIPT_LEN: usize = 56; +pub(crate) const FRAME_HEADER_LEN: usize = 12; +pub(crate) const DRAIN_RECEIPT_LEN: usize = 56; pub const FRAME_LIMIT: usize = 1024 * 1024; pub const CLIENT_PIPE_RIGHTS: u32 = 0x0012_0083; // data R/W, attributes R, RC, synchronize; no bit4 const READ_MASK: u32 = 0x0012_00a9; @@ -302,6 +302,8 @@ pub enum Operation { generation: u64, }, Probe {}, + UpdateObserve {request:crate::update_observer::Request}, + UpdateHealth {request:rmm_agent_core::update_handoff::NativeControlRequest}, Snapshot { generation: u64, }, @@ -361,10 +363,17 @@ pub enum ReplyBody { ready: bool, ledger: FileIdentity, lock: FileIdentity, + #[serde(default,skip_serializing_if="Option::is_none")] + reboot_privilege_available:Option, + /// Passive protocol negotiation only; no update capability/readiness. + #[serde(default,skip_serializing_if="Option::is_none")] + update_observer_configured:Option, }, Snapshot { snapshot: Snapshot, }, + UpdateObservation {response:Box}, + UpdateHealth {reply:Box}, Applied { snapshot: Snapshot, unlocked_grants: Vec, @@ -374,6 +383,9 @@ pub enum ReplyBody { Executed { outcome: Outcome, }, + UpdateAccepted { + accepted: crate::update_admission::Accepted, + }, Abandoned { outcome: Outcome, }, @@ -408,7 +420,7 @@ pub fn binding_hash(b: &Binding) -> Result { pub fn wide(s: impl AsRef) -> Vec { s.as_ref().encode_wide().chain(Some(0)).collect() } -fn owned(raw: HANDLE) -> Result { +pub(crate) fn owned(raw: HANDLE) -> Result { if raw.is_null() || raw == INVALID_HANDLE_VALUE { return Err(api_failure("HELPER_HANDLE")); } @@ -540,7 +552,7 @@ pub fn require_self(peer: &PeerPin) -> Result<()> { let token = owned(token)?; verify_token(token.as_raw_handle(), &peer.user_sid, &peer.service_sid) } -fn check_acl( +pub(crate) fn check_acl( handle: HANDLE, readers: &[String], writers: &[String], @@ -801,7 +813,7 @@ impl Drop for ServiceHandle { } } } -fn service_status(pin: &PeerPin) -> Result { +pub(crate) fn service_status(pin: &PeerPin) -> Result { let manager = ServiceHandle(unsafe { OpenSCManagerW(ptr::null(), ptr::null(), SC_MANAGER_CONNECT) }); ensure!(!manager.0.is_null(), "HELPER_SCM_MANAGER"); @@ -906,7 +918,7 @@ impl ProcessIdentity { } } impl PeerProof { - fn capture(pipe: HANDLE, pin: &PeerPin, client: bool) -> Result { + pub(crate) fn capture(pipe: HANDLE, pin: &PeerPin, client: bool) -> Result { let mut pid = 0; ensure!( unsafe { @@ -923,7 +935,7 @@ impl PeerProof { } /// Internal fixture admission shares the exact same live-process proof as /// both pipe peers. The caller supplies the PID read from its held SCM handle. - pub(crate) fn for_service(pin: &PeerPin, pid: u32) -> Result { + pub fn for_service(pin: &PeerPin, pid: u32) -> Result { ensure!(pid == service_status(pin)?, "HELPER_PIPE_SCM_PID"); let process = owned(unsafe { OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION | SYNCHRONIZE, 0, pid) })?; @@ -1040,9 +1052,9 @@ impl PeerProof { } } -struct Descriptor(*mut c_void); +pub(crate) struct Descriptor(pub(crate) *mut c_void); impl Descriptor { - fn from(s: &str) -> Result { + pub(crate) fn from(s: &str) -> Result { let mut descriptor = ptr::null_mut(); ensure!( unsafe { @@ -1106,18 +1118,18 @@ fn pipe_descriptor(agent: &str, helper: &str) -> Result { )) } -struct IoEvent { +pub(crate) struct IoEvent { event: OwnedHandle, - overlapped: OVERLAPPED, + pub(crate) overlapped: OVERLAPPED, } impl IoEvent { - fn new() -> Result { + pub(crate) fn new() -> Result { let event = owned(unsafe { CreateEventW(ptr::null(), 1, 0, ptr::null()) })?; let mut overlapped: OVERLAPPED = unsafe { zeroed() }; overlapped.hEvent = event.as_raw_handle(); Ok(Self { event, overlapped }) } - fn wait(&mut self, pipe: HANDLE, deadline: Instant) -> Result { + pub(crate) fn wait(&mut self, pipe: HANDLE, deadline: Instant) -> Result { let left = deadline.saturating_duration_since(Instant::now()); let milliseconds = u32::try_from(left.as_millis().max(1)).unwrap_or(u32::MAX - 1); if unsafe { WaitForSingleObject(self.event.as_raw_handle(), milliseconds) } != WAIT_OBJECT_0 @@ -1167,7 +1179,7 @@ impl IoEvent { Ok(count) } } -fn transfer(pipe: HANDLE, bytes: &mut [u8], write: bool, deadline: Instant) -> Result<()> { +pub(crate) fn transfer(pipe: HANDLE, bytes: &mut [u8], write: bool, deadline: Instant) -> Result<()> { let mut offset = 0; while offset < bytes.len() { ensure!(Instant::now() < deadline, "HELPER_PIPE_TIMEOUT"); @@ -1222,7 +1234,7 @@ impl Write for LimitedJson { Ok(()) } } -fn encode(value: &impl Serialize) -> Result> { +pub(crate) fn encode(value: &impl Serialize) -> Result> { let mut writer = LimitedJson(Vec::with_capacity(FRAME_LIMIT)); serde_json::to_writer(&mut writer, value)?; ensure!(!writer.0.is_empty(), "HELPER_FRAME_EMPTY"); @@ -1235,12 +1247,12 @@ fn frame_header(len: usize) -> Result<[u8; FRAME_HEADER_LEN]> { header[8..].copy_from_slice(&u32::try_from(len)?.to_be_bytes()); Ok(header) } -fn send_bytes(pipe: HANDLE, bytes: &mut [u8], deadline: Instant) -> Result<()> { +pub(crate) fn send_bytes(pipe: HANDLE, bytes: &mut [u8], deadline: Instant) -> Result<()> { let mut header = frame_header(bytes.len())?; transfer(pipe, &mut header, true, deadline)?; transfer(pipe, bytes, true, deadline) } -fn send(pipe: HANDLE, value: &impl Serialize, deadline: Instant) -> Result<()> { +pub(crate) fn send(pipe: HANDLE, value: &impl Serialize, deadline: Instant) -> Result<()> { send_bytes(pipe, &mut encode(value)?, deadline) } fn frame_length(header: [u8; FRAME_HEADER_LEN]) -> Result { @@ -1249,30 +1261,30 @@ fn frame_length(header: [u8; FRAME_HEADER_LEN]) -> Result { ensure!((1..=FRAME_LIMIT).contains(&len), "HELPER_FRAME_LENGTH"); Ok(len) } -fn length(pipe: HANDLE, deadline: Instant) -> Result { +pub(crate) fn length(pipe: HANDLE, deadline: Instant) -> Result { let mut header = [0u8; FRAME_HEADER_LEN]; transfer(pipe, &mut header, false, deadline)?; frame_length(header) } -fn body_bytes(pipe: HANDLE, len: usize, deadline: Instant) -> Result> { +pub(crate) fn body_bytes(pipe: HANDLE, len: usize, deadline: Instant) -> Result> { ensure!((1..=FRAME_LIMIT).contains(&len), "HELPER_FRAME_LENGTH"); let mut bytes = vec![0u8; len]; transfer(pipe, &mut bytes, false, deadline)?; Ok(bytes) } -fn body(pipe: HANDLE, len: usize, deadline: Instant) -> Result { +pub(crate) fn body(pipe: HANDLE, len: usize, deadline: Instant) -> Result { Ok(serde_json::from_slice(&body_bytes(pipe, len, deadline)?)?) } // This fixed-size receipt only acknowledges receipt of these transport bytes. // It never acknowledges durable evidence, clears state, or permits an effect. -fn drain_receipt(challenge: Uuid, reply_bytes: &[u8]) -> [u8; DRAIN_RECEIPT_LEN] { +pub(crate) fn drain_receipt(challenge: Uuid, reply_bytes: &[u8]) -> [u8; DRAIN_RECEIPT_LEN] { let mut receipt = [0; DRAIN_RECEIPT_LEN]; receipt[..8].copy_from_slice(&DRAIN_TAG); receipt[8..24].copy_from_slice(challenge.as_bytes()); receipt[24..].copy_from_slice(&Sha256::digest(reply_bytes)); receipt } -fn verify_drain_receipt( +pub(crate) fn verify_drain_receipt( receipt: &[u8; DRAIN_RECEIPT_LEN], challenge: Uuid, reply_bytes: &[u8], @@ -1470,8 +1482,11 @@ fn exchange_fixed(pin: &Pin, call: &Call, timeout: Duration, time_only: bool) -> (_, ReplyBody::Denied { .. }) | (Operation::Probe { .. }, ReplyBody::Probe { .. }) | (Operation::Snapshot { .. }, ReplyBody::Snapshot { .. }) + | (Operation::UpdateHealth {..},ReplyBody::UpdateHealth{..}) + | (Operation::UpdateObserve {..},ReplyBody::UpdateObservation{..}) | (Operation::Apply { .. }, ReplyBody::Applied { .. }) | (Operation::Execute { .. }, ReplyBody::Executed { .. }) + | (Operation::Execute { .. }, ReplyBody::UpdateAccepted { .. }) | (Operation::Abandon { .. }, ReplyBody::Abandoned { .. }) | (Operation::TimeBegin { .. }, ReplyBody::TimeChallenge { .. }) | ( diff --git a/crates/agent-windows/src/helper_runtime.rs b/crates/agent-windows/src/helper_runtime.rs index a75169a..9789b83 100644 --- a/crates/agent-windows/src/helper_runtime.rs +++ b/crates/agent-windows/src/helper_runtime.rs @@ -25,8 +25,11 @@ const PROBE_FILE: &str = "helper-probe.json"; #[derive(Clone)] pub struct Client { pin: ipc::Pin, + raw_pin_sha256: String, + raw_settings_sha256: String, lane: Arc, qualified_capabilities: Vec, + update_observer_configured:bool, probed_at: Option, } pub struct ControlSnapshot { @@ -62,6 +65,28 @@ impl Client { file.file.read_to_end(&mut bytes)?; let pin: ipc::Pin = serde_json::from_slice(&bytes)?; pin.validate()?; + let mut settings_file = ipc::PinnedFile::open( + Path::new(crate::helper_system::CONFIG_PATH), + false, + &readers, + &[], + false, + )?; + ensure!( + settings_file.file.metadata()?.len() <= 32768, + "HELPER_SETTINGS_LIMIT" + ); + let mut settings_raw = Vec::new(); + (&mut settings_file.file) + .take(32769) + .read_to_end(&mut settings_raw)?; + ensure!(settings_raw.len() <= 32768, "HELPER_SETTINGS_LIMIT"); + let settings: crate::helper_system::Settings = serde_json::from_slice(&settings_raw)?; + ensure!( + serde_json::to_vec(&settings.pin()?)? == serde_json::to_vec(&pin)?, + "HELPER_CURRENT_SETTINGS_PIN_BINDING" + ); + settings_file.check()?; ensure!( pin.binding.agent_id.to_string() == agent_id && pin.binding.asset_id.to_string() == asset_id @@ -75,7 +100,15 @@ impl Client { "HELPER_JOB_BINDING_MISMATCH" ); } - Ok(Some(Self { pin, lane, qualified_capabilities:vec![], probed_at:None })) + Ok(Some(Self { + raw_pin_sha256: rmm_domain::jobs::hash(&bytes), + raw_settings_sha256: rmm_domain::jobs::hash(&settings_raw), + pin, + lane, + qualified_capabilities: vec![], + update_observer_configured:false, + probed_at: None, + })) } pub async fn refresh( agent_id: String, @@ -112,7 +145,9 @@ impl Client { )? .context("HELPER_PIN_REMOVED")?; ensure!( - serde_json::to_vec(¤t.pin)? == serde_json::to_vec(&self.pin)?, + serde_json::to_vec(¤t.pin)? == serde_json::to_vec(&self.pin)? + && current.raw_pin_sha256 == self.raw_pin_sha256 + && current.raw_settings_sha256 == self.raw_settings_sha256, "HELPER_PIN_CHANGED" ); Ok(()) @@ -123,6 +158,32 @@ impl Client { pub fn helper_binary_hash(&self) -> &str { &self.pin.helper.binary_sha256 } + fn retained_intent_context(&self, intent: &intent::Intent, job: &JobPayload) -> bool { + if intent.policy_sha256 == self.pin.policy_sha256 + && intent.helper_binary_sha256 == self.pin.helper.binary_sha256 + { + return true; + } + let Action::UpdateAgent { update } = &job.action else { + return false; + }; + let rmm_domain::agent_update::PeerPinTransition::WindowsCodePairV1 { + new_pin_sha256, + new_settings_sha256, + time_profile: Some(_), + .. + } = &update.peer_pin_transition + else { + return false; + }; + update.validate() + && intent.helper_binary_sha256 == update.predecessor.helper_sha256 + && update + .manifest() + .is_ok_and(|manifest| manifest.artifacts[1].sha256 == self.pin.helper.binary_sha256) + && *new_pin_sha256 == self.raw_pin_sha256 + && *new_settings_sha256 == self.raw_settings_sha256 + } /// Import only independently authenticated raw helper evidence. c+start is /// atomic through the existing core API. A crash before outcome persistence /// stays locked; the next fresh snapshot repairs that exact start idempotently. @@ -159,9 +220,9 @@ impl Client { let permit = intent.permit()?; ensure!( self.supports_system(&job) - && intent.policy_sha256 == self.pin.policy_sha256 - && intent.helper_binary_sha256 == self.pin.helper.binary_sha256 - && snapshot.boot_id == intent.original_boot_id + && self.retained_intent_context(&intent, &job) + && (snapshot.boot_id == intent.original_boot_id + || rmm_domain::windows_reboot::supported(&job)) && snapshot.journal_id == intent.anchor.journal_id() && snapshot.checkpoint >= intent.anchor.checkpoint() && observed_at >= intent.recorded_at @@ -176,8 +237,78 @@ impl Client { .next() .context("SYSTEM_DELEGATION_NO_HELPER_EVIDENCE")?; ensure!(matches.next().is_none(), "SYSTEM_DUPLICATE_HELPER_ATTEMPT"); + if matches!(job.action, Action::UpdateAgent { .. }) + && !row.update_handoff_bytes.is_empty() + { + let proof = rmm_domain::agent_update::UpdateInflightProof::from_bytes( + &row.update_handoff_bytes, + ) + .map_err(anyhow::Error::msg)?; + let key = rmm_domain::agent_update::job_health_public_key(&job) + .map_err(anyhow::Error::msg)?; + let (handoff, _) = rmm_domain::agent_update::verify_inflight_proof(&proof, key) + .map_err(anyhow::Error::msg)?; + ensure!( + rmm_domain::agent_update::handoff_matches_job(&handoff, &job) + && handoff.attempt.grant_id == permit.grant_id + && row.job_id == job.job_id + && row.attempt_id == job.attempt_id + && row.job_payload_hash == permit.job_payload_hash + && row.authorization_id == permit.authorization_id + && row.plan_hash == permit.plan_hash + && row.action == permit.action + && row.execution_identity == "system" + && row.grant_id == permit.grant_id + && row.original_request_sha256 + == rmm_domain::jobs::hash(&serde_json::to_vec(&intent.request)?) + && row.original_boot_id == intent.original_boot_id + && handoff.boot_id == intent.original_boot_id + && row.state == "running" + && row.consumption == "consumed" + && row.outcome_bytes.is_empty() + && row.outcome_sha256.is_empty() + && snapshot.journal_id == handoff.helper_journal_id, + "UPDATE_MIRROR_ORIGINAL_INFLIGHT" + ); + let start = core_ledger::start_witness_bytes( + &permit, + &intent.request, + handoff.boot_id, + proof.delegation.prepared_at, + )?; + ensure!( + rmm_domain::jobs::hash(&start) == handoff.attempt.original_start_witness_sha256, + "UPDATE_MIRROR_ORIGINAL_START" + ); + let existing: Option> = ledger + .query_row( + "SELECT start FROM execution_evidence WHERE grant_id=?1", + [permit.grant_id.to_string()], + |r| r.get(0), + ) + .optional()?; + if let Some(existing) = existing { + ensure!(existing == start, "UPDATE_MIRROR_LOCAL_START_CONFLICT"); + } else { + core_ledger::begin_execution( + ledger, + &permit, + &intent.request, + handoff.boot_id, + proof.delegation.prepared_at, + )?; + } + continue; + } let outcome = verified_mirror_row(row, &job, &permit, &intent.request, intent.original_boot_id)?; + if rmm_domain::windows_reboot::supported(&job) && outcome.state == "succeeded" { + ensure!( + snapshot.boot_id != intent.original_boot_id + && outcome.evidence["new_boot_id"] == snapshot.boot_id.to_string(), + "SYSTEM_REBOOT_MIRROR_NEW_BOOT" + ); + } let existing:Option<(String,u64,String,String,Vec)>=ledger.query_row("SELECT c.agent,c.generation,c.job,c.attempt,e.start FROM consumed c JOIN execution_evidence e USING(grant_id) WHERE c.grant_id=?1",[permit.grant_id.to_string()],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?,r.get(3)?,r.get(4)?))).optional()?; if let Some((agent, generation, j, a, start)) = existing { let start: serde_json::Value = serde_json::from_slice(&start)?; @@ -189,9 +320,16 @@ impl Client { && a == job.attempt_id.to_string() && serde_json::to_vec(&request)? == serde_json::to_vec(&intent.request)? && start["previous_boot_id"] == intent.original_boot_id.to_string() - && serde_json::from_value::>( - start["reserved_at"].clone() - )? == intent.recorded_at, + && { + let at = serde_json::from_value::>( + start["reserved_at"].clone(), + )?; + if matches!(job.action, Action::UpdateAgent { .. }) { + at >= permit.not_before && at < permit.start_before + } else { + at == intent.recorded_at + } + }, "SYSTEM_MIRROR_LOCAL_START_CONFLICT" ); } else { @@ -226,10 +364,9 @@ impl Client { == Some(row.outcome_sha256.as_str()); ensure!( self.supports_system(&job) - && ((intent.policy_sha256 == self.pin.policy_sha256 - && intent.helper_binary_sha256 == self.pin.helper.binary_sha256) - || mirrored) - && snapshot.boot_id == intent.original_boot_id + && (self.retained_intent_context(&intent, &job) || mirrored) + && (snapshot.boot_id == intent.original_boot_id + || rmm_domain::windows_reboot::supported(&job)) && snapshot.journal_id == intent.anchor.journal_id() && snapshot.checkpoint >= intent.anchor.checkpoint(), "SYSTEM_MIRROR_CONTEXT" @@ -358,25 +495,48 @@ impl Client { ready, ledger, lock, + reboot_privilege_available, + update_observer_configured, } = reply.body else { anyhow::bail!("HELPER_PROBE_DENIED"); }; let value = json!({"schema_version":1,"source":"actual_local_service_runtime","agent_process_id":std::process::id(),"agent_service":crate::SERVICE_NAME,"agent_id":pin.binding.agent_id,"asset_id":pin.binding.asset_id,"challenge":reply.challenge,"observed_at":chrono::Utc::now(),"helper_service":ipc::HELPER_SERVICE,"verified_helper_user_sid":pin.helper.user_sid,"verified_helper_service_sid":pin.helper.service_sid,"helper_binary_sha256":reply.helper_binary_sha256,"policy_sha256":reply.policy_sha256,"authenticated_pipe_exchange":true,"client_service_pid_verified_by_helper":true,"ledger_file_id":ledger,"executor_lock_file_id":lock,"helper_clock_qualified":clock_qualified,"helper_ready":ready,"system_capability_advertised":false,"no_jobs":true}); self.check_pin()?; - // Advertise the static qualification independently of this connection's - // clock warm-up: a capability change forces a reconnect, which resets the - // per-generation clock again. Every start stays gated by helper readiness. - let _ = clock_qualified; - self.qualified_capabilities=crate::system_capabilities::qualified(pin,true)?; - self.probed_at=Some(std::time::Instant::now()); - let mut value=value; - value["system_capability_advertised"]=json!(!self.qualified_capabilities.is_empty()); - value["qualified_capabilities"]=json!(self.qualified_capabilities); + // Static qualification only; a per-connection clock warm-up must not flap + // advertised capabilities (each change forces a reconnect). + let qualification=crate::system_capabilities::qualified(pin,true,reboot_privilege_available); + let system_qualification_unavailable=qualification.is_err(); + // Capability evidence is deny-only. A missing/stale optional record + // cannot remove the separately authenticated control/SignedSync lane. + self.qualified_capabilities=qualification.unwrap_or_default(); + self.update_observer_configured=update_observer_configured==Some(true); + self.probed_at = Some(std::time::Instant::now()); + let mut value = value; + if system_qualification_unavailable { + value["system_qualification_diagnostic"]="SYSTEM_QUALIFICATION_UNAVAILABLE".into(); + } + value["system_capability_advertised"] = json!(!self.qualified_capabilities.is_empty()); + value["qualified_capabilities"] = json!(self.qualified_capabilities); + if let Some(available) = reboot_privilege_available { + value["reboot_privilege_available"] = json!(available); + } write_current_probe(state, &value).context(ipc::Stage::ClientReport) } + /// An actual recent authenticated Probe negotiates the passive method. + /// Old helpers/missing local policy return false; never probe unknown IPC. + pub fn update_observer_configured(&self)->bool { + self.update_observer_configured && self.probed_at.is_some_and(|at|at.elapsed()<=Duration::from_secs(90)) + } pub fn qualified_capabilities(&self) -> Vec { - if self.probed_at.is_some_and(|at|at.elapsed()<=Duration::from_secs(90)) {self.qualified_capabilities.clone()} else {vec![]} + if self + .probed_at + .is_some_and(|at| at.elapsed() <= Duration::from_secs(90)) + { + self.qualified_capabilities.clone() + } else { + vec![] + } } /// Pure admission shape only; no capability or qualification is asserted. pub fn supports_system(&self, job: &JobPayload) -> bool { @@ -394,13 +554,17 @@ impl Client { &self, intent: intent::Intent, admit: impl Fn() -> Result<()> + Send + 'static, - ) -> Result<()> { + ) -> Result> { let job = self.pin.binding.job(&intent.request.job_bytes)?; ensure!( intent.connection_generation > 0 && self.supports_system(&job), "SYSTEM_TYPED_SERVICE_REQUIRED" ); - let timeout = execution_timeout(job.max_runtime_seconds)?; + let timeout = if matches!(job.action, Action::UpdateAgent { .. }) { + Duration::from_secs(60) + } else { + execution_timeout(job.max_runtime_seconds)? + }; let permit = self .lane .clone() @@ -438,6 +602,14 @@ impl Client { let call = ipc::Call::new(&client.pin, operation); let reply = ipc::exchange(&client.pin, &call, timeout)?; client.check_pin()?; + if let ipc::ReplyBody::UpdateAccepted { accepted } = &reply.body { + ensure!( + matches!(job.action, Action::UpdateAgent { .. }), + "UPDATE_ACK_FOR_NONUPDATE" + ); + accepted.matches(&intent.request, intent.permit()?.grant_id)?; + return Ok(Some(accepted.clone())); + } let outcome = match reply.body { ipc::ReplyBody::Executed { outcome } | ipc::ReplyBody::Abandoned { outcome } => outcome, @@ -446,7 +618,7 @@ impl Client { checked_outcome(&job, &outcome)?; // A reply is never the consumption/mirror witness. Every outcome, // including a successful reply, requires a fresh raw snapshot. - Ok::<_, anyhow::Error>(()) + Ok::<_, anyhow::Error>(None) }), ) .await @@ -476,6 +648,101 @@ impl Client { ); Ok(()) } + /// Independent passive measurements only; returned records grant no job. + pub async fn observe_update(&self,request:crate::update_observer::Request)->Result { + let permit=tokio::time::timeout(Duration::from_secs(5),self.lane.clone().acquire_owned()).await.context("UPDATE_OBSERVER_LANE_BUSY")??; + let client=self.clone(); + tokio::task::spawn_blocking(move||->Result{ + let _permit=permit;client.check_pin()?; + let reply=ipc::exchange(&client.pin,&ipc::Call::new(&client.pin,ipc::Operation::UpdateObserve{request:request.clone()}),Duration::from_secs(15))?; + client.check_pin()?; + let ipc::ReplyBody::UpdateObservation{response}=reply.body else {anyhow::bail!("UPDATE_OBSERVER_HELPER_DENIED");}; + response.validate(request.generation)?; + ensure!(response.observation.predecessor.as_ref().is_some_and(|p|p.agent_sha256==client.pin.agent.binary_sha256 && p.helper_sha256==client.pin.helper.binary_sha256),"UPDATE_OBSERVER_ACTUAL_PAIR"); + Ok(*response) + }).await? + } + /// Evidence-only metadata for the already consumed original Update job. + /// No LocalService caller can claim Stop/Finalize through this route. + pub async fn submit_update_health( + &self, + handoff: &rmm_updater_handoff::Handoff, + key: [u8; 32], + receipt: rmm_updater_handoff::SignedHealth, + ) -> Result<()> { + use rmm_agent_core::update_handoff::{NativeControlOperation, NativeControlRequest}; + handoff.validate()?; + let request = NativeControlRequest { + operation: "agent_update_control_v1".into(), + schema_version: 1, + challenge: uuid::Uuid::new_v4(), + tenant_id: handoff.attempt.tenant_id, + asset_id: handoff.attempt.asset_id, + agent_id: handoff.attempt.agent_id, + enrollment_generation: handoff.attempt.enrollment_generation, + assignment_version: handoff.attempt.assignment_version, + grant_id: handoff.attempt.grant_id, + owner_nonce: handoff.owner_nonce, + handoff_sha256: rmm_domain::jobs::hash(&handoff.bytes()?), + method: NativeControlOperation::Health { receipt }, + }; + let permit = + tokio::time::timeout(Duration::from_secs(5), self.lane.clone().acquire_owned()) + .await + .context("UPDATE_HEALTH_CONTROL_BUSY")??; + let client = self.clone(); + tokio::task::spawn_blocking(move || -> Result<()> { + let _permit = permit; + client.check_pin()?; + let reply = ipc::exchange( + &client.pin, + &ipc::Call::new( + &client.pin, + ipc::Operation::UpdateHealth { + request: request.clone(), + }, + ), + Duration::from_secs(5), + )?; + client.check_pin()?; + let ipc::ReplyBody::UpdateHealth { reply } = reply.body else { + anyhow::bail!("UPDATE_HEALTH_HELPER_DENIED"); + }; + ensure!( + reply.schema_version == 1 + && reply.challenge == request.challenge + && !reply.ready + && reply.grant_id == request.grant_id + && reply.owner_nonce == request.owner_nonce + && reply.handoff_sha256 == request.handoff_sha256 + && reply.tenant_id == request.tenant_id + && reply.asset_id == request.asset_id + && reply.agent_id == request.agent_id + && reply.enrollment_generation == request.enrollment_generation + && reply.assignment_version == request.assignment_version + && reply.original_start_base64url.is_none() + && reply.pre_stop_sync_request_base64url.is_none() + && reply.pre_stop_sync_response_base64url.is_none() + && reply.claim.is_none() + && reply.original_outcome_base64url.is_none(), + "UPDATE_HEALTH_REPLY_BINDING" + ); + let proof = reply.proof.context("UPDATE_HEALTH_REPLY_PROOF")?; + let (actual, journal) = rmm_domain::agent_update::verify_inflight_proof(&proof, key) + .map_err(anyhow::Error::msg)?; + ensure!( + rmm_domain::jobs::hash(&actual.bytes()?) == request.handoff_sha256 + && matches!( + journal.phase(), + rmm_updater_handoff::Phase::HealthVerified + | rmm_updater_handoff::Phase::RollbackHealthVerified + ), + "UPDATE_HEALTH_ORIGINAL_PROOF" + ); + Ok(()) + }) + .await? + } pub async fn snapshot(&self, generation: u64, boot: uuid::Uuid) -> Result { let reply = self.call(ipc::Operation::Snapshot { generation }).await?; let ipc::ReplyBody::Snapshot { snapshot } = reply.body else { @@ -599,6 +866,18 @@ fn verified_mirror_row( Ok(outcome) } fn system_shape(job: &JobPayload) -> bool { + if let Action::UpdateAgent { update } = &job.action { + return job.execution_identity == "system" + && job.max_runtime_seconds == 600 + && update.validate() + && update.execution_identity() == Some("system") + && job + .action + .valid_job_limits(job.max_runtime_seconds, job.max_output_bytes); + } + if matches!(job.action, Action::Reboot { .. }) { + return rmm_domain::windows_reboot::supported(job); + } if job.action.full_maintenance() { return job.execution_identity == "system" && job.action.validate() @@ -627,6 +906,123 @@ fn execution_timeout(seconds: u32) -> Result { Ok(Duration::from_secs(u64::from(seconds) + 5)) } pub(super) fn checked_outcome(job: &JobPayload, outcome: &Outcome) -> Result<()> { + if let Action::UpdateAgent { update } = &job.action { + ensure!( + system_shape(job) + && outcome.stdout.is_empty() + && outcome.stderr.is_empty() + && !outcome.output_truncated + && !outcome.reboot_required, + "UPDATE_OUTCOME_SCOPE" + ); + let evidence = &outcome.evidence; + let data = &evidence["agent_update"]; + match outcome.state.as_str() { + "succeeded" => { + ensure!( + outcome.exit_code == Some(0) + && outcome.error_code.is_empty() + && evidence["postconditions_passed"] == true + && data["schema_version"] == 1 + && data["manifest_sha256"] == update.manifest_sha256 + && data["predecessor_record_sha256"] + == update.predecessor.installed_record_sha256 + && data["rolled_back"] == false + && [ + "handoff_sha256", + "installed_record_sha256", + "signed_health_sha256" + ] + .iter() + .all(|k| data[*k] + .as_str() + .is_some_and(rmm_domain::agent_update::digest)) + && data["activation_floor"] + == update + .manifest() + .map_err(anyhow::Error::msg)? + .release_sequence, + "UPDATE_SUCCESS_EVIDENCE" + ); + } + "failed" if data["rolled_back"] == true => ensure!( + outcome.exit_code.is_none() + && outcome.error_code == "AGENT_UPDATE_RETURNED_TO_PREDECESSOR" + && evidence["postconditions_passed"] == false + && data["schema_version"] == 2 + && data["manifest_sha256"] == update.manifest_sha256 + && data["predecessor_record_sha256"] + == update.predecessor.installed_record_sha256 + && data["installed_record_sha256"] + == update.predecessor.installed_record_sha256 + && ["handoff_sha256", "signed_health_sha256"] + .iter() + .all(|k| data[*k] + .as_str() + .is_some_and(rmm_domain::agent_update::digest)), + "UPDATE_ROLLBACK_EVIDENCE" + ), + "failed" | "cancelled" | "expired" => ensure!( + evidence["not_started"] == true && !outcome.error_code.is_empty(), + "UPDATE_NO_START_EVIDENCE" + ), + "unknown" => ensure!( + evidence["postconditions_passed"] != true && !outcome.error_code.is_empty(), + "UPDATE_UNKNOWN_EVIDENCE" + ), + _ => anyhow::bail!("UPDATE_NONTERMINAL_IS_NOT_OUTCOME"), + } + return Ok(()); + } + if matches!(job.action, Action::Reboot { .. }) { + ensure!( + rmm_domain::windows_reboot::supported(job) + && outcome.stdout.is_empty() + && outcome.stderr.is_empty() + && outcome.exit_code.is_none() + && !outcome.output_truncated + && !outcome.reboot_required, + "SYSTEM_REBOOT_OUTCOME_SCOPE" + ); + let e = &outcome.evidence; + match outcome.state.as_str() { + "awaiting_reboot" => ensure!( + e["provider"] == "windows.shutdown/1" + && e["native_request_accepted"] == true + && e["postconditions_passed"] == false + && e["force_apps_closed"] == false + && e["local_machine_only"] == true + && e["announcement_seconds"] + == rmm_domain::windows_reboot::ANNOUNCEMENT_SECONDS + && e["automatic_retry"] == false + && e["previous_boot_id"] + .as_str() + .is_some_and(|s| uuid::Uuid::parse_str(s).is_ok_and(|id| !id.is_nil())), + "SYSTEM_REBOOT_ACCEPTANCE_EVIDENCE" + ), + "succeeded" => ensure!( + e["postconditions_passed"] == true + && e["reconciled_after_reboot"] == true + && ["new_boot_id", "inventory_message_id"].iter().all(|k| e[k] + .as_str() + .is_some_and(|s| uuid::Uuid::parse_str(s).is_ok_and(|id| !id.is_nil()))), + "SYSTEM_REBOOT_NEW_BOOT_EVIDENCE" + ), + "failed" => ensure!( + !outcome.error_code.is_empty() && e["not_started"] == true, + "SYSTEM_REBOOT_NONSTART_EVIDENCE" + ), + "unknown" => ensure!( + !outcome.error_code.is_empty(), + "SYSTEM_REBOOT_UNKNOWN_REASON" + ), + "cancelled" | "expired" => { + ensure!(e["not_started"] == true, "SYSTEM_REBOOT_NONSTART_EVIDENCE") + } + _ => anyhow::bail!("SYSTEM_REBOOT_OUTCOME_SCOPE"), + } + return Ok(()); + } ensure!( matches!( outcome.state.as_str(), @@ -856,7 +1252,9 @@ pub fn record_verified_time( rmm_time_attestation::Role::SystemHelper => { ("helper-time-sample.json", ".helper-time.pending") } - rmm_time_attestation::Role::Updater => anyhow::bail!("TIME_UPDATER_OWN_PROFILE_REQUIRED"), + rmm_time_attestation::Role::Updater => { + anyhow::bail!("TIME_UPDATER_EVIDENCE_NOT_AGENT_OWNED") + } }; let value = json!({ "schema_version": 1, "agent_pid": std::process::id(), "observed_at": observed_at, @@ -906,6 +1304,37 @@ fn write_report(state: &Path, name: &str, pending: &str, value: &serde_json::Val mod tests { use super::*; #[test] + fn reboot_acceptance_is_not_success_and_cannot_inherit_another_action() { + let mut job = msi_test_job(); + job.action = Action::Reboot { + reason: "Windows-MVP".into(), + dependency_group: "windows-mvp".into(), + reconnect_timeout_seconds: 180, + }; + job.max_runtime_seconds = 60; + let old = uuid::Uuid::new_v4(); + let mut o = Outcome { + state: "awaiting_reboot".into(), + stdout: vec![], + stderr: vec![], + exit_code: None, + output_truncated: false, + reboot_required: false, + error_code: "EFFECT_REQUIRES_RECONCILIATION".into(), + evidence: json!({"provider":"windows.shutdown/1","native_request_accepted":true,"postconditions_passed":false,"force_apps_closed":false,"local_machine_only":true,"announcement_seconds":5,"automatic_retry":false,"previous_boot_id":old}), + }; + checked_outcome(&job, &o).unwrap(); + o.state = "succeeded".into(); + assert!(checked_outcome(&job, &o).is_err()); + o.evidence = json!({"postconditions_passed":true,"reconciled_after_reboot":true,"new_boot_id":uuid::Uuid::new_v4(),"inventory_message_id":uuid::Uuid::new_v4()}); + checked_outcome(&job, &o).unwrap(); + o.evidence["inventory_message_id"] = json!(null); + assert!(checked_outcome(&job, &o).is_err()); + job.execution_identity = "agent_service".into(); + assert!(!system_shape(&job)); + assert!(checked_outcome(&job, &o).is_err()); + } + #[test] fn msi_scope_requires_bound_independent_postconditions_and_exact_noop_or_installer_exit() { let job = msi_test_job(); assert!(system_shape(&job)); diff --git a/crates/agent-windows/src/helper_system.rs b/crates/agent-windows/src/helper_system.rs index deb927f..aaeaba1 100644 --- a/crates/agent-windows/src/helper_system.rs +++ b/crates/agent-windows/src/helper_system.rs @@ -105,7 +105,7 @@ impl Settings { }) } fn permits_script(&self, job: &JobPayload) -> bool { - self.schema_version == 3 + self.schema_version >= 3 && job.execution_identity == "system" && job.action.full_maintenance() && job.action.valid_execution_identity("system") @@ -117,11 +117,17 @@ impl Settings { && self.allowed_script_profiles.as_deref() == Some(&[rmm_domain::jobs::PrivilegedScriptProfile::FullMaintenanceV1]) } + fn permits_reboot(&self, job: &JobPayload) -> bool { + self.schema_version == 4 + && self.allow_reboot + && rmm_domain::windows_reboot::supported(job) + && job.max_runtime_seconds <= self.max_runtime_seconds + } pub fn validate(&self) -> Result<()> { ensure!( - matches!(self.schema_version, 1..=3) + matches!(self.schema_version, 1..=4) && (self.schema_version >= 2 || self.allowed_msi_recipe_sha256.is_none()) - && (self.schema_version == 3 || self.allowed_script_profiles.is_none()) + && (self.schema_version >= 3 || self.allowed_script_profiles.is_none()) && self .allowed_msi_recipe_sha256 .as_ref() @@ -137,7 +143,7 @@ impl Settings { && self.allowed_script_profiles.as_deref().is_none_or( |v| v == [rmm_domain::jobs::PrivilegedScriptProfile::FullMaintenanceV1] ) - && !self.allow_reboot + && (self.schema_version == 4 || !self.allow_reboot) && (1..=120).contains(&self.max_runtime_seconds) && self.allowed_services.len() <= 16, "SYSTEM_POLICY_PROFILE" @@ -228,14 +234,14 @@ pub fn read_settings() -> Result<(Settings, Vec)> { settings.validate()?; Ok((settings, vec![root, file])) } -struct WindowsBoot(Uuid); +pub struct WindowsBoot(Uuid); impl BootSource for WindowsBoot { fn current_boot(&self) -> Result { Ok(self.0) } } impl WindowsBoot { - fn capture() -> Result { + pub fn capture() -> Result { // The exact existing fixed read-only CIM getter, independently called here. // No caller values, execution-policy flag, or supplied command are accepted. let rt = tokio::runtime::Builder::new_current_thread() @@ -306,6 +312,16 @@ impl LedgerGuard { guard.check(&db)?; Ok((guard, db)) } + pub(crate) fn update_identity( + &self, + db: &Connection, + ) -> Result { + self.check(db)?; + Ok(crate::update_state::LedgerIdentity { + ledger: self.ledger.identity, + lock: self.lock.identity, + }) + } fn check_files(&self) -> Result<()> { for file in [&self.root, &self.lock, &self.ledger] { ensure!( @@ -833,6 +849,17 @@ struct UnsettledMsi { request_sha256: String, installer: Box, } +/// Internal native-control adapter. No caller can construct readiness, choose +/// another database, or replace the real held executor through the wire. +pub(crate) struct UpdateContext<'a> { + pub db:&'a mut Connection, + pub guard:&'a LedgerGuard, + pub binding:&'a Binding, + pub clock:&'a BoundClock, + pub pin:&'a Pin, + pub boot:&'a WindowsBoot, + pub sync:Option<&'a mut HelperSync>, +} pub struct SystemHelper { settings: Settings, pin: Pin, @@ -845,6 +872,7 @@ pub struct SystemHelper { last_diagnostic: Option, last_apply_diagnostic: Option, unsettled_msi: Option, + pending_update_activation: Option, } impl SystemHelper { pub fn open() -> Result { @@ -870,8 +898,13 @@ impl SystemHelper { last_diagnostic: None, last_apply_diagnostic: None, unsettled_msi: None, + pending_update_activation: None, }) } + pub(crate) fn update_context(&mut self)->UpdateContext<'_> { + UpdateContext{db:&mut self.db,guard:&self.guard,binding:&self.settings.binding,clock:&self.clock, + pin:&self.pin,boot:&self.boot,sync:self.sync.as_mut()} + } pub fn pin(&self) -> &Pin { &self.pin } @@ -922,54 +955,8 @@ impl SystemHelper { ); Ok(()) } - // One authenticated control call, same original bytes/capture/deadline. - // Only a typed clock failure proven before BEGIN can be retried. - fn apply_control_with_clock( - &mut self, - response: &rmm_agent_core::helper_reconcile::SignedResponse, - request: &[u8], - issued: chrono::DateTime, - until: chrono::DateTime, - ) -> Result { - let began = Instant::now(); - loop { - ensure!( - began.elapsed() < Duration::from_secs(3), - "SYSTEM_APPLY_CLOCK_WAIT_EXPIRED" - ); - match crate::job_readiness::response_window( - issued, - until, - began.elapsed(), - self.clock.reading().ok().map(|r| (r.own_wall, r.upper)), - ) { - crate::job_readiness::ResponseWindow::WaitForClock => { - std::thread::sleep(Duration::from_millis(20)); - continue; - } - crate::job_readiness::ResponseWindow::Expired => { - anyhow::bail!("SYSTEM_APPLY_ORIGINAL_DEADLINE_EXPIRED") - } - crate::job_readiness::ResponseWindow::WithinWindow => {} - } - self.sync()?; - match self.sync.as_mut().unwrap().apply( - &mut self.db, - &self.guard, - response, - request, - &self.clock, - &self.boot, - ) { - Ok(value) => return Ok(value), - Err(error) - if rmm_agent_core::helper_reconcile::retryable_precommit_clock(&error) => - { - std::thread::sleep(Duration::from_millis(20)) - } - Err(error) => return Err(error), - } - } + fn wait_apply_clock(&self,issued:chrono::DateTime,until:chrono::DateTime)->Result<()> { + crate::job_readiness::wait_for_helper_apply_clock(&self.clock,issued,until) } /// Passive, bounded static denial metadata only. Never feeds a gate. fn record_apply_error(&mut self,error:&anyhow::Error)->Result<()> { @@ -1030,6 +1017,13 @@ impl SystemHelper { | Operation::TimeClose { .. } => { anyhow::bail!("SYSTEM_TIME_PIPE_REQUIRED") } + Operation::UpdateObserve{request}=>{ + Ok(ReplyBody::UpdateObservation{response:Box::new(crate::update_observer::collect(self.update_context(),request)?)}) + } + Operation::UpdateHealth{request}=>{ + ensure!(matches!(request.method,rmm_agent_core::update_handoff::NativeControlOperation::Health{..}),"UPDATE_AGENT_HEALTH_ONLY"); + Ok(ReplyBody::UpdateHealth{reply:Box::new(crate::update_control::handle_agent_health(self.update_context(),peer,request)?)}) + } Operation::Probe {} => { let ready = self.settings.enable_effects && self @@ -1042,22 +1036,31 @@ impl SystemHelper { }) .unwrap_or(false); Ok(ReplyBody::Probe { + update_observer_configured:Some(crate::update_admission::configured(&self.settings.binding)), clock_qualified: self.clock.now().is_ok(), ready, ledger: self.guard.ledger.identity, lock: self.guard.lock.identity, + reboot_privilege_available: if self.settings.schema_version == 4 + && self.settings.allow_reboot + { + Some(crate::reboot::privilege_available()?) + } else { + None + }, }) } Operation::Snapshot { generation } => { self.clock = self.clock.for_generation(*generation); self.sync()?; - let snapshot = self.sync.as_mut().unwrap().snapshot( - &mut self.db, - &self.guard, - *generation, - &self.clock, - &self.boot, - )?; + let snapshot = if let Some(grant)=crate::update_control::active_grant(&self.db)? { + let budget=crate::update_native::Budget::new(&self.boot,self.boot.current_boot()?,Duration::from_secs(5))?; + let guard=crate::update_control::Guard::open(&self.db,&self.guard,&self.settings.binding, + &self.clock,&self.pin,&budget,grant)?; + self.sync.as_mut().unwrap().snapshot(&mut self.db,&guard,*generation,&self.clock,&self.boot)? + } else { + self.sync.as_mut().unwrap().snapshot(&mut self.db,&self.guard,*generation,&self.clock,&self.boot)? + }; Ok(ReplyBody::Snapshot { snapshot }) } Operation::Apply { @@ -1068,16 +1071,20 @@ impl SystemHelper { serde_json::from_slice(&response.decision_bytes)?; self.clock .require_generation(decision.connection_generation)?; - // Same authenticated original call, BEFORE any application. - // The independent time pipe continues on its own thread. - // No signature/deadline/lease is relaxed and no Execute retry. - let value = self.apply_control_with_clock( - response, - request_bytes, - decision.issued_at, - decision.valid_until, - )?; - let no_start_anchor = if value.ready && self.settings.enable_effects { + self.wait_apply_clock(decision.issued_at,decision.valid_until)?; + self.sync()?; + let value = if let Some(grant)=crate::update_control::active_grant(&self.db)? { + let budget=crate::update_native::Budget::new(&self.boot,self.boot.current_boot()?,Duration::from_secs(5))?; + let guard=crate::update_control::Guard::open(&self.db,&self.guard,&self.settings.binding, + &self.clock,&self.pin,&budget,grant)?; + self.sync.as_mut().unwrap().apply(&mut self.db,&guard,response,request_bytes,&self.clock,&self.boot)? + } else { + self.sync.as_mut().unwrap().apply(&mut self.db,&self.guard,response,request_bytes,&self.clock,&self.boot)? + }; + let no_start_anchor = if value.ready + && (self.settings.enable_effects + || crate::update_admission::configured(&self.settings.binding)) + { let guard = DenialGuard { ledger: &self.guard, pin: &self.pin, @@ -1109,9 +1116,41 @@ impl SystemHelper { Operation::Execute { generation, request, - } => Ok(ReplyBody::Executed { - outcome: self.execute(*generation, request, peer)?, - }), + } => { + let job = self.settings.binding.job(&request.job_bytes)?; + if matches!(job.action, Action::UpdateAgent { .. }) { + ensure!( + self.pending_update_activation.is_none(), + "UPDATE_ACTIVATION_PENDING" + ); + self.clock.require_generation(*generation)?; + self.sync()?; + let prepared = crate::update_admission::Prepared::new( + &self.db, + crate::update_admission::Local { + binding: &self.settings.binding, + guard: &self.guard, + clock: &self.clock, + boot: &self.boot, + pin: &self.pin, + generation: *generation, + }, + self.sync.as_ref().context("SYSTEM_SYNC_REQUIRED")?, + request, + )?; + peer.check()?; + let accepted = prepared.consume( + &mut self.db, + self.sync.as_mut().context("SYSTEM_SYNC_REQUIRED")?, + )?; + self.pending_update_activation = Some(prepared.into_activation()); + Ok(ReplyBody::UpdateAccepted { accepted }) + } else { + Ok(ReplyBody::Executed { + outcome: self.execute(*generation, request, peer)?, + }) + } + } Operation::Abandon { anchor, request, @@ -1125,10 +1164,15 @@ impl SystemHelper { let job = self.settings.binding.job(&request.job_bytes)?; ensure!( job.execution_identity == "system" - && job.max_runtime_seconds <= self.settings.max_runtime_seconds - && (matches!(&job.action,Action::SetServiceState{unit,state} if matches!(state.as_str(),"running"|"stopped")&&self.settings.allowed_services.iter().any(|r|r.name==*unit)) - || self.settings.permits_msi(&job) - || self.settings.permits_script(&job)), + && ((job.max_runtime_seconds <= self.settings.max_runtime_seconds + && (matches!(&job.action,Action::SetServiceState{unit,state} if matches!(state.as_str(),"running"|"stopped")&&self.settings.allowed_services.iter().any(|r|r.name==*unit)) + || self.settings.permits_msi(&job) + || self.settings.permits_script(&job) + || self.settings.permits_reboot(&job))) + || crate::update_admission::permits_denial( + &self.settings.binding, + &job + )), "SYSTEM_ABANDON_POLICY_DENIED" ); self.sync()?; @@ -1227,6 +1271,9 @@ impl SystemHelper { if job.action.windows_msi().is_some() { return self.execute_msi(generation, request, &job, &permit, peer); } + if matches!(job.action, Action::Reboot { .. }) { + return self.execute_reboot(generation, request, &job, &permit, peer); + } let mut provider = PreparedService::prepare(&self.settings, &job)?; self.recheck()?; peer.check()?; @@ -1272,6 +1319,69 @@ impl SystemHelper { ledger::finish(&self.db, &permit, &outcome)?; Ok(outcome) } + fn execute_reboot( + &mut self, + generation: u64, + request: &Request, + job: &JobPayload, + permit: &ExecutionPermitPayload, + peer: &mut ipc::PeerProof, + ) -> Result { + ensure!( + self.settings.permits_reboot(job), + "SYSTEM_REBOOT_POLICY_DENIED" + ); + self.observe_unsettled_msi()?; + ensure!( + self.unsettled_msi.is_none(), + "SYSTEM_MSI_PREVIOUS_PROCESS_UNSETTLED" + ); + let provider = crate::reboot::Prepared::prepare(job)?; + self.recheck()?; + peer.check()?; + let (_, fresh, recorded_at) = + verified_window(&self.settings.binding, request, &self.clock)?; + ensure!( + &fresh == permit && !STOP.load(Ordering::SeqCst), + "SYSTEM_REBOOT_START_FENCED" + ); + let boot = self.boot.current_boot()?; + crate::helper_runtime::intent::Store::require_not_denied( + request, + boot, + generation, + &self.pin.policy_sha256, + &self.pin.helper.binary_sha256, + )?; + ledger::begin_execution(&mut self.db, permit, request, boot, recorded_at)?; + self.sync.as_mut().unwrap().close(); + let outcome = provider + .request(boot, || { + self.clock.require_generation(generation)?; + self.recheck()?; + peer.check()?; + ensure!( + !STOP.load(Ordering::SeqCst), + "SYSTEM_REBOOT_CANCELLED_BEFORE_REQUEST" + ); + verified_window(&self.settings.binding, request, &self.clock)?; + crate::helper_runtime::intent::Store::require_not_denied( + request, + boot, + generation, + &self.pin.policy_sha256, + &self.pin.helper.binary_sha256, + )?; + Ok(()) + }) + .unwrap_or_else(|_| Outcome::unknown("WINDOWS_REBOOT_REQUEST_UNCONFIRMED")); + ledger::persist_outcome(&self.db, permit, &outcome)?; + self.guard.check(&self.db)?; + // Awaiting/Unknown deliberately keeps consumed.result NULL. Only the + // existing signed new-boot reconciliation may finish the same attempt. + ledger::finish(&self.db, permit, &outcome)?; + Ok(outcome) + } fn execute_script( &mut self, generation: u64, @@ -1650,30 +1760,76 @@ unsafe extern "system" fn service_main(_: u32, _: *mut *mut u16) { let mut helper = SystemHelper::open()?; let server = ipc::Server::bind(helper.pin().clone())?; let time_server = ipc::Server::bind_time(helper.pin().clone())?; + let update_server=crate::update_control::server_pin(&helper.settings.binding,&helper.pin.helper)? + .map(crate::update_control_ipc::Server::bind).transpose()?; let time_pin = helper.pin().clone(); let time_clock = helper.clock.source(); let time_worker = std::thread::Builder::new() .name("rmm-helper-time-control".into()) .spawn(move || time_control(time_server, time_pin, time_clock))?; scm_status(SERVICE_RUNNING, 0); + let mut next_update_unknown=Instant::now(); while !STOP.load(Ordering::SeqCst) { + if Instant::now()>=next_update_unknown { + next_update_unknown=Instant::now()+Duration::from_secs(2); + if let Err(error)=crate::update_control::observe_worker_unknown(helper.update_context()) { + let _diagnostic=helper.record_pipe_error(&error); + } + } // A failed observation keeps the owned slot and its handles locked. if helper.observe_unsettled_msi().is_err() && let Some(sync) = &mut helper.sync { sync.close(); } + if let Some(update_server)=&update_server { + match update_server.receive() { + Ok(Some(mut incoming))=> { + let reply=crate::update_control::handle_updater(helper.update_context(),&mut incoming.peer,&incoming.request); + let result=match reply { + Ok(reply)=>update_server.reply(&mut incoming,&reply), + Err(error)=>Err(error), + }; + update_server.disconnect(); + if let Err(error)=result { + if let Some(sync)=&mut helper.sync {sync.close();} + let _diagnostic=helper.record_pipe_error(&error); + } + } + Ok(None)=>{}, + Err(error)=> { + update_server.disconnect(); + if let Some(sync)=&mut helper.sync {sync.close();} + let _diagnostic=helper.record_pipe_error(&error); + } + } + } match server.receive() { Ok(Some(mut incoming)) => { let reply = helper.handle(&incoming.call, &mut incoming.peer); - if let Err(error) = server.reply(&reply, &mut incoming.peer) { + let delivered = server.reply(&reply, &mut incoming.peer); + server.disconnect(); + if let Err(error) = delivered { + if let Some(sync) = &mut helper.sync { + sync.close(); + } + // Receipt loss cannot trigger an Activate or a retry. + helper.pending_update_activation = None; + let _diagnostic = helper.record_pipe_error(&error); + } else if matches!(reply.body, ReplyBody::UpdateAccepted { .. }) + && let Some(activation) = helper.pending_update_activation.take() + && let Err(error) = activation.dispatch_after_reply( + &helper.db, + &helper.guard, + &helper.clock, + &helper.boot, + ) + { if let Some(sync) = &mut helper.sync { sync.close(); } - server.disconnect(); let _diagnostic = helper.record_pipe_error(&error); } - server.disconnect(); } Ok(None) => {} Err(error) => { @@ -1862,6 +2018,26 @@ mod tests { let mut null = legacy; null["allowed_script_profiles"] = serde_json::Value::Null; assert!(serde_json::from_value::(null).is_err()); + let mut reboot = job.clone(); + reboot.action = Action::Reboot { + reason: "Windows-MVP".into(), + dependency_group: "windows-mvp".into(), + reconnect_timeout_seconds: 180, + }; + reboot.max_runtime_seconds = 60; + settings.max_runtime_seconds = 120; + settings.allow_reboot = true; + for v in 1..=3 { + settings.schema_version = v; + assert!(!settings.permits_reboot(&reboot)); + } + settings.schema_version = 4; + assert!(settings.permits_reboot(&reboot)); + settings.allow_reboot = false; + assert!(!settings.permits_reboot(&reboot)); + settings.allow_reboot = true; + reboot.execution_identity = "agent_service".into(); + assert!(!settings.permits_reboot(&reboot)); } #[test] fn service_adapter_exposes_only_implemented_states() { diff --git a/crates/agent-windows/src/lib.rs b/crates/agent-windows/src/lib.rs index 7085308..3b8fc37 100644 --- a/crates/agent-windows/src/lib.rs +++ b/crates/agent-windows/src/lib.rs @@ -7,6 +7,8 @@ pub mod certificate_rotation; pub mod clock; pub mod echo_probe; pub mod echo_completion; +#[cfg(feature = "system-helper")] +pub mod reboot; #[cfg(all(windows, feature = "system-helper"))] pub mod system_capabilities; pub mod event_log; @@ -28,6 +30,7 @@ pub mod msi_cache; #[cfg(windows)] pub mod native; pub mod package; +pub mod release_platform; #[cfg(windows)] pub mod process; #[cfg(windows)] @@ -41,4 +44,46 @@ pub mod update_native; pub const SERVICE_NAME: &str = "RmmDiscoveryWindows"; pub const CAPABILITIES: &[&str] = &["windows.base/1", "heartbeat/1"]; +#[cfg(all(windows, feature = "system-helper"))] +pub mod update_ipc; + +#[cfg(all(windows, feature = "system-helper"))] +pub mod update_cache; + +#[cfg(all(windows, feature = "system-helper"))] +pub mod update_trust; + +#[cfg(all(windows, feature = "system-helper"))] +pub mod update_state; + +#[cfg(all(windows, feature = "system-helper"))] +pub mod release_service; + +#[cfg(all(windows, feature = "system-helper"))] +pub mod update_admission; + pub mod job_readiness; + +#[cfg(all(windows, feature = "system-helper"))] +pub mod update_original; + +#[cfg(all(windows, feature = "system-helper"))] +pub mod update_control_ipc; + +#[cfg(all(windows, feature = "system-helper"))] +pub mod update_owned; + +#[cfg(all(windows, feature = "system-helper"))] +pub(crate) mod update_control; + +#[cfg(all(windows, feature = "system-helper"))] +pub mod update_time_transport; + +#[cfg(all(windows, feature = "system-helper"))] +pub mod update_worker; + +#[cfg(all(windows, feature = "system-helper"))] +pub(crate) mod update_record; + +#[cfg(all(windows, feature = "system-helper"))] +pub mod update_observer; diff --git a/crates/agent-windows/src/main.rs b/crates/agent-windows/src/main.rs index f974603..9e4f7c1 100644 --- a/crates/agent-windows/src/main.rs +++ b/crates/agent-windows/src/main.rs @@ -1,3 +1,10 @@ +#[cfg(all(windows, feature = "system-helper"))] +mod update_observation_runtime; +#[cfg(all(windows, feature = "system-helper"))] +#[path = "../../agent/src/agent_update_health.rs"] +mod agent_update_health; +#[cfg(all(windows, feature = "system-helper"))] +mod update_download; #[cfg(windows)] #[path = "../../agent/src/https_channel.rs"] mod https_channel; diff --git a/crates/agent-windows/src/reboot.rs b/crates/agent-windows/src/reboot.rs new file mode 100644 index 0000000..2b38c9d --- /dev/null +++ b/crates/agent-windows/src/reboot.rs @@ -0,0 +1,279 @@ +//! Typed local reboot provider. The caller must durably consume the original +//! signed attempt and keep the independent helper gate before `request`. +#[cfg(any(windows, test))] +use rmm_agent_core::auth::Outcome; +#[cfg(any(windows, test))] +use uuid::Uuid; + +#[cfg(any(windows, test))] +fn report(previous_boot: Uuid, accepted: bool, native_error: u32) -> Outcome { + Outcome { + state: if accepted { + "awaiting_reboot" + } else { + "failed" + } + .into(), + stdout: vec![], + stderr: vec![], + exit_code: None, + output_truncated: false, + reboot_required: false, + error_code: if accepted { + "EFFECT_REQUIRES_RECONCILIATION" + } else { + "WINDOWS_REBOOT_REQUEST_REJECTED" + } + .into(), + evidence: serde_json::json!({"provider":"windows.shutdown/1","previous_boot_id":previous_boot,"postconditions_passed":false, + "native_request_accepted":accepted,"native_error":native_error,"not_started":!accepted,"force_apps_closed":false,"local_machine_only":true, + "announcement_seconds":rmm_domain::windows_reboot::ANNOUNCEMENT_SECONDS,"reconnect_timeout_seconds":rmm_domain::windows_reboot::RECONNECT_SECONDS, + "automatic_retry":false,"success_requires_authenticated_new_boot":true}), + } +} + +#[cfg(windows)] +mod native { + use super::*; + use anyhow::{Result, ensure}; + use std::{ + mem::{size_of, zeroed}, + ptr, + }; + use windows_sys::Win32::{ + Foundation::{ + CloseHandle, ERROR_INSUFFICIENT_BUFFER, GetLastError, HANDLE, LUID, SetLastError, + }, + Security::{ + AdjustTokenPrivileges, GetTokenInformation, LUID_AND_ATTRIBUTES, LookupPrivilegeValueW, + SE_PRIVILEGE_ENABLED, SE_SHUTDOWN_NAME, TOKEN_ADJUST_PRIVILEGES, TOKEN_PRIVILEGES, + TOKEN_QUERY, TokenPrivileges, + }, + System::{ + Shutdown::{ + InitiateSystemShutdownExW, SHTDN_REASON_FLAG_PLANNED, + SHTDN_REASON_MAJOR_APPLICATION, SHTDN_REASON_MINOR_MAINTENANCE, + }, + Threading::{GetCurrentProcess, OpenProcessToken}, + }, + }; + struct Token(HANDLE); + impl Drop for Token { + fn drop(&mut self) { + unsafe { + CloseHandle(self.0); + } + } + } + fn open(access: u32) -> Result { + let mut raw = ptr::null_mut(); + ensure!( + unsafe { OpenProcessToken(GetCurrentProcess(), access, &mut raw) } != 0, + "REBOOT_TOKEN_OPEN" + ); + Ok(Token(raw)) + } + fn luid() -> Result { + let mut id = unsafe { zeroed() }; + ensure!( + unsafe { LookupPrivilegeValueW(ptr::null(), SE_SHUTDOWN_NAME, &mut id) } != 0, + "REBOOT_PRIVILEGE_NAME" + ); + Ok(id) + } + fn present(token: &Token, wanted: &LUID) -> Result { + let mut size = 0; + unsafe { + GetTokenInformation(token.0, TokenPrivileges, ptr::null_mut(), 0, &mut size); + } + ensure!( + unsafe { GetLastError() } == ERROR_INSUFFICIENT_BUFFER && (4..=65536).contains(&size), + "REBOOT_PRIVILEGE_SIZE" + ); + let mut bytes = vec![0u64; (size as usize).div_ceil(8)]; + ensure!( + unsafe { + GetTokenInformation( + token.0, + TokenPrivileges, + bytes.as_mut_ptr().cast(), + size, + &mut size, + ) + } != 0, + "REBOOT_PRIVILEGE_READ" + ); + let p = bytes.as_ptr().cast::(); + let count = unsafe { (*p).PrivilegeCount } as usize; + let offset = std::mem::offset_of!(TOKEN_PRIVILEGES, Privileges); + ensure!( + offset + .checked_add( + count + .checked_mul(size_of::()) + .ok_or_else(|| anyhow::anyhow!("REBOOT_PRIVILEGE_OVERFLOW"))? + ) + .is_some_and(|v| v <= size as usize), + "REBOOT_PRIVILEGE_BOUNDS" + ); + let entries = unsafe { + std::slice::from_raw_parts( + ptr::addr_of!((*p).Privileges).cast::(), + count, + ) + }; + Ok(entries + .iter() + .any(|x| x.Luid.LowPart == wanted.LowPart && x.Luid.HighPart == wanted.HighPart)) + } + /// Read only; does not enable a privilege, call Shutdown or create a job. + pub fn privilege_available() -> Result { + present(&open(TOKEN_QUERY)?, &luid()?) + } + struct Privilege<'a> { + token: &'a Token, + previous: TOKEN_PRIVILEGES, + restore: bool, + } + impl<'a> Privilege<'a> { + fn enable(token: &'a Token, id: LUID) -> Result { + let change = TOKEN_PRIVILEGES { + PrivilegeCount: 1, + Privileges: [LUID_AND_ATTRIBUTES { + Luid: id, + Attributes: SE_PRIVILEGE_ENABLED, + }], + }; + let mut previous = unsafe { zeroed() }; + let mut len = 0; + unsafe { + SetLastError(0); + } + ensure!( + unsafe { + AdjustTokenPrivileges( + token.0, + 0, + &change, + size_of::() as u32, + &mut previous, + &mut len, + ) + } != 0 + && unsafe { GetLastError() } == 0, + "REBOOT_PRIVILEGE_ENABLE" + ); + Ok(Self { + token, + previous, + restore: true, + }) + } + fn restore(&mut self) -> Result<()> { + if self.restore { + ensure!( + unsafe { + AdjustTokenPrivileges( + self.token.0, + 0, + &self.previous, + 0, + ptr::null_mut(), + ptr::null_mut(), + ) + } != 0, + "REBOOT_PRIVILEGE_RESTORE" + ); + self.restore = false; + } + Ok(()) + } + } + impl Drop for Privilege<'_> { + fn drop(&mut self) { + let _ = self.restore(); + } + } + pub(crate) struct Prepared { + token: Token, + luid: LUID, + } + impl Prepared { + pub fn prepare(job: &rmm_domain::jobs::JobPayload) -> Result { + ensure!( + rmm_domain::windows_reboot::supported(job), + "WINDOWS_REBOOT_FIXED_PROFILE_REQUIRED" + ); + let token = open(TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES)?; + let luid = luid()?; + ensure!( + present(&token, &luid)?, + "WINDOWS_REBOOT_PRIVILEGE_UNAVAILABLE" + ); + Ok(Self { token, luid }) + } + pub fn request( + self, + previous_boot: Uuid, + mut last_gate: impl FnMut() -> Result<()>, + ) -> Result { + last_gate()?; + let mut privilege = Privilege::enable(&self.token, self.luid)?; + last_gate()?; + // No remote target, free command, force flag, clock setter or retry. + let message: Vec = "RustDiscovery: genehmigter Neustart" + .encode_utf16() + .chain(Some(0)) + .collect(); + let accepted = unsafe { + InitiateSystemShutdownExW( + ptr::null(), + message.as_ptr(), + rmm_domain::windows_reboot::ANNOUNCEMENT_SECONDS, + 0, + 1, + SHTDN_REASON_FLAG_PLANNED + | SHTDN_REASON_MAJOR_APPLICATION + | SHTDN_REASON_MINOR_MAINTENANCE, + ) + } != 0; + let code = if accepted { + 0 + } else { + unsafe { GetLastError() } + }; + let restored = privilege.restore(); + if accepted && restored.is_err() { + return Ok(Outcome { + evidence: serde_json::json!({"provider":"windows.shutdown/1","previous_boot_id":previous_boot,"native_request_accepted":true,"postconditions_passed":false,"automatic_retry":false}), + ..Outcome::unknown("WINDOWS_REBOOT_ACCEPTED_PRIVILEGE_RESTORE_UNCONFIRMED") + }); + } + restored?; + Ok(report(previous_boot, accepted, code)) + } + } +} +#[cfg(windows)] +pub(crate) use native::Prepared; +#[cfg(windows)] +pub use native::privilege_available; + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn native_acceptance_requires_new_boot_instead_of_claiming_success_or_retry() { + let boot = Uuid::new_v4(); + let accepted = report(boot, true, 0); + assert_eq!(accepted.state, "awaiting_reboot"); + assert!(!accepted.reboot_required); + assert_eq!(accepted.evidence["previous_boot_id"], boot.to_string()); + assert_eq!(accepted.evidence["postconditions_passed"], false); + assert_eq!(accepted.evidence["force_apps_closed"], false); + let denied = report(boot, false, 1314); + assert_eq!(denied.state, "failed"); + assert_eq!(denied.evidence["not_started"], true); + assert_eq!(denied.evidence["automatic_retry"], false); + } +} diff --git a/crates/agent-windows/src/release_platform.rs b/crates/agent-windows/src/release_platform.rs new file mode 100644 index 0000000..fb2b4b2 --- /dev/null +++ b/crates/agent-windows/src/release_platform.rs @@ -0,0 +1,14 @@ +//! The release catalog distinguishes the two Windows ABIs even on the same CPU. +#[cfg(all(windows, target_env = "gnu"))] +pub const WIRE: rmm_domain::agent_update::Platform = + rmm_domain::agent_update::Platform::WindowsGnuX64; +#[cfg(not(all(windows, target_env = "gnu")))] +pub const WIRE: rmm_domain::agent_update::Platform = rmm_domain::agent_update::Platform::WindowsX64; +#[cfg(all(windows, target_env = "gnu"))] +pub const VERIFY: rmm_updater::Platform = rmm_updater::Platform::WindowsGnuX64; +#[cfg(not(all(windows, target_env = "gnu")))] +pub const VERIFY: rmm_updater::Platform = rmm_updater::Platform::WindowsX64; +#[cfg(all(windows, target_env = "gnu"))] +pub const TRIPLE: &str = "x86_64-pc-windows-gnu"; +#[cfg(not(all(windows, target_env = "gnu")))] +pub const TRIPLE: &str = "x86_64-pc-windows-msvc"; diff --git a/crates/agent-windows/src/release_service.rs b/crates/agent-windows/src/release_service.rs new file mode 100644 index 0000000..a7bc8f2 --- /dev/null +++ b/crates/agent-windows/src/release_service.rs @@ -0,0 +1,459 @@ +//! Unattended, fixed-role releases for installations made by the HTTPS installer. +use crate::release_platform::{TRIPLE, VERIFY}; +use crate::{ + certificate_rotation::{ProtectedKeyFiles, RotationStore}, + job_binding, native, +}; +use anyhow::{Context, Result, ensure}; +use reqwest::{Client, Response}; +use rmm_domain::agent_update::ReleaseEnvelope; +use rmm_updater::ReleaseManifest; +use rusqlite::{Connection, OpenFlags}; +use serde::{Deserialize, Serialize}; +use sha2::{Digest, Sha256}; +use std::{ + ffi::OsStr, + fs, + io::Write, + net::SocketAddr, + os::windows::ffi::OsStrExt, + path::{Path, PathBuf}, + process::Command, + sync::atomic::{AtomicBool, Ordering}, + time::Duration, +}; +use uuid::Uuid; + +pub const SERVICE: &str = "RmmDiscoveryReleasePull"; +const AGENT: &str = "rmm-agent-windows.exe"; +const HELPER: &str = "rmm-helper-windows.exe"; +const ACTIVE: &str = "installed-release.json"; +const INTENT: &str = "release-transition.json"; + +#[derive(Clone, Serialize, Deserialize)] +struct Installed { + schema_version: u32, + tenant_id: Uuid, + release_id: Uuid, + release_sequence: u64, + manifest_sha256: String, +} +#[derive(Serialize, Deserialize)] +struct Transition { + old: Installed, + new: Installed, +} +#[derive(Deserialize)] +struct Endpoint { + server_name: String, + connect_address: SocketAddr, + transport: String, + state_directory: PathBuf, + ca_file: PathBuf, + #[serde(default)] + enable_jobs: bool, +} +#[derive(Deserialize)] +struct Health { + agent_id: Uuid, + agent_version: Option, + connection_generation: u64, + last_contact_at: Option>, +} +#[derive(Deserialize)] +struct Current { + status: String, + release: Option, +} +#[derive(Deserialize)] +struct Published { + release_envelope: ReleaseEnvelope, + manifest: ReleaseManifest, +} + +fn data(name: &str) -> PathBuf { + PathBuf::from(std::env::var_os("ProgramData").unwrap_or_else(|| r"C:\ProgramData".into())) + .join("RustDiscovery") + .join(name) +} +fn releases() -> PathBuf { + PathBuf::from(std::env::var_os("ProgramFiles").unwrap_or_else(|| r"C:\Program Files".into())) + .join("RustDiscovery") + .join("releases") +} +fn generation(id: Uuid) -> PathBuf { + releases().join(id.to_string()) +} + +fn protected(path: &Path, limit: usize) -> Result> { + job_binding::check_admin_readonly(path)?; + ensure!( + fs::metadata(path)?.len() <= limit as u64, + "protected file size" + ); + Ok(fs::read(path)?) +} +fn read_record(name: &str) -> Result { + Ok(serde_json::from_slice(&protected(&data(name), 8192)?)?) +} +fn write_new(path: &Path, bytes: &[u8]) -> Result<()> { + let mut file = fs::File::create_new(path)?; + file.write_all(bytes)?; + file.sync_all()?; + Ok(()) +} +fn write_record(name: &str, value: &T) -> Result<()> { + use windows_sys::Win32::Storage::FileSystem::{ + MOVEFILE_REPLACE_EXISTING, MOVEFILE_WRITE_THROUGH, MoveFileExW, + }; + let tmp = data(&format!(".release-{}", Uuid::new_v4())); + let wide = |p: &OsStr| p.encode_wide().chain(Some(0)).collect::>(); + let result = (|| -> Result<()> { + write_new(&tmp, &serde_json::to_vec(value)?)?; + let (from, to) = (wide(tmp.as_os_str()), wide(data(name).as_os_str())); + if unsafe { + MoveFileExW( + from.as_ptr(), + to.as_ptr(), + MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH, + ) + } == 0 + { + return Err(std::io::Error::last_os_error().into()); + } + Ok(()) + })(); + let _ = fs::remove_file(tmp); + result +} +struct Device { + client: Client, + base: String, + id: Uuid, +} +impl Device { + fn open(config: &Endpoint) -> Result { + ensure!( + config.transport == "https" + && config.ca_file == data("server-ca.pem") + && config.state_directory == data("state"), + "installed HTTPS configuration" + ); + let ca = protected(&config.ca_file, 32768)?; + let state = &config.state_directory; + let identity_path = state.join("identity.json"); + native::private_path(&identity_path, false)?; + ensure!( + fs::metadata(&identity_path)?.len() <= 32768, + "identity size" + ); + let identity: rmm_protocol::EnrollmentResponse = + serde_json::from_slice(&fs::read(identity_path)?)?; + let id = Uuid::parse_str(&identity.agent_id)?; + let db_path = state.join("telemetry.sqlite"); + native::private_path(&db_path, false)?; + let db = Connection::open_with_flags( + db_path, + OpenFlags::SQLITE_OPEN_READ_ONLY | OpenFlags::SQLITE_OPEN_NO_MUTEX, + )?; + db.execute_batch("PRAGMA trusted_schema=OFF;PRAGMA query_only=ON;")?; + let keys = ProtectedKeyFiles::open(state)?; + let rotation = RotationStore::new(id, 1, ca.clone())?; + let tls = rotation.read_only_current(&db, &keys, chrono::Utc::now().timestamp())?; + let mut pem = tls.certificate_pem; + pem.push(b'\n'); + pem.extend_from_slice(&tls.private_key_pem); + let base = reqwest::Url::parse(&format!( + "https://{}:{}", + config.server_name, + config.connect_address.port() + ))?; + ensure!( + base.domain() == Some(config.server_name.as_str()), + "invalid gateway hostname" + ); + let client = Client::builder() + .https_only(true) + .tls_built_in_root_certs(false) + .add_root_certificate(reqwest::Certificate::from_pem(&ca)?) + .identity(reqwest::Identity::from_pem(&pem)?) + .resolve(&config.server_name, config.connect_address) + .no_proxy() + .redirect(reqwest::redirect::Policy::none()) + .connect_timeout(Duration::from_secs(10)) + .timeout(Duration::from_secs(180)) + .build()?; + Ok(Self { + client, + base: base.origin().ascii_serialization(), + id, + }) + } + async fn get(&self, path: &str, timeout: Duration) -> Result { + let r = self + .client + .get(format!("{}{path}", self.base)) + .timeout(timeout) + .send() + .await?; + ensure!( + r.status() == 200, + "device release service returned {}", + r.status() + ); + Ok(r) + } + async fn json(&self, path: &str) -> Result { + let mut r = self.get(path, Duration::from_secs(10)).await?; + let mut body = Vec::new(); + while let Some(chunk) = r.chunk().await? { + ensure!( + body.len() + chunk.len() <= 131072, + "release response too large" + ); + body.extend_from_slice(&chunk); + } + Ok(serde_json::from_slice(&body)?) + } + async fn health(&self) -> Result { + let value: Health = self.json("/agent/v1/releases/installed").await?; + ensure!(value.agent_id == self.id, "device release identity changed"); + Ok(value) + } + async fn download(&self, path: &Path, url: &str, limit: u64) -> Result<()> { + ensure!( + (1..=rmm_updater::MAX_ARTIFACT_BYTES).contains(&limit), + "release size" + ); + let mut r = self.get(url, Duration::from_secs(180)).await?; + ensure!(r.content_length() == Some(limit), "release length"); + let mut file = fs::File::create_new(path)?; + let mut count = 0; + while let Some(chunk) = r.chunk().await? { + count += chunk.len() as u64; + ensure!(count <= limit, "release body too large"); + file.write_all(&chunk)?; + } + ensure!(count == limit, "truncated release"); + file.sync_all()?; + Ok(()) + } +} + +fn local_manifest(installed: &Installed) -> Result { + let root = generation(installed.release_id); + let raw = protected(&root.join("manifest.json"), rmm_updater::MAX_MANIFEST_BYTES)?; + ensure!( + hex::encode(Sha256::digest(&raw)) == installed.manifest_sha256, + "changed installed manifest" + ); + let m: ReleaseManifest = serde_json::from_slice(&raw)?; + ensure!( + installed.schema_version == 1 + && m.platform == VERIFY + && m.release_id == installed.release_id + && m.release_sequence == installed.release_sequence, + "installed release identity" + ); + for (expected, name) in m.artifacts.iter().zip([AGENT, HELPER]) { + let path = root.join(name); + job_binding::check_admin_readonly(&path)?; + let mut digest = Sha256::new(); + let count = std::io::copy(&mut fs::File::open(path)?, &mut digest)?; + ensure!( + expected.bytes == count && expected.sha256 == hex::encode(digest.finalize()), + "installed release component changed" + ); + } + Ok(m) +} + +// Only typed release UUIDs enter the fixed SCM command. The actual service path, +// LocalService account and absence of an independently provisioned helper are checked again on the target. +fn select(from: Uuid, to: Uuid) -> Result<()> { + let script = include_str!("release_service_switch.ps1") + .replace("FROM_UUID", &from.to_string()) + .replace("TO_UUID", &to.to_string()); + let windows = std::env::var_os("SystemRoot").context("Windows directory")?; + let ps = Path::new(&windows).join(r"System32\WindowsPowerShell\v1.0\powershell.exe"); + let result = Command::new(ps) + .args([ + "-NoLogo", + "-NoProfile", + "-NonInteractive", + "-Command", + &script, + ]) + .output()?; + ensure!(result.status.success(), "SCM release selection failed"); + Ok(()) +} +async fn rollback(t: &Transition) -> Result<()> { + local_manifest(&t.old)?; + select(t.new.release_id, t.old.release_id)?; + write_record("rejected-release.json", &t.new)?; + fs::remove_file(data(INTENT))?; + Ok(()) +} + +async fn stage(device: &Device, release: &Published, active: &Installed) -> Result { + let id = release.manifest.release_id; + let tmp = releases().join(format!(".stage-{}", Uuid::new_v4())); + fs::create_dir(&tmp)?; + let result = async { + let env_path = tmp.join("envelope.json"); + write_new(&env_path, &serde_json::to_vec(&release.release_envelope)?)?; + for (entry, name) in release.manifest.artifacts.iter().zip([AGENT, HELPER]) { + device + .download( + &tmp.join(name), + &format!("/agent/v1/releases/{id}/artifacts/{}", entry.artifact_id), + entry.bytes, + ) + .await?; + } + let paths = [ + data("release-keyring.json"), + env_path, + tmp.join(AGENT), + tmp.join(HELPER), + ] + .map(PathBuf::into_os_string); + let verified = rmm_updater::verify_bootstrap_files(VERIFY, &paths)?; + ensure!( + verified.manifest() == &release.manifest + && verified.manifest().release_sequence > active.release_sequence, + "signed release identity" + ); + let record = Installed { + schema_version: 1, + tenant_id: active.tenant_id, + release_id: id, + release_sequence: verified.manifest().release_sequence, + manifest_sha256: verified.manifest_sha256().into(), + }; + write_new( + &tmp.join("manifest.json"), + &serde_json::to_vec(verified.manifest())?, + )?; + if !generation(id).try_exists()? { + fs::rename(&tmp, generation(id))?; + } + local_manifest(&record)?; + Ok::<_, anyhow::Error>(record) + } + .await; + if tmp.try_exists()? { + fs::remove_dir_all(tmp)?; + } + result +} + +async fn cycle() -> Result<()> { + let active: Installed = read_record(ACTIVE)?; + let config: Endpoint = serde_json::from_slice(&protected(&data("config.json"), 32768)?)?; + // Installed passive pairs only. A separately provisioned SYSTEM helper and + // privileged time/profile pins need the existing coordinated handoff. + ensure!( + !config.enable_jobs, + "job-enabled pair requires coordinated helper handoff" + ); + if data(INTENT).try_exists()? { + let t: Transition = read_record(INTENT)?; + if active.release_id == t.new.release_id { + fs::remove_file(data(INTENT))?; + } else { + ensure!( + active.release_id == t.old.release_id, + "unexpected activation floor" + ); + rollback(&t).await?; + } + } + let device = Device::open(&config)?; + let catalog: Current = device + .json(&format!("/agent/v1/releases/current?platform={TRIPLE}")) + .await?; + let Some(release) = catalog.release else { + ensure!( + catalog.status == "not_configured", + "unexpected release response" + ); + return Ok(()); + }; + let decoded = release + .release_envelope + .decode() + .map_err(|_| anyhow::anyhow!("invalid release envelope"))?; + let candidate = &release.manifest; + ensure!( + catalog.status == "available" + && candidate.platform == VERIFY + && candidate.release_sequence >= active.release_sequence, + "invalid release sequence or platform" + ); + if candidate.release_sequence == active.release_sequence { + ensure!( + candidate.release_id == active.release_id + && hex::encode(Sha256::digest(decoded.payload_bytes)) == active.manifest_sha256, + "conflicting equal release" + ); + return Ok(()); + } + if data("rejected-release.json").try_exists()? { + let rejected: Installed = read_record("rejected-release.json")?; + ensure!( + candidate.release_sequence > rejected.release_sequence, + "previously failed release sequence" + ); + } + let old = local_manifest(&active)?; + let before = device.health().await?; + ensure!( + before.agent_version.as_deref() == Some(&old.version), + "current agent version not confirmed" + ); + let new = stage(&device, &release, &active).await?; + let t = Transition { old: active, new }; + write_record(INTENT, &t)?; + let start = chrono::Utc::now(); + let selected = select(t.old.release_id, t.new.release_id); + if selected.is_ok() { + for _ in 0..18 { + if let Ok(h) = device.health().await + && h.connection_generation > before.connection_generation + && h.agent_version.as_deref() == Some(&candidate.version) + && h.last_contact_at.is_some_and(|v| v >= start) + { + write_record(ACTIVE, &t.new)?; + fs::remove_file(data(INTENT))?; + return Ok(()); + } + tokio::time::sleep(Duration::from_secs(5)).await; + } + } + rollback(&t).await?; + anyhow::bail!("new release did not reconnect; previous release selected") +} + +pub fn dispatch() -> Result<()> { + crate::service::dispatch_named(SERVICE, run) +} +fn run(stop: &'static AtomicBool) -> Result<()> { + let runtime = tokio::runtime::Runtime::new()?; + while !stop.load(Ordering::SeqCst) { + let result = runtime.block_on(cycle()); + write_record( + "release-status.json", + &serde_json::json!({"observed_at": chrono::Utc::now(), + "status": if result.is_ok() { "ok" } else { "error" }, "detail": result.err().map(|e| e.to_string())}), + )?; + for _ in 0..300 { + if stop.load(Ordering::SeqCst) { + break; + } + std::thread::sleep(Duration::from_secs(1)); + } + } + Ok(()) +} diff --git a/crates/agent-windows/src/release_service_switch.ps1 b/crates/agent-windows/src/release_service_switch.ps1 new file mode 100644 index 0000000..aca8772 --- /dev/null +++ b/crates/agent-windows/src/release_service_switch.ps1 @@ -0,0 +1,28 @@ +$ErrorActionPreference = 'Stop' +Set-StrictMode -Version Latest +function Get-Image([string]$Id) { + $image = Join-Path ([Environment]::GetFolderPath('ProgramFiles')) ('RustDiscovery\releases\' + $Id + '\rmm-agent-windows.exe') + return '"' + $image + '" --service --config "' + $configPath + '"' +} +$configPath = Join-Path ([Environment]::GetFolderPath('CommonApplicationData')) 'RustDiscovery\config.json' +$from = Get-Image 'FROM_UUID' +$to = Get-Image 'TO_UUID' +$service = Get-CimInstance -ClassName Win32_Service -Filter "Name='RmmDiscoveryWindows'" +$config = Get-Content -LiteralPath $configPath -Raw | ConvertFrom-Json +if ($config.PSObject.Properties['enable_jobs'] -and $config.enable_jobs) { throw 'Job-enabled agent requires a coordinated handoff.' } +if (-not $service -or $service.StartName -ine 'NT AUTHORITY\LocalService' -or + $service.PathName -cnotin @($from,$to) -or (Get-Service 'RmmDiscoverySystemHelper' -ErrorAction SilentlyContinue)) { throw 'Unexpected service configuration.' } +if ($service.PathName -cne $to) { + $control = Get-Service 'RmmDiscoveryWindows' + if ($control.Status -ne 'Stopped') { + $control.Stop() + $control.WaitForStatus('Stopped', [TimeSpan]::FromSeconds(45)) + } + $res = Invoke-CimMethod -InputObject $service -MethodName Change -Arguments @{PathName=$to} + if ($res.ReturnValue -ne 0) { throw 'SCM path change failed.' } +} +$control = Get-Service 'RmmDiscoveryWindows' +if ($control.Status -ne 'Running') { + $control.Start() + $control.WaitForStatus('Running',[TimeSpan]::FromSeconds(45)) +} diff --git a/crates/agent-windows/src/runtime.rs b/crates/agent-windows/src/runtime.rs index 0a23a3e..22e3c48 100644 --- a/crates/agent-windows/src/runtime.rs +++ b/crates/agent-windows/src/runtime.rs @@ -386,7 +386,26 @@ impl EffectFence { }) } } -type Completion = (JobOffer, ExecutionPermitPayload, Outcome); +enum ExecutorResult { + Outcome(Outcome), + #[cfg(feature = "system-helper")] + UpdatePending(Option), +} +impl From for ExecutorResult { + fn from(value: Outcome) -> Self { + Self::Outcome(value) + } +} +fn interrupted_executor(grant: &ExecutionPermitPayload) -> ExecutorResult { + #[cfg(not(feature="system-helper"))] + let _=grant; + #[cfg(feature = "system-helper")] + if grant.action == "update_agent" { + return ExecutorResult::UpdatePending(None); + } + Outcome::unknown("EXECUTOR_THREAD_INTERRUPTED").into() +} +type Completion = (JobOffer, ExecutionPermitPayload, ExecutorResult); #[cfg(feature = "system-helper")] fn needs_bound_outcome( db: &Connection, @@ -573,6 +592,7 @@ impl HelperControl { } struct Agent { config: Config, + reported_version: String, identity: EnrollmentResponse, ca: Vec, journal: Journal, @@ -591,6 +611,14 @@ struct Agent { prepared: bool, deferred_sync: Option, #[cfg(feature = "system-helper")] + update_pending: bool, + #[cfg(feature="system-helper")] + update_observer:crate::update_observation_runtime::Observer, + #[cfg(feature = "system-helper")] + update_health: Option>>, + #[cfg(feature = "system-helper")] + update_inventory_head: Option<(u64, String)>, + #[cfg(feature = "system-helper")] prepared_request: Option>, #[cfg(feature = "system-helper")] helper_apply_unconfirmed: bool, @@ -617,6 +645,10 @@ struct Agent { running: Option, deferred_permit: Option<(u64, ExecutionPermit)>, readiness_worker: Option>>, + #[cfg(feature = "system-helper")] + update_prefetch: Option<(u64, String, String, tokio::task::JoinHandle>)>, + #[cfg(feature = "system-helper")] + update_cached: Option<(u64, String, String)>, } impl Agent { fn rotation_without_effects(&self) -> Result<()> { @@ -1096,6 +1128,19 @@ impl Agent { let (ledger, result) = task.await?; self.ledger = Some(ledger); let (snapshot, unknowns) = result?; + if Path::new(rmm_agent_windows::helper_runtime::intent::DB).is_file() { + self.update_pending = + rmm_agent_windows::helper_runtime::intent::Store::open(false)? + .pending()? + .iter() + .any(|intent| { + self.binding.as_ref().is_some_and(|binding| { + binding.job(&intent.request.job_bytes).is_ok_and(|job| { + matches!(job.action, Action::UpdateAgent { .. }) + }) + }) + }); + } for bound in unknowns { if needs_bound_outcome(self.journal.connection(), &bound)? { let bytes: Vec = self.journal.connection().query_row( @@ -1232,6 +1277,88 @@ impl Agent { .is_some_and(|sync| sync.can_start(&channel, helper, &self.clock)) }) } + #[cfg(feature = "system-helper")] + async fn poll_update_health(&mut self, generation: u64) -> Result { + if self + .update_health + .as_ref() + .is_some_and(|task| task.is_finished()) + { + let task = self.update_health.take().context("UPDATE_HEALTH_TASK")?; + task.await??; + return Ok(true); + } + if !self.update_pending + || self.update_health.is_some() + || self.prepared + || self.helper_control_pending() + || self.clock.reading().is_err() + { + return Ok(false); + } + let binding = self + .binding + .as_ref() + .context("UPDATE_BINDING_REQUIRED")? + .clone(); + let Some(proof) = rmm_agent_core::update_health_inventory::current_proof( + self.journal.connection(), + &binding, + )? + else { + return Ok(true); + }; + let decoded = proof.decode().map_err(anyhow::Error::msg)?; + let event = decoded + .events + .last() + .map(|raw| serde_json::from_slice::(raw)) + .transpose()?; + if !event.is_some_and(|event| { + matches!( + event.evidence, + rmm_updater_handoff::Evidence::ServicesStarted { .. } + | rmm_updater_handoff::Evidence::RollbackServicesStarted { .. } + ) + }) { + return Ok(true); + } + let inventory_key = (generation, proof.head_sha256.clone()); + if self.update_inventory_head.as_ref() != Some(&inventory_key) + && self.queue_inventory(generation)? + { + self.update_inventory_head = Some(inventory_key); + } + let Some(context) = crate::agent_update_health::context( + self.journal.connection(), + &binding, + &proof, + self.clock.now()?, + )? + else { + return Ok(true); + }; + let handoff = context.handoff().clone(); + let key = context.health_public_key(); + let identity = self.certificates.current( + self.journal.connection(), + &self.key_files, + Utc::now().timestamp(), + )?; + let client = crate::https_channel::mtls_client( + self.config.connect_address, + &self.ca, + &identity.certificate_pem, + &identity.private_key_pem, + )?; + let helper = self.helper.clone().context("UPDATE_HELPER_REQUIRED")?; + let address = self.config.connect_address; + self.update_health = Some(tokio::spawn(async move { + let receipt = crate::agent_update_health::request(&client, address, &context).await?; + helper.submit_update_health(&handoff, key, receipt).await + })); + Ok(false) + } fn supported_job(&self, job: &rmm_domain::jobs::JobPayload) -> bool { if self.config.windows_echo_probe_only && !self @@ -1278,8 +1405,99 @@ impl Agent { rmm_agent_windows::echo_probe::permits_offer(scope, offer, job) }) } + #[cfg(feature = "system-helper")] + async fn prefetch_update( + &mut self, + generation: u64, + offer: &JobOffer, + job: &rmm_domain::jobs::JobPayload, + ) -> Result { + let Action::UpdateAgent { update } = &job.action else { + return Ok(true); + }; + ensure!( + update.validate() + && update.manifest().map_err(anyhow::Error::msg)?.platform + == rmm_agent_windows::release_platform::WIRE, + "UPDATE_PREFETCH_JOB" + ); + let key = (generation, offer.job_id.clone(), offer.attempt_id.clone()); + if self.update_cached.as_ref() == Some(&key) { + return Ok(true); + } + if self.update_prefetch.as_ref().is_some_and(|(g, j, a, _)| { + (*g, j.as_str(), a.as_str()) + != (generation, offer.job_id.as_str(), offer.attempt_id.as_str()) + }) && let Some((_, _, _, task)) = self.update_prefetch.take() { + task.abort(); + } + if self + .update_prefetch + .as_ref() + .is_some_and(|(_, _, _, task)| task.is_finished()) + { + let (_, _, _, task) = self + .update_prefetch + .take() + .context("UPDATE_PREFETCH_TASK")?; + task.await??; + self.update_cached = Some(key); + return Ok(true); + } + if self.update_prefetch.is_none() { + ensure!( + rmm_agent_windows::update_cache::configured(), + "UPDATE_PREFETCH_NOT_PROVISIONED" + ); + let address = self.config.connect_address; + let identity = self.certificates.current( + self.journal.connection(), + &self.key_files, + Utc::now().timestamp(), + )?; + let client = crate::https_channel::mtls_client( + address, + &self.ca, + &identity.certificate_pem, + &identity.private_key_pem, + )?; + let base = format!( + "https://{}:{}", + crate::https_channel::server_name()?, + address.port() + ); + let guard_job = job.clone(); + let clock = self.clock.clone(); + let fence = self.fence.clone(); + let job = job.clone(); + let manifest = update.manifest().map_err(anyhow::Error::msg)?; + let task = tokio::spawn(crate::update_download::prefetch( + client, + base, + job, + manifest, + move || { + ensure!( + fence.allows_identity(generation, true, &clock) + && clock.now()? < guard_job.start_before, + "UPDATE_PREFETCH_FENCED" + ); + Ok(()) + }, + )); + self.update_prefetch = Some(( + generation, + offer.job_id.clone(), + offer.attempt_id.clone(), + task, + )); + } + Ok(false) + } fn capabilities(&self) -> Vec { let mut caps: Vec = CAPABILITIES.iter().map(|c| c.to_string()).collect(); + #[cfg(target_env = "gnu")] + caps.push("agent.release.windows.gnu/1".into()); // queue_update_observation emits the passive update status in every profile. caps.push("agent.update/1".into()); if self.config.windows_echo_probe_only { @@ -1307,6 +1525,10 @@ impl Agent { && let Some(helper) = &self.helper { caps.extend(helper.qualified_capabilities()); + if helper.update_observer_configured() + && self.update_observer.cached().is_some_and(|r|r.observation.predecessor.as_ref().is_some_and(|p|p.helper_sha256==helper.helper_binary_hash())) { + for cap in self.update_observer.capabilities(){if !caps.contains(&cap){caps.push(cap);}} + } } } caps @@ -1338,6 +1560,13 @@ impl Agent { let pending = intents.pending()?; if let Some(intent) = pending.first() { let p = intent.permit()?; + if matches!( + binding.job(&intent.request.job_bytes)?.action, + Action::UpdateAgent { .. } + ) { + self.update_pending = true; + return Ok(()); + } let incompatible:bool=self.journal.connection().query_row("SELECT EXISTS(SELECT 1 FROM job_attempts WHERE state IN ('requesting','running','verifying','unknown','awaiting_reboot') AND NOT(job=?1 AND attempt=?2))",rusqlite::params![p.job_id.to_string(),p.attempt_id.to_string()],|r|r.get(0))?; ensure!(!incompatible, "SYSTEM_PENDING_INTENT_CONFLICT"); binding.verify_historical_for_denial_with( @@ -1496,37 +1725,13 @@ impl Agent { helper: Option<&reconcile::HelperSnapshot>, ) -> Result<()> { let context = self.channel(generation)?; - let closed_control_idle = { - #[cfg(feature = "system-helper")] - { - self.running.is_none() - && !self.prepared - && self.deferred_sync.is_none() - && self.deferred_permit.is_none() - && self.helper_control.is_none() - && self.helper_probe.is_none() - && helper.is_some() - && (if Path::new(rmm_agent_windows::helper_runtime::intent::DB).exists() { - rmm_agent_windows::helper_runtime::intent::Store::open(false) - .and_then(|store| store.pending()) - .is_ok_and(|pending| pending.is_empty()) - } else { - helper.is_some_and(|snapshot| snapshot.attempts.is_empty()) - }) - } - #[cfg(not(feature = "system-helper"))] - { - false - } - }; let sync = self.sync.as_mut().context("SYNC_NOT_CONFIGURED")?; - let prepared = sync.prepare_with_closed_control_idle( + let prepared = sync.prepare( self.journal.connection_mut(), self.ledger.as_ref().context("LEDGER_REQUIRED")?, context, helper, &self.clock, - closed_control_idle, ); #[cfg(feature = "system-helper")] if helper.is_some() @@ -1708,7 +1913,7 @@ impl Agent { } Ok(()) } - fn completed(&mut self, generation: u64, (offer, grant, outcome): Completion) -> Result<()> { + fn completed(&mut self, generation: u64, (offer, grant, result): Completion) -> Result<()> { let running = self .running .as_ref() @@ -1719,6 +1924,48 @@ impl Agent { && running.grant == grant, "EXECUTOR_COMPLETION_BINDING" ); + #[cfg(feature = "system-helper")] + if let ExecutorResult::UpdatePending(accepted) = result { + ensure!( + grant.execution_identity == "system" && grant.action == "update_agent", + "UPDATE_COMPLETION_SCOPE" + ); + if let Some(accepted) = accepted { + let intent = rmm_agent_windows::helper_runtime::intent::Store::open(false)? + .by_grant(grant.grant_id)?; + accepted.matches(&intent.request, grant.grant_id)?; + let mut envelope = self.envelope( + generation, + Payload::JobStateChanged(JobStateChanged::default()), + )?; + let tx = self.journal.connection_mut().transaction()?; + let revision = + jobs::transition(&tx, &offer, "running", &grant.grant_id.to_string())?; + envelope.payload = Some(Payload::JobStateChanged(JobStateChanged { + job_id: offer.job_id.clone(), + attempt_id: offer.attempt_id.clone(), + revision, + state: "running".into(), + grant_id: grant.grant_id.to_string(), + })); + jobs::event(&tx, &envelope)?; + tx.commit()?; + } + // Neither a typed handoff ACK nor its loss is an Outcome. Import + // only actual original helper evidence in the next normal Sync. + self.update_pending = true; + self.running = None; + self.close_gate(); + return Ok(()); + } + #[cfg(not(feature="system-helper"))] + let ExecutorResult::Outcome(outcome)=result; + #[cfg(feature="system-helper")] + let outcome = match result { + ExecutorResult::Outcome(outcome) => outcome, + #[cfg(feature = "system-helper")] + ExecutorResult::UpdatePending(_) => unreachable!("handled update completion"), + }; if grant.execution_identity == "system" { // No local consumption or definitive result from an IPC outcome. // Import only a fresh raw helper snapshot before the next Sync. @@ -1845,6 +2092,10 @@ impl Agent { let completed = self.completed_tx.clone(); let work_offer = offer.clone(); let work_grant = grant.clone(); + let is_update = matches!(job.action, Action::UpdateAgent { .. }); + if is_update { + self.update_pending = true; + } let msi = job.action.windows_msi().cloned(); let address = self.config.connect_address; let ca = self.ca.clone(); @@ -1912,7 +2163,7 @@ impl Agent { } else { true }; - let _result = helper + let result = helper .delegate(intent, move || { ensure!(staged, "MSI_DOWNLOAD_NOT_READY"); ensure!( @@ -1931,7 +2182,11 @@ impl Agent { .send(( work_offer, work_grant, - Outcome::unknown("SYSTEM_DELEGATION_REQUIRES_HELPER_SNAPSHOT"), + if is_update { + ExecutorResult::UpdatePending(result.ok().flatten()) + } else { + Outcome::unknown("SYSTEM_DELEGATION_REQUIRES_HELPER_SNAPSHOT").into() + }, )) .await; }); @@ -2054,7 +2309,7 @@ impl Agent { outcome.error_code = "WINDOWS_FINAL_CLOCK_UNTRUSTED".into(); outcome.evidence["postconditions_passed"] = false.into(); } - let _ = completed.blocking_send((work_offer, work_grant, outcome)); + let _ = completed.blocking_send((work_offer, work_grant, outcome.into())); }); self.running = Some(Running { offer, @@ -2078,9 +2333,9 @@ impl Agent { payload: Some(payload), }) } - fn queue_inventory(&mut self, generation: u64) -> Result<()> { + fn queue_inventory(&mut self, generation: u64) -> Result { if self.journal.count()? > 0 || !jobs::events(self.journal.connection())?.is_empty() { - return Ok(()); + return Ok(false); } let data = serde_json::to_vec(&native::snapshot()?)?; ensure!(data.len() <= 32768, "WINDOWS_INVENTORY_LIMIT"); @@ -2097,22 +2352,36 @@ impl Agent { completeness: "partial".into(), }), )?; - if self.binding.is_some() { - jobs::event(self.journal.connection(), &envelope) + if let Some(binding) = &self.binding { + jobs::event(self.journal.connection(), &envelope)?; + let initialized:bool=self.journal.connection().query_row("SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE type='table' AND name='reconcile_meta')",[],|r|r.get(0))?; + if initialized + && self.journal.connection().query_row( + "SELECT generation FROM reconcile_meta WHERE id=1", + [], + |r| r.get::<_, u64>(0), + )? == generation + { + rmm_agent_core::update_health_inventory::retain_current( + self.journal.connection(), + &envelope, + binding, + )?; + } } else { - self.journal.save(&envelope) + self.journal.save(&envelope)?; } + Ok(true) } fn queue_update_observation(&mut self, generation: u64) -> Result<()> { if self.journal.count()? > 0 || !jobs::events(self.journal.connection())?.is_empty() { return Ok(()); } - // Schema support is passive only; no qualified updater/helper observer - // is configured by this source checkpoint, so apply remains closed. + #[cfg(feature="system-helper")] + let observation=self.update_observer.observation(generation); + #[cfg(not(feature="system-helper"))] let observation = rmm_domain::agent_update::AgentUpdateObservation::not_configured( - rmm_domain::agent_update::Platform::WindowsX64, - Utc::now(), - ); + rmm_agent_windows::release_platform::WIRE,Utc::now()); let data = serde_json::to_vec(&serde_json::json!({"agent_update":observation}))?; let envelope = self.envelope( generation, @@ -2190,7 +2459,7 @@ impl Agent { let hello = self.envelope( 0, Payload::ClientHello(ClientHello { - agent_version: env!("CARGO_PKG_VERSION").into(), + agent_version: self.reported_version.clone(), capabilities: advertised.clone(), }), )?; @@ -2254,6 +2523,8 @@ impl Agent { let mut tick = tokio::time::interval(Duration::from_millis(20)); tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip); let mut readiness_at = Instant::now() - Duration::from_secs(5); + #[cfg(feature = "system-helper")] + let mut update_control_at = Instant::now() - Duration::from_secs(2); while !stop.load(Ordering::SeqCst) || self.running.is_some() { if stop.load(Ordering::SeqCst) { self.close_gate(); @@ -2272,10 +2543,23 @@ impl Agent { } if self.running.as_ref().is_some_and(|r|r.worker.is_finished()) { if let Ok(completion)=self.completed_rx.try_recv(){self.completed(generation,completion)?;} - else {let running=self.running.as_ref().context("RUNNING_REQUIRED")?;self.completed(generation,(running.offer.clone(),running.grant.clone(),Outcome::unknown("EXECUTOR_THREAD_INTERRUPTED")))?;} + else {let running=self.running.as_ref().context("RUNNING_REQUIRED")?;self.completed(generation,(running.offer.clone(),running.grant.clone(),interrupted_executor(&running.grant)))?;} needs_sync=true; } + #[cfg(feature="system-helper")] + if !stop.load(Ordering::SeqCst) && update_control_at.elapsed()>=Duration::from_secs(2) { + update_control_at=Instant::now(); + if !self.update_pending && !self.prepared && !self.helper_control_pending() && self.running.is_none() && self.ready(generation) { + let transport=(||->Result<_>{let helper=self.helper.clone().filter(|h|h.update_observer_configured()).context("UPDATE_OBSERVER_NOT_CONFIGURED")?; + let identity=self.certificates.current(self.journal.connection(),&self.key_files,Utc::now().timestamp())?; + Ok((crate::https_channel::mtls_client(self.config.connect_address,&self.ca,&identity.certificate_pem,&identity.private_key_pem)?,self.config.connect_address,helper))})(); + self.update_observer.poll(generation,||transport).await; + } + match self.poll_update_health(generation).await {Ok(refresh)=>{needs_sync|=refresh;},Err(_)=>{self.close_gate();needs_sync=true;}} + } let busy=self.running.is_some() || self.journal.connection().query_row("SELECT EXISTS(SELECT 1 FROM job_attempts WHERE state IN ('requesting','running','verifying'))",[],|r|r.get::<_,bool>(0))?; + #[cfg(feature="system-helper")] + let busy=(busy && !(self.update_pending && self.running.is_none())) || self.update_health.is_some(); if !stop.load(Ordering::SeqCst) && !busy { if capabilities_at.elapsed()>=Duration::from_secs(60) {capabilities_at=Instant::now();if advertised!=self.capabilities(){return Ok(());}} if self.prepared && self.deferred_sync.is_none() && sync_at.elapsed()>=Duration::from_secs(20){self.close_gate();needs_sync=true;} @@ -2289,9 +2573,15 @@ impl Agent { ensure!(self.scope_permits(&offer,&job),"WINDOWS_ECHO_OFFER_OUT_OF_SCOPE"); if now>=job.start_before {self.record(generation,&offer,"",jobs::no_start("expired","START_DEADLINE_EXPIRED"))?;needs_sync=true;} else if now-chrono::Duration::seconds(2)>=job.not_before && self.ready_identity(generation,job.execution_identity=="system") { - jobs::reserve_request(self.journal.connection(),&offer)?; - let request=self.envelope(generation,Payload::ExecutionPermitRequest(ExecutionPermitRequest{job_id:offer.job_id,attempt_id:offer.attempt_id,job_payload_hash:offer.job_payload_hash,assignment_version:job.assignment_version}))?; - channel.send(&request).await?; + #[cfg(feature="system-helper")] + let prefetched=self.prefetch_update(generation,&offer,&job).await?; + #[cfg(not(feature="system-helper"))] + let prefetched=true; + if prefetched { + jobs::reserve_request(self.journal.connection(),&offer)?; + let request=self.envelope(generation,Payload::ExecutionPermitRequest(ExecutionPermitRequest{job_id:offer.job_id,attempt_id:offer.attempt_id,job_payload_hash:offer.job_payload_hash,assignment_version:job.assignment_version}))?; + channel.send(&request).await?; + } } } } @@ -2484,6 +2774,29 @@ impl Agent { ) } } +fn installed_version() -> Result { + let executable = std::env::current_exe()?; + let directory = executable.parent().context("AGENT_IMAGE_DIRECTORY")?; + let path = directory.join("manifest.json"); + if !path.try_exists()? { + return Ok(env!("CARGO_PKG_VERSION").into()); + } + rmm_agent_windows::job_binding::check_admin_readonly(&path)?; + let manifest: rmm_updater::ReleaseManifest = + serde_json::from_slice(&protected_read(&path, rmm_updater::MAX_MANIFEST_BYTES)?)?; + let expected = &manifest.artifacts[0]; + let mut digest = Sha256::new(); + let bytes = std::io::copy(&mut fs::File::open(executable)?, &mut digest)?; + ensure!( + manifest.platform == rmm_agent_windows::release_platform::VERIFY + && expected.role == rmm_updater::ArtifactRole::Agent + && expected.bytes == bytes + && expected.sha256 == hex::encode(digest.finalize()), + "INSTALLED_AGENT_IMAGE_MISMATCH" + ); + Ok(manifest.version) +} + fn service_run(stop: &'static AtomicBool) -> Result<()> { let arguments: Vec = std::env::args().skip(1).collect(); ensure!( @@ -2550,6 +2863,7 @@ fn service_run(stop: &'static AtomicBool) -> Result<()> { let (completed_tx,completed_rx)=tokio::sync::mpsc::channel(1); let mut agent = Agent { config, + reported_version: installed_version()?, identity, ca, journal, @@ -2580,7 +2894,20 @@ fn service_run(stop: &'static AtomicBool) -> Result<()> { helper_checked:false, #[cfg(feature="system-helper")] helper_refused:false, - prepared:false,deferred_sync:None,fence:Arc::new(EffectFence::default()),completed_tx,completed_rx,running:None,deferred_permit:None,readiness_worker:None, + prepared:false,deferred_sync:None, + #[cfg(feature="system-helper")] + update_pending:false, + #[cfg(feature="system-helper")] + update_observer:crate::update_observation_runtime::Observer::default(), + #[cfg(feature="system-helper")] + update_health:None, + #[cfg(feature="system-helper")] + update_inventory_head:None, + fence:Arc::new(EffectFence::default()),completed_tx,completed_rx,running:None,deferred_permit:None,readiness_worker:None, + #[cfg(feature="system-helper")] + update_prefetch:None, + #[cfg(feature="system-helper")] + update_cached:None, }; agent.recover_interrupted()?; let mut backoff = 1; @@ -2591,7 +2918,7 @@ fn service_run(stop: &'static AtomicBool) -> Result<()> { if let Ok(completion)=agent.completed_rx.try_recv(){agent.completed(0,completion)?;} if agent.running.as_ref().is_some_and(|r|r.worker.is_finished()) { let running=agent.running.as_ref().context("RUNNING_REQUIRED")?; - agent.completed(0,(running.offer.clone(),running.grant.clone(),Outcome::unknown("EXECUTOR_THREAD_INTERRUPTED")))?; + agent.completed(0,(running.offer.clone(),running.grant.clone(),interrupted_executor(&running.grant)))?; } if agent.running.is_some() {tokio::select!{Some(completion)=agent.completed_rx.recv()=>agent.completed(0,completion)?,_=tokio::time::sleep(Duration::from_millis(250))=>{}}} continue; @@ -2613,7 +2940,7 @@ fn service_run(stop: &'static AtomicBool) -> Result<()> { if let Ok(completion)=agent.completed_rx.try_recv(){agent.completed(0,completion)?;} if agent.running.as_ref().is_some_and(|r|r.worker.is_finished()) { let running=agent.running.as_ref().context("RUNNING_REQUIRED")?; - agent.completed(0,(running.offer.clone(),running.grant.clone(),Outcome::unknown("EXECUTOR_THREAD_INTERRUPTED")))?; + agent.completed(0,(running.offer.clone(),running.grant.clone(),interrupted_executor(&running.grant)))?; } tokio::time::sleep(Duration::from_millis(250)).await; } diff --git a/crates/agent-windows/src/service.rs b/crates/agent-windows/src/service.rs index 64b485c..7613b67 100644 --- a/crates/agent-windows/src/service.rs +++ b/crates/agent-windows/src/service.rs @@ -12,6 +12,7 @@ static STOP: AtomicBool = AtomicBool::new(false); static HANDLE: AtomicUsize = AtomicUsize::new(0); type Runner = fn(&'static AtomicBool) -> Result<()>; static RUN: OnceLock = OnceLock::new(); +static NAME: OnceLock<&'static str> = OnceLock::new(); fn status(state: u32, exit: u32) { let handle = HANDLE.load(Ordering::SeqCst) as SERVICE_STATUS_HANDLE; if handle.is_null() { @@ -51,7 +52,7 @@ unsafe extern "system" fn control( 0 } unsafe extern "system" fn service_main(_count: u32, _args: *mut *mut u16) { - let name = crate::native::wide(crate::SERVICE_NAME); + let name = crate::native::wide(NAME.get().copied().unwrap_or(crate::SERVICE_NAME)); let handle = unsafe { RegisterServiceCtrlHandlerExW(name.as_ptr(), Some(control), ptr::null_mut()) }; if handle.is_null() { @@ -64,8 +65,12 @@ unsafe extern "system" fn service_main(_count: u32, _args: *mut *mut u16) { status(SERVICE_STOPPED, if result.is_ok() { 0 } else { 1066 }); } pub fn dispatch(run: Runner) -> Result<()> { + dispatch_named(crate::SERVICE_NAME, run) +} +pub fn dispatch_named(name: &'static str, run: Runner) -> Result<()> { + ensure!(NAME.set(name).is_ok(), "SCM_ALREADY_INITIALIZED"); ensure!(RUN.set(run).is_ok(), "SCM_ALREADY_INITIALIZED"); - let mut name = crate::native::wide(crate::SERVICE_NAME); + let mut name = crate::native::wide(name); let table = [ SERVICE_TABLE_ENTRYW { lpServiceName: name.as_mut_ptr(), diff --git a/crates/agent-windows/src/signed_clock.rs b/crates/agent-windows/src/signed_clock.rs index 63f390c..ba6396c 100644 --- a/crates/agent-windows/src/signed_clock.rs +++ b/crates/agent-windows/src/signed_clock.rs @@ -113,6 +113,65 @@ pub struct RoleQualification { pub binary_sha256: String, pub qualification_sha256: String, } +/// Separately protected stable-updater clock profile. It never loads a helper +/// calibration/qualification as its own image or process evidence. +#[derive(Debug, serde::Deserialize, serde::Serialize)] +#[serde(deny_unknown_fields)] +pub struct UpdaterConfiguration { + pub schema_version: u32, + pub key_generation: u64, + pub server_instance: Uuid, + pub binding: rmm_agent_core::auth::Binding, + pub public_keys_hex: std::collections::BTreeMap, + pub updater_policy_sha256: String, + pub updater_service_configuration_sha256: String, + pub trusted_os_active_guest: TrustedOsActiveGuest, +} +impl UpdaterConfiguration { + #[cfg(any(windows, test))] + fn validate(&self, image: &str) -> Result<()> { + let profile = &self.trusted_os_active_guest; + ensure!( + self.schema_version == 3 + && self.key_generation > 0 + && !self.server_instance.is_nil() + && !self.binding.agent_id.is_nil() + && !self.binding.asset_id.is_nil() + && !self.binding.tenant_id.is_nil() + && self.binding.enrollment_generation > 0 + && self.binding.assignment_version > 0 + && digest(&self.updater_policy_sha256) + && digest(&self.updater_service_configuration_sha256) + && matches!( + profile.operating_assumption, + ActiveGuestOperation::NoPauseSaveRestoreSnapshotMigrationHostSuspend + ) + && matches!(profile.platform, TrustedPlatform::KvmQemuHypervClock) + && digest(&profile.platform_provenance_sha256) + && profile.qualifications.len() == 1 + && profile.qualifications[0].role == rmm_time_attestation::Role::Updater + && profile.qualifications[0].binary_sha256 == image + && digest(&profile.qualifications[0].qualification_sha256), + "TIME_UPDATER_OWN_PROFILE" + ); + ensure!( + !self.public_keys_hex.is_empty() && self.public_keys_hex.len() <= 8, + "TIME_UPDATER_KEYS" + ); + for (id, public) in &self.public_keys_hex { + ensure!( + !id.is_empty() + && id.len() <= 64 + && id + .bytes() + .all(|b| b.is_ascii_alphanumeric() || b"_-".contains(&b)), + "TIME_UPDATER_KEY_ID" + ); + independent_time_key(public, &self.binding.public_key_hex)?; + } + Ok(()) + } +} #[derive(Clone, Copy, Debug, PartialEq, Eq)] enum CaptureMode { Physical { base_error_ns: u64 }, @@ -159,6 +218,10 @@ impl Configuration { helper_image: &str, ) -> Result { use rmm_time_attestation::Role; + ensure!( + own_role != Role::Updater, + "TIME_UPDATER_OWN_PROFILE_REQUIRED" + ); ensure!(self.key_generation() > 0, "TIME_NATIVE_CONFIG_PROFILE"); let images = [ (Role::Agent, agent_image), @@ -663,6 +726,8 @@ mod installed { }; pub const CONFIG_PATH: &str = r"C:\ProgramData\RustDiscoverySystem\time-attestation.json"; + pub const UPDATER_CONFIG_PATH: &str = + r"C:\ProgramData\RustDiscoveryUpdater\time-attestation.json"; const PUBLIC_ROOT: &str = r"C:\ProgramData\RustDiscoverySystem"; const MAX_CONFIG_BYTES: usize = 16_384; const MAX_REPLY_BYTES: usize = 16_384; @@ -728,12 +793,16 @@ mod installed { capture_mode: CaptureMode, pending: Option, latest: Option, + own_updater_configuration: Option<(ipc::PeerPin, String)>, } impl SignedClock { /// Connection generation is later confirmed by the independently /// signed server response. It is never itself a ready/sync flag. pub async fn open(role: Role, connection_generation: u64) -> Result { ensure!(connection_generation > 0, "TIME_NATIVE_CONNECTION"); + if role == Role::Updater { + return Self::open_updater(connection_generation).await; + } let mut failure_fence = ConstructorFailureFence { armed: true }; let (settings, mut files) = crate::helper_system::read_settings()?; let own_pin = match role { @@ -830,6 +899,127 @@ mod installed { capture_mode, pending: None, latest: None, + own_updater_configuration: None, + }; + value.recheck()?; + process() + .lock() + .map_err(|_| anyhow::anyhow!("TIME_NATIVE_STATE_POISONED"))? + .accept_connection(connection_generation)?; + observed(boot_id, capture_mode)?; + failure_fence.armed = false; + Ok(value) + } + /// Stable-updater-only process proof and separately protected profile. + /// It uses its OWN current SCM process/image/token and challenge. + pub async fn open_updater(connection_generation: u64) -> Result { + ensure!(connection_generation > 0, "TIME_NATIVE_CONNECTION"); + let mut failure_fence = ConstructorFailureFence { armed: true }; + let readers = vec![ + ipc::service_sid(crate::update_ipc::SERVICE)?, + ipc::service_sid(crate::SERVICE_NAME)?, + ipc::service_sid(ipc::HELPER_SERVICE)?, + ]; + let root = PinnedFile::open_read_shared( + Path::new(r"C:\ProgramData\RustDiscoveryUpdater"), + true, + &readers, + &[], + )?; + let mut policy_file = PinnedFile::open( + Path::new(r"C:\ProgramData\RustDiscoveryUpdater\policy.json"), + false, + &readers, + &[], + false, + )?; + ensure!( + policy_file.file.metadata()?.len() <= 65536, + "TIME_UPDATER_POLICY_SIZE" + ); + let mut policy_raw = Vec::new(); + (&mut policy_file.file) + .take(65537) + .read_to_end(&mut policy_raw)?; + let (policy, policy_hash) = + rmm_domain::agent_update_provisioning::LocalUpdatePolicy::from_bytes(&policy_raw) + .map_err(anyhow::Error::msg)?; + let own_pin = crate::update_native::services::updater_pin(&policy)?; + ipc::require_self(&own_pin)?; + let own_process = PeerProof::for_service(&own_pin, unsafe { + windows_sys::Win32::System::Threading::GetCurrentProcessId() + })?; + let service_hash = + crate::update_native::services::updater_configuration_sha256(&own_pin)?; + ensure!( + service_hash == policy.updater_service.unit_sha256, + "TIME_UPDATER_SCM_POLICY" + ); + let mut config_file = + PinnedFile::open(Path::new(UPDATER_CONFIG_PATH), false, &readers, &[], false)?; + ensure!( + config_file.file.metadata()?.len() <= MAX_CONFIG_BYTES as u64, + "TIME_NATIVE_CONFIG_SIZE" + ); + let mut raw = Vec::new(); + (&mut config_file.file) + .take(MAX_CONFIG_BYTES as u64 + 1) + .read_to_end(&mut raw)?; + ensure!(raw.len() <= MAX_CONFIG_BYTES, "TIME_NATIVE_CONFIG_SIZE"); + let config: UpdaterConfiguration = serde_json::from_slice(&raw)?; + config.validate(&own_pin.binary_sha256)?; + ensure!( + config.updater_policy_sha256 == policy_hash + && config.updater_service_configuration_sha256 == service_hash + && config.binding.tenant_id == policy.tenant_id + && config.binding.asset_id == policy.asset_id + && config.binding.agent_id == policy.agent_id + && config.binding.enrollment_generation == policy.enrollment_generation + && config.binding.assignment_version == policy.assignment_version, + "TIME_UPDATER_POLICY_BINDING" + ); + let keys = config + .public_keys_hex + .iter() + .map(|(id, key)| { + Ok(( + id.clone(), + independent_time_key(key, &config.binding.public_key_hex)?, + )) + }) + .collect::>>()?; + let pins = Pins::new(config.key_generation, config.server_instance, keys)?; + process() + .lock() + .map_err(|_| anyhow::anyhow!("TIME_NATIVE_STATE_POISONED"))? + .accept_configuration(config.key_generation, &hash(&raw))?; + let boot_id = Uuid::parse_str(&crate::native::boot_id().await?)?; + let context = Context { + tenant_id: config.binding.tenant_id, + asset_id: config.binding.asset_id, + agent_id: config.binding.agent_id, + enrollment_generation: config.binding.enrollment_generation, + assignment_generation: config.binding.assignment_version, + connection_generation, + windows_boot_id: boot_id, + verifier_incarnation: *INCARNATION.get_or_init(Uuid::new_v4), + role: Role::Updater, + helper_image_sha256: None, + binding_schema: 2, + updater_image_sha256: Some(own_pin.binary_sha256.clone()), + }; + let capture_mode = CaptureMode::TrustedOsActiveGuest; + let mut value = Self { + verifier: Verifier::new(context, pins)?, + own_process, + files: vec![root, policy_file, config_file], + config_sha256: hash(&raw), + boot_id, + connection_generation, + capture_mode, + pending: None, + latest: None, + own_updater_configuration: Some((own_pin, service_hash)), }; value.recheck()?; process() @@ -843,6 +1033,13 @@ mod installed { fn recheck(&mut self) -> Result<()> { let result = (|| { self.own_process.check()?; + if let Some((pin, expected)) = &self.own_updater_configuration { + ensure!( + crate::update_native::services::updater_configuration_sha256(pin)? + == *expected, + "TIME_UPDATER_SCM_CHANGED" + ); + } for file in &mut self.files { file.check()?; } @@ -1127,6 +1324,22 @@ mod installed { fn now(&self) -> Result> { Ok(self.reading()?.own_wall) } + fn bounds(&self) -> Result<(chrono::DateTime, chrono::DateTime)> { + ensure!(self.generation > 0, "TIME_RUNTIME_NO_CONNECTION"); + let mut state = self + .source + .state + .lock() + .map_err(|_| anyhow::anyhow!("TIME_RUNTIME_POISONED"))?; + let (held, clock) = state.as_mut().context("TIME_RUNTIME_NO_EVIDENCE")?; + ensure!(*held == self.generation, "TIME_RUNTIME_CONNECTION_CHANGED"); + clock.with_current_comparison(|value| { + Ok(( + chrono::DateTime::from_timestamp_nanos(value.interval().lower_utc_ns()), + chrono::DateTime::from_timestamp_nanos(value.interval().upper_utc_ns()), + )) + }) + } fn reading(&self) -> Result { ensure!(self.generation > 0, "TIME_RUNTIME_NO_CONNECTION"); let mut state = self @@ -1163,12 +1376,60 @@ mod installed { } } #[cfg(all(windows, feature = "system-helper"))] -pub use installed::{BoundClock, CONFIG_PATH, Comparison, RuntimeClock, SignedClock}; +pub use installed::{ + BoundClock, CONFIG_PATH, Comparison, RuntimeClock, SignedClock, UPDATER_CONFIG_PATH, +}; #[cfg(test)] mod tests { use super::*; + #[test] + fn updater_profile_binds_only_its_own_image_and_explicit_active_guest_assumption() { + use serde_json::json; + let job = ed25519_dalek::SigningKey::from_bytes(&[71; 32]) + .verifying_key() + .to_bytes(); + let time = ed25519_dalek::SigningKey::from_bytes(&[72; 32]) + .verifying_key() + .to_bytes(); + let hex = |raw: [u8; 32]| raw.iter().map(|b| format!("{b:02x}")).collect::(); + let value = json!({"schema_version":3,"key_generation":1,"server_instance":Uuid::new_v4(), + "binding":{"tenant_id":Uuid::new_v4(),"asset_id":Uuid::new_v4(),"agent_id":Uuid::new_v4(),"enrollment_generation":1,"assignment_version":1,"public_key_hex":hex(job)}, + "public_keys_hex":{"updater-time":hex(time)},"updater_policy_sha256":"12".repeat(32),"updater_service_configuration_sha256":"13".repeat(32), + "trusted_os_active_guest":{"operating_assumption":"active_guest_no_pause_save_restore_snapshot_migration_host_suspend","platform":"kvm_qemu_hypervclock","platform_provenance_sha256":"14".repeat(32), + "qualifications":[{"role":"updater","binary_sha256":"15".repeat(32),"qualification_sha256":"16".repeat(32)}]}}); + let config: UpdaterConfiguration = serde_json::from_value(value.clone()).unwrap(); + config.validate(&"15".repeat(32)).unwrap(); + assert!(config.validate(&"17".repeat(32)).is_err()); + for mutation in ["helper", "second", "policy", "assumption"] { + let mut bad = value.clone(); + match mutation { + "helper" => { + bad["trusted_os_active_guest"]["qualifications"][0]["role"] = + json!("system_helper") + } + "second" => { + let q = bad["trusted_os_active_guest"]["qualifications"][0].clone(); + bad["trusted_os_active_guest"]["qualifications"] + .as_array_mut() + .unwrap() + .push(q); + } + "policy" => bad["updater_policy_sha256"] = json!("bad"), + _ => bad["trusted_os_active_guest"]["operating_assumption"] = json!(true), + } + let result = serde_json::from_value::(bad); + assert!( + match result { + Err(_) => true, + Ok(c) => c.validate(&"15".repeat(32)).is_err(), + }, + "mutation {mutation}" + ); + } + } + #[test] fn passive_sampling_requires_a_profile_and_uses_heartbeat_cadence() { let dir = std::env::temp_dir().join(Uuid::new_v4().to_string()); diff --git a/crates/agent-windows/src/system_capabilities.rs b/crates/agent-windows/src/system_capabilities.rs index 4bf5c1e..b3911e0 100644 --- a/crates/agent-windows/src/system_capabilities.rs +++ b/crates/agent-windows/src/system_capabilities.rs @@ -6,7 +6,11 @@ use crate::{ }; use anyhow::{Result, ensure}; use serde::Deserialize; -use std::{collections::BTreeSet, io::Read, path::Path}; +use std::{ + collections::BTreeSet, + io::Read, + path::{Path, PathBuf}, +}; use uuid::Uuid; pub const PATH: &str = r"C:\ProgramData\RustDiscoverySystem\system-qualification.json"; @@ -27,65 +31,31 @@ struct Qualification { qualification_reference: Uuid, actions: Vec, } -pub fn qualified(pin: &Pin, clock_qualified: bool) -> Result> { - if !clock_qualified || !Path::new(PATH).try_exists()? { +pub fn qualified( + pin: &Pin, + clock_qualified: bool, + reboot_privilege_available: Option, +) -> Result> { + if !clock_qualified { return Ok(vec![]); } - let readers = [ - ipc::service_sid(crate::SERVICE_NAME)?, - ipc::service_sid(ipc::HELPER_SERVICE)?, - ]; - let root = Path::new(PATH) - .parent() - .expect("fixed qualification parent"); - let mut dir = PinnedFile::open_read_shared(root, true, &readers, &[])?; - let mut file = PinnedFile::open(Path::new(PATH), false, &readers, &[], false)?; - let mut bytes = vec![]; - (&mut file.file).take(16385).read_to_end(&mut bytes)?; - ensure!(bytes.len() <= 16384, "system qualification size"); - file.check()?; - dir.check()?; - let q: Qualification = serde_json::from_slice(&bytes)?; - ensure!( - q.schema_version == 1 - && ( - q.tenant_id, - q.asset_id, - q.agent_id, - q.enrollment_generation, - q.assignment_version - ) == ( - pin.binding.tenant_id, - pin.binding.asset_id, - pin.binding.agent_id, - pin.binding.enrollment_generation, - pin.binding.assignment_version - ) - && q.agent_binary_sha256 == pin.agent.binary_sha256 - && q.helper_binary_sha256 == pin.helper.binary_sha256 - && q.policy_sha256 == pin.policy_sha256 - && ipc::digest(&q.native_result_sha256) - && !q.qualification_reference.is_nil() - && !q.actions.is_empty() - && q.actions.len() <= 3 - && q.actions.iter().collect::>().len() == q.actions.len() - && q.actions.iter().all(|a| matches!( - a.as_str(), - "run_script" | "set_service_state" | "ensure_package" - )), - "system qualification binding" - ); - let mut result = PinnedFile::open(Path::new(RESULT_PATH), false, &readers, &[], false)?; - let mut result_bytes = vec![]; - (&mut result.file) - .take(65537) - .read_to_end(&mut result_bytes)?; - ensure!( - result_bytes.len() <= 65536 - && rmm_domain::jobs::hash(&result_bytes) == q.native_result_sha256, - "system native qualification evidence hash" - ); - result.check()?; + pin.validate()?; + let ordinary = load_ordinary(pin); + let (q, result_bytes) = match ordinary { + Ok(sources) => sources, + Err(error) => match load_catalog(pin) { + Ok(sources) => sources, + Err(catalog_error) => { + if !Path::new(PATH).try_exists()? && !catalog_directory(pin)?.try_exists()? { + return Ok(vec![]); + } + if catalog_directory(pin)?.try_exists()? { + return Err(catalog_error); + } + return Err(error); + } + }, + }; let evidence: serde_json::Value = serde_json::from_slice(&result_bytes)?; ensure!( evidence["schema_version"] == 1 @@ -111,7 +81,7 @@ pub fn qualified(pin: &Pin, clock_qualified: bool) -> Result> { match action.as_str() { "run_script" => { ensure!( - settings.schema_version == 3 + settings.schema_version >= 3 && settings.allowed_script_profiles.as_deref() == Some(&[ rmm_domain::jobs::PrivilegedScriptProfile::FullMaintenanceV1 @@ -147,8 +117,247 @@ pub fn qualified(pin: &Pin, clock_qualified: bool) -> Result> { .map(str::to_string), ); } + "reboot" => { + ensure!( + settings.schema_version == 4 + && settings.allow_reboot + && reboot_privilege_available == Some(true), + "system reboot qualification policy or live token" + ); + caps.extend( + [ + "reboot", + "system:reboot", + rmm_domain::windows_reboot::CAPABILITY, + ] + .map(str::to_string), + ); + } _ => unreachable!("validated qualification action"), } } Ok(caps) } +fn read(path: &Path, max: u64) -> Result> { + let readers = [ + ipc::service_sid(crate::SERVICE_NAME)?, + ipc::service_sid(ipc::HELPER_SERVICE)?, + ]; + let mut dir = PinnedFile::open_read_shared( + path.parent().expect("fixed qualification parent"), + true, + &readers, + &[], + )?; + let mut file = PinnedFile::open(path, false, &readers, &[], false)?; + ensure!( + file.file.metadata()?.len() <= max, + "system qualification file limit" + ); + let mut raw = vec![]; + (&mut file.file).take(max + 1).read_to_end(&mut raw)?; + ensure!(raw.len() as u64 <= max, "system qualification file limit"); + file.check()?; + dir.check()?; + Ok(raw) +} +fn validate(q: &Qualification, pin: &Pin) -> Result<()> { + ensure!( + q.schema_version == 1 + && ( + q.tenant_id, + q.asset_id, + q.agent_id, + q.enrollment_generation, + q.assignment_version + ) == ( + pin.binding.tenant_id, + pin.binding.asset_id, + pin.binding.agent_id, + pin.binding.enrollment_generation, + pin.binding.assignment_version + ) + && q.agent_binary_sha256 == pin.agent.binary_sha256 + && q.helper_binary_sha256 == pin.helper.binary_sha256 + && q.policy_sha256 == pin.policy_sha256 + && ipc::digest(&q.native_result_sha256) + && !q.qualification_reference.is_nil() + && !q.actions.is_empty() + && q.actions.len() <= 4 + && q.actions.iter().collect::>().len() == q.actions.len() + && q.actions.iter().all(|a| matches!( + a.as_str(), + "run_script" | "set_service_state" | "ensure_package" | "reboot" + )), + "system qualification binding" + ); + Ok(()) +} +fn load_ordinary(pin: &Pin) -> Result<(Qualification, Vec)> { + let raw = read(Path::new(PATH), 16384)?; + let q: Qualification = serde_json::from_slice(&raw)?; + validate(&q, pin)?; + let result = read(Path::new(RESULT_PATH), 65536)?; + ensure!( + rmm_domain::jobs::hash(&result) == q.native_result_sha256, + "system native qualification evidence hash" + ); + Ok((q, result)) +} +/// Fixed per-device MVP catalog, provisioned only from actual qualification. +/// It is public metadata/deny-only capability evidence, never a job lease. +pub fn catalog_directory(pin: &Pin) -> Result { + ensure!( + ipc::digest(&pin.agent.binary_sha256) + && ipc::digest(&pin.helper.binary_sha256) + && ipc::digest(&pin.policy_sha256), + "system catalog digest" + ); + let key = rmm_domain::jobs::hash(&serde_json::to_vec(&( + &pin.agent.binary_sha256, + &pin.helper.binary_sha256, + &pin.policy_sha256, + ))?); + Ok(Path::new(r"C:\ProgramData\RustDiscoverySystem\system-qualification-catalog").join(key)) +} +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct CatalogEvidence { + schema_version: u32, + source_manifest_sha256: String, + qualification_sha256: String, + native_result_sha256: String, + start_witness_sha256: String, + outcome_sha256: String, + approval_audit_sha256: String, + plan_id: Uuid, + plan_sha256: String, + job_id: Uuid, + attempt_id: Uuid, + grant_id: Uuid, + authorization_id: Uuid, + operation_id: Uuid, + approval_origin: String, + testsimulation: bool, +} +fn load_catalog(pin: &Pin) -> Result<(Qualification, Vec)> { + use rmm_domain::jobs::hash; + let directory = catalog_directory(pin)?; + let q_raw = read(&directory.join("qualification.json"), 16384)?; + let q: Qualification = serde_json::from_slice(&q_raw)?; + validate(&q, pin)?; + let result = read(&directory.join("native-result.json"), 65536)?; + let source_manifest = read(&directory.join("source-manifest.json"), 512 * 1024)?; + let source_document:serde_json::Value=serde_json::from_slice(&source_manifest)?; + ensure!(source_document.as_array().is_some_and(|a|!a.is_empty()) + || source_document.as_object().is_some_and(|a|!a.is_empty()),"system catalog source manifest"); + let evidence_raw = read(&directory.join("prequalification.json"), 16384)?; + let e: CatalogEvidence = serde_json::from_slice(&evidence_raw)?; + ensure!( + e.schema_version == 1 + && e.source_manifest_sha256 == hash(&source_manifest) + && e.qualification_sha256 == hash(&q_raw) + && e.native_result_sha256 == hash(&result) + && e.native_result_sha256 == q.native_result_sha256 + && [ + e.plan_id, + e.job_id, + e.attempt_id, + e.grant_id, + e.authorization_id, + e.operation_id + ] + .iter() + .all(|id| !id.is_nil()) + && ipc::digest(&e.plan_sha256) + && matches!( + (e.testsimulation, e.approval_origin.as_str()), + (true, "dev_test_browser_simulation") | (false, "human_webui") + ), + "system catalog qualification provenance" + ); + let start = read(&directory.join("start-witness.json"), 512 * 1024)?; + let outcome = read(&directory.join("powershell-outcome.json"), 128 * 1024)?; + let audit = read(&directory.join("approval-audit.json"), 65536)?; + ensure!( + hash(&start) == e.start_witness_sha256 + && hash(&outcome) == e.outcome_sha256 + && hash(&audit) == e.approval_audit_sha256, + "system catalog actual evidence bytes" + ); + let start_value: serde_json::Value = serde_json::from_slice(&start)?; + let request: rmm_agent_core::auth::Request = + serde_json::from_value(start_value["request"].clone())?; + let at: chrono::DateTime = + serde_json::from_value(start_value["reserved_at"].clone())?; + let boot: Uuid = serde_json::from_value(start_value["previous_boot_id"].clone())?; + let (job, permit) = pin.binding.verify(&request, at)?; + ensure!( + rmm_agent_core::ledger::start_witness_bytes(&permit, &request, boot, at)? == start + && ( + job.job_id, + job.attempt_id, + permit.grant_id, + permit.authorization_id + ) == (e.job_id, e.attempt_id, e.grant_id, e.authorization_id) + && permit.plan_hash == e.plan_sha256 + && job.execution_identity == "system" + && job.action.full_maintenance(), + "system catalog actual original SYSTEM job" + ); + let rmm_domain::jobs::Action::RunScript { + interpreter, + script_utf8, + .. + } = &job.action + else { + anyhow::bail!("system catalog PowerShell qualification required") + }; + let parsed: rmm_domain::reconciliation::ReconciledOutcome = serde_json::from_slice(&outcome)?; + ensure!( + rmm_domain::reconciliation::canonical_outcome_bytes(&parsed)? == outcome + && parsed.state == "succeeded" + && parsed.exit_code == Some(0) + && parsed.error_code.is_empty() + && !parsed.output_truncated + && !parsed.reboot_required + && interpreter == "powershell" + && parsed.evidence["postconditions_passed"] == true + && parsed.evidence["execution_sid"] == "S-1-5-18" + && parsed.evidence["privileged_script_profile"] == "full_maintenance_v1" + && parsed.evidence["script_sha256"] == hash(script_utf8.as_bytes()) + && parsed.evidence["execution_context"]["schema_version"] == 1 + && parsed.evidence["execution_context"]["tenant_id"] + == pin.binding.tenant_id.to_string() + && parsed.evidence["execution_context"]["asset_id"] == pin.binding.asset_id.to_string() + && parsed.evidence["execution_context"]["agent_id"] == pin.binding.agent_id.to_string() + && parsed.evidence["execution_context"]["agent_binary_sha256"] + == pin.agent.binary_sha256 + && parsed.evidence["execution_context"]["helper_binary_sha256"] + == pin.helper.binary_sha256 + && parsed.evidence["execution_context"]["policy_sha256"] == pin.policy_sha256 + && parsed.evidence["execution_context"]["binding_sha256"] + == ipc::binding_hash(&pin.binding)? + && parsed.evidence["execution_context"]["rechecked_at_finish"] == true, + "system catalog actual PowerShell outcome" + ); + let audit: serde_json::Value = serde_json::from_slice(&audit)?; + ensure!( + audit["tenant_id"] == pin.binding.tenant_id.to_string() + && audit["event_type"] == "plan_authorization" + && audit["event_id"] + .as_str() + .is_some_and(|s| Uuid::parse_str(s).is_ok_and(|id| !id.is_nil())) + && audit["principal"] + .as_str() + .is_some_and(|s| !s.is_empty() && s.len() <= 256) + && audit["data"]["plan_id"] == e.plan_id.to_string() + && audit["data"]["plan_hash"] == e.plan_sha256 + && audit["data"]["operation_id"] == e.operation_id.to_string() + && audit["data"]["decision"] == "approve" + && audit["data"]["approval_origin"] == e.approval_origin + && audit["data"]["testsimulation"] == e.testsimulation, + "system catalog actual WebUI approval audit" + ); + Ok((q, result)) +} diff --git a/crates/agent-windows/src/update_admission.rs b/crates/agent-windows/src/update_admission.rs new file mode 100644 index 0000000..bbadd89 --- /dev/null +++ b/crates/agent-windows/src/update_admission.rs @@ -0,0 +1,670 @@ +//! Independently verified SYSTEM admission for an approved code-pair update. +//! This never inherits script, MSI or SCM permissions. Its nonterminal ACK is +//! flushed before the original delegation is dispatched once to the updater. +use crate::{ + helper_ipc::{self as ipc, PeerProof}, + helper_system::{LedgerGuard, WindowsBoot}, + signed_clock::BoundClock, + update_cache, update_ipc, + update_native::{ + Budget, DurableEffectFence, Effect, Role, + files::{self, StageDescriptor, Staged}, + services, transition, + }, + update_state::{BoundFile, Bundle, LedgerIdentity, QualifiedRegistry, RetainedSet}, + update_trust::{Protected, TrustState}, +}; +use anyhow::{Context, Result, ensure}; +use rmm_agent_core::{ + auth::{Binding, Request}, + crypto::DalekVerifier, + helper_reconcile::{BootSource, ExecutorLedgerGuard, HelperSync}, + reconcile::SyncClock, + update_handoff::{PreparedHandoff, UpdateAdmissionGuard}, +}; +use rmm_domain::{ + agent_update::{ParticipantRole, PeerPinTransition, ResolvedAgentUpdate, UpdateDelegation}, + jobs::{Action, hash}, +}; +use rmm_updater_handoff::{AttemptBinding, CodePair, FileTransition, Handoff, PinTransition}; +use rusqlite::Connection; +use serde::{Deserialize, Serialize}; +use std::{cell::RefCell, path::Path, time::Duration}; +use uuid::Uuid; +#[derive(Clone, Debug, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct Accepted { + pub schema_version: u32, + pub operation: String, + pub grant_id: Uuid, + pub owner_nonce: Uuid, + pub handoff_sha256: String, + pub original_request_sha256: String, + pub ready: bool, + pub terminal: bool, +} +impl Accepted { + pub fn matches(&self, request: &Request, grant: Uuid) -> Result<()> { + ensure!( + self.schema_version == 1 + && self.operation == "agent_update_handoff_accepted_v1" + && self.grant_id == grant + && !self.owner_nonce.is_nil() + && ipc::digest(&self.handoff_sha256) + && self.original_request_sha256 == hash(&serde_json::to_vec(request)?) + && !self.ready + && !self.terminal, + "UPDATE_TYPED_HANDOFF_ACK" + ); + Ok(()) + } +} +pub fn initialize(db: &Connection, guard: &impl ExecutorLedgerGuard) -> Result<()> { + rmm_agent_core::update_handoff::initialize(db, guard)?; + db.execute_batch("CREATE TABLE IF NOT EXISTS windows_update_stage_claims(grant_id TEXT NOT NULL,role TEXT NOT NULL,owner_nonce TEXT NOT NULL,original_request_sha256 TEXT NOT NULL,claimed_at TEXT NOT NULL,PRIMARY KEY(grant_id,role)); + CREATE TABLE IF NOT EXISTS windows_update_stage_observations(grant_id TEXT NOT NULL,role TEXT NOT NULL,observation_sha256 TEXT NOT NULL,observed_at TEXT NOT NULL,PRIMARY KEY(grant_id,role),FOREIGN KEY(grant_id,role) REFERENCES windows_update_stage_claims(grant_id,role)); + CREATE TRIGGER IF NOT EXISTS windows_update_stage_claim_no_update BEFORE UPDATE ON windows_update_stage_claims BEGIN SELECT RAISE(ABORT,'UPDATE_STAGE_IMMUTABLE');END; + CREATE TRIGGER IF NOT EXISTS windows_update_stage_claim_no_delete BEFORE DELETE ON windows_update_stage_claims BEGIN SELECT RAISE(ABORT,'UPDATE_STAGE_IMMUTABLE');END; + CREATE TRIGGER IF NOT EXISTS windows_update_stage_obs_no_update BEFORE UPDATE ON windows_update_stage_observations BEGIN SELECT RAISE(ABORT,'UPDATE_STAGE_IMMUTABLE');END; + CREATE TRIGGER IF NOT EXISTS windows_update_stage_obs_no_delete BEFORE DELETE ON windows_update_stage_observations BEGIN SELECT RAISE(ABORT,'UPDATE_STAGE_IMMUTABLE');END;")?; + guard.check(db) +} +pub struct Local<'a> { + pub binding: &'a Binding, + pub guard: &'a LedgerGuard, + pub clock: &'a BoundClock, + pub boot: &'a WindowsBoot, + pub pin: &'a ipc::Pin, + pub generation: u64, +} +fn fresh( + local: &Local<'_>, + request: &Request, +) -> Result<( + rmm_domain::jobs::JobPayload, + rmm_domain::jobs::ExecutionPermitPayload, +)> { + local.clock.require_generation(local.generation)?; + let (lower, upper) = local.clock.bounds()?; + let (job, grant) = local.binding.verify(request, lower)?; + local.binding.verify(request, upper)?; + ensure!( + job.execution_identity == "system" + && job.max_runtime_seconds == 600 + && matches!(&job.action,Action::UpdateAgent{update} if update.validate() && update.execution_identity()==Some("system")), + "UPDATE_ADMISSION_ACTION" + ); + Ok((job, grant)) +} +struct StageFence<'a, 'b> { + local: &'a Local<'b>, + db: &'a Connection, + sync: &'a HelperSync, + request: &'a Request, + grant: Uuid, + nonce: Uuid, + trust: &'a TrustState, + pending: Option, +} +impl DurableEffectFence for StageFence<'_, '_> { + fn before_effect(&mut self, effect: &Effect) -> Result<()> { + let Effect::StageFile { role } = effect else { + anyhow::bail!("UPDATE_PREPARE_STAGE_ONLY"); + }; + ensure!(self.pending.is_none(), "UPDATE_STAGE_PENDING"); + self.local.guard.check(self.db)?; + fresh(self.local, self.request)?; + self.trust.recheck_protected()?; + ensure!( + self.sync.can_start( + self.db, + self.local.guard, + self.local.generation, + self.local.clock, + self.local.boot + ), + "UPDATE_STAGE_SIGNED_SYNC_REQUIRED" + ); + let role = serde_json::to_string(role)?; + self.db.execute( + "INSERT INTO windows_update_stage_claims VALUES(?1,?2,?3,?4,?5)", + rusqlite::params![ + self.grant.to_string(), + role, + self.nonce.to_string(), + hash(&serde_json::to_vec(self.request)?), + self.local.clock.now()?.to_rfc3339() + ], + )?; + self.pending = Some(role); + Ok(()) + } + fn after_effect(&mut self, effect: &Effect, observation: &str) -> Result<()> { + let Effect::StageFile { role } = effect else { + anyhow::bail!("UPDATE_PREPARE_STAGE_ONLY"); + }; + let role = serde_json::to_string(role)?; + ensure!( + self.pending.as_ref() == Some(&role) && ipc::digest(observation), + "UPDATE_STAGE_OBSERVATION" + ); + self.local.guard.check(self.db)?; + fresh(self.local, self.request)?; + self.db.execute( + "INSERT INTO windows_update_stage_observations VALUES(?1,?2,?3,?4)", + rusqlite::params![ + self.grant.to_string(), + role, + observation, + self.local.clock.now()?.to_rfc3339() + ], + )?; + self.pending = None; + Ok(()) + } +} +pub struct Prepared<'a> { + local: Local<'a>, + request: Request, + update: ResolvedAgentUpdate, + bundle: Bundle, + trust: TrustState, + registry: QualifiedRegistry, + retained: RetainedSet, + ledger: LedgerIdentity, + running: RefCell, + updater: RefCell, + original: RefCell, + stages: Vec, + protected: Vec, + sqlite: usize, +} +impl<'a> Prepared<'a> { + pub fn new( + db: &Connection, + local: Local<'a>, + sync: &HelperSync, + request: &Request, + ) -> Result { + local.guard.check(db)?; + let (job, permit) = fresh(&local, request)?; + let Action::UpdateAgent { update } = &job.action else { + unreachable!() + }; + let trust = TrustState::load_prepared(update, local.binding, local.clock)?; + trust.qualify_history(db, local.guard, local.binding)?; + initialize(db, local.guard)?; + let boot = local.boot.current_boot()?; + let budget = Budget::new( + local.boot, + boot, + (permit.start_before - local.clock.now()?).to_std()?, + )?; + let registry = QualifiedRegistry::load(&trust)?; + let running = services::Running::observe( + [local.pin.agent.clone(), local.pin.helper.clone()], + &budget, + )?; + let (updater, updater_id) = services::observe_updater(trust.policy(), &budget)?; + let ipc_pin = update_ipc::Pin { + schema_version: 1, + binding: local.binding.clone(), + policy_sha256: update.updater.policy_sha256.clone(), + helper: local.pin.helper.clone(), + updater: services::updater_pin(trust.policy())?, + }; + let description = update_ipc::exchange( + &ipc_pin, + &update_ipc::Request::Describe {}, + Duration::from_secs(5), + )?; + ensure!( + description.state == update_ipc::State::Described + && description.head_sha256.is_none() + && description.updater == updater_id, + "UPDATE_ADMISSION_LIVE_UPDATER" + ); + registry.verify_observed( + &running.proofs(), + &services::updater_configuration_sha256(&ipc_pin.updater)?, + )?; + let (original, helper_id) = + update_ipc::observe(&local.pin.helper, ParticipantRole::WindowsHelper)?; + ensure!( + helper_id.pid == std::process::id(), + "UPDATE_ACTUAL_SYSTEM_HELPER" + ); + let manifest = update.manifest().map_err(anyhow::Error::msg)?; + ensure!( + manifest.artifacts[0].sha256 != update.predecessor.agent_sha256 + || manifest.artifacts[1].sha256 != update.predecessor.helper_sha256, + "UPDATE_NO_CODE_CHANGE" + ); + let readers = [ + ipc::service_sid(crate::SERVICE_NAME)?, + ipc::service_sid(ipc::HELPER_SERVICE)?, + ]; + let mut protected = Vec::new(); + let (f, settings) = + Protected::read_shared(Path::new(Role::Settings.target()), 32768, &readers)?; + protected.push(f); + let (f, pin) = Protected::read_shared(Path::new(Role::Pin.target()), 32768, &readers)?; + protected.push(f); + let (f, time) = + Protected::read_shared(Path::new(Role::TimeProfile.target()), 32768, &readers)?; + protected.push(f); + let (f, candidate_time) = Protected::read( + Path::new(r"C:\ProgramData\RustDiscoveryUpdater\candidate-time-profile.json"), + 32768, + )?; + protected.push(f); + let rendered = transition::render(transition::Inputs { + settings: &settings, + pin: &pin, + time_profile: &time, + qualified_candidate_time_profile: &candidate_time, + target_agent_sha256: &manifest.artifacts[0].sha256, + target_helper_sha256: &manifest.artifacts[1].sha256, + })?; + ensure!( + rendered.proof() == &update.peer_pin_transition, + "UPDATE_APPROVED_WINDOWS_RENDER_CHANGED" + ); + let nonce = Uuid::new_v4(); + let mut fence = StageFence { + local: &local, + db, + sync, + request, + grant: permit.grant_id, + nonce, + trust: &trust, + pending: None, + }; + let mut stages = Vec::new(); + for (role, artifact, expected_old) in [ + ( + Role::Agent, + &manifest.artifacts[0], + &update.predecessor.agent_sha256, + ), + ( + Role::Helper, + &manifest.artifacts[1], + &update.predecessor.helper_sha256, + ), + ] { + let original = files::observe(role, &budget)?; + ensure!( + &original.sha256 == expected_old, + "UPDATE_PREDECESSOR_BINARY_CHANGED" + ); + let mut source = update_cache::Source::open(artifact)?; + stages.push(Staged::create( + StageDescriptor { + role, + owner_nonce: nonce, + original: &original, + replacement_sha256: &artifact.sha256, + replacement_bytes: artifact.bytes, + }, + &mut source.file, + &budget, + &mut fence, + )?); + source.check()?; + } + for (role, bytes) in [ + (Role::Settings, rendered.settings_bytes()), + (Role::Pin, rendered.pin_bytes()), + (Role::TimeProfile, rendered.time_profile_bytes()), + ] { + let original = files::observe(role, &budget)?; + stages.push(Staged::create( + StageDescriptor { + role, + owner_nonce: nonce, + original: &original, + replacement_sha256: &hash(bytes), + replacement_bytes: bytes.len() as u64, + }, + &mut std::io::Cursor::new(bytes), + &budget, + &mut fence, + )?); + } + drop(fence); + let retained = RetainedSet::capture()?; + let ledger = local.guard.update_identity(db)?; + let bound_files = stages + .iter() + .zip([ + Role::Agent, + Role::Helper, + Role::Settings, + Role::Pin, + Role::TimeProfile, + ]) + .map(|(s, role)| BoundFile { + role, + original: s.original().clone(), + staged: s.staged().clone(), + }) + .collect::>(); + let PeerPinTransition::WindowsCodePairV1 { + old_pin_sha256, + new_pin_sha256, + .. + } = &update.peer_pin_transition + else { + anyhow::bail!("UPDATE_WINDOWS_TRANSITION_REQUIRED"); + }; + let (helper_journal,checkpoint,decision,agent_journal,generation):(String,u64,String,String,u64)=db.query_row("SELECT journal_id,checkpoint,last_decision,agent_journal_id,generation FROM helper_sync_meta WHERE id=1 AND fault IS NULL",[],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?,r.get(3)?,r.get(4)?)))?; + let (sync_response, sync_request): (Vec, Vec) = db.query_row( + "SELECT response,request FROM helper_sync_decisions WHERE decision_id=?1", + [&decision], + |r| Ok((r.get(0)?, r.get(1)?)), + )?; + let now = local.clock.now()?; + let consumed_at = u64::try_from(now.timestamp())?; + let start = rmm_agent_core::ledger::start_witness_bytes(&permit, request, boot, now)?; + let h = Handoff { + schema_version: 2, + attempt: AttemptBinding { + tenant_id: permit.tenant_id, + asset_id: permit.asset_id, + agent_id: permit.agent_id, + enrollment_generation: permit.enrollment_generation, + assignment_version: permit.assignment_version, + plan_id: permit + .agent_update_plan_id + .context("UPDATE_PLAN_ID_REQUIRED")?, + plan_sha256: permit.plan_hash.clone(), + job_id: permit.job_id, + attempt_id: permit.attempt_id, + job_payload_sha256: permit.job_payload_hash.clone(), + grant_id: permit.grant_id, + authorization_id: permit.authorization_id, + original_request_sha256: hash(&serde_json::to_vec(request)?), + original_start_witness_sha256: hash(&start), + }, + agent_journal_id: agent_journal.parse()?, + helper_journal_id: helper_journal.parse()?, + helper_checkpoint: checkpoint, + previous_decision_id: decision.parse()?, + boot_id: boot, + connection_generation: generation, + owner_nonce: nonce, + updater_sha256: update.updater.binary_sha256.clone(), + updater_policy_sha256: update.updater.policy_sha256.clone(), + predecessor_record_sha256: update.predecessor.installed_record_sha256.clone(), + retained_state_sha256: retained.sha256()?, + ledger_identity_sha256: ledger.sha256()?, + staged_files_sha256: hash(&serde_json::to_vec(&bound_files)?), + predecessor: CodePair { + manifest_sha256: update.predecessor.manifest_sha256.clone(), + agent_sha256: update.predecessor.agent_sha256.clone(), + helper_sha256: update.predecessor.helper_sha256.clone(), + pin_sha256: old_pin_sha256.clone(), + }, + target: CodePair { + manifest_sha256: update.manifest_sha256.clone(), + agent_sha256: manifest.artifacts[0].sha256.clone(), + helper_sha256: manifest.artifacts[1].sha256.clone(), + pin_sha256: new_pin_sha256.clone(), + }, + pin_transition: PinTransition::WindowsCodePairClockV1, + pin_transition_sha256: hash(&serde_json::to_vec(&update.peer_pin_transition)?), + files: bound_files + .iter() + .map(|f| FileTransition { + role: f.role.handoff_role(), + old_sha256: f.original.sha256.clone(), + new_sha256: f.staged.sha256.clone(), + }) + .collect(), + stop_set: vec![ + rmm_updater_handoff::Service::WindowsAgent, + rmm_updater_handoff::Service::WindowsHelper, + ], + consumed_at, + finish_before: consumed_at + .checked_add(600) + .context("UPDATE_FINISH_OVERFLOW")?, + }; + let delegation = UpdateDelegation { + schema_version: 1, + handoff_sha256: hash(&h.bytes()?), + owner_nonce: nonce, + boot_id: boot, + prepared_at: now, + updater: updater_id, + original_helper: helper_id, + }; + let bundle = Bundle { + schema_version: 1, + original: request.clone(), + handoff_record: h.bytes()?, + delegation, + files: bound_files, + retained: retained.proofs().to_vec(), + ledger: ledger.clone(), + signed_sync_response: sync_response, + signed_sync_request: sync_request, + }; + bundle.write_before_consume()?; + let prepared = Self { + local, + request: request.clone(), + update: update.as_ref().clone(), + bundle, + trust, + registry, + retained, + ledger, + running: RefCell::new(running), + updater: RefCell::new(updater), + original: RefCell::new(original), + stages, + protected, + sqlite: unsafe { db.handle() } as usize, + }; + prepared.check(db)?; + Ok(prepared) + } + pub fn consume( + &self, + db: &mut Connection, + sync: &mut HelperSync, + ) -> Result { + let h = self.bundle.validate()?; + sync.begin_update_handoff( + db, + self, + self.local.generation, + &PreparedHandoff { + request: &self.request, + handoff: &h, + delegation: &self.bundle.delegation, + recorded_at: self.bundle.delegation.prepared_at, + }, + self.local.clock, + self.local.boot, + )?; + Ok(Accepted { + schema_version: 1, + operation: "agent_update_handoff_accepted_v1".into(), + grant_id: h.attempt.grant_id, + owner_nonce: h.owner_nonce, + handoff_sha256: hash(&h.bytes()?), + original_request_sha256: h.attempt.original_request_sha256, + ready: false, + terminal: false, + }) + } + pub fn into_activation(self) -> Activation { + Activation { + pin: update_ipc::Pin { + schema_version: 1, + binding: self.local.binding.clone(), + policy_sha256: self.update.updater.policy_sha256.clone(), + helper: self.local.pin.helper.clone(), + updater: services::updater_pin(self.trust.policy()).expect("validated updater pin"), + }, + bundle: self.bundle, + trust: self.trust, + registry: self.registry, + retained: self.retained, + running: self.running, + updater: self.updater, + original: self.original, + _stages: self.stages, + _protected: self.protected, + } + } +} +impl ExecutorLedgerGuard for Prepared<'_> { + fn check(&self, db: &Connection) -> Result<()> { + self.local.guard.check(db)?; + ensure!( + unsafe { db.handle() } as usize == self.sqlite + && self.local.guard.update_identity(db)?.sha256()? == self.ledger.sha256()?, + "UPDATE_ADMISSION_ORIGINAL_LEDGER" + ); + self.trust + .recheck_prepared(&self.update, self.local.clock)?; + self.registry.verify()?; + self.retained.verify()?; + let h = self.bundle.validate()?; + let budget = Budget::new(self.local.boot, h.boot_id, Duration::from_secs(1))?; + self.running.try_borrow_mut()?.check(&budget)?; + self.updater.try_borrow_mut()?.check()?; + self.original.try_borrow_mut()?.check()?; + for f in &self.protected { + f.verify()?; + } + for f in &self.bundle.files { + ensure!( + files::observe_bound(f.role, h.owner_nonce, files::Location::Stage, &budget)? + == f.staged, + "UPDATE_ADMISSION_STAGED_CHANGED" + ); + } + Ok(()) + } +} +impl UpdateAdmissionGuard for Prepared<'_> { + fn health_public_key(&self) -> Result<[u8; 32]> { + Ok(self.trust.health_public_key()) + } + fn verify_prepared_update( + &self, + request: &Request, + h: &Handoff, + d: &UpdateDelegation, + _now: chrono::DateTime, + ) -> Result<()> { + ensure!( + serde_json::to_vec(request)? == serde_json::to_vec(&self.request)? + && h.bytes()? == self.bundle.handoff_record + && d == &self.bundle.delegation, + "UPDATE_ADMISSION_EXACT_PREPARED" + ); + Ok(()) + } +} +/// Retains all original process/file witnesses until the one dispatch finishes +/// or the original helper is stopped. No restart/replay constructor exists. +pub struct Activation { + pin: update_ipc::Pin, + bundle: Bundle, + trust: TrustState, + registry: QualifiedRegistry, + retained: RetainedSet, + running: RefCell, + updater: RefCell, + original: RefCell, + _stages: Vec, + _protected: Vec, +} +impl Activation { + pub fn dispatch_after_reply( + self, + db: &Connection, + guard: &LedgerGuard, + clock: &BoundClock, + boot: &WindowsBoot, + ) -> Result<()> { + guard.check(db)?; + let h = self.bundle.validate()?; + let raw: Vec = db.query_row( + "SELECT record FROM agent_update_handoffs WHERE grant_id=?1", + [h.attempt.grant_id.to_string()], + |r| r.get(0), + )?; + ensure!( + raw == h.bytes()? + && rmm_agent_core::update_handoff::read_delegation(db, h.attempt.grant_id)? + == self.bundle.delegation, + "UPDATE_DISPATCH_ORIGINAL_CONSUMED" + ); + let now = u64::try_from(clock.now()?.timestamp())?; + ensure!( + now < h.finish_before && boot.current_boot()? == h.boot_id, + "UPDATE_DISPATCH_DEADLINE_BOOT" + ); + self.trust.recheck_protected()?; + self.registry.verify()?; + self.retained.verify()?; + let budget = Budget::new(boot, h.boot_id, Duration::from_secs(5))?; + self.running.try_borrow_mut()?.check(&budget)?; + self.original.try_borrow_mut()?.check()?; + self.updater.try_borrow_mut()?.check()?; + let reply = update_ipc::exchange( + &self.pin, + &update_ipc::Request::Activate { + grant_id: h.attempt.grant_id, + owner_nonce: h.owner_nonce, + handoff_sha256: hash(&h.bytes()?), + }, + Duration::from_secs(5), + )?; + ensure!( + reply.state == update_ipc::State::Inflight + && reply.updater == self.bundle.delegation.updater, + "UPDATE_DISPATCH_NOT_ACCEPTED" + ); + Ok(()) + } +} + +/// Presence is a separate protected deny-only local update policy, never a +/// consequence of Full/SCM/MSI settings. This does not advertise capability, +/// attest readiness or authorize an effect. +pub fn configured(binding: &Binding) -> bool { + (|| -> Result<()> { + let (_guard, raw) = Protected::read( + Path::new(r"C:\ProgramData\RustDiscoveryUpdater\policy.json"), + 65536, + )?; + let (p, _) = rmm_domain::agent_update_provisioning::LocalUpdatePolicy::from_bytes(&raw) + .map_err(anyhow::Error::msg)?; + ensure!( + p.schema_version == 2 + && p.tenant_id == binding.tenant_id + && p.asset_id == binding.asset_id + && p.agent_id == binding.agent_id + && p.enrollment_generation == binding.enrollment_generation + && p.assignment_version == binding.assignment_version, + "UPDATE_LOCAL_POLICY_BINDING" + ); + Ok(()) + })() + .is_ok() +} +pub fn permits_denial(binding: &Binding, job: &rmm_domain::jobs::JobPayload) -> bool { + configured(binding) + && job.execution_identity == "system" + && job.max_runtime_seconds == 600 + && matches!(&job.action,Action::UpdateAgent{update} if update.validate() && update.execution_identity()==Some("system")) +} diff --git a/crates/agent-windows/src/update_cache.rs b/crates/agent-windows/src/update_cache.rs new file mode 100644 index 0000000..0ce2543 --- /dev/null +++ b/crates/agent-windows/src/update_cache.rs @@ -0,0 +1,221 @@ +//! Public signed artifact bytes only, before any startgrant is requested. +//! This cache grants no execution authority. SYSTEM reopens and hashes each +//! source independently; the writable LocalService source is never a trust pin. +use crate::helper_ipc::{self as ipc, PinnedFile}; +use anyhow::{Context, Result, ensure}; +use rmm_domain::agent_update::{ArtifactDescriptor, ReleaseManifest}; +use sha2::{Digest, Sha256}; +use std::{ + fs::{File, OpenOptions}, + io::{Read, Seek, SeekFrom, Write}, + mem::zeroed, + os::windows::{ + fs::OpenOptionsExt, + io::{AsRawHandle, FromRawHandle}, + }, + path::{Path, PathBuf}, + ptr, +}; +use windows_sys::Win32::{Foundation::*, Storage::FileSystem::*}; +pub const ROOT: &str = r"C:\ProgramData\RustDiscovery\state\update-stage"; +fn path(a: &ArtifactDescriptor, partial: bool) -> Result { + ensure!( + !a.artifact_id.is_nil() + && ipc::digest(&a.sha256) + && a.bytes > 0 + && a.bytes <= rmm_domain::agent_update::MAX_ARTIFACT_BYTES, + "UPDATE_CACHE_DESCRIPTOR" + ); + Ok(Path::new(ROOT).join(format!( + "{}.{}", + a.sha256, + if partial { "part" } else { "bin" } + ))) +} +fn regular(f: &File, dir: bool) -> Result<()> { + let mut i: BY_HANDLE_FILE_INFORMATION = unsafe { zeroed() }; + ensure!( + unsafe { GetFileInformationByHandle(f.as_raw_handle(), &mut i) } != 0 + && i.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT == 0 + && (i.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY != 0) == dir + && (dir || i.nNumberOfLinks == 1), + "UPDATE_CACHE_FILE_TYPE" + ); + Ok(()) +} +fn parents(p: &Path) -> Result> { + let mut guards = Vec::new(); + for parent in p.ancestors().skip(1) { + let h = unsafe { + CreateFileW( + ipc::wide(parent).as_ptr(), + FILE_READ_ATTRIBUTES, + FILE_SHARE_READ | FILE_SHARE_WRITE, + ptr::null(), + OPEN_EXISTING, + FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, + ptr::null_mut(), + ) + }; + ensure!(h != INVALID_HANDLE_VALUE, "UPDATE_CACHE_NOT_PROVISIONED"); + let file = unsafe { File::from_raw_handle(h) }; + regular(&file, true)?; + guards.push(file); + } + Ok(guards) +} +fn verify(file: &mut File, a: &ArtifactDescriptor) -> Result<()> { + regular(file, false)?; + ensure!(file.metadata()?.len() == a.bytes, "UPDATE_CACHE_LENGTH"); + file.seek(SeekFrom::Start(0))?; + let mut digest = Sha256::new(); + let mut bytes = [0; 65536]; + let mut length = 0u64; + loop { + let n = file.read(&mut bytes)?; + if n == 0 { + break; + } + length += n as u64; + ensure!(length <= a.bytes, "UPDATE_CACHE_LENGTH"); + digest.update(&bytes[..n]); + } + ensure!( + length == a.bytes && format!("{:x}", digest.finalize()) == a.sha256, + "UPDATE_CACHE_DIGEST" + ); + file.seek(SeekFrom::Start(0))?; + Ok(()) +} +/// An already open independently hashed source. Parent and source handles deny +/// replacement and the source denies data writes until protected staging ends. +pub struct Source { + pub file: File, + _parents: Vec, + identity: ipc::FileIdentity, + descriptor: ArtifactDescriptor, +} +impl Source { + pub fn open(a: &ArtifactDescriptor) -> Result { + let p = path(a, false)?; + let parents = parents(&p)?; + let mut file = OpenOptions::new() + .read(true) + .share_mode(FILE_SHARE_READ) + .custom_flags(FILE_FLAG_OPEN_REPARSE_POINT) + .open(&p) + .context("UPDATE_CACHE_MISSING")?; + verify(&mut file, a)?; + Ok(Self { + identity: ipc::file_identity(&file)?, + file, + _parents: parents, + descriptor: a.clone(), + }) + } + pub fn check(&mut self) -> Result<()> { + ensure!( + ipc::file_identity(&self.file)? == self.identity, + "UPDATE_CACHE_IDENTITY" + ); + verify(&mut self.file, &self.descriptor) + } +} +pub fn configured() -> bool { + crate::native::private_path(Path::new(ROOT), true).is_ok() +} +pub fn ready(m: &ReleaseManifest) -> Result { + ensure!(m.validate(), "UPDATE_CACHE_MANIFEST"); + for a in &m.artifacts { + if !path(a, false)?.try_exists()? { + return Ok(false); + } + let _ = Source::open(a)?; + } + Ok(true) +} +/// The only resumable operation is a bounded public byte download. No journal, +/// request, consumption, handoff or effect is resumed by this cache. +pub struct Download { + file: File, + descriptor: ArtifactDescriptor, + received: u64, + _parents: Vec, + _root: PinnedFile, +} +impl Download { + pub fn begin(a: &ArtifactDescriptor) -> Result { + crate::native::require_local_service()?; + let p = path(a, true)?; + let parents = parents(&p)?; + crate::native::private_path(Path::new(ROOT), true)?; + let root = PinnedFile::open( + Path::new(ROOT), + true, + &[crate::native::service_sid()?], + &[crate::native::service_sid()?], + false, + )?; + let mut file = OpenOptions::new() + .read(true) + .write(true) + .create(true) + .truncate(false) + .share_mode(FILE_SHARE_READ) + .custom_flags(FILE_FLAG_OPEN_REPARSE_POINT) + .open(&p)?; + regular(&file, false)?; + crate::native::private_path(&p, false)?; + let received = file.metadata()?.len(); + ensure!(received <= a.bytes, "UPDATE_CACHE_PARTIAL_OVERSIZE"); + file.seek(SeekFrom::Start(received))?; + Ok(Self { + file, + descriptor: a.clone(), + received, + _parents: parents, + _root: root, + }) + } + pub fn offset(&self) -> u64 { + self.received + } + pub fn append(&mut self, offset: u64, bytes: &[u8]) -> Result<()> { + ensure!( + offset == self.received + && !bytes.is_empty() + && bytes.len() <= 512 * 1024 + && self.received + bytes.len() as u64 <= self.descriptor.bytes, + "UPDATE_CACHE_CHUNK" + ); + self._root.check()?; + self.file.write_all(bytes)?; + self.received += bytes.len() as u64; + Ok(()) + } + pub fn finish(mut self) -> Result<()> { + ensure!( + self.received == self.descriptor.bytes, + "UPDATE_CACHE_INCOMPLETE" + ); + self.file.sync_all()?; + verify(&mut self.file, &self.descriptor)?; + self._root.check()?; + let src = path(&self.descriptor, true)?; + let dst = path(&self.descriptor, false)?; + drop(self.file); + // No replace, no delete of an existing source, and no shell invocation. + ensure!( + unsafe { + MoveFileExW( + ipc::wide(src).as_ptr(), + ipc::wide(dst).as_ptr(), + MOVEFILE_WRITE_THROUGH, + ) + } != 0, + "UPDATE_CACHE_PUBLISH" + ); + let _ = Source::open(&self.descriptor)?; + Ok(()) + } +} diff --git a/crates/agent-windows/src/update_control.rs b/crates/agent-windows/src/update_control.rs new file mode 100644 index 0000000..f9b2f79 --- /dev/null +++ b/crates/agent-windows/src/update_control.rs @@ -0,0 +1,1254 @@ +//! Authenticated local control of the SAME consumed SYSTEM update. IPC bytes +//! identify an original attempt; actual retained handles supply every proof. +use crate::{ + helper_ipc::{PeerProof, Pin}, + helper_system::{LedgerGuard, UpdateContext}, + signed_clock::BoundClock, + update_ipc, + update_native::{Budget, services::Running}, + update_original::Original, + update_state::{Bundle, QualifiedRegistry, RetainedSet}, + update_trust::TrustState, +}; +use anyhow::{Context, Result, ensure}; +use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD}; +use rmm_agent_core::{ + auth::Binding, + helper_reconcile::ExecutorLedgerGuard, + reconcile::SyncClock, + update_handoff::{ + self as core, NativeControlOperation, NativeControlReply, NativeControlRequest, + NativeEffect, NativeEffectStage, NativeService, Participant, UpdateParticipantGuard, + }, +}; +use rmm_domain::{ + agent_update::{ParticipantRole, UpdateDelegation}, + jobs::hash, +}; +use rmm_updater_handoff::{Event, Evidence, Handoff, Phase, SignedHealth}; +use rusqlite::Connection; +use std::{cell::RefCell, path::Path, time::Duration}; +use uuid::Uuid; +pub(crate) struct Guard<'a, 'b> { + ledger: &'a LedgerGuard, + binding: &'a Binding, + clock: &'a BoundClock, + pin: &'a Pin, + budget: &'a Budget<'b>, + original: Original, + trust: TrustState, + bundle: Bundle, + bundle_recheck: Box Result<()>>, + retained: RetainedSet, + registry: QualifiedRegistry, + running: RefCell, + own: RefCell, + updater: RefCell>, + participant: Participant, + sqlite: usize, + verified_health: RefCell>, + publication: RefCell>, + code_files: Vec<( + crate::update_native::files::Proof, + RefCell, + )>, +} +impl<'a, 'b> Guard<'a, 'b> { + pub(crate) fn open( + db: &Connection, + ledger: &'a LedgerGuard, + binding: &'a Binding, + clock: &'a BoundClock, + pin: &'a Pin, + budget: &'a Budget<'b>, + grant: Uuid, + ) -> Result { + ledger.check(db)?; + let journal = core::read(db, ledger, grant)?; + ensure!( + !matches!(journal.phase(), Phase::Unknown | Phase::OutcomePersisted), + "UPDATE_NOT_ACTIVE" + ); + let (record,start):(Vec,Vec)=db.query_row( + "SELECT h.record,e.start FROM agent_update_handoffs h JOIN execution_evidence e USING(grant_id) WHERE h.grant_id=?1", + [grant.to_string()],|r|Ok((r.get(0)?,r.get(1)?)))?; + let original = + Original::verify_retained(binding, &start, &record, core::read_delegation(db, grant)?)?; + let trust = TrustState::load_retained( + original.update(), + binding, + original.delegation().prepared_at, + )?; + let (bundle, recheck) = Bundle::load(grant)?; + ensure!( + bundle.handoff_record == record && bundle.delegation == *original.delegation(), + "UPDATE_ORIGINAL_BUNDLE_CHANGED" + ); + ensure!( + ledger.update_identity(db)?.sha256()? == original.handoff().ledger_identity_sha256, + "UPDATE_ORIGINAL_LEDGER_IDENTITY" + ); + let retained = RetainedSet::reopen(&bundle.retained)?; + let registry = QualifiedRegistry::load(&trust)?; + let running = Running::observe([pin.agent.clone(), pin.helper.clone()], budget)?; + let own = PeerProof::for_service(&pin.helper, std::process::id())?; + let identity = update_ipc::participant(&own, ParticipantRole::WindowsHelper)?; + let restored = matches!( + journal.phase(), + Phase::RollbackLedgerReturnIntent + | Phase::RollbackServicesStarted + | Phase::RollbackHealthVerified + ); + let target = matches!( + journal.phase(), + Phase::LedgerReturnIntent | Phase::ServicesStarted | Phase::HealthVerified + ); + let participant = if identity == original.delegation().original_helper { + Participant::OriginalHelper + } else if restored && identity.image_sha256 == original.handoff().predecessor.helper_sha256 + { + Participant::RestoredHelper + } else if target && identity.image_sha256 == original.handoff().target.helper_sha256 { + Participant::NewHelper + } else { + Participant::Observer + }; + // Historical capture must be able to classify owner loss as Unknown; + // an observer never authorizes an effect or a successful outcome. + let updater_pin = crate::update_native::services::updater_pin(trust.policy())?; + let updater = update_ipc::observe(&updater_pin, ParticipantRole::WindowsUpdater) + .ok() + .map(|(peer, _)| peer); + + // Read-sharing without WRITE/DELETE sharing makes the observed code + // bytes immutable for this real control operation. Later checks retain + // those exact handles/IDs/security instead of hashing EXEs repeatedly. + let readers = vec![ + crate::helper_ipc::service_sid(crate::SERVICE_NAME)?, + crate::helper_ipc::service_sid(crate::helper_ipc::HELPER_SERVICE)?, + crate::helper_ipc::service_sid(crate::update_ipc::SERVICE)?, + ]; + let mut code_files = vec![]; + for bound in &bundle.files { + let expected = if participant == Participant::NewHelper { + &bound.staged + } else { + &bound.original + }; + let path = Path::new(bound.role.target()); + let mut file = crate::helper_ipc::PinnedFile::open(path, false, &readers, &[], false)?; + let proof = + crate::update_native::files::proof(&mut file.file, path, bound.role.max_bytes())?; + ensure!(&proof == expected, "UPDATE_ACTUAL_CODE_PAIR_FILES_CHANGED"); + code_files.push((proof, RefCell::new(file))); + } + let result = Self { + ledger, + binding, + clock, + pin, + budget, + original, + trust, + bundle, + bundle_recheck: Box::new(recheck), + retained, + registry, + running: RefCell::new(running), + own: RefCell::new(own), + updater: RefCell::new(updater), + participant, + sqlite: unsafe { db.handle() } as usize, + verified_health: RefCell::new(None), + publication: RefCell::new(None), + code_files, + }; + result.check(db)?; + Ok(result) + } + fn current(&self) -> Result<()> { + (self.bundle_recheck)()?; + self.budget.check()?; + if let Some(namespace) = self.publication.try_borrow()?.as_ref() { + self.trust.recheck_other_protected()?; + namespace.verify_original(self.trust.installed_raw())?; + } else { + self.trust.recheck_protected()?; + } + self.registry.verify()?; + self.retained.verify()?; + self.running.try_borrow_mut()?.check(self.budget)?; + let proofs = self.running.try_borrow()?.proofs(); + let pair = if self.participant == Participant::NewHelper { + &self.original.handoff().target + } else { + &self.original.handoff().predecessor + }; + ensure!( + proofs[0].process.image_sha256 == pair.agent_sha256 + && proofs[1].process.image_sha256 == pair.helper_sha256 + && proofs + .iter() + .zip(&self.trust.policy().services) + .all(|(actual, pin)| serde_json::to_vec(&actual.configuration) + .is_ok_and(|raw| hash(&raw) == pin.unit_sha256)), + "UPDATE_ACTUAL_PAIR_CONFIGURATION_CHANGED" + ); + let updater = crate::update_native::services::updater_pin(self.trust.policy())?; + ensure!( + crate::update_native::services::updater_configuration_sha256(&updater)? + == self.trust.policy().updater_service.unit_sha256, + "UPDATE_UPDATER_CONFIGURATION_CHANGED" + ); + self.own.try_borrow_mut()?.check()?; + for (proof, file) in &self.code_files { + let mut file = file.try_borrow_mut()?; + file.check()?; + ensure!( + file.identity == proof.identity + && file.file.metadata()?.len() == proof.bytes + && crate::update_native::files::security_sha256(&file.file)? + == proof.security_sha256, + "UPDATE_HELD_CODE_FILES_CHANGED" + ); + } + Ok(()) + } + fn owner_current(&self) -> Result<()> { + ensure!( + self.participant != Participant::Observer, + "UPDATE_ACTUAL_HELPER_GENERATION_REQUIRED" + ); + let mut owner = self.updater.try_borrow_mut()?; + let owner = owner + .as_mut() + .context("UPDATE_ORIGINAL_UPDATER_UNAVAILABLE")?; + owner.check()?; + ensure!( + update_ipc::participant(owner, ParticipantRole::WindowsUpdater)? + == self.original.delegation().updater, + "UPDATE_ORIGINAL_UPDATER_PROCESS_CHANGED" + ); + Ok(()) + } + fn effects(&self, db: &Connection) -> Result<()> { + self.check(db)?; + self.owner_current()?; + self.original + .check_current(self.binding, self.clock, self.budget)?; + self.trust + .recheck_crypto(self.original.update(), self.clock)?; + self.trust.qualify_history(db, self.ledger, self.binding) + } + fn same(&self, h: &Handoff, d: &UpdateDelegation) -> Result<()> { + ensure!( + h.bytes()? == self.original.handoff().bytes()? && d == self.original.delegation(), + "UPDATE_ORIGINAL_OWNER_CHANGED" + ); + self.current() + } + fn started(&self) -> Result<(Vec, String)> { + self.current()?; + let proofs = self.running.try_borrow()?.proofs(); + for (p, b) in proofs.iter().zip([&self.pin.agent, &self.pin.helper]) { + ensure!( + p.process.image_sha256 == b.binary_sha256, + "UPDATE_STARTED_IMAGE_CHANGED" + ); + } + Ok(( + proofs.iter().map(|p| p.started()).collect(), + hash(&serde_json::to_vec(&proofs)?), + )) + } + fn verify_health(&self, db: &Connection, signed: &SignedHealth) -> Result<()> { + self.effects(db)?; + ensure!( + matches!( + self.participant, + Participant::NewHelper | Participant::RestoredHelper + ), + "UPDATE_NEW_HELPER_REQUIRED" + ); + let mut journal = core::read(db, self, self.original.permit().grant_id)?; + if matches!( + journal.phase(), + Phase::ServicesStarted | Phase::RollbackServicesStarted + ) { + let event = journal.prepare( + u64::try_from(self.clock.reading()?.upper.timestamp())?, + if self.participant == Participant::RestoredHelper { + Evidence::RollbackHealthVerified { + receipt: signed.clone(), + } + } else { + Evidence::HealthVerified { + receipt: signed.clone(), + } + }, + )?; + journal.replay(&event)?; + } else { + ensure!( + matches!( + journal.phase(), + Phase::HealthVerified | Phase::RollbackHealthVerified + ), + "UPDATE_HEALTH_PHASE" + ); + let raw:Vec=db.query_row("SELECT event FROM agent_update_handoff_events WHERE grant_id=?1 ORDER BY sequence DESC LIMIT 1", + [self.original.permit().grant_id.to_string()],|r|r.get(0))?; + let event: Event = serde_json::from_slice(&raw)?; + ensure!( + hash(&raw) == journal.head_sha256() + && match event.evidence { + Evidence::HealthVerified { receipt } + | Evidence::RollbackHealthVerified { receipt } => receipt == *signed, + _ => false, + }, + "UPDATE_ORIGINAL_STORED_HEALTH_REQUIRED" + ); + } + let receipt: rmm_updater_handoff::HealthReceipt = serde_json::from_slice(&signed.payload)?; + let (generation,agent,helper):(u64,String,String)=db.query_row( + "SELECT generation,agent_journal_id,journal_id FROM helper_sync_meta WHERE id=1 AND fault IS NULL",[], + |r|Ok((r.get(0)?,r.get(1)?,r.get(2)?)))?; + ensure!( + generation == receipt.connection_generation + && agent == receipt.agent_journal_id.to_string() + && helper == receipt.helper_journal_id.to_string() + && self.started()?.0 == receipt.service_processes, + "UPDATE_HEALTH_CURRENT_CHANNEL_OR_PROCESSES" + ); + rmm_agent_core::update_health_sync::verified_span( + db, + self.ledger, + self.binding, + self.original.handoff(), + &receipt, + self.trust.health_public_key(), + )?; + verify_inventory(&self.retained, &self.original, &receipt)?; + *self.verified_health.try_borrow_mut()? = Some(hash(&serde_json::to_vec(signed)?)); + Ok(()) + } +} +impl ExecutorLedgerGuard for Guard<'_, '_> { + fn check(&self, db: &Connection) -> Result<()> { + self.ledger.check(db)?; + self.current()?; + ensure!( + unsafe { db.handle() } as usize == self.sqlite, + "UPDATE_ORIGINAL_SQLITE_HANDLE_CHANGED" + ); + ensure!( + self.ledger.update_identity(db)?.sha256()? + == self.original.handoff().ledger_identity_sha256, + "UPDATE_ORIGINAL_LEDGER_CHANGED" + ); + let start: Vec = db.query_row( + "SELECT start FROM execution_evidence WHERE grant_id=?1", + [self.original.permit().grant_id.to_string()], + |r| r.get(0), + )?; + ensure!( + start == self.original.start_bytes(), + "UPDATE_ORIGINAL_START_CHANGED" + ); + Ok(()) + } + fn check_update_owner( + &self, + h: &Handoff, + d: &UpdateDelegation, + _phase: Phase, + _events: &[Event], + ) -> Result<()> { + self.same(h, d)?; + self.owner_current()?; + self.original + .check_current(self.binding, self.clock, self.budget)?; + self.trust + .recheck_crypto(self.original.update(), self.clock) + } +} +impl UpdateParticipantGuard for Guard<'_, '_> { + fn participant(&self) -> Participant { + self.participant + } + fn verify_native_effect( + &self, + h: &Handoff, + d: &UpdateDelegation, + effect: &NativeEffect, + stage: NativeEffectStage, + ) -> Result<()> { + self.same(h, d)?; + self.owner_current()?; + self.original + .check_current(self.binding, self.clock, self.budget)?; + self.trust + .recheck_crypto(self.original.update(), self.clock)?; + match (effect, stage) { + ( + NativeEffect::StopService { + service: NativeService::WindowsAgent | NativeService::WindowsHelper, + }, + NativeEffectStage::Claim, + ) if self.participant == Participant::OriginalHelper => { + let proofs = self.running.try_borrow()?.proofs(); + self.registry + .verify_observed(&proofs, &self.trust.policy().updater_service.unit_sha256)?; + ensure!( + proofs[0].process.image_sha256 == h.predecessor.agent_sha256 + && proofs[1].process.image_sha256 == h.predecessor.helper_sha256, + "UPDATE_STOP_PREDECESSOR_REQUIRED" + ); + Ok(()) + } + (NativeEffect::StartService { service }, NativeEffectStage::Observe) + if self.participant == Participant::NewHelper => + { + self.verify_started_service( + *service, + h.target.agent_sha256.as_str(), + h.target.helper_sha256.as_str(), + ) + } + (NativeEffect::RollbackStartService { service }, NativeEffectStage::Observe) + if self.participant == Participant::RestoredHelper => + { + self.verify_started_service( + *service, + h.predecessor.agent_sha256.as_str(), + h.predecessor.helper_sha256.as_str(), + ) + } + ( + NativeEffect::SaveInstalledRecord { .. } + | NativeEffect::PublishInstalledRecord { .. }, + NativeEffectStage::Claim | NativeEffectStage::Observe, + ) if self.participant == Participant::NewHelper => self + .publication + .try_borrow()? + .as_ref() + .context("UPDATE_RECORD_NAMESPACE_REQUIRED")? + .verify_effect(effect, stage == NativeEffectStage::Observe), + _ => anyhow::bail!("UPDATE_WINDOWS_HELPER_EFFECT_NOT_QUALIFIED"), + } + } + fn verify_update_event(&self, h: &Handoff, d: &UpdateDelegation, event: &Event) -> Result<()> { + self.same(h, d)?; + self.owner_current()?; + self.original + .check_current(self.binding, self.clock, self.budget)?; + self.trust + .recheck_crypto(self.original.update(), self.clock)?; + match &event.evidence { + Evidence::ServicesStarted { + services, + ledger_identity_sha256, + observation_sha256, + } + | Evidence::RollbackServicesStarted { + services, + ledger_identity_sha256, + observation_sha256, + } => { + let (actual, digest) = self.started()?; + ensure!( + *services == actual + && *observation_sha256 == digest + && *ledger_identity_sha256 == self.bundle.ledger.sha256()?, + "UPDATE_ACTUAL_STARTS_REQUIRED" + ); + Ok(()) + } + Evidence::HealthVerified { receipt } | Evidence::RollbackHealthVerified { receipt } => { + ensure!( + self.verified_health.try_borrow()?.as_ref() + == Some(&hash(&serde_json::to_vec(receipt)?)), + "UPDATE_ACTUAL_LOCAL_HEALTH_REQUIRED" + ); + Ok(()) + } + Evidence::OutcomePersisted { .. } => { + ensure!( + self.verified_health.try_borrow()?.is_some(), + "UPDATE_ACTUAL_HEALTH_REQUIRED" + ); + self.publication + .try_borrow()? + .as_ref() + .context("UPDATE_RECORD_NAMESPACE_REQUIRED")? + .published() + } + Evidence::RollbackOutcomePersisted { .. } => { + ensure!( + self.participant == Participant::RestoredHelper + && self.publication.try_borrow()?.is_none() + && self.verified_health.try_borrow()?.is_some(), + "UPDATE_ROLLBACK_NO_RECORD_CHANGE" + ); + self.trust.recheck_protected() + } + _ => anyhow::bail!("UPDATE_WINDOWS_HELPER_EVENT_NOT_QUALIFIED"), + } + } +} +impl Guard<'_, '_> { + fn verify_started_service( + &self, + service: NativeService, + agent: &str, + helper: &str, + ) -> Result<()> { + let (service, image) = match service { + NativeService::WindowsAgent => (crate::update_native::Service::Agent, agent), + NativeService::WindowsHelper => (crate::update_native::Service::Helper, helper), + _ => anyhow::bail!("UPDATE_WINDOWS_SERVICE_REQUIRED"), + }; + ensure!( + self.running + .try_borrow()? + .proofs() + .iter() + .any(|p| p.configuration.service == service && p.process.image_sha256 == image), + "UPDATE_ACTUAL_STARTED_SERVICE_REQUIRED" + ); + Ok(()) + } +} +pub(crate) fn handle_updater( + ctx: UpdateContext<'_>, + peer: &mut PeerProof, + request: &NativeControlRequest, +) -> Result { + handle(ctx, peer, request, false) +} +pub(crate) fn handle_agent_health( + ctx: UpdateContext<'_>, + peer: &mut PeerProof, + request: &NativeControlRequest, +) -> Result { + ensure!( + matches!(request.method, NativeControlOperation::Health { .. }), + "UPDATE_AGENT_HEALTH_ONLY" + ); + handle(ctx, peer, request, true) +} +fn handle( + ctx: UpdateContext<'_>, + peer: &mut PeerProof, + request: &NativeControlRequest, + agent_health: bool, +) -> Result { + ensure!( + request.operation == "agent_update_control_v1" + && request.schema_version == 1 + && !request.challenge.is_nil() + && request.tenant_id == ctx.binding.tenant_id + && request.asset_id == ctx.binding.asset_id + && request.agent_id == ctx.binding.agent_id + && request.enrollment_generation == ctx.binding.enrollment_generation + && request.assignment_version == ctx.binding.assignment_version, + "UPDATE_CONTROL_BINDING" + ); + use rmm_agent_core::helper_reconcile::BootSource; + let budget = Budget::new(ctx.boot, ctx.boot.current_boot()?, Duration::from_secs(5))?; + let guard = Guard::open( + ctx.db, + ctx.guard, + ctx.binding, + ctx.clock, + ctx.pin, + &budget, + request.grant_id, + )?; + let header = guard.original.handoff(); + ensure!( + header.owner_nonce == request.owner_nonce + && hash(&header.bytes()?) == request.handoff_sha256, + "UPDATE_CONTROL_ORIGINAL_REQUIRED" + ); + peer.check()?; + if agent_health { + peer.identity() + .validate(&ctx.pin.agent, peer.identity().pid)?; + let agent = guard.running.try_borrow()?.proofs()[0].process.clone(); + ensure!( + peer.identity().pid == agent.pid + && peer.identity().creation_ticks == agent.birth + && peer.identity().image_sha256 == agent.image_sha256, + "UPDATE_CURRENT_AGENT_PEER_REQUIRED" + ); + } else { + ensure!( + update_ipc::participant(peer, ParticipantRole::WindowsUpdater)? + == guard.original.delegation().updater, + "UPDATE_ORIGINAL_UPDATER_PEER_REQUIRED" + ); + } + if !matches!(request.method, NativeControlOperation::ReadOriginal) { + ensure!(ctx.sync.is_some(), "UPDATE_EXISTING_SYNC_OWNER_REQUIRED"); + let generation: u64 = ctx.db.query_row( + "SELECT generation FROM helper_sync_meta WHERE id=1 AND fault IS NULL", + [], + |r| r.get(0), + )?; + ctx.clock.require_generation(generation)?; + guard.effects(ctx.db)?; + } + let mut original_start_base64url = None; + let mut original_outcome_base64url = None; + let mut claim = None; + match &request.method { + NativeControlOperation::ReadOriginal => { + original_start_base64url = Some(URL_SAFE_NO_PAD.encode(guard.original.start_bytes())) + } + NativeControlOperation::ClaimStop { + expected_head_sha256, + service, + } => { + claim = Some(core::claim_native_effect( + ctx.db, + &guard, + request.grant_id, + expected_head_sha256, + &NativeEffect::StopService { service: *service }, + ctx.clock.reading()?.upper, + )?); + } + NativeControlOperation::ObserveStarts { + services, + observation_sha256, + } => { + let journal = core::read(ctx.db, &guard, request.grant_id)?; + ensure!( + matches!( + journal.phase(), + Phase::LedgerReturnIntent | Phase::RollbackLedgerReturnIntent + ), + "UPDATE_START_PHASE" + ); + let (actual, digest) = guard.started()?; + ensure!( + *services == actual && *observation_sha256 == digest, + "UPDATE_ACTUAL_STARTS_REQUIRED" + ); + for service in [NativeService::WindowsHelper, NativeService::WindowsAgent] { + let effect = if guard.participant == Participant::RestoredHelper { + NativeEffect::RollbackStartService { service } + } else { + NativeEffect::StartService { service } + }; + let reserved = core::read_native_claim(ctx.db, &guard, request.grant_id, &effect)?; + let proof = guard + .running + .try_borrow()? + .proofs() + .into_iter() + .find(|p| { + p.configuration.service.handoff_service() + == match service { + NativeService::WindowsHelper => { + rmm_updater_handoff::Service::WindowsHelper + } + NativeService::WindowsAgent => { + rmm_updater_handoff::Service::WindowsAgent + } + _ => unreachable!(), + } + }) + .context("UPDATE_ACTUAL_START_PROOF_REQUIRED")?; + core::observe_native_effect( + ctx.db, + &guard, + &reserved, + &hash(&serde_json::to_vec(&proof)?), + ctx.clock.reading()?.upper, + )?; + } + let event = journal.prepare( + u64::try_from(ctx.clock.reading()?.upper.timestamp())?, + if guard.participant == Participant::RestoredHelper { + Evidence::RollbackServicesStarted { + services: actual, + ledger_identity_sha256: header.ledger_identity_sha256.clone(), + observation_sha256: digest, + } + } else { + Evidence::ServicesStarted { + services: actual, + ledger_identity_sha256: header.ledger_identity_sha256.clone(), + observation_sha256: digest, + } + }, + )?; + core::append( + ctx.db, + &guard, + request.grant_id, + journal.head_sha256(), + &event, + )?; + } + NativeControlOperation::Health { receipt } => { + guard.verify_health(ctx.db, receipt)?; + let journal = core::read(ctx.db, &guard, request.grant_id)?; + let event = journal.prepare( + u64::try_from(ctx.clock.reading()?.upper.timestamp())?, + if guard.participant == Participant::RestoredHelper { + Evidence::RollbackHealthVerified { + receipt: receipt.clone(), + } + } else { + Evidence::HealthVerified { + receipt: receipt.clone(), + } + }, + )?; + core::append( + ctx.db, + &guard, + request.grant_id, + journal.head_sha256(), + &event, + )?; + } + NativeControlOperation::Finalize => { + original_outcome_base64url = Some(URL_SAFE_NO_PAD.encode(guard.finalize(ctx.db)?)); + } + } + let proof = if original_outcome_base64url.is_none() { + Some( + core::current_proof(ctx.db, &guard, request.grant_id)? + .context("UPDATE_ACTIVE_PROOF_REQUIRED")?, + ) + } else { + None + }; + let pre_stop = if matches!(request.method, NativeControlOperation::ReadOriginal) { + pre_stop_snapshot( + ctx.db, + &guard, + proof.as_ref().context("UPDATE_ACTIVE_PROOF_REQUIRED")?, + )? + } else { + None + }; + let (pre_stop_sync_request_base64url, pre_stop_sync_response_base64url) = match pre_stop { + Some((request, response)) => ( + Some(URL_SAFE_NO_PAD.encode(request)), + Some(URL_SAFE_NO_PAD.encode(response)), + ), + None => (None, None), + }; + Ok(NativeControlReply { + schema_version: 1, + challenge: request.challenge, + tenant_id: ctx.binding.tenant_id, + asset_id: ctx.binding.asset_id, + agent_id: ctx.binding.agent_id, + enrollment_generation: ctx.binding.enrollment_generation, + assignment_version: ctx.binding.assignment_version, + grant_id: request.grant_id, + owner_nonce: request.owner_nonce, + handoff_sha256: request.handoff_sha256.clone(), + ready: false, + proof, + claim, + original_start_base64url, + original_outcome_base64url, + pre_stop_sync_request_base64url, + pre_stop_sync_response_base64url, + }) +} + +fn verify_inventory( + retained: &RetainedSet, + original: &Original, + receipt: &rmm_updater_handoff::HealthReceipt, +) -> Result<()> { + use crate::update_state::Retention; + use prost::Message; + use rusqlite::OpenFlags; + const PATH: &str = r"C:\ProgramData\RustDiscovery\state\telemetry.sqlite"; + ensure!( + retained + .proofs() + .iter() + .any(|s| s.spec.path == Path::new(PATH) + && s.spec.retention == Retention::MutableDatabase), + "UPDATE_RETAINED_AGENT_JOURNAL_REQUIRED" + ); + retained.verify()?; + let journal_pin = crate::update_state::AgentStateFile::journal()?; + let db = Connection::open_with_flags( + PATH, + OpenFlags::SQLITE_OPEN_READ_ONLY | OpenFlags::SQLITE_OPEN_NO_MUTEX, + )?; + db.busy_timeout(Duration::ZERO)?; + // This journal belongs to the unprivileged agent. Bound SQLite's own + // materialization before querying; a hostile oversized BLOB/view cannot + // turn a root health check into an unbounded allocation or schema program. + unsafe { + rusqlite::ffi::sqlite3_limit( + db.handle(), + rusqlite::ffi::SQLITE_LIMIT_LENGTH, + (rmm_domain::MAX_MESSAGE + 65536) as i32, + ); + } + db.execute_batch("PRAGMA trusted_schema=OFF;PRAGMA query_only=ON;")?; + let tx = db.unchecked_transaction()?; + let kind: String = tx.query_row( + "SELECT type FROM sqlite_master WHERE name='update_health_inventory'", + [], + |r| r.get(0), + )?; + ensure!(kind == "table", "UPDATE_AGENT_RETENTION_MUST_BE_TABLE"); + let length: u64 = tx.query_row( + "SELECT length(envelope) FROM update_health_inventory WHERE grant_id=?1 AND message_id=?2", + rusqlite::params![ + original.permit().grant_id.to_string(), + receipt.inventory_message_id.to_string() + ], + |r| r.get(0), + )?; + ensure!( + length > 0 && length <= rmm_domain::MAX_MESSAGE as u64, + "UPDATE_LOCAL_INVENTORY_RAW_LIMIT" + ); + journal_pin.check()?; + let envelope = rmm_agent_core::update_health_inventory::read( + &tx, + original.permit().grant_id, + receipt.inventory_message_id, + )?; + let marker:(String,String)=tx.query_row("SELECT signed_decision_id,signed_response_sha256 FROM update_health_inventory WHERE grant_id=?1 AND message_id=?2",rusqlite::params![original.permit().grant_id.to_string(),receipt.inventory_message_id.to_string()],|r|Ok((r.get(0)?,r.get(1)?)))?; + ensure!( + marker + == ( + receipt.signed_sync_decision_id.to_string(), + receipt.signed_sync_response_sha256.clone() + ) + && envelope.agent_id == original.handoff().attempt.agent_id.to_string() + && envelope.boot_id == original.handoff().boot_id.to_string() + && envelope.enrollment_generation == original.handoff().attempt.enrollment_generation + && envelope.connection_generation == receipt.connection_generation, + "UPDATE_LOCAL_INVENTORY_ORIGINAL_BINDING" + ); + let Some(rmm_protocol::Payload::InventorySnapshot(snapshot)) = &envelope.payload else { + anyhow::bail!("UPDATE_LOCAL_BASE_INVENTORY_REQUIRED") + }; + ensure!( + snapshot.scope == "windows.base" + && !snapshot.data.is_empty() + && snapshot.sha256 == hex::decode(hash(&snapshot.data))? + && envelope.encode_to_vec().len() <= rmm_domain::MAX_MESSAGE, + "UPDATE_LOCAL_BASE_INVENTORY_HASH" + ); + rmm_domain::inventory_document::validate_for_scope( + &snapshot.data, + chrono::Utc::now(), + "windows.base", + ) + .map_err(anyhow::Error::msg)?; + tx.commit()?; + journal_pin.check()?; + retained.verify() +} + +/// Read-only selection of the one active ORIGINAL; never creates an attempt. +pub(crate) fn active_grant(db: &Connection) -> Result> { + let exists:bool=db.query_row("SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE type='table' AND name='agent_update_handoffs')",[],|r|r.get(0))?; + if !exists { + return Ok(None); + } + let mut query=db.prepare("SELECT grant_id FROM agent_update_handoffs WHERE phase NOT IN ('unknown','outcome_persisted') ORDER BY grant_id LIMIT 2")?; + let rows = query + .query_map([], |r| r.get::<_, String>(0))? + .collect::>>()?; + ensure!(rows.len() <= 1, "UPDATE_MULTIPLE_ORIGINAL_HANDOFFS"); + rows.first() + .map(|id| Uuid::parse_str(id).map_err(Into::into)) + .transpose() +} +pub(crate) fn server_pin( + binding: &Binding, + helper: &crate::helper_ipc::PeerPin, +) -> Result> { + if !crate::update_admission::configured(binding) { + return Ok(None); + } + let (file, raw) = crate::update_trust::Protected::read( + Path::new(r"C:\ProgramData\RustDiscoveryUpdater\policy.json"), + 65536, + )?; + let (policy, policy_sha256) = + rmm_domain::agent_update_provisioning::LocalUpdatePolicy::from_bytes(&raw) + .map_err(anyhow::Error::msg)?; + ensure!( + policy.schema_version == 2 + && policy.tenant_id == binding.tenant_id + && policy.asset_id == binding.asset_id + && policy.agent_id == binding.agent_id + && policy.enrollment_generation == binding.enrollment_generation + && policy.assignment_version == binding.assignment_version, + "UPDATE_CONTROL_PROTECTED_POLICY_BINDING" + ); + let pin = update_ipc::Pin { + schema_version: 1, + binding: binding.clone(), + policy_sha256, + helper: helper.clone(), + updater: crate::update_native::services::updater_pin(&policy)?, + }; + file.verify()?; + pin.validate()?; + Ok(Some(pin)) +} +fn pre_stop_snapshot( + db: &Connection, + guard: &Guard<'_, '_>, + proof: &rmm_domain::agent_update::UpdateInflightProof, +) -> Result, Vec)>> { + use prost::Message; + let (_, journal) = + rmm_domain::agent_update::verify_inflight_proof(proof, guard.trust.health_public_key()) + .map_err(anyhow::Error::msg)?; + if journal.phase() != Phase::StopIntent { + return Ok(None); + } + let latest: Option = db.query_row( + "SELECT last_decision FROM helper_sync_meta WHERE id=1 AND fault IS NULL", + [], + |r| r.get(0), + )?; + let Some(id) = latest else { return Ok(None) }; + let applied:bool=db.query_row("SELECT EXISTS(SELECT 1 FROM agent_update_sync_applied WHERE grant_id=?1 AND decision_id=?2)", + rusqlite::params![guard.original.permit().grant_id.to_string(),id],|r|r.get(0))?; + if !applied { + return Ok(None); + } + let round = rmm_agent_core::update_health_sync::read_round( + db, + guard.ledger, + guard.binding, + guard.original.permit().grant_id, + id.parse()?, + )?; + let (request_len, response_len): (usize, usize) = db.query_row( + "SELECT length(request),length(response) FROM helper_sync_decisions WHERE decision_id=?1", + [&id], + |r| Ok((r.get(0)?, r.get(1)?)), + )?; + ensure!( + request_len <= 512 * 1024 && response_len <= 512 * 1024, + "UPDATE_PRE_STOP_SYNC_LIMIT" + ); + let (request, response): (Vec, Vec) = db.query_row( + "SELECT request,response FROM helper_sync_decisions WHERE decision_id=?1", + [&id], + |r| Ok((r.get(0)?, r.get(1)?)), + )?; + let decoded = rmm_protocol::SyncRequest::decode(request.as_slice())?; + if decoded.previous_decision_id.is_empty() + || decoded.previous_decision_id != decoded.helper_previous_decision_id + { + return Ok(None); + } + let previous: Uuid = decoded.previous_decision_id.parse()?; + let prior_applied:bool=db.query_row("SELECT EXISTS(SELECT 1 FROM agent_update_sync_applied WHERE grant_id=?1 AND decision_id=?2)", + rusqlite::params![guard.original.permit().grant_id.to_string(),previous.to_string()],|r|r.get(0))?; + if !prior_applied { + return Ok(None); + } + let prior = rmm_agent_core::update_health_sync::read_round( + db, + guard.ledger, + guard.binding, + guard.original.permit().grant_id, + previous, + )?; + let expected = + rmm_domain::agent_update::inflight_decision(proof, guard.trust.health_public_key()) + .map_err(anyhow::Error::msg)?; + for decision in [round.decision(), prior.decision()] { + ensure!( + decision + .attempts + .iter() + .any(|a| a.job_id == guard.original.permit().job_id + && a.attempt_id == guard.original.permit().attempt_id + && a.update_inflight.as_ref() == Some(&expected) + && !a.unlock), + "UPDATE_PRE_STOP_ORIGINAL_ACK_REQUIRED" + ); + } + let proof_bytes = proof.bytes().map_err(anyhow::Error::msg)?; + ensure!( + decoded + .attempts + .iter() + .any(|a| a.job_id == guard.original.permit().job_id.to_string() + && a.attempt_id == guard.original.permit().attempt_id.to_string() + && a.update_handoff_bytes == proof_bytes), + "UPDATE_PRE_STOP_ORIGINAL_REQUEST_REQUIRED" + ); + guard.check(db)?; + Ok(Some((request, response))) +} +impl Guard<'_, '_> { + fn finalize(&self, db: &mut Connection) -> Result> { + self.effects(db)?; + let grant = self.original.permit().grant_id; + let journal = core::read(db, self, grant)?; + let raw:Vec=db.query_row("SELECT event FROM agent_update_handoff_events WHERE grant_id=?1 ORDER BY sequence DESC LIMIT 1", + [grant.to_string()],|r|r.get(0))?; + ensure!( + hash(&raw) == journal.head_sha256(), + "UPDATE_STORED_HEALTH_HEAD_CHANGED" + ); + let event: Event = serde_json::from_slice(&raw)?; + let signed = match &event.evidence { + Evidence::HealthVerified { receipt } if self.participant == Participant::NewHelper => { + receipt + } + Evidence::RollbackHealthVerified { receipt } + if self.participant == Participant::RestoredHelper => + { + receipt + } + _ => anyhow::bail!("UPDATE_ORIGINAL_STORED_HEALTH_REQUIRED"), + }; + self.verify_health(db, signed)?; + let health_sha256 = hash(&serde_json::to_vec(signed)?); + if self.participant == Participant::RestoredHelper { + self.trust.recheck_protected()?; + let outcome = rmm_agent_core::auth::Outcome { + state: "failed".into(), + stdout: vec![], + stderr: vec![], + exit_code: None, + output_truncated: false, + reboot_required: false, + error_code: "AGENT_UPDATE_RETURNED_TO_PREDECESSOR".into(), + evidence: serde_json::json!({"postconditions_passed":false,"previous_boot_id":self.original.handoff().boot_id, + "agent_update":{"schema_version":2,"handoff_sha256":journal.handoff_sha256(), + "manifest_sha256":self.original.handoff().target.manifest_sha256, + "predecessor_record_sha256":self.original.handoff().predecessor_record_sha256, + "installed_record_sha256":self.original.handoff().predecessor_record_sha256, + "signed_health_sha256":health_sha256,"rolled_back":true}}), + }; + core::finalize_rollback( + db, + self, + self.original.permit(), + journal.head_sha256(), + u64::try_from(self.clock.reading()?.upper.timestamp())?, + &outcome, + )?; + } else { + let built = crate::update_record::BuiltRecord::build( + &self.original, + self.trust.installed_raw(), + &journal, + &raw, + )?; + let namespace = crate::update_record::Transition::prepare(built)?; + ensure!( + self.publication + .try_borrow_mut()? + .replace(namespace) + .is_none(), + "UPDATE_RECORD_NO_RESUME" + ); + for index in 0..2 { + let effect = self + .publication + .try_borrow()? + .as_ref() + .context("UPDATE_RECORD_NAMESPACE_REQUIRED")? + .effect()?; + let claim = core::claim_native_effect( + db, + self, + grant, + journal.head_sha256(), + &effect, + self.clock.reading()?.upper, + )?; + if index == 0 { + let new_sha256 = self + .publication + .try_borrow()? + .as_ref() + .context("UPDATE_RECORD_NAMESPACE_REQUIRED")? + .built() + .sha256() + .to_owned(); + self.trust.release_installed_pin(&claim, &new_sha256)?; + } + self.publication + .try_borrow_mut()? + .as_mut() + .context("UPDATE_RECORD_NAMESPACE_REQUIRED")? + .apply(&claim)?; + let observation = self + .publication + .try_borrow()? + .as_ref() + .context("UPDATE_RECORD_NAMESPACE_REQUIRED")? + .observation()?; + core::observe_native_effect( + db, + self, + &claim, + &observation, + self.clock.reading()?.upper, + )?; + } + let (record_sha256, floor) = { + let namespace = self.publication.try_borrow()?; + let namespace = namespace + .as_ref() + .context("UPDATE_RECORD_NAMESPACE_REQUIRED")?; + namespace.published()?; + ( + namespace.built().sha256().to_owned(), + namespace.built().record().activation_floor, + ) + }; + let outcome = rmm_agent_core::auth::Outcome { + state: "succeeded".into(), + stdout: vec![], + stderr: vec![], + exit_code: Some(0), + output_truncated: false, + reboot_required: false, + error_code: String::new(), + evidence: serde_json::json!({"postconditions_passed":true,"previous_boot_id":self.original.handoff().boot_id, + "agent_update":{"schema_version":2,"handoff_sha256":journal.handoff_sha256(), + "manifest_sha256":self.original.handoff().target.manifest_sha256, + "predecessor_record_sha256":self.original.handoff().predecessor_record_sha256, + "installed_record_sha256":record_sha256,"signed_health_sha256":health_sha256,"activation_floor":floor,"rolled_back":false}}), + }; + core::finalize( + db, + self, + self.original.permit(), + journal.head_sha256(), + u64::try_from(self.clock.reading()?.upper.timestamp())?, + &outcome, + )?; + } + db.query_row( + "SELECT outcome FROM execution_evidence WHERE grant_id=?1", + [grant.to_string()], + |r| r.get(0), + ) + .map_err(Into::into) + } +} +/// This guard can persist uncertainty only. It cannot qualify native effects, +/// success, health, lease, rollback or a replacement original. +struct UnknownGuard<'a> { + ledger: &'a LedgerGuard, + original: Original, + helper: RefCell, + sqlite: usize, +} +impl ExecutorLedgerGuard for UnknownGuard<'_> { + fn check(&self, db: &Connection) -> Result<()> { + self.ledger.check(db)?; + self.helper.try_borrow_mut()?.check()?; + ensure!( + unsafe { db.handle() } as usize == self.sqlite + && self.ledger.update_identity(db)?.sha256()? + == self.original.handoff().ledger_identity_sha256, + "UPDATE_UNKNOWN_ORIGINAL_LEDGER_REQUIRED" + ); + let (record,start):(Vec,Vec)=db.query_row( + "SELECT h.record,e.start FROM agent_update_handoffs h JOIN execution_evidence e USING(grant_id) WHERE h.grant_id=?1", + [self.original.permit().grant_id.to_string()],|r|Ok((r.get(0)?,r.get(1)?)))?; + ensure!( + record == self.original.handoff().bytes()? && start == self.original.start_bytes(), + "UPDATE_UNKNOWN_ORIGINAL_CHANGED" + ); + Ok(()) + } +} +impl UpdateParticipantGuard for UnknownGuard<'_> { + fn participant(&self) -> Participant { + Participant::Observer + } + fn verify_update_event(&self, h: &Handoff, d: &UpdateDelegation, event: &Event) -> Result<()> { + ensure!( + matches!(event.evidence, Evidence::Unknown { .. }) + && h.bytes()? == self.original.handoff().bytes()? + && d == self.original.delegation() + && crate::update_state::Uncertain::read(h, d)?, + "UPDATE_UNKNOWN_ONLY_ORIGINAL_REPORT" + ); + self.helper.try_borrow_mut()?.check() + } +} +pub(crate) fn observe_worker_unknown(ctx: UpdateContext<'_>) -> Result { + let Some(grant) = active_grant(ctx.db)? else { + return Ok(false); + }; + ctx.guard.check(ctx.db)?; + let (record,start):(Vec,Vec)=ctx.db.query_row( + "SELECT h.record,e.start FROM agent_update_handoffs h JOIN execution_evidence e USING(grant_id) WHERE h.grant_id=?1", + [grant.to_string()],|r|Ok((r.get(0)?,r.get(1)?)))?; + let delegation = core::read_delegation(ctx.db, grant)?; + let header: Handoff = serde_json::from_slice(&record)?; + if !crate::update_state::Uncertain::read(&header, &delegation)? { + return Ok(false); + } + let original = Original::verify_retained(ctx.binding, &start, &record, delegation)?; + let helper = PeerProof::for_service(&ctx.pin.helper, std::process::id())?; + ensure!( + helper.identity().image_sha256 == header.predecessor.helper_sha256 + || helper.identity().image_sha256 == header.target.helper_sha256, + "UPDATE_UNKNOWN_QUALIFIED_HELPER_IMAGE_REQUIRED" + ); + let guard = UnknownGuard { + ledger: ctx.guard, + original, + helper: RefCell::new(helper), + sqlite: unsafe { ctx.db.handle() } as usize, + }; + let journal = core::read(ctx.db, &guard, grant)?; + // Never rewrite a known outcome, including a successful Finalize whose + // receipt the worker could not observe. Already persisted bytes win. + let outcome: Option> = ctx.db.query_row( + "SELECT outcome FROM execution_evidence WHERE grant_id=?1", + [grant.to_string()], + |r| r.get(0), + )?; + if outcome.is_some() { + return Ok(false); + } + let observed = ctx + .clock + .reading() + .map(|r| r.upper) + .unwrap_or_else(|_| chrono::Utc::now()); + // When time is unqualified this is only an observed wall timestamp on an + // Unknown event, never time evidence or permission. Kernel chronology must + // still accept it; no invented/backdated maximum or new deadline is used. + core::mark_unknown( + ctx.db, + &guard, + guard.original.permit(), + journal.head_sha256(), + u64::try_from(observed.timestamp())?, + rmm_updater_handoff::UnknownReason::StateChanged, + )?; + if let Some(sync) = ctx.sync { + sync.close(); + } + Ok(true) +} diff --git a/crates/agent-windows/src/update_control_ipc.rs b/crates/agent-windows/src/update_control_ipc.rs new file mode 100644 index 0000000..783d7d4 --- /dev/null +++ b/crates/agent-windows/src/update_control_ipc.rs @@ -0,0 +1,301 @@ +//! Reverse stable-updater -> SYSTEM-helper control. A distinct fixed endpoint +//! never broadens the LocalService pipe into an updater effect API. Native +//! control still requires the ORIGINAL guarded journal and phase-specific proof. +use crate::{ + helper_ipc::{self as ipc, PeerProof}, + update_ipc::Pin, +}; +use anyhow::{Result, ensure}; +use rmm_agent_core::update_handoff::{ + NativeControlOperation, NativeControlReply, NativeControlRequest, NativeService, +}; +use std::{ + mem::size_of, + os::windows::io::{AsRawHandle, OwnedHandle}, + ptr, + time::{Duration, Instant}, +}; +use windows_sys::Win32::{ + Foundation::*, + Security::*, + Storage::FileSystem::*, + System::{Pipes::*, Threading::*}, +}; +pub const PIPE: &str = r"\\.\pipe\RustDiscovery-System-Update-v1"; +fn request_valid(pin: &Pin, r: &NativeControlRequest) -> Result<()> { + ensure!( + r.operation == "agent_update_control_v1" + && r.schema_version == 1 + && !r.challenge.is_nil() + && r.tenant_id == pin.binding.tenant_id + && r.asset_id == pin.binding.asset_id + && r.agent_id == pin.binding.agent_id + && r.enrollment_generation == pin.binding.enrollment_generation + && r.assignment_version == pin.binding.assignment_version + && !r.grant_id.is_nil() + && !r.owner_nonce.is_nil() + && ipc::digest(&r.handoff_sha256), + "UPDATE_CONTROL_REQUEST_BINDING" + ); + match &r.method { + NativeControlOperation::ClaimStop { + expected_head_sha256, + service, + } => ensure!( + ipc::digest(expected_head_sha256) + && matches!( + service, + NativeService::WindowsAgent | NativeService::WindowsHelper + ), + "UPDATE_CONTROL_WINDOWS_STOP_ONLY" + ), + NativeControlOperation::Health { receipt } => ensure!( + !receipt.payload.is_empty() + && receipt.payload.len() <= 4096 + && receipt.signature.len() == 64, + "UPDATE_CONTROL_HEALTH_LIMIT" + ), + NativeControlOperation::ObserveStarts { + services, + observation_sha256, + } => ensure!( + services.len() == 2 && ipc::digest(observation_sha256), + "UPDATE_CONTROL_START_LIMIT" + ), + NativeControlOperation::ReadOriginal | NativeControlOperation::Finalize => {} + } + Ok(()) +} +fn reply_valid(r: &NativeControlRequest, v: &NativeControlReply) -> Result<()> { + ensure!( + v.schema_version == 1 + && v.challenge == r.challenge + && v.tenant_id == r.tenant_id + && v.asset_id == r.asset_id + && v.agent_id == r.agent_id + && v.enrollment_generation == r.enrollment_generation + && v.assignment_version == r.assignment_version + && v.grant_id == r.grant_id + && v.owner_nonce == r.owner_nonce + && v.handoff_sha256 == r.handoff_sha256 + && !v.ready, + "UPDATE_CONTROL_REPLY_BINDING" + ); + if let Some(proof) = &v.proof { + ensure!( + proof.delegation.owner_nonce == r.owner_nonce + && proof.delegation.handoff_sha256 == r.handoff_sha256, + "UPDATE_CONTROL_PROOF_BINDING" + ); + } + ensure!( + v.original_start_base64url + .as_ref() + .is_none_or(|s| s.len() <= 699051) + && v.original_outcome_base64url + .as_ref() + .is_none_or(|s| s.len() <= 699051), + "UPDATE_CONTROL_REPLY_LIMIT" + ); + match ( + &v.pre_stop_sync_request_base64url, + &v.pre_stop_sync_response_base64url, + ) { + (None, None) => {} + (Some(request), Some(response)) => { + use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD}; + ensure!( + matches!(r.method, NativeControlOperation::ReadOriginal) + && request.len() <= 699051 + && response.len() <= 699051, + "UPDATE_CONTROL_PRESTOP_SCOPE_LIMIT" + ); + for raw in [request, response] { + let decoded = URL_SAFE_NO_PAD.decode(raw)?; + ensure!( + !decoded.is_empty() + && decoded.len() <= 512 * 1024 + && URL_SAFE_NO_PAD.encode(&decoded) == *raw, + "UPDATE_CONTROL_PRESTOP_CANONICAL" + ); + } + } + _ => anyhow::bail!("UPDATE_CONTROL_PRESTOP_PAIR_REQUIRED"), + } + match &r.method { + NativeControlOperation::ReadOriginal => ensure!( + v.original_start_base64url.is_some() + && v.original_outcome_base64url.is_none() + && v.claim.is_none(), + "UPDATE_CONTROL_READ_REPLY" + ), + NativeControlOperation::ClaimStop { .. } => ensure!( + v.claim.is_some() + && v.original_start_base64url.is_none() + && v.original_outcome_base64url.is_none(), + "UPDATE_CONTROL_CLAIM_REPLY" + ), + NativeControlOperation::ObserveStarts { .. } | NativeControlOperation::Health { .. } => { + ensure!( + v.original_start_base64url.is_none() + && v.original_outcome_base64url.is_none() + && v.claim.is_none(), + "UPDATE_CONTROL_PHASE_REPLY" + ) + } + NativeControlOperation::Finalize => ensure!( + v.original_start_base64url.is_none() && v.claim.is_none(), + "UPDATE_CONTROL_FINAL_REPLY" + ), + } + Ok(()) +} +pub trait Engine { + fn handle( + &mut self, + peer: &mut PeerProof, + request: &NativeControlRequest, + ) -> Result; +} +pub struct Server { + pin: Pin, + pipe: OwnedHandle, +} +pub struct Received { + pub request: NativeControlRequest, + pub peer: PeerProof, +} +impl Server { + pub fn bind(pin: Pin) -> Result { + pin.validate()?; + ipc::require_self(&pin.helper)?; + let d = ipc::Descriptor::from(&format!( + "O:SYG:SYD:P(D;;GA;;;NU)(A;;GA;;;SY)(A;;GA;;;BA)(A;;GA;;;{})(A;;0x{:08x};;;{})", + pin.helper.service_sid, + ipc::CLIENT_PIPE_RIGHTS, + pin.updater.service_sid + ))?; + let sa = SECURITY_ATTRIBUTES { + nLength: size_of::() as u32, + lpSecurityDescriptor: d.0, + bInheritHandle: 0, + }; + let pipe = ipc::owned(unsafe { + CreateNamedPipeW( + ipc::wide(PIPE).as_ptr(), + PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED | FILE_FLAG_FIRST_PIPE_INSTANCE, + PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT | PIPE_REJECT_REMOTE_CLIENTS, + 1, + 65536, + 65536, + 1000, + &sa, + ) + })?; + Ok(Self { pin, pipe }) + } + pub fn receive(&self) -> Result> { + ipc::require_self(&self.pin.helper)?; + let pipe = self.pipe.as_raw_handle(); + let mut event = ipc::IoEvent::new()?; + if unsafe { ConnectNamedPipe(pipe, &mut event.overlapped) } == 0 { + let error = unsafe { GetLastError() }; + if error == ERROR_IO_PENDING { + if let Err(e) = event.wait(pipe, Instant::now() + Duration::from_millis(25)) { + if ipc::diagnostic(&e).code == "HELPER_PIPE_TIMEOUT" { + self.disconnect(); + return Ok(None); + } + return Err(e); + } + } else { + ensure!(error == ERROR_PIPE_CONNECTED, "UPDATE_CONTROL_CONNECT"); + } + } + let deadline = Instant::now() + Duration::from_secs(5); + let len = ipc::length(pipe, deadline)?; + let mut peer = PeerProof::capture(pipe, &self.pin.updater, true)?; + ensure!( + unsafe { ImpersonateNamedPipeClient(pipe) } != 0, + "UPDATE_CONTROL_IMPERSONATE" + ); + let auth = (|| -> Result<()> { + let mut token = ptr::null_mut(); + ensure!( + unsafe { OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, 1, &mut token) } != 0, + "UPDATE_CONTROL_THREAD_TOKEN" + ); + let token = ipc::owned(token)?; + ipc::verify_token( + token.as_raw_handle(), + &self.pin.updater.user_sid, + &self.pin.updater.service_sid, + ) + })(); + if unsafe { RevertToSelf() } == 0 { + std::process::abort(); + } + auth?; + ipc::require_self(&self.pin.helper)?; + let request: NativeControlRequest = ipc::body(pipe, len, deadline)?; + request_valid(&self.pin, &request)?; + peer.check()?; + Ok(Some(Received { request, peer })) + } + pub fn reply(&self, received: &mut Received, reply: &NativeControlReply) -> Result<()> { + reply_valid(&received.request, reply)?; + received.peer.check()?; + let mut raw = ipc::encode(reply)?; + let deadline = Instant::now() + Duration::from_secs(5); + ipc::send_bytes(self.pipe.as_raw_handle(), &mut raw, deadline)?; + let mut receipt = [0; ipc::DRAIN_RECEIPT_LEN]; + ipc::transfer(self.pipe.as_raw_handle(), &mut receipt, false, deadline)?; + ipc::verify_drain_receipt(&receipt, received.request.challenge, &raw)?; + received.peer.check() + } + pub fn serve_one(&self, engine: &mut impl Engine) -> Result { + let result = (|| -> Result { + let Some(mut received) = self.receive()? else { + return Ok(false); + }; + let reply = engine.handle(&mut received.peer, &received.request)?; + self.reply(&mut received, &reply)?; + Ok(true) + })(); + self.disconnect(); + result + } + pub fn disconnect(&self) { + unsafe { + DisconnectNamedPipe(self.pipe.as_raw_handle()); + } + } +} +/// One original request, no reconnect/retry of a possibly committed claim. +pub fn exchange(pin: &Pin, request: &NativeControlRequest) -> Result { + pin.validate()?; + request_valid(pin, request)?; + ipc::require_self(&pin.updater)?; + let pipe = ipc::owned(unsafe { + CreateFileW( + ipc::wide(PIPE).as_ptr(), + ipc::CLIENT_PIPE_RIGHTS, + 0, + ptr::null(), + OPEN_EXISTING, + FILE_FLAG_OVERLAPPED | SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION, + ptr::null_mut(), + ) + })?; + let mut peer = PeerProof::capture(pipe.as_raw_handle(), &pin.helper, false)?; + let deadline = Instant::now() + Duration::from_secs(5); + ipc::send(pipe.as_raw_handle(), request, deadline)?; + let length = ipc::length(pipe.as_raw_handle(), deadline)?; + let raw = ipc::body_bytes(pipe.as_raw_handle(), length, deadline)?; + let reply: NativeControlReply = serde_json::from_slice(&raw)?; + reply_valid(request, &reply)?; + peer.check()?; + let mut receipt = ipc::drain_receipt(request.challenge, &raw); + ipc::transfer(pipe.as_raw_handle(), &mut receipt, true, deadline)?; + Ok(reply) +} diff --git a/crates/agent-windows/src/update_download.rs b/crates/agent-windows/src/update_download.rs new file mode 100644 index 0000000..6eb40f3 --- /dev/null +++ b/crates/agent-windows/src/update_download.rs @@ -0,0 +1,111 @@ +//! mTLS public artifact prefetch for an already approved JobOffer. This runs +//! before the sixty-second startgrant, on its own task and bounded disk lanes. +use anyhow::{Result, ensure}; +use reqwest::{Client, StatusCode}; +use rmm_agent_windows::update_cache::{self, Download}; +use rmm_domain::{ + agent_update::ReleaseManifest, + jobs::JobPayload, +}; +use std::time::{Duration, Instant}; +const CHUNK: u64 = 512 * 1024; +fn metadata( + response: &reqwest::Response, + a: &rmm_domain::agent_update::ArtifactDescriptor, + offset: u64, + length: u64, +) -> Result<()> { + let partial = offset != 0 || length != a.bytes; + ensure!( + response.status() + == if partial { + StatusCode::PARTIAL_CONTENT + } else { + StatusCode::OK + }, + "UPDATE_DOWNLOAD_STATUS" + ); + let h = response.headers(); + ensure!( + h.get("x-artifact-sha256").and_then(|v| v.to_str().ok()) == Some(a.sha256.as_str()) + && h.get("content-type").and_then(|v| v.to_str().ok()) + == Some("application/octet-stream") + && !h.contains_key("content-encoding") + && h.get("content-length") + .and_then(|v| v.to_str().ok()) + .and_then(|v| v.parse::().ok()) + == Some(length), + "UPDATE_DOWNLOAD_METADATA" + ); + if partial { + ensure!( + h.get("content-range").and_then(|v| v.to_str().ok()) + == Some(format!("bytes {}-{}/{}", offset, offset + length - 1, a.bytes).as_str()), + "UPDATE_DOWNLOAD_RANGE" + ); + } else { + ensure!(!h.contains_key("content-range"), "UPDATE_DOWNLOAD_RANGE"); + } + Ok(()) +} +pub async fn prefetch( + client: Client, + base: String, + job: JobPayload, + manifest: ReleaseManifest, + guard: impl Fn() -> Result<()> + Send + 'static, +) -> Result<()> { + ensure!( + manifest.validate() && manifest.platform == rmm_agent_windows::release_platform::WIRE, + "UPDATE_DOWNLOAD_MANIFEST" + ); + let deadline = Instant::now() + Duration::from_secs(600); + for artifact in manifest.artifacts { + guard()?; + let descriptor = artifact.clone(); + let exists = tokio::task::spawn_blocking(move || -> Result { + if update_cache::Source::open(&descriptor).is_ok() { + Ok(true) + } else { + Ok(false) + } + }) + .await??; + if exists { + continue; + } + let descriptor = artifact.clone(); + let mut stage = tokio::task::spawn_blocking(move || Download::begin(&descriptor)).await??; + while stage.offset() < artifact.bytes { + guard()?; + ensure!(Instant::now() < deadline, "UPDATE_DOWNLOAD_DEADLINE"); + let offset = stage.offset(); + let length = CHUNK.min(artifact.bytes - offset); + let mut response=client.get(format!("{base}/agent/v1/update-artifacts/{}?job_id={}&attempt_id={}&offset={offset}&length={length}",artifact.artifact_id,job.job_id,job.attempt_id)).send().await?; + metadata(&response, &artifact, offset, length)?; + let mut bytes = Vec::with_capacity(length as usize); + while let Some(chunk) = response.chunk().await? { + ensure!( + bytes.len() + chunk.len() <= length as usize, + "UPDATE_DOWNLOAD_BODY_LIMIT" + ); + bytes.extend_from_slice(&chunk); + } + ensure!( + bytes.len() == length as usize, + "UPDATE_DOWNLOAD_BODY_LENGTH" + ); + guard()?; + ensure!(Instant::now() < deadline, "UPDATE_DOWNLOAD_DEADLINE"); + stage = tokio::task::spawn_blocking(move || -> Result { + stage.append(offset, &bytes)?; + Ok(stage) + }) + .await??; + } + guard()?; + tokio::task::spawn_blocking(move || stage.finish()).await??; + } + guard()?; + Ok(()) +} diff --git a/crates/agent-windows/src/update_ipc.rs b/crates/agent-windows/src/update_ipc.rs new file mode 100644 index 0000000..c52ca0f --- /dev/null +++ b/crates/agent-windows/src/update_ipc.rs @@ -0,0 +1,419 @@ +//! Stable updater channel, separate from the LocalService agent channel. +//! Mutually pinned service identity is checked before decoding a bounded call. +//! An Activate is never retried by the transport. A response is not readiness. +use crate::helper_ipc::{self as ipc, PeerPin, PeerProof}; +use anyhow::{Context, Result, ensure}; +use rmm_agent_core::auth::Binding; +use rmm_domain::{ + agent_update::{ParticipantIdentity, ParticipantRole}, + jobs::hash, +}; +use serde::{Deserialize, Serialize}; +use std::{ + mem::size_of, + os::windows::io::{AsRawHandle, OwnedHandle}, + path::Path, + ptr, + time::{Duration, Instant}, +}; +use uuid::Uuid; +use windows_sys::Win32::{ + Foundation::*, + Security::*, + Storage::FileSystem::*, + System::{Pipes::*, Threading::*}, +}; + +pub const SERVICE: &str = "RmmDiscoveryUpdater"; +pub const BINARY: &str = r"C:\Program Files\RustDiscovery\rmm-updater-windows.exe"; +pub const PIPE: &str = r"\\.\pipe\RustDiscovery-Updater-v1"; +const LIMIT: usize = 32768; +#[derive(Clone, Debug, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct Pin { + pub schema_version: u32, + pub binding: Binding, + pub policy_sha256: String, + pub helper: PeerPin, + pub updater: PeerPin, +} +impl Pin { + pub fn validate(&self) -> Result<()> { + ensure!( + self.schema_version == 1 && ipc::digest(&self.policy_sha256), + "UPDATE_IPC_PIN" + ); + self.helper.validate(true)?; + ensure!( + self.updater.service_name == SERVICE + && self.updater.service_sid == ipc::service_sid(SERVICE)? + && self.updater.user_sid == "S-1-5-18" + && self.updater.binary == Path::new(BINARY) + && ipc::digest(&self.updater.binary_sha256), + "UPDATE_IPC_UPDATER_PIN" + ); + ensure!( + !self.binding.agent_id.is_nil() + && !self.binding.asset_id.is_nil() + && !self.binding.tenant_id.is_nil() + && self.binding.enrollment_generation > 0 + && self.binding.assignment_version > 0, + "UPDATE_IPC_BINDING" + ); + Ok(()) + } +} +#[derive(Clone, Debug, Serialize, Deserialize)] +#[serde(tag = "method", rename_all = "snake_case", deny_unknown_fields)] +pub enum Request { + Describe {}, + Activate { + grant_id: Uuid, + owner_nonce: Uuid, + handoff_sha256: String, + }, + Read { + grant_id: Uuid, + owner_nonce: Uuid, + handoff_sha256: String, + }, + Health { + grant_id: Uuid, + owner_nonce: Uuid, + handoff_sha256: String, + payload_base64url: String, + signature_base64url: String, + }, +} +impl Request { + pub fn validate(&self) -> Result<()> { + match self { + Self::Describe {} => {} + Self::Activate { + grant_id, + owner_nonce, + handoff_sha256, + } + | Self::Read { + grant_id, + owner_nonce, + handoff_sha256, + } + | Self::Health { + grant_id, + owner_nonce, + handoff_sha256, + .. + } => { + ensure!( + !grant_id.is_nil() && !owner_nonce.is_nil() && ipc::digest(handoff_sha256), + "UPDATE_IPC_ORIGINAL_BINDING" + ); + if let Self::Health { + payload_base64url, + signature_base64url, + .. + } = self + { + ensure!( + !payload_base64url.is_empty() + && payload_base64url.len() <= 21846 + && signature_base64url.len() == 86 + && payload_base64url + .bytes() + .chain(signature_base64url.bytes()) + .all(|b| b.is_ascii_alphanumeric() || b"-_".contains(&b)), + "UPDATE_IPC_HEALTH_LIMIT" + ); + } + } + } + Ok(()) + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum State { + Described, + Inflight, + OutcomePersisted, + Unknown, + NotConfigured, +} +#[derive(Clone, Debug, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct Response { + pub schema_version: u32, + pub state: State, + pub ready: bool, + pub updater: ParticipantIdentity, + pub head_sha256: Option, +} +impl Response { + fn validate(&self) -> Result<()> { + ensure!( + self.schema_version == 1 + && !self.ready + && self.updater.validate() + && self.updater.role == ParticipantRole::WindowsUpdater + && self.head_sha256.as_ref().is_none_or(|v| ipc::digest(v)), + "UPDATE_IPC_RESPONSE" + ); + Ok(()) + } +} +#[derive(Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct Call { + schema_version: u32, + challenge: Uuid, + binding_sha256: String, + policy_sha256: String, + request: Request, +} +#[derive(Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct Reply { + schema_version: u32, + challenge: Uuid, + binding_sha256: String, + policy_sha256: String, + response: Response, +} +/// The instance digest covers the pinned SCM command and held live process, +/// including image file identity and service SID, rather than PID alone. +pub fn participant(peer: &PeerProof, role: ParticipantRole) -> Result { + ensure!( + matches!( + role, + ParticipantRole::WindowsHelper | ParticipantRole::WindowsUpdater + ), + "UPDATE_IPC_PARTICIPANT_ROLE" + ); + let p = peer.identity(); + let expected = if role == ParticipantRole::WindowsHelper { + ipc::HELPER_SERVICE + } else { + SERVICE + }; + ensure!( + p.user_sid == "S-1-5-18" && p.service_sid == ipc::service_sid(expected)?, + "UPDATE_IPC_PARTICIPANT_SID" + ); + let value = ParticipantIdentity { + role, + pid: p.pid, + birth: p.creation_ticks, + image_sha256: p.image_sha256.clone(), + security_principal: p.user_sid.clone(), + service_instance_sha256: hash(&serde_json::to_vec(p)?), + }; + ensure!(value.validate(), "UPDATE_IPC_PARTICIPANT"); + Ok(value) +} +pub fn observe(pin: &PeerPin, role: ParticipantRole) -> Result<(PeerProof, ParticipantIdentity)> { + let mut proof = PeerProof::for_service(pin, ipc::service_status(pin)?)?; + proof.check()?; + let value = participant(&proof, role)?; + Ok((proof, value)) +} +/// Caller implements all original-ledger, retained-state, clock and one-pass +/// checks. This transport has no default handler or automatic startup replay. +pub trait Engine { + fn handle(&mut self, peer: &ParticipantIdentity, request: Request) -> Result; +} +pub struct Server { + pipe: OwnedHandle, + pin: Pin, +} +impl Server { + pub fn bind(pin: Pin) -> Result { + pin.validate()?; + ipc::require_self(&pin.updater)?; + let descriptor = ipc::Descriptor::from(&format!( + "O:SYG:SYD:P(D;;GA;;;NU)(A;;GA;;;SY)(A;;GA;;;BA)(A;;GA;;;{})(A;;0x{:08x};;;{})", + pin.updater.service_sid, + ipc::CLIENT_PIPE_RIGHTS, + pin.helper.service_sid + ))?; + let sa = SECURITY_ATTRIBUTES { + nLength: size_of::() as u32, + lpSecurityDescriptor: descriptor.0, + bInheritHandle: 0, + }; + let pipe = ipc::owned(unsafe { + CreateNamedPipeW( + ipc::wide(PIPE).as_ptr(), + PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED | FILE_FLAG_FIRST_PIPE_INSTANCE, + PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT | PIPE_REJECT_REMOTE_CLIENTS, + 1, + LIMIT as u32, + LIMIT as u32, + 1000, + &sa, + ) + })?; + Ok(Self { pipe, pin }) + } + pub fn serve_one(&self, engine: &mut impl Engine) -> Result { + let result = self.serve_connected(engine); + unsafe { + DisconnectNamedPipe(self.pipe.as_raw_handle()); + } + result + } + fn serve_connected(&self, engine: &mut impl Engine) -> Result { + ipc::require_self(&self.pin.updater)?; + let pipe = self.pipe.as_raw_handle(); + let mut event = ipc::IoEvent::new()?; + if unsafe { ConnectNamedPipe(pipe, &mut event.overlapped) } == 0 { + let error = unsafe { GetLastError() }; + if error == ERROR_IO_PENDING { + if let Err(e) = event.wait(pipe, Instant::now() + Duration::from_millis(250)) { + if ipc::diagnostic(&e).code == "HELPER_PIPE_TIMEOUT" { + return Ok(false); + } + return Err(e); + } + } else { + ensure!(error == ERROR_PIPE_CONNECTED, "UPDATE_IPC_CONNECT"); + } + } + let deadline = Instant::now() + Duration::from_secs(5); + let len = ipc::length(pipe, deadline)?; + ensure!(len <= LIMIT, "UPDATE_IPC_FRAME_LIMIT"); + let mut peer = PeerProof::capture(pipe, &self.pin.helper, true)?; + ensure!( + unsafe { ImpersonateNamedPipeClient(pipe) } != 0, + "UPDATE_IPC_IMPERSONATE" + ); + let auth = (|| -> Result<()> { + let mut token = ptr::null_mut(); + ensure!( + unsafe { OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, 1, &mut token) } != 0, + "UPDATE_IPC_THREAD_TOKEN" + ); + let token = ipc::owned(token)?; + ipc::verify_token( + token.as_raw_handle(), + &self.pin.helper.user_sid, + &self.pin.helper.service_sid, + ) + })(); + if unsafe { RevertToSelf() } == 0 { + std::process::abort(); + } + auth?; + ipc::require_self(&self.pin.updater)?; + let call: Call = ipc::body(pipe, len, deadline)?; + ensure!( + call.schema_version == 1 + && !call.challenge.is_nil() + && call.binding_sha256 == ipc::binding_hash(&self.pin.binding)? + && call.policy_sha256 == self.pin.policy_sha256, + "UPDATE_IPC_CALL_BINDING" + ); + call.request.validate()?; + peer.check()?; + let response = engine.handle( + &participant(&peer, ParticipantRole::WindowsHelper)?, + call.request, + )?; + response.validate()?; + let (_own, own) = observe(&self.pin.updater, ParticipantRole::WindowsUpdater)?; + ensure!(response.updater == own, "UPDATE_IPC_SELF_RESPONSE"); + let reply = Reply { + schema_version: 1, + challenge: call.challenge, + binding_sha256: call.binding_sha256, + policy_sha256: call.policy_sha256, + response, + }; + let mut bytes = ipc::encode(&reply)?; + ensure!(bytes.len() <= LIMIT, "UPDATE_IPC_REPLY_LIMIT"); + peer.check()?; + let deadline = Instant::now() + Duration::from_secs(5); + ipc::send_bytes(pipe, &mut bytes, deadline)?; + let mut receipt = [0; ipc::DRAIN_RECEIPT_LEN]; + ipc::transfer(pipe, &mut receipt, false, deadline)?; + ipc::verify_drain_receipt(&receipt, reply.challenge, &bytes)?; + peer.check()?; + Ok(true) + } +} +/// Bounded blocking lane only. Every failure propagates; no Activate retry. +pub fn exchange(pin: &Pin, request: &Request, timeout: Duration) -> Result { + pin.validate()?; + request.validate()?; + ipc::require_self(&pin.helper)?; + ensure!( + (Duration::from_secs(1)..=Duration::from_secs(30)).contains(&timeout), + "UPDATE_IPC_TIMEOUT" + ); + let deadline = Instant::now() + timeout; + let pipe = ipc::owned(unsafe { + CreateFileW( + ipc::wide(PIPE).as_ptr(), + ipc::CLIENT_PIPE_RIGHTS, + 0, + ptr::null(), + OPEN_EXISTING, + FILE_FLAG_OVERLAPPED | SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION, + ptr::null_mut(), + ) + }) + .context("UPDATE_IPC_UNAVAILABLE")?; + let mut peer = PeerProof::capture(pipe.as_raw_handle(), &pin.updater, false)?; + let expected = participant(&peer, ParticipantRole::WindowsUpdater)?; + let call = Call { + schema_version: 1, + challenge: Uuid::new_v4(), + binding_sha256: ipc::binding_hash(&pin.binding)?, + policy_sha256: pin.policy_sha256.clone(), + request: request.clone(), + }; + let raw = ipc::encode(&call)?; + ensure!(raw.len() <= LIMIT, "UPDATE_IPC_FRAME_LIMIT"); + ipc::send(pipe.as_raw_handle(), &call, deadline)?; + let len = ipc::length(pipe.as_raw_handle(), deadline)?; + ensure!(len <= LIMIT, "UPDATE_IPC_FRAME_LIMIT"); + let bytes = ipc::body_bytes(pipe.as_raw_handle(), len, deadline)?; + let reply: Reply = serde_json::from_slice(&bytes)?; + peer.check()?; + ensure!( + reply.schema_version == 1 + && reply.challenge == call.challenge + && reply.binding_sha256 == call.binding_sha256 + && reply.policy_sha256 == call.policy_sha256 + && reply.response.updater == expected, + "UPDATE_IPC_REPLY_BINDING" + ); + reply.response.validate()?; + let mut receipt = ipc::drain_receipt(call.challenge, &bytes); + ipc::transfer(pipe.as_raw_handle(), &mut receipt, true, deadline)?; + Ok(reply.response) +} +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn request_cannot_select_a_path_command_service_or_weak_original_binding() { + for raw in [ + r#"{"method":"activate","grant_id":"00000000-0000-0000-0000-000000000000","owner_nonce":"00000000-0000-0000-0000-000000000000","handoff_sha256":"00"}"#, + r#"{"method":"describe","path":"C:\\Windows\\cmd.exe"}"#, + r#"{"method":"prepare"}"#, + ] { + assert!( + serde_json::from_str::(raw) + .and_then(|r| r.validate().map_err(serde::de::Error::custom)) + .is_err() + ); + } + assert!( + serde_json::from_str::(r#"{"method":"describe"}"#) + .unwrap() + .validate() + .is_ok() + ); + } +} diff --git a/crates/agent-windows/src/update_native/control_fence.rs b/crates/agent-windows/src/update_native/control_fence.rs new file mode 100644 index 0000000..cb0a348 --- /dev/null +++ b/crates/agent-windows/src/update_native/control_fence.rs @@ -0,0 +1,417 @@ +//! Once-only native service fences. They consume committed ORIGINAL claims, +//! keep real live witnesses, and never open SQLite beside a running helper. +use super::{ + Budget, DurableEffectFence, Effect, Service, + services::{Proof, Stopped}, +}; +use crate::{ + helper_ipc::PeerProof, signed_clock::BoundClock, update_ipc, update_original::Original, + update_state::RetainedSet, update_trust::TrustState, +}; +use anyhow::{Result, ensure}; +use rmm_agent_core::{ + auth::Binding, + reconcile::SyncClock, + update_handoff::{NativeEffect, NativeEffectClaim, NativeService}, +}; +use rmm_domain::{ + agent_update::{ParticipantRole, UpdateInflightProof, verify_inflight_proof}, + jobs::hash, +}; +use rmm_updater_handoff::Phase; +use std::cell::RefCell; + +pub struct Context<'a, 'b> { + pub original: &'a Original, + pub binding: &'a Binding, + pub clock: &'a BoundClock, + pub budget: &'a Budget<'b>, + pub updater: &'a RefCell, + pub retained: &'a RetainedSet, + pub trust: &'a TrustState, +} +impl Context<'_, '_> { + fn check(&self) -> Result<()> { + self.original + .check_current(self.binding, self.clock, self.budget)?; + self.trust + .recheck_prepared(self.original.update(), self.clock)?; + self.retained.verify()?; + let mut updater = self.updater.try_borrow_mut()?; + updater.check()?; + ensure!( + update_ipc::participant(&updater, ParticipantRole::WindowsUpdater)? + == self.original.delegation().updater, + "UPDATE_ORIGINAL_UPDATER_PROCESS_CHANGED" + ); + let pin = super::services::updater_pin(self.trust.policy())?; + ensure!( + super::services::updater_configuration_sha256(&pin)? + == self.trust.policy().updater_service.unit_sha256, + "UPDATE_UPDATER_CONFIGURATION_CHANGED" + ); + Ok(()) + } +} +pub struct StopFence<'a, 'b> { + context: Context<'a, 'b>, + claims: [NativeEffectClaim; 2], + proofs: [Proof; 2], + next: usize, + pending: bool, + poisoned: bool, + observations: Vec, +} +/// No deserializer or public constructor: actual successful native stop +/// callbacks and the still-stopped SCM instances create this value. +pub struct StopObservations { + pub(crate) claims: [NativeEffectClaim; 2], + pub(crate) observations: [String; 2], + pub(crate) proofs: [Proof; 2], +} +impl<'a, 'b> StopFence<'a, 'b> { + pub fn new( + context: Context<'a, 'b>, + claims: [NativeEffectClaim; 2], + proofs: [Proof; 2], + proof: &UpdateInflightProof, + ) -> Result { + context.check()?; + let (header, journal) = verify_inflight_proof(proof, context.trust.health_public_key()) + .map_err(anyhow::Error::msg)?; + ensure!( + header.bytes()? == context.original.handoff().bytes()? + && proof.delegation == *context.original.delegation() + && journal.phase() == Phase::StopIntent, + "UPDATE_STOP_ORIGINAL_PREFIX_REQUIRED" + ); + for (index, claim) in claims.iter().enumerate() { + let service = [NativeService::WindowsAgent, NativeService::WindowsHelper][index]; + ensure!( + claim.grant_id() == header.attempt.grant_id + && claim.owner_nonce() == header.owner_nonce + && claim.head_sha256() == journal.head_sha256() + && claim.effect() == &NativeEffect::StopService { service } + && claim.claimed_at() >= context.original.delegation().prepared_at + && claim.claimed_at() <= context.clock.reading()?.upper, + "UPDATE_STOP_COMMITTED_ORIGINAL_CLAIM_REQUIRED" + ); + } + ensure!( + proofs[0].configuration.service == Service::Agent + && proofs[1].configuration.service == Service::Helper + && proofs[0].process.image_sha256 == header.predecessor.agent_sha256 + && proofs[1].process.image_sha256 == header.predecessor.helper_sha256, + "UPDATE_ORIGINAL_STOP_PROCESS_PROOFS_REQUIRED" + ); + Ok(Self { + context, + claims, + proofs, + next: 0, + pending: false, + poisoned: false, + observations: vec![], + }) + } + pub fn finish(self, stopped: &Stopped) -> Result { + self.context.check()?; + stopped.check(self.context.budget)?; + ensure!( + !self.pending && !self.poisoned && self.next == 2 && stopped.proofs() == self.proofs, + "UPDATE_STOP_NOT_FULLY_OBSERVED" + ); + Ok(StopObservations { + claims: self.claims, + observations: self + .observations + .try_into() + .map_err(|_| anyhow::anyhow!("UPDATE_STOP_OBSERVATIONS_REQUIRED"))?, + proofs: self.proofs, + }) + } +} +impl DurableEffectFence for StopFence<'_, '_> { + fn before_effect(&mut self, effect: &Effect) -> Result<()> { + ensure!( + !self.poisoned && !self.pending && self.next < 2, + "UPDATE_STOP_NO_RETRY" + ); + self.poisoned = true; + self.context.check()?; + ensure!( + *effect + == Effect::StopService { + service: [Service::Agent, Service::Helper][self.next] + }, + "UPDATE_STOP_CLOSED_SEQUENCE" + ); + self.pending = true; + Ok(()) + } + fn after_effect(&mut self, effect: &Effect, observation: &str) -> Result<()> { + ensure!( + self.poisoned + && self.pending + && self.next < 2 + && *effect + == Effect::StopService { + service: [Service::Agent, Service::Helper][self.next] + } + && observation == hash(&serde_json::to_vec(&self.proofs[self.next])?), + "UPDATE_STOP_ACTUAL_OBSERVATION_REQUIRED" + ); + self.context.check()?; + self.observations.push(observation.into()); + self.next += 1; + self.pending = false; + self.poisoned = false; + Ok(()) + } +} +/// Original reservations returned only after the guarded SQLite connection +/// closes. Holds no mutable connection beside the new helper. +pub struct PreparedStart { + claims: rmm_agent_core::update_handoff::PreparedReturnClaims<2>, + proof: UpdateInflightProof, +} +impl PreparedStart { + pub(crate) fn after_closed_connection( + claims: rmm_agent_core::update_handoff::PreparedReturnClaims<2>, + proof: UpdateInflightProof, + ) -> Self { + Self { claims, proof } + } + pub fn bind<'a, 'b>( + self, + context: Context<'a, 'b>, + released: crate::update_owned::ReleasedFiles, + bundle: &'a crate::update_state::Bundle, + ) -> Result> { + let result = StartFence { + context, + released, + bundle, + reservation: self, + next: 0, + pending: false, + poisoned: false, + }; + result.check()?; + Ok(result) + } +} +pub struct StartFence<'a, 'b> { + context: Context<'a, 'b>, + released: crate::update_owned::ReleasedFiles, + bundle: &'a crate::update_state::Bundle, + reservation: PreparedStart, + next: usize, + pending: bool, + poisoned: bool, +} +impl StartFence<'_, '_> { + fn check(&self) -> Result<()> { + self.context.check()?; + self.released.check(self.bundle)?; + let header = self.context.original.handoff(); + let (actual, journal) = verify_inflight_proof( + &self.reservation.proof, + self.context.trust.health_public_key(), + ) + .map_err(anyhow::Error::msg)?; + ensure!( + actual.bytes()? == header.bytes()? + && self.reservation.proof.delegation == *self.context.original.delegation() + && matches!( + journal.phase(), + Phase::LedgerReturnIntent | Phase::RollbackLedgerReturnIntent + ), + "UPDATE_RETURN_ORIGINAL_PREFIX_REQUIRED" + ); + let rollback = journal.phase() == Phase::RollbackLedgerReturnIntent; + let return_at = self + .reservation + .proof + .decode() + .map_err(anyhow::Error::msg)? + .events + .iter() + .map(|raw| serde_json::from_slice::(raw)) + .collect::, _>>()? + .into_iter() + .find(|event| { + matches!( + event.evidence, + rmm_updater_handoff::Evidence::LedgerReturnIntent + ) + }) + .ok_or_else(|| anyhow::anyhow!("UPDATE_ORIGINAL_RETURN_DEADLINE_REQUIRED"))? + .observed_at; + ensure!( + u64::try_from(self.context.clock.reading()?.upper.timestamp())? + < return_at + .checked_add(180) + .ok_or_else(|| anyhow::anyhow!("UPDATE_RETURN_DEADLINE_OVERFLOW"))?, + "UPDATE_ORIGINAL_HEALTH_WINDOW_EXPIRED" + ); + let return_claim = &self.reservation.claims.return_ledger; + ensure!( + return_claim.effect() + == &if rollback { + NativeEffect::RollbackReturnLedger + } else { + NativeEffect::ReturnLedger + }, + "UPDATE_ORIGINAL_RETURN_CLAIM_REQUIRED" + ); + for (index, claim) in self.reservation.claims.starts.iter().enumerate() { + let service = [NativeService::WindowsHelper, NativeService::WindowsAgent][index]; + ensure!( + claim.effect() + == &if rollback { + NativeEffect::RollbackStartService { service } + } else { + NativeEffect::StartService { service } + }, + "UPDATE_START_ORIGINAL_ORDER" + ); + } + for claim in std::iter::once(return_claim).chain(self.reservation.claims.starts.iter()) { + ensure!( + claim.grant_id() == header.attempt.grant_id + && claim.owner_nonce() == header.owner_nonce + && claim.head_sha256() == journal.head_sha256() + && u64::try_from(claim.claimed_at().timestamp())? >= header.consumed_at + && u64::try_from(claim.claimed_at().timestamp())? < header.finish_before, + "UPDATE_START_COMMITTED_ORIGINAL_CLAIM_REQUIRED" + ); + } + for file in &self.bundle.files { + ensure!( + super::files::observe_bound( + file.role, + header.owner_nonce, + super::files::Location::Target, + self.context.budget + )? == if rollback { + file.original.clone() + } else { + file.staged.clone() + }, + "UPDATE_RETURN_TARGET_CHANGED" + ); + } + Ok(()) + } + pub fn finish(self, running: &mut super::services::Running) -> Result<()> { + self.check()?; + ensure!( + !self.pending && !self.poisoned && self.next == 2, + "UPDATE_START_NOT_FULLY_OBSERVED" + ); + running.check(self.context.budget) + } +} +impl DurableEffectFence for StartFence<'_, '_> { + fn before_effect(&mut self, effect: &Effect) -> Result<()> { + ensure!( + !self.poisoned && !self.pending && self.next < 2, + "UPDATE_START_NO_RETRY" + ); + self.poisoned = true; + self.check()?; + ensure!( + *effect + == Effect::StartService { + service: [Service::Helper, Service::Agent][self.next] + }, + "UPDATE_START_CLOSED_SEQUENCE" + ); + self.pending = true; + Ok(()) + } + fn after_effect(&mut self, effect: &Effect, observation: &str) -> Result<()> { + ensure!( + self.poisoned + && self.pending + && self.next < 2 + && *effect + == Effect::StartService { + service: [Service::Helper, Service::Agent][self.next] + }, + "UPDATE_START_CALLBACK_CHANGED" + ); + self.check()?; + let header = self.context.original.handoff(); + let mut pin = if self.next == 0 { + self.bundle_helper_pin()? + } else { + self.bundle_agent_pin()? + }; + let (_, journal) = verify_inflight_proof( + &self.reservation.proof, + self.context.trust.health_public_key(), + ) + .map_err(anyhow::Error::msg)?; + let pair = if journal.phase() == Phase::RollbackLedgerReturnIntent { + &header.predecessor + } else { + &header.target + }; + pin.binary_sha256 = if self.next == 0 { + pair.helper_sha256.clone() + } else { + pair.agent_sha256.clone() + }; + let proof = super::services::observe_public( + [Service::Helper, Service::Agent][self.next], + &pin, + self.context.budget, + )?; + ensure!( + hash(&serde_json::to_vec(&proof)?) == observation, + "UPDATE_START_ACTUAL_OBSERVATION_REQUIRED" + ); + self.next += 1; + self.pending = false; + self.poisoned = false; + Ok(()) + } +} +impl StartFence<'_, '_> { + fn bundle_helper_pin(&self) -> Result { + crate::helper_system::read_settings().map(|(s, _)| s.helper) + } + fn bundle_agent_pin(&self) -> Result { + crate::helper_system::read_settings().map(|(s, _)| s.agent) + } +} +impl StartFence<'_, '_> { + /// Only failure of the FIRST (helper) native start can produce a new + /// all-stopped token without additional authorized stops. A partially + /// started helper/agent pair does not qualify through this path. + pub fn helper_failed(self, failed: super::services::KnownStartupFailure) -> Result { + self.check()?; + let (_, journal) = verify_inflight_proof( + &self.reservation.proof, + self.context.trust.health_public_key(), + ) + .map_err(anyhow::Error::msg)?; + ensure!( + journal.phase() == Phase::LedgerReturnIntent + && self.next == 0 + && self.pending + && self.poisoned + && failed.failure().service() == Service::Helper + && failed.started().is_empty(), + "UPDATE_HELPER_FAILED_START_LINEAGE_REQUIRED" + ); + let mut stopped = failed.into_all_stopped(self.context.budget)?; + stopped.bind_failure( + self.reservation.claims, + self.context.original.delegation().updater.clone(), + )?; + Ok(stopped) + } +} diff --git a/crates/agent-windows/src/update_native/fence.rs b/crates/agent-windows/src/update_native/fence.rs index 9ea23e2..2477108 100644 --- a/crates/agent-windows/src/update_native/fence.rs +++ b/crates/agent-windows/src/update_native/fence.rs @@ -276,3 +276,233 @@ impl DurableEffectFence for LedgerFence Ok(()) } } + +/// A distinct one-shot V2 return fence. It cannot be constructed from Unknown, +/// a partial forward replacement, a completed update or a future grant. +pub struct RestoreFence<'a, 'b, G, C> { + db: &'a mut Connection, + guard: &'a G, + clock: &'a C, + budget: &'a Budget<'b>, + original: Handoff, + originals: &'a [Proof; 5], + staged: &'a [Proof; 5], + pending: Option<(Effect, NativeEffectClaim)>, + next: usize, + saved: bool, + poisoned: bool, +} +impl<'a, 'b, G: UpdateParticipantGuard, C: SyncClock> RestoreFence<'a, 'b, G, C> { + pub fn new(input: Inputs<'a, 'b, G, C>) -> Result { + input.budget.check()?; + input.original.validate()?; + let grant = input.original.attempt.grant_id; + let journal = core::read(input.db, input.guard, grant)?; + ensure!( + input.original.schema_version == 2 + && input.original.pin_transition == PinTransition::WindowsCodePairClockV1 + && input.guard.participant() == Participant::StableUpdater + && journal.phase() == Phase::RollbackStopped, + "UPDATE_WINDOWS_NO_RESTORE_RESUME" + ); + let raw: Vec = input.db.query_row( + "SELECT record FROM agent_update_handoffs WHERE grant_id=?1", + [grant.to_string()], + |r| r.get(0), + )?; + ensure!( + raw == input.original.bytes()?, + "UPDATE_WINDOWS_ORIGINAL_HANDOFF" + ); + for (i, role) in ROLES.iter().copied().enumerate() { + ensure!( + input.original.files[i].role == role.handoff_role() + && input.original.files[i].old_sha256 == input.originals[i].sha256 + && input.original.files[i].new_sha256 == input.staged[i].sha256 + && files::observe_bound( + role, + input.original.owner_nonce, + Location::Target, + input.budget + )? == input.staged[i] + && files::observe_bound( + role, + input.original.owner_nonce, + Location::Previous, + input.budget + )? == input.originals[i], + "UPDATE_WINDOWS_RESTORE_FILES" + ); + } + Ok(Self { + db: input.db, + guard: input.guard, + clock: input.clock, + budget: input.budget, + original: input.original.clone(), + originals: input.originals, + staged: input.staged, + pending: None, + next: 0, + saved: false, + poisoned: false, + }) + } + fn append(&mut self, evidence: Evidence) -> Result<()> { + self.budget.check()?; + let grant = self.original.attempt.grant_id; + let journal = core::read(self.db, self.guard, grant)?; + let raw = journal.prepare(u64::try_from(self.clock.bounds()?.1.timestamp())?, evidence)?; + core::append(self.db, self.guard, grant, journal.head_sha256(), &raw) + } + pub fn finish(mut self) -> Result<()> { + ensure!( + !self.poisoned && self.pending.is_none() && !self.saved && self.next == ROLES.len(), + "UPDATE_WINDOWS_RESTORE_INCOMPLETE" + ); + for (i, role) in ROLES.iter().copied().enumerate() { + ensure!( + files::observe_bound( + role, + self.original.owner_nonce, + Location::Target, + self.budget + )? == self.originals[i] + && files::observe_bound( + role, + self.original.owner_nonce, + Location::Rejected, + self.budget + )? == self.staged[i], + "UPDATE_WINDOWS_RESTORED_STATE_CHANGED" + ); + } + self.append(Evidence::PredecessorVerified { + pair: self.original.predecessor.clone(), + retained_state_sha256: self.original.retained_state_sha256.clone(), + predecessor_record_sha256: self.original.predecessor_record_sha256.clone(), + }) + } +} +impl DurableEffectFence for RestoreFence<'_, '_, G, C> { + fn before_effect(&mut self, effect: &Effect) -> Result<()> { + ensure!( + !self.poisoned && self.pending.is_none() && self.next < ROLES.len(), + "UPDATE_WINDOWS_RESTORE_REENTRY" + ); + self.poisoned = true; + self.budget.check()?; + let i = ROLES.len() - 1 - self.next; + let role = ROLES[i]; + let effect_kind = match *effect { + Effect::SaveRejectedCandidate { role: r } if r == role && !self.saved => { + ensure!( + files::observe_bound( + role, + self.original.owner_nonce, + Location::Target, + self.budget + )? == self.staged[i] + && files::observe_bound( + role, + self.original.owner_nonce, + Location::Previous, + self.budget + )? == self.originals[i], + "UPDATE_WINDOWS_RESTORE_FILES_CHANGED" + ); + self.append(Evidence::RestoreIntent { + role: role.handoff_role(), + })?; + NativeEffect::SaveRejectedCandidate { role: native(role) } + } + Effect::RestorePredecessor { role: r } if r == role && self.saved => { + ensure!( + files::observe_bound( + role, + self.original.owner_nonce, + Location::Rejected, + self.budget + )? == self.staged[i] + && files::observe_bound( + role, + self.original.owner_nonce, + Location::Previous, + self.budget + )? == self.originals[i], + "UPDATE_WINDOWS_RESTORE_FILES_CHANGED" + ); + NativeEffect::RestorePredecessor { role: native(role) } + } + _ => anyhow::bail!("UPDATE_WINDOWS_RESTORE_SCOPE"), + }; + let journal = core::read(self.db, self.guard, self.original.attempt.grant_id)?; + let claim = core::claim_native_effect( + self.db, + self.guard, + self.original.attempt.grant_id, + journal.head_sha256(), + &effect_kind, + self.clock.bounds()?.1, + )?; + self.pending = Some((effect.clone(), claim)); + Ok(()) + } + fn after_effect(&mut self, effect: &Effect, observation: &str) -> Result<()> { + let (expected, claim) = self + .pending + .take() + .ok_or_else(|| anyhow::anyhow!("UPDATE_WINDOWS_RESTORE_NOT_CLAIMED"))?; + ensure!( + self.poisoned && *effect == expected, + "UPDATE_WINDOWS_RESTORE_CALLBACK_CHANGED" + ); + self.budget.check()?; + let i = ROLES.len() - 1 - self.next; + let role = ROLES[i]; + let restored = matches!(effect, Effect::RestorePredecessor { .. }); + let proof = files::observe_bound( + role, + self.original.owner_nonce, + if restored { + Location::Target + } else { + Location::Rejected + }, + self.budget, + )?; + ensure!( + proof + == if restored { + self.originals[i].clone() + } else { + self.staged[i].clone() + } + && digest(&serde_json::to_vec(&proof)?) == observation, + "UPDATE_WINDOWS_RESTORE_READBACK" + ); + core::observe_native_effect( + self.db, + self.guard, + &claim, + observation, + self.clock.bounds()?.1, + )?; + if restored { + self.append(Evidence::PredecessorRestored { + role: role.handoff_role(), + observed_sha256: proof.sha256, + })?; + self.next += 1; + self.saved = false; + } else { + self.append(Evidence::CandidatePreserved { + role: role.handoff_role(), + observation_sha256: observation.into(), + })?; + self.saved = true; + } + self.poisoned = false; + Ok(()) + } +} diff --git a/crates/agent-windows/src/update_native/files.rs b/crates/agent-windows/src/update_native/files.rs index 2458664..668d056 100644 --- a/crates/agent-windows/src/update_native/files.rs +++ b/crates/agent-windows/src/update_native/files.rs @@ -2,10 +2,7 @@ //! No archive extraction, free target path, overwrite, replacement of journals, //! or implicit retry/rollback. A failed rename/readback is an uncertain effect. use super::{Budget, DurableEffectFence, Effect, Role, digest, valid_digest}; -use crate::{ - helper_ipc::{self as ipc, FileIdentity, PinnedFile}, - job_binding, -}; +use crate::helper_ipc::{self as ipc, FileIdentity, PinnedFile}; use anyhow::{Context, Result, ensure}; use serde::{Deserialize, Serialize}; use sha2::{Digest, Sha256}; @@ -45,6 +42,16 @@ struct Directory { root: PinnedFile, ancestors: Vec, } +fn readers() -> Result> { + let mut values = vec![ + ipc::service_sid(crate::SERVICE_NAME)?, + ipc::service_sid(ipc::HELPER_SERVICE)?, + ]; + if let Ok(updater) = ipc::service_sid(crate::update_ipc::SERVICE) { + values.push(updater); + } + Ok(values) +} fn regular(file: &File, directory: bool) -> Result<()> { let mut info: BY_HANDLE_FILE_INFORMATION = unsafe { zeroed() }; ensure!( @@ -87,11 +94,7 @@ impl Directory { let path = Path::new(role.target()) .parent() .context("UPDATE_TARGET_DIRECTORY")?; - let readers = vec![ - ipc::service_sid(crate::SERVICE_NAME)?, - ipc::service_sid(ipc::HELPER_SERVICE)?, - ]; - let root = PinnedFile::open_read_shared(path, true, &readers, &[])?; + let root = PinnedFile::open_read_shared(path, true, &readers()?, &[])?; let mut ancestors = Vec::new(); for ancestor in path.ancestors().skip(1) { let raw = unsafe { @@ -123,6 +126,9 @@ impl Directory { self.root.path.join(name) } } +pub(crate) fn security_sha256(file: &File) -> Result { + SecurityDescriptor::read(file)?.hash() +} struct SecurityDescriptor(*mut core::ffi::c_void); impl Drop for SecurityDescriptor { fn drop(&mut self) { @@ -230,9 +236,13 @@ fn hash_file(file: &mut File, max: u64) -> Result { } Ok(format!("{:x}", hash.finalize())) } -fn proof(file: &mut File, path: &Path, max: u64) -> Result { +pub(crate) fn proof(file: &mut File, path: &Path, max: u64) -> Result { regular(file, false)?; - job_binding::check_admin_readonly(path)?; + // The agent-only binding reader rejects the helper service's legitimate + // read ACE. These are the SAME fixed three service readers used by the + // updater; none gets write/delete/owner/DACL rights. Check the held object, + // not an unrelated path-based collector ACL helper. + ipc::check_acl(file.as_raw_handle(), &readers()?, &[], None)?; let identity = ipc::file_identity(file)?; let bytes = file.metadata()?.len(); ensure!(bytes > 0 && bytes <= max, "UPDATE_FILE_SIZE"); @@ -291,6 +301,7 @@ pub(crate) enum Location { Target, Stage, Previous, + Rejected, } /// Independent readback while the actual swap retains DELETE/write handles. /// Opening this read-only observer grants no write/delete access or authority. @@ -309,6 +320,9 @@ pub(crate) fn observe_bound( Location::Previous => { directory.child(&format!(".rmm-update-{nonce}-{}.previous", role.label())) } + Location::Rejected => { + directory.child(&format!(".rmm-update-{nonce}-{}.rejected", role.label())) + } }; let raw = unsafe { CreateFileW( @@ -336,6 +350,12 @@ pub struct StageDescriptor<'a> { pub replacement_sha256: &'a str, pub replacement_bytes: u64, } +pub struct BoundStage<'a> { + pub role: Role, + pub owner_nonce: Uuid, + pub original: &'a Proof, + pub staged: &'a Proof, +} pub struct Staged { role: Role, nonce: Uuid, @@ -346,6 +366,52 @@ pub struct Staged { staged: Proof, } impl Staged { + /// Reopen only the exact prepared stage in the immutable consumed bundle. + /// A partial publication/old predecessor name is never treated as a stage. + pub fn reopen_bound(bound: BoundStage<'_>, budget: &Budget<'_>) -> Result { + ensure!(!bound.owner_nonce.is_nil(), "UPDATE_STAGE_NONCE"); + budget.check()?; + let mut directory = Directory::open(bound.role)?; + let path = directory.child(&format!( + ".rmm-update-{}-{}.stage", + bound.owner_nonce, + bound.role.label() + )); + let previous = directory.child(&format!( + ".rmm-update-{}-{}.previous", + bound.owner_nonce, + bound.role.label() + )); + ensure!(!previous.try_exists()?, "UPDATE_NO_STAGE_RESUME"); + ensure!( + observe_bound(bound.role, bound.owner_nonce, Location::Target, budget)? + == *bound.original, + "UPDATE_STAGE_PREDECESSOR_CHANGED" + ); + let mut file = open( + &path, + FILE_GENERIC_READ | FILE_GENERIC_WRITE | DELETE, + OPEN_EXISTING, + ptr::null(), + )?; + ensure!( + proof(&mut file, &path, bound.role.max_bytes())? == *bound.staged + && bound.original.identity != bound.staged.identity + && bound.original.identity.volume_serial == bound.staged.identity.volume_serial + && bound.original.security_sha256 == bound.staged.security_sha256, + "UPDATE_BOUND_STAGE_CHANGED" + ); + directory.check()?; + Ok(Self { + role: bound.role, + nonce: bound.owner_nonce, + directory, + path, + file, + original: bound.original.clone(), + staged: bound.staged.clone(), + }) + } /// Source is a bounded stream of already independently release-verified /// artifact bytes. No URL or caller-chosen destination is accepted. Both /// code files MUST be fully staged before original activation consumption. @@ -548,6 +614,53 @@ pub struct Published { replacement_proof: Proof, } impl Published { + /// Reopening exact files is an observation only. The separate V2 restore + /// fence still requires a known failure, original owner and current guard. + pub fn reopen_bound( + bound: BoundStage<'_>, + stopped: &super::services::Stopped, + budget: &Budget<'_>, + ) -> Result { + stopped.check(budget)?; + ensure!(!bound.owner_nonce.is_nil(), "UPDATE_RESTORE_NONCE"); + let mut directory = Directory::open(bound.role)?; + let predecessor = directory.child(&format!( + ".rmm-update-{}-{}.previous", + bound.owner_nonce, + bound.role.label() + )); + let mut original = open( + &predecessor, + FILE_GENERIC_READ | FILE_GENERIC_WRITE | DELETE, + OPEN_EXISTING, + ptr::null(), + )?; + let mut replacement = open( + Path::new(bound.role.target()), + FILE_GENERIC_READ | FILE_GENERIC_WRITE | DELETE, + OPEN_EXISTING, + ptr::null(), + )?; + ensure!( + proof(&mut original, &predecessor, bound.role.max_bytes())? == *bound.original + && proof( + &mut replacement, + Path::new(bound.role.target()), + bound.role.max_bytes() + )? == *bound.staged, + "UPDATE_RESTORE_BOUND_FILES_CHANGED" + ); + directory.check()?; + Ok(Self { + role: bound.role, + directory, + original, + predecessor, + original_proof: bound.original.clone(), + replacement, + replacement_proof: bound.staged.clone(), + }) + } pub fn proof(&self) -> &Proof { &self.replacement_proof } @@ -573,4 +686,86 @@ impl Published { self.verify(budget)?; Ok((self.original_proof, self.replacement_proof)) } + /// V2-only caller fence: preserve the rejected candidate and restore the + /// exact predecessor with TWO distinct durable intents and readbacks. + pub fn restore( + mut self, + stopped: &super::services::Stopped, + budget: &Budget<'_>, + fence: &mut impl DurableEffectFence, + ) -> Result<(Proof, Proof)> { + stopped.check(budget)?; + self.verify(budget)?; + let rejected = self.predecessor.with_extension("rejected"); + let save = Effect::SaveRejectedCandidate { role: self.role }; + fence.before_effect(&save)?; + budget.check()?; + stopped.check(budget)?; + self.directory.check()?; + rename_new(&self.replacement, &rejected)?; + let saved = proof(&mut self.replacement, &rejected, self.role.max_bytes())?; + ensure!( + saved == self.replacement_proof, + "UPDATE_REJECTED_CANDIDATE_CHANGED" + ); + fence.after_effect(&save, &digest(&serde_json::to_vec(&saved)?))?; + let restore = Effect::RestorePredecessor { role: self.role }; + fence.before_effect(&restore)?; + budget.check()?; + stopped.check(budget)?; + self.directory.check()?; + rename_new(&self.original, Path::new(self.role.target()))?; + let restored = proof( + &mut self.original, + Path::new(self.role.target()), + self.role.max_bytes(), + )?; + ensure!( + restored == self.original_proof, + "UPDATE_RESTORED_PREDECESSOR_CHANGED" + ); + fence.after_effect(&restore, &digest(&serde_json::to_vec(&restored)?))?; + Ok((restored, saved)) + } +} + +/// Fixed installed-record namespace only; the caller's original native claim +/// remains mandatory. This primitive grants no approval or retry authority. +pub(crate) fn rename_record(file: &File, target: &Path) -> Result<()> { + let root = Path::new(r"C:\ProgramData\RustDiscoveryUpdater"); + let name = target.file_name().and_then(|n| n.to_str()).unwrap_or(""); + ensure!( + (target.parent() == Some(root) && name == "installed-record.json") + || (target.parent() == Some(root.join("records").as_path()) + && name.strip_suffix(".json").is_some_and(valid_digest)), + "UPDATE_RECORD_FIXED_NAMESPACE" + ); + rename_new(file, target) +} +pub(crate) fn create_record_stage(source: &File, target: &Path) -> Result { + ensure!( + target.parent() == Some(Path::new(r"C:\ProgramData\RustDiscoveryUpdater")) + && target + .file_name() + .and_then(|n| n.to_str()) + .is_some_and(|n| n.starts_with(".rmm-record-") && n.ends_with(".stage")), + "UPDATE_RECORD_FIXED_STAGE" + ); + let descriptor = SecurityDescriptor::read(source)?; + let attributes = SECURITY_ATTRIBUTES { + nLength: size_of::() as u32, + lpSecurityDescriptor: descriptor.0, + bInheritHandle: 0, + }; + let file = open( + target, + FILE_GENERIC_READ | FILE_GENERIC_WRITE | DELETE, + CREATE_NEW, + &attributes, + )?; + ensure!( + SecurityDescriptor::read(&file)?.hash()? == descriptor.hash()?, + "UPDATE_RECORD_STAGE_SECURITY" + ); + Ok(file) } diff --git a/crates/agent-windows/src/update_native/mod.rs b/crates/agent-windows/src/update_native/mod.rs index 78c347b..801439a 100644 --- a/crates/agent-windows/src/update_native/mod.rs +++ b/crates/agent-windows/src/update_native/mod.rs @@ -14,6 +14,8 @@ use uuid::Uuid; #[cfg(windows)] pub mod fence; #[cfg(windows)] +pub mod control_fence; +#[cfg(windows)] pub mod files; #[cfg(windows)] pub mod services; @@ -109,6 +111,10 @@ impl<'a> Budget<'a> { value.check()?; Ok(value) } + pub fn boot_id(&self) -> Result { + self.check()?; + Ok(self.boot_id) + } pub fn check(&self) -> Result<()> { ensure!(Instant::now() < self.until, "UPDATE_DEADLINE"); ensure!( @@ -127,6 +133,7 @@ pub enum Effect { SavePredecessor { role: Role }, PublishReplacement { role: Role }, RestorePredecessor { role: Role }, + SaveRejectedCandidate { role: Role }, StartService { service: Service }, } diff --git a/crates/agent-windows/src/update_native/services.rs b/crates/agent-windows/src/update_native/services.rs index 7e3d28c..a03e39f 100644 --- a/crates/agent-windows/src/update_native/services.rs +++ b/crates/agent-windows/src/update_native/services.rs @@ -4,6 +4,7 @@ use super::{Budget, DurableEffectFence, Effect, Service, digest}; use crate::helper_ipc::{PeerPin, PeerProof, utf16_pointer, wide}; use anyhow::{Result, ensure}; +use rmm_domain::agent_update_provisioning::LocalUpdatePolicy; use rmm_updater_handoff::{Process, StartedService}; use serde::{Deserialize, Serialize}; use std::{ @@ -11,7 +12,12 @@ use std::{ ptr, thread, time::Duration, }; -use windows_sys::Win32::System::Services::*; +use windows_sys::Win32::{ + Foundation::{ + ERROR_ACCESS_DENIED, ERROR_PATH_NOT_FOUND, ERROR_SERVICE_LOGON_FAILED, GetLastError, + }, + System::Services::*, +}; struct Handle(SC_HANDLE); impl Drop for Handle { @@ -115,12 +121,11 @@ fn configuration(handle: &Handle, service: Service, pin: &PeerPin) -> Result) -> Result, +) -> Result { + let mut held = observe(service, pin, budget)?; + held.peer.check()?; + Ok(held.proof.clone()) +} + /// Observation holds both original processes/images, not a freely constructible /// Running flag. Drop these witnesses only after confirmed process termination. pub struct Running { @@ -262,10 +277,7 @@ impl Running { loop { budget.check()?; let state = status(&service.handle)?; - if state.dwCurrentState == SERVICE_STOPPED - && state.dwProcessId == 0 - && service.peer.exited()? - { + if state.dwCurrentState == SERVICE_STOPPED && service.peer.exited()? { break; } ensure!( @@ -283,6 +295,9 @@ impl Running { proofs[0].configuration.clone(), proofs[1].configuration.clone(), ], + proofs, + failed_start: None, + failure_binding: None, }; // Held image handles intentionally close here, after BOTH exact original // processes have terminated. Neither PID reuse nor SCM state suffices. @@ -297,8 +312,15 @@ impl Running { pub struct Stopped { pins: [PeerPin; 2], configurations: [Configuration; 2], + proofs: Vec, + failed_start: Option, + failure_binding: Option, } impl Stopped { + pub fn proofs(&self) -> &[Proof] { + &self.proofs + } + pub fn check(&self, budget: &Budget<'_>) -> Result<()> { budget.check()?; for (i, service) in [Service::Agent, Service::Helper].into_iter().enumerate() { @@ -309,7 +331,6 @@ impl Stopped { let state = status(&handle)?; ensure!( state.dwCurrentState == SERVICE_STOPPED - && state.dwProcessId == 0 && configuration(&handle, service, &self.pins[i])? == self.configurations[i], "UPDATE_STOPPED_STATE_CHANGED" ); @@ -325,6 +346,19 @@ impl Stopped { budget: &Budget<'_>, fence: &mut impl DurableEffectFence, ) -> Result { + match self.start_observed(replacement_pins, budget, fence)? { + StartResult::Running(running) => Ok(*running), + StartResult::KnownFailure(_) => { + anyhow::bail!("UPDATE_KNOWN_STARTUP_FAILURE_REQUIRES_ORIGINAL_ROLLBACK") + } + } + } + pub fn start_observed( + self, + replacement_pins: [PeerPin; 2], + budget: &Budget<'_>, + fence: &mut impl DurableEffectFence, + ) -> Result { self.check(budget)?; let mut started = Vec::with_capacity(2); for (i, service) in [(1, Service::Helper), (0, Service::Agent)] { @@ -354,16 +388,52 @@ impl Stopped { status(&handle)?.dwCurrentState == SERVICE_STOPPED, "UPDATE_START_ALREADY_RUNNING" ); - ensure!( - unsafe { StartServiceW(handle.0, 0, ptr::null()) } != 0, - "UPDATE_START_REQUEST_UNCERTAIN" - ); + if unsafe { StartServiceW(handle.0, 0, ptr::null()) } == 0 { + let error = unsafe { GetLastError() }; + let state = status(&handle)?; + ensure!( + matches!( + error, + ERROR_ACCESS_DENIED | ERROR_PATH_NOT_FOUND | ERROR_SERVICE_LOGON_FAILED + ) && state.dwCurrentState == SERVICE_STOPPED, + "UPDATE_START_REQUEST_UNCERTAIN" + ); + let failure = FailedStartProof::capture( + service, + &replacement_pins[i], + &handle, + error, + false, + )?; + let mut known = KnownStartupFailure { + original: self, + pins: replacement_pins, + failure, + started, + }; + known.verify(budget)?; + return Ok(StartResult::KnownFailure(Box::new(known))); + } loop { budget.check()?; let state = status(&handle)?; if state.dwCurrentState == SERVICE_RUNNING { break; } + if state.dwCurrentState == SERVICE_STOPPED + && (state.dwWin32ExitCode != 0 || state.dwServiceSpecificExitCode != 0) + { + let failure = + FailedStartProof::capture(service, &replacement_pins[i], &handle, 0, true)?; + let mut known = KnownStartupFailure { + original: self, + pins: replacement_pins, + failure, + started, + }; + known.verify(budget)?; + return Ok(StartResult::KnownFailure(Box::new(known))); + } ensure!( state.dwCurrentState == SERVICE_START_PENDING, "UPDATE_START_STATE_UNCERTAIN" @@ -380,7 +450,7 @@ impl Stopped { held: started, }; running.check(budget)?; - Ok(running) + Ok(StartResult::Running(Box::new(running))) } } impl Proof { @@ -391,3 +461,391 @@ impl Proof { } } } + +/// The stable updater is independently pinned and never part of the stop set. +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct UpdaterConfiguration { + pub service_name: String, + pub command: String, + pub account: String, + pub start_type: u32, + pub error_control: u32, + pub sid_type: u32, +} +pub fn updater_pin(policy: &LocalUpdatePolicy) -> Result { + ensure!( + policy.validate() + && policy.schema_version == 2 + && policy.profile == "windows_code_pair_clock_v1", + "UPDATE_WINDOWS_LOCAL_POLICY" + ); + Ok(PeerPin { + service_name: crate::update_ipc::SERVICE.into(), + service_sid: crate::helper_ipc::service_sid(crate::update_ipc::SERVICE)?, + user_sid: "S-1-5-18".into(), + binary: crate::update_ipc::BINARY.into(), + binary_sha256: policy.updater_binary_sha256.clone(), + }) +} +pub fn updater_configuration(pin: &PeerPin) -> Result { + updater_configuration_inner(pin, true) +} +/// Bootstrap metadata of an already registered fixed service. This does not +/// authenticate a running updater, qualify its clock, or create readiness. +pub fn updater_bootstrap_definition(pin: &PeerPin) -> Result { + updater_configuration_inner(pin, false) +} +fn updater_configuration_inner( + pin: &PeerPin, + require_running: bool, +) -> Result { + ensure!( + pin.service_name == crate::update_ipc::SERVICE + && pin.service_sid == crate::helper_ipc::service_sid(crate::update_ipc::SERVICE)? + && pin.user_sid == "S-1-5-18" + && pin.binary == std::path::Path::new(crate::update_ipc::BINARY) + && super::valid_digest(&pin.binary_sha256), + "UPDATE_UPDATER_FIXED_SERVICE" + ); + let manager = Handle(unsafe { OpenSCManagerW(ptr::null(), ptr::null(), SC_MANAGER_CONNECT) }); + ensure!(!manager.0.is_null(), "UPDATE_SCM_MANAGER"); + let service = Handle(unsafe { + OpenServiceW( + manager.0, + wide(crate::update_ipc::SERVICE).as_ptr(), + SERVICE_QUERY_CONFIG | SERVICE_QUERY_STATUS | SERVICE_ENUMERATE_DEPENDENTS, + ) + }); + ensure!(!service.0.is_null(), "UPDATE_UPDATER_SCM"); + let mut needed = 0; + unsafe { + QueryServiceConfigW(service.0, ptr::null_mut(), 0, &mut needed); + } + ensure!((1..=32768).contains(&needed), "UPDATE_SCM_CONFIG_SIZE"); + let mut bytes = vec![0usize; (needed as usize).div_ceil(size_of::())]; + ensure!( + unsafe { QueryServiceConfigW(service.0, bytes.as_mut_ptr().cast(), needed, &mut needed) } + != 0, + "UPDATE_SCM_CONFIG" + ); + let cfg = unsafe { &*bytes.as_ptr().cast::() }; + let command = unsafe { utf16_pointer(cfg.lpBinaryPathName) }?; + let account = unsafe { utf16_pointer(cfg.lpServiceStartName) }?; + ensure!( + cfg.dwServiceType == SERVICE_WIN32_OWN_PROCESS + && cfg.dwStartType == SERVICE_AUTO_START + && command == format!("\"{}\"", crate::update_ipc::BINARY) + && account == "LocalSystem" + && (cfg.lpDependencies.is_null() || unsafe { *cfg.lpDependencies } == 0) + && (cfg.lpLoadOrderGroup.is_null() || unsafe { *cfg.lpLoadOrderGroup } == 0), + "UPDATE_UPDATER_SCM_CONFIGURATION" + ); + let recovery = config2(&service, SERVICE_CONFIG_FAILURE_ACTIONS)?; + ensure!( + unsafe { (*recovery.as_ptr().cast::()).cActions } == 0, + "UPDATE_UPDATER_RECOVERY_ACTIONS" + ); + let triggers = config2(&service, SERVICE_CONFIG_TRIGGER_INFO)?; + ensure!( + unsafe { (*triggers.as_ptr().cast::()).cTriggers } == 0, + "UPDATE_UPDATER_TRIGGERS" + ); + let sid = config2(&service, SERVICE_CONFIG_SERVICE_SID_INFO)?; + let sid_type = unsafe { (*sid.as_ptr().cast::()).dwServiceSidType }; + ensure!( + sid_type == SERVICE_SID_TYPE_UNRESTRICTED, + "UPDATE_UPDATER_SERVICE_SID" + ); + let mut dependent_bytes = 0; + let mut dependent_count = 0; + ensure!( + unsafe { + EnumDependentServicesW( + service.0, + SERVICE_ACTIVE, + ptr::null_mut(), + 0, + &mut dependent_bytes, + &mut dependent_count, + ) + } != 0 + && dependent_bytes == 0 + && dependent_count == 0, + "UPDATE_UPDATER_ACTIVE_DEPENDENTS" + ); + ensure!( + !require_running || status(&service)?.dwCurrentState == SERVICE_RUNNING, + "UPDATE_UPDATER_NOT_RUNNING" + ); + Ok(UpdaterConfiguration { + service_name: pin.service_name.clone(), + command, + account, + start_type: cfg.dwStartType, + error_control: cfg.dwErrorControl, + sid_type, + }) +} +pub fn updater_configuration_sha256(pin: &PeerPin) -> Result { + Ok(digest(&serde_json::to_vec(&updater_configuration(pin)?)?)) +} +pub fn observe_updater( + policy: &LocalUpdatePolicy, + budget: &Budget<'_>, +) -> Result<(PeerProof, rmm_domain::agent_update::ParticipantIdentity)> { + budget.check()?; + let pin = updater_pin(policy)?; + ensure!( + updater_configuration_sha256(&pin)? == policy.updater_service.unit_sha256, + "UPDATE_UPDATER_SCM_PIN" + ); + let (mut peer, identity) = crate::update_ipc::observe( + &pin, + rmm_domain::agent_update::ParticipantRole::WindowsUpdater, + )?; + peer.check()?; + ensure!( + updater_configuration_sha256(&pin)? == policy.updater_service.unit_sha256, + "UPDATE_UPDATER_SCM_PIN" + ); + budget.check()?; + Ok((peer, identity)) +} +/// The native API actually rejected the start, or the accepted service exited +/// with an observed failure before RUNNING. An ambiguous API error, timeout, +/// lost callback, unknown state or incomplete identity is never this token. +pub enum StartResult { + Running(Box), + KnownFailure(Box), +} +#[derive(Clone, Debug, PartialEq, Eq, Serialize)] +pub struct FailedStartProof { + service: Service, + image_sha256: String, + configuration: Configuration, + request_error: u32, + accepted_then_exited: bool, + win32_exit: u32, + service_exit: u32, +} +impl FailedStartProof { + fn capture( + service: Service, + pin: &PeerPin, + handle: &Handle, + error: u32, + accepted_then_exited: bool, + ) -> Result { + let state = status(handle)?; + ensure!( + state.dwCurrentState == SERVICE_STOPPED, + "UPDATE_FAILED_START_NOT_STOPPED" + ); + Ok(Self { + service, + image_sha256: pin.binary_sha256.clone(), + configuration: configuration(handle, service, pin)?, + request_error: error, + accepted_then_exited, + win32_exit: state.dwWin32ExitCode, + service_exit: state.dwServiceSpecificExitCode, + }) + } + pub fn service(&self) -> Service { + self.service + } + pub fn sha256(&self) -> Result { + Ok(digest(&serde_json::to_vec(self)?)) + } +} +pub struct KnownStartupFailure { + original: Stopped, + pins: [PeerPin; 2], + failure: FailedStartProof, + started: Vec, +} +impl KnownStartupFailure { + pub fn failure(&self) -> &FailedStartProof { + &self.failure + } + pub fn started(&self) -> Vec { + self.started.iter().map(|s| s.proof.clone()).collect() + } + pub fn verify(&mut self, budget: &Budget<'_>) -> Result<()> { + budget.check()?; + for held in &mut self.started { + held.peer.check()?; + } + let index = match self.failure.service { + Service::Agent => 0, + Service::Helper => 1, + }; + let h = handle( + self.failure.service, + SERVICE_QUERY_STATUS | SERVICE_QUERY_CONFIG | SERVICE_ENUMERATE_DEPENDENTS, + )?; + ensure!( + FailedStartProof::capture( + self.failure.service, + &self.pins[index], + &h, + self.failure.request_error, + self.failure.accepted_then_exited + )? == self.failure, + "UPDATE_FAILED_START_OBSERVATION_CHANGED" + ); + if self.failure.service == Service::Helper { + ensure!( + self.started.is_empty(), + "UPDATE_HELPER_FAILURE_STARTED_AGENT" + ); + self.original.check(budget)?; + } else { + ensure!( + self.started.len() == 1 && self.started[0].service == Service::Helper, + "UPDATE_AGENT_FAILURE_HELPER_LINEAGE" + ); + } + Ok(()) + } + pub(crate) fn into_all_stopped(mut self, budget: &Budget<'_>) -> Result { + self.verify(budget)?; + ensure!( + self.failure.service == Service::Helper && self.started.is_empty(), + "UPDATE_PARTIAL_START_REQUIRES_AUTHORIZED_STOPS" + ); + self.original.failed_start = Some(self.failure); + self.original.check(budget)?; + Ok(self.original) + } +} +impl Stopped { + pub(crate) fn failed_start(&self) -> Option<&FailedStartProof> { + self.failed_start.as_ref() + } +} + +struct FailureBinding { + claims: rmm_agent_core::update_handoff::PreparedReturnClaims<2>, + updater: rmm_domain::agent_update::ParticipantIdentity, +} +impl Stopped { + pub(crate) fn bind_failure( + &mut self, + claims: rmm_agent_core::update_handoff::PreparedReturnClaims<2>, + updater: rmm_domain::agent_update::ParticipantIdentity, + ) -> Result<()> { + ensure!( + self.failed_start.is_some() && self.failure_binding.is_none(), + "UPDATE_FAILED_START_BINDING_REQUIRED" + ); + self.failure_binding = Some(FailureBinding { claims, updater }); + Ok(()) + } + pub(crate) fn verify_failure_claims( + &self, + db: &rusqlite::Connection, + h: &rmm_updater_handoff::Handoff, + ) -> Result<()> { + if let Some(binding) = &self.failure_binding { + for claim in + std::iter::once(&binding.claims.return_ledger).chain(binding.claims.starts.iter()) + { + ensure!( + claim.grant_id() == h.attempt.grant_id && claim.owner_nonce() == h.owner_nonce, + "UPDATE_FAILURE_ORIGINAL_RESERVATION_REQUIRED" + ); + let raw: Vec = db.query_row( + "SELECT claim FROM agent_update_native_claims WHERE grant_id=?1 AND claim=?2", + rusqlite::params![h.attempt.grant_id.to_string(), serde_json::to_vec(claim)?], + |r| r.get(0), + )?; + ensure!( + raw == serde_json::to_vec(claim)?, + "UPDATE_FAILURE_RESERVATION_CHANGED" + ); + } + } + Ok(()) + } + pub(crate) fn failure_observation( + &self, + h: &rmm_updater_handoff::Handoff, + d: &rmm_domain::agent_update::UpdateDelegation, + effect: &rmm_agent_core::update_handoff::NativeEffect, + budget: &Budget<'_>, + ) -> Result { + use rmm_agent_core::update_handoff::{NativeEffect as E, NativeService as S}; + self.check(budget)?; + let failure = self + .failed_start + .as_ref() + .ok_or_else(|| anyhow::anyhow!("UPDATE_KNOWN_START_FAILURE_REQUIRED"))?; + let binding = self + .failure_binding + .as_ref() + .ok_or_else(|| anyhow::anyhow!("UPDATE_FAILURE_ORIGINAL_START_BINDING_REQUIRED"))?; + ensure!( + failure.service == Service::Helper + && failure.image_sha256 == h.target.helper_sha256 + && binding.updater == d.updater, + "UPDATE_FAILURE_ACTUAL_ORIGINAL_CONTEXT_REQUIRED" + ); + let helper = handle( + Service::Helper, + SERVICE_QUERY_STATUS | SERVICE_QUERY_CONFIG | SERVICE_ENUMERATE_DEPENDENTS, + )?; + let mut pin = self.pins[1].clone(); + pin.binary_sha256 = failure.image_sha256.clone(); + ensure!( + FailedStartProof::capture( + Service::Helper, + &pin, + &helper, + failure.request_error, + failure.accepted_then_exited + )? == *failure, + "UPDATE_FAILED_START_OBSERVATION_CHANGED" + ); + let service = match effect { + E::StartService { + service: S::WindowsHelper | S::WindowsAgent, + } + | E::RollbackStopService { + service: S::WindowsHelper | S::WindowsAgent, + } => { + if matches!( + effect, + E::StartService { + service: S::WindowsHelper + } | E::RollbackStopService { + service: S::WindowsHelper + } + ) { + S::WindowsHelper + } else { + S::WindowsAgent + } + } + _ => anyhow::bail!("UPDATE_FAILURE_NONSTART_SCOPE_REQUIRED"), + }; + ensure!( + binding.claims.starts[0].effect() + == &E::StartService { + service: S::WindowsHelper + } + && binding.claims.starts[1].effect() + == &E::StartService { + service: S::WindowsAgent + }, + "UPDATE_FAILURE_START_SEQUENCE_CHANGED" + ); + Ok(digest(&serde_json::to_vec(&( + failure, + &binding.updater, + service, + &binding.claims.starts, + ))?)) + } +} diff --git a/crates/agent-windows/src/update_native/transition.rs b/crates/agent-windows/src/update_native/transition.rs index 397f7ff..b1ae70c 100644 --- a/crates/agent-windows/src/update_native/transition.rs +++ b/crates/agent-windows/src/update_native/transition.rs @@ -211,12 +211,12 @@ pub fn render(input: Inputs<'_>) -> Result { let mut settings: Settings = serde_json::from_slice(input.settings)?; let mut pin: Pin = serde_json::from_slice(input.pin)?; ensure!( - matches!(settings.schema_version, 1..=3) - && !settings.allow_reboot + matches!(settings.schema_version, 1..=4) + && (settings.schema_version == 4 || !settings.allow_reboot) && (1..=120).contains(&settings.max_runtime_seconds) && settings.allowed_services.len() <= 16 && (settings.schema_version >= 2 || settings.allowed_msi_recipe_sha256.is_none()) - && (settings.schema_version == 3 || settings.allowed_script_profiles.is_none()) + && (settings.schema_version >= 3 || settings.allowed_script_profiles.is_none()) && bound_peer(&settings.agent, false) && bound_peer(&settings.helper, true) && !settings.binding.tenant_id.is_nil() diff --git a/crates/agent-windows/src/update_observation_runtime.rs b/crates/agent-windows/src/update_observation_runtime.rs new file mode 100644 index 0000000..efea9d9 --- /dev/null +++ b/crates/agent-windows/src/update_observation_runtime.rs @@ -0,0 +1,57 @@ +//! One bounded passive mTLS catalog/read-only SYSTEM observation actor. +//! Its cache is evidence for planning, never an execution permit. +use anyhow::{Result,ensure}; +use rmm_domain::agent_update::{AgentUpdateObservation,ReleaseEnvelope,ReleaseManifest}; +use rmm_agent_windows::{helper_runtime::Client,update_observer::{Request,Response}}; +use serde::Deserialize; +use std::{net::SocketAddr,time::{Duration,Instant}}; +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct Catalog {status:String,release:Option,observed_at:chrono::DateTime,server_time:chrono::DateTime,job_created:bool} +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct CatalogRelease {release_envelope:ReleaseEnvelope,manifest:ReleaseManifest} +async fn collect(client:reqwest::Client,address:SocketAddr,helper:Client,generation:u64)->Result{ + let url=format!("https://{}:{}/agent/v1/releases/current?platform={}",crate::https_channel::server_name()?,address.port(),rmm_agent_windows::release_platform::TRIPLE); + let response=client.get(&url).send().await?; + ensure!(response.url().as_str()==url,"UPDATE_CATALOG_REDIRECT"); + let raw=crate::https_channel::bounded_body(response,64*1024,"application/json").await?; + let catalog:Catalog=serde_json::from_slice(&raw)?; + ensure!(!catalog.job_created && catalog.observed_at.timestamp()>0 && catalog.server_time.timestamp()>0,"UPDATE_CATALOG_NOT_A_JOB"); + let candidate=match (catalog.status.as_str(),catalog.release) { + ("not_configured",None)=>None, + ("available",Some(release))=>{ + ensure!(release.release_envelope.decode().map_err(anyhow::Error::msg)?.manifest==release.manifest && release.manifest.platform==rmm_agent_windows::release_platform::WIRE,"UPDATE_CATALOG_UNSIGNED_VIEW");Some(release.release_envelope) + } + _=>anyhow::bail!("UPDATE_CATALOG_RESPONSE_SHAPE"), + }; + helper.observe_update(Request{generation,candidate}).await +} +#[derive(Default)] +pub struct Observer {current:Option,pending:Option>>,started:Option} +impl Observer { + pub async fn poll(&mut self,generation:u64,transport:impl FnOnce()->Result<(reqwest::Client,SocketAddr,Client)>){ + if self.pending.as_ref().is_some_and(|task|task.is_finished()) { + let task=self.pending.take().expect("finished task"); + self.current=match task.await {Ok(Ok(value)) if value.validate(generation).is_ok()=>Some(value),_=>None}; + } + if self.pending.is_none() && self.started.is_none_or(|at|at.elapsed()>=Duration::from_secs(60)) { + self.started=Some(Instant::now()); + if let Ok((client,address,helper))=transport(){self.pending=Some(tokio::spawn(async move{tokio::time::timeout(Duration::from_secs(50),collect(client,address,helper,generation)).await?}));} + else {self.current=None;} + } + } + pub fn cached(&self)->Option<&Response>{ + let value=self.current.as_ref()?; + let age=chrono::Utc::now()-value.observation.observed_at; + (value.validate(value.generation).is_ok() && age>=chrono::Duration::zero() && age<=chrono::Duration::seconds(90)).then_some(value) + } + pub fn observation(&self,generation:u64)->AgentUpdateObservation{ + self.cached().filter(|v|v.generation==generation).map(|v|v.observation.clone()).unwrap_or_else(||AgentUpdateObservation::not_configured(rmm_agent_windows::release_platform::WIRE,chrono::Utc::now())) + } + pub fn capabilities(&self)->Vec{ + let Some(value)=self.cached() else{return vec![];}; + let(Some(updater),Some(predecessor))=(&value.observation.updater,&value.observation.predecessor) else{return vec![];}; + vec![rmm_domain::agent_update::APPLY_CAPABILITY.into(),rmm_domain::agent_update::CHECK_CAPABILITY.into(),"update_agent".into(),"system:update_agent".into(),"helper.system.v1".into(),format!("updater.binary.sha256:{}",updater.binary_sha256),format!("updater.policy.sha256:{}",updater.policy_sha256),format!("helper.binary.sha256:{}",predecessor.helper_sha256)] + } +} diff --git a/crates/agent-windows/src/update_observer.rs b/crates/agent-windows/src/update_observer.rs new file mode 100644 index 0000000..73baa99 --- /dev/null +++ b/crates/agent-windows/src/update_observer.rs @@ -0,0 +1,89 @@ +//! Passive SYSTEM measurements for the code-pair updater. No staging, journal +//! append, service mutation, approval, grant or repair occurs on this path. +use crate::{ + helper_system::UpdateContext, + update_ipc, + update_native::{Budget,Role,services,transition}, + update_state::QualifiedRegistry, + update_trust::{Protected,TrustState}, +}; +use anyhow::{Context,Result,ensure}; +use rmm_agent_core::{helper_reconcile::{BootSource,ExecutorLedgerGuard},reconcile::SyncClock}; +use rmm_domain::{agent_update::{AgentUpdateObservation,CandidatePreview,CatalogCandidate,CatalogCheckReport,CatalogCheckStatus,ObservationQuality,ReleaseEnvelope,ResolvedAgentUpdate,UpdateProfile,Recovery,HealthProfile},jobs::hash}; +use serde::{Deserialize,Serialize}; +use std::{path::Path,time::Duration}; +use uuid::Uuid; +#[derive(Clone,Debug,Serialize,Deserialize)] +#[serde(deny_unknown_fields)] +pub struct Request { pub generation:u64,pub candidate:Option } +#[derive(Clone,Debug,Serialize,Deserialize)] +#[serde(deny_unknown_fields)] +pub struct Response { + pub generation:u64, + pub observation:AgentUpdateObservation, + pub catalog:CatalogCheckReport, + pub installed_record:Vec, +} +fn require_sync(ctx:&UpdateContext<'_>,generation:u64)->Result{ + ctx.guard.check(ctx.db)?; + ctx.clock.require_generation(generation)?; + ensure!(crate::update_control::active_grant(ctx.db)?.is_none(),"UPDATE_OBSERVE_NO_ACTIVE_HANDOFF"); + ensure!(ctx.sync.as_ref().is_some_and(|s|s.can_start(ctx.db,ctx.guard,generation,ctx.clock,ctx.boot)),"UPDATE_OBSERVE_CURRENT_SIGNED_SYNC_REQUIRED"); + let decision:String=ctx.db.query_row("SELECT last_decision FROM helper_sync_meta WHERE id=1 AND generation=?1 AND fault IS NULL",[generation],|r|r.get(0))?; + Ok(Uuid::parse_str(&decision)?) +} +pub(crate) fn collect(ctx:UpdateContext<'_>,request:&Request)->Result{ + let decision=require_sync(&ctx,request.generation)?; + let trust=TrustState::load_observed(ctx.binding,ctx.clock)?; + trust.qualify_history(ctx.db,ctx.guard,ctx.binding)?; + let budget=Budget::new(ctx.boot,ctx.boot.current_boot()?,Duration::from_secs(10))?; + let registry=QualifiedRegistry::load(&trust)?; + let mut running=services::Running::observe([ctx.pin.agent.clone(),ctx.pin.helper.clone()],&budget)?; + let(mut updater,updater_identity)=services::observe_updater(trust.policy(),&budget)?; + let pin=update_ipc::Pin{schema_version:1,binding:ctx.binding.clone(),policy_sha256:trust.updater_binding().policy_sha256.clone(),helper:ctx.pin.helper.clone(),updater:services::updater_pin(trust.policy())?}; + let description=update_ipc::exchange(&pin,&update_ipc::Request::Describe{},Duration::from_secs(5))?; + ensure!(description.state==update_ipc::State::Described && !description.ready && description.head_sha256.is_none() && description.updater==updater_identity,"UPDATE_OBSERVE_LIVE_UPDATER"); + registry.verify_observed(&running.proofs(),&services::updater_configuration_sha256(&pin.updater)?)?; + ensure!(ctx.pin.agent.binary_sha256==trust.predecessor().agent_sha256 && ctx.pin.helper.binary_sha256==trust.predecessor().helper_sha256,"UPDATE_OBSERVE_ACTUAL_PREDECESSOR"); + let(_,helper)=update_ipc::observe(&ctx.pin.helper,rmm_domain::agent_update::ParticipantRole::WindowsHelper)?; + ensure!(helper.pid==std::process::id(),"UPDATE_OBSERVE_ACTUAL_SYSTEM_HELPER"); + let mut protected=vec![]; + let mut previews=vec![]; + let mut catalog=CatalogCheckReport{schema_version:1,source_id:"mtls:release-catalog-v1".into(),checked_at:ctx.clock.now()?,status:CatalogCheckStatus::NotConfigured,candidate:None}; + if let Some(candidate)=&request.candidate { + trust.verify_candidate(candidate,ctx.clock)?; + let decoded=candidate.decode().map_err(anyhow::Error::msg)?; + let manifest=&decoded.manifest; + catalog.status=if manifest.release_id==trust.predecessor().release_id {CatalogCheckStatus::Current} else {CatalogCheckStatus::Available}; + catalog.candidate=Some(CatalogCandidate{release_id:manifest.release_id,release_sequence:manifest.release_sequence,version:manifest.version.clone(),manifest_sha256:hash(&decoded.payload_bytes),keyring_generation:trust.updater_binding().keyring_generation}); + if manifest.release_id!=trust.predecessor().release_id { + let readers=[ctx.pin.agent.service_sid.clone(),ctx.pin.helper.service_sid.clone()]; + let(f,settings)=Protected::read_shared(Path::new(Role::Settings.target()),32768,&readers)?;protected.push(f); + let(f,pin)=Protected::read_shared(Path::new(Role::Pin.target()),32768,&readers)?;protected.push(f); + let(f,time)=Protected::read_shared(Path::new(Role::TimeProfile.target()),32768,&readers)?;protected.push(f); + let(f,candidate_time)=Protected::read(Path::new(r"C:\ProgramData\RustDiscoveryUpdater\candidate-time-profile.json"),32768)?;protected.push(f); + let rendered=transition::render(transition::Inputs{settings:&settings,pin:&pin,time_profile:&time,qualified_candidate_time_profile:&candidate_time,target_agent_sha256:&manifest.artifacts[0].sha256,target_helper_sha256:&manifest.artifacts[1].sha256})?; + let update=ResolvedAgentUpdate{schema_version:1,profile:UpdateProfile::FixedCodePairV1,release_envelope:candidate.clone(),release_envelope_sha256:candidate.sha256().map_err(anyhow::Error::msg)?,manifest_sha256:hash(&decoded.payload_bytes),predecessor:trust.predecessor().clone(),updater:trust.updater_binding().clone(),peer_pin_transition:rendered.proof().clone(),recovery:Recovery::RestoreExactPredecessorOnce,health_profile:HealthProfile::MtlsInventorySyncV1,health_timeout_seconds:180,no_reboot:true}; + ensure!(update.validate(),"UPDATE_OBSERVE_RENDERED_PLAN"); + previews.push(CandidatePreview{release_id:manifest.release_id,manifest_sha256:update.manifest_sha256,peer_pin_transition:update.peer_pin_transition}); + } + } + running.check(&budget)?;updater.check()?;registry.verify()?;trust.recheck_protected()?; + for file in protected {file.verify()?;} + ensure!(require_sync(&ctx,request.generation)?==decision,"UPDATE_OBSERVE_SIGNED_HEAD_CHANGED"); + let observed_at=ctx.clock.now()?; + let observed_at=observed_at-chrono::Duration::nanoseconds(i64::from(observed_at.timestamp_subsec_nanos()%1_000_000)); + let observation=AgentUpdateObservation{schema_version:1,platform:crate::release_platform::WIRE,observed_at,quality:ObservationQuality::Valid,predecessor:Some(trust.predecessor().clone()),updater:Some(trust.updater_binding().clone()),activation_floor:Some(trust.activation_floor()),rolled_back:false,helper_observation_sha256:Some(hash(&serde_json::to_vec(&(running.proofs(),updater_identity,decision,request.generation,&previews))?)),signed_sync_decision_id:Some(decision),candidate_previews:previews}; + ensure!(observation.validate() && catalog.validate(observed_at,observed_at),"UPDATE_OBSERVE_OUTPUT_SHAPE"); + Ok(Response{generation:request.generation,observation,catalog,installed_record:trust.installed_raw().to_vec()}) +} +impl Response { + pub fn validate(&self,generation:u64)->Result<()> { + ensure!(self.generation==generation && self.observation.platform==crate::release_platform::WIRE && self.observation.quality==ObservationQuality::Valid && self.observation.validate() && self.catalog.validate(self.observation.observed_at,self.observation.observed_at),"UPDATE_OBSERVE_RESPONSE"); + let record=rmm_domain::agent_update_provisioning::InstalledReleaseRecord::from_bytes(&self.installed_record).map_err(anyhow::Error::msg)?; + let predecessor=self.observation.predecessor.as_ref().context("UPDATE_OBSERVE_PREDECESSOR")?; + let manifest=record.release_envelope.decode().map_err(anyhow::Error::msg)?.manifest; + ensure!(hash(&self.installed_record)==predecessor.installed_record_sha256 && record.manifest_sha256==predecessor.manifest_sha256 && manifest.release_id==predecessor.release_id && manifest.release_sequence==predecessor.release_sequence && manifest.artifacts[0].sha256==predecessor.agent_sha256 && manifest.artifacts[1].sha256==predecessor.helper_sha256 && Some(record.activation_floor)==self.observation.activation_floor && record.rolled_back==self.observation.rolled_back,"UPDATE_OBSERVE_RECORD_BINDING"); + Ok(()) + } +} diff --git a/crates/agent-windows/src/update_original.rs b/crates/agent-windows/src/update_original.rs new file mode 100644 index 0000000..fde8a03 --- /dev/null +++ b/crates/agent-windows/src/update_original.rs @@ -0,0 +1,196 @@ +//! Independently reverify the retained ORIGINAL request, never an IPC-supplied +//! approval bit, a replacement request or a renewed start window. +//! Windows SYSTEM/code-pair-clock profile only; no Linux or four-file fallback. +use crate::update_native::Budget; +use anyhow::{Result, ensure}; +use rmm_agent_core::{ + auth::{Binding, Request}, + reconcile::SyncClock, +}; +use rmm_domain::{ + agent_update::{ParticipantRole, ResolvedAgentUpdate, UpdateDelegation}, + jobs::{Action, ExecutionPermitPayload, JobPayload, hash}, +}; +use rmm_updater_handoff::{Handoff, PinTransition, Service}; + +pub struct Original { + request: Request, + permit: ExecutionPermitPayload, + job: JobPayload, + update: ResolvedAgentUpdate, + handoff: Handoff, + delegation: UpdateDelegation, + start_bytes: Vec, +} +impl Original { + /// `start_bytes` must come from execution_evidence.start in the SAME + /// existing guarded ledger. This is validation only; callers must re-read + /// and compare that immutable row at each subsequent guarded operation. + pub fn verify( + binding: &Binding, + start_bytes: &[u8], + record: &[u8], + delegation: UpdateDelegation, + clock: &impl SyncClock, + budget: &Budget<'_>, + ) -> Result { + let result = Self::verify_retained(binding, start_bytes, record, delegation)?; + result.check_current(binding, clock, budget)?; + Ok(result) + } + /// Historical evidence ONLY. Never supplies current boot/time/owner trust, + /// health authority, a new lease or permission for any native effect. + pub fn verify_retained( + binding: &Binding, + start_bytes: &[u8], + record: &[u8], + delegation: UpdateDelegation, + ) -> Result { + ensure!( + !start_bytes.is_empty() + && start_bytes.len() <= 512 * 1024 + && !record.is_empty() + && record.len() <= rmm_updater_handoff::MAX_RECORD_BYTES, + "UPDATE_ORIGINAL_LIMIT" + ); + let handoff: Handoff = serde_json::from_slice(record)?; + handoff.validate()?; + ensure!( + handoff.bytes()? == record + && delegation.validate() + && delegation.handoff_sha256 == hash(record) + && delegation.owner_nonce == handoff.owner_nonce + && delegation.boot_id == handoff.boot_id + && delegation.updater.role == ParticipantRole::WindowsUpdater + && delegation.updater.image_sha256 == handoff.updater_sha256 + && delegation.original_helper.image_sha256 == handoff.predecessor.helper_sha256 + && u64::try_from(delegation.prepared_at.timestamp())? == handoff.consumed_at, + "UPDATE_ORIGINAL_DELEGATION" + ); + let start: serde_json::Value = serde_json::from_slice(start_bytes)?; + let request: Request = serde_json::from_value(start["request"].clone())?; + ensure!( + hash(start_bytes) == handoff.attempt.original_start_witness_sha256 + && hash(&serde_json::to_vec(&request)?) == handoff.attempt.original_request_sha256, + "UPDATE_ORIGINAL_START_CHANGED" + ); + // Original consumption happened at the immutable prepared_at. It must + // have had a valid live start grant THEN. Current checks below constrain + // this one already consumed attempt; they grant no new start window. + let (job, permit) = binding.verify(&request, delegation.prepared_at)?; + ensure!( + rmm_agent_core::ledger::start_witness_bytes( + &permit, + &request, + handoff.boot_id, + delegation.prepared_at + )? == start_bytes, + "UPDATE_ORIGINAL_START_CHANGED" + ); + ensure!( + job.execution_identity == "system" + && permit.action == "update_agent" + && Some(handoff.attempt.plan_id) == permit.agent_update_plan_id + && handoff.attempt.tenant_id == permit.tenant_id + && handoff.attempt.asset_id == permit.asset_id + && handoff.attempt.agent_id == permit.agent_id + && handoff.attempt.enrollment_generation == permit.enrollment_generation + && handoff.attempt.assignment_version == permit.assignment_version + && handoff.attempt.job_id == permit.job_id + && handoff.attempt.attempt_id == permit.attempt_id + && handoff.attempt.grant_id == permit.grant_id + && handoff.attempt.authorization_id == permit.authorization_id + && handoff.attempt.plan_sha256 == permit.plan_hash + && handoff.attempt.job_payload_sha256 == permit.job_payload_hash, + "UPDATE_ORIGINAL_JOB_BINDING" + ); + let Action::UpdateAgent { update } = &job.action else { + anyhow::bail!("UPDATE_ACTION_REQUIRED") + }; + ensure!( + rmm_domain::agent_update::handoff_matches_job(&handoff, &job) + && update.validate() + && update.manifest_sha256 == handoff.target.manifest_sha256 + && update.predecessor.manifest_sha256 == handoff.predecessor.manifest_sha256 + && update.predecessor.agent_sha256 == handoff.predecessor.agent_sha256 + && update.predecessor.helper_sha256 == handoff.predecessor.helper_sha256 + && update.predecessor.installed_record_sha256 == handoff.predecessor_record_sha256 + && update.updater.binary_sha256 == handoff.updater_sha256 + && update.updater.policy_sha256 == handoff.updater_policy_sha256 + && matches!( + handoff.pin_transition, + PinTransition::WindowsCodePairClockV1 + ) + && handoff.stop_set == [Service::WindowsAgent, Service::WindowsHelper], + "UPDATE_ORIGINAL_CODE_POLICY_BINDING" + ); + let update = update.as_ref().clone(); + let decoded = update + .release_envelope + .decode() + .map_err(anyhow::Error::msg)?; + ensure!( + decoded.manifest.artifacts[0].sha256 == handoff.target.agent_sha256 + && decoded.manifest.artifacts[1].sha256 == handoff.target.helper_sha256, + "UPDATE_ORIGINAL_TARGET_PAIR" + ); + let result = Self { + request, + permit, + job, + update, + handoff, + delegation, + start_bytes: start_bytes.to_vec(), + }; + Ok(result) + } + pub fn check_current( + &self, + binding: &Binding, + clock: &impl SyncClock, + budget: &Budget<'_>, + ) -> Result<()> { + ensure!( + budget.boot_id()? == self.handoff.boot_id, + "UPDATE_ORIGINAL_BOOT_CHANGED" + ); + // Budget independently pins the actual native boot and monotonic + // lifetime. The trusted clock must cover its entire signed interval, + // rather than treating the local wall clock as a lower bound. + let (lower, upper) = clock.bounds()?; + ensure!( + lower <= upper + && lower >= self.delegation.prepared_at + && u64::try_from(upper.timestamp())? < self.handoff.finish_before + && upper + < self.job.start_before + + chrono::Duration::seconds(i64::from(self.job.max_runtime_seconds)) + && self.handoff.finish_before + <= self.handoff.consumed_at + u64::from(self.job.max_runtime_seconds), + "UPDATE_ORIGINAL_EXPIRED" + ); + let (job, permit) = binding.verify(&self.request, self.delegation.prepared_at)?; + ensure!( + serde_json::to_vec(&job)? == serde_json::to_vec(&self.job)? + && serde_json::to_vec(&permit)? == serde_json::to_vec(&self.permit)?, + "UPDATE_ORIGINAL_CHANGED" + ); + Ok(()) + } + pub fn handoff(&self) -> &Handoff { + &self.handoff + } + pub fn delegation(&self) -> &UpdateDelegation { + &self.delegation + } + pub fn update(&self) -> &ResolvedAgentUpdate { + &self.update + } + pub fn permit(&self) -> &ExecutionPermitPayload { + &self.permit + } + pub fn start_bytes(&self) -> &[u8] { + &self.start_bytes + } +} diff --git a/crates/agent-windows/src/update_owned.rs b/crates/agent-windows/src/update_owned.rs new file mode 100644 index 0000000..a564c2e --- /dev/null +++ b/crates/agent-windows/src/update_owned.rs @@ -0,0 +1,830 @@ +//! Stable updater ownership of the existing SYSTEM ledger. No CREATE, schema +//! initialization, replayed activation, replacement ledger or reset is allowed. +use crate::{ + helper_ipc::{self as ipc, PeerProof, PinnedFile}, + signed_clock::BoundClock, + update_ipc, + update_native::{ + Budget, Role, + files::{self, Location}, + services::Stopped, + }, + update_original::Original, + update_state::{AgentStateFile, Bundle, QualifiedRegistry, RetainedSet}, + update_trust::TrustState, +}; +use anyhow::{Context, Result, ensure}; +use fs2::FileExt; +use rmm_agent_core::{ + auth::Binding, + helper_reconcile::ExecutorLedgerGuard, + reconcile::SyncClock, + update_handoff::{ + self as core, NativeEffect, NativeEffectStage, NativeFileRole, NativeService, Participant, + UpdateParticipantGuard, + }, +}; +use rmm_domain::{ + agent_update::{ParticipantRole, UpdateDelegation}, + jobs::hash, +}; +use rmm_updater_handoff::{Event, Evidence, Handoff, Phase}; +use rusqlite::{Connection, OpenFlags}; +use std::{cell::RefCell, path::Path, time::Duration}; +const ROOT: &str = r"C:\ProgramData\RustDiscoverySystem\state"; +const LEDGER: &str = r"C:\ProgramData\RustDiscoverySystem\state\ledger.sqlite"; +const LOCK: &str = r"C:\ProgramData\RustDiscoverySystem\state\executor.lock"; +const AGENT_LOCK: &str = r"C:\ProgramData\RustDiscovery\state\agent.lock"; +/// These are the TWO original locks used by the registered helper and agent, +/// acquired only after their exact original instances have terminated. +pub struct ClosedFiles { + root: RefCell, + ledger: RefCell, + executor: RefCell, + agent: RefCell, +} +impl ClosedFiles { + pub fn acquire(bundle: &Bundle, stopped: &Stopped, budget: &Budget<'_>) -> Result { + bundle.validate()?; + stopped.check(budget)?; + let helper = ipc::service_sid(ipc::HELPER_SERVICE)?; + let root = PinnedFile::open( + Path::new(ROOT), + true, + &[], + std::slice::from_ref(&helper), + true, + )?; + let executor = PinnedFile::open( + Path::new(LOCK), + false, + &[], + std::slice::from_ref(&helper), + true, + )?; + ensure!( + executor.identity == bundle.ledger.lock, + "UPDATE_ORIGINAL_LOCK_IDENTITY" + ); + executor + .file + .try_lock_exclusive() + .context("UPDATE_ORIGINAL_EXECUTOR_BUSY")?; + let agent = AgentStateFile::lock()?; + let expected_agent = bundle + .retained + .iter() + .find(|p| p.spec.path == Path::new(AGENT_LOCK)) + .context("UPDATE_ORIGINAL_AGENT_LOCK_REQUIRED")?; + ensure!( + agent.identity == expected_agent.spec.identity, + "UPDATE_ORIGINAL_AGENT_LOCK_IDENTITY" + ); + agent + .file + .try_lock_exclusive() + .context("UPDATE_ORIGINAL_AGENT_BUSY")?; + let ledger = PinnedFile::open(Path::new(LEDGER), false, &[], &[helper], true)?; + ensure!( + ledger.identity == bundle.ledger.ledger, + "UPDATE_ORIGINAL_LEDGER_IDENTITY" + ); + stopped.check(budget)?; + let value = Self { + root: RefCell::new(root), + ledger: RefCell::new(ledger), + executor: RefCell::new(executor), + agent: RefCell::new(agent), + }; + value.verify(bundle, stopped, budget)?; + Ok(value) + } + fn verify(&self, bundle: &Bundle, stopped: &Stopped, budget: &Budget<'_>) -> Result<()> { + stopped.check(budget)?; + for file in [&self.root, &self.ledger, &self.executor] { + file.try_borrow_mut()?.check()?; + } + self.agent.try_borrow()?.check()?; + ensure!( + self.ledger.try_borrow()?.identity == bundle.ledger.ledger + && self.executor.try_borrow()?.identity == bundle.ledger.lock, + "UPDATE_OWNED_LEDGER_REPLACED" + ); + Ok(()) + } +} +/// Produced by consuming both actually-held original locks after the SQLite +/// connection has closed; the retained handles continue to pin their names. +pub struct ReleasedFiles { + files: ClosedFiles, +} +impl ReleasedFiles { + pub(crate) fn check(&self, bundle: &Bundle) -> Result<()> { + for file in [&self.files.root, &self.files.ledger, &self.files.executor] { + file.try_borrow_mut()?.check()?; + } + self.files.agent.try_borrow()?.check()?; + ensure!( + self.files.ledger.try_borrow()?.identity == bundle.ledger.ledger + && self.files.executor.try_borrow()?.identity == bundle.ledger.lock, + "UPDATE_RELEASED_FILES_CHANGED" + ); + Ok(()) + } +} +impl ClosedFiles { + pub fn release( + self, + bundle: &Bundle, + stopped: &Stopped, + budget: &Budget<'_>, + ) -> Result { + self.verify(bundle, stopped, budget)?; + FileExt::unlock(&self.executor.try_borrow()?.file)?; + FileExt::unlock(&self.agent.try_borrow()?.file)?; + let result = ReleasedFiles { files: self }; + result.check(bundle)?; + Ok(result) + } +} +pub struct Inputs<'a, 'b> { + pub closed: &'a ClosedFiles, + pub stopped: &'a Stopped, + pub bundle: &'a Bundle, + pub bundle_recheck: &'a dyn Fn() -> Result<()>, + pub original: &'a Original, + pub binding: &'a Binding, + pub clock: &'a BoundClock, + pub budget: &'a Budget<'b>, + pub updater: &'a RefCell, + pub retained: &'a RetainedSet, + pub registry: &'a QualifiedRegistry, + pub trust: &'a TrustState, +} +pub struct Guard<'a, 'b> { + input: Inputs<'a, 'b>, + sqlite: usize, + return_before: Option, +} +pub struct OwnedLedger<'a, 'b> { + db: Connection, + guard: Guard<'a, 'b>, +} +impl<'a, 'b> OwnedLedger<'a, 'b> { + pub fn open(input: Inputs<'a, 'b>) -> Result { + input + .closed + .verify(input.bundle, input.stopped, input.budget)?; + ensure!( + input.bundle.ledger.sha256()? == input.original.handoff().ledger_identity_sha256 + && input.retained.sha256()? == input.original.handoff().retained_state_sha256, + "UPDATE_ORIGINAL_STATE_BINDING" + ); + let db = Connection::open_with_flags( + LEDGER, + OpenFlags::SQLITE_OPEN_READ_WRITE | OpenFlags::SQLITE_OPEN_NO_MUTEX, + )?; + db.busy_timeout(Duration::ZERO)?; + ensure!( + db.query_row("PRAGMA journal_mode", [], |r| r.get::<_, String>(0))? == "delete" + && db.query_row("PRAGMA synchronous", [], |r| r.get::<_, u32>(0))? >= 2, + "UPDATE_LEDGER_DURABILITY_REQUIRED" + ); + let sqlite = unsafe { db.handle() } as usize; + let (count, max): (usize, Option) = db.query_row( + "SELECT count(*),max(length(event)) FROM agent_update_handoff_events WHERE grant_id=?1", + [input.original.permit().grant_id.to_string()], + |r| Ok((r.get(0)?, r.get(1)?)), + )?; + ensure!( + count <= rmm_updater_handoff::MAX_V2_EVENTS + && max.is_none_or(|n| n <= rmm_updater_handoff::MAX_EVENT_BYTES), + "UPDATE_ORIGINAL_EVENT_LIMIT" + ); + let mut query = db.prepare( + "SELECT event FROM agent_update_handoff_events WHERE grant_id=?1 ORDER BY sequence", + )?; + let rows = query + .query_map([input.original.permit().grant_id.to_string()], |r| { + r.get::<_, Vec>(0) + })? + .collect::>>()?; + drop(query); + let mut return_before = None; + for raw in rows { + let event: Event = serde_json::from_slice(&raw)?; + if matches!(event.evidence, Evidence::LedgerReturnIntent) { + ensure!( + return_before.is_none(), + "UPDATE_MULTIPLE_ORIGINAL_RETURN_EVENTS" + ); + return_before = Some( + event + .observed_at + .checked_add(180) + .context("UPDATE_RETURN_DEADLINE_OVERFLOW")?, + ); + } + } + let guard = Guard { + input, + sqlite, + return_before, + }; + guard.check(&db)?; + core::read(&db, &guard, guard.input.original.permit().grant_id)?; + guard + .input + .trust + .qualify_history(&db, &guard, guard.input.binding)?; + db.execute_batch("PRAGMA foreign_keys=ON")?; + ensure!( + db.query_row("PRAGMA foreign_keys", [], |r| r.get::<_, bool>(0))?, + "UPDATE_LEDGER_FOREIGN_KEYS_REQUIRED" + ); + rmm_agent_core::ledger::bounded_journal_capacity(&db)?; + Ok(Self { db, guard }) + } + pub fn record_stops( + &mut self, + observations: crate::update_native::control_fence::StopObservations, + ) -> Result<()> { + self.guard.effect_window()?; + ensure!( + self.guard.input.stopped.proofs() == observations.proofs, + "UPDATE_STOP_SOURCE_CHANGED" + ); + for (claim, observed) in observations.claims.iter().zip(&observations.observations) { + core::observe_native_effect( + &mut self.db, + &self.guard, + claim, + observed, + self.guard.input.clock.reading()?.upper, + )?; + } + self.append(Evidence::AllStopped { + observation_sha256: hash(&serde_json::to_vec(self.guard.input.stopped.proofs())?), + })?; + let owner = &self.guard.input.original.delegation().updater; + self.append(Evidence::UpdaterOwnsLedger { + process: rmm_updater_handoff::Process { + pid: owner.pid, + birth: owner.birth, + image_sha256: owner.image_sha256.clone(), + }, + ledger_identity_sha256: self.guard.input.bundle.ledger.sha256()?, + }) + } + fn append(&mut self, evidence: Evidence) -> Result<()> { + let grant = self.guard.input.original.permit().grant_id; + let journal = core::read(&self.db, &self.guard, grant)?; + let event = journal.prepare( + u64::try_from(self.guard.input.clock.reading()?.upper.timestamp())?, + evidence, + )?; + core::append( + &mut self.db, + &self.guard, + grant, + journal.head_sha256(), + &event, + ) + } + pub fn prepare_return_and_close( + mut self, + ) -> Result { + self.guard.effect_window()?; + let grant = self.guard.input.original.permit().grant_id; + let journal = core::read(&self.db, &self.guard, grant)?; + ensure!( + journal.phase() == Phase::PairVerified, + "UPDATE_VERIFIED_PAIR_REQUIRED" + ); + let now = self.guard.input.clock.reading()?.upper; + let event = journal.prepare( + u64::try_from(now.timestamp())?, + Evidence::LedgerReturnIntent, + )?; + let claims = core::prepare_windows_return_and_starts( + &mut self.db, + &self.guard, + grant, + journal.head_sha256(), + &event, + now, + )?; + let proof = core::current_proof(&self.db, &self.guard, grant)? + .context("UPDATE_RETURN_PREFIX_REQUIRED")?; + self.close()?; + Ok( + crate::update_native::control_fence::PreparedStart::after_closed_connection( + claims, proof, + ), + ) + } + pub fn parts(&mut self) -> (&mut Connection, &Guard<'a, 'b>) { + (&mut self.db, &self.guard) + } + pub fn close(self) -> Result<()> { + self.guard.check(&self.db)?; + self.db.close().map_err(|(_, error)| error)?; + self.guard.input.closed.verify( + self.guard.input.bundle, + self.guard.input.stopped, + self.guard.input.budget, + ) + } +} +impl Guard<'_, '_> { + fn current(&self) -> Result<()> { + let i = &self.input; + (i.bundle_recheck)()?; + i.closed.verify(i.bundle, i.stopped, i.budget)?; + Original::verify_retained( + i.binding, + i.original.start_bytes(), + &i.original.handoff().bytes()?, + i.original.delegation().clone(), + )?; + i.trust.recheck_protected()?; + let updater_pin = crate::update_native::services::updater_pin(i.trust.policy())?; + let updater_configuration = + crate::update_native::services::updater_configuration_sha256(&updater_pin)?; + ensure!( + updater_configuration == i.trust.policy().updater_service.unit_sha256, + "UPDATE_UPDATER_CONFIGURATION_CHANGED" + ); + i.registry + .verify_observed(i.stopped.proofs(), &updater_configuration)?; + i.retained.verify()?; + let mut updater = i.updater.try_borrow_mut()?; + updater.check()?; + ensure!( + update_ipc::participant(&updater, ParticipantRole::WindowsUpdater)? + == i.original.delegation().updater, + "UPDATE_ORIGINAL_UPDATER_PROCESS_CHANGED" + ); + Ok(()) + } + fn effect_window(&self) -> Result<()> { + self.current()?; + let i = &self.input; + i.original.check_current(i.binding, i.clock, i.budget)?; + if let Some(until) = self.return_before { + ensure!( + u64::try_from(i.clock.reading()?.upper.timestamp())? < until, + "UPDATE_ORIGINAL_HEALTH_WINDOW_EXPIRED" + ); + } + i.trust.recheck_prepared(i.original.update(), i.clock) + } + fn same(&self, h: &Handoff, d: &UpdateDelegation) -> Result<()> { + ensure!( + h.bytes()? == self.input.original.handoff().bytes()? + && d == self.input.original.delegation(), + "UPDATE_ORIGINAL_OWNER_CHANGED" + ); + self.current() + } + fn file(&self, role: Role, location: Location, candidate: bool) -> Result<()> { + let bound = self + .input + .bundle + .files + .iter() + .find(|v| v.role == role) + .context("UPDATE_ORIGINAL_ROLE_REQUIRED")?; + let expected = if candidate { + &bound.staged + } else { + &bound.original + }; + ensure!( + files::observe_bound( + role, + self.input.original.handoff().owner_nonce, + location, + self.input.budget + )? == *expected, + "UPDATE_OWNED_FILE_CHANGED" + ); + Ok(()) + } + fn pair(&self, candidate: bool) -> Result<()> { + for f in &self.input.bundle.files { + self.file(f.role, Location::Target, candidate)?; + self.file( + f.role, + if candidate { + Location::Previous + } else { + Location::Rejected + }, + !candidate, + )?; + } + Ok(()) + } +} +impl ExecutorLedgerGuard for Guard<'_, '_> { + fn check(&self, db: &Connection) -> Result<()> { + self.current()?; + self.input + .stopped + .verify_failure_claims(db, self.input.original.handoff())?; + ensure!( + unsafe { db.handle() } as usize == self.sqlite && db.path() == Some(LEDGER), + "UPDATE_OWNED_SQLITE_CONNECTION_CHANGED" + ); + let start: Vec = db.query_row( + "SELECT start FROM execution_evidence WHERE grant_id=?1", + [self.input.original.permit().grant_id.to_string()], + |r| r.get(0), + )?; + ensure!( + start == self.input.original.start_bytes(), + "UPDATE_ORIGINAL_START_CHANGED" + ); + let other: u64 = db.query_row( + "SELECT count(*) FROM consumed WHERE result IS NULL AND grant_id<>?1", + [self.input.original.permit().grant_id.to_string()], + |r| r.get(0), + )?; + ensure!(other == 0, "UPDATE_OTHER_UNRESOLVED_ATTEMPT"); + Ok(()) + } + fn check_update_owner( + &self, + h: &Handoff, + d: &UpdateDelegation, + phase: Phase, + _events: &[Event], + ) -> Result<()> { + ensure!( + !matches!( + phase, + Phase::HandoffConsumed + | Phase::ServicesStarted + | Phase::HealthVerified + | Phase::RollbackServicesStarted + | Phase::RollbackHealthVerified + | Phase::OutcomePersisted + ), + "UPDATE_STABLE_WRITER_PHASE" + ); + self.same(h, d)?; + self.effect_window() + } +} +fn role(r: NativeFileRole) -> Result { + Ok(match r { + NativeFileRole::AgentBinary => Role::Agent, + NativeFileRole::HelperBinary => Role::Helper, + NativeFileRole::WindowsSettings => Role::Settings, + NativeFileRole::WindowsPin => Role::Pin, + NativeFileRole::WindowsTimeProfile => Role::TimeProfile, + _ => anyhow::bail!("UPDATE_WINDOWS_FILE_ROLE_REQUIRED"), + }) +} +impl UpdateParticipantGuard for Guard<'_, '_> { + fn participant(&self) -> Participant { + Participant::StableUpdater + } + fn verify_native_effect( + &self, + h: &Handoff, + d: &UpdateDelegation, + effect: &NativeEffect, + stage: NativeEffectStage, + ) -> Result<()> { + self.same(h, d)?; + self.effect_window()?; + match (effect, stage) { + ( + NativeEffect::StartService { .. } | NativeEffect::RollbackStopService { .. }, + NativeEffectStage::ObserveNonstart, + ) => self + .input + .stopped + .failure_observation(h, d, effect, self.input.budget) + .map(|_| ()), + (NativeEffect::StopService { service }, NativeEffectStage::Observe) => { + let expected = match service { + NativeService::WindowsAgent => super::update_native::Service::Agent, + NativeService::WindowsHelper => super::update_native::Service::Helper, + _ => anyhow::bail!("UPDATE_WINDOWS_SERVICE_REQUIRED"), + }; + ensure!( + self.input + .stopped + .proofs() + .iter() + .any(|p| p.configuration.service == expected), + "UPDATE_STOPPED_ORIGINAL_SERVICE_REQUIRED" + ); + self.input.stopped.check(self.input.budget) + } + (NativeEffect::SavePredecessor { role: r }, NativeEffectStage::Claim) => { + self.file(role(*r)?, Location::Target, false)?; + self.file(role(*r)?, Location::Stage, true) + } + (NativeEffect::SavePredecessor { role: r }, NativeEffectStage::Observe) => { + self.file(role(*r)?, Location::Previous, false) + } + (NativeEffect::PublishReplacement { role: r }, NativeEffectStage::Claim) => { + self.file(role(*r)?, Location::Previous, false)?; + self.file(role(*r)?, Location::Stage, true) + } + (NativeEffect::PublishReplacement { role: r }, NativeEffectStage::Observe) => { + self.file(role(*r)?, Location::Target, true) + } + (NativeEffect::SaveRejectedCandidate { role: r }, NativeEffectStage::Claim) => { + self.file(role(*r)?, Location::Target, true)?; + self.file(role(*r)?, Location::Previous, false) + } + (NativeEffect::SaveRejectedCandidate { role: r }, NativeEffectStage::Observe) => { + self.file(role(*r)?, Location::Rejected, true) + } + (NativeEffect::RestorePredecessor { role: r }, NativeEffectStage::Claim) => { + self.file(role(*r)?, Location::Previous, false)?; + self.file(role(*r)?, Location::Rejected, true) + } + (NativeEffect::RestorePredecessor { role: r }, NativeEffectStage::Observe) => { + self.file(role(*r)?, Location::Target, false) + } + (NativeEffect::ReturnLedger, NativeEffectStage::Claim) => self.pair(true), + (NativeEffect::RollbackReturnLedger, NativeEffectStage::Claim) => self.pair(false), + ( + NativeEffect::StartService { + service: NativeService::WindowsHelper | NativeService::WindowsAgent, + }, + NativeEffectStage::ReserveFutureStart, + ) => self.pair(true), + ( + NativeEffect::RollbackStartService { + service: NativeService::WindowsHelper | NativeService::WindowsAgent, + }, + NativeEffectStage::ReserveFutureStart, + ) => self.pair(false), + _ => anyhow::bail!("UPDATE_WINDOWS_OWNED_EFFECT_NOT_QUALIFIED"), + } + } + fn native_observation_sha256( + &self, + h: &Handoff, + d: &UpdateDelegation, + effect: &NativeEffect, + stage: NativeEffectStage, + ) -> Result { + self.same(h, d)?; + self.effect_window()?; + ensure!( + stage == NativeEffectStage::ObserveNonstart, + "UPDATE_KNOWN_NONSTART_STAGE_REQUIRED" + ); + self.input + .stopped + .failure_observation(h, d, effect, self.input.budget) + } + fn verify_update_event(&self, h: &Handoff, d: &UpdateDelegation, event: &Event) -> Result<()> { + self.same(h, d)?; + if matches!(event.evidence, Evidence::Unknown { .. }) { + return Ok(()); + } + self.effect_window()?; + match &event.evidence { + Evidence::AllStopped { observation_sha256 } => ensure!( + *observation_sha256 == hash(&serde_json::to_vec(self.input.stopped.proofs())?), + "UPDATE_STOPPED_OBSERVATION_CHANGED" + ), + Evidence::UpdaterOwnsLedger { + process, + ledger_identity_sha256, + } => ensure!( + process.pid == d.updater.pid + && process.birth == d.updater.birth + && process.image_sha256 == d.updater.image_sha256 + && *ledger_identity_sha256 == self.input.bundle.ledger.sha256()?, + "UPDATE_UPDATER_OWNER_OBSERVATION_CHANGED" + ), + Evidence::ReplaceIntent { role: r } => { + let r = self + .input + .bundle + .files + .iter() + .find(|v| v.role.handoff_role() == *r) + .context("UPDATE_ORIGINAL_ROLE_REQUIRED")? + .role; + self.file(r, Location::Target, false)?; + self.file(r, Location::Stage, true)?; + } + Evidence::Replaced { + role: r, + observed_sha256, + } => { + let f = self + .input + .bundle + .files + .iter() + .find(|v| v.role.handoff_role() == *r) + .context("UPDATE_ORIGINAL_ROLE_REQUIRED")?; + ensure!( + *observed_sha256 == f.staged.sha256, + "UPDATE_REPLACED_HASH_CHANGED" + ); + self.file(f.role, Location::Target, true)?; + self.file(f.role, Location::Previous, false)?; + } + Evidence::PairVerified { + pair, + retained_state_sha256, + } => { + ensure!( + *pair == h.target && *retained_state_sha256 == self.input.retained.sha256()?, + "UPDATE_PAIR_OBSERVATION_CHANGED" + ); + self.pair(true)?; + } + Evidence::LedgerReturnIntent => self.pair(true)?, + Evidence::RollbackIntent { + cause: + rmm_updater_handoff::RollbackCause::StartupFailed { + service: rmm_updater_handoff::Service::WindowsHelper, + }, + failure_observation_sha256, + } => { + let failed = self + .input + .stopped + .failed_start() + .context("UPDATE_KNOWN_HELPER_FAILURE_REQUIRED")?; + ensure!( + *failure_observation_sha256 == failed.sha256()?, + "UPDATE_ACTUAL_HELPER_FAILURE_CHANGED" + ); + self.input.stopped.failure_observation( + h, + d, + &NativeEffect::StartService { + service: NativeService::WindowsHelper, + }, + self.input.budget, + )?; + self.pair(true)?; + } + Evidence::RollbackStopped { + process, + ledger_identity_sha256, + observation_sha256, + } => { + let failed = self + .input + .stopped + .failed_start() + .context("UPDATE_KNOWN_HELPER_FAILURE_REQUIRED")?; + ensure!( + process.pid == d.updater.pid + && process.birth == d.updater.birth + && process.image_sha256 == d.updater.image_sha256 + && *ledger_identity_sha256 == self.input.bundle.ledger.sha256()? + && *observation_sha256 + == hash(&serde_json::to_vec(&(failed, self.input.stopped.proofs()))?), + "UPDATE_ACTUAL_ROLLBACK_STOPPED_CHANGED" + ); + self.input.stopped.check(self.input.budget)?; + } + Evidence::RestoreIntent { role: r } + | Evidence::CandidatePreserved { role: r, .. } + | Evidence::PredecessorRestored { role: r, .. } => { + let bound = self + .input + .bundle + .files + .iter() + .find(|f| f.role.handoff_role() == *r) + .context("UPDATE_ORIGINAL_RESTORE_ROLE_REQUIRED")?; + match &event.evidence { + Evidence::RestoreIntent { .. } => { + self.file(bound.role, Location::Target, true)?; + self.file(bound.role, Location::Previous, false)?; + } + Evidence::CandidatePreserved { + observation_sha256, .. + } => { + self.file(bound.role, Location::Rejected, true)?; + self.file(bound.role, Location::Previous, false)?; + ensure!( + *observation_sha256 == hash(&serde_json::to_vec(&bound.staged)?), + "UPDATE_ACTUAL_PRESERVED_CANDIDATE_CHANGED" + ); + } + Evidence::PredecessorRestored { + observed_sha256, .. + } => { + self.file(bound.role, Location::Target, false)?; + self.file(bound.role, Location::Rejected, true)?; + ensure!( + *observed_sha256 == bound.original.sha256, + "UPDATE_ACTUAL_RESTORED_PREDECESSOR_CHANGED" + ); + } + _ => unreachable!(), + } + } + Evidence::PredecessorVerified { + pair, + retained_state_sha256, + predecessor_record_sha256, + } => { + ensure!( + *pair == h.predecessor + && *retained_state_sha256 == self.input.retained.sha256()? + && *predecessor_record_sha256 == hash(self.input.trust.installed_raw()), + "UPDATE_PREDECESSOR_OBSERVATION_CHANGED" + ); + self.pair(false)?; + } + Evidence::RollbackLedgerReturnIntent => self.pair(false)?, + // Failed-start/rollback events require a retained native failure + // source; a caller-provided reason or hash is never sufficient. + _ => anyhow::bail!("UPDATE_WINDOWS_OWNED_EVENT_NOT_QUALIFIED"), + } + Ok(()) + } +} +impl OwnedLedger<'_, '_> { + pub fn begin_failed_helper_rollback(&mut self) -> Result<()> { + self.guard.effect_window()?; + let failed = self + .guard + .input + .stopped + .failed_start() + .context("UPDATE_KNOWN_HELPER_FAILURE_REQUIRED")?; + ensure!( + failed.service() == crate::update_native::Service::Helper, + "UPDATE_HELPER_FAILURE_REQUIRED" + ); + let grant = self.guard.input.original.permit().grant_id; + let journal = core::read(&self.db, &self.guard, grant)?; + core::begin_rollback( + &mut self.db, + &self.guard, + grant, + journal.head_sha256(), + &rmm_updater_handoff::RollbackCause::StartupFailed { + service: rmm_updater_handoff::Service::WindowsHelper, + }, + &failed.sha256()?, + self.guard.input.clock.reading()?.upper, + )?; + let owner = &self.guard.input.original.delegation().updater; + self.append(Evidence::RollbackStopped { + process: rmm_updater_handoff::Process { + pid: owner.pid, + birth: owner.birth, + image_sha256: owner.image_sha256.clone(), + }, + ledger_identity_sha256: self.guard.input.bundle.ledger.sha256()?, + observation_sha256: hash(&serde_json::to_vec(&( + failed, + self.guard.input.stopped.proofs(), + ))?), + }) + } + pub fn prepare_rollback_return_and_close( + mut self, + ) -> Result { + self.guard.effect_window()?; + let grant = self.guard.input.original.permit().grant_id; + let journal = core::read(&self.db, &self.guard, grant)?; + ensure!( + journal.phase() == Phase::PredecessorVerified, + "UPDATE_VERIFIED_PREDECESSOR_REQUIRED" + ); + let now = self.guard.input.clock.reading()?.upper; + let event = journal.prepare( + u64::try_from(now.timestamp())?, + Evidence::RollbackLedgerReturnIntent, + )?; + let claims = core::prepare_windows_rollback_return_and_starts( + &mut self.db, + &self.guard, + grant, + journal.head_sha256(), + &event, + now, + )?; + let proof = core::current_proof(&self.db, &self.guard, grant)? + .context("UPDATE_ROLLBACK_RETURN_PREFIX_REQUIRED")?; + self.close()?; + Ok( + crate::update_native::control_fence::PreparedStart::after_closed_connection( + claims, proof, + ), + ) + } +} diff --git a/crates/agent-windows/src/update_record.rs b/crates/agent-windows/src/update_record.rs new file mode 100644 index 0000000..c6ec293 --- /dev/null +++ b/crates/agent-windows/src/update_record.rs @@ -0,0 +1,354 @@ +//! Private Windows installed-record builder and fixed handle-based namespace. +//! Public metadata assembly is never permission to publish a record/floor. +use crate::{ + helper_ipc::PinnedFile, + update_native::files::{self, Proof}, + update_original::Original, +}; +use anyhow::{Result, ensure}; +use ed25519_dalek::{Signature, VerifyingKey}; +use rmm_agent_core::update_handoff::{NativeEffect, NativeEffectClaim}; +use rmm_domain::{ + agent_update::ResolvedAgentUpdate, + agent_update_provisioning::{InstalledReleaseRecord, MAX_RECORD_BYTES}, + jobs::hash, +}; +use rmm_updater_handoff::{ + Event, Evidence, HEALTH_DOMAIN, HealthReceipt, Journal, Phase, SignedHealth, +}; +use std::{ + fs::{File, OpenOptions}, + io::Write, + os::windows::fs::OpenOptionsExt, + path::{Path, PathBuf}, +}; +use uuid::Uuid; +use windows_sys::Win32::Storage::FileSystem::*; +const ROOT: &str = r"C:\ProgramData\RustDiscoveryUpdater"; +const CURRENT: &str = r"C:\ProgramData\RustDiscoveryUpdater\installed-record.json"; +const RECORDS: &str = r"C:\ProgramData\RustDiscoveryUpdater\records"; +pub(crate) struct BuiltRecord { + record: InstalledReleaseRecord, + raw: Vec, + prior_raw: Vec, + old_sha256: String, + sha256: String, + grant_id: Uuid, + owner_nonce: Uuid, +} +impl BuiltRecord { + pub(crate) fn build( + original: &Original, + prior_raw: &[u8], + journal: &Journal, + health_event_raw: &[u8], + ) -> Result { + let header = original.handoff(); + let handoff_sha256 = hash(&header.bytes()?); + ensure!( + journal.phase() == Phase::HealthVerified + && journal.handoff_sha256() == handoff_sha256 + && !health_event_raw.is_empty() + && health_event_raw.len() <= rmm_updater_handoff::MAX_EVENT_BYTES + && hash(health_event_raw) == journal.head_sha256(), + "UPDATE_RECORD_HEALTH_HEAD" + ); + let event: Event = serde_json::from_slice(health_event_raw)?; + ensure!( + serde_json::to_vec(&event)? == health_event_raw + && event.handoff_sha256 == handoff_sha256 + && event.boot_id == header.boot_id, + "UPDATE_RECORD_HEALTH_EVENT" + ); + let Evidence::HealthVerified { receipt: signed } = &event.evidence else { + anyhow::bail!("UPDATE_RECORD_HEALTH_REQUIRED") + }; + ensure!( + !signed.payload.is_empty() + && signed.payload.len() <= 4096 + && signed.signature.len() == 64, + "UPDATE_RECORD_HEALTH_LIMIT" + ); + let receipt: HealthReceipt = serde_json::from_slice(&signed.payload)?; + ensure!( + serde_json::to_vec(&receipt)? == signed.payload, + "UPDATE_RECORD_HEALTH_NONCANONICAL" + ); + // Journal possession is not independent key trust. Authenticate the + // exact receipt again with the ORIGINAL signed job's external key pin. + let raw: [u8; 32] = hex::decode(&original.update().updater.health_public_key_hex)? + .try_into() + .map_err(|_| anyhow::anyhow!("UPDATE_RECORD_HEALTH_KEY"))?; + let public = VerifyingKey::from_bytes(&raw)?; + ensure!(!public.is_weak(), "UPDATE_RECORD_HEALTH_KEY"); + let mut message = HEALTH_DOMAIN.to_vec(); + message.extend_from_slice(&signed.payload); + public.verify_strict(&message, &Signature::from_slice(&signed.signature)?)?; + ensure!( + receipt.schema_version == 1 + && receipt.handoff_sha256 == handoff_sha256 + && receipt.owner_nonce == header.owner_nonce + && receipt.boot_id == header.boot_id + && receipt.helper_journal_id == header.helper_journal_id + && receipt.agent_journal_id == header.agent_journal_id + && receipt.connection_generation > header.connection_generation + && !receipt.ready + && receipt.issued_at >= header.consumed_at + && receipt.issued_at <= event.observed_at + && event.observed_at < receipt.valid_until + && receipt.valid_until <= header.finish_before, + "UPDATE_RECORD_HEALTH_BINDING" + ); + Self::assemble( + original.update(), + prior_raw, + &handoff_sha256, + signed, + &receipt, + header.attempt.grant_id, + header.owner_nonce, + ) + } + fn assemble( + update: &ResolvedAgentUpdate, + prior_raw: &[u8], + handoff_sha256: &str, + signed: &SignedHealth, + receipt: &HealthReceipt, + grant_id: Uuid, + owner_nonce: Uuid, + ) -> Result { + ensure!( + update.validate() && !grant_id.is_nil() && !owner_nonce.is_nil(), + "UPDATE_RECORD_INPUT" + ); + let record = rmm_domain::agent_update_provisioning::assemble_updated_record( + update, + prior_raw, + handoff_sha256, + signed, + receipt, + ) + .map_err(anyhow::Error::msg)?; + let old_sha256 = hash(prior_raw); + let raw = record.bytes().map_err(anyhow::Error::msg)?; + let sha256 = hash(&raw); + ensure!(sha256 != old_sha256, "UPDATE_RECORD_SAME_BYTES"); + Ok(Self { + record, + raw, + prior_raw: prior_raw.to_vec(), + old_sha256, + sha256, + grant_id, + owner_nonce, + }) + } + + pub(crate) fn record(&self) -> &InstalledReleaseRecord { + &self.record + } + pub(crate) fn sha256(&self) -> &str { + &self.sha256 + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)] +enum State { + Staged, + Archived, + Published, +} +pub(crate) struct Transition { + built: BuiltRecord, + root: std::cell::RefCell, + records: std::cell::RefCell, + old_proof: Proof, + new_proof: Proof, + new: File, + old: Option, + stage: PathBuf, + archive: PathBuf, + state: State, +} +fn open(path: &Path, delete: bool) -> Result { + let mut options = OpenOptions::new(); + options + .read(true) + .share_mode(FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE) + .custom_flags(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_WRITE_THROUGH); + if delete { + options + .access_mode(FILE_GENERIC_READ | FILE_GENERIC_WRITE | DELETE) + .share_mode(FILE_SHARE_READ); + } + Ok(options.open(path)?) +} +fn read(path: &Path) -> Result { + files::proof(&mut open(path, false)?, path, MAX_RECORD_BYTES as u64) +} +impl Transition { + pub(crate) fn prepare(built: BuiltRecord) -> Result { + let root = PinnedFile::open(Path::new(ROOT), true, &[], &[], false)?; + let records = PinnedFile::open(Path::new(RECORDS), true, &[], &[], false)?; + let mut original = open(Path::new(CURRENT), false)?; + let old_proof = files::proof(&mut original, Path::new(CURRENT), MAX_RECORD_BYTES as u64)?; + ensure!( + old_proof.sha256 == built.old_sha256, + "UPDATE_RECORD_ORIGINAL_FILE_REQUIRED" + ); + let stage = Path::new(ROOT).join(format!(".rmm-record-{}.stage", built.owner_nonce)); + let archive = Path::new(RECORDS).join(format!("{}.json", built.old_sha256)); + ensure!( + !archive.try_exists()?, + "UPDATE_RECORD_ARCHIVE_ALREADY_PRESENT" + ); + let mut new = files::create_record_stage(&original, &stage)?; + new.write_all(&built.raw)?; + new.sync_all()?; + let new_proof = files::proof(&mut new, &stage, MAX_RECORD_BYTES as u64)?; + ensure!( + new_proof.sha256 == built.sha256 + && new_proof.security_sha256 == old_proof.security_sha256 + && new_proof.identity != old_proof.identity, + "UPDATE_RECORD_STAGE_BINDING" + ); + let result = Self { + built, + root: std::cell::RefCell::new(root), + records: std::cell::RefCell::new(records), + old_proof, + new_proof, + new, + old: None, + stage, + archive, + state: State::Staged, + }; + result.verify()?; + Ok(result) + } + pub(crate) fn verify(&self) -> Result<()> { + self.root.try_borrow_mut()?.check()?; + self.records.try_borrow_mut()?.check()?; + match self.state { + State::Staged => ensure!( + read(Path::new(CURRENT))? == self.old_proof + && read(&self.stage)? == self.new_proof + && !self.archive.try_exists()?, + "UPDATE_RECORD_STAGED_NAMESPACE_CHANGED" + ), + State::Archived => ensure!( + read(&self.archive)? == self.old_proof + && read(&self.stage)? == self.new_proof + && !Path::new(CURRENT).try_exists()?, + "UPDATE_RECORD_ARCHIVED_NAMESPACE_CHANGED" + ), + State::Published => ensure!( + read(&self.archive)? == self.old_proof + && read(Path::new(CURRENT))? == self.new_proof + && !self.stage.try_exists()?, + "UPDATE_RECORD_PUBLISHED_NAMESPACE_CHANGED" + ), + } + Ok(()) + } + pub(crate) fn verify_original(&self, raw: &[u8]) -> Result<()> { + ensure!( + self.built.prior_raw == raw && hash(raw) == self.old_proof.sha256, + "UPDATE_RECORD_PREDECESSOR_CHANGED" + ); + self.verify() + } + pub(crate) fn effect(&self) -> Result { + let old_sha256 = self.built.old_sha256.clone(); + let new_sha256 = self.built.sha256.clone(); + Ok(match self.state { + State::Staged => NativeEffect::SaveInstalledRecord { + old_sha256, + new_sha256, + }, + State::Archived => NativeEffect::PublishInstalledRecord { + old_sha256, + new_sha256, + }, + State::Published => anyhow::bail!("UPDATE_RECORD_ALREADY_PUBLISHED"), + }) + } + pub(crate) fn verify_effect(&self, effect: &NativeEffect, observed: bool) -> Result<()> { + self.verify()?; + let expected = match (self.state, observed) { + (State::Staged, false) | (State::Archived, true) => NativeEffect::SaveInstalledRecord { + old_sha256: self.built.old_sha256.clone(), + new_sha256: self.built.sha256.clone(), + }, + (State::Archived, false) | (State::Published, true) => { + NativeEffect::PublishInstalledRecord { + old_sha256: self.built.old_sha256.clone(), + new_sha256: self.built.sha256.clone(), + } + } + _ => anyhow::bail!("UPDATE_RECORD_EFFECT_PHASE"), + }; + ensure!( + *effect == expected, + "UPDATE_RECORD_EXACT_NATIVE_EFFECT_REQUIRED" + ); + Ok(()) + } + pub(crate) fn apply(&mut self, claim: &NativeEffectClaim) -> Result<()> { + self.verify_effect(claim.effect(), false)?; + ensure!( + claim.grant_id() == self.built.grant_id + && claim.owner_nonce() == self.built.owner_nonce, + "UPDATE_RECORD_ORIGINAL_CLAIM_REQUIRED" + ); + match self.state { + State::Staged => { + let mut old = open(Path::new(CURRENT), true)?; + ensure!( + files::proof(&mut old, Path::new(CURRENT), MAX_RECORD_BYTES as u64)? + == self.old_proof, + "UPDATE_RECORD_OLD_HANDLE_CHANGED" + ); + files::rename_record(&old, &self.archive)?; + ensure!( + files::proof(&mut old, &self.archive, MAX_RECORD_BYTES as u64)? + == self.old_proof, + "UPDATE_RECORD_ARCHIVE_READBACK" + ); + self.old = Some(old); + self.state = State::Archived; + } + State::Archived => { + files::rename_record(&self.new, Path::new(CURRENT))?; + ensure!( + files::proof(&mut self.new, Path::new(CURRENT), MAX_RECORD_BYTES as u64)? + == self.new_proof, + "UPDATE_RECORD_PUBLISH_READBACK" + ); + self.state = State::Published; + } + State::Published => anyhow::bail!("UPDATE_RECORD_NO_RETRY"), + } + self.verify() + } + pub(crate) fn observation(&self) -> Result { + self.verify()?; + Ok(hash(&serde_json::to_vec(&( + self.state, + &self.old_proof, + &self.new_proof, + ))?)) + } + pub(crate) fn built(&self) -> &BuiltRecord { + &self.built + } + pub(crate) fn published(&self) -> Result<()> { + ensure!( + self.state == State::Published, + "UPDATE_RECORD_PUBLICATION_REQUIRED" + ); + self.verify() + } +} diff --git a/crates/agent-windows/src/update_state.rs b/crates/agent-windows/src/update_state.rs new file mode 100644 index 0000000..f6cd0d8 --- /dev/null +++ b/crates/agent-windows/src/update_state.rs @@ -0,0 +1,727 @@ +//! Original update state witnesses, never key contents or recovery authority. +//! The local retained list and compatible-reader registry are protected files; +//! none of their paths, identities or qualification hashes come from a job. +use crate::{ + helper_ipc::{self as ipc, FileIdentity, PinnedFile}, + update_native::{Role, files}, + update_trust::{Protected, TrustState}, +}; +use anyhow::{Result, ensure}; +use rmm_agent_core::auth::Request; +use rmm_domain::{ + agent_update::UpdateDelegation, agent_update_provisioning::ActivationEvidence, jobs::hash, +}; +use rmm_updater_handoff::Handoff; +use serde::{Deserialize, Serialize}; +use std::{ + fs::{File, OpenOptions}, + io::Write, + mem::zeroed, + os::windows::{ + fs::OpenOptionsExt, + io::{AsRawHandle, FromRawHandle}, + }, + path::{Path, PathBuf}, + ptr, +}; +use uuid::Uuid; +use windows_sys::Win32::{Foundation::*, Storage::FileSystem::*}; +pub const ROOT: &str = r"C:\ProgramData\RustDiscoveryUpdater"; +const RETAINED: &str = r"C:\ProgramData\RustDiscoveryUpdater\retained-files.json"; +const ATTEMPTS: &str = r"C:\ProgramData\RustDiscoveryUpdater\attempts"; +#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum Retention { + MutableDatabase, + ImmutableMetadata, +} +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct Spec { + pub path: PathBuf, + pub identity: FileIdentity, + pub retention: Retention, +} +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct Metadata { + pub bytes: u64, + pub created: u64, + pub modified: u64, + pub attributes: u32, +} +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct RetainedProof { + pub spec: Spec, + pub security_sha256: String, + pub immutable_metadata: Option, +} +struct Held { + file: File, + parents: Vec, + proof: RetainedProof, +} +fn info(file: &File, dir: bool) -> Result { + let mut v: BY_HANDLE_FILE_INFORMATION = unsafe { zeroed() }; + ensure!( + unsafe { GetFileInformationByHandle(file.as_raw_handle(), &mut v) } != 0 + && v.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT == 0 + && (v.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY != 0) == dir + && (dir || v.nNumberOfLinks == 1), + "UPDATE_RETAINED_FILE_TYPE" + ); + Ok(Metadata { + bytes: (u64::from(v.nFileSizeHigh) << 32) | u64::from(v.nFileSizeLow), + created: (u64::from(v.ftCreationTime.dwHighDateTime) << 32) + | u64::from(v.ftCreationTime.dwLowDateTime), + modified: (u64::from(v.ftLastWriteTime.dwHighDateTime) << 32) + | u64::from(v.ftLastWriteTime.dwLowDateTime), + attributes: v.dwFileAttributes, + }) +} +fn open_meta(path: &Path, dir: bool) -> Result { + // Do not request FILE_READ_DATA, even for the retained private TLS key. + let h = unsafe { + CreateFileW( + ipc::wide(path).as_ptr(), + FILE_READ_ATTRIBUTES | READ_CONTROL, + FILE_SHARE_READ | FILE_SHARE_WRITE, + ptr::null(), + OPEN_EXISTING, + FILE_FLAG_OPEN_REPARSE_POINT | if dir { FILE_FLAG_BACKUP_SEMANTICS } else { 0 }, + ptr::null_mut(), + ) + }; + ensure!(h != INVALID_HANDLE_VALUE, "UPDATE_RETAINED_OPEN"); + let file = unsafe { File::from_raw_handle(h) }; + info(&file, dir)?; + Ok(file) +} +fn fixed_namespace(path: &Path) -> bool { + path.is_absolute() + && !path.to_string_lossy().starts_with(r"\\") + && !path.to_string_lossy().contains("..") + && [ + r"C:\ProgramData\RustDiscovery\state", + r"C:\ProgramData\RustDiscoverySystem\state", + r"C:\ProgramData\RustDiscoverySystem\agent-intents", + ] + .iter() + .any(|root| path.starts_with(root)) + && !path.as_os_str().to_string_lossy().contains('\0') +} +fn protected_metadata(file: &File, path: &Path) -> Result<()> { + if path.starts_with(r"C:\ProgramData\RustDiscovery\state") { + crate::native::private_path(path, false) + } else { + let writer = if path.starts_with(r"C:\ProgramData\RustDiscoverySystem\agent-intents") { + crate::SERVICE_NAME + } else { + ipc::HELPER_SERVICE + }; + ipc::check_acl( + file.as_raw_handle(), + &[], + &[ipc::service_sid(writer)?], + None, + ) + } +} +impl Held { + fn open(spec: Spec) -> Result { + ensure!( + fixed_namespace(&spec.path), + "UPDATE_RETAINED_FIXED_NAMESPACE" + ); + let mut parents = Vec::new(); + for parent in spec.path.ancestors().skip(1) { + parents.push(open_meta(parent, true)?); + } + let file = open_meta(&spec.path, false)?; + ensure!( + ipc::file_identity(&file)? == spec.identity, + "UPDATE_RETAINED_FILE_IDENTITY" + ); + protected_metadata(&file, &spec.path)?; + let metadata = info(&file, false)?; + let proof = RetainedProof { + security_sha256: files::security_sha256(&file)?, + immutable_metadata: (spec.retention == Retention::ImmutableMetadata) + .then_some(metadata), + spec, + }; + let held = Self { + file, + parents, + proof, + }; + held.verify()?; + Ok(held) + } + fn verify(&self) -> Result<()> { + for parent in &self.parents { + info(parent, true)?; + } + let named = open_meta(&self.proof.spec.path, false)?; + protected_metadata(&named, &self.proof.spec.path)?; + ensure!( + ipc::file_identity(&named)? == self.proof.spec.identity + && ipc::file_identity(&self.file)? == self.proof.spec.identity + && files::security_sha256(&named)? == self.proof.security_sha256 + && self + .proof + .immutable_metadata + .as_ref() + .is_none_or(|v| info(&named, false).is_ok_and(|actual| &actual == v)), + "UPDATE_RETAINED_CHANGED" + ); + Ok(()) + } +} +/// Held access to the two fixed, LocalService-created agent state files. +/// The agent's existing private ACL contract permits its LocalService file +/// owner; SYSTEM helper policy files continue to use the stricter PinnedFile. +/// This pins names and security, and does not grant an executor/update effect. +pub(crate) struct AgentStateFile { + pub(crate) file: File, + pub(crate) identity: FileIdentity, + held: Held, +} +impl AgentStateFile { + pub(crate) fn journal() -> Result { + Self::open( + Path::new(r"C:\ProgramData\RustDiscovery\state\telemetry.sqlite"), + false, + ) + } + pub(crate) fn lock() -> Result { + Self::open( + Path::new(r"C:\ProgramData\RustDiscovery\state\agent.lock"), + true, + ) + } + fn open(path: &Path, write: bool) -> Result { + crate::native::private_path(Path::new(r"C:\ProgramData\RustDiscovery\state"), true)?; + let file = OpenOptions::new() + .read(true) + .write(write) + .share_mode(FILE_SHARE_READ | FILE_SHARE_WRITE) + .custom_flags(FILE_FLAG_OPEN_REPARSE_POINT) + .open(path)?; + info(&file, false)?; + let identity = ipc::file_identity(&file)?; + let held = Held::open(Spec { + path: path.into(), + identity, + retention: Retention::MutableDatabase, + })?; + let result = Self { + file, + identity, + held, + }; + result.check()?; + Ok(result) + } + pub(crate) fn check(&self) -> Result<()> { + self.held.verify()?; + info(&self.file, false)?; + ensure!( + ipc::file_identity(&self.file)? == self.identity + && files::security_sha256(&self.file)? == self.held.proof.security_sha256, + "UPDATE_AGENT_STATE_CHANGED" + ); + Ok(()) + } +} +fn key_paths() -> Result> { + let mut keys = std::collections::BTreeSet::new(); + for entry in std::fs::read_dir(r"C:\ProgramData\RustDiscovery\state")? { + let entry = entry?; + let path = entry.path(); + if path.extension().is_some_and(|v| v == "key") { + let name = path + .file_name() + .and_then(|v| v.to_str()) + .ok_or_else(|| anyhow::anyhow!("UPDATE_RETAINED_KEY_NAME"))?; + ensure!( + name == "device.key" + || name + .strip_prefix("device-") + .and_then(|v| v.strip_suffix(".key")) + .is_some_and(|v| Uuid::parse_str(v).is_ok_and(|id| id.to_string() == v)), + "UPDATE_RETAINED_KEY_NAME" + ); + ensure!( + keys.len() < 64 && keys.insert(path), + "UPDATE_RETAINED_KEY_LIMIT" + ); + } + } + ensure!(!keys.is_empty(), "UPDATE_RETAINED_KEYS_MISSING"); + Ok(keys) +} +const MANDATORY: [(&str, Retention); 9] = [ + ( + r"C:\ProgramData\RustDiscovery\state\telemetry.sqlite", + Retention::MutableDatabase, + ), + ( + r"C:\ProgramData\RustDiscovery\state\consumption.sqlite", + Retention::MutableDatabase, + ), + ( + r"C:\ProgramData\RustDiscovery\state\agent.lock", + Retention::ImmutableMetadata, + ), + ( + r"C:\ProgramData\RustDiscovery\state\identity.json", + Retention::ImmutableMetadata, + ), + ( + r"C:\ProgramData\RustDiscovery\state\device.key", + Retention::ImmutableMetadata, + ), + ( + r"C:\ProgramData\RustDiscovery\state\device.pem", + Retention::ImmutableMetadata, + ), + ( + r"C:\ProgramData\RustDiscoverySystem\state\ledger.sqlite", + Retention::MutableDatabase, + ), + ( + r"C:\ProgramData\RustDiscoverySystem\state\executor.lock", + Retention::ImmutableMetadata, + ), + ( + r"C:\ProgramData\RustDiscoverySystem\agent-intents\system-intents.sqlite", + Retention::MutableDatabase, + ), +]; +pub struct RetainedSet { + config: Protected, + files: Vec, + proofs: Vec, +} +impl RetainedSet { + /// Administrative read-only metadata, not an admitted retained set or lease. + /// The original key data and mutable SQLite contents are never read here. + pub fn bootstrap_metadata() -> Result> { + let mut specs = MANDATORY + .iter() + .map(|(p, r)| (PathBuf::from(p), *r)) + .collect::>(); + for key in key_paths()? { + specs.insert(key, Retention::ImmutableMetadata); + } + ensure!(specs.len() <= 64, "UPDATE_RETAINED_LIMIT"); + let mut held = Vec::new(); + for (path, retention) in specs { + let file = open_meta(&path, false)?; + held.push(Held::open(Spec { + identity: ipc::file_identity(&file)?, + path, + retention, + })?); + } + for file in &held { + file.verify()?; + } + Ok(held.iter().map(|file| file.proof.clone()).collect()) + } + pub fn capture() -> Result { + let (config, raw) = Protected::read(Path::new(RETAINED), 65536)?; + let specs: Vec = serde_json::from_slice(&raw)?; + ensure!( + !specs.is_empty() && specs.len() <= 64, + "UPDATE_RETAINED_LIMIT" + ); + let mut files = Vec::new(); + for spec in specs { + ensure!( + !files.iter().any(|h: &Held| h.proof.spec.path == spec.path), + "UPDATE_RETAINED_DUPLICATE" + ); + files.push(Held::open(spec)?); + } + for (path, retention) in MANDATORY { + ensure!( + files + .iter() + .any(|h| h.proof.spec.path == Path::new(path) + && h.proof.spec.retention == retention), + "UPDATE_RETAINED_MANDATORY" + ); + } + // Read only names/metadata, never another role's SQLite or key data. + // Include EVERY immutable private key namespace member, so the current + // selector cannot name an unretained key; accepted jobs prevent normal + // TLS rotation and verify() rejects an added/removed key meanwhile. + for key in key_paths()? { + ensure!( + files.iter().any(|h| h.proof.spec.path == key + && h.proof.spec.retention == Retention::ImmutableMetadata), + "UPDATE_RETAINED_TLS_KEYS" + ); + } + let proofs = files.iter().map(|h| h.proof.clone()).collect(); + let value = Self { + config, + files, + proofs, + }; + value.verify()?; + Ok(value) + } + /// Reopen exactly the original public metadata set; no local JSON edit can + /// substitute a new key, journal inode or immutable identity after consume. + pub fn reopen(proofs: &[RetainedProof]) -> Result { + let result = Self::capture()?; + ensure!( + result.proofs == proofs, + "UPDATE_RETAINED_ORIGINAL_SET_CHANGED" + ); + Ok(result) + } + pub fn verify(&self) -> Result<()> { + self.config.verify()?; + for f in &self.files { + f.verify()?; + } + let actual = key_paths()?; + let expected = self + .files + .iter() + .filter(|f| { + f.proof.spec.path.parent() == Some(Path::new(r"C:\ProgramData\RustDiscovery\state")) + && f.proof.spec.path.extension().is_some_and(|v| v == "key") + }) + .map(|f| f.proof.spec.path.clone()) + .collect::>(); + ensure!(actual == expected, "UPDATE_RETAINED_TLS_NAMESPACE_CHANGED"); + Ok(()) + } + pub fn proofs(&self) -> &[RetainedProof] { + &self.proofs + } + pub fn sha256(&self) -> Result { + Ok(hash(&serde_json::to_vec(&self.proofs)?)) + } +} +#[derive(Clone, Debug, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct BoundFile { + pub role: Role, + pub original: files::Proof, + pub staged: files::Proof, +} +#[derive(Clone, Debug, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct LedgerIdentity { + pub ledger: FileIdentity, + pub lock: FileIdentity, +} +impl LedgerIdentity { + pub fn sha256(&self) -> Result { + Ok(hash(&serde_json::to_vec(self)?)) + } +} +#[derive(Clone, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct Bundle { + pub schema_version: u32, + pub original: Request, + pub handoff_record: Vec, + pub delegation: UpdateDelegation, + pub files: Vec, + pub retained: Vec, + pub ledger: LedgerIdentity, + /// ORIGINAL retained signed decision and request, not a claimed ready bit. + pub signed_sync_response: Vec, + pub signed_sync_request: Vec, +} +impl Bundle { + pub fn validate(&self) -> Result { + ensure!( + self.schema_version == 1 && self.handoff_record.len() <= 65536, + "UPDATE_BUNDLE_SCHEMA" + ); + let h: Handoff = serde_json::from_slice(&self.handoff_record)?; + h.validate()?; + ensure!( + h.bytes()? == self.handoff_record + && h.pin_transition == rmm_updater_handoff::PinTransition::WindowsCodePairClockV1 + && self.delegation.validate() + && self.delegation.handoff_sha256 == hash(&self.handoff_record) + && self.delegation.owner_nonce == h.owner_nonce + && self.delegation.boot_id == h.boot_id + && hash(&serde_json::to_vec(&self.original)?) == h.attempt.original_request_sha256 + && hash(&serde_json::to_vec(&self.files)?) == h.staged_files_sha256 + && hash(&serde_json::to_vec(&self.retained)?) == h.retained_state_sha256 + && self.ledger.sha256()? == h.ledger_identity_sha256 + && self.files.iter().map(|f| f.role).collect::>() + == [ + Role::Agent, + Role::Helper, + Role::Settings, + Role::Pin, + Role::TimeProfile + ] + && self.signed_sync_response.len() <= 1048576 + && self.signed_sync_request.len() <= 1048576, + "UPDATE_BUNDLE_BINDING" + ); + for (f, t) in self.files.iter().zip(&h.files) { + ensure!( + f.role.handoff_role() == t.role + && f.original.sha256 == t.old_sha256 + && f.staged.sha256 == t.new_sha256, + "UPDATE_BUNDLE_FILE_BINDING" + ); + } + Ok(h) + } + pub fn write_before_consume(&self) -> Result<()> { + let h = self.validate()?; + let raw = serde_json::to_vec(self)?; + ensure!(raw.len() <= 3 * 1024 * 1024, "UPDATE_BUNDLE_SIZE"); + let mut root = PinnedFile::open(Path::new(ATTEMPTS), true, &[], &[], false)?; + let directory = Path::new(ATTEMPTS).join(h.attempt.grant_id.to_string()); + // Inherit only the separately provisioned SYS/Admin private ACL. + // No pre-existing/partial directory is reused or repaired. + std::fs::create_dir(&directory)?; + let mut dir = PinnedFile::open(&directory, true, &[], &[], false)?; + let path = directory.join("bundle.json"); + let mut file = OpenOptions::new() + .write(true) + .create_new(true) + .share_mode(FILE_SHARE_READ) + .custom_flags(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_WRITE_THROUGH) + .open(&path)?; + file.write_all(&raw)?; + file.sync_all()?; + drop(file); + let mut published = PinnedFile::open(&path, false, &[], &[], false)?; + ensure!( + published.sha256()? == hash(&raw), + "UPDATE_BUNDLE_WRITE_CHANGED" + ); + published.check()?; + dir.check()?; + root.check() + } + pub fn load(grant: Uuid) -> Result<(Self, impl Fn() -> Result<()>)> { + ensure!(!grant.is_nil(), "UPDATE_BUNDLE_GRANT"); + let path = Path::new(ATTEMPTS) + .join(grant.to_string()) + .join("bundle.json"); + let (file, raw) = Protected::read(&path, 3 * 1024 * 1024)?; + let value: Self = serde_json::from_slice(&raw)?; + let handoff = value.validate()?; + ensure!( + handoff.attempt.grant_id == grant, + "UPDATE_BUNDLE_WRONG_GRANT" + ); + Ok((value, move || file.verify())) + } +} + +/// Every registered reader is an explicit decoder-compatible baseline service. +/// This protected registry is not a claim of global future process absence. +/// Worker additionally proves all registered original instances have stopped +/// and holds BOTH original executor/journal locks before opening mutable state. +pub const READER_CONTRACT:&[u8]=b"rmm.windows-shared-readers.v2\0agent:existing-agent.lock-before-agent-sqlite-and-held-for-process-lifetime;helper:existing-executor.lock-before-helper-sqlite-and-every-sql-or-effect;all-registered-readers:original-update-handoff-v2-inflight-decoder-compatible;updater:both-original-locks-only-after-registered-instances-stopped;scope:no-global-future-exec-absence-promise\n"; +#[derive(Clone, Debug, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct Reader { + pub service: String, + pub binary_sha256: String, + pub configuration_sha256: String, +} +#[derive(Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct RegistryFile { + schema_version: u32, + profile: String, + bootstrap_receipt_sha256: String, + reader_contract_sha256: String, + readers: Vec, +} +pub struct QualifiedRegistry { + file: Protected, + qualification: Protected, + readers: Vec, +} +impl QualifiedRegistry { + pub fn load(trust: &TrustState) -> Result { + let p = trust.policy(); + ensure!( + p.schema_version == 2 && p.profile == "windows_code_pair_clock_v1", + "UPDATE_READER_POLICY" + ); + let (file, raw) = Protected::read(Path::new(&p.registry_path), 65536)?; + ensure!( + hash(&raw) == p.reader_registry_sha256, + "UPDATE_READER_REGISTRY_HASH" + ); + let r: RegistryFile = serde_json::from_slice(&raw)?; + let baseline = p.initial_baseline.decode().map_err(anyhow::Error::msg)?; + let ActivationEvidence::Bootstrap { + qualification_receipt_sha256, + } = baseline.record.activation_evidence + else { + anyhow::bail!("UPDATE_READER_BASELINE_REQUIRED"); + }; + let initial = baseline + .record + .release_envelope + .decode() + .map_err(anyhow::Error::msg)?; + ensure!( + r.schema_version == 1 + && r.profile == "windows_compatible_readers_v2" + && r.bootstrap_receipt_sha256 == qualification_receipt_sha256 + && r.reader_contract_sha256 == hash(READER_CONTRACT) + && r.readers + .iter() + .map(|v| v.service.as_str()) + .collect::>() + == [ + crate::SERVICE_NAME, + ipc::HELPER_SERVICE, + crate::update_ipc::SERVICE + ] + && r.readers[0].binary_sha256 == initial.manifest.artifacts[0].sha256 + && r.readers[1].binary_sha256 == initial.manifest.artifacts[1].sha256 + && r.readers[2].binary_sha256 == p.updater_binary_sha256 + && r.readers + .iter() + .all(|v| ipc::digest(&v.binary_sha256) && ipc::digest(&v.configuration_sha256)) + && r.readers[0].configuration_sha256 == p.services[0].unit_sha256 + && r.readers[1].configuration_sha256 == p.services[1].unit_sha256 + && r.readers[2].configuration_sha256 == p.updater_service.unit_sha256, + "UPDATE_READER_REGISTRY_BINDING" + ); + let (qualification, qraw) = Protected::read( + Path::new(r"C:\ProgramData\RustDiscoveryUpdater\bootstrap-qualification.json"), + 65536, + )?; + ensure!( + hash(&qraw) == qualification_receipt_sha256, + "UPDATE_READER_QUALIFICATION_PIN" + ); + // Raw real native evidence is covered by the separately signed baseline + // receipt hash; parsing a label here never creates native qualification. + Ok(Self { + file, + qualification, + readers: r.readers, + }) + } + pub fn verify(&self) -> Result<()> { + self.file.verify()?; + self.qualification.verify() + } + pub fn verify_observed( + &self, + pair: &[crate::update_native::services::Proof], + updater_configuration_sha256: &str, + ) -> Result<()> { + self.verify()?; + ensure!(pair.len() == 2, "UPDATE_READER_PAIR"); + for (proof, reader) in pair.iter().zip(&self.readers) { + ensure!( + proof.configuration.service.name() == reader.service + && hash(&serde_json::to_vec(&proof.configuration)?) + == reader.configuration_sha256, + "UPDATE_READER_SCM_CONFIGURATION" + ); + // For later releases the signed installed record/approved exact + // predecessor supplies current binary pins. This is the original + // compatible reader contract, not a permanent initial image pin. + } + ensure!( + self.readers[2].configuration_sha256 == updater_configuration_sha256, + "UPDATE_READER_STABLE_UPDATER_CONFIGURATION" + ); + self.verify() + } +} +/// One-way uncertainty report from the actual original stable worker. It never +/// asserts readiness, missing effects, a new start window or recovery rights. +#[derive(Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub(crate) struct Uncertain { + schema_version: u32, + grant_id: Uuid, + owner_nonce: Uuid, + handoff_sha256: String, + delegation_sha256: String, + worker: rmm_domain::agent_update::ParticipantIdentity, +} +impl Uncertain { + pub(crate) fn write( + grant: Uuid, + worker: &rmm_domain::agent_update::ParticipantIdentity, + ) -> Result<()> { + let (bundle, recheck) = Bundle::load(grant)?; + let h = bundle.validate()?; + ensure!( + &bundle.delegation.updater == worker, + "UPDATE_UNKNOWN_ORIGINAL_WORKER_REQUIRED" + ); + let value = Self { + schema_version: 1, + grant_id: grant, + owner_nonce: h.owner_nonce, + handoff_sha256: hash(&h.bytes()?), + delegation_sha256: hash(&serde_json::to_vec(&bundle.delegation)?), + worker: worker.clone(), + }; + let raw = serde_json::to_vec(&value)?; + ensure!(raw.len() <= 4096, "UPDATE_UNKNOWN_REPORT_LIMIT"); + let directory = Path::new(ATTEMPTS).join(grant.to_string()); + let mut root = PinnedFile::open(&directory, true, &[], &[], false)?; + let path = directory.join("uncertain.json"); + let mut file = OpenOptions::new() + .read(true) + .write(true) + .create_new(true) + .share_mode(FILE_SHARE_READ) + .custom_flags(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_WRITE_THROUGH) + .open(&path)?; + ipc::check_acl(file.as_raw_handle(), &[], &[], None)?; + file.write_all(&raw)?; + file.sync_all()?; + drop(file); + let (published, bytes) = Protected::read(&path, 4096)?; + ensure!(bytes == raw, "UPDATE_UNKNOWN_REPORT_WRITE_CHANGED"); + published.verify()?; + root.check()?; + recheck() + } + pub(crate) fn read(header: &Handoff, delegation: &UpdateDelegation) -> Result { + let path = Path::new(ATTEMPTS) + .join(header.attempt.grant_id.to_string()) + .join("uncertain.json"); + if !path.try_exists()? { + return Ok(false); + } + let (file, raw) = Protected::read(&path, 4096)?; + let value: Self = serde_json::from_slice(&raw)?; + ensure!( + serde_json::to_vec(&value)? == raw + && value.schema_version == 1 + && value.grant_id == header.attempt.grant_id + && value.owner_nonce == header.owner_nonce + && value.handoff_sha256 == hash(&header.bytes()?) + && value.delegation_sha256 == hash(&serde_json::to_vec(delegation)?) + && value.worker == delegation.updater, + "UPDATE_UNKNOWN_REPORT_ORIGINAL_CONTEXT_REQUIRED" + ); + file.verify()?; + Ok(true) + } +} diff --git a/crates/agent-windows/src/update_time_transport.rs b/crates/agent-windows/src/update_time_transport.rs new file mode 100644 index 0000000..87e2d71 --- /dev/null +++ b/crates/agent-windows/src/update_time_transport.rs @@ -0,0 +1,164 @@ +//! Stable-updater-only time transport. Reuses the enrolled device's selected +//! certificate without enrollment, rotation, ClientHello, or inventory changes. +//! SignedClock still independently verifies its OWN role/image/nonce/context. +use crate::{ + certificate_rotation::{ProtectedKeyFiles, RotationStore}, + helper_ipc as ipc, + update_trust::Protected, +}; +use anyhow::{Context, Result, ensure}; +use rmm_agent_core::auth::Binding; +use rusqlite::{Connection, OpenFlags}; +use std::{ + net::{IpAddr, Ipv4Addr, SocketAddr}, + path::Path, + time::Duration, +}; +const STATE: &str = r"C:\ProgramData\RustDiscovery\state"; +const CONFIG: &str = r"C:\ProgramData\RustDiscovery\config.json"; +const CA: &str = r"C:\ProgramData\RustDiscovery\server-ca.pem"; +const JOURNAL: &str = r"C:\ProgramData\RustDiscovery\state\telemetry.sqlite"; +const DOMAIN: &str = "discovery.ease-technologies.de"; +pub struct Transport { + client: reqwest::Client, + configuration: Protected, + ca: Protected, + address: SocketAddr, +} +impl Transport { + pub fn open(binding: &Binding) -> Result { + let readers = vec![ + ipc::service_sid(crate::SERVICE_NAME)?, + ipc::service_sid(ipc::HELPER_SERVICE)?, + ipc::service_sid(crate::update_ipc::SERVICE)?, + ]; + let (configuration, raw) = Protected::read_shared(Path::new(CONFIG), 16384, &readers)?; + let value: serde_json::Value = serde_json::from_slice(&raw)?; + let fields = value.as_object().context("UPDATE_TIME_CONFIG_OBJECT")?; + ensure!( + fields.keys().all(|key| matches!( + key.as_str(), + "server_name" + | "connect_address" + | "ca_file" + | "state_directory" + | "enrollment_token_file" + | "transport" + | "job_binding_file" + | "enable_jobs" + | "windows_echo_probe_only" + | "windows_execution_profile" + )), + "UPDATE_TIME_CONFIG_UNKNOWN_FIELD" + ); + ensure!( + value["server_name"].as_str() == Some(DOMAIN) + && value["ca_file"].as_str() == Some(CA) + && value["state_directory"].as_str() == Some(STATE) + && matches!(value["transport"].as_str(), Some("auto" | "https")), + "UPDATE_TIME_FIXED_ENDPOINT" + ); + let address: SocketAddr = value["connect_address"] + .as_str() + .context("UPDATE_TIME_ADDRESS")? + .parse()?; + ensure!( + address.ip() == IpAddr::V4(Ipv4Addr::new(88, 99, 80, 202)) && address.port() == 443, + "UPDATE_TIME_FIXED_ADDRESS" + ); + let (ca, ca_bytes) = Protected::read_shared(Path::new(CA), 65536, &readers)?; + crate::native::private_path(Path::new(STATE), true)?; + crate::native::private_path(Path::new(JOURNAL), false)?; + let journal_pin = crate::update_state::AgentStateFile::journal()?; + let db = Connection::open_with_flags( + JOURNAL, + OpenFlags::SQLITE_OPEN_READ_ONLY | OpenFlags::SQLITE_OPEN_NO_MUTEX, + )?; + db.busy_timeout(Duration::ZERO)?; + unsafe { + rusqlite::ffi::sqlite3_limit(db.handle(), rusqlite::ffi::SQLITE_LIMIT_LENGTH, 65536); + } + db.execute_batch("PRAGMA trusted_schema=OFF;PRAGMA query_only=ON;")?; + let keys = ProtectedKeyFiles::open(Path::new(STATE))?; + let rotation = RotationStore::new( + binding.agent_id, + binding.enrollment_generation, + ca_bytes.clone(), + )?; + let identity = rotation.read_only_current(&db, &keys, chrono::Utc::now().timestamp())?; + let mut pem = identity.certificate_pem; + pem.push(b'\n'); + pem.extend_from_slice(&identity.private_key_pem); + let client = reqwest::Client::builder() + .https_only(true) + .tls_built_in_root_certs(false) + .add_root_certificate(reqwest::Certificate::from_pem(&ca_bytes)?) + .identity(reqwest::Identity::from_pem(&pem)?) + .resolve(DOMAIN, address) + .no_proxy() + .redirect(reqwest::redirect::Policy::none()) + .connect_timeout(Duration::from_millis(650)) + .timeout(Duration::from_millis(650)) + .pool_max_idle_per_host(1) + .build()?; + db.close().map_err(|(_, error)| error)?; + journal_pin.check()?; + configuration.verify()?; + ca.verify()?; + Ok(Self { + client, + configuration, + ca, + address, + }) + } + pub async fn compare(&mut self, request: &rmm_time_attestation::Request) -> Result> { + request.validate()?; + ensure!( + request.context.role == rmm_time_attestation::Role::Updater, + "UPDATE_TIME_OWN_ROLE_REQUIRED" + ); + self.configuration.verify()?; + self.ca.verify()?; + let client = self.client.clone(); + let address = self.address; + let body = tokio::time::timeout(Duration::from_millis(650), async move { + let mut response = client + .post(format!( + "https://{DOMAIN}:{}/agent/v1/time-attestation", + address.port() + )) + .json(request) + .send() + .await?; + ensure!( + response.status() == reqwest::StatusCode::OK + && response + .headers() + .get(reqwest::header::CONTENT_TYPE) + .and_then(|h| h.to_str().ok()) + == Some("application/json") + && !response + .headers() + .contains_key(reqwest::header::CONTENT_ENCODING) + && response.content_length().is_none_or(|n| n <= 16384), + "UPDATE_TIME_HTTP_PROFILE" + ); + let mut body = vec![]; + while let Some(chunk) = response.chunk().await? { + ensure!( + chunk.len() <= 16384usize.saturating_sub(body.len()), + "UPDATE_TIME_BODY_LIMIT" + ); + body.extend_from_slice(&chunk); + } + ensure!(!body.is_empty(), "UPDATE_TIME_EMPTY_RESPONSE"); + Ok::, anyhow::Error>(body) + }) + .await + .context("UPDATE_TIME_HTTP_DEADLINE")??; + self.configuration.verify()?; + self.ca.verify()?; + Ok(body) + } +} diff --git a/crates/agent-windows/src/update_trust.rs b/crates/agent-windows/src/update_trust.rs new file mode 100644 index 0000000..af0392a --- /dev/null +++ b/crates/agent-windows/src/update_trust.rs @@ -0,0 +1,627 @@ +//! Shared Windows protected update trust. No network input provisions a key, +//! policy, floor, baseline or compatible-reader qualification. SYSTEM helper +//! and stable updater each open these exact files independently. +use crate::helper_ipc::{self as ipc, PinnedFile}; +use anyhow::{Context, Result, ensure}; +use ed25519_dalek::{Signature, VerifyingKey}; +use rmm_agent_core::{auth::Binding, helper_reconcile::ExecutorLedgerGuard, reconcile::SyncClock}; +use rmm_domain::{ + agent_update::{ResolvedAgentUpdate, UpdateKeyringFile}, + agent_update_provisioning::{ + ActivationEvidence, BASELINE_SIGNATURE_DOMAIN, HealthKeyPin, InstalledReleaseRecord, + LocalUpdatePolicy, + }, + jobs::hash, +}; +use rmm_updater::{ + ActiveRelease, SignedRelease, TrustedContext, TrustedUpdateKey, + UpdateKeyring, verify_release, +}; +use std::{cell::RefCell, io::Read, path::Path}; +pub(crate) struct Protected { + file: RefCell, + root: RefCell, + sha256: String, +} +impl Protected { + pub(crate) fn read(path: &Path, max: u64) -> Result<(Self, Vec)> { + Self::read_shared(path, max, &[]) + } + pub(crate) fn read_shared( + path: &Path, + max: u64, + readers: &[String], + ) -> Result<(Self, Vec)> { + let root = PinnedFile::open( + path.parent().context("UPDATE_TRUST_PARENT")?, + true, + readers, + &[], + false, + )?; + let mut file = PinnedFile::open(path, false, readers, &[], false)?; + ensure!( + file.file.metadata()?.len() <= max, + "UPDATE_TRUST_FILE_LIMIT" + ); + let mut raw = Vec::new(); + (&mut file.file).take(max + 1).read_to_end(&mut raw)?; + ensure!(raw.len() as u64 <= max, "UPDATE_TRUST_FILE_LIMIT"); + file.check()?; + Ok(( + Self { + file: RefCell::new(file), + root: RefCell::new(root), + sha256: hash(&raw), + }, + raw, + )) + } + pub(crate) fn verify(&self) -> Result<()> { + self.root.try_borrow_mut()?.check()?; + let mut file = self.file.try_borrow_mut()?; + file.check()?; + ensure!(file.sha256()? == self.sha256, "UPDATE_TRUST_BYTES_CHANGED"); + Ok(()) + } +} +pub struct TrustState { + updater_binding: rmm_domain::agent_update::UpdaterBinding, + predecessor: rmm_domain::agent_update::Predecessor, + protected: Vec, + policy: LocalUpdatePolicy, + installed: InstalledReleaseRecord, + installed_raw: Vec, + installed_pin: RefCell>, + keyring: UpdateKeyring, + keyring_file: UpdateKeyringFile, + baseline_signer_revoked: bool, + health_public_key: [u8; 32], +} +impl TrustState { + pub fn load_prepared( + update: &ResolvedAgentUpdate, + binding: &Binding, + clock: &crate::signed_clock::BoundClock, + ) -> Result { + ensure!( + update.validate() && update.execution_identity() == Some("system"), + "UPDATE_PREPARED_ACTION" + ); + let state = Self::load_inputs(Some(update), binding, clock.now()?)?; + state.recheck_prepared(update, clock)?; + Ok(state) + } + pub fn load_retained( + update: &ResolvedAgentUpdate, + binding: &Binding, + prepared_at: chrono::DateTime, + ) -> Result { + ensure!( + update.validate() && update.execution_identity() == Some("system"), + "UPDATE_RETAINED_ACTION" + ); + Self::load_inputs(Some(update), binding, prepared_at) + } + /// Passive protected originals only. No candidate, staging, admission or + /// synthetic execution plan is used to discover the installed trust state. + pub fn load_observed( + binding: &Binding, + clock: &crate::signed_clock::BoundClock, + ) -> Result { + let state = Self::load_inputs(None, binding, clock.now()?)?; + ensure!( + !state.baseline_signer_revoked, + "UPDATE_BASELINE_SIGNER_REVOKED" + ); + verify_installed_release( + &state.keyring, + &state.installed, + state.updater_binding.keyring_generation, + )?; + state.recheck_protected()?; + Ok(state) + } + fn load_inputs( + expected: Option<&ResolvedAgentUpdate>, + binding: &Binding, + prepared_at: chrono::DateTime, + ) -> Result { + let mut protected = Vec::new(); + let (file, raw) = Protected::read( + Path::new(r"C:\ProgramData\RustDiscoveryUpdater\policy.json"), + 65536, + )?; + let (policy, policy_hash) = + LocalUpdatePolicy::from_bytes(&raw).map_err(anyhow::Error::msg)?; + ensure!( + policy.schema_version == 2 + && policy.profile == "windows_code_pair_clock_v1" + && policy.tenant_id == binding.tenant_id + && policy.asset_id == binding.asset_id + && policy.agent_id == binding.agent_id + && policy.enrollment_generation == binding.enrollment_generation + && policy.assignment_version == binding.assignment_version, + "UPDATE_PROTECTED_POLICY_CHANGED" + ); + protected.push(file); + let (file, raw) = Protected::read(Path::new(&policy.registry_path), 65536)?; + ensure!( + hash(&raw) == policy.reader_registry_sha256, + "UPDATE_PROTECTED_READER_REGISTRY_CHANGED" + ); + protected.push(file); + let (file, raw) = Protected::read(Path::new(&policy.keyring_path), 16384)?; + let keys: UpdateKeyringFile = serde_json::from_slice(&raw)?; + ensure!(keys.validate(), "UPDATE_PROTECTED_KEYRING_CHANGED"); + let keyring_sha256 = hash(&raw); + protected.push(file); + let job_key = hex::decode(&binding.public_key_hex)?; + let mut trusted = Vec::new(); + let mut historical_keys = Vec::new(); + let mut baseline_key = None; + for entry in &keys.keys { + ensure!( + entry.platform == crate::release_platform::WIRE, + "UPDATE_KEY_PLATFORM" + ); + let public: [u8; 32] = hex::decode(&entry.public_key_hex)? + .try_into() + .map_err(|_| anyhow::anyhow!("UPDATE_KEY_SIZE"))?; + ensure!( + public.as_slice() != job_key, + "UPDATE_JOB_RELEASE_KEYS_NOT_SEPARATE" + ); + if hash(&public) == policy.initial_baseline.key_id { + baseline_key = Some((entry, public)); + } + trusted.push(TrustedUpdateKey::new( + public, + crate::release_platform::VERIFY, + entry.first_sequence, + entry.last_sequence, + entry.revoked, + )?); + historical_keys.push(TrustedUpdateKey::new( + public, + crate::release_platform::VERIFY, + entry.first_sequence, + entry.last_sequence, + false, + )?); + } + let keyring = UpdateKeyring::new(keys.generation, trusted)?; + let historical = UpdateKeyring::new(keys.generation, historical_keys)?; + let baseline = policy + .initial_baseline + .decode() + .map_err(anyhow::Error::msg)?; + let (baseline_entry, public) = baseline_key.context("UPDATE_BASELINE_KEY_NOT_TRUSTED")?; + ensure!( + baseline + .record + .release_envelope + .decode() + .map_err(anyhow::Error::msg)? + .manifest + .release_sequence + >= baseline_entry.first_sequence + && baseline + .record + .release_envelope + .decode() + .map_err(anyhow::Error::msg)? + .manifest + .release_sequence + <= baseline_entry.last_sequence, + "UPDATE_BASELINE_KEY_REVOKED_OR_RANGE" + ); + let public = VerifyingKey::from_bytes(&public)?; + ensure!(!public.is_weak(), "UPDATE_BASELINE_WEAK_KEY"); + let mut message = BASELINE_SIGNATURE_DOMAIN.to_vec(); + message.extend_from_slice(&baseline.payload_bytes); + public.verify_strict(&message, &Signature::from_bytes(&baseline.signature))?; + let (file, raw) = Protected::read(Path::new(&policy.health_pin_path), 4096)?; + let health: HealthKeyPin = serde_json::from_slice(&raw)?; + let health_public_key = health.public_key().map_err(anyhow::Error::msg)?; + ensure!( + !VerifyingKey::from_bytes(&health_public_key)?.is_weak() + && health_public_key.as_slice() != job_key + && keys + .keys + .iter() + .all(|key| key.public_key_hex != hex::encode(health_public_key)), + "UPDATE_HEALTH_KEY_NOT_SEPARATE_OR_CHANGED" + ); + let updater_binding = rmm_domain::agent_update::UpdaterBinding { + binary_sha256: policy.updater_binary_sha256.clone(), + policy_sha256: policy_hash, + keyring_generation: keys.generation, + keyring_sha256, + health_public_key_hex: hex::encode(health_public_key), + health_key_pin_sha256: hash(&raw), + }; + protected.push(file); + let (file, raw) = Protected::read(Path::new(&policy.installed_record_path), 32768)?; + let installed = InstalledReleaseRecord::from_bytes(&raw).map_err(anyhow::Error::msg)?; + ensure!( + !installed.rolled_back + && installed.activation_floor >= policy.initial_activation_floor + && installed.activated_at <= u64::try_from(prepared_at.timestamp())?, + "UPDATE_INSTALLED_FLOOR_OR_TIME" + ); + if matches!( + installed.activation_evidence, + ActivationEvidence::Bootstrap { .. } + ) { + ensure!( + raw == baseline.payload_bytes + && hash(&raw) == policy.initial_record_sha256 + && installed.activation_floor == policy.initial_activation_floor, + "UPDATE_INSTALLED_BASELINE_CHANGED" + ); + } + let active = installed + .release_envelope + .decode() + .map_err(anyhow::Error::msg)?; + let predecessor = rmm_domain::agent_update::Predecessor { + release_id: active.manifest.release_id, + release_sequence: active.manifest.release_sequence, + manifest_sha256: installed.manifest_sha256.clone(), + installed_record_sha256: hash(&raw), + agent_sha256: active.manifest.artifacts[0].sha256.clone(), + helper_sha256: active.manifest.artifacts[1].sha256.clone(), + }; + verify_installed_release(&historical, &installed, keys.generation)?; + if let Some(update) = expected { + ensure!( + update.updater == updater_binding && update.predecessor == predecessor, + "UPDATE_INSTALLED_PREDECESSOR_OR_TRUST_BINDING" + ); + verify( + &historical, + &update.release_envelope, + &TrustedContext { + platform: crate::release_platform::VERIFY, + now_utc_seconds: u64::try_from(prepared_at.timestamp())?, + keyring_generation: keys.generation, + protocol_major: active.manifest.protocol_major, + state_schema: active.manifest.state_schema, + updater_version: 1, + minimum_release_sequence: installed.activation_floor, + active_release: Some(ActiveRelease { + sequence: active.manifest.release_sequence, + manifest_sha256: installed.manifest_sha256.clone(), + }), + }, + )?; + } + let installed_pin = RefCell::new(Some(file)); + let baseline_signer_revoked = baseline_entry.revoked; + Ok(Self { + updater_binding, + predecessor, + protected, + policy, + installed, + installed_raw: raw, + installed_pin, + keyring, + keyring_file: keys, + baseline_signer_revoked, + health_public_key, + }) + } + pub fn recheck_prepared( + &self, + update: &ResolvedAgentUpdate, + clock: &crate::signed_clock::BoundClock, + ) -> Result<()> { + self.recheck_protected()?; + self.recheck_crypto(update, clock) + } + pub(crate) fn recheck_crypto( + &self, + update: &ResolvedAgentUpdate, + clock: &crate::signed_clock::BoundClock, + ) -> Result<()> { + ensure!( + update.updater == self.updater_binding && update.predecessor == self.predecessor, + "UPDATE_TRUST_CONTEXT_CHANGED" + ); + ensure!( + !self.baseline_signer_revoked, + "UPDATE_BASELINE_SIGNER_REVOKED" + ); + verify_installed_release( + &self.keyring, + &self.installed, + update.updater.keyring_generation, + )?; + let active = self + .installed + .release_envelope + .decode() + .map_err(anyhow::Error::msg)?; + let (lower, upper) = clock.bounds()?; + for now in [lower, upper] { + verify( + &self.keyring, + &update.release_envelope, + &TrustedContext { + platform: crate::release_platform::VERIFY, + now_utc_seconds: u64::try_from(now.timestamp())?, + keyring_generation: update.updater.keyring_generation, + protocol_major: active.manifest.protocol_major, + state_schema: active.manifest.state_schema, + updater_version: 1, + minimum_release_sequence: self.installed.activation_floor, + active_release: Some(ActiveRelease { + sequence: active.manifest.release_sequence, + manifest_sha256: self.installed.manifest_sha256.clone(), + }), + }, + )?; + } + Ok(()) + } + pub fn recheck_protected(&self) -> Result<()> { + self.recheck_other_protected()?; + self.installed_pin + .try_borrow()? + .as_ref() + .context("UPDATE_INSTALLED_NAMESPACE_PROOF_REQUIRED")? + .verify() + } + pub(crate) fn recheck_other_protected(&self) -> Result<()> { + for p in &self.protected { + p.verify()?; + } + Ok(()) + } + pub(crate) fn release_installed_pin( + &self, + claim: &rmm_agent_core::update_handoff::NativeEffectClaim, + new_sha256: &str, + ) -> Result<()> { + ensure!( + claim.effect() + == &rmm_agent_core::update_handoff::NativeEffect::SaveInstalledRecord { + old_sha256: hash(&self.installed_raw), + new_sha256: new_sha256.into() + }, + "UPDATE_RECORD_ORIGINAL_SAVE_CLAIM_REQUIRED" + ); + self.recheck_protected()?; + self.installed_pin + .try_borrow_mut()? + .take() + .context("UPDATE_RECORD_PIN_ALREADY_RELEASED")?; + Ok(()) + } + pub fn qualify_history( + &self, + db: &rusqlite::Connection, + guard: &impl ExecutorLedgerGuard, + binding: &Binding, + ) -> Result<()> { + self.recheck_protected()?; + let baseline = self + .policy + .initial_baseline + .decode() + .map_err(anyhow::Error::msg)?; + let baseline_hash = hash(&baseline.payload_bytes); + let mut records = Vec::new(); + let mut held = Vec::new(); + let mut seen = std::collections::BTreeSet::new(); + let mut next = self.installed.previous_record_sha256.clone(); + let mut total = self.installed_raw.len() + baseline.payload_bytes.len(); + while let Some(digest) = next { + ensure!( + ipc::digest(&digest) && seen.insert(digest.clone()) && seen.len() < 64, + "UPDATE_RECORD_ARCHIVE_CHAIN" + ); + if digest == baseline_hash { + break; + } + let (file, raw) = Protected::read( + &Path::new(r"C:\ProgramData\RustDiscoveryUpdater\records") + .join(format!("{digest}.json")), + 32768, + )?; + ensure!(hash(&raw) == digest, "UPDATE_RECORD_ARCHIVE_HASH"); + total = total + .checked_add(raw.len()) + .context("UPDATE_RECORD_ARCHIVE_SIZE")?; + ensure!(total <= 2 * 1024 * 1024, "UPDATE_RECORD_ARCHIVE_SIZE"); + let record = InstalledReleaseRecord::from_bytes(&raw).map_err(anyhow::Error::msg)?; + next = record.previous_record_sha256; + records.push(raw); + held.push(file); + } + let record = rmm_update_history::verify_history( + db, + guard, + binding, + &self.keyring_file, + &self.policy.initial_baseline, + &records, + &self.installed_raw, + )?; + ensure!( + record.bytes().map_err(anyhow::Error::msg)? == self.installed_raw, + "UPDATE_HISTORY_ACTIVE_CHANGED" + ); + for file in held { + file.verify()?; + } + self.recheck_protected() + } + pub fn predecessor(&self) -> &rmm_domain::agent_update::Predecessor { + &self.predecessor + } + pub fn updater_binding(&self) -> &rmm_domain::agent_update::UpdaterBinding { + &self.updater_binding + } + pub fn activation_floor(&self) -> u64 { + self.installed.activation_floor + } + pub fn verify_candidate( + &self, + envelope: &rmm_domain::agent_update::ReleaseEnvelope, + clock: &crate::signed_clock::BoundClock, + ) -> Result<()> { + self.recheck_protected()?; + ensure!( + !self.baseline_signer_revoked, + "UPDATE_BASELINE_SIGNER_REVOKED" + ); + let active = self + .installed + .release_envelope + .decode() + .map_err(anyhow::Error::msg)? + .manifest; + let (lower, upper) = clock.bounds()?; + for now in [lower, upper] { + verify( + &self.keyring, + envelope, + &TrustedContext { + platform: crate::release_platform::VERIFY, + now_utc_seconds: u64::try_from(now.timestamp())?, + keyring_generation: self.updater_binding.keyring_generation, + protocol_major: active.protocol_major, + state_schema: active.state_schema, + updater_version: 1, + minimum_release_sequence: self.installed.activation_floor, + active_release: Some(ActiveRelease { + sequence: active.release_sequence, + manifest_sha256: self.installed.manifest_sha256.clone(), + }), + }, + )?; + } + self.recheck_protected() + } + pub fn policy(&self) -> &LocalUpdatePolicy { + &self.policy + } + pub fn installed_raw(&self) -> &[u8] { + &self.installed_raw + } + pub fn health_public_key(&self) -> [u8; 32] { + self.health_public_key + } +} +fn verify( + keyring: &UpdateKeyring, + envelope: &rmm_domain::agent_update::ReleaseEnvelope, + context: &TrustedContext, +) -> Result<()> { + let decoded = envelope.decode().map_err(anyhow::Error::msg)?; + verify_release( + SignedRelease { + schema_version: envelope.schema_version, + key_id: &envelope.key_id, + payload_bytes: &decoded.payload_bytes, + signature: &decoded.signature, + }, + keyring, + context, + )?; + Ok(()) +} + +fn verify_installed_release( + keyring: &UpdateKeyring, + installed: &InstalledReleaseRecord, + generation: u64, +) -> Result<()> { + let active = installed + .release_envelope + .decode() + .map_err(anyhow::Error::msg)?; + verify( + keyring, + &installed.release_envelope, + &TrustedContext { + platform: crate::release_platform::VERIFY, + now_utc_seconds: installed.activated_at, + keyring_generation: generation, + protocol_major: active.manifest.protocol_major, + state_schema: active.manifest.state_schema, + updater_version: 1, + minimum_release_sequence: installed.activation_floor, + active_release: Some(ActiveRelease { + sequence: active.manifest.release_sequence, + manifest_sha256: installed.manifest_sha256.clone(), + }), + }, + ) +} +/// A released worker READ pin is not an observed record-save effect. Its exact +/// original identity/bytes/security must reappear under the archive namespace. +pub(crate) struct ReleasedRecordReadPin { + original: crate::update_native::files::Proof, +} +impl ReleasedRecordReadPin { + pub(crate) fn verify_archive(&self) -> Result<()> { + let path = Path::new(r"C:\ProgramData\RustDiscoveryUpdater\records") + .join(format!("{}.json", self.original.sha256)); + let (file, raw) = Protected::read(&path, 32768)?; + ensure!( + hash(&raw) == self.original.sha256, + "UPDATE_WORKER_ARCHIVE_BYTES_CHANGED" + ); + let mut handle = file.file.try_borrow_mut()?; + ensure!( + crate::update_native::files::proof(&mut handle.file, &path, 32768)? == self.original, + "UPDATE_WORKER_ARCHIVE_IDENTITY_CHANGED" + ); + Ok(()) + } +} +impl TrustState { + /// Only after actual authenticated HealthVerified, release this worker's + /// old-name READ handle so the independent helper can commit its native + /// Save/Observe and Publish/Observe. ALL other trust handles remain held; + /// no filesystem mutation, floor change or effect observation happens here. + pub(crate) fn release_worker_record_pin_after_health( + &self, + header: &rmm_updater_handoff::Handoff, + proof: &rmm_domain::agent_update::UpdateInflightProof, + ) -> Result { + let (actual, journal) = + rmm_domain::agent_update::verify_inflight_proof(proof, self.health_public_key) + .map_err(anyhow::Error::msg)?; + ensure!( + journal.phase() == rmm_updater_handoff::Phase::HealthVerified + && actual.bytes()? == header.bytes()? + && header.predecessor_record_sha256 == hash(&self.installed_raw) + && header.updater_sha256 == self.policy.updater_binary_sha256, + "UPDATE_ACTUAL_HEALTH_BEFORE_WORKER_READ_PIN_RELEASE" + ); + self.recheck_protected()?; + let pin = self + .installed_pin + .try_borrow_mut()? + .take() + .context("UPDATE_WORKER_RECORD_PIN_ALREADY_RELEASED")?; + let mut file = pin.file.try_borrow_mut()?; + let original = crate::update_native::files::proof( + &mut file.file, + Path::new(&self.policy.installed_record_path), + 32768, + )?; + ensure!( + original.sha256 == hash(&self.installed_raw), + "UPDATE_WORKER_ORIGINAL_RECORD_CHANGED" + ); + drop(file); + drop(pin); + Ok(ReleasedRecordReadPin { original }) + } +} diff --git a/crates/agent-windows/src/update_worker.rs b/crates/agent-windows/src/update_worker.rs new file mode 100644 index 0000000..efa4249 --- /dev/null +++ b/crates/agent-windows/src/update_worker.rs @@ -0,0 +1,799 @@ +//! Stable, separately provisioned SCM updater. Activation is one live pass: +//! only a successfully drained reply releases the queued original; no startup +//! scan resumes effects, and a duplicate activation is always denied. +use crate::{ + helper_ipc::{self as ipc, PeerProof}, + helper_system::{self, WindowsBoot}, + signed_clock::{BoundClock, RuntimeClock, UpdaterConfiguration}, + update_ipc::{self, Pin, Request, Response, State}, + update_native::{ + self as native, Budget, control_fence, + files::{BoundStage, Staged}, + services, + }, + update_original::Original, + update_owned, + update_state::{Bundle, QualifiedRegistry, RetainedSet}, + update_time_transport::Transport, + update_trust::{Protected, TrustState}, +}; +use anyhow::{Context, Result, ensure}; +use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD}; +use rmm_agent_core::{ + auth::Binding, + helper_reconcile::BootSource, + reconcile::SyncClock, + update_handoff::{ + NativeControlOperation, NativeControlReply, NativeControlRequest, NativeService, + }, +}; +use rmm_domain::{ + agent_update::{ParticipantIdentity, ParticipantRole, verify_inflight_proof}, + jobs::hash, +}; +use rmm_updater_handoff::Phase; +use std::{ + cell::RefCell, + collections::BTreeMap, + path::Path, + sync::{ + Arc, + atomic::{AtomicBool, AtomicU64, Ordering}, + }, + time::Duration, +}; +use uuid::Uuid; +struct Worker { + binding: Binding, + policy: rmm_domain::agent_update_provisioning::LocalUpdatePolicy, + policy_file: Protected, + profile_file: Protected, + pin: Pin, + own: RefCell, + identity: ParticipantIdentity, + clock: RuntimeClock, + generation: Arc, + pending: Option, + current: Option, + seen: BTreeMap, + state: State, +} +impl Worker { + fn open(clock: RuntimeClock, generation: Arc) -> Result { + let (policy_file, raw) = Protected::read( + Path::new(r"C:\ProgramData\RustDiscoveryUpdater\policy.json"), + 65536, + )?; + let (policy, policy_sha256) = + rmm_domain::agent_update_provisioning::LocalUpdatePolicy::from_bytes(&raw) + .map_err(anyhow::Error::msg)?; + let (profile_file, raw) = + Protected::read(Path::new(crate::signed_clock::UPDATER_CONFIG_PATH), 16384)?; + let profile: UpdaterConfiguration = serde_json::from_slice(&raw)?; + ensure!( + policy.schema_version == 2 + && profile.schema_version == 3 + && profile.updater_policy_sha256 == policy_sha256 + && policy.tenant_id == profile.binding.tenant_id + && policy.asset_id == profile.binding.asset_id + && policy.agent_id == profile.binding.agent_id + && policy.enrollment_generation == profile.binding.enrollment_generation + && policy.assignment_version == profile.binding.assignment_version, + "UPDATE_WORKER_PROTECTED_BINDING" + ); + let boot = WindowsBoot::capture()?; + let budget = Budget::new(&boot, boot.current_boot()?, Duration::from_secs(5))?; + let (own, identity) = services::observe_updater(&policy, &budget)?; + let (settings, _) = helper_system::read_settings()?; + ensure!( + serde_json::to_vec(&settings.binding)? == serde_json::to_vec(&profile.binding)?, + "UPDATE_WORKER_HELPER_BINDING" + ); + let pin = Pin { + schema_version: 1, + binding: profile.binding.clone(), + policy_sha256, + helper: settings.helper, + updater: services::updater_pin(&policy)?, + }; + pin.validate()?; + Ok(Self { + binding: profile.binding, + policy, + policy_file, + profile_file, + pin, + own: RefCell::new(own), + identity, + clock, + generation, + pending: None, + current: None, + seen: BTreeMap::new(), + state: State::NotConfigured, + }) + } + fn check(&self) -> Result<()> { + self.policy_file.verify()?; + self.profile_file.verify()?; + let mut own = self.own.try_borrow_mut()?; + own.check()?; + ensure!( + update_ipc::participant(&own, ParticipantRole::WindowsUpdater)? == self.identity + && services::updater_configuration_sha256(&self.pin.updater)? + == self.policy.updater_service.unit_sha256, + "UPDATE_WORKER_OWN_INSTANCE_CHANGED" + ); + Ok(()) + } + fn bound_clock(&self) -> BoundClock { + self.clock + .for_generation(self.generation.load(Ordering::SeqCst)) + } + fn request( + &self, + h: &rmm_updater_handoff::Handoff, + method: NativeControlOperation, + ) -> Result { + self.check()?; + let r = NativeControlRequest { + operation: "agent_update_control_v1".into(), + schema_version: 1, + challenge: Uuid::new_v4(), + tenant_id: self.binding.tenant_id, + asset_id: self.binding.asset_id, + agent_id: self.binding.agent_id, + enrollment_generation: self.binding.enrollment_generation, + assignment_version: self.binding.assignment_version, + grant_id: h.attempt.grant_id, + owner_nonce: h.owner_nonce, + handoff_sha256: hash(&h.bytes()?), + method, + }; + crate::update_control_ipc::exchange(&self.pin, &r) + } + fn drive(&mut self, grant: Uuid) -> Result<()> { + self.check()?; + let (bundle, bundle_recheck) = Bundle::load(grant)?; + let h = bundle.validate()?; + ensure!( + h.schema_version == 2 && bundle.delegation.updater == self.identity, + "UPDATE_WORKER_ORIGINAL_OWNER_REQUIRED" + ); + let mut reply = self.request(&h, NativeControlOperation::ReadOriginal)?; + let start = URL_SAFE_NO_PAD.decode( + reply + .original_start_base64url + .as_ref() + .context("UPDATE_ORIGINAL_START_REQUIRED")?, + )?; + let boot = WindowsBoot::capture()?; + let budget = Budget::new(&boot, h.boot_id, Duration::from_secs(600))?; + let clock = self.bound_clock(); + clock.require_generation(h.connection_generation)?; + let original = Original::verify( + &self.binding, + &start, + &bundle.handoff_record, + bundle.delegation.clone(), + &clock, + &budget, + )?; + let trust = TrustState::load_prepared(original.update(), &self.binding, &clock)?; + let retained = RetainedSet::reopen(&bundle.retained)?; + let registry = QualifiedRegistry::load(&trust)?; + let (settings, _) = helper_system::read_settings()?; + let mut running = + services::Running::observe([settings.agent.clone(), settings.helper.clone()], &budget)?; + registry.verify_observed( + &running.proofs(), + &services::updater_configuration_sha256(&self.pin.updater)?, + )?; + running.check(&budget)?; + while !pre_stop_context(&self.binding, &original, &trust, &clock, &reply)? { + original.check_current(&self.binding, &clock, &budget)?; + std::thread::sleep(Duration::from_millis(100)); + reply = self.request(&h, NativeControlOperation::ReadOriginal)?; + } + let proof = reply + .proof + .as_ref() + .context("UPDATE_ORIGINAL_PREFIX_REQUIRED")?; + let (_, journal) = + verify_inflight_proof(proof, trust.health_public_key()).map_err(anyhow::Error::msg)?; + ensure!( + journal.phase() == Phase::StopIntent, + "UPDATE_NO_REENTER_OR_RESUME" + ); + let mut claims = vec![]; + for service in [NativeService::WindowsAgent, NativeService::WindowsHelper] { + claims.push( + self.request( + &h, + NativeControlOperation::ClaimStop { + expected_head_sha256: journal.head_sha256().into(), + service, + }, + )? + .claim + .context("UPDATE_ORIGINAL_STOP_CLAIM_REQUIRED")?, + ); + } + let context = || control_fence::Context { + original: &original, + binding: &self.binding, + clock: &clock, + budget: &budget, + updater: &self.own, + retained: &retained, + trust: &trust, + }; + let proofs = running + .proofs() + .try_into() + .map_err(|_| anyhow::anyhow!("UPDATE_TWO_ORIGINAL_SERVICES_REQUIRED"))?; + let mut stop = control_fence::StopFence::new( + context(), + claims + .try_into() + .map_err(|_| anyhow::anyhow!("UPDATE_TWO_STOP_CLAIMS_REQUIRED"))?, + proofs, + proof, + )?; + let stopped = running.stop(&budget, &mut stop)?; + let observations = stop.finish(&stopped)?; + let closed = update_owned::ClosedFiles::acquire(&bundle, &stopped, &budget)?; + let mut ledger = update_owned::OwnedLedger::open(update_owned::Inputs { + closed: &closed, + stopped: &stopped, + bundle: &bundle, + bundle_recheck: &bundle_recheck, + original: &original, + binding: &self.binding, + clock: &clock, + budget: &budget, + updater: &self.own, + retained: &retained, + registry: ®istry, + trust: &trust, + })?; + ledger.record_stops(observations)?; + let originals = bundle + .files + .iter() + .map(|f| f.original.clone()) + .collect::>() + .try_into() + .map_err(|_| anyhow::anyhow!("UPDATE_FIVE_FILES_REQUIRED"))?; + let stages = bundle + .files + .iter() + .map(|f| f.staged.clone()) + .collect::>() + .try_into() + .map_err(|_| anyhow::anyhow!("UPDATE_FIVE_FILES_REQUIRED"))?; + let (db, guard) = ledger.parts(); + let mut fence = native::fence::LedgerFence::new(native::fence::Inputs { + db, + guard, + clock: &clock, + budget: &budget, + original: &h, + originals: &originals, + staged: &stages, + })?; + let mut published = vec![]; + for f in &bundle.files { + let stage = Staged::reopen_bound( + BoundStage { + role: f.role, + owner_nonce: h.owner_nonce, + original: &f.original, + staged: &f.staged, + }, + &budget, + )?; + published.push(stage.publish(&stopped, &budget, &mut fence)?); + } + fence.finish()?; + for file in published { + file.release(&budget)?; + } + let prepared = ledger.prepare_return_and_close()?; + let released = closed.release(&bundle, &stopped, &budget)?; + let mut start_fence = prepared.bind(context(), released, &bundle)?; + let (settings, _) = helper_system::read_settings()?; + let result = stopped.start_observed( + [settings.agent, settings.helper.clone()], + &budget, + &mut start_fence, + )?; + let (mut started, rolled_back) = match result { + services::StartResult::Running(mut running) => { + start_fence.finish(&mut running)?; + (running, false) + } + services::StartResult::KnownFailure(failed) => { + // Only first-helper failure has no started candidate reader. + // Partial starts require separately authorized stops; this + // branch cannot infer those from a caller reason or timeout. + let stopped = start_fence.helper_failed(*failed)?; + let closed = update_owned::ClosedFiles::acquire(&bundle, &stopped, &budget)?; + let mut ledger = update_owned::OwnedLedger::open(update_owned::Inputs { + closed: &closed, + stopped: &stopped, + bundle: &bundle, + bundle_recheck: &bundle_recheck, + original: &original, + binding: &self.binding, + clock: &clock, + budget: &budget, + updater: &self.own, + retained: &retained, + registry: ®istry, + trust: &trust, + })?; + ledger.begin_failed_helper_rollback()?; + let (db, guard) = ledger.parts(); + let mut fence = native::fence::RestoreFence::new(native::fence::Inputs { + db, + guard, + clock: &clock, + budget: &budget, + original: &h, + originals: &originals, + staged: &stages, + })?; + for f in bundle.files.iter().rev() { + native::files::Published::reopen_bound( + BoundStage { + role: f.role, + owner_nonce: h.owner_nonce, + original: &f.original, + staged: &f.staged, + }, + &stopped, + &budget, + )? + .restore(&stopped, &budget, &mut fence)?; + } + fence.finish()?; + let prepared = ledger.prepare_rollback_return_and_close()?; + let released = closed.release(&bundle, &stopped, &budget)?; + let mut fence = prepared.bind(context(), released, &bundle)?; + let (settings, _) = helper_system::read_settings()?; + let result = stopped.start_observed( + [settings.agent, settings.helper], + &budget, + &mut fence, + )?; + let services::StartResult::Running(mut running) = result else { + anyhow::bail!("UPDATE_PREDECESSOR_START_FAILED_NO_SECOND_RETURN") + }; + fence.finish(&mut running)?; + (running, true) + } + }; + self.pin.helper = helper_system::read_settings()?.0.helper; + let health_key = trust.health_public_key(); + let proof = started.proofs(); + self.request( + &h, + NativeControlOperation::ObserveStarts { + services: proof.iter().map(|p| p.started()).collect(), + observation_sha256: hash(&serde_json::to_vec(&proof)?), + }, + )?; + loop { + original.check_current(&self.binding, &clock, &budget)?; + started.check(&budget)?; + let reply = self.request(&h, NativeControlOperation::ReadOriginal)?; + let proof = reply.proof.context("UPDATE_ACTIVE_PREFIX_REQUIRED")?; + let (_, journal) = + verify_inflight_proof(&proof, health_key).map_err(anyhow::Error::msg)?; + if journal.phase() + == if rolled_back { + Phase::RollbackHealthVerified + } else { + Phase::HealthVerified + } + { + trust.recheck_prepared(original.update(), &clock)?; + let released = if rolled_back { + None + } else { + Some(trust.release_worker_record_pin_after_health(&h, &proof)?) + }; + let reply = self.request(&h, NativeControlOperation::Finalize)?; + if rolled_back { + verify_rollback_outcome(&original, &trust, &proof, &reply)?; + trust.recheck_protected()?; + } else { + verify_final_record(&original, &trust, &proof, &reply)?; + released + .context("UPDATE_WORKER_READ_PIN_RELEASE_REQUIRED")? + .verify_archive()?; + trust.recheck_other_protected()?; + } + self.state = State::OutcomePersisted; + return Ok(()); + } + ensure!( + journal.phase() + == if rolled_back { + Phase::RollbackServicesStarted + } else { + Phase::ServicesStarted + }, + "UPDATE_UNEXPECTED_POST_START_PHASE" + ); + std::thread::sleep(Duration::from_millis(100)); + } + } +} +// This is evidence of one already applied original control context, not a new +// grant/approval/start window. Absent witness means bounded no-effect waiting. +fn pre_stop_context( + binding: &Binding, + original: &Original, + trust: &TrustState, + clock: &BoundClock, + reply: &NativeControlReply, +) -> Result { + use prost::Message; + let (Some(raw), Some(signed)) = ( + &reply.pre_stop_sync_request_base64url, + &reply.pre_stop_sync_response_base64url, + ) else { + return Ok(false); + }; + let raw = URL_SAFE_NO_PAD.decode(raw)?; + let signed = URL_SAFE_NO_PAD.decode(signed)?; + ensure!( + raw.len() <= 512 * 1024 && signed.len() <= 512 * 1024, + "UPDATE_PRE_STOP_SYNC_LIMIT" + ); + let request = rmm_protocol::SyncRequest::decode(raw.as_slice())?; + let signed: rmm_agent_core::helper_reconcile::SignedResponse = serde_json::from_slice(&signed)?; + let response = rmm_protocol::SyncResponse { + decision_bytes: signed.decision_bytes, + signature: signed.signature, + }; + let decision: rmm_domain::reconciliation::ReconcileDecisionPayload = + serde_json::from_slice(&response.decision_bytes)?; + clock.require_generation(decision.connection_generation)?; + let (lower, upper) = clock.bounds()?; + ensure!( + request.encode_to_vec() == raw + && decision.issued_at <= lower + && upper < decision.valid_until + && !request.previous_decision_id.is_empty() + && request.previous_decision_id == request.helper_previous_decision_id, + "UPDATE_PRE_STOP_CURRENT_CONFIRMED_CONTEXT_REQUIRED" + ); + let verified = rmm_agent_core::reconcile::verify_response( + binding, + &request, + &rmm_agent_core::reconcile::Channel { + connection_generation: decision.connection_generation, + boot_id: original.handoff().boot_id, + }, + &response, + lower, + )?; + let proof = reply + .proof + .as_ref() + .context("UPDATE_PRE_STOP_PREFIX_REQUIRED")?; + let expected = rmm_domain::agent_update::inflight_decision(proof, trust.health_public_key()) + .map_err(anyhow::Error::msg)?; + let (header, journal) = + verify_inflight_proof(proof, trust.health_public_key()).map_err(anyhow::Error::msg)?; + ensure!( + header.bytes()? == original.handoff().bytes()? + && journal.phase() == Phase::StopIntent + && verified + .attempts + .iter() + .any(|a| a.job_id == original.permit().job_id + && a.attempt_id == original.permit().attempt_id + && a.update_inflight.as_ref() == Some(&expected) + && !a.unlock), + "UPDATE_PRE_STOP_EXACT_ORIGINAL_ACK_REQUIRED" + ); + let proof_bytes = proof.bytes().map_err(anyhow::Error::msg)?; + ensure!( + request + .attempts + .iter() + .any(|a| a.job_id == original.permit().job_id.to_string() + && a.attempt_id == original.permit().attempt_id.to_string() + && a.update_handoff_bytes == proof_bytes), + "UPDATE_PRE_STOP_EXACT_ORIGINAL_REQUEST_REQUIRED" + ); + Ok(true) +} +impl update_ipc::Engine for Worker { + fn handle(&mut self, peer: &ParticipantIdentity, request: Request) -> Result { + self.check()?; + match request { + Request::Describe {} => { + if self.pending.is_none() + && self.state != State::Unknown + && self.state != State::OutcomePersisted + { + self.state = if self.bound_clock().now().is_ok() { + State::Described + } else { + State::NotConfigured + }; + } + } + Request::Activate { + grant_id, + owner_nonce, + handoff_sha256, + } => { + ensure!( + self.pending.is_none() && !self.seen.contains_key(&grant_id), + "UPDATE_ACTIVATION_NO_REPLAY" + ); + let (bundle, recheck) = Bundle::load(grant_id)?; + let h = bundle.validate()?; + ensure!( + h.schema_version == 2 + && h.owner_nonce == owner_nonce + && hash(&h.bytes()?) == handoff_sha256 + && bundle.delegation.original_helper == *peer + && bundle.delegation.updater == self.identity, + "UPDATE_ACTIVATION_ORIGINAL_BINDING" + ); + self.bound_clock() + .require_generation(h.connection_generation)?; + self.bound_clock().now()?; + recheck()?; + ensure!( + matches!(self.state, State::Described | State::OutcomePersisted) + && self.seen.len() < 64, + "UPDATE_WORKER_NOT_AVAILABLE_FOR_NEW_ATTEMPT" + ); + self.seen.insert(grant_id, (owner_nonce, handoff_sha256)); + self.pending = Some(grant_id); + self.current = Some(grant_id); + self.state = State::Inflight; + } + Request::Read { + grant_id, + owner_nonce, + handoff_sha256, + } => ensure!( + self.current == Some(grant_id) + && self.seen.get(&grant_id) == Some(&(owner_nonce, handoff_sha256)), + "UPDATE_NO_ACTIVE_ORIGINAL" + ), + Request::Health { .. } => anyhow::bail!("UPDATE_AGENT_HEALTH_USES_SYSTEM_CONTROL"), + } + Ok(Response { + schema_version: 1, + state: self.state, + ready: false, + updater: self.identity.clone(), + head_sha256: None, + }) + } +} +fn current_generation_hint() -> Result { + const LEDGER: &str = r"C:\ProgramData\RustDiscoverySystem\state\ledger.sqlite"; + let file = ipc::PinnedFile::open( + Path::new(LEDGER), + false, + &[], + &[ipc::service_sid(ipc::HELPER_SERVICE)?], + true, + )?; + let db = rusqlite::Connection::open_with_flags( + LEDGER, + rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY | rusqlite::OpenFlags::SQLITE_OPEN_NO_MUTEX, + )?; + db.busy_timeout(Duration::ZERO)?; + db.execute_batch("PRAGMA query_only=ON;PRAGMA trusted_schema=OFF")?; + let generation: u64 = db.query_row( + "SELECT generation FROM helper_sync_meta WHERE id=1 AND fault IS NULL", + [], + |r| r.get(0), + )?; + ensure!(generation > 0, "UPDATE_TIME_GENERATION_HINT_MISSING"); + db.close().map_err(|(_, error)| error)?; + ensure!( + ipc::file_identity(&file.file)? == file.identity, + "UPDATE_TIME_HINT_FILE_CHANGED" + ); + // Hint only: independent server context/signature/nonce validates it. + Ok(generation) +} +pub fn dispatch() -> Result<()> { + crate::service::dispatch_named(update_ipc::SERVICE, run) +} +fn run(stop: &'static AtomicBool) -> Result<()> { + let runtime = tokio::runtime::Builder::new_multi_thread() + .worker_threads(2) + .enable_all() + .build()?; + let clock = RuntimeClock::new(rmm_time_attestation::Role::Updater); + let generation = Arc::new(AtomicU64::new(current_generation_hint()?)); + let mut worker = Worker::open(clock.clone(), generation.clone())?; + let binding = worker.binding.clone(); + let time_clock = clock.clone(); + let time_generation = generation.clone(); + let time_task = runtime.spawn(async move { + loop { + if stop.load(Ordering::SeqCst) { + break; + } + let generation = time_generation.load(Ordering::SeqCst); + let result = async { + if !time_clock.configured_for(generation) { + time_clock.open_connection(generation).await?; + } + let mut transport = Transport::open(&binding)?; + let request = time_clock.begin(generation)?; + let response = transport.compare(&request).await?; + time_clock.complete(generation, &response) + } + .await; + if result.is_err() { + let _ = time_clock.close_generation(generation); + } + tokio::time::sleep(Duration::from_millis(if result.is_ok() { + 250 + } else { + 1000 + })) + .await; + } + }); + let mut server = update_ipc::Server::bind(worker.pin.clone())?; + while !stop.load(Ordering::SeqCst) { + let delivered = server.serve_one(&mut worker); + match delivered { + Ok(true) => { + if let Some(grant) = worker.pending.take() { + // Only this successful drain receipt allows a live pass. + let result = worker.drive(grant); + if result.is_err() { + worker.state = State::Unknown; + let _report = + crate::update_state::Uncertain::write(grant, &worker.identity); + } + drop(server); + let (settings, _) = helper_system::read_settings()?; + worker.pin.helper = settings.helper; + server = update_ipc::Server::bind(worker.pin.clone())?; + generation.store(current_generation_hint()?, Ordering::SeqCst); + } + } + Ok(false) => {} + Err(_) => { + // Lost reply/receipt can never execute the queued original. + if let Some(grant) = worker.pending.take() { + worker.state = State::Unknown; + let _report = crate::update_state::Uncertain::write(grant, &worker.identity); + } + } + } + } + time_task.abort(); + clock.close()?; + Ok(()) +} + +fn verify_final_record( + original: &Original, + trust: &TrustState, + proof: &rmm_domain::agent_update::UpdateInflightProof, + reply: &NativeControlReply, +) -> Result<()> { + let encoded = reply + .original_outcome_base64url + .as_ref() + .context("UPDATE_ORIGINAL_FINAL_OUTCOME_REQUIRED")?; + let raw = URL_SAFE_NO_PAD.decode(encoded)?; + let outcome: rmm_domain::reconciliation::ReconciledOutcome = serde_json::from_slice(&raw)?; + ensure!( + rmm_domain::reconciliation::canonical_outcome_bytes(&outcome)? == raw + && outcome.state == "succeeded" + && !outcome.reboot_required + && outcome.error_code.is_empty() + && outcome.exit_code == Some(0) + && outcome.evidence["postconditions_passed"] == true, + "UPDATE_ORIGINAL_FINAL_OUTCOME_CHANGED" + ); + let event_raw = URL_SAFE_NO_PAD.decode( + proof + .events + .last() + .context("UPDATE_ORIGINAL_HEALTH_EVENT_REQUIRED")?, + )?; + let event: rmm_updater_handoff::Event = serde_json::from_slice(&event_raw)?; + let rmm_updater_handoff::Evidence::HealthVerified { receipt: signed } = event.evidence else { + anyhow::bail!("UPDATE_ORIGINAL_HEALTH_EVENT_REQUIRED") + }; + let receipt: rmm_updater_handoff::HealthReceipt = serde_json::from_slice(&signed.payload)?; + let expected = rmm_domain::agent_update_provisioning::assemble_updated_record( + original.update(), + trust.installed_raw(), + &hash(&original.handoff().bytes()?), + &signed, + &receipt, + ) + .map_err(anyhow::Error::msg)? + .bytes() + .map_err(anyhow::Error::msg)?; + let (file, actual) = Protected::read( + Path::new(r"C:\ProgramData\RustDiscoveryUpdater\installed-record.json"), + 32768, + )?; + let evidence = &outcome.evidence["agent_update"]; + ensure!( + actual == expected + && evidence["handoff_sha256"] == hash(&original.handoff().bytes()?) + && evidence["installed_record_sha256"] == hash(&actual) + && evidence["manifest_sha256"] == original.handoff().target.manifest_sha256 + && evidence["predecessor_record_sha256"] + == original.handoff().predecessor_record_sha256 + && evidence["signed_health_sha256"] == hash(&serde_json::to_vec(&signed)?) + && evidence["rolled_back"] == false, + "UPDATE_ORIGINAL_RECORD_AND_OUTCOME_CHANGED" + ); + file.verify() +} + +fn verify_rollback_outcome( + original: &Original, + trust: &TrustState, + proof: &rmm_domain::agent_update::UpdateInflightProof, + reply: &NativeControlReply, +) -> Result<()> { + let raw = URL_SAFE_NO_PAD.decode( + reply + .original_outcome_base64url + .as_ref() + .context("UPDATE_ORIGINAL_ROLLBACK_OUTCOME_REQUIRED")?, + )?; + let outcome: rmm_domain::reconciliation::ReconciledOutcome = serde_json::from_slice(&raw)?; + let event_raw = URL_SAFE_NO_PAD.decode( + proof + .events + .last() + .context("UPDATE_ROLLBACK_HEALTH_EVENT_REQUIRED")?, + )?; + let event: rmm_updater_handoff::Event = serde_json::from_slice(&event_raw)?; + let rmm_updater_handoff::Evidence::RollbackHealthVerified { receipt: signed } = event.evidence + else { + anyhow::bail!("UPDATE_ROLLBACK_HEALTH_EVENT_REQUIRED") + }; + let evidence = &outcome.evidence["agent_update"]; + ensure!( + rmm_domain::reconciliation::canonical_outcome_bytes(&outcome)? == raw + && outcome.state == "failed" + && outcome.error_code == "AGENT_UPDATE_RETURNED_TO_PREDECESSOR" + && !outcome.reboot_required + && outcome.evidence["postconditions_passed"] == false + && evidence["rolled_back"] == true + && evidence["handoff_sha256"] == hash(&original.handoff().bytes()?) + && evidence["predecessor_record_sha256"] + == original.handoff().predecessor_record_sha256 + && evidence["installed_record_sha256"] == original.handoff().predecessor_record_sha256 + && evidence["signed_health_sha256"] == hash(&serde_json::to_vec(&signed)?), + "UPDATE_ROLLBACK_OUTCOME_CHANGED" + ); + let (file, raw) = Protected::read( + Path::new(r"C:\ProgramData\RustDiscoveryUpdater\installed-record.json"), + 32768, + )?; + ensure!( + raw == trust.installed_raw(), + "UPDATE_ROLLBACK_CHANGED_RECORD_OR_FLOOR" + ); + file.verify() +} diff --git a/crates/agent/src/agent_update_health.rs b/crates/agent/src/agent_update_health.rs index 2d26f6f..b5eaecf 100644 --- a/crates/agent/src/agent_update_health.rs +++ b/crates/agent/src/agent_update_health.rs @@ -320,7 +320,7 @@ pub fn context( rmm_domain::jobs::Action::UpdateAgent { ref update } => { match update.manifest().map_err(anyhow::Error::msg)?.platform { update::Platform::LinuxX64 => "linux.base", - update::Platform::WindowsX64 => "windows.base", + update::Platform::WindowsX64 | update::Platform::WindowsGnuX64 => "windows.base", } } _ => anyhow::bail!("UPDATE_HEALTH_ACTION"), diff --git a/crates/domain/examples/agent_update_golden.rs b/crates/domain/examples/agent_update_golden.rs index 7e6a556..174cde7 100644 --- a/crates/domain/examples/agent_update_golden.rs +++ b/crates/domain/examples/agent_update_golden.rs @@ -60,7 +60,7 @@ fn fixture(platform: Platform, full: bool) -> serde_json::Value { Platform::LinuxX64 => PeerPinTransition::UnchangedGeneralPinV1 { general_pin_sha256: "10".repeat(32), }, - Platform::WindowsX64 => PeerPinTransition::WindowsCodePairV1 { + Platform::WindowsX64 | Platform::WindowsGnuX64 => PeerPinTransition::WindowsCodePairV1 { old_settings_sha256: "11".repeat(32), new_settings_sha256: "12".repeat(32), old_pin_sha256: "13".repeat(32), @@ -111,7 +111,7 @@ fn fixture(platform: Platform, full: bool) -> serde_json::Value { }, execution_identity: match platform { Platform::LinuxX64 => "root", - Platform::WindowsX64 => "system", + Platform::WindowsX64 | Platform::WindowsGnuX64 => "system", } .into(), not_before: "2030-01-01T12:00:00Z".parse().unwrap(), diff --git a/crates/domain/src/agent_update.rs b/crates/domain/src/agent_update.rs index 86b0cec..7dd12b9 100644 --- a/crates/domain/src/agent_update.rs +++ b/crates/domain/src/agent_update.rs @@ -52,6 +52,8 @@ pub enum Platform { LinuxX64, #[serde(rename = "x86_64-pc-windows-msvc")] WindowsX64, + #[serde(rename = "x86_64-pc-windows-gnu")] + WindowsGnuX64, } #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)] #[serde(rename_all = "snake_case")] @@ -707,7 +709,7 @@ impl ResolvedAgentUpdate { pub fn execution_identity(&self) -> Option<&'static str> { self.manifest().ok().map(|m| match m.platform { Platform::LinuxX64 => "root", - Platform::WindowsX64 => "system", + Platform::WindowsX64 | Platform::WindowsGnuX64 => "system", }) } } diff --git a/crates/domain/src/inventory_document.rs b/crates/domain/src/inventory_document.rs index 76775af..0e14845 100644 --- a/crates/domain/src/inventory_document.rs +++ b/crates/domain/src/inventory_document.rs @@ -66,12 +66,7 @@ pub fn validate_for_scope( .map_err(|_| "INVALID_AGENT_UPDATE_OBSERVATION")? != update || !typed.agent_update.validate() - || typed.agent_update.platform - != if scope == "linux.base" { - crate::agent_update::Platform::LinuxX64 - } else { - crate::agent_update::Platform::WindowsX64 - } + || (typed.agent_update.platform == crate::agent_update::Platform::LinuxX64) != (scope == "linux.base") || typed.agent_update.observed_at - now > chrono::Duration::seconds(45) || now - typed.agent_update.observed_at > chrono::Duration::hours(72) { diff --git a/crates/server/src/agent_service.rs b/crates/server/src/agent_service.rs index 7c75dc9..078cdef 100644 --- a/crates/server/src/agent_service.rs +++ b/crates/server/src/agent_service.rs @@ -63,7 +63,12 @@ pub async fn open( ); let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant).await?; control_lock(&mut tx, tenant, agent).await?; - let generation:i64=sqlx::query_scalar("UPDATE agent_installations SET connection_generation=connection_generation+1,capabilities=$2,transport=$3,connection_boot_id=$4,restore_blocked=restore_blocked OR $5<=last_sequence,sequence_regressed=sequence_regressed OR $5<=last_sequence,sync_required=$6,sync_ready=NOT $6,helper_sync_ready=false,last_sequence=$5 WHERE agent_id=$1 AND revoked_at IS NULL RETURNING connection_generation").bind(agent).bind(serde_json::to_value(&client.capabilities)?).bind(transport).bind(Uuid::parse_str(&e.boot_id)?).bind(i64::try_from(e.sequence)?).bind(client.capabilities.iter().any(|c|c=="rmm.sync.v1")).fetch_one(&mut *tx).await?; + anyhow::ensure!( + client.agent_version.len() <= 64 + && client.agent_version.bytes().all(|b| b.is_ascii_graphic()), + "invalid agent version" + ); + let generation:i64=sqlx::query_scalar("UPDATE agent_installations SET connection_generation=connection_generation+1,capabilities=$2,transport=$3,connection_boot_id=$4,restore_blocked=restore_blocked OR $5<=last_sequence,sequence_regressed=sequence_regressed OR $5<=last_sequence,sync_required=$6,sync_ready=NOT $6,helper_sync_ready=false,last_sequence=$5,reported_agent_version=NULLIF($7,'') WHERE agent_id=$1 AND revoked_at IS NULL RETURNING connection_generation").bind(agent).bind(serde_json::to_value(&client.capabilities)?).bind(transport).bind(Uuid::parse_str(&e.boot_id)?).bind(i64::try_from(e.sequence)?).bind(client.capabilities.iter().any(|c|c=="rmm.sync.v1")).bind(&client.agent_version).fetch_one(&mut *tx).await?; tx.commit().await?; Ok(reply( e, diff --git a/crates/server/src/agent_update_health.rs b/crates/server/src/agent_update_health.rs index 6579e90..a3d50fb 100644 --- a/crates/server/src/agent_update_health.rs +++ b/crates/server/src/agent_update_health.rs @@ -419,7 +419,7 @@ async fn issue( )?; let scope = match action.manifest().map_err(|_| denied())?.platform { update::Platform::LinuxX64 => "linux.base", - update::Platform::WindowsX64 => "windows.base", + update::Platform::WindowsX64 | update::Platform::WindowsGnuX64 => "windows.base", }; // Health requires a fresh real base inventory of the restarted platform; // a not_configured update observation cannot stand in for that evidence. diff --git a/crates/server/src/agent_updates.rs b/crates/server/src/agent_updates.rs index 877494a..18ec287 100644 --- a/crates/server/src/agent_updates.rs +++ b/crates/server/src/agent_updates.rs @@ -1,5 +1,7 @@ //! Tenant release publication and update-only bounded object transport. //! Catalog metadata and passive checks never create/approve an execution job. +#[path = "bootstrap/mod.rs"] +mod bootstrap; use crate::{ jobs::Error, update_artifact_store::{MAX_CHUNK_BYTES, UpdateArtifacts}, @@ -42,6 +44,7 @@ pub fn platform_name(platform: Platform) -> &'static str { match platform { Platform::LinuxX64 => "x86_64-unknown-linux-gnu", Platform::WindowsX64 => "x86_64-pc-windows-msvc", + Platform::WindowsGnuX64 => "x86_64-pc-windows-gnu", } } pub fn protected_file(path: &FsPath, maximum: u64) -> Result, Error> { @@ -122,9 +125,11 @@ pub fn store() -> Result { } Ok(UpdateArtifacts::new( &std::env::var("RMM_PROFILE").unwrap_or_default(), - path.parent() - .ok_or_else(|| fail("AGENT_UPDATE_NOT_CONFIGURED"))? - .join("agent-update-artifacts"), + match std::env::var_os("RMM_AGENT_UPDATE_ARTIFACT_DIR") { + Some(value) if FsPath::new(&value).is_absolute() => value.into(), + Some(_) => return Err(fail("AGENT_UPDATE_NOT_CONFIGURED")), + None => path.parent().ok_or_else(|| fail("AGENT_UPDATE_NOT_CONFIGURED"))?.join("agent-update-artifacts"), + }, metadata.uid(), )?) } @@ -132,6 +137,7 @@ fn verifier_platform(platform: Platform) -> rmm_updater::Platform { match platform { Platform::LinuxX64 => rmm_updater::Platform::LinuxX64, Platform::WindowsX64 => rmm_updater::Platform::WindowsX64, + Platform::WindowsGnuX64 => rmm_updater::Platform::WindowsGnuX64, } } /// Network input can choose only one of two statically named protected @@ -143,6 +149,7 @@ fn keyring_path_with( let name = match platform { Platform::LinuxX64 => "RMM_AGENT_UPDATE_LINUX_KEYRING_FILE", Platform::WindowsX64 => "RMM_AGENT_UPDATE_WINDOWS_KEYRING_FILE", + Platform::WindowsGnuX64 => "RMM_AGENT_UPDATE_WINDOWS_GNU_KEYRING_FILE", }; if let Some(path) = lookup(name)? { if path.is_empty() || !FsPath::new(&path).is_absolute() { @@ -161,12 +168,10 @@ pub fn verify_envelope( binding: Option<&rmm_domain::agent_update::UpdaterBinding>, ) -> Result { let platform = envelope.decode().map_err(|_| invalid())?.manifest.platform; - let path = keyring_path_with(platform, |name| match std::env::var(name) { - Ok(value) => Ok(Some(value)), - Err(std::env::VarError::NotPresent) => Ok(None), - Err(std::env::VarError::NotUnicode(_)) => Err(fail("AGENT_UPDATE_NOT_CONFIGURED")), - })?; - let raw = protected_file(&path, 16384)?; + if platform == Platform::WindowsGnuX64 && std::env::var("RMM_PROFILE").as_deref() != Ok("development") { + return Err(fail("AGENT_UPDATE_DEVELOPMENT_CHANNEL_REQUIRED")); + } + let raw = keyring_bytes(platform)?; verify_envelope_with_keyring( envelope, binding, @@ -177,6 +182,14 @@ pub fn verify_envelope( .map_err(|_| invalid())?, ) } +fn keyring_bytes(platform: Platform) -> Result, Error> { + let path = keyring_path_with(platform, |name| match std::env::var(name) { + Ok(value) => Ok(Some(value)), + Err(std::env::VarError::NotPresent) => Ok(None), + Err(std::env::VarError::NotUnicode(_)) => Err(fail("AGENT_UPDATE_NOT_CONFIGURED")), + })?; + protected_file(&path, 16384) +} fn verify_envelope_with_keyring( envelope: &ReleaseEnvelope, binding: Option<&rmm_domain::agent_update::UpdaterBinding>, @@ -242,6 +255,7 @@ fn verify_envelope_with_keyring( } pub fn routes(router: Router) -> Router { router + .route("/api/v1/tenants/{tenant}/enrollment-tokens", post(bootstrap::issue)) .route( "/api/v1/tenants/{tenant}/agent-releases", get(list).post(import), @@ -253,7 +267,20 @@ pub fn routes(router: Router) -> Router { } pub fn gateway_routes(router: Router) -> Router { router + .route("/install/linux.sh", get(|| async { ([("content-type", "text/x-shellscript")], concat!(include_str!("bootstrap/install.sh"),include_str!("bootstrap/lifecycle.py")," +RMM_BOOTSTRAP_PYTHON +/usr/bin/python3 -I \"$file\" install \"$@\" +")) })) + .route("/install/windows.ps1", get(|| async { ([("content-type", "text/plain; charset=utf-8")], include_str!("bootstrap/install.ps1")) })) + .route("/agent/v1/bootstrap/current", get(bootstrap::current)) + .route("/agent/v1/bootstrap/releases/{release}/artifacts/{artifact}", get(bootstrap::artifact)) + .route("/agent/v1/bootstrap/updater", get(bootstrap::updater)) .route("/agent/v1/releases/current", get(current)) + .route("/agent/v1/releases/installed", get(installed)) + .route( + "/agent/v1/releases/{release}/artifacts/{artifact}", + get(release_artifact), + ) .route("/agent/v1/update-artifacts/{artifact}", get(download)) } #[derive(Deserialize)] @@ -412,12 +439,26 @@ pub async fn import( let sequence = i64::try_from(m.release_sequence).map_err(|_| invalid())?; resolve_artifacts(&mut tx, t, &m.artifacts).await?; let manifest_sha = hash(&envelope.decode().map_err(|_| invalid())?.payload_bytes); - sqlx::query("INSERT INTO agent_update_releases(tenant_id,release_id,platform,release_sequence,manifest_sha256,envelope_sha256,envelope,agent_artifact_id,agent_sha256,agent_bytes,helper_artifact_id,helper_sha256,helper_bytes) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13)") - .bind(t).bind(m.release_id).bind(platform_name(m.platform)).bind(sequence).bind(&manifest_sha).bind(hash(&raw)).bind(raw) + let inserted = sqlx::query("INSERT INTO agent_update_releases(tenant_id,release_id,platform,release_sequence,manifest_sha256,envelope_sha256,envelope,agent_artifact_id,agent_sha256,agent_bytes,helper_artifact_id,helper_sha256,helper_bytes) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13) ON CONFLICT DO NOTHING") + .bind(t).bind(m.release_id).bind(platform_name(m.platform)).bind(sequence).bind(&manifest_sha).bind(hash(&raw)).bind(&raw) .bind(m.artifacts[0].artifact_id).bind(&m.artifacts[0].sha256).bind(m.artifacts[0].bytes as i64) .bind(m.artifacts[1].artifact_id).bind(&m.artifacts[1].sha256).bind(m.artifacts[1].bytes as i64).execute(&mut *tx).await?; + if inserted.rows_affected() == 0 { + let stored: Option> = sqlx::query_scalar( + "SELECT envelope FROM agent_update_releases WHERE release_id=$1 AND platform=$2 AND release_sequence=$3", + ) + .bind(m.release_id) + .bind(platform_name(m.platform)) + .bind(sequence) + .fetch_optional(&mut *tx) + .await?; + if stored.as_deref() != Some(raw.as_slice()) { + return Err(fail("AGENT_UPDATE_RELEASE_CONFLICT")); + } + } else { sqlx::query("INSERT INTO audit_events VALUES($1,$2,$3,'agent_update_release_imported',$4,now())").bind(t).bind(Uuid::new_v4()).bind(p.name) .bind(json!({"release_id":m.release_id,"manifest_sha256":manifest_sha,"testsimulation":p.testsimulation})).execute(&mut *tx).await?; + } tx.commit().await?; Ok(Json( json!({"release_id":m.release_id,"manifest_sha256":manifest_sha,"release_envelope":envelope,"manifest":m}), @@ -496,6 +537,86 @@ async fn device( .await .map_err(|status| Error(status, "UNAUTHENTICATED")) } +async fn installed(State(s): State, Extension(peer): Extension, headers: HeaderMap) -> Result { + let (tenant, agent) = device(&s, peer, &headers).await?; + let mut tx = rmm_persistence::tenant_tx(&s.pool, tenant).await?; + let row = sqlx::query("SELECT reported_agent_version,connection_generation,last_contact_at FROM agent_installations WHERE agent_id=$1 AND revoked_at IS NULL").bind(agent).fetch_one(&mut *tx).await?; + tx.commit().await?; + Ok(([("cache-control","private, no-store")], Json(json!({"agent_id":agent, + "agent_version":row.get::,_>("reported_agent_version"), + "connection_generation":row.get::("connection_generation"), + "last_contact_at":row.get::>,_>("last_contact_at")}))).into_response()) +} + +async fn check_device_platform( + tx: &mut Transaction<'_, Postgres>, + agent: Uuid, + platform: Platform, +) -> Result<(), Error> { + let caps: Value = sqlx::query_scalar( + "SELECT capabilities FROM agent_installations WHERE agent_id=$1 AND revoked_at IS NULL", + ) + .bind(agent) + .fetch_one(&mut **tx) + .await?; + let caps: Vec = serde_json::from_value(caps)?; + let expected = match platform { + Platform::LinuxX64 => "linux.base/1", + Platform::WindowsX64 if caps.iter().any(|c| c == "agent.release.windows.gnu/1") => return Err(missing()), + Platform::WindowsX64 => "windows.base/1", + Platform::WindowsGnuX64 => "agent.release.windows.gnu/1", + }; + if !caps.iter().any(|c| c == expected) { + return Err(missing()); + } + Ok(()) +} + +/// A published release grants access to its two fixed binaries for authenticated +/// devices of its own tenant and platform. A catalog write first verifies both +/// objects. Fetching rechecks the live signing trust and the actual object. +async fn release_artifact( + State(s): State, + Extension(peer): Extension, + headers: HeaderMap, + Path((release, artifact)): Path<(Uuid, Uuid)>, +) -> Result { + let (tenant, agent) = device(&s, peer, &headers).await?; + let mut tx = rmm_persistence::tenant_tx(&s.pool, tenant).await?; + let (_, manifest) = checked_release(&mut tx, release).await?; + check_device_platform(&mut tx, agent, manifest.platform).await?; + let descriptor = manifest.artifacts.into_iter() + .find(|entry| entry.artifact_id == artifact).ok_or_else(missing)?; + tx.commit().await?; + verified_binary(tenant, descriptor.sha256, descriptor.bytes).await +} + +async fn verified_binary(tenant: Uuid, sha256: String, size: u64) -> Result { + use tokio::io::AsyncReadExt; + let digest = sha256.clone(); + let file = tokio::task::spawn_blocking(move || -> Result { + Ok(store()?.verified_file(tenant, &digest, size)?) + }) + .await + .map_err(|_| fail("AGENT_UPDATE_ARTIFACT_UNAVAILABLE"))??; + let reader = tokio::fs::File::from_std(file).take(size); + let stream = futures_util::stream::try_unfold(reader, |mut reader| async move { + let mut chunk = vec![0; 64 * 1024]; + let count = reader.read(&mut chunk).await?; + chunk.truncate(count); + Ok::<_, std::io::Error>((count != 0).then_some((chunk, reader))) + }); + let mut response = Response::new(Body::from_stream(stream)); + let headers = response.headers_mut(); + headers.insert("content-type", HeaderValue::from_static("application/octet-stream")); + headers.insert("content-length", HeaderValue::from(size)); + headers.insert("content-disposition", HeaderValue::from_static("attachment")); + headers.insert("x-content-type-options", HeaderValue::from_static("nosniff")); + headers.insert("cache-control", HeaderValue::from_static("private, no-store")); + headers.insert("x-artifact-sha256", HeaderValue::from_str(&sha256).map_err(|_| invalid())?); + Ok(response) +} + async fn current( State(s): State, Extension(peer): Extension, @@ -504,20 +625,7 @@ async fn current( ) -> Result, Error> { let (tenant, agent) = device(&s, peer, &headers).await?; let mut tx = rmm_persistence::tenant_tx(&s.pool, tenant).await?; - let caps: Value = sqlx::query_scalar( - "SELECT capabilities FROM agent_installations WHERE agent_id=$1 AND revoked_at IS NULL", - ) - .bind(agent) - .fetch_one(&mut *tx) - .await?; - let caps: Vec = serde_json::from_value(caps)?; - let expected = match q.platform { - Platform::LinuxX64 => "linux.base/1", - Platform::WindowsX64 => "windows.base/1", - }; - if !caps.iter().any(|c| c == expected) { - return Err(missing()); - } + check_device_platform(&mut tx, agent, q.platform).await?; let ids:Vec=sqlx::query_scalar("SELECT release_id FROM agent_update_releases WHERE platform=$1 ORDER BY release_sequence DESC LIMIT 1").bind(platform_name(q.platform)).fetch_all(&mut *tx).await?; let release = if let Some(id) = ids.first() { let (envelope, manifest) = checked_release(&mut tx, *id).await?; diff --git a/crates/server/src/api.rs b/crates/server/src/api.rs index 86d83a2..1f49f9e 100644 --- a/crates/server/src/api.rs +++ b/crates/server/src/api.rs @@ -128,7 +128,7 @@ async fn device_list( .map_err(|e| e.0)?; let mut page = crate::pagination::Cursor::parse(state, &principal, "devices:agent_id:asc", query)?; - let rows = sqlx::query("SELECT a.agent_id,a.asset_id,a.revoked_at,a.last_contact_at,a.certificate_sha256,a.last_authenticated_certificate_sha256,a.last_authenticated_at,a.capabilities,a.enrollment_generation,a.assignment_version,o.observed_at,o.received_at,o.data,o.source_id FROM agent_installations a LEFT JOIN LATERAL (SELECT observed_at,received_at,data,source_id FROM observations WHERE tenant_id=a.tenant_id AND agent_id=a.agent_id AND source_id IN ('linux.base','windows.base') AND received_at<=$2 ORDER BY observed_at DESC, received_at DESC LIMIT 1) o ON true WHERE ($1::uuid IS NULL OR a.asset_id=$1) AND a.agent_id>$3 AND a.created_at<=$2 ORDER BY a.agent_id LIMIT $4") + let rows = sqlx::query("SELECT a.agent_id,a.asset_id,a.revoked_at,a.last_contact_at,a.certificate_sha256,a.last_authenticated_certificate_sha256,a.last_authenticated_at,a.reported_agent_version,a.capabilities,a.enrollment_generation,a.assignment_version,o.observed_at,o.received_at,o.data,o.source_id FROM agent_installations a LEFT JOIN LATERAL (SELECT observed_at,received_at,data,source_id FROM observations WHERE tenant_id=a.tenant_id AND agent_id=a.agent_id AND source_id IN ('linux.base','windows.base') AND received_at<=$2 ORDER BY observed_at DESC, received_at DESC LIMIT 1) o ON true WHERE ($1::uuid IS NULL OR a.asset_id=$1) AND a.agent_id>$3 AND a.created_at<=$2 ORDER BY a.agent_id LIMIT $4") .bind(asset) .bind(page.as_of).bind(page.last).bind(i64::from(page.limit)+1) .fetch_all(&mut *tx).await.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; @@ -141,7 +141,7 @@ async fn device_list( let revoked: Option> = r.get("revoked_at"); let age = last.map(|t| (Utc::now()-t).num_seconds()); let presence = if revoked.is_some() { "revoked" } else { match age { None=>"never_seen",Some(n) if n<90=>"online",Some(n) if n<180=>"stale",_=>"unreachable" } }; - json!({"agent_id":r.get::("agent_id"),"asset_id":r.get::("asset_id"),"certificate_sha256":r.get::("certificate_sha256"),"last_authenticated_certificate_sha256":r.get::,_>("last_authenticated_certificate_sha256"),"last_authenticated_at":r.get::>,_>("last_authenticated_at"),"capabilities":r.get::("capabilities"),"enrollment_generation":r.get::("enrollment_generation"),"assignment_version":r.get::("assignment_version"),"presence":presence,"last_contact_at":last,"inventory":r.get::,_>("data"),"observed_at":r.get::>,_>("observed_at"),"received_at":r.get::>,_>("received_at"),"source_id":r.get::,_>("source_id"),"quality":if r.get::,_>("data").is_some(){"valid"}else{"unknown"},"completeness":"partial","health":"unknown"}) + json!({"agent_id":r.get::("agent_id"),"asset_id":r.get::("asset_id"),"agent_version":r.get::,_>("reported_agent_version"),"certificate_sha256":r.get::("certificate_sha256"),"last_authenticated_certificate_sha256":r.get::,_>("last_authenticated_certificate_sha256"),"last_authenticated_at":r.get::>,_>("last_authenticated_at"),"capabilities":r.get::("capabilities"),"enrollment_generation":r.get::("enrollment_generation"),"assignment_version":r.get::("assignment_version"),"presence":presence,"last_contact_at":last,"inventory":r.get::,_>("data"),"observed_at":r.get::>,_>("observed_at"),"received_at":r.get::>,_>("received_at"),"source_id":r.get::,_>("source_id"),"quality":if r.get::,_>("data").is_some(){"valid"}else{"unknown"},"completeness":"partial","health":"unknown"}) }).collect::>(); let next = if truncated { Some(page.next(state, rows[usize::from(page.limit) - 1].get("agent_id"))?) diff --git a/crates/server/src/bootstrap/install.ps1 b/crates/server/src/bootstrap/install.ps1 new file mode 100644 index 0000000..bae6951 --- /dev/null +++ b/crates/server/src/bootstrap/install.ps1 @@ -0,0 +1,205 @@ +#requires -Version 5.1 +#requires -RunAsAdministrator +[CmdletBinding()] +param( + [Parameter(Mandatory)][Uri]$BootstrapBase, + [Security.SecureString]$EnrollmentToken, + [ValidateSet('x86_64-pc-windows-msvc','x86_64-pc-windows-gnu')] + [string]$Platform = 'x86_64-pc-windows-msvc' +) +$ErrorActionPreference = 'Stop' +Set-StrictMode -Version Latest +if ($PSVersionTable.PSEdition -ne 'Desktop' -or -not [Environment]::Is64BitProcess -or + $env:PROCESSOR_ARCHITECTURE -ne 'AMD64') { throw 'Use 64-bit Windows PowerShell on x64 Windows.' } + +function Get-Origin([Uri]$Uri) { + if (-not $Uri.IsAbsoluteUri -or $Uri.Scheme -cne 'https' -or $Uri.HostNameType -ne 'Dns' -or + $Uri.UserInfo -or $Uri.Fragment -or $Uri.Query -or $Uri.AbsolutePath -cne '/') { throw 'A DNS HTTPS origin is required.' } + return $Uri.GetLeftPart([UriPartial]::Authority) +} +function Get-Id([string]$Value) { + $id = [Guid]::ParseExact($Value, 'D') + if ($id -eq [Guid]::Empty) { throw 'Empty release identifier.' } + return $id.ToString('D') +} +function Get-Download([string]$Path, [string]$File, [long]$Limit, [bool]$Exact) { + if ($Limit -lt 1 -or $Limit -gt 268435456) { throw 'Invalid bootstrap file size.' } + $request = [Net.HttpWebRequest]::Create($origin + $Path) + $request.AllowAutoRedirect = $false + $request.Timeout = 60000 + $request.ReadWriteTimeout = 60000 + $request.Headers['Authorization'] = 'Enrollment ' + $token + $response = $null + try { + $response = $request.GetResponse() + if ([int]$response.StatusCode -ne 200 -or $response.ContentLength -gt $Limit) { throw 'Unexpected bootstrap response.' } + $source = $response.GetResponseStream() + $dest = [IO.File]::Open($File, [IO.FileMode]::CreateNew, [IO.FileAccess]::Write, [IO.FileShare]::None) + try { + $buffer = New-Object byte[] 65536 + [long]$total = 0 + while (($n = $source.Read($buffer, 0, $buffer.Length)) -gt 0) { + $total += $n + if ($total -gt $Limit) { throw 'Bootstrap response too large.' } + $dest.Write($buffer, 0, $n) + } + if ($Exact -and $total -ne $Limit) { throw 'Incomplete bootstrap download.' } + $dest.Flush($true) + } finally { $dest.Dispose(); $source.Dispose() } + } finally { if ($response) { $response.Dispose() } } +} +function Get-DirectoryAcl($ServiceSid, [string]$Rights) { + $acl = New-Object Security.AccessControl.DirectorySecurity + $acl.SetAccessRuleProtection($true, $false) + $acl.SetOwner($administrators) + foreach ($sid in @($administrators, $system)) { + $acl.AddAccessRule([Security.AccessControl.FileSystemAccessRule]::new($sid, 'FullControl', 'ContainerInherit,ObjectInherit', 'None', 'Allow')) + } + if ($ServiceSid) { + $acl.AddAccessRule([Security.AccessControl.FileSystemAccessRule]::new($ServiceSid, $Rights, 'ContainerInherit,ObjectInherit', 'None', 'Allow')) + } + return $acl +} +function Set-Text([string]$Path, [string]$Value) { + [IO.File]::WriteAllText($Path, $Value, $utf8) +} +function Get-Hash([string]$Path) { + return (Get-FileHash -LiteralPath $Path -Algorithm SHA256).Hash.ToLowerInvariant() +} +$origin = Get-Origin $BootstrapBase +$app = Join-Path ([Environment]::GetFolderPath('ProgramFiles')) 'RustDiscovery' +$data = Join-Path ([Environment]::GetFolderPath('CommonApplicationData')) 'RustDiscovery' +$state = Join-Path $data 'state' +$identity = Join-Path $state 'identity.json' +$serviceName = 'RmmDiscoveryWindows' +$releaseService = 'RmmDiscoveryReleasePull' +$service = Get-Service -Name $serviceName -ErrorAction SilentlyContinue +if ($service -and (Test-Path -LiteralPath $identity -PathType Leaf)) { + Write-Output "Rust Discovery is already enrolled. Agent service: $($service.Status)." + return +} +if ($service -or (Get-Service $releaseService -ErrorAction SilentlyContinue) -or (Test-Path -LiteralPath $app) -or (Test-Path -LiteralPath $data)) { + throw 'Existing incomplete installation. Inspect the service and enrollment state before retrying.' +} +if (-not $EnrollmentToken) { $EnrollmentToken = Read-Host 'One-time enrollment token' -AsSecureString } +$ptr = [Runtime.InteropServices.Marshal]::SecureStringToBSTR($EnrollmentToken) +try { $token = [Runtime.InteropServices.Marshal]::PtrToStringBSTR($ptr) } +finally { [Runtime.InteropServices.Marshal]::ZeroFreeBSTR($ptr) } +if ($token -cnotmatch '^[0-9a-f]{64}$') { throw 'Invalid one-time enrollment token.' } +$query = '?platform=' + $platform +$utf8 = New-Object Text.UTF8Encoding($false) +$administrators = [Security.Principal.SecurityIdentifier]::new('S-1-5-32-544') +$system = [Security.Principal.SecurityIdentifier]::new('S-1-5-18') +$stage = Join-Path ([Environment]::GetFolderPath('ProgramFiles')) ('RustDiscovery-install-' + [Guid]::NewGuid().ToString('N')) +[void][IO.Directory]::CreateDirectory($stage, (Get-DirectoryAcl $null '')) +$madeApp = $false +$madeData = $false +$madeService = $false +$madeReleaseService = $false +$startRequested = $false +try { + [Net.ServicePointManager]::SecurityProtocol = [Net.ServicePointManager]::SecurityProtocol -bor [Net.SecurityProtocolType]::Tls12 + $metaPath = Join-Path $stage 'metadata.json' + Get-Download ('/agent/v1/bootstrap/current' + $query) $metaPath 131072 $false + $meta = [IO.File]::ReadAllText($metaPath) | ConvertFrom-Json + if ($meta.schema_version -ne 1 -or $meta.manifest.platform -cne $platform -or + $meta.manifest.artifacts.Count -ne 2 -or $meta.updater.sha256 -cnotmatch '^[0-9a-f]{64}$' -or + $meta.ca_pem.Length -gt 32768 -or $meta.ca_pem -notmatch '-----BEGIN CERTIFICATE-----') { throw 'Invalid bootstrap metadata.' } + $releaseId = Get-Id $meta.manifest.release_id + $tenant = Get-Id $meta.tenant_id + $gateway = [Uri](Get-Origin ([Uri]$meta.gateway_origin)) + $addresses = @([Net.Dns]::GetHostAddresses($gateway.DnsSafeHost) | Sort-Object { $_.AddressFamily -ne [Net.Sockets.AddressFamily]::InterNetwork }) + if (-not $addresses.Count) { throw 'Could not resolve the device gateway.' } + $endpoint = [Net.IPEndPoint]::new($addresses[0], $gateway.Port) + $appStage = Join-Path $stage 'application' + $dataStage = Join-Path $stage 'data' + $images = Join-Path $appStage ('releases\' + $releaseId) + $private = Get-DirectoryAcl $null '' + [void][IO.Directory]::CreateDirectory($appStage, $private) + [void][IO.Directory]::CreateDirectory($images) + [void][IO.Directory]::CreateDirectory($dataStage, $private) + $ring = Join-Path $dataStage 'release-keyring.json' + $envelope = Join-Path $images 'envelope.json' + Set-Text $ring ($meta.keyring | ConvertTo-Json -Depth 16 -Compress) + Set-Text $envelope ($meta.release_envelope | ConvertTo-Json -Depth 16 -Compress) + $updater = Join-Path $appStage 'rmm-updater-windows.exe' + Get-Download ('/agent/v1/bootstrap/updater' + $query) $updater $meta.updater.bytes $true + if ((Get-Hash $updater) -cne $meta.updater.sha256) { throw 'Bootstrap updater digest mismatch.' } + $roles = @('agent', 'helper') + for ($i = 0; $i -lt $roles.Count; $i++) { + $descriptor = $meta.manifest.artifacts[$i] + if ($descriptor.role -cne $roles[$i]) { throw 'Unexpected release role.' } + $id = Get-Id $descriptor.artifact_id + $file = Join-Path $images ('rmm-' + $roles[$i] + '-windows.exe') + Get-Download ("/agent/v1/bootstrap/releases/$releaseId/artifacts/$id" + $query) $file $descriptor.bytes $true + } + $agentPath = Join-Path $images 'rmm-agent-windows.exe' + $helperPath = Join-Path $images 'rmm-helper-windows.exe' + $canonical = & $updater --verify-bootstrap $ring $envelope $agentPath $helperPath + if ($LASTEXITCODE -ne 0 -or -not $canonical -or @($canonical).Count -ne 1) { throw 'Signed Windows release verification failed.' } + $verified = $canonical | ConvertFrom-Json + if ($verified.platform -cne $platform -or $verified.release_id -cne $releaseId) { throw 'Release identity mismatch.' } + Set-Text (Join-Path $images 'manifest.json') $canonical + $configPath = Join-Path $data 'config.json' + $tokenPath = Join-Path $state 'enrollment.token' + $ca = Join-Path $data 'server-ca.pem' + Set-Text (Join-Path $dataStage 'server-ca.pem') $meta.ca_pem + $config = [ordered]@{server_name=$gateway.DnsSafeHost; connect_address=$endpoint.ToString(); ca_file=$ca; state_directory=$state; enrollment_token_file=$tokenPath; transport='https'} + Set-Text (Join-Path $dataStage 'config.json') ($config | ConvertTo-Json -Compress) + $baseline = [ordered]@{schema_version=1; tenant_id=$tenant; release_id=$releaseId; release_sequence=$verified.release_sequence; manifest_sha256=(Get-Hash (Join-Path $images 'manifest.json'))} + Set-Text (Join-Path $dataStage 'installed-release.json') ($baseline | ConvertTo-Json -Compress) + [IO.Directory]::Move($appStage, $app) + $madeApp = $true + [IO.Directory]::Move($dataStage, $data) + $madeData = $true + $liveAgent = Join-Path $app ("releases\$releaseId\rmm-agent-windows.exe") + $binary = '"' + $liveAgent + '" --service --config "' + $configPath + '"' + New-Service -Name $serviceName -BinaryPathName $binary -StartupType Manual -Description 'Rust Discovery HTTPS pull agent' | Out-Null + $madeService = $true + $sc = Join-Path $env:SystemRoot 'System32\sc.exe' + & $sc config $serviceName start= auto obj= 'NT AUTHORITY\LocalService' | Out-Null + if ($LASTEXITCODE -ne 0) { throw 'SCM agent identity configuration failed.' } + & $sc sidtype $serviceName unrestricted | Out-Null + if ($LASTEXITCODE -ne 0) { throw 'SCM service SID configuration failed.' } + $sid = ([Security.Principal.NTAccount]::new('NT SERVICE', $serviceName)).Translate([Security.Principal.SecurityIdentifier]) + Set-Acl -LiteralPath $app -AclObject (Get-DirectoryAcl $sid 'ReadAndExecute') + Set-Acl -LiteralPath $data -AclObject (Get-DirectoryAcl $sid 'ReadAndExecute') + [void][IO.Directory]::CreateDirectory($state, (Get-DirectoryAcl $sid 'Modify')) + # Agent-side private-path checks authenticate the owner as well as the DACL. + foreach ($root in @($app, $data)) { + foreach ($item in @(Get-ChildItem -LiteralPath $root -Recurse -Force)) { + $acl = Get-Acl -LiteralPath $item.FullName + $acl.SetOwner($administrators) + Set-Acl -LiteralPath $item.FullName -AclObject $acl + } + } + Set-Text $tokenPath $token + $tokenAcl = Get-Acl -LiteralPath $tokenPath + $tokenAcl.SetOwner($administrators) + Set-Acl -LiteralPath $tokenPath -AclObject $tokenAcl + $updaterBinary = '"' + (Join-Path $app 'rmm-updater-windows.exe') + '" --release-service' + New-Service -Name $releaseService -BinaryPathName $updaterBinary -StartupType Automatic -Description 'Rust Discovery signed Windows release polling' | Out-Null + $madeReleaseService = $true + $startRequested = $true + Start-Service $serviceName + $until = [DateTime]::UtcNow.AddSeconds(120) + while (-not (Test-Path -LiteralPath $identity -PathType Leaf)) { + if ([DateTime]::UtcNow -ge $until -or (Get-Service $serviceName).Status -ne 'Running') { + throw 'Enrollment has not completed. Installed configuration and device key are retained.' + } + Start-Sleep -Seconds 2 + } + Start-Service $releaseService + Write-Output "Enrolled Rust Discovery agent $($verified.version) over HTTPS." +} catch { + if (-not $startRequested) { + if ($madeReleaseService) { & (Join-Path $env:SystemRoot 'System32\sc.exe') delete $releaseService | Out-Null } + if ($madeService) { & (Join-Path $env:SystemRoot 'System32\sc.exe') delete $serviceName | Out-Null } + if ($madeData) { Remove-Item -LiteralPath $data -Recurse -Force } + if ($madeApp) { Remove-Item -LiteralPath $app -Recurse -Force } + } + throw +} finally { + $token = $null + Remove-Item -LiteralPath $stage -Recurse -Force +} diff --git a/crates/server/src/bootstrap/install.sh b/crates/server/src/bootstrap/install.sh new file mode 100644 index 0000000..6e6d3ee --- /dev/null +++ b/crates/server/src/bootstrap/install.sh @@ -0,0 +1,7 @@ +#!/bin/sh +# Usage: sudo sh linux.sh https://bootstrap.example +set -eu +umask 077 +file=$(mktemp) +trap 'rm -f "$file"' EXIT +cat >"$file" <<'RMM_BOOTSTRAP_PYTHON' diff --git a/crates/server/src/bootstrap/lifecycle.py b/crates/server/src/bootstrap/lifecycle.py new file mode 100644 index 0000000..7d10b7a --- /dev/null +++ b/crates/server/src/bootstrap/lifecycle.py @@ -0,0 +1,400 @@ +"""Bootstrap a Linux systemd client and maintain its signed release pair.""" +import argparse +import datetime +import fcntl +import getpass +import hashlib +import json +import os +from pathlib import Path +import platform +import pwd +import re +import shutil +import socket +import sqlite3 +import ssl +import subprocess +import sys +import tempfile +import time +from urllib.parse import urlsplit +import urllib.request +import uuid + +ROOT = Path('/opt/rust-discovery-client') +STATE = Path('/var/lib/rmm-discovery') +SERVICE = 'rmm-discovery-agent.service' +TIMER = 'rmm-discovery-update.timer' +PLATFORM = 'x86_64-unknown-linux-gnu' +MAX_BINARY = 256 * 1024 * 1024 +UNIT_DIR = Path('/etc/systemd/system') + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def origin(value): + parsed = urlsplit(value) + require(parsed.scheme == 'https' and parsed.hostname and parsed.username is None + and parsed.password is None and not parsed.query and not parsed.fragment + and parsed.path in ('', '/'), 'HTTPS origin required') + return 'https://' + parsed.netloc + + +def canonical_id(value): + require(str(uuid.UUID(value)) == value, 'invalid object identifier') + return value + + +def save(path, value, mode=0o644): + data = json.dumps(value, separators=(',', ':')).encode() if not isinstance(value, bytes) else value + with tempfile.NamedTemporaryFile(dir=path.parent, delete=False) as tmp: + tmp.write(data) + os.fchmod(tmp.fileno(), mode) + tmp.flush() + os.fsync(tmp.fileno()) + os.replace(tmp.name, path) + fd = os.open(path.parent, os.O_DIRECTORY) + try: + os.fsync(fd) + finally: + os.close(fd) + + +def read(path): + return json.loads(path.read_bytes()) + + +class NoRedirect(urllib.request.HTTPRedirectHandler): + def redirect_request(self, *_): + raise ValueError('unexpected HTTP redirect') + + +def retrieve(base, route, target, *, context, token=None, size=None, expected=None): + request = urllib.request.Request(origin(base) + route) + if token: + request.add_header('Authorization', 'Enrollment ' + token) + client = urllib.request.build_opener(urllib.request.ProxyHandler({}), NoRedirect(), + urllib.request.HTTPSHandler(context=context)) + limit = 65536 if size is None else size + require(type(limit) is int and 0 < limit <= MAX_BINARY, 'download size outside profile') + digest = hashlib.sha256() + count = 0 + with client.open(request, timeout=30) as response: + require(response.status == 200, 'download rejected') + while True: + chunk = response.read(min(65536, limit + 1 - count)) + if not chunk: + break + count += len(chunk) + require(count <= limit, 'download larger than descriptor') + digest.update(chunk) + target.write(chunk) + if size is not None: + require(count == size and digest.hexdigest() == expected, 'download hash or size mismatch') + + +def as_device(action, *args, stdout=None): + return subprocess.run(['/usr/sbin/runuser', '-u', 'rmm-discovery', '--', sys.executable, '-I', + str(ROOT / 'lifecycle.py'), action, *map(str, args)], + stdout=stdout, check=True, timeout=240) + + +def device_get(route, size=None, digest=None): + config = read(ROOT / 'config.json') + version = canonical_id(read(STATE / 'certificates/current.json')['version']) + pair = STATE / 'certificates/versions' / version + ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT) + ctx.load_verify_locations(cafile=str(ROOT / 'gateway-ca.pem')) + ctx.load_cert_chain(str(pair / 'device.pem'), str(pair / 'device.key')) + retrieve(config['gateway'], route, sys.stdout.buffer, context=ctx, + size=int(size) if size is not None else None, expected=digest) + + +def device_idle(): + # The root worker holds the admission lock before consulting this journal. + with sqlite3.connect(f'file:{STATE}/journal.sqlite?mode=ro', uri=True) as conn: + busy, = conn.execute("SELECT EXISTS(SELECT 1 FROM job_attempts WHERE state IN ('requesting','running','verifying'))").fetchone() + print('busy' if busy else 'idle') + + +def remote(source, route, target, descriptor=None): + size = digest = None + if descriptor: + size, digest = descriptor['bytes'], descriptor['sha256'] + require(type(size) is int and 0 < size <= MAX_BINARY and re.fullmatch('[0-9a-f]{64}', digest), + 'invalid binary descriptor') + with target.open('xb') as output: + if source: + base, token = source + retrieve(base, route, output, context=ssl.create_default_context(), token=token, size=size, expected=digest) + else: + args = [size, digest] if descriptor else [] + as_device('fetch', route, *args, stdout=output) + output.flush() + os.fsync(output.fileno()) + + +def pair(folder, doc, source, updater): + manifest = doc['manifest'] + release_id = canonical_id(manifest['release_id']) + prefix = '/agent/v1/bootstrap/releases' if source else '/agent/v1/releases' + suffix = '?platform=' + PLATFORM if source else '' + save(folder / 'envelope.json', doc['release_envelope']) + for artifact, role in zip(manifest['artifacts'], ('agent', 'helper'), strict=True): + require(artifact['role'] == role, 'incorrect artifact role') + aid = canonical_id(artifact['artifact_id']) + remote(source, f'{prefix}/{release_id}/artifacts/{aid}{suffix}', folder / role, artifact) + (folder / role).chmod(0o755) + ring = updater.parent / 'keyring.json' + verified = subprocess.check_output([updater, '--verify-bootstrap', ring, folder / 'envelope.json', + folder / 'agent', folder / 'helper'], timeout=120) + require(json.loads(verified) == manifest, 'metadata differs from signed release') + save(folder / 'manifest.json', verified) + folder.chmod(0o755) + return manifest + + +def link(base, name): + target = base / 'current.next' + target.unlink(missing_ok=True) + target.symlink_to('releases/' + canonical_id(name)) + os.replace(target, base / 'current') + fd = os.open(base, os.O_DIRECTORY) + try: + os.fsync(fd) + finally: + os.close(fd) + + +def installed(): + return json.loads(as_device('fetch', '/agent/v1/releases/installed', stdout=subprocess.PIPE).stdout) + + +def healthy(version, baseline, duration=90): + until = time.monotonic() + duration + while time.monotonic() < until: + try: + record = installed() + contact = record.get('last_contact_at') + if contact: + recent = datetime.datetime.fromisoformat(contact.replace('Z', '+00:00')).timestamp() + if (time.time() - 65 < recent <= time.time() + 10 and record['agent_version'] == version + and record['connection_generation'] > baseline): + return True + except (subprocess.SubprocessError, ValueError, OSError): + pass + time.sleep(2) + return False + + +def service(*args): + subprocess.run(['systemctl', *args], check=True, timeout=60) + + +def units(): + program = '/usr/bin/python3 -I ' + str(ROOT / 'lifecycle.py') + return { + SERVICE: f"""[Unit] +Description=Rust Discovery Linux agent +Wants=network-online.target +After=network-online.target time-sync.target +[Service] +User=rmm-discovery +Group=rmm-discovery +StateDirectory=rmm-discovery +StateDirectoryMode=0700 +UMask=0077 +ExecStart={program} run-agent +Restart=on-failure +RestartSec=5 +NoNewPrivileges=true +PrivateTmp=true +ProtectSystem=strict +ProtectHome=true +[Install] +WantedBy=multi-user.target +""", + 'rmm-discovery-update.service': f"""[Unit] +Description=Check and activate a signed Rust Discovery agent release +After=network-online.target +[Service] +Type=oneshot +ExecStart={program} update +UMask=0077 +""", + TIMER: """[Unit] +Description=Periodic Rust Discovery agent release check +[Timer] +OnBootSec=1min +OnUnitActiveSec=5min +RandomizedDelaySec=20 +[Install] +WantedBy=timers.target +""", + } + + +def enable(): + for name, data in units().items(): + path = UNIT_DIR / name + if path.exists(): + require(path.read_bytes() == data.encode(), 'service file conflict: ' + name) + else: + save(path, data.encode()) + service('daemon-reload') + service('enable', '--now', SERVICE, TIMER) + + +def install(base, token_file): + require(platform.machine() == 'x86_64', 'Linux x86-64 required') + base = origin(base) + if ROOT.exists(): + config = read(ROOT / 'config.json') + require(config['bootstrap'] == base and (ROOT / 'current/manifest.json').is_file(), + 'existing installation differs') + enable() + return + require(not STATE.exists() and not any((UNIT_DIR/name).exists() for name in units()), + 'existing device installation requires migration') + token = Path(token_file).read_text().strip() if token_file else getpass.getpass('Einmalcode: ').strip() + require(re.fullmatch('[0-9a-f]{64}', token), 'invalid enrollment token') + try: + account = pwd.getpwnam('rmm-discovery') + except KeyError: + subprocess.run(['useradd', '--system', '--user-group', '--no-create-home', '--shell', '/usr/sbin/nologin', + 'rmm-discovery'], check=True) + account = pwd.getpwnam('rmm-discovery') + require(account.pw_uid != 0 and account.pw_gid != 0, 'dedicated unprivileged service account required') + with tempfile.TemporaryDirectory(prefix='.rmm-', dir=ROOT.parent) as work: + staging = Path(work) / 'installation' + staging.mkdir() + remote((base, token), '/agent/v1/bootstrap/current?platform=' + PLATFORM, staging / 'bootstrap.json') + doc = read(staging / 'bootstrap.json') + require(doc['schema_version'] == 1, 'unknown bootstrap profile') + save(staging / 'keyring.json', doc['keyring']) + save(staging / 'gateway-ca.pem', doc['ca_pem'].encode()) + save(staging / 'config.json', {'bootstrap': base, 'gateway': origin(doc['gateway_origin']), + 'tenant': canonical_id(doc['tenant_id'])}) + updater = staging / 'updater' + remote((base, token), '/agent/v1/bootstrap/updater?platform=' + PLATFORM, updater, doc['updater']) + updater.chmod(0o755) + releases = staging / 'releases' + releases.mkdir() + folder = releases / canonical_id(doc['manifest']['release_id']) + folder.mkdir() + manifest = pair(folder, doc, (base, token), updater) + link(staging, manifest['release_id']) + save(staging / 'lifecycle.py', Path(__file__).read_bytes()) + save(staging / 'release.lock', b'') + save(staging / 'first.token', token.encode(), 0o440) + os.chown(staging / 'first.token', 0, account.pw_gid) + staging.chmod(0o755) + releases.chmod(0o755) + os.rename(staging, ROOT) + enable() + require(healthy(manifest['version'], 0), 'installed, awaiting authenticated device heartbeat') + (ROOT / 'first.token').unlink(missing_ok=True) + + +def run_agent(): + conf = read(ROOT / 'config.json') + url = urlsplit(conf['gateway']) + # Resolve again on each service start. TLS identity always uses the configured DNS name. + address = socket.getaddrinfo(url.hostname, url.port or 443, type=socket.SOCK_STREAM)[0][4][0] + if ':' in address: + address = '[' + address + ']' + os.environ.update(RMM_AGENT_STATE=str(STATE), RMM_CA_FILE=str(ROOT / 'gateway-ca.pem'), + RMM_CONNECT_ADDR=f'{address}:{url.port or 443}', RMM_SERVER_NAME=url.hostname, + RMM_TRANSPORT='https', RMM_ENROLLMENT_TOKEN_FILE=str(ROOT / 'first.token'), + RMM_ENROLLMENT_TENANT=conf['tenant'], RMM_JOB_SIGNING_KEY_BOOTSTRAP='1', + RMM_RELEASE_LOCK=str(ROOT / 'release.lock'), + RMM_INSTALLED_RELEASE_VERSION=read(ROOT / 'current/manifest.json')['version']) + exe = str(ROOT / 'current/agent') + os.execv(exe, [exe]) + + +def revert(intent): + # Persist failed sequence before restoring. An interruption re-enters recovery. + save(ROOT / 'failed.json', {'release_sequence': intent['sequence'], 'reason': 'activation_unconfirmed'}) + link(ROOT, intent['previous']) + service('restart', SERVICE) + (ROOT / 'pending.json').unlink() + raise RuntimeError('release activation unconfirmed; predecessor selected') + + +def update(): + with (ROOT / 'release.lock').open('rb') as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + pending = ROOT / 'pending.json' + if pending.exists(): + revert(read(pending)) + active = read(ROOT / 'current/manifest.json') + with tempfile.TemporaryDirectory(prefix='.incoming-', dir=ROOT / 'releases') as work: + staging = Path(work) / 'generation' + staging.mkdir() + remote(None, '/agent/v1/releases/current?platform=' + PLATFORM, staging / 'current.json') + response = read(staging / 'current.json') + if response['status'] == 'not_configured': + return + require(response['status'] == 'available', 'unexpected release status') + doc = response['release'] + if doc['release_envelope'] == read(ROOT / 'current/envelope.json'): + return + floor = active['release_sequence'] + if (ROOT / 'failed.json').exists(): + floor = max(floor, read(ROOT / 'failed.json')['release_sequence']) + manifest = pair(staging, doc, None, ROOT / 'updater') + require(manifest['release_sequence'] > floor, 'release sequence previously activated or rejected') + # Guard only this device while it is being changed. A fresh offer may + # remain queued while the worker temporarily owns the admission lock. + if as_device('idle', stdout=subprocess.PIPE).stdout.strip() != b'idle': + return + previous_health = installed() + release = canonical_id(manifest['release_id']) + dest = ROOT / 'releases' / release + if dest.exists(): + # A previous check may have staged this version before a crash. + require(read(dest / 'envelope.json') == doc['release_envelope'], 'release id conflict') + subprocess.run([ROOT / 'updater', '--verify-bootstrap', ROOT / 'keyring.json', dest / 'envelope.json', + dest / 'agent', dest / 'helper'], stdout=subprocess.DEVNULL, check=True) + else: + (staging / 'current.json').unlink() + os.rename(staging, dest) + intent = {'previous': active['release_id'], 'sequence': manifest['release_sequence']} + save(pending, intent) + link(ROOT, release) + service('restart', SERVICE) + if not healthy(manifest['version'], previous_health['connection_generation']): + revert(intent) + pending.unlink() + (ROOT / 'first.token').unlink(missing_ok=True) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('action', choices=('install', 'update', 'run-agent', 'fetch', 'idle')) + parser.add_argument('values', nargs='*') + parser.add_argument('--token-file') + args = parser.parse_args() + if args.action in ('install', 'update'): + require(os.geteuid() == 0, 'administrative installation required') + os.umask(0o022) + if args.action == 'install': + require(len(args.values) == 1, 'one HTTPS bootstrap origin required') + install(args.values[0], args.token_file) + elif args.action == 'update': + update() + elif args.action == 'run-agent': + run_agent() + elif args.action == 'fetch': + device_get(*args.values) + else: + device_idle() + + +if __name__ == '__main__': + main() diff --git a/crates/server/src/bootstrap/mod.rs b/crates/server/src/bootstrap/mod.rs new file mode 100644 index 0000000..595afbb --- /dev/null +++ b/crates/server/src/bootstrap/mod.rs @@ -0,0 +1,88 @@ +//! Fresh-device bootstrap. Public scripts contain no credentials. Downloads use +//! the tenant's one-time enrollment token until the final enrollment consumes it. +use super::*; + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct Config { + gateway_origin: String, + updater_sha256: String, + updater_bytes: u64, +} +fn config(platform: Platform) -> Result { + let slot = match platform { + Platform::LinuxX64 => "RMM_AGENT_BOOTSTRAP_LINUX_FILE", + Platform::WindowsX64 => "RMM_AGENT_BOOTSTRAP_WINDOWS_FILE", + Platform::WindowsGnuX64 => "RMM_AGENT_BOOTSTRAP_WINDOWS_GNU_FILE", + }; + let path = std::env::var(slot).map_err(|_| fail("BOOTSTRAP_NOT_CONFIGURED"))?; + let config: Config = serde_json::from_slice(&protected_file(FsPath::new(&path), 8192)?)?; + let url = url::Url::parse(&config.gateway_origin).map_err(|_| invalid())?; + if url.scheme() != "https" || url.domain().is_none() || !url.username().is_empty() + || url.password().is_some() || url.query().is_some() || url.fragment().is_some() + || url.path() != "/" || !rmm_domain::agent_update::digest(&config.updater_sha256) + || !(1..=rmm_updater::MAX_ARTIFACT_BYTES).contains(&config.updater_bytes) { + return Err(fail("BOOTSTRAP_CONFIGURATION_INVALID")); + } + Ok(config) +} +fn private_json(body: Value) -> Response { + ([("cache-control", "private, no-store")], Json(body)).into_response() +} +pub(super) async fn issue(State(s): State, headers: HeaderMap, Path(t): Path) -> Result { + let p = s.auth.principal(&s, &headers, true).await.map_err(|status| Error(status, crate::auth::error_code(status)))?; + crate::jobs::scope(&p, t, true)?; + if p.session_hash.is_none() { return Err(Error(StatusCode::FORBIDDEN, "INTERACTIVE_AUTH_REQUIRED")); } + let mut tx = rmm_persistence::tenant_tx(&s.pool, t).await?; + crate::permissions::require_principal(&mut tx, &p, "devices:enroll").await?; + let bootstrap_origin = std::env::var("RMM_BOOTSTRAP_ORIGIN").ok().map(|raw| { + let url = url::Url::parse(&raw).map_err(|_| invalid())?; + if url.scheme() != "https" || url.domain().is_none() || !url.username().is_empty() || url.password().is_some() + || url.path() != "/" || url.query().is_some() || url.fragment().is_some() { return Err(invalid()); } + Ok(url.origin().ascii_serialization()) + }).transpose()?; + let mut bytes = [0; 32]; + openssl::rand::rand_bytes(&mut bytes).map_err(|_| fail("TOKEN_GENERATION_FAILED"))?; + let token = hex::encode(bytes); + let expires: chrono::DateTime = sqlx::query_scalar("SELECT issue_enrollment_token($1)") + .bind(hash(token.as_bytes())).fetch_one(&mut *tx).await?; + sqlx::query("INSERT INTO audit_events VALUES($1,$2,$3,'enrollment_token_issued',$4,now())") + .bind(t).bind(Uuid::new_v4()).bind(p.name).bind(json!({"expires_at":expires})).execute(&mut *tx).await?; + tx.commit().await?; + Ok(private_json(json!({"token":token,"expires_at":expires,"bootstrap_origin":bootstrap_origin}))) +} +async fn token_tenant(s: &crate::State, h: &HeaderMap) -> Result { + let denied = || Error(StatusCode::UNAUTHORIZED, "ENROLLMENT_TOKEN_REQUIRED"); + let token = h.get("authorization").and_then(|v| v.to_str().ok()).and_then(|v| v.strip_prefix("Enrollment ")).filter(|v| rmm_domain::agent_update::digest(v)).ok_or_else(denied)?; + let t: Option = sqlx::query_scalar("SELECT bootstrap_enrollment_tenant($1)") + .bind(hash(token.as_bytes())).fetch_one(&s.pool).await?; + t.ok_or_else(denied) +} +pub(super) async fn current(State(s): State, headers: HeaderMap, Query(q): Query) -> Result { + let t = token_tenant(&s, &headers).await?; + let c = config(q.platform)?; + let mut tx = rmm_persistence::tenant_tx(&s.pool, t).await?; + let release: Uuid = sqlx::query_scalar("SELECT release_id FROM agent_update_releases WHERE platform=$1 ORDER BY release_sequence DESC LIMIT 1") + .bind(platform_name(q.platform)).fetch_optional(&mut *tx).await?.ok_or_else(missing)?; + let (envelope, manifest) = checked_release(&mut tx, release).await?; + tx.commit().await?; + let ring: Value = serde_json::from_slice(&keyring_bytes(q.platform)?)?; + let ca = s.signer.as_ref().ok_or_else(missing)?.ca.to_pem().map_err(|_| invalid())?; + Ok(private_json(json!({"schema_version":1,"tenant_id":t,"release_envelope":envelope,"manifest":manifest, + "gateway_origin":c.gateway_origin,"ca_pem":String::from_utf8(ca).map_err(|_| invalid())?, + "keyring":ring,"updater":{"sha256":c.updater_sha256,"bytes":c.updater_bytes}}))) +} +pub(super) async fn artifact(State(s): State, headers: HeaderMap, Path((id, artifact)): Path<(Uuid,Uuid)>, Query(q): Query) -> Result { + let tenant = token_tenant(&s, &headers).await?; + let mut tx = rmm_persistence::tenant_tx(&s.pool, tenant).await?; + let (_, manifest) = checked_release(&mut tx, id).await?; + if manifest.platform != q.platform { return Err(missing()); } + let d = manifest.artifacts.into_iter().find(|v| v.artifact_id == artifact).ok_or_else(missing)?; + tx.commit().await?; + verified_binary(tenant, d.sha256, d.bytes).await +} +pub(super) async fn updater(State(s): State, headers: HeaderMap, Query(q): Query) -> Result { + let tenant = token_tenant(&s, &headers).await?; + let c = config(q.platform)?; + verified_binary(tenant, c.updater_sha256, c.updater_bytes).await +} diff --git a/crates/server/src/jobs.rs b/crates/server/src/jobs.rs index 88730ab..764d0ba 100644 --- a/crates/server/src/jobs.rs +++ b/crates/server/src/jobs.rs @@ -1091,7 +1091,11 @@ pub async fn operation( "needs_attention" } else if c("succeeded") == n { "succeeded" - } else if c("succeeded") + c("failed") + c("cancelled") + c("expired") + c("closed_unknown") + } else if c("succeeded") + + c("failed") + + c("cancelled") + + c("expired") + + c("closed_unknown") == n { if c("succeeded") > 0 { @@ -1242,12 +1246,13 @@ pub async fn close_unknown( } let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant).await?; crate::permissions::require_principal(&mut tx, p, "plans:approve").await?; - let row = - sqlx::query("SELECT attempt_id,state,revision,result FROM jobs WHERE job_id=$1 FOR UPDATE") - .bind(id) - .fetch_optional(&mut *tx) - .await? - .ok_or_else(missing)?; + let row = sqlx::query( + "SELECT attempt_id,state,revision,result FROM jobs WHERE job_id=$1 FOR UPDATE", + ) + .bind(id) + .fetch_optional(&mut *tx) + .await? + .ok_or_else(missing)?; if row.get::("attempt_id") != input.attempt_id || row.get::("revision") != input.revision { @@ -1287,11 +1292,9 @@ pub async fn close_unknown( .bind(tenant) .bind(Uuid::new_v4()) .bind(&p.name) - .bind( - json!({"job_id":id,"attempt_id":input.attempt_id,"grant_id":grant,"closure_id":closure, + .bind(json!({"job_id":id,"attempt_id":input.attempt_id,"grant_id":grant,"closure_id":closure, "original_revision":input.revision,"reason":input.reason,"session_hash":session, - "approval_origin":p.approval_origin(),"testsimulation":p.testsimulation}), - ) + "approval_origin":p.approval_origin(),"testsimulation":p.testsimulation})) .execute(&mut *tx) .await?; tx.commit().await?; diff --git a/crates/server/src/update_artifact_store.rs b/crates/server/src/update_artifact_store.rs index 4c69a54..9f33aa1 100644 --- a/crates/server/src/update_artifact_store.rs +++ b/crates/server/src/update_artifact_store.rs @@ -98,7 +98,7 @@ impl UpdateArtifacts { hasher: Sha256::new(), }) } - fn verified_file(&self, tenant: Uuid, hash: &str, bytes: u64) -> Result { + pub(crate) fn verified_file(&self, tenant: Uuid, hash: &str, bytes: u64) -> Result { ensure!(descriptor(hash, bytes), "bounded update object descriptor"); let parent = self.parent(tenant)?; let mut file = OpenOptions::new() diff --git a/crates/server/src/windows_echo_probe.rs b/crates/server/src/windows_echo_probe.rs index cd6b206..be3a6bd 100644 --- a/crates/server/src/windows_echo_probe.rs +++ b/crates/server/src/windows_echo_probe.rs @@ -516,5 +516,5 @@ pub(super) async fn test_fixed_echo( tx.rollback().await.unwrap(); } } - crate::windows_echo_completion::test_completed_echo(admin, s, &p, &w).await; + crate::windows_echo_completion::test_completed_echo(admin,s,&p,&w).await; } diff --git a/crates/updater-worker/src/main.rs b/crates/updater-worker/src/main.rs index 6ac9bdc..9ced5b1 100644 --- a/crates/updater-worker/src/main.rs +++ b/crates/updater-worker/src/main.rs @@ -43,6 +43,11 @@ mod linux { } pub fn run() -> Result<()> { let args: Vec<_> = std::env::args_os().skip(1).collect(); + if args.first().is_some_and(|arg| arg == "--verify-bootstrap") { + let release = rmm_updater::verify_bootstrap_files(rmm_updater::Platform::LinuxX64, &args[1..])?; + println!("{}", serde_json::to_string(release.manifest())?); + return Ok(()); + } if args == [OsStr::new("--help")] { println!( "rmm-agent-updater --serve\nFixed protected local binding/policy and authenticated Fullhelper IPC only. No automatic activation or startup replay. A failed/ambiguous pass stops closed; operator recovery must inspect the original handoff." diff --git a/crates/updater/Cargo.toml b/crates/updater/Cargo.toml index ed2c5b9..df653c4 100644 --- a/crates/updater/Cargo.toml +++ b/crates/updater/Cargo.toml @@ -12,3 +12,4 @@ serde.workspace = true serde_json.workspace = true sha2.workspace = true uuid.workspace = true +rmm-domain = { path = "../domain" } diff --git a/crates/updater/src/bootstrap.rs b/crates/updater/src/bootstrap.rs new file mode 100644 index 0000000..71b523e --- /dev/null +++ b/crates/updater/src/bootstrap.rs @@ -0,0 +1,45 @@ +//! Local verification for the separately distributed stable bootstrap updater. +use crate::{ArtifactRole, Platform, SignedRelease, TrustedContext, TrustedUpdateKey, UpdateKeyring, VerifiedRelease}; +use anyhow::{Context, Result, ensure}; +use rmm_domain::agent_update::{Platform as WirePlatform, ReleaseEnvelope, UpdateKeyringFile}; +use std::{ffi::OsString, fs::File, io::Read, time::{SystemTime, UNIX_EPOCH}}; + +fn bounded(path: &OsString, limit: u64) -> Result> { + let mut bytes = Vec::new(); + File::open(path)?.take(limit + 1).read_to_end(&mut bytes)?; + ensure!(bytes.len() as u64 <= limit, "bootstrap metadata too large"); + Ok(bytes) +} + +/// Arguments are four local files in order: pinned keyring, envelope, agent, +/// helper. The caller owns the protected staging directory and activation floor. +pub fn verify_bootstrap_files(platform: Platform, args: &[OsString]) -> Result { + let [keyring, envelope, agent, helper] = args else { + anyhow::bail!("four local paths required: KEYRING ENVELOPE AGENT HELPER"); + }; + let config: UpdateKeyringFile = serde_json::from_slice(&bounded(keyring, 16384)?)?; + ensure!(config.validate(), "invalid bootstrap keyring"); + let keys = config.keys.into_iter().map(|key| { + let platform = match key.platform { + WirePlatform::LinuxX64 => Platform::LinuxX64, + WirePlatform::WindowsX64 => Platform::WindowsX64, + WirePlatform::WindowsGnuX64 => Platform::WindowsGnuX64, + }; + let raw = hex::decode(key.public_key_hex)?.try_into().ok().context("Ed25519 public key length")?; + TrustedUpdateKey::new(raw, platform, key.first_sequence, key.last_sequence, key.revoked) + }).collect::>>()?; + let ring = UpdateKeyring::new(config.generation, keys)?; + let envelope: ReleaseEnvelope = serde_json::from_slice(&bounded(envelope, 32768)?)?; + let decoded = envelope.decode().map_err(|_| anyhow::anyhow!("invalid release envelope"))?; + let context = TrustedContext { + platform, now_utc_seconds: SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs(), + keyring_generation: config.generation, protocol_major: 1, state_schema: 1, + updater_version: 1, minimum_release_sequence: 0, active_release: None, + }; + let release = crate::verify_release(SignedRelease {schema_version: envelope.schema_version, + key_id: &envelope.key_id, payload_bytes: &decoded.payload_bytes, + signature: &decoded.signature}, &ring, &context)?; + release.verify_artifact(ArtifactRole::Agent, File::open(agent)?)?; + release.verify_artifact(ArtifactRole::Helper, File::open(helper)?)?; + Ok(release) +} diff --git a/crates/updater/src/lib.rs b/crates/updater/src/lib.rs index 385637f..50e4150 100644 --- a/crates/updater/src/lib.rs +++ b/crates/updater/src/lib.rs @@ -3,8 +3,11 @@ //! //! See docs/agent-updater-proposal.md for the separate, unfinished integration. +mod bootstrap; mod manifest; +pub use bootstrap::verify_bootstrap_files; + pub use manifest::{ ActiveRelease, ArtifactDescriptor, ArtifactRole, MAX_ARTIFACT_BYTES, MAX_MANIFEST_BYTES, Platform, RELEASE_SIGNATURE_DOMAIN, ReleaseManifest, ReleaseRelation, SignedRelease, diff --git a/crates/updater/src/manifest.rs b/crates/updater/src/manifest.rs index df5ba57..c40be14 100644 --- a/crates/updater/src/manifest.rs +++ b/crates/updater/src/manifest.rs @@ -18,6 +18,8 @@ pub enum Platform { LinuxX64, #[serde(rename = "x86_64-pc-windows-msvc")] WindowsX64, + #[serde(rename = "x86_64-pc-windows-gnu")] + WindowsGnuX64, } #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)] diff --git a/deploy/server-bootstrap-ingress.conf b/deploy/server-bootstrap-ingress.conf new file mode 100644 index 0000000..f3379e9 --- /dev/null +++ b/deploy/server-bootstrap-ingress.conf @@ -0,0 +1,40 @@ +worker_processes 1; +pid /run/rmm-install-ingress/nginx.pid; +error_log stderr warn; + +events { worker_connections 128; } + +http { + access_log off; + client_body_temp_path /run/rmm-install-ingress/client; + proxy_temp_path /run/rmm-install-ingress/proxy; + fastcgi_temp_path /run/rmm-install-ingress/fastcgi; + uwsgi_temp_path /run/rmm-install-ingress/uwsgi; + scgi_temp_path /run/rmm-install-ingress/scgi; + client_max_body_size 1k; + server_tokens off; + keepalive_timeout 10; + server { + listen 0.0.0.0:8443 ssl; + listen [::]:8443 ssl; + server_name discovery.ease-technologies.de; + ssl_protocols TLSv1.2 TLSv1.3; + ssl_certificate /run/credentials/rmm-install-ingress.service/chain.pem; + ssl_certificate_key /run/credentials/rmm-install-ingress.service/key.pem; + proxy_ssl_trusted_certificate /run/credentials/rmm-install-ingress.service/gateway-ca.pem; + proxy_ssl_name discovery.ease-technologies.de; + proxy_ssl_server_name on; + proxy_ssl_verify on; + proxy_buffering off; + proxy_pass_request_body off; + proxy_pass_request_headers off; + proxy_set_header Host discovery.ease-technologies.de; + proxy_set_header Content-Length ""; + proxy_set_header Authorization $http_authorization; + location ~ "^/(install/(linux\.sh|windows\.ps1)|agent/v1/bootstrap/(current|updater|releases/[0-9a-f-]{36}/artifacts/[0-9a-f-]{36}))$" { + limit_except GET { deny all; } + proxy_pass https://127.0.0.1:18444$uri$is_args$args; + } + location / { return 404; } + } +} diff --git a/deploy/server-bootstrap-ingress.service b/deploy/server-bootstrap-ingress.service new file mode 100644 index 0000000..d1fa50d --- /dev/null +++ b/deploy/server-bootstrap-ingress.service @@ -0,0 +1,22 @@ +[Unit] +Description=Public HTTPS installer and tenant bootstrap downloads +After=network-online.target docker.service + +[Service] +DynamicUser=true +RuntimeDirectory=rmm-install-ingress +LoadCredential=chain.pem:/opt/rmm-bootstrap-download/chain.pem +LoadCredential=key.pem:/opt/rmm-bootstrap-download/domain.key +LoadCredential=gateway-ca.pem:/opt/rust-discovery/devstate/pki/ca.pem +ExecStart=/usr/sbin/nginx -c /etc/rmm-install-ingress.conf -g "daemon off;" +Restart=on-failure +NoNewPrivileges=true +ProtectSystem=strict +ProtectHome=true +PrivateTmp=true +PrivateDevices=true +CapabilityBoundingSet= +UMask=0077 + +[Install] +WantedBy=multi-user.target diff --git a/deploy/server.releases.compose.yaml b/deploy/server.releases.compose.yaml new file mode 100644 index 0000000..cc24f96 --- /dev/null +++ b/deploy/server.releases.compose.yaml @@ -0,0 +1,22 @@ +x-release-environment: &release-environment + RMM_AGENT_UPDATE_ARTIFACT_DIR: /release-objects + RMM_AGENT_UPDATE_LINUX_KEYRING_FILE: /release-config/linux-keyring.json + RMM_AGENT_UPDATE_WINDOWS_KEYRING_FILE: /release-config/windows-keyring.json + RMM_AGENT_BOOTSTRAP_LINUX_FILE: /release-config/linux-bootstrap.json + RMM_AGENT_BOOTSTRAP_WINDOWS_FILE: /release-config/windows-bootstrap.json + RMM_AGENT_UPDATE_WINDOWS_GNU_KEYRING_FILE: /release-config/windows-gnu-keyring.json + RMM_AGENT_BOOTSTRAP_WINDOWS_GNU_FILE: /release-config/windows-gnu-bootstrap.json + +services: + api: + environment: + <<: *release-environment + RMM_BOOTSTRAP_ORIGIN: ${RMM_BOOTSTRAP_ORIGIN:-https://discovery.ease-technologies.de:8443} + volumes: + - ../devstate/mvp-releases/config:/release-config:ro + - ../devstate/mvp-releases/objects:/release-objects:rw + gateway: + environment: *release-environment + volumes: + - ../devstate/mvp-releases/config:/release-config:ro + - ../devstate/mvp-releases/objects:/release-objects:ro diff --git a/migrations/0024_enrollment_bootstrap.sql b/migrations/0024_enrollment_bootstrap.sql new file mode 100644 index 0000000..cfaf01b --- /dev/null +++ b/migrations/0024_enrollment_bootstrap.sql @@ -0,0 +1,22 @@ +-- Pre-enrollment downloads and final enrollment share one short-lived credential. +-- Only the final enrollment consumes it. Table access stays with the DB owner. +CREATE FUNCTION bootstrap_enrollment_tenant(digest text) RETURNS uuid +LANGUAGE sql STABLE SECURITY DEFINER SET search_path = pg_catalog AS $$ + SELECT tenant_id FROM public.enrollment_tokens + WHERE token_hash = digest AND consumed_at IS NULL AND expires_at > now(); +$$; +CREATE FUNCTION issue_enrollment_token(digest text) RETURNS timestamptz +LANGUAGE sql SECURITY DEFINER SET search_path = pg_catalog AS $$ + INSERT INTO public.enrollment_tokens (token_hash,tenant_id,expires_at) + SELECT digest, current_setting('app.tenant_id')::uuid, now() + interval '15 minutes' + WHERE digest ~ '^[0-9a-f]{64}$' RETURNING expires_at; +$$; +REVOKE ALL ON FUNCTION bootstrap_enrollment_tenant(text), issue_enrollment_token(text) FROM PUBLIC; +GRANT EXECUTE ON FUNCTION bootstrap_enrollment_tenant(text), issue_enrollment_token(text) TO rmm_app; +UPDATE memberships SET permissions = array_append(permissions,'devices:enroll') +WHERE 'devices:revoke' = ANY(permissions) AND NOT ('devices:enroll' = ANY(permissions)); +ALTER TABLE agent_installations ADD COLUMN reported_agent_version text; +GRANT UPDATE(reported_agent_version) ON agent_installations TO rmm_app; +ALTER TABLE agent_update_releases DROP CONSTRAINT agent_update_releases_platform_check; +ALTER TABLE agent_update_releases ADD CHECK (platform IN + ('x86_64-unknown-linux-gnu','x86_64-pc-windows-msvc','x86_64-pc-windows-gnu')); diff --git a/tools/agent_release.py b/tools/agent_release.py new file mode 100755 index 0000000..76f8635 --- /dev/null +++ b/tools/agent_release.py @@ -0,0 +1,257 @@ +#!/usr/bin/env python3 +"""Prepare an Ed25519 agent release on the signing host and publish through the catalog API.""" +import argparse +import base64 +import datetime +import getpass +import hashlib +import http.client +from http.cookies import SimpleCookie +import json +import os +from pathlib import Path +import re +import shutil +import ssl +import subprocess +import tempfile +import time +from urllib.parse import urlencode, urlsplit +import uuid + +LINUX = 'x86_64-unknown-linux-gnu' +WINDOWS = 'x86_64-pc-windows-msvc' +FILES = {LINUX: ('rmm-agent', 'rmm-privileged-helper', 'rmm-agent-updater'), + WINDOWS: ('rmm-agent-windows.exe', 'rmm-helper-windows.exe', 'rmm-updater-windows.exe')} +WINDOWS_GNU = 'x86_64-pc-windows-gnu' +FILES[WINDOWS_GNU] = FILES[WINDOWS] +LIMIT = 256 * 1024 * 1024 +PREFIX = b'rmm.agent-release.v1\0' + + +def check(test, message): + if not test: + raise ValueError(message) + + +def encoded(value): + return json.dumps(value, separators=(',', ':'), ensure_ascii=False).encode() + + +def b64(data): + return base64.urlsafe_b64encode(data).rstrip(b'=').decode() + + +def fingerprint(path): + digest = hashlib.sha256() + size = path.stat().st_size + check(path.is_file() and 0 < size <= LIMIT, 'invalid release binary size') + with path.open('rb') as f: + for block in iter(lambda: f.read(1024 * 1024), b''): + digest.update(block) + return digest.hexdigest(), size + + +def binaries(folder, receipt): + record = json.loads(receipt.read_text(encoding='utf-8-sig')) + if 'target' in record and 'sha256' in record: + target, hashes = record['target'], record['sha256'] + else: + check(record.get('completed') is True and record['stage'] == 'built_not_deployed', 'completed MSVC receipt required') + target = WINDOWS + entries = record['artifacts'] + check(all(entries[name[:-4]]['build_target'] == target for name in FILES[target]), 'incorrect build target') + hashes = {name: entries[name[:-4]]['sha256'] for name in FILES[target]} + check(target in FILES, 'unknown release target') + result = [] + for name in FILES[target]: + path = folder / name + digest, size = fingerprint(path) + check(digest == hashes[name], 'file differs from build receipt: ' + name) + result.append({'artifact_id': str(uuid.uuid5(uuid.NAMESPACE_OID, target + '/' + name + '/' + digest)), + 'sha256': digest, 'bytes': size}) + return target, result + + +def openssl(*args): + return subprocess.check_output(['openssl', *map(str, args)], stderr=subprocess.DEVNULL, timeout=20) + + +def save_once(path, raw, uid=None): + if path.exists(): + check(path.read_bytes() == raw, 'existing configuration differs: ' + path.name) + return + with tempfile.NamedTemporaryFile(dir=path.parent, delete=False) as f: + try: + f.write(raw) + os.fchmod(f.fileno(), 0o600) + if uid is not None: + os.fchown(f.fileno(), uid, uid) + f.flush() + os.fsync(f.fileno()) + os.link(f.name, path) + finally: + os.unlink(f.name) + + +def provision_folder(path, uid=None): + path.mkdir(mode=0o700, parents=True, exist_ok=True) + check(path.is_dir() and not path.is_symlink(), 'release state directory required') + if uid is not None and path.stat().st_uid != uid: + os.chown(path, uid, uid) + os.chmod(path, 0o700) + + +def https(value): + url = urlsplit(value) + check(url.scheme == 'https' and url.hostname and not url.username and not url.password + and url.path in ('', '/') and not url.query and not url.fragment, 'HTTPS origin required') + return url + + +def prepare(args): + https(args.gateway) + check(0 < args.sequence < 2**63 and re.fullmatch('[A-Za-z0-9.+_-]{1,64}', args.version), 'invalid release version/sequence') + check(0 < args.days <= 3650, 'invalid validity in days') + platform, blobs = binaries(args.artifacts, args.build_receipt) + label = {LINUX:'linux', WINDOWS:'windows', WINDOWS_GNU:'windows-gnu'}[platform] + provision_folder(args.state) + config, private = args.state / 'config', args.state / 'private' + provision_folder(config, args.service_uid) + provision_folder(args.state / 'objects', args.service_uid) + provision_folder(private) + key = private / (label + '.pem') + if not key.exists(): + save_once(key, openssl('genpkey', '-algorithm', 'ED25519')) + check(not key.is_symlink() and key.stat().st_mode & 0o077 == 0, 'private release key permissions') + public = openssl('pkey', '-in', key, '-pubout', '-outform', 'DER') + check(len(public) == 44 and public[:12] == bytes.fromhex('302a300506032b6570032100'), 'Ed25519 key required') + pub = public[12:] + ring = {'schema_version': 1, 'generation': 1, 'keys': [{'public_key_hex': pub.hex(), 'platform': platform, + 'first_sequence': 1, 'last_sequence': 2**63-1, 'revoked': False}]} + save_once(config / (label + '-keyring.json'), encoded(ring), args.service_uid) + boot = {'gateway_origin': args.gateway.rstrip('/'), 'updater_sha256': blobs[2]['sha256'], 'updater_bytes': blobs[2]['bytes']} + boot_path = config / (label + '-bootstrap.json') + # The stable bootstrap worker is provisioned separately from replaceable code. + if not boot_path.exists(): + save_once(boot_path, encoded(boot), args.service_uid) + existing = json.loads(boot_path.read_bytes()) + check(existing['gateway_origin'] == boot['gateway_origin'], 'existing gateway origin differs') + prepared = args.state / 'prepared' / label / str(args.sequence) + provision_folder(prepared.parent) + if prepared.exists(): + check(json.loads((prepared / 'inputs.json').read_bytes()) == {'version': args.version, 'blobs': blobs}, 'sequence already bound') + print(prepared / 'envelope.json') + return + now = int(time.time()) + manifest = {'schema_version': 1, 'release_id': str(uuid.uuid4()), 'release_sequence': args.sequence, + 'version': args.version, 'platform': platform, 'published_at': now, 'expires_at': now + args.days * 86400, + 'protocol_major': 1, 'state_schema': 1, 'minimum_updater_version': 1, + 'artifacts': [dict(role=role, **blob) for role, blob in zip(('agent', 'helper'), blobs[:2])]} + raw = encoded(manifest) + with tempfile.TemporaryDirectory(dir=prepared.parent) as tmpdir: + work = Path(tmpdir) + msg = work / 'message' + msg.write_bytes(PREFIX + raw) + sig = openssl('pkeyutl', '-sign', '-rawin', '-inkey', key, '-in', msg) + (work / 'public.der').write_bytes(public) + (work / 'signature').write_bytes(sig) + openssl('pkeyutl', '-verify', '-rawin', '-pubin', '-keyform', 'DER', '-inkey', work / 'public.der', + '-in', msg, '-sigfile', work / 'signature') + output = work / 'release' + output.mkdir() + env = {'schema_version': 1, 'key_id': hashlib.sha256(pub).hexdigest(), 'payload_bytes': b64(raw), 'signature': b64(sig)} + save_once(output / 'envelope.json', encoded(env)) + save_once(output / 'inputs.json', encoded({'version': args.version, 'blobs': blobs})) + output.rename(prepared) + print(prepared / 'envelope.json') + + +class Publisher: + def __init__(self, address, ca): + self.origin = address.rstrip('/') + self.url = https(self.origin) + self.ctx = ssl.create_default_context(cafile=ca) + self.headers = {'Origin': self.origin} + + def request(self, method, route, body=None, headers=None): + conn = http.client.HTTPSConnection(self.url.hostname, self.url.port or 443, context=self.ctx, timeout=180) + try: + conn.request(method, route, body=body, headers={**self.headers, **(headers or {})}) + reply = conn.getresponse() + data = reply.read(1048577) + check(200 <= reply.status < 300, f'{method} {route.split("?")[0]} returned HTTP {reply.status}') + check(len(data) <= 1048576, 'response exceeds limit') + if reply.getheader('Set-Cookie'): + cookie = SimpleCookie(reply.getheader('Set-Cookie')) + token = cookie['__Host-rmm_session'].value + self.headers['Cookie'] = '__Host-rmm_session=' + token + return json.loads(data) if data else None + finally: + conn.close() + + +def publish(args): + platform, blobs = binaries(args.artifacts, args.build_receipt) + env = json.loads(args.envelope.read_bytes()) + manifest = json.loads(base64.urlsafe_b64decode(env['payload_bytes'] + '===')) + check(manifest['platform'] == platform and manifest['artifacts'] == [dict(role=role, **blob) + for role, blob in zip(('agent', 'helper'), blobs[:2])], 'input files differ from release envelope') + client = Publisher(args.origin, args.ca) + if args.dev_login_file: + path = args.dev_login_file + check(path.stat().st_mode & 0o077 == 0, 'dev login file requires private permissions') + credentials = json.loads(path.read_bytes()) + login = {k: credentials[k] for k in ('username','password')} + else: + login = {'username': args.dev_username, 'password': getpass.getpass('Development WebUI password: ')} + client.request('POST', '/auth/dev/login', encoded(login), {'Content-Type': 'application/json'}) + session = client.request('GET', '/auth/session') + client.headers['X-CSRF-Token'] = session['csrf_token'] + try: + tenant = str(uuid.UUID(args.tenant)) + check(session['tenant_id'] == tenant and 'catalog:write' in session['permissions'], 'tenant catalog write permission required') + path = '/api/v1/tenants/' + tenant + for name, blob in zip(FILES[platform], blobs): + query = urlencode(dict(artifact_id=blob['artifact_id'], sha256=blob['sha256'], size_bytes=blob['bytes'])) + with (args.artifacts / name).open('rb') as data: + result = client.request('POST', path + '/agent-update-artifacts?' + query, data, + {'Content-Type': 'application/octet-stream', 'Content-Length': str(blob['bytes'])}) + check(result['sha256'] == blob['sha256'] and result['size_bytes'] == blob['bytes'], 'artifact receipt differs') + result = client.request('POST', path + '/agent-releases', encoded(env), {'Content-Type': 'application/json'}) + check(result['release_envelope'] == env, 'published envelope changed') + print(json.dumps({'release_id': result['release_id'], 'version': manifest['version'], 'platform': platform, + 'manifest_sha256': result['manifest_sha256']})) + finally: + client.request('POST', '/auth/logout', b'{}', {'Content-Type':'application/json'}) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + sub = parser.add_subparsers(required=True) + for name, fn in (('prepare', prepare), ('publish', publish)): + cmd = sub.add_parser(name) + cmd.set_defaults(run=fn) + cmd.add_argument('--artifacts', type=Path, required=True) + cmd.add_argument('--build-receipt', type=Path, required=True) + if name == 'prepare': + cmd.add_argument('--state', type=Path, required=True) + cmd.add_argument('--gateway', required=True) + cmd.add_argument('--sequence', type=int, required=True) + cmd.add_argument('--version', required=True) + cmd.add_argument('--days', type=int, default=90) + cmd.add_argument('--service-uid', type=int, default=os.getuid()) + else: + cmd.add_argument('--origin', required=True) + cmd.add_argument('--ca', type=Path) + cmd.add_argument('--tenant', required=True) + cmd.add_argument('--envelope', type=Path, required=True) + auth = cmd.add_mutually_exclusive_group(required=True) + auth.add_argument('--dev-username') + auth.add_argument('--dev-login-file', type=Path) + args = parser.parse_args() + args.run(args) + + +if __name__ == '__main__': + main() diff --git a/tools/dev_agent_release.py b/tools/dev_agent_release.py new file mode 100755 index 0000000..0b23cd9 --- /dev/null +++ b/tools/dev_agent_release.py @@ -0,0 +1,97 @@ +#!/usr/bin/env python3 +"""Stage a build on the development server, sign there, and publish over the loopback HTTPS management API.""" +import argparse +import hashlib +import json +from pathlib import Path +import shlex +import subprocess +import sys + +import agent_release +from dev_stage import ssh_prefix + +ROOT = Path(__file__).resolve().parents[1] + +def on_server(options): + import hashlib + import json + import os + from pathlib import Path + import shutil + import subprocess + import tempfile + + os.umask(0o077) + state = Path('/opt/rust-discovery/devstate/mvp-releases') + stage = Path.home() / 'rmm-dev-stage' + tool = stage / options['tool'] / 'agent_release.py' + if hashlib.sha256(tool.read_bytes()).hexdigest() != options['tool']: + raise ValueError('staged release tool differs') + build = state / 'builds' / options['label'] / str(options['sequence']) + build.mkdir(parents=True, exist_ok=True) + for name, digest in options['files'].items(): + source = stage / digest / name + dest = build / name + if hashlib.sha256(source.read_bytes()).hexdigest() != digest: + raise ValueError('staged build differs: ' + name) + if not dest.exists(): + with tempfile.NamedTemporaryFile(dir=build, delete=False) as tmp: + with source.open('rb') as f: + shutil.copyfileobj(f, tmp) + tmp.flush() + os.fsync(tmp.fileno()) + try: + os.link(tmp.name, dest) + finally: + os.unlink(tmp.name) + if hashlib.sha256(dest.read_bytes()).hexdigest() != digest: + raise ValueError('sequence already contains different build: ' + name) + inputs = ['--artifacts', str(build), '--build-receipt', str(build / options['receipt'])] + subprocess.run(['python3', '-I', str(tool), 'prepare', *inputs, '--state', str(state), '--gateway', options['gateway'], + '--service-uid','10001','--sequence',str(options['sequence']),'--version',options['version']],check=True) + if options['prepare_only']: + return + # Use the ordinary development catalog permission and CSRF-protected API. + # Credentials are read within the dev server and never returned over SSH. + cid = subprocess.check_output(['docker','ps','-q','--filter','label=com.docker.compose.project=rust-discovery-server', + '--filter','label=com.docker.compose.service=api']).decode().strip().splitlines() + if len(cid) != 1: + raise ValueError('expected one running development API') + env = dict(x.partition('=')[::2] for x in json.loads(subprocess.check_output(['docker','inspect',cid[0]]))[0]['Config']['Env']) + if env.get('RMM_PROFILE') != 'development' or env.get('RMM_DEV_AUTH') != 'true': + raise ValueError('explicit dev API required') + with tempfile.NamedTemporaryFile(mode='w', dir=state) as auth: + json.dump({'username':env['RMM_DEV_USERNAME'],'password':env['RMM_DEV_PASSWORD']},auth) + auth.flush() + subprocess.run(['python3','-I',str(tool),'publish',*inputs,'--tenant',options['tenant'], + '--envelope',str(state/'prepared'/options['label']/str(options['sequence'])/'envelope.json'), + '--origin','https://localhost:18443','--ca','/opt/rust-discovery/devstate/api-pki/ca.pem', + '--dev-login-file',auth.name],check=True) + +def main(): + import inspect + parser=argparse.ArgumentParser(description=__doc__) + parser.add_argument('--artifacts',type=Path,required=True) + parser.add_argument('--build-receipt',type=Path,required=True) + parser.add_argument('--sequence',type=int,required=True) + parser.add_argument('--version',required=True) + parser.add_argument('--gateway',default='https://discovery.ease-technologies.de') + parser.add_argument('--tenant',default='11111111-1111-4111-8111-111111111111') + parser.add_argument('--prepare-only',action='store_true') + args=parser.parse_args() + platform, _ = agent_release.binaries(args.artifacts,args.build_receipt) + files=[*(args.artifacts/name for name in agent_release.FILES[platform]),args.build_receipt] + tool=Path(agent_release.__file__).resolve() + if args.build_receipt.name in agent_release.FILES[platform]: + raise ValueError('build receipt and binary names must differ') + params={'files':{f.name:hashlib.sha256(f.read_bytes()).hexdigest() for f in files},'tool':hashlib.sha256(tool.read_bytes()).hexdigest(), + 'receipt':args.build_receipt.name,'sequence':args.sequence,'version':args.version,'tenant':args.tenant, + 'gateway':args.gateway,'prepare_only':args.prepare_only,'label':{agent_release.LINUX:'linux', + agent_release.WINDOWS:'windows',agent_release.WINDOWS_GNU:'windows-gnu'}[platform]} + subprocess.run([sys.executable,str(ROOT/'tools/dev_stage.py'),'server',*map(str,files),str(tool)],check=True) + command=inspect.getsource(on_server)+'\non_server('+repr(params)+')\n' + subprocess.run([*ssh_prefix('server'),shlex.join(['python3','-I','-'])],input=command,text=True,check=True) + +if __name__=='__main__': + main() diff --git a/web/src/agent-updates.ts b/web/src/agent-updates.ts index 0bbec9e..230af60 100644 --- a/web/src/agent-updates.ts +++ b/web/src/agent-updates.ts @@ -25,7 +25,7 @@ export function releaseEnvelope(value: unknown): ReleaseView { if (!bytes.length || bytes.length > 16384 || signature.length !== 64) throw new Error('Agentupdate: Manifest-/Signaturlimit'); const m = record(JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes))); exact(m, ['schema_version', 'release_id', 'release_sequence', 'version', 'platform', 'published_at', 'expires_at', 'protocol_major', 'state_schema', 'minimum_updater_version', 'artifacts']); - if (m.schema_version !== 1 || !['x86_64-unknown-linux-gnu', 'x86_64-pc-windows-msvc'].includes(String(m.platform)) || typeof m.version !== 'string' || !/^[A-Za-z0-9.+_-]{1,64}$/.test(m.version) + if (m.schema_version !== 1 || !['x86_64-unknown-linux-gnu', 'x86_64-pc-windows-msvc', 'x86_64-pc-windows-gnu'].includes(String(m.platform)) || typeof m.version !== 'string' || !/^[A-Za-z0-9.+_-]{1,64}$/.test(m.version) || !Array.isArray(m.artifacts) || m.artifacts.length !== 2) throw new Error('Agentupdate: festes x64-Codepaar erforderlich'); const artifacts = m.artifacts.map((value, index) => { const a = record(value); exact(a, ['role', 'artifact_id', 'sha256', 'bytes']); if (a.role !== ['agent', 'helper'][index]) throw new Error('Agentupdate: Agent-/Helperreihenfolge'); return { role: a.role, artifact_id: uuid(a.artifact_id), sha256: digest(a.sha256), bytes: integer(a.bytes, 1, 268435456) }; }); if (artifacts[0]!.artifact_id === artifacts[1]!.artifact_id) throw new Error('Agentupdate: doppelte Artefakt-ID'); diff --git a/web/src/main.tsx b/web/src/main.tsx index fc01e27..d0d85bb 100644 --- a/web/src/main.tsx +++ b/web/src/main.tsx @@ -176,15 +176,18 @@ function WindowsMsiCatalog({ tenantId, auth }: { tenantId: string; auth: Session function AgentReleaseCatalog({ tenantId, auth }: { tenantId: string; auth: Session }) { const [cursor, setCursor] = useState(null), [revision, setRevision] = useState(0), [source, setSource] = useState('{}'), [busy, setBusy] = useState(false), [error, setError] = useState(null), [receipts, setReceipts] = useState([]); + const [enrollment, setEnrollment] = useState<{ token: string; expires: string; origin: string | null } | null>(null); + const [enrollmentError, setEnrollmentError] = useState(null); + const [issuing, setIssuing] = useState(false); const list = useResource(async signal => { const result = page(await request(tenantPath(tenantId, `/agent-releases${cursor ? `?cursor=${encodeURIComponent(cursor)}` : ''}`), { signal })); const items: RecordValue[] = []; for (const item of result.items) { const release = await verifyReleaseMetadata(item.release_envelope, item.manifest_sha256); if (item.release_id !== release.manifest.release_id) throw new Error('Release-ID widerspricht originalem Manifest'); items.push({ release_id: item.release_id, manifest_sha256: item.manifest_sha256, manifest: release.manifest, signature_and_time_valid: item.signature_and_time_valid === true }); } return { ...result, items }; }, [tenantId, cursor, revision]); - return

Signierter Agent-Releasekatalog

Feste Release-ID für update_agent verwenden. Die Planung löst Vorgänger und Peerpinübergang aus frischen gespeicherten Gerätebeobachtungen auf. Ein Katalogeintrag oder passiver Versionscheck erteilt keine Ausführungserlaubnis; fehlende Qualifikation bleibt gesperrt.

+ return

Signierter Agent-Releasekatalog

Installierte Clients können hier veröffentlichte Versionen beim nächsten regulären Abruf beziehen. Jedes signierte Manifest bindet eine Plattform sowie die genauen Agent- und Helperdateien.

{list.data && <>} -
Signiertes festes Release mit Agent und Helper veröffentlichen

Nur Katalogverwaltung mit catalog:write. Kein Gerätejob und keine Freigabe zur Installation. Dateien werden gegen die festen signierten Längen/Hashes geprüft; erst beide vollständigen Importe erlauben die Releaseveröffentlichung. Bei Fehler keine automatische Wiederholung; vorhandene Teilimportbelege bleiben sichtbar.

+
Signiertes festes Release mit Agent und Helper veröffentlichen

Der Server prüft Signatur, Größe und SHA-256 beider Dateien. Erst nach dem vollständigen Upload wird die neue Version für Geräte sichtbar.

{ event.preventDefault(); setBusy(true); setError(null); setReceipts([]); const form = new FormData(event.currentTarget); try { if (!allowed(auth, 'catalog:write')) throw new Error('catalog:write unbekannt/nicht erteilt'); const release = releaseEnvelope(parseStrictJson(source)), artifacts = release.manifest.artifacts as RecordValue[]; @@ -198,9 +201,27 @@ function AgentReleaseCatalog({ tenantId, auth }: { tenantId: string; auth: Sessi } catch (error) { setError(errorText(error)); } finally { setBusy(false); } }}>