use crate::jobs::Error; use axum::http::StatusCode; use chrono::{DateTime, Utc}; use rmm_domain::jobs::{Action, JobPayload}; use serde::Deserialize; use sqlx::{Postgres, Transaction}; use std::{ fs, os::unix::fs::{MetadataExt, PermissionsExt}, path::Path, }; use uuid::Uuid; #[derive(Deserialize)] #[serde(deny_unknown_fields)] pub struct RootPolicy { schema_version: u32, profile: String, expires_at: DateTime, scopes: Vec, } #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct RootScope { tenant_id: Uuid, asset_id: Uuid, agent_id: Uuid, enrollment_generation: u64, assignment_version: u64, principals: Vec, helper_policy_sha256: String, acceptance_evidence_id: String, allowed_services: Vec, allow_root_scripts: bool, allow_reboot: bool, #[serde(default)] apt: Option, #[serde(default)] root_logs: Option, } #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct RootLogPolicy { schema_version: u32, allowed_units: Vec, #[serde(default)] sensitive_units: Vec, } fn valid_log_unit(unit: &str) -> bool { unit.len() > ".service".len() && unit.len() <= 255 && unit.ends_with(".service") && unit.as_bytes()[0].is_ascii_alphanumeric() && unit .bytes() .all(|c| c.is_ascii_alphanumeric() || b"_.@:-".contains(&c)) } fn valid_log_units(units: &[String]) -> bool { let distinct = units.iter().collect::>(); units.len() <= 128 && distinct.len() == units.len() && units.iter().all(|u| valid_log_unit(u)) } fn parse_log_units(raw: Option<&str>) -> Result>, Error> { let Some(raw) = raw else { return Ok(None) }; // Explicit empty environment means deny-all, never an implicit wildcard. let units: Vec = if raw.trim().is_empty() { Vec::new() } else { if raw.len() > 32768 { return Err(Error(StatusCode::CONFLICT, "ROOT_LOG_ALLOWLIST_INVALID")); } serde_json::from_str(raw) .map_err(|_| Error(StatusCode::CONFLICT, "ROOT_LOG_ALLOWLIST_INVALID"))? }; if !valid_log_units(&units) { return Err(Error(StatusCode::CONFLICT, "ROOT_LOG_ALLOWLIST_INVALID")); } Ok(Some(units)) } impl RootLogPolicy { fn valid(&self) -> bool { self.schema_version == 1 && valid_log_units(&self.allowed_units) && valid_log_units(&self.sensitive_units) } } impl RootPolicy { fn sensitive_log_unit(&self, job: &JobPayload, unit: &str, extra: Option<&[String]>) -> bool { matches!(unit, "ssh.service" | "sshd.service" | "auditd.service" | "systemd-logind.service") || (unit.starts_with("sshd@") && unit.ends_with(".service")) || extra.is_some_and(|units| units.iter().any(|u| u == unit)) // Classification is shared across matching target scopes, not just // the first scope/actor that grants a unit. Another scope cannot // silently declassify a sensitive source. || self.scopes.iter().any(|scope| scope.matches_target(job) && scope.root_logs.as_ref().is_some_and(|logs| logs.sensitive_units.iter().any(|u| u == unit))) } } fn required_permissions(job: &JobPayload, sensitive_log: bool) -> Vec<&'static str> { let mut permissions = vec!["root:execute"]; if matches!(job.action, Action::AptNativeAcceptance { .. }) { permissions.push("apt:native_acceptance"); } if matches!(job.action, Action::QueryLogs { .. }) { permissions.push("logs:read"); if sensitive_log { permissions.push("logs:read_sensitive"); } } permissions } #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct RootAptPolicy { allow_native_acceptance: bool, allow_execute: bool, provider_sha256: String, hook_sha256: String, apt_config_sha256: String, runtime_sha256: String, } impl RootAptPolicy { fn permits( &self, m: &rmm_domain::apt_transaction::AptExecutionManifest, native: bool, caps: &[String], ) -> bool { m.validate() && if native { self.allow_native_acceptance && caps.iter().any(|c| c == "apt.native-acceptance.v1") } else { self.allow_execute && caps.iter().any(|c| c == "apt.native-accepted.v1") } && caps.iter().any(|c| c == "apt.manifest.v2") && m.provider_sha256 == self.provider_sha256 && m.hook_sha256 == self.hook_sha256 && m.apt_config_sha256 == self.apt_config_sha256 && m.runtime_sha256 == self.runtime_sha256 } } impl RootScope { fn matches_target(&self, job: &JobPayload) -> bool { self.tenant_id == job.tenant_id && self.asset_id == job.asset_id && self.agent_id == job.agent_id && self.enrollment_generation == job.enrollment_generation && self.assignment_version == job.assignment_version } fn permits( &self, principal: &str, job: &JobPayload, capabilities: &[String], global_log_units: Option<&[String]>, ) -> bool { if job.execution_identity != "root" || capabilities.iter().any(|c| c == "windows.base/1") { return false; } if !self.matches_target(job) || !self.principals.iter().any(|p| p == principal) || self.helper_policy_sha256.len() != 64 || !self .helper_policy_sha256 .bytes() .all(|c| c.is_ascii_digit() || b"abcdef".contains(&c)) || self.acceptance_evidence_id.trim().is_empty() { return false; } if ![ "rmm.sync.v1".to_string(), "helper.root.v1".to_string(), format!("helper.policy.sha256:{}", self.helper_policy_sha256), format!("root:{}", job.action.name()), job.action.name().into(), ] .iter() .all(|cap| capabilities.contains(cap)) { return false; } if job.max_output_bytes > 65536 { return false; } match &job.action { Action::QueryLogs { unit, since, until, max_lines, } => { let allowed = match &self.root_logs { Some(logs) => { logs.valid() && logs.allowed_units.contains(unit) && global_log_units.is_none_or(|units| units.iter().any(|u| u == unit)) } None => global_log_units.is_some_and(|units| units.iter().any(|u| u == unit)), }; allowed && valid_log_unit(unit) && since.timestamp() >= 0 && since < until && *until - *since <= chrono::Duration::hours(24) && (1..=1000).contains(max_lines) && (20..=3600).contains(&job.max_runtime_seconds) && (1..=65536).contains(&job.max_output_bytes) } Action::RunScript { .. } => self.allow_root_scripts && job.max_runtime_seconds <= 300, Action::SetServiceState { unit, state } => { self.allowed_services.contains(unit) && matches!(state.as_str(), "running" | "stopped") && job.max_runtime_seconds >= 180 } Action::Reboot { .. } => self.allow_reboot && job.max_runtime_seconds >= 60, Action::AptNativeAcceptance { apt_manifest: m, .. } => { job.max_runtime_seconds >= 180 && self .apt .as_ref() .is_some_and(|p| p.permits(m, true, capabilities)) } Action::EnsurePackage { apt_manifest: Some(m), .. } | Action::ApplyUpdates { apt_manifest: Some(m), .. } => { job.max_runtime_seconds >= 180 && self .apt .as_ref() .is_some_and(|p| p.permits(m, false, capabilities)) } // Legacy package actions never gain authority from a capability. _ => false, } } } fn load() -> Result { let disabled = || Error(StatusCode::CONFLICT, "UNSUPPORTED_CAPABILITY"); if std::env::var("RMM_PROFILE").as_deref() != Ok("development") || std::env::var("RMM_DEV_ROOT_ENABLED").as_deref() != Ok("true") { return Err(disabled()); } let path = std::env::var("RMM_DEV_ROOT_POLICY_FILE").map_err(|_| disabled())?; let metadata = fs::symlink_metadata(&path).map_err(|_| disabled())?; let key = std::env::var("RMM_JOB_KEY_FILE").unwrap_or_else(|_| "devstate/jobs/ed25519.pem".into()); let owner = fs::metadata(key).map_err(|_| disabled())?.uid(); let parent = Path::new(&path).parent().ok_or_else(disabled)?; let parent_meta = fs::symlink_metadata(parent).map_err(|_| disabled())?; if !metadata.is_file() || metadata.permissions().mode() & 0o077 != 0 || metadata.uid() != owner || metadata.len() > 65536 || !parent_meta.is_dir() || parent_meta.permissions().mode() & 0o022 != 0 { return Err(disabled()); } let policy: RootPolicy = serde_json::from_slice(&fs::read(path).map_err(|_| disabled())?).map_err(|_| disabled())?; if policy.schema_version != 1 || policy.profile != "development" || policy.expires_at <= Utc::now() || policy.scopes.is_empty() || policy.scopes.len() > 64 || policy .scopes .iter() .any(|scope| scope.root_logs.as_ref().is_some_and(|logs| !logs.valid())) { return Err(disabled()); } Ok(policy) } pub fn execution_permission(identity: &str) -> Option<&'static str> { match identity { "root" => Some("root:execute"), "system" => Some("system:execute"), _ => None, } } pub fn needs_helper(identity: &str) -> bool { execution_permission(identity).is_some() } pub async fn authorize( tx: &mut Transaction<'_, Postgres>, principal: &str, job: &JobPayload, ) -> Result<(), Error> { match job.execution_identity.as_str() { "system" => return crate::windows_policy::authorize(tx, principal, job).await, "agent_service" => return Ok(()), "root" => {} _ => return Err(Error(StatusCode::FORBIDDEN, "EXECUTION_IDENTITY_DENIED")), } for permission in required_permissions(job, false) { crate::permissions::require(tx, principal, permission).await?; } let policy = load()?; let global_log_units = if matches!(job.action, Action::QueryLogs { .. }) { parse_log_units(std::env::var("RMM_ROOT_LOG_UNITS").ok().as_deref())? } else { None }; if let Action::QueryLogs { unit, .. } = &job.action { let sensitive_units = parse_log_units( std::env::var("RMM_ROOT_SENSITIVE_LOG_UNITS") .ok() .as_deref(), )?; if policy.sensitive_log_unit(job, unit, sensitive_units.as_deref()) { // Re-read current membership on every planning/approval/start call. // No policy flag, viewer role, capability or test profile grants it. crate::permissions::require(tx, principal, "logs:read_sensitive").await?; } } let caps:serde_json::Value=sqlx::query_scalar("SELECT capabilities FROM agent_installations WHERE agent_id=$1 AND asset_id=$2 AND revoked_at IS NULL AND enrollment_generation=$3 AND assignment_version=$4").bind(job.agent_id).bind(job.asset_id).bind(i64::try_from(job.enrollment_generation).map_err(|_|Error(StatusCode::CONFLICT,"BINDING_MISMATCH"))?).bind(i64::try_from(job.assignment_version).map_err(|_|Error(StatusCode::CONFLICT,"BINDING_MISMATCH"))?).fetch_optional(&mut **tx).await?.ok_or(Error(StatusCode::CONFLICT,"AUTHORIZATION_REVOKED"))?; let caps: Vec = serde_json::from_value(caps)?; if !policy .scopes .iter() .any(|scope| scope.permits(principal, job, &caps, global_log_units.as_deref())) { return Err(Error( StatusCode::FORBIDDEN, "ROOT_SCOPE_OR_HELPER_POLICY_DENIED", )); } Ok(()) } #[cfg(test)] mod tests { use super::*; #[test] fn no_capability_or_relabel_shortcut() { let id = Uuid::new_v4(); let now = Utc::now(); let job = JobPayload { schema_version: 1, tenant_id: id, asset_id: id, agent_id: id, enrollment_generation: 1, assignment_version: 1, job_id: id, attempt_id: id, action: Action::RunScript { interpreter: "posix_sh".into(), script_utf8: "true\n".into(), arguments: vec![], expected_stdout: None, windows_execution_profile: None, }, execution_identity: "root".into(), not_before: now, start_before: now + chrono::Duration::hours(1), max_runtime_seconds: 60, max_output_bytes: 1024, }; let scope = RootScope { tenant_id: id, asset_id: id, agent_id: id, enrollment_generation: 1, assignment_version: 1, principals: vec!["selected".into()], helper_policy_sha256: "ab".repeat(32), acceptance_evidence_id: "native-test-record".into(), allowed_services: vec![], allow_root_scripts: true, allow_reboot: false, apt: None, root_logs: None, }; let caps = vec![ "rmm.sync.v1".into(), "helper.root.v1".into(), format!("helper.policy.sha256:{}", "ab".repeat(32)), "root:run_script".into(), "run_script".into(), ]; assert!(scope.permits("selected", &job, &caps, None)); assert!(!scope.permits("automation", &job, &caps, None)); assert!(!scope.permits("selected", &job, &caps[..4], None)); let mut windows = caps; windows.push("windows.base/1".into()); assert!(!scope.permits("selected", &job, &windows, None)); } } #[cfg(test)] #[path = "../../../tests/backend_root_logs.rs"] mod root_log_tests;