//! 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}, }; use axum::{ Extension, Json, Router, body::Body, extract::{Path, Query, State}, http::{HeaderMap, HeaderValue, StatusCode}, response::{IntoResponse, Response}, routing::{get, post}, }; use futures_util::StreamExt; use rmm_domain::{ agent_update::{ArtifactDescriptor, Platform, ReleaseEnvelope, ReleaseManifest}, jobs::{ArtifactReference, encode, hash}, }; use serde::Deserialize; use serde_json::{Value, json}; use sqlx::{Postgres, Row, Transaction}; use std::{ fs, io::Read, os::unix::fs::{MetadataExt, OpenOptionsExt, PermissionsExt}, path::Path as FsPath, time::{Duration, Instant}, }; use uuid::Uuid; fn fail(code: &'static str) -> Error { Error(StatusCode::CONFLICT, code) } fn missing() -> Error { Error(StatusCode::NOT_FOUND, "NOT_FOUND") } fn invalid() -> Error { Error(StatusCode::BAD_REQUEST, "INVALID_AGENT_RELEASE") } 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> { let key_path = std::env::var("RMM_JOB_KEY_FILE").map_err(|_| fail("AGENT_UPDATE_NOT_CONFIGURED"))?; let key_meta = fs::symlink_metadata(key_path).map_err(|_| fail("AGENT_UPDATE_NOT_CONFIGURED"))?; if !key_meta.is_file() || key_meta.mode() & 0o077 != 0 { return Err(fail("AGENT_UPDATE_NOT_CONFIGURED")); } let owner = key_meta.uid(); let mut file = fs::OpenOptions::new() .read(true) .custom_flags(libc::O_NOFOLLOW | libc::O_CLOEXEC) .open(path) .map_err(|_| fail("AGENT_UPDATE_NOT_CONFIGURED"))?; let m = file .metadata() .map_err(|_| fail("AGENT_UPDATE_NOT_CONFIGURED"))?; let parent = fs::symlink_metadata( path.parent() .ok_or_else(|| fail("AGENT_UPDATE_NOT_CONFIGURED"))?, ) .map_err(|_| fail("AGENT_UPDATE_NOT_CONFIGURED"))?; if !m.is_file() || m.uid() != owner || m.mode() & 0o777 != 0o600 || m.nlink() != 1 || m.len() == 0 || m.len() > maximum || !parent.is_dir() || parent.uid() != owner || parent.permissions().mode() & 0o022 != 0 { return Err(fail("AGENT_UPDATE_NOT_CONFIGURED")); } let mut raw = Vec::new(); (&mut file) .take(maximum + 1) .read_to_end(&mut raw) .map_err(|_| fail("AGENT_UPDATE_NOT_CONFIGURED"))?; let after = file .metadata() .map_err(|_| fail("AGENT_UPDATE_NOT_CONFIGURED"))?; if raw.len() as u64 != m.len() || ( m.dev(), m.ino(), m.len(), m.uid(), m.mode(), m.ctime(), m.ctime_nsec(), m.mtime(), m.mtime_nsec(), ) != ( after.dev(), after.ino(), after.len(), after.uid(), after.mode(), after.ctime(), after.ctime_nsec(), after.mtime(), after.mtime_nsec(), ) { return Err(fail("AGENT_UPDATE_NOT_CONFIGURED")); } Ok(raw) } pub fn store() -> Result { let key = std::env::var("RMM_JOB_KEY_FILE").map_err(|_| fail("AGENT_UPDATE_NOT_CONFIGURED"))?; let path = FsPath::new(&key); let metadata = fs::symlink_metadata(path).map_err(|_| fail("AGENT_UPDATE_NOT_CONFIGURED"))?; if !metadata.is_file() || metadata.permissions().mode() & 0o077 != 0 { return Err(fail("AGENT_UPDATE_NOT_CONFIGURED")); } Ok(UpdateArtifacts::new( &std::env::var("RMM_PROFILE").unwrap_or_default(), 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(), )?) } 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 /// configuration slots. It never supplies a path or introduces update trust. fn keyring_path_with( platform: Platform, lookup: impl Fn(&str) -> Result, Error>, ) -> Result { 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() { return Err(fail("AGENT_UPDATE_NOT_CONFIGURED")); } return Ok(path.into()); } // Exact legacy compatibility only when the platform-specific slot is // absent. An invalid explicit slot must never silently choose other trust. lookup("RMM_AGENT_UPDATE_KEYRING_FILE")? .map(Into::into) .ok_or_else(|| fail("AGENT_UPDATE_NOT_CONFIGURED")) } pub fn verify_envelope( envelope: &ReleaseEnvelope, binding: Option<&rmm_domain::agent_update::UpdaterBinding>, ) -> Result { let platform = envelope.decode().map_err(|_| invalid())?.manifest.platform; if platform == Platform::WindowsGnuX64 && std::env::var("RMM_PROFILE").as_deref() != Ok("development") { return Err(fail("AGENT_UPDATE_DEVELOPMENT_CHANNEL_REQUIRED")); } verify_signed_envelope(envelope, platform, binding) } // The public management process can copy an operator-selected release into an empty // catalog. Network-supplied publications additionally go through the profile check above. fn verify_signed_envelope( envelope: &ReleaseEnvelope, platform: Platform, binding: Option<&rmm_domain::agent_update::UpdaterBinding>, ) -> Result { let raw = keyring_bytes(platform)?; verify_envelope_with_keyring( envelope, binding, &raw, chrono::Utc::now() .timestamp() .try_into() .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>, raw: &[u8], now_utc_seconds: u64, ) -> Result { let decoded = envelope.decode().map_err(|_| invalid())?; let config: rmm_domain::agent_update::UpdateKeyringFile = serde_json::from_slice(raw).map_err(|_| fail("AGENT_UPDATE_TRUST_INVALID"))?; if !config.validate() || binding.is_some_and(|b| { b.keyring_generation != config.generation || b.keyring_sha256 != hash(raw) }) { return Err(fail("AGENT_UPDATE_TRUST_INVALID")); } let mut keys = Vec::new(); for key in config.keys { if !rmm_domain::agent_update::digest(&key.public_key_hex) { return Err(fail("AGENT_UPDATE_TRUST_INVALID")); } let raw = hex::decode(key.public_key_hex).map_err(|_| fail("AGENT_UPDATE_TRUST_INVALID"))?; keys.push( rmm_updater::TrustedUpdateKey::new( raw.try_into() .map_err(|_| fail("AGENT_UPDATE_TRUST_INVALID"))?, verifier_platform(key.platform), key.first_sequence, key.last_sequence, key.revoked, ) .map_err(|_| fail("AGENT_UPDATE_TRUST_INVALID"))?, ); } let keyring = rmm_updater::UpdateKeyring::new(config.generation, keys) .map_err(|_| fail("AGENT_UPDATE_TRUST_INVALID"))?; let context = rmm_updater::TrustedContext { platform: verifier_platform(decoded.manifest.platform), now_utc_seconds, keyring_generation: config.generation, protocol_major: 1, state_schema: 1, updater_version: if binding.is_none() && decoded.manifest.platform == Platform::WindowsGnuX64 { 2 } else { 1 }, minimum_release_sequence: 0, active_release: None, }; let verified = rmm_updater::verify_release( rmm_updater::SignedRelease { schema_version: envelope.schema_version, key_id: &envelope.key_id, payload_bytes: &decoded.payload_bytes, signature: &decoded.signature, }, &keyring, &context, ) .map_err(|_| invalid())?; if verified.manifest_sha256() != hash(&decoded.payload_bytes) { return Err(invalid()); } Ok(decoded.manifest) } 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), ) .route( "/api/v1/tenants/{tenant}/agent-update-artifacts", post(upload), ) } 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/device-trust", get(bootstrap::device_trust)) .route( "/agent/v1/releases/{release}/artifacts/{artifact}", get(release_artifact), ) .route("/agent/v1/update-artifacts/{artifact}", get(download)) } #[derive(Deserialize)] #[serde(deny_unknown_fields)] pub struct UploadDescriptor { artifact_id: Uuid, sha256: String, size_bytes: u64, } pub async fn upload( State(s): State, h: HeaderMap, Path(t): Path, Query(input): Query, body: Body, ) -> Result, Error> { let (p, tx) = crate::catalog::context(&s, &h, t, true).await?; if input.artifact_id.is_nil() || !rmm_domain::agent_update::digest(&input.sha256) || !(1..=rmm_updater::MAX_ARTIFACT_BYTES).contains(&input.size_bytes) || h.get("content-type").and_then(|v| v.to_str().ok()) != Some("application/octet-stream") || h.get("content-length") .and_then(|v| v.to_str().ok()) .and_then(|v| v.parse::().ok()) != Some(input.size_bytes) { return Err(invalid()); } tx.rollback().await?; // Authentication/CSRF/tenant checks precede body reads. No unbounded body Vec. let store = store()?; let mut staged = store.begin(t, &input.sha256, input.size_bytes)?; let deadline = Instant::now() + Duration::from_secs(180); let mut stream = body.into_data_stream(); loop { if Instant::now() >= deadline { return Err(Error( StatusCode::REQUEST_TIMEOUT, "AGENT_UPDATE_IMPORT_TIMEOUT", )); } let frame = tokio::time::timeout( deadline.saturating_duration_since(Instant::now()), stream.next(), ) .await .map_err(|_| Error(StatusCode::REQUEST_TIMEOUT, "AGENT_UPDATE_IMPORT_TIMEOUT"))?; if Instant::now() >= deadline { return Err(Error( StatusCode::REQUEST_TIMEOUT, "AGENT_UPDATE_IMPORT_TIMEOUT", )); } let Some(frame) = frame else { break }; let bytes = frame.map_err(|_| invalid())?; for chunk in bytes.chunks(32768) { staged.append(chunk)?; } if Instant::now() >= deadline { return Err(Error( StatusCode::REQUEST_TIMEOUT, "AGENT_UPDATE_IMPORT_TIMEOUT", )); } } let (current_principal, mut tx) = crate::catalog::context(&s, &h, t, true).await?; if current_principal.name != p.name { return Err(Error(StatusCode::FORBIDDEN, "FORBIDDEN")); } if Instant::now() >= deadline { return Err(Error( StatusCode::REQUEST_TIMEOUT, "AGENT_UPDATE_IMPORT_TIMEOUT", )); } staged.finish(&store, t)?; sqlx::query("INSERT INTO agent_update_artifacts(tenant_id,artifact_id,sha256,size_bytes) VALUES($1,$2,$3,$4) ON CONFLICT DO NOTHING") .bind(t).bind(input.artifact_id).bind(&input.sha256).bind(input.size_bytes as i64).execute(&mut *tx).await?; let actual = sqlx::query("SELECT sha256,size_bytes FROM agent_update_artifacts WHERE artifact_id=$1") .bind(input.artifact_id) .fetch_one(&mut *tx) .await?; if actual.get::("sha256") != input.sha256 || actual.get::("size_bytes") as u64 != input.size_bytes { return Err(fail("AGENT_UPDATE_ARTIFACT_CONFLICT")); } sqlx::query("INSERT INTO audit_events VALUES($1,$2,$3,'agent_update_artifact_imported',$4,now())") .bind(t).bind(Uuid::new_v4()).bind(p.name).bind(json!({"artifact_id":input.artifact_id,"sha256":input.sha256,"size_bytes":input.size_bytes,"testsimulation":p.testsimulation})).execute(&mut *tx).await?; tx.commit().await?; Ok(Json( json!({"artifact_id":input.artifact_id,"sha256":input.sha256,"size_bytes":input.size_bytes}), )) } pub async fn checked_release( tx: &mut Transaction<'_, Postgres>, id: Uuid, ) -> Result<(ReleaseEnvelope, ReleaseManifest), Error> { let row = sqlx::query("SELECT envelope,envelope_sha256,manifest_sha256 FROM agent_update_releases WHERE release_id=$1") .bind(id).fetch_optional(&mut **tx).await?.ok_or_else(missing)?; let raw: Vec = row.get("envelope"); let envelope: ReleaseEnvelope = serde_json::from_slice(&raw)?; let manifest = verify_envelope(&envelope, None)?; if encode(&envelope)? != raw || hash(&raw) != row.get::("envelope_sha256") || hash(&envelope.decode().map_err(|_| invalid())?.payload_bytes) != row.get::("manifest_sha256") || manifest.release_id != id { return Err(fail("AGENT_UPDATE_CATALOG_INTEGRITY")); } Ok((envelope, manifest)) } pub async fn resolve_artifacts( tx: &mut Transaction<'_, Postgres>, tenant: Uuid, descriptors: &[ArtifactDescriptor; 2], ) -> Result, Error> { let store = store()?; let mut refs = Vec::new(); for d in descriptors { let actual = sqlx::query( "SELECT sha256,size_bytes FROM agent_update_artifacts WHERE artifact_id=$1", ) .bind(d.artifact_id) .fetch_optional(&mut **tx) .await? .ok_or_else(missing)?; if actual.get::("sha256") != d.sha256 || actual.get::("size_bytes") as u64 != d.bytes { return Err(fail("AGENT_UPDATE_ARTIFACT_BINDING")); } store.verify(tenant, &d.sha256, d.bytes)?; refs.push(ArtifactReference { artifact_id: d.artifact_id, sha256: d.sha256.clone(), size_bytes: d.bytes, }); } Ok(refs) } pub async fn import( State(s): State, h: HeaderMap, Path(t): Path, Json(envelope): Json, ) -> Result, Error> { let (p, mut tx) = crate::catalog::context(&s, &h, t, true).await?; let raw = encode(&envelope)?; if raw.len() > 32768 { return Err(invalid()); } let m = verify_envelope(&envelope, None)?; 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); 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}), )) } pub async fn list_for( s: &crate::State, p: &crate::auth::Principal, tenant: Uuid, query: crate::pagination::PageQuery, ) -> Result { crate::jobs::scope(p, tenant, false)?; let mut tx = rmm_persistence::tenant_tx(&s.pool, tenant).await?; crate::permissions::require_principal(&mut tx, p, "operations:read").await?; let mut page = crate::pagination::Cursor::parse(s, p, "catalog:agent-releases:release_id:asc", query) .map_err(|status| Error(status, "VALIDATION_ERROR"))?; let rows = sqlx::query("SELECT release_id,envelope,envelope_sha256,manifest_sha256 FROM agent_update_releases WHERE release_id>$1 AND created_at<=$2 ORDER BY release_id LIMIT $3") .bind(page.last).bind(page.as_of).bind(i64::from(page.limit)+1).fetch_all(&mut *tx).await?; let truncated = rows.len() > usize::from(page.limit); let next = if truncated { Some( page.next(s, rows[usize::from(page.limit) - 1].get("release_id")) .map_err(|status| Error(status, "VALIDATION_ERROR"))?, ) } else { None }; let mut items = Vec::new(); for row in rows.iter().take(usize::from(page.limit)) { let raw: Vec = row.get("envelope"); let envelope: ReleaseEnvelope = serde_json::from_slice(&raw)?; let decoded = envelope.decode().map_err(|_| invalid())?; if encode(&envelope)? != raw || hash(&raw) != row.get::("envelope_sha256") || hash(&decoded.payload_bytes) != row.get::("manifest_sha256") || decoded.manifest.release_id != row.get::("release_id") { return Err(fail("AGENT_UPDATE_CATALOG_INTEGRITY")); } // Stored expired metadata remains readable and is explicitly not apply authority. items.push(json!({"release_id":decoded.manifest.release_id,"manifest_sha256":hash(&decoded.payload_bytes),"release_envelope":envelope,"manifest":decoded.manifest,"signature_and_time_valid":verify_envelope(&envelope,None).is_ok()})); } tx.commit().await?; Ok( json!({"items":items,"next_cursor":next,"completeness":if truncated {"partial"}else{"complete"},"truncated":truncated,"as_of":page.as_of}), ) } async fn list( State(s): State, h: HeaderMap, Path(t): Path, Query(query): Query, ) -> Result, Error> { let p = s .auth .principal(&s, &h, false) .await .map_err(|status| Error(status, crate::auth::error_code(status)))?; Ok(Json(list_for(&s, &p, t, query).await?)) } #[derive(Deserialize)] #[serde(deny_unknown_fields)] pub struct Current { platform: Platform, } async fn device( s: &crate::State, peer: crate::Peer, headers: &HeaderMap, ) -> Result<(Uuid, Uuid), Error> { if headers.contains_key("authorization") { return Err(Error(StatusCode::UNAUTHORIZED, "DEVICE_MTLS_REQUIRED")); } crate::agent_http::identity(s, peer) .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, headers: HeaderMap, Query(q): Query, ) -> Result, Error> { let (tenant, agent) = device(&s, peer, &headers).await?; let mut tx = rmm_persistence::tenant_tx(&s.pool, tenant).await?; 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?; // Polling is frequent. The catalog binds immutable descriptors by FK. // Publication and actual downloads verify the full stream. let objects = store()?; for item in &manifest.artifacts { objects.available(tenant, &item.sha256, item.bytes)?; } Some(json!({"release_envelope":envelope,"manifest":manifest})) } else { None }; tx.commit().await?; Ok(Json( json!({"status":if release.is_some(){"available"}else{"not_configured"},"release":release,"observed_at":chrono::Utc::now(),"server_time":chrono::Utc::now(),"job_created":false}), )) } #[derive(Deserialize)] #[serde(deny_unknown_fields)] pub struct Chunk { job_id: Uuid, attempt_id: Uuid, #[serde(default)] offset: u64, length: Option, } async fn download( State(s): State, Extension(peer): Extension, headers: HeaderMap, Path(id): Path, Query(q): Query, ) -> Result { let (tenant, agent) = device(&s, peer, &headers).await?; let length = q.length.unwrap_or(MAX_CHUNK_BYTES); if !(1..=MAX_CHUNK_BYTES).contains(&length) { return Err(invalid()); } let mut tx = rmm_persistence::tenant_tx(&s.pool, tenant).await?; let row=sqlx::query("SELECT j.payload,p.payload AS plan_payload,p.plan_hash,z.principal AS approver,i.asset_id,i.enrollment_generation,i.assignment_version FROM jobs j JOIN operations o ON o.tenant_id=j.tenant_id AND o.operation_id=j.operation_id JOIN authorizations z ON z.tenant_id=o.tenant_id AND z.authorization_id=o.authorization_id JOIN approval_requests r ON r.tenant_id=j.tenant_id AND r.operation_id=j.operation_id JOIN operation_plans p ON p.tenant_id=r.tenant_id AND p.plan_id=r.plan_id JOIN agent_installations i ON i.tenant_id=j.tenant_id AND i.agent_id=j.agent_id WHERE j.agent_id=$1 AND j.job_id=$2 AND j.attempt_id=$3 AND j.state IN ('queued','accepted','running','verifying') AND r.approval_state='approved' AND z.revoked_at IS NULL AND p.expires_at>now() AND i.revoked_at IS NULL") .bind(agent).bind(q.job_id).bind(q.attempt_id).fetch_optional(&mut *tx).await?.ok_or_else(missing)?; let job: rmm_domain::jobs::JobPayload = serde_json::from_slice(&row.get::, _>("payload"))?; let raw: Vec = row.get("plan_payload"); if hash(&raw) != row.get::("plan_hash") { return Err(fail("PLAN_HASH_MISMATCH")); } let plan: rmm_domain::jobs::PlanPayload = serde_json::from_slice(&raw)?; validate_job_binding(&plan, &job)?; let rmm_domain::jobs::Action::UpdateAgent { update } = &job.action else { return Err(missing()); }; crate::root_policy::authorize(&mut tx, &plan.principal, &job).await?; crate::root_policy::authorize(&mut tx, &row.get::("approver"), &job).await?; check_update(&mut tx, update).await?; if job.tenant_id != tenant || job.agent_id != agent || job.asset_id != row.get::("asset_id") || job.enrollment_generation != row.get::("enrollment_generation") as u64 || job.assignment_version != row.get::("assignment_version") as u64 { return Err(missing()); } let manifest = update.manifest().map_err(|_| invalid())?; let descriptor = manifest .artifacts .iter() .find(|a| a.artifact_id == id) .ok_or_else(missing)?; if q.offset >= descriptor.bytes { return Err(Error( StatusCode::RANGE_NOT_SATISFIABLE, "INVALID_ARTIFACT_RANGE", )); } tx.commit().await?; let bytes = store()?.read_chunk( tenant, &descriptor.sha256, descriptor.bytes, q.offset, length, )?; let end = q.offset + bytes.len() as u64; let partial = q.offset > 0 || end < descriptor.bytes; let mut response = ( if partial { StatusCode::PARTIAL_CONTENT } else { StatusCode::OK }, bytes, ) .into_response(); let h = response.headers_mut(); for (name, value) in [ ("content-type", "application/octet-stream"), ("content-disposition", "attachment"), ("x-content-type-options", "nosniff"), ("accept-ranges", "bytes"), ] { h.insert(name, HeaderValue::from_static(value)); } h.insert( "x-artifact-sha256", HeaderValue::from_str(&descriptor.sha256).map_err(|_| invalid())?, ); if partial { h.insert( "content-range", HeaderValue::from_str(&format!( "bytes {}-{}/{}", q.offset, end - 1, descriptor.bytes )) .map_err(|_| invalid())?, ); } Ok(response) } pub async fn check_update( tx: &mut Transaction<'_, Postgres>, update: &rmm_domain::agent_update::ResolvedAgentUpdate, ) -> Result<(), Error> { if !update.validate() { return Err(invalid()); } let manifest = verify_envelope(&update.release_envelope, Some(&update.updater))?; let (envelope, stored) = checked_release(tx, manifest.release_id).await?; if envelope != update.release_envelope || stored != manifest { return Err(fail("AGENT_UPDATE_CATALOG_BINDING")); } Ok(()) } pub fn validate_plan_bindings(plan: &rmm_domain::jobs::PlanPayload) -> Result<(), Error> { use rmm_domain::jobs::Action; let updates = plan .jobs .iter() .filter(|j| matches!(j.payload.action, Action::UpdateAgent { .. })) .count(); if updates == 0 { return Ok(()); } if updates != plan.jobs.len() || !plan.recipe_references.is_empty() || plan.artifact_references.len() != updates * 2 { return Err(fail("AGENT_UPDATE_ARTIFACT_BINDING")); } for fixed in &plan.jobs { let Action::UpdateAgent { update } = &fixed.payload.action else { return Err(invalid()); }; let m = update.manifest().map_err(|_| invalid())?; let refs = plan .artifact_references .iter() .filter(|r| { r.job_id == fixed.payload.job_id && r.attempt_id == fixed.payload.attempt_id }) .collect::>(); if !update.validate() || !fixed.payload.action.valid_job_limits( fixed.payload.max_runtime_seconds, fixed.payload.max_output_bytes, ) || plan.tenant_id != fixed.payload.tenant_id || update.execution_identity() != Some(fixed.payload.execution_identity.as_str()) || refs.len() != 2 || refs .iter() .zip(m.artifacts.iter()) .any(|(actual, expected)| { actual.artifact != ArtifactReference { artifact_id: expected.artifact_id, sha256: expected.sha256.clone(), size_bytes: expected.bytes, } }) || hash(&encode(&fixed.payload)?) != fixed.job_payload_hash || fixed.script_sha256.is_some() || plan .jobs .iter() .filter(|other| { other.payload.job_id == fixed.payload.job_id || other.payload.attempt_id == fixed.payload.attempt_id }) .count() != 1 { return Err(fail("AGENT_UPDATE_ARTIFACT_BINDING")); } } Ok(()) } pub fn validate_job_binding( plan: &rmm_domain::jobs::PlanPayload, job: &rmm_domain::jobs::JobPayload, ) -> Result<(), Error> { if !matches!(job.action, rmm_domain::jobs::Action::UpdateAgent { .. }) { return Err(missing()); } validate_plan_bindings(plan)?; let actual = encode(job)?; let fixed = plan .jobs .iter() .filter(|j| j.payload.job_id == job.job_id && j.payload.attempt_id == job.attempt_id) .collect::>(); if fixed.len() != 1 || encode(&fixed[0].payload)? != actual || fixed[0].job_payload_hash != hash(&actual) { return Err(fail("AGENT_UPDATE_ARTIFACT_BINDING")); } Ok(()) } /// Only saved, authenticated passive observations are consulted. This never /// asks a device for live data and never accepts caller-provided predecessor pins. pub async fn resolve_target( tx: &mut Transaction<'_, Postgres>, asset: Uuid, release_id: Uuid, ) -> Result { use rmm_domain::agent_update::{ AgentUpdateObservation, HealthProfile, ObservationQuality, Recovery, ResolvedAgentUpdate, UpdateProfile, }; let row=sqlx::query("SELECT i.tenant_id,i.asset_id,i.agent_id,i.enrollment_generation,i.assignment_version,i.connection_generation,i.connection_boot_id,i.last_contact_at,i.sync_ready,i.helper_sync_ready,i.restore_blocked,i.sync_recovery_required,i.sequence_regressed,o.boot_id,o.observed_at,o.received_at,o.quality,o.completeness,o.data,s.journal_id,s.helper_journal_id FROM agent_installations i JOIN agent_sync_state s ON s.tenant_id=i.tenant_id AND s.agent_id=i.agent_id JOIN LATERAL (SELECT boot_id,observed_at,received_at,quality,completeness,data FROM observations WHERE tenant_id=i.tenant_id AND agent_id=i.agent_id AND source_id IN ('linux.base','windows.base','agent.update') ORDER BY observed_at DESC,received_at DESC LIMIT 1) o ON true WHERE i.asset_id=$1 AND i.revoked_at IS NULL") .bind(asset).fetch_all(&mut **tx).await?; if row.len() != 1 { return Err(fail("AGENT_UPDATE_STATE_NOT_CONFIGURED")); } let row = &row[0]; let now = chrono::Utc::now(); let observed: chrono::DateTime = row.get("observed_at"); let received: chrono::DateTime = row.get("received_at"); let contact: Option> = row.get("last_contact_at"); if row.get::("quality") != "valid" || row.get::("completeness") != "partial" || !row.get::("sync_ready") || !row.get::("helper_sync_ready") || row.get::("restore_blocked") || row.get::("sync_recovery_required") || row.get::("sequence_regressed") || row.get::, _>("connection_boot_id") != Some(row.get("boot_id")) || contact.is_none_or(|t| t > now || t < now - chrono::Duration::seconds(90)) || observed > now || received > now || observed < now - chrono::Duration::minutes(5) || received < now - chrono::Duration::minutes(5) { return Err(fail("AGENT_UPDATE_STATE_STALE")); } let data: Value = row.get("data"); let observation: AgentUpdateObservation = serde_json::from_value( data.get("agent_update") .cloned() .ok_or_else(|| fail("AGENT_UPDATE_STATE_NOT_CONFIGURED"))?, )?; if !observation.validate() || observation.quality != ObservationQuality::Valid || observation.observed_at > observed || observation.observed_at < now - chrono::Duration::minutes(5) { return Err(fail("AGENT_UPDATE_STATE_STALE")); } let checkpoint=sqlx::query("SELECT payload,created_at,connection_generation,journal_id FROM sync_checkpoints WHERE agent_id=$1 AND decision_id=$2") .bind(row.get::("agent_id")).bind(observation.signed_sync_decision_id).fetch_optional(&mut **tx).await?.ok_or_else(||fail("AGENT_UPDATE_SYNC_PROVENANCE"))?; let original: rmm_domain::reconciliation::ReconcileDecisionPayload = serde_json::from_slice(&checkpoint.get::, _>("payload"))?; if !original.valid_profile(observation.observed_at) || !original.ready || !original.helper_ready || original.tenant_id != row.get::("tenant_id") || original.asset_id != asset || original.agent_id != row.get::("agent_id") || original.boot_id != row.get::("boot_id") || original.connection_generation != row.get::("connection_generation") as u64 || original.enrollment_generation != row.get::("enrollment_generation") as u64 || original.assignment_version != row.get::("assignment_version") as u64 || original.journal_id != row.get::("journal_id") || original.helper_journal_id != row.get::, _>("helper_journal_id") || checkpoint.get::, _>("created_at") > observation.observed_at { return Err(fail("AGENT_UPDATE_SYNC_PROVENANCE")); } let (envelope, manifest) = checked_release(tx, release_id).await?; let manifest_sha = hash(&envelope.decode().map_err(|_| invalid())?.payload_bytes); let preview = observation .candidate_previews .iter() .find(|c| c.release_id == release_id && c.manifest_sha256 == manifest_sha) .ok_or_else(|| fail("AGENT_UPDATE_PREVIEW_NOT_CONFIGURED"))?; if observation.platform != manifest.platform || observation .activation_floor .is_none_or(|floor| manifest.release_sequence <= floor) { return Err(fail("AGENT_UPDATE_PREDECESSOR_MISMATCH")); } let update = ResolvedAgentUpdate { schema_version: 1, profile: UpdateProfile::FixedCodePairV1, release_envelope_sha256: envelope.sha256()?, release_envelope: envelope, manifest_sha256: manifest_sha, predecessor: observation.predecessor.ok_or_else(invalid)?, updater: observation.updater.ok_or_else(invalid)?, peer_pin_transition: preview.peer_pin_transition.clone(), recovery: Recovery::RestoreExactPredecessorOnce, health_profile: HealthProfile::MtlsInventorySyncV1, health_timeout_seconds: 180, no_reboot: true, }; if !update.validate() { return Err(fail("AGENT_UPDATE_PREDECESSOR_MISMATCH")); } verify_envelope(&update.release_envelope, Some(&update.updater))?; Ok(update) } pub async fn validate_current_target( tx: &mut Transaction<'_, Postgres>, job: &rmm_domain::jobs::JobPayload, ) -> Result<(), Error> { let rmm_domain::jobs::Action::UpdateAgent { update } = &job.action else { return Err(invalid()); }; let current = resolve_target( tx, job.asset_id, update.manifest().map_err(|_| invalid())?.release_id, ) .await?; if ¤t != update.as_ref() { return Err(fail("AGENT_UPDATE_PREDECESSOR_MISMATCH")); } Ok(()) } #[cfg(test)] mod tests { use super::*; #[test] fn protected_keyring_slots_are_platform_specific_with_exact_legacy_fallback() { use std::collections::BTreeMap; let paths = BTreeMap::from([ ("RMM_AGENT_UPDATE_LINUX_KEYRING_FILE", "/trust/linux.json"), ( "RMM_AGENT_UPDATE_WINDOWS_KEYRING_FILE", "/trust/windows.json", ), ("RMM_AGENT_UPDATE_KEYRING_FILE", "/trust/legacy.json"), ]); let choose = |platform, map: &BTreeMap<&str, &str>| { keyring_path_with(platform, |name| Ok(map.get(name).map(|v| v.to_string()))) }; assert_eq!( choose(Platform::LinuxX64, &paths).unwrap(), FsPath::new("/trust/linux.json") ); assert_eq!( choose(Platform::WindowsX64, &paths).unwrap(), FsPath::new("/trust/windows.json") ); let legacy = BTreeMap::from([("RMM_AGENT_UPDATE_KEYRING_FILE", "legacy-relative.json")]); for platform in [Platform::LinuxX64, Platform::WindowsX64] { assert_eq!( choose(platform, &legacy).unwrap(), FsPath::new("legacy-relative.json") ); } let only_linux = BTreeMap::from([("RMM_AGENT_UPDATE_LINUX_KEYRING_FILE", "/trust/linux.json")]); assert!(choose(Platform::WindowsX64, &only_linux).is_err()); for invalid in ["", "relative.json"] { let wrong = BTreeMap::from([ ("RMM_AGENT_UPDATE_LINUX_KEYRING_FILE", invalid), ("RMM_AGENT_UPDATE_KEYRING_FILE", "/trust/legacy.json"), ]); assert!(choose(Platform::LinuxX64, &wrong).is_err()); } assert!( keyring_path_with(Platform::WindowsX64, |_| Err(fail( "AGENT_UPDATE_NOT_CONFIGURED" ))) .is_err() ); } #[test] fn selected_platform_keyring_still_enforces_real_signatures_revocation_generation_and_raw_hash() { use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD}; use openssl::{pkey::PKey, sign::Signer}; use rmm_domain::agent_update::{ ArtifactRole, UpdateKeyringEntry, UpdateKeyringFile, UpdaterBinding, }; let make = |platform| { let key = PKey::generate_ed25519().unwrap(); let public = key.raw_public_key().unwrap(); let manifest = ReleaseManifest { schema_version: 1, release_id: Uuid::new_v4(), release_sequence: 2, version: "0.1.1".into(), platform, published_at: 90, expires_at: 200, protocol_major: 1, state_schema: 1, minimum_updater_version: 1, artifacts: [ ArtifactDescriptor { role: ArtifactRole::Agent, artifact_id: Uuid::new_v4(), sha256: hash(b"agent"), bytes: 10, }, ArtifactDescriptor { role: ArtifactRole::Helper, artifact_id: Uuid::new_v4(), sha256: hash(b"helper"), bytes: 20, }, ], }; let raw = encode(&manifest).unwrap(); let mut message = rmm_updater::RELEASE_SIGNATURE_DOMAIN.to_vec(); message.extend_from_slice(&raw); let signature = Signer::new_without_digest(&key) .unwrap() .sign_oneshot_to_vec(&message) .unwrap(); let envelope = ReleaseEnvelope { schema_version: 1, key_id: hash(&public), payload_bytes: URL_SAFE_NO_PAD.encode(&raw), signature: URL_SAFE_NO_PAD.encode(signature), }; let keys = UpdateKeyringFile { schema_version: 1, generation: 7, keys: vec![UpdateKeyringEntry { public_key_hex: hex::encode(public), platform, first_sequence: 1, last_sequence: 4, revoked: false, }], }; (envelope, keys) }; let (linux, linux_keys) = make(Platform::LinuxX64); let (windows, windows_keys) = make(Platform::WindowsX64); let linux_raw = encode(&linux_keys).unwrap(); let windows_raw = encode(&windows_keys).unwrap(); assert_eq!( verify_envelope_with_keyring(&linux, None, &linux_raw, 100) .unwrap() .platform, Platform::LinuxX64 ); assert_eq!( verify_envelope_with_keyring(&windows, None, &windows_raw, 100) .unwrap() .platform, Platform::WindowsX64 ); assert!(verify_envelope_with_keyring(&windows, None, &linux_raw, 100).is_err()); assert!(verify_envelope_with_keyring(&linux, None, &windows_raw, 100).is_err()); let fixture: Value = serde_json::from_str(include_str!( "../../../tests/agent_update/codec-golden.json" )) .unwrap(); let mut binding: UpdaterBinding = serde_json::from_value( fixture["linux_full"]["payload"]["jobs"][0]["payload"]["action"]["update"]["updater"] .clone(), ) .unwrap(); binding.keyring_generation = 7; binding.keyring_sha256 = hash(&linux_raw); assert!(verify_envelope_with_keyring(&linux, Some(&binding), &linux_raw, 100).is_ok()); binding.keyring_generation = 8; assert!(verify_envelope_with_keyring(&linux, Some(&binding), &linux_raw, 100).is_err()); binding.keyring_generation = 7; binding.keyring_sha256 = hash(b"different raw bytes"); assert!(verify_envelope_with_keyring(&linux, Some(&binding), &linux_raw, 100).is_err()); let mut forged = linux.clone(); forged.signature = URL_SAFE_NO_PAD.encode([0u8; 64]); assert!(verify_envelope_with_keyring(&forged, None, &linux_raw, 100).is_err()); let mut revoked = linux_keys; revoked.keys[0].revoked = true; assert!( verify_envelope_with_keyring(&linux, None, &encode(&revoked).unwrap(), 100).is_err() ); let mut changed = linux.decode().unwrap().manifest; changed.platform = Platform::WindowsX64; let mut forged = linux; forged.payload_bytes = URL_SAFE_NO_PAD.encode(encode(&changed).unwrap()); assert!(verify_envelope_with_keyring(&forged, None, &linux_raw, 100).is_err()); } #[test] fn actual_codec_pair_plan_requires_exact_per_attempt_artifact_authority() { let fixtures: Value = serde_json::from_str(include_str!( "../../../tests/agent_update/codec-golden.json" )) .unwrap(); for name in ["linux_general", "linux_full", "windows_pair"] { let fixture = &fixtures[name]; let raw: Vec = serde_json::from_value(fixture["plan_payload_bytes"].clone()).unwrap(); let plan: rmm_domain::jobs::PlanPayload = serde_json::from_slice(&raw).unwrap(); assert_eq!(encode(&plan).unwrap(), raw); let job = &plan.jobs[0].payload; validate_job_binding(&plan, job).unwrap(); for variant in 0..5 { let mut bad = plan.clone(); match variant { 0 => bad.artifact_references.clear(), 1 => bad .artifact_references .push(bad.artifact_references[0].clone()), 2 => bad.artifact_references[0].artifact.artifact_id = Uuid::new_v4(), 3 => bad.artifact_references[0].attempt_id = Uuid::new_v4(), _ => bad.jobs[0].payload.max_runtime_seconds = 601, } assert!(validate_job_binding(&bad, job).is_err()); } } } #[test] fn plan_request_accepts_release_id_but_never_user_supplied_local_bindings() { let mut value = json!({"tenant_id":"11111111-1111-4111-8111-111111111111","action":"update_agent","targets":{"asset_ids":["11111111-1111-4111-8111-111111111112"]}, "parameters":{"release_id":"11111111-1111-4111-8111-111111111113","execution_identity":"root","timeout_seconds":600,"max_output_bytes":65536}, "schedule":{"not_before":"2030-01-01T12:00:00Z","start_before":"2030-01-01T12:10:00Z","offline_policy":"wait_until_deadline"},"rollout":{"max_parallel":1,"halt_after_failures":1},"reason":"codec only"}); let parsed: crate::jobs::PlanRequest = serde_json::from_value(value.clone()).unwrap(); assert!(matches!(parsed, crate::jobs::PlanRequest::AgentUpdate(_))); // The old synchronous resolver cannot manufacture local state. assert!( parsed .resolve(Uuid::parse_str(value["tenant_id"].as_str().unwrap()).unwrap()) .is_err() ); value["parameters"]["predecessor"] = json!({"installed_record_sha256":"00".repeat(32)}); assert!(serde_json::from_value::(value).is_err()); } }