//! 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) { 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::>(), ) .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)); }