//! 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, #[serde(default)] localservice_time_policy: Option, } #[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 } fn exclusive_job_gate() -> Result> { use std::os::windows::fs::OpenOptionsExt; let path = data("release-job.lock"); job_binding::check_admin_readonly(&path)?; match fs::OpenOptions::new().read(true).share_mode(0).open(path) { Ok(file) => Ok(Some(file)), Err(error) if error.raw_os_error() == Some(32) => Ok(None), Err(error) => Err(error.into()), } } async fn cycle() -> Result<()> { let active: Installed = read_record(ACTIVE)?; let config: Endpoint = serde_json::from_slice(&protected(&data("config.json"), 32768)?)?; // Additional SYSTEM helper pins need their separately coordinated handoff. ensure!( !config.enable_jobs || config.localservice_time_policy.as_ref() == Some(&data("job-time.json")), "job-enabled pair requires coordinated helper handoff" ); if data(INTENT).try_exists()? { let _job_gate = if config.enable_jobs { let Some(file) = exclusive_job_gate()? else { return Ok(()); }; Some(file) } else { None }; 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 _job_gate = if config.enable_jobs { let Some(file) = exclusive_job_gate()? else { return Ok(()); }; Some(file) } else { None }; 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(()) }