Files
rust-discovery/tests/backend_root_logs.rs
T
BuTzZ 6c3203d725
Rust development slice / linux (push) Failing after 1m10s
feat: snapshot Linux-first RMM MVP and pause handover
2026-11-12 22:06:25 +01:00

227 lines
8.0 KiB
Rust

//! Pure backend policy/permission requirements: no DB memberships, approval,
//! journald reads, helper invocation or root effects are manufactured here.
use super::*;
fn fixture() -> (RootScope, JobPayload, Vec<String>) {
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: Uuid::new_v4(),
attempt_id: Uuid::new_v4(),
action: Action::QueryLogs {
unit: "rmm-acceptance.service".into(),
since: now - chrono::Duration::minutes(5),
until: now,
max_lines: 100,
},
execution_identity: "root".into(),
not_before: now,
start_before: now + chrono::Duration::hours(1),
max_runtime_seconds: 20,
max_output_bytes: 65536,
};
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: "reviewed-helper-record".into(),
allowed_services: vec!["mutation-only.service".into()],
allow_root_scripts: false,
allow_reboot: false,
apt: None,
root_logs: Some(RootLogPolicy {
schema_version: 1,
allowed_units: vec!["rmm-acceptance.service".into()],
sensitive_units: vec![],
}),
};
let caps = vec![
"rmm.sync.v1".into(),
"helper.root.v1".into(),
format!("helper.policy.sha256:{}", "ab".repeat(32)),
"root:query_logs".into(),
"query_logs".into(),
];
(scope, job, caps)
}
#[test]
fn exact_root_log_plan_shape_and_selected_scope() {
let (scope, job, caps) = fixture();
assert!(job.action.validate());
assert!(scope.permits("selected", &job, &caps, None));
assert!(!scope.permits("viewer", &job, &caps, None));
let mut foreign = job.clone();
foreign.tenant_id = Uuid::new_v4();
assert!(!scope.permits("selected", &foreign, &caps, None));
foreign = job.clone();
foreign.asset_id = Uuid::new_v4();
assert!(!scope.permits("selected", &foreign, &caps, None));
foreign = job.clone();
foreign.assignment_version += 1;
assert!(!scope.permits("selected", &foreign, &caps, None));
foreign = job.clone();
foreign.execution_identity = "agent_service".into();
assert!(!scope.permits("selected", &foreign, &caps, None));
assert!(!scope.permits("selected", &job, &caps[..4], None));
}
#[test]
fn default_empty_and_service_mutation_list_never_authorize_logs() {
let (mut scope, job, caps) = fixture();
scope.root_logs = None;
scope.allowed_services.push("rmm-acceptance.service".into());
assert!(!scope.permits("selected", &job, &caps, None));
let units = vec!["rmm-acceptance.service".into()];
assert!(scope.permits("selected", &job, &caps, Some(&units)));
scope.root_logs = Some(RootLogPolicy {
schema_version: 1,
allowed_units: vec![],
sensitive_units: vec![],
});
assert!(!scope.permits("selected", &job, &caps, Some(&units)));
}
#[test]
fn scoped_allowlist_and_global_ceiling_are_exact() {
let (scope, mut job, caps) = fixture();
assert!(!scope.permits("selected", &job, &caps, Some(&[])));
let foreign = vec!["other.service".into()];
assert!(!scope.permits("selected", &job, &caps, Some(&foreign)));
if let Action::QueryLogs { unit, .. } = &mut job.action {
*unit = "mutation-only.service".into();
}
assert!(!scope.permits("selected", &job, &caps, None));
}
#[test]
fn exact_log_bounds_not_rounded_hours() {
let (scope, job, caps) = fixture();
for lines in [0, 1001] {
let mut bad = job.clone();
if let Action::QueryLogs { max_lines, .. } = &mut bad.action {
*max_lines = lines;
}
assert!(!scope.permits("selected", &bad, &caps, None));
}
for runtime in [0, 19, 3601] {
let mut bad = job.clone();
bad.max_runtime_seconds = runtime;
assert!(!scope.permits("selected", &bad, &caps, None));
}
for output in [0, 65537] {
let mut bad = job.clone();
bad.max_output_bytes = output;
assert!(!scope.permits("selected", &bad, &caps, None));
}
let mut bad = job.clone();
if let Action::QueryLogs { since, until, .. } = &mut bad.action {
*since = *until - chrono::Duration::hours(24) - chrono::Duration::nanoseconds(1);
}
assert!(!scope.permits("selected", &bad, &caps, None));
if let Action::QueryLogs { since, until, .. } = &mut bad.action {
*since = chrono::DateTime::from_timestamp(-1, 0).unwrap();
*until = chrono::DateTime::from_timestamp(1, 0).unwrap();
}
assert!(!scope.permits("selected", &bad, &caps, None));
if let Action::QueryLogs { since, until, .. } = &mut bad.action {
*since = *until;
}
assert!(!scope.permits("selected", &bad, &caps, None));
}
#[test]
fn env_lists_are_bounded_data_not_paths_wildcards_or_bools() {
assert!(parse_log_units(None).unwrap().is_none());
assert_eq!(parse_log_units(Some("")).unwrap(), Some(vec![]));
assert_eq!(
parse_log_units(Some(r#"["rmm-acceptance.service"]"#)).unwrap(),
Some(vec!["rmm-acceptance.service".into()])
);
for raw in [
"true",
r#""/tmp/units""#,
r#"["*.service"]"#,
r#"["../ssh.service"]"#,
r#"["-x.service"]"#,
r#"["x.service","x.service"]"#,
] {
assert!(parse_log_units(Some(raw)).is_err());
}
let too_many = serde_json::to_string(
&(0..129)
.map(|i| format!("u{i}.service"))
.collect::<Vec<_>>(),
)
.unwrap();
assert!(parse_log_units(Some(&too_many)).is_err());
}
#[test]
fn classification_cannot_be_bypassed_by_another_scope_or_empty_env() {
let (mut scope, job, _) = fixture();
scope
.root_logs
.as_mut()
.unwrap()
.sensitive_units
.push("rmm-acceptance.service".into());
let mut policy = RootPolicy {
schema_version: 1,
profile: "development".into(),
expires_at: Utc::now() + chrono::Duration::hours(1),
scopes: vec![scope],
};
let (mut other, _, _) = fixture();
other.tenant_id = job.tenant_id;
other.asset_id = job.asset_id;
other.agent_id = job.agent_id;
other.principals = vec!["another-actor".into()];
policy.scopes.push(other);
assert!(policy.sensitive_log_unit(&job, "rmm-acceptance.service", Some(&[])));
for unit in [
"ssh.service",
"sshd.service",
"sshd@fixture.service",
"auditd.service",
"systemd-logind.service",
] {
assert!(policy.sensitive_log_unit(&job, unit, Some(&[])));
}
assert!(policy.sensitive_log_unit(&job, "custom.service", Some(&["custom.service".into()])));
assert!(!policy.sensitive_log_unit(&job, "ordinary.service", None));
}
#[test]
fn permissions_are_separate_root_read_and_sensitive_requirements() {
let (_, job, _) = fixture();
let normal = required_permissions(&job, false);
assert_eq!(normal, vec!["root:execute", "logs:read"]);
let sensitive = required_permissions(&job, true);
assert_eq!(
sensitive,
vec!["root:execute", "logs:read", "logs:read_sensitive"]
);
for rights in [
vec!["inventory:read"],
vec!["logs:read"],
vec!["root:execute"],
] {
assert!(!normal.iter().all(|p| rights.contains(p)));
}
let operator = ["root:execute", "logs:read"];
assert!(normal.iter().all(|p| operator.contains(p)));
assert!(!sensitive.iter().all(|p| operator.contains(p)));
let privileged = ["root:execute", "logs:read", "logs:read_sensitive"];
assert!(sensitive.iter().all(|p| privileged.contains(p)));
}
#[test]
fn unknown_log_profile_version_denies() {
let (mut scope, job, caps) = fixture();
scope.root_logs.as_mut().unwrap().schema_version = 2;
assert!(!scope.permits("selected", &job, &caps, None));
}