227 lines
8.0 KiB
Rust
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));
|
|
}
|