Files
rust-discovery/crates/server/src/windows_policy.rs
T

787 lines
33 KiB
Rust

//! Independent development-only Windows SYSTEM ceiling. Policy never approves a
//! plan, publishes a capability, provisions a helper or substitutes for Sync.
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::{self, File},
io::Read,
os::unix::fs::{MetadataExt, PermissionsExt},
path::Path,
};
use uuid::Uuid;
const POLICY_LIMIT: u64 = 65536;
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct SystemPolicy {
schema_version: u32,
profile: String,
expires_at: DateTime<Utc>,
scopes: Vec<SystemScope>,
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct SystemScope {
tenant_id: Uuid,
asset_id: Uuid,
agent_id: Uuid,
enrollment_generation: u64,
assignment_version: u64,
principals: Vec<String>,
helper_policy_sha256: String,
helper_binary_sha256: String,
// Administrative evidence pin, never an approval or authorization ID.
acceptance_evidence_id: Uuid,
allowed_services: Vec<String>,
#[serde(default, deserialize_with = "strict_optional_hashes")]
allowed_script_sha256: Option<Vec<String>>,
#[serde(default, deserialize_with = "strict_optional_hashes")]
allowed_msi_recipe_sha256: Option<Vec<String>>,
max_runtime_seconds: u32,
#[serde(
default,
deserialize_with = "rmm_domain::jobs::deserialize_script_profiles"
)]
allowed_script_profiles: Option<Vec<rmm_domain::jobs::PrivilegedScriptProfile>>,
#[serde(default)]
windows_update_max_runtime_seconds: Option<u32>,
#[serde(default, deserialize_with = "strict_optional_reboot")]
allow_reboot: Option<bool>,
}
fn strict_optional_reboot<'de, D: serde::Deserializer<'de>>(
d: D,
) -> Result<Option<bool>, D::Error> {
bool::deserialize(d).map(Some)
}
fn strict_optional_hashes<'de, D>(deserializer: D) -> Result<Option<Vec<String>>, D::Error>
where
D: serde::Deserializer<'de>,
{
Vec::<String>::deserialize(deserializer).map(Some)
}
fn digest(value: &str) -> bool {
value.len() == 64
&& value
.bytes()
.all(|c| c.is_ascii_digit() || b"abcdef".contains(&c))
}
fn fixture_service(name: &str) -> bool {
name.starts_with("RmmDiscoveryFixture")
&& name.len() > "RmmDiscoveryFixture".len()
&& name.len() <= 80
&& name
.bytes()
.all(|c| c.is_ascii_alphanumeric() || b"_-".contains(&c))
}
impl SystemScope {
pub(crate) fn valid(&self) -> bool {
!self.tenant_id.is_nil()
&& !self.asset_id.is_nil()
&& !self.agent_id.is_nil()
&& self.enrollment_generation > 0
&& self.assignment_version > 0
&& !self.acceptance_evidence_id.is_nil()
&& digest(&self.helper_policy_sha256)
&& digest(&self.helper_binary_sha256)
&& !self.principals.is_empty()
&& self.principals.len() <= 64
&& self
.principals
.iter()
.all(|p| !p.trim().is_empty() && p.len() <= 256)
&& self
.principals
.iter()
.collect::<std::collections::BTreeSet<_>>()
.len()
== self.principals.len()
&& self.allowed_script_sha256.as_ref().is_none_or(|hashes| {
hashes.len() <= 64
&& hashes.iter().all(|h| digest(h))
&& hashes
.iter()
.collect::<std::collections::BTreeSet<_>>()
.len()
== hashes.len()
})
&& self.allowed_services.len() <= 16
&& self
.allowed_services
.iter()
.all(|name| fixture_service(name))
&& self
.allowed_services
.iter()
.collect::<std::collections::BTreeSet<_>>()
.len()
== self.allowed_services.len()
&& self
.allowed_msi_recipe_sha256
.as_ref()
.is_none_or(|hashes| {
hashes.len() <= 2
&& hashes.iter().all(|h| digest(h))
&& hashes
.iter()
.collect::<std::collections::BTreeSet<_>>()
.len()
== hashes.len()
})
&& self
.allowed_script_profiles
.as_deref()
.is_none_or(|v| v == [rmm_domain::jobs::PrivilegedScriptProfile::FullMaintenanceV1])
&& rmm_domain::jobs::valid_windows_update_limit(self.windows_update_max_runtime_seconds)
&& (1..=120).contains(&self.max_runtime_seconds)
}
pub(crate) fn permits(
&self,
principal: &str,
job: &JobPayload,
capabilities: &[String],
allow_msi: bool,
allow_scripts: bool,
allow_reboot: bool,
) -> bool {
let has = |cap: &str| capabilities.iter().any(|c| c == cap);
self.valid()
&& job.execution_identity == "system"
&& 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
&& self.principals.iter().any(|p| p == principal)
&& has("windows.base/1")
&& !has("linux.base/1")
&& has("rmm.sync.v1")
&& has("helper.system.v1")
&& has(&format!(
"helper.policy.sha256:{}",
self.helper_policy_sha256
))
&& has(&format!(
"helper.binary.sha256:{}",
self.helper_binary_sha256
))
&& (1..=job.action.windows_system_runtime_limit(
self.max_runtime_seconds,
self.windows_update_max_runtime_seconds,
))
.contains(&job.max_runtime_seconds)
&& (job.max_runtime_seconds <= 120
|| has(rmm_domain::jobs::WINDOWS_UPDATE_LONG_CAPABILITY))
&& (1..=65536).contains(&job.max_output_bytes)
&& match &job.action {
Action::Reboot { .. } => {
allow_reboot
&& self.allow_reboot == Some(true)
&& rmm_domain::windows_reboot::supported(job)
&& job.action.available_for("system", capabilities)
}
Action::SetServiceState { unit, state } => {
self.allowed_services.contains(unit)
&& matches!(state.as_str(), "running" | "stopped")
&& has("system:set_service_state")
&& has("set_service_state")
}
Action::RunScript {
script_utf8,
arguments,
..
} => {
allow_scripts
&& self.allowed_script_sha256.as_ref().is_none_or(|hashes| {
arguments.is_empty()
&& hashes.contains(&rmm_domain::jobs::hash(script_utf8.as_bytes()))
})
&& job.action.full_maintenance()
&& (self.allowed_script_profiles.as_ref().is_some_and(|v| {
v.contains(
&rmm_domain::jobs::PrivilegedScriptProfile::FullMaintenanceV1,
)
}) || (self.windows_update_max_runtime_seconds.is_some()
&& job.action.windows_update_or_identity_probe()))
&& job.action.validate()
&& job
.action
.valid_job_limits(job.max_runtime_seconds, job.max_output_bytes)
&& job.action.available_for("system", capabilities)
}
_ if allow_msi => job.action.windows_msi().is_some_and(|m| {
job.action.validate()
&& job
.action
.valid_job_limits(job.max_runtime_seconds, job.max_output_bytes)
&& self
.allowed_msi_recipe_sha256
.as_ref()
.is_some_and(|hashes| hashes.contains(&m.recipe_sha256))
&& has("ensure_package")
&& has("system:ensure_package")
&& has(rmm_domain::windows_execution::MSI_CAPABILITY)
}),
_ => false,
}
}
}
impl SystemPolicy {
fn valid(&self, now: DateTime<Utc>) -> bool {
matches!(self.schema_version, 1..=4)
&& (self.schema_version >= 2
|| self
.scopes
.iter()
.all(|scope| scope.allowed_msi_recipe_sha256.is_none()))
&& (self.schema_version >= 3
|| self
.scopes
.iter()
.all(|scope| scope.allowed_script_profiles.is_none()))
&& (self.schema_version == 4
|| self.scopes.iter().all(|scope| scope.allow_reboot.is_none()))
&& self.profile == "development"
&& self.expires_at > now
&& !self.scopes.is_empty()
&& self.scopes.len() <= 64
&& self.scopes.iter().all(SystemScope::valid)
}
fn permits(
&self,
principal: &str,
job: &JobPayload,
capabilities: &[String],
now: DateTime<Utc>,
) -> bool {
self.valid(now)
&& self.scopes.iter().any(|scope| {
scope.permits(
principal,
job,
capabilities,
self.schema_version >= 2,
self.schema_version >= 3,
self.schema_version == 4,
)
})
}
}
fn disabled() -> Error {
Error(StatusCode::CONFLICT, "UNSUPPORTED_CAPABILITY")
}
fn no_symlink_components(path: &Path) -> Result<(), Error> {
let absolute = if path.is_absolute() {
path.to_path_buf()
} else {
std::env::current_dir().map_err(|_| disabled())?.join(path)
};
for component in absolute.ancestors() {
if fs::symlink_metadata(component)
.map_err(|_| disabled())?
.file_type()
.is_symlink()
{
return Err(disabled());
}
}
Ok(())
}
fn protected_parent_chain(path: &Path, owner: u32) -> Result<(), Error> {
// A private immediate parent can itself be renamed through an unsafe
// ancestor. Trust every directory owner, and reject writable ancestors
// unless their sticky bit protects the trusted-owned next component.
// This deliberately preserves /tmp's root-owned sticky-directory contract.
let absolute = if path.is_absolute() {
path.to_path_buf()
} else {
std::env::current_dir().map_err(|_| disabled())?.join(path)
};
for ancestor in absolute.ancestors().skip(1) {
let directory = fs::symlink_metadata(ancestor).map_err(|_| disabled())?;
let mode = directory.permissions().mode();
if !directory.is_dir()
|| ![0, owner].contains(&directory.uid())
|| (mode & 0o022 != 0 && mode & 0o1000 == 0)
{
return Err(disabled());
}
}
Ok(())
}
pub(crate) fn protected_bytes(path: &Path, owner: u32) -> Result<Vec<u8>, Error> {
no_symlink_components(path)?;
protected_parent_chain(path, owner)?;
let before = fs::symlink_metadata(path).map_err(|_| disabled())?;
let parent = path.parent().ok_or_else(disabled)?;
let directory = fs::symlink_metadata(parent).map_err(|_| disabled())?;
if !before.is_file()
|| before.uid() != owner
|| before.permissions().mode() & 0o777 != 0o600
|| before.len() > POLICY_LIMIT
|| !directory.is_dir()
|| ![0, owner].contains(&directory.uid())
|| directory.permissions().mode() & 0o022 != 0
{
return Err(disabled());
}
// The protected immediate parent excludes unprivileged swaps. Additionally
// bind the opened descriptor to the lstat identity and bound the actual read.
let mut file = File::open(path).map_err(|_| disabled())?;
let opened = file.metadata().map_err(|_| disabled())?;
if opened.dev() != before.dev() || opened.ino() != before.ino() {
return Err(disabled());
}
let mut bytes = Vec::new();
file.by_ref()
.take(POLICY_LIMIT + 1)
.read_to_end(&mut bytes)
.map_err(|_| disabled())?;
no_symlink_components(path)?;
protected_parent_chain(path, owner)?;
let after = fs::symlink_metadata(path).map_err(|_| disabled())?;
if bytes.len() as u64 > POLICY_LIMIT
|| !after.is_file()
|| after.dev() != before.dev()
|| after.ino() != before.ino()
|| after.uid() != owner
|| after.permissions().mode() & 0o777 != 0o600
|| after.len() != before.len()
|| after.mtime() != before.mtime()
|| after.mtime_nsec() != before.mtime_nsec()
{
return Err(disabled());
}
Ok(bytes)
}
fn load() -> Result<SystemPolicy, Error> {
if std::env::var("RMM_PROFILE").as_deref() != Ok("development")
|| std::env::var("RMM_DEV_SYSTEM_ENABLED").as_deref() != Ok("true")
{
return Err(disabled());
}
let path = std::env::var("RMM_DEV_SYSTEM_POLICY_FILE").map_err(|_| disabled())?;
let key =
std::env::var("RMM_JOB_KEY_FILE").unwrap_or_else(|_| "devstate/jobs/ed25519.pem".into());
// Inspect only signing-key metadata, never read/log/export the private key.
no_symlink_components(Path::new(&key))?;
let key = fs::symlink_metadata(key).map_err(|_| disabled())?;
if !key.is_file() {
return Err(disabled());
}
let policy: SystemPolicy =
serde_json::from_slice(&protected_bytes(Path::new(&path), key.uid())?)
.map_err(|_| disabled())?;
if !policy.valid(Utc::now()) {
return Err(disabled());
}
Ok(policy)
}
pub async fn authorize(
tx: &mut Transaction<'_, Postgres>,
principal: &str,
job: &JobPayload,
) -> Result<(), Error> {
if job.execution_identity != "system" {
return Err(Error(StatusCode::FORBIDDEN, "SYSTEM_IDENTITY_REQUIRED"));
}
// Independent DB permission; root:execute never implies this scope.
crate::permissions::require(tx, principal, "system:execute").await?;
if matches!(job.action, Action::RunScript { .. }) {
crate::permissions::require(tx, principal, "scripts:execute").await?;
}
let caps:serde_json::Value=sqlx::query_scalar("SELECT capabilities FROM agent_installations WHERE tenant_id=$1 AND agent_id=$2 AND asset_id=$3 AND revoked_at IS NULL AND enrollment_generation=$4 AND assignment_version=$5").bind(job.tenant_id).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 capabilities: Vec<String> = serde_json::from_value(caps)?;
if crate::managed_scripts::permits(tx, principal, job, &capabilities).await? {
return Ok(());
}
let policy = load()?;
if !policy.permits(principal, job, &capabilities, Utc::now()) {
return Err(Error(
StatusCode::FORBIDDEN,
"SYSTEM_SCOPE_OR_HELPER_POLICY_DENIED",
));
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
#[test]
fn reboot_needs_v4_independent_opt_in_capabilities_and_exact_fixed_window() {
let (mut p, mut job, mut caps) = fixture();
job.action = Action::Reboot {
reason: "Einzelne Windows-MVP-Abnahme".into(),
dependency_group: "windows-mvp".into(),
reconnect_timeout_seconds: 180,
};
job.max_runtime_seconds = 60;
p.scopes[0].max_runtime_seconds = 120;
caps.extend(
[
"reboot",
"system:reboot",
rmm_domain::windows_reboot::CAPABILITY,
]
.map(str::to_string),
);
for version in 1..=4 {
p.schema_version = version;
assert!(!p.permits("selected", &job, &caps, Utc::now()));
}
p.scopes[0].allow_reboot = Some(true);
for version in 1..=3 {
p.schema_version = version;
assert!(!p.permits("selected", &job, &caps, Utc::now()));
}
p.schema_version = 4;
assert!(p.permits("selected", &job, &caps, Utc::now()));
assert!(!p.permits("foreign", &job, &caps, Utc::now()));
let complete = caps.clone();
caps.retain(|c| c != "system:reboot");
assert!(!p.permits("selected", &job, &caps, Utc::now()));
caps = complete;
job.execution_identity = "agent_service".into();
assert!(!p.permits("selected", &job, &caps, Utc::now()));
job.execution_identity = "system".into();
if let Action::Reboot {
reconnect_timeout_seconds,
..
} = &mut job.action
{
*reconnect_timeout_seconds = 181;
}
assert!(!p.permits("selected", &job, &caps, Utc::now()));
let invalid = json!({"schema_version":4,"profile":"development","expires_at":Utc::now(),"scopes":[{"allow_reboot":null}]});
assert!(serde_json::from_value::<SystemPolicy>(invalid).is_err());
}
fn fixture() -> (SystemPolicy, JobPayload, Vec<String>) {
let id = Uuid::new_v4();
let now = Utc::now();
let policy:SystemPolicy=serde_json::from_value(json!({"schema_version":1,"profile":"development","expires_at":now+chrono::Duration::minutes(10),"scopes":[{"tenant_id":id,"asset_id":id,"agent_id":id,"enrollment_generation":1,"assignment_version":1,"principals":["selected"],"helper_policy_sha256":"ab".repeat(32),"helper_binary_sha256":"cd".repeat(32),"acceptance_evidence_id":Uuid::new_v4(),"allowed_services":["RmmDiscoveryFixtureService"],"max_runtime_seconds":30}]})).unwrap();
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::SetServiceState {
unit: "RmmDiscoveryFixtureService".into(),
state: "running".into(),
},
execution_identity: "system".into(),
not_before: now,
start_before: now + chrono::Duration::minutes(5),
max_runtime_seconds: 30,
max_output_bytes: 4096,
};
let caps = vec![
"windows.base/1".into(),
"rmm.sync.v1".into(),
"helper.system.v1".into(),
format!("helper.policy.sha256:{}", "ab".repeat(32)),
format!("helper.binary.sha256:{}", "cd".repeat(32)),
"system:set_service_state".into(),
"set_service_state".into(),
];
(policy, job, caps)
}
#[test]
fn system_permission_and_helper_requirement_are_distinct_from_root() {
let id = Uuid::new_v4();
let principal = crate::auth::Principal {
tenant: id,
name: "root-only".into(),
operator: true,
session_hash: None,
csrf: None,
scopes: Some(std::collections::BTreeSet::from(["root:execute".into()])),
testsimulation: false,
identity: None,
tenants: vec![id],
};
assert!(principal.permits_scope(crate::root_policy::execution_permission("root").unwrap()));
assert!(
!principal.permits_scope(crate::root_policy::execution_permission("system").unwrap())
);
assert!(crate::root_policy::needs_helper("system"));
assert!(crate::root_policy::needs_helper("root"));
assert!(!crate::root_policy::needs_helper("agent_service"));
let (policy, job, caps) = fixture();
let mut empty = policy;
empty.scopes.clear();
assert!(!empty.permits("selected", &job, &caps, Utc::now()));
}
#[test]
fn exact_system_scope_never_inherits_root_or_other_device_authority() {
let (policy, job, caps) = fixture();
let now = Utc::now();
assert!(policy.permits("selected", &job, &caps, now));
assert!(!policy.permits("root-operator", &job, &caps, now));
for identity in ["root", "agent_service", "SYSTEM"] {
let mut other = job.clone();
other.execution_identity = identity.into();
assert!(!policy.permits("selected", &other, &caps, now));
}
for field in ["tenant", "asset", "agent", "enrollment", "assignment"] {
let mut other = job.clone();
match field {
"tenant" => other.tenant_id = Uuid::new_v4(),
"asset" => other.asset_id = Uuid::new_v4(),
"agent" => other.agent_id = Uuid::new_v4(),
"enrollment" => other.enrollment_generation += 1,
_ => other.assignment_version += 1,
}
assert!(!policy.permits("selected", &other, &caps, now));
}
for i in 0..caps.len() {
let mut missing = caps.clone();
missing.remove(i);
assert!(!policy.permits("selected", &job, &missing, now));
}
let mut mixed = caps.clone();
mixed.push("linux.base/1".into());
assert!(!policy.permits("selected", &job, &mixed, now));
let mut wrong = caps.clone();
wrong[4] = format!("helper.binary.sha256:{}", "ef".repeat(32));
assert!(!policy.permits("selected", &job, &wrong, now));
assert!(!policy.permits("selected", &job, &caps, policy.expires_at));
}
#[test]
fn full_script_requires_v3_explicit_scope_and_does_not_inherit_scm_or_msi() {
let (mut policy, mut job, mut caps) = fixture();
job.action = Action::RunScript {
interpreter: "powershell".into(),
script_utf8: "Write-Output 'hi'\r\n".into(),
arguments: vec![],
expected_stdout: None,
windows_execution_profile: None,
privileged_script_profile: Some(
rmm_domain::jobs::PrivilegedScriptProfile::FullMaintenanceV1,
),
};
caps.extend([
"run_script".into(),
"system:run_script".into(),
"script.powershell/1".into(),
rmm_domain::jobs::FULL_MAINTENANCE_CAPABILITY.into(),
]);
for version in [1, 2, 3] {
policy.schema_version = version;
assert!(!policy.permits("selected", &job, &caps, Utc::now()));
}
policy.scopes[0].allowed_script_profiles = Some(vec![
rmm_domain::jobs::PrivilegedScriptProfile::FullMaintenanceV1,
]);
for version in [1, 2] {
policy.schema_version = version;
assert!(!policy.permits("selected", &job, &caps, Utc::now()));
}
policy.schema_version = 3;
assert!(policy.permits("selected", &job, &caps, Utc::now()));
assert!(!policy.permits("foreign", &job, &caps, Utc::now()));
policy.scopes[0].allowed_script_sha256 = Some(vec![]);
assert!(!policy.permits("selected", &job, &caps, Utc::now()));
policy.scopes[0].allowed_script_sha256 =
Some(vec![rmm_domain::jobs::hash(b"Write-Output 'hi'\r\n")]);
assert!(policy.permits("selected", &job, &caps, Utc::now()));
let mut changed = job.clone();
if let Action::RunScript { arguments, .. } = &mut changed.action {
arguments.push("unexpected".into());
}
assert!(!policy.permits("selected", &changed, &caps, Utc::now()));
if let Action::RunScript {
arguments,
script_utf8,
..
} = &mut changed.action
{
arguments.clear();
script_utf8.push(' ');
}
assert!(!policy.permits("selected", &changed, &caps, Utc::now()));
policy.scopes[0].allowed_script_sha256 = None;
let general = job.action.clone();
job.action = Action::RunScript {
interpreter: "powershell".into(),
script_utf8: rmm_domain::jobs::WINDOWS_UPDATE_SCRIPT_UTF8.into(),
arguments: vec![],
expected_stdout: None,
windows_execution_profile: Some(
rmm_domain::jobs::WindowsExecutionProfile::PowerShell51RemoteSigned,
),
privileged_script_profile: Some(
rmm_domain::jobs::PrivilegedScriptProfile::FullMaintenanceV1,
),
};
caps.push("script.powershell.process_remote_signed/1".into());
job.max_runtime_seconds = 3600;
assert!(!policy.permits("selected", &job, &caps, Utc::now()));
policy.scopes[0].windows_update_max_runtime_seconds = Some(3600);
assert!(!policy.permits("selected", &job, &caps, Utc::now()));
caps.push(rmm_domain::jobs::WINDOWS_UPDATE_LONG_CAPABILITY.into());
assert!(policy.permits("selected", &job, &caps, Utc::now()));
policy.scopes[0].windows_update_max_runtime_seconds = Some(1800);
assert!(!policy.permits("selected", &job, &caps, Utc::now()));
policy.scopes[0].windows_update_max_runtime_seconds = Some(3600);
job.action = general;
assert!(!policy.permits("selected", &job, &caps, Utc::now()));
job.max_runtime_seconds = 30;
caps.retain(|c| c != rmm_domain::jobs::FULL_MAINTENANCE_CAPABILITY);
assert!(!policy.permits("selected", &job, &caps, Utc::now()));
}
#[test]
fn windows_update_window_accepts_only_the_two_fixed_scripts() {
use rmm_domain::jobs::{
PrivilegedScriptProfile, WINDOWS_UPDATE_IDENTITY_PROBE, WINDOWS_UPDATE_LONG_CAPABILITY,
WINDOWS_UPDATE_SCRIPT_UTF8, WindowsExecutionProfile,
};
let (mut policy, mut job, mut caps) = fixture();
policy.schema_version = 3;
let scope = &mut policy.scopes[0];
scope.allowed_services.clear();
scope.windows_update_max_runtime_seconds = Some(3600);
caps.extend(
[
"run_script",
"system:run_script",
"script.powershell/1",
"script.powershell.process_remote_signed/1",
WINDOWS_UPDATE_LONG_CAPABILITY,
]
.map(str::to_owned),
);
for (script, seconds, expected) in [
(WINDOWS_UPDATE_SCRIPT_UTF8, 3600, true),
(WINDOWS_UPDATE_IDENTITY_PROBE, 30, true),
(WINDOWS_UPDATE_IDENTITY_PROBE, 31, false),
("Write-Output 12", 30, false),
] {
job.action = Action::RunScript {
interpreter: "powershell".into(),
script_utf8: script.into(),
arguments: vec![],
expected_stdout: None,
windows_execution_profile: Some(WindowsExecutionProfile::PowerShell51RemoteSigned),
privileged_script_profile: Some(PrivilegedScriptProfile::FullMaintenanceV1),
};
job.max_runtime_seconds = seconds;
assert_eq!(
policy.permits("selected", &job, &caps, Utc::now()),
expected
);
}
}
#[test]
fn narrow_scm_ceiling_denies_unreviewed_effects_and_provider_inputs() {
let (mut policy, mut job, caps) = fixture();
let now = Utc::now();
for (unit, state) in [
("RmmDiscoveryWindows", "stopped"),
("RmmDiscoverySystemHelper", "stopped"),
("Spooler", "running"),
("RmmDiscoveryFixtureService", "restarted"),
] {
job.action = Action::SetServiceState {
unit: unit.into(),
state: state.into(),
};
assert!(!policy.permits("selected", &job, &caps, now));
}
job.action = Action::RunScript {
interpreter: "powershell".into(),
script_utf8: "Write-Output 'hello'".into(),
arguments: vec![],
expected_stdout: None,
windows_execution_profile: None,
privileged_script_profile: None,
};
assert!(!policy.permits("selected", &job, &caps, now));
job.action = Action::SetServiceState {
unit: "RmmDiscoveryFixtureService".into(),
state: "stopped".into(),
};
assert!(policy.permits("selected", &job, &caps, now));
job.max_runtime_seconds = 31;
assert!(!policy.permits("selected", &job, &caps, now));
job.max_runtime_seconds = 30;
policy.scopes[0].acceptance_evidence_id = Uuid::nil();
assert!(!policy.permits("selected", &job, &caps, now));
let invalid = json!({"schema_version":1,"profile":"development","expires_at":now,"scopes":[],"allow_system_scripts":true});
assert!(serde_json::from_value::<SystemPolicy>(invalid).is_err());
}
#[test]
fn only_explicit_v2_hash_scope_and_package_caps_allow_fixed_msi() {
let (mut policy, mut job, mut caps) = fixture();
let m = crate::windows_msi_catalog::test_manifest(Uuid::new_v4(), &"ab".repeat(32), 32);
job.action = crate::windows_msi_catalog::test_action(m.clone());
caps.extend([
"ensure_package".into(),
"system:ensure_package".into(),
rmm_domain::windows_execution::MSI_CAPABILITY.into(),
]);
assert!(!policy.permits("selected", &job, &caps, Utc::now()));
policy.scopes[0].allowed_msi_recipe_sha256 = Some(vec![m.recipe_sha256.clone()]);
assert!(!policy.permits("selected", &job, &caps, Utc::now())); // v1 remains SCM-only
policy.schema_version = 2;
assert!(policy.permits("selected", &job, &caps, Utc::now()));
for index in caps.len() - 3..caps.len() {
let mut short = caps.clone();
short.remove(index);
assert!(!policy.permits("selected", &job, &short, Utc::now()));
}
policy.scopes[0].allowed_msi_recipe_sha256 = Some(vec!["cd".repeat(32)]);
assert!(!policy.permits("selected", &job, &caps, Utc::now()));
}
#[test]
fn policy_file_refuses_symlinks_public_mode_wrong_owner_and_writable_parent() {
use std::os::unix::fs::symlink;
let directory = std::env::temp_dir().join(format!("rmm-windows-policy-{}", Uuid::new_v4()));
fs::create_dir(&directory).unwrap();
fs::set_permissions(&directory, fs::Permissions::from_mode(0o700)).unwrap();
let path = directory.join("policy.json");
fs::write(&path, b"{}").unwrap();
fs::set_permissions(&path, fs::Permissions::from_mode(0o600)).unwrap();
let owner = fs::metadata(&path).unwrap().uid();
assert_eq!(protected_bytes(&path, owner).unwrap(), b"{}");
assert!(protected_bytes(&path, owner.wrapping_add(1)).is_err());
let link = directory.join("link.json");
symlink(&path, &link).unwrap();
assert!(protected_bytes(&link, owner).is_err());
fs::set_permissions(&path, fs::Permissions::from_mode(0o640)).unwrap();
assert!(protected_bytes(&path, owner).is_err());
fs::set_permissions(&path, fs::Permissions::from_mode(0o600)).unwrap();
fs::set_permissions(&directory, fs::Permissions::from_mode(0o770)).unwrap();
assert!(protected_bytes(&path, owner).is_err());
fs::set_permissions(&directory, fs::Permissions::from_mode(0o700)).unwrap();
fs::write(&path, vec![b' '; POLICY_LIMIT as usize + 1]).unwrap();
assert!(protected_bytes(&path, owner).is_err());
let real = directory.join("real");
let nested = real.join("nested");
fs::create_dir_all(&nested).unwrap();
fs::set_permissions(&nested, fs::Permissions::from_mode(0o700)).unwrap();
let data = nested.join("policy.json");
fs::write(&data, b"{}").unwrap();
fs::set_permissions(&data, fs::Permissions::from_mode(0o600)).unwrap();
// The immediate parent remains protected throughout. A writable
// ancestor still permits substitution of that entire directory.
fs::set_permissions(&real, fs::Permissions::from_mode(0o777)).unwrap();
assert!(protected_bytes(&data, owner).is_err());
fs::set_permissions(&real, fs::Permissions::from_mode(0o1777)).unwrap();
assert_eq!(protected_bytes(&data, owner).unwrap(), b"{}");
fs::set_permissions(&real, fs::Permissions::from_mode(0o700)).unwrap();
let alias = directory.join("alias");
symlink(&real, &alias).unwrap();
assert!(protected_bytes(&alias.join("nested/policy.json"), owner).is_err());
fs::remove_dir_all(directory).unwrap();
}
}