feat: snapshot Linux-first RMM MVP and pause handover
Rust development slice / linux (push) Failing after 1m10s
Rust development slice / linux (push) Failing after 1m10s
This commit is contained in:
@@ -0,0 +1,382 @@
|
||||
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<Utc>,
|
||||
scopes: Vec<RootScope>,
|
||||
}
|
||||
#[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<String>,
|
||||
helper_policy_sha256: String,
|
||||
acceptance_evidence_id: String,
|
||||
allowed_services: Vec<String>,
|
||||
allow_root_scripts: bool,
|
||||
allow_reboot: bool,
|
||||
#[serde(default)]
|
||||
apt: Option<RootAptPolicy>,
|
||||
#[serde(default)]
|
||||
root_logs: Option<RootLogPolicy>,
|
||||
}
|
||||
#[derive(Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
struct RootLogPolicy {
|
||||
schema_version: u32,
|
||||
allowed_units: Vec<String>,
|
||||
#[serde(default)]
|
||||
sensitive_units: Vec<String>,
|
||||
}
|
||||
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::<std::collections::BTreeSet<_>>();
|
||||
units.len() <= 128 && distinct.len() == units.len() && units.iter().all(|u| valid_log_unit(u))
|
||||
}
|
||||
fn parse_log_units(raw: Option<&str>) -> Result<Option<Vec<String>>, Error> {
|
||||
let Some(raw) = raw else { return Ok(None) };
|
||||
// Explicit empty environment means deny-all, never an implicit wildcard.
|
||||
let units: Vec<String> = 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" {
|
||||
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<RootPolicy, Error> {
|
||||
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 async fn authorize(
|
||||
tx: &mut Transaction<'_, Postgres>,
|
||||
principal: &str,
|
||||
job: &JobPayload,
|
||||
) -> Result<(), Error> {
|
||||
if job.execution_identity != "root" {
|
||||
return Ok(());
|
||||
}
|
||||
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<String> = 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,
|
||||
},
|
||||
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));
|
||||
}
|
||||
}
|
||||
#[cfg(test)]
|
||||
#[path = "../../../tests/backend_root_logs.rs"]
|
||||
mod root_log_tests;
|
||||
Reference in New Issue
Block a user