1332 lines
51 KiB
Rust
1332 lines
51 KiB
Rust
//! Version 1 codec: UTF-8 compact serde JSON of these structs, declaration field
|
|
//! order, explicit null legacy options (new opt-in fields omit None), ordered vectors,
|
|
//! UTC RFC3339 timestamps. Hash the
|
|
//! stored bytes, never a reconstructed API view. No floating point/map payloads.
|
|
use chrono::{DateTime, Utc};
|
|
use serde::{Deserialize, Serialize};
|
|
use sha2::{Digest, Sha256};
|
|
use uuid::Uuid;
|
|
|
|
pub fn hash(bytes: &[u8]) -> String {
|
|
hex::encode(Sha256::digest(bytes))
|
|
}
|
|
pub fn encode<T: Serialize>(value: &T) -> Result<Vec<u8>, serde_json::Error> {
|
|
serde_json::to_vec(value)
|
|
}
|
|
|
|
/// One explicitly qualified Event Log source, not an arbitrary channel/XPath.
|
|
pub const WINDOWS_EVENT_LOG_FIXTURE_SOURCE: &str =
|
|
"windows.eventlog.application.rustdiscovery-mvp-test";
|
|
pub const WINDOWS_EVENT_LOG_FIXTURE_CAPABILITY: &str = "logs.windows.eventlog.fixture/1";
|
|
pub const WINDOWS_EVENT_LOG_FIXTURE_CHANNEL: &str = "Application";
|
|
pub const WINDOWS_EVENT_LOG_FIXTURE_PROVIDER: &str = "RustDiscovery-MVP-Test";
|
|
|
|
/// Fixed per-job Windows PowerShell 5.1 option, never a machine/GPO policy.
|
|
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, schemars::JsonSchema)]
|
|
pub enum WindowsExecutionProfile {
|
|
#[serde(rename = "powershell_51_remote_signed")]
|
|
PowerShell51RemoteSigned,
|
|
}
|
|
|
|
/// A missing field uses serde's default None. A present field must be the exact
|
|
/// string: null and serde's externally-tagged enum object form are not profiles.
|
|
pub fn deserialize_windows_execution_profile<'de, D>(
|
|
deserializer: D,
|
|
) -> Result<Option<WindowsExecutionProfile>, D::Error>
|
|
where
|
|
D: serde::Deserializer<'de>,
|
|
{
|
|
let value = String::deserialize(deserializer)?;
|
|
match value.as_str() {
|
|
"powershell_51_remote_signed" => {
|
|
Ok(Some(WindowsExecutionProfile::PowerShell51RemoteSigned))
|
|
}
|
|
_ => Err(serde::de::Error::unknown_variant(
|
|
&value,
|
|
&["powershell_51_remote_signed"],
|
|
)),
|
|
}
|
|
}
|
|
|
|
/// Explicit authority for a separately qualified, fully privileged script.
|
|
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, schemars::JsonSchema)]
|
|
pub enum PrivilegedScriptProfile {
|
|
#[serde(rename = "full_maintenance_v1")]
|
|
FullMaintenanceV1,
|
|
}
|
|
pub const FULL_MAINTENANCE_CAPABILITY: &str = "script.full_maintenance/1";
|
|
pub fn deserialize_privileged_script_profile<'de, D>(
|
|
d: D,
|
|
) -> Result<Option<PrivilegedScriptProfile>, D::Error>
|
|
where
|
|
D: serde::Deserializer<'de>,
|
|
{
|
|
let value = String::deserialize(d)?;
|
|
match value.as_str() {
|
|
"full_maintenance_v1" => Ok(Some(PrivilegedScriptProfile::FullMaintenanceV1)),
|
|
_ => Err(serde::de::Error::unknown_variant(
|
|
&value,
|
|
&["full_maintenance_v1"],
|
|
)),
|
|
}
|
|
}
|
|
/// Optional metadata pins preserve old codecs when missing, reject null or
|
|
/// noncanonical digests when explicitly supplied.
|
|
pub fn deserialize_optional_sha256<'de, D>(d: D) -> Result<Option<String>, D::Error>
|
|
where
|
|
D: serde::Deserializer<'de>,
|
|
{
|
|
let value = String::deserialize(d)?;
|
|
if value.len() != 64
|
|
|| !value
|
|
.bytes()
|
|
.all(|b| b.is_ascii_digit() || b"abcdef".contains(&b))
|
|
{
|
|
return Err(serde::de::Error::custom("lowercase SHA256 required"));
|
|
}
|
|
Ok(Some(value))
|
|
}
|
|
|
|
/// Policy lists are strict when present; omission is deny, never a wildcard.
|
|
pub fn deserialize_script_profiles<'de, D>(
|
|
d: D,
|
|
) -> Result<Option<Vec<PrivilegedScriptProfile>>, D::Error>
|
|
where
|
|
D: serde::Deserializer<'de>,
|
|
{
|
|
let values = Vec::<String>::deserialize(d)?;
|
|
if values.len() != 1 || values[0] != "full_maintenance_v1" {
|
|
return Err(serde::de::Error::custom(
|
|
"exact full_maintenance_v1 profile required",
|
|
));
|
|
}
|
|
Ok(Some(vec![PrivilegedScriptProfile::FullMaintenanceV1]))
|
|
}
|
|
|
|
/// Missing preserves Linux codecs; explicit null/nonobject is never a manifest.
|
|
pub fn deserialize_windows_msi_manifest<'de, D>(
|
|
deserializer: D,
|
|
) -> Result<Option<Box<crate::windows_execution::ResolvedWindowsMsi>>, D::Error>
|
|
where
|
|
D: serde::Deserializer<'de>,
|
|
{
|
|
crate::windows_execution::ResolvedWindowsMsi::deserialize(deserializer)
|
|
.map(|m| Some(Box::new(m)))
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, schemars::JsonSchema)]
|
|
#[serde(tag = "action", rename_all = "snake_case", deny_unknown_fields)]
|
|
pub enum Action {
|
|
RunScript {
|
|
interpreter: String,
|
|
script_utf8: String,
|
|
arguments: Vec<String>,
|
|
expected_stdout: Option<String>,
|
|
#[serde(
|
|
default,
|
|
deserialize_with = "deserialize_windows_execution_profile",
|
|
skip_serializing_if = "Option::is_none"
|
|
)]
|
|
#[schemars(with = "WindowsExecutionProfile")]
|
|
windows_execution_profile: Option<WindowsExecutionProfile>,
|
|
#[serde(
|
|
default,
|
|
deserialize_with = "deserialize_privileged_script_profile",
|
|
skip_serializing_if = "Option::is_none"
|
|
)]
|
|
#[schemars(with = "PrivilegedScriptProfile")]
|
|
privileged_script_profile: Option<PrivilegedScriptProfile>,
|
|
},
|
|
RefreshInventory {
|
|
scope: String,
|
|
},
|
|
QueryLogs {
|
|
unit: String,
|
|
since: DateTime<Utc>,
|
|
until: DateTime<Utc>,
|
|
max_lines: u32,
|
|
},
|
|
SetServiceState {
|
|
unit: String,
|
|
state: String,
|
|
},
|
|
EnsurePackage {
|
|
provider: String,
|
|
package: String,
|
|
version: String,
|
|
architecture: String,
|
|
recipe_version: String,
|
|
installation_context: String,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
recipe_id: Option<String>,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
apt_manifest: Option<crate::apt_transaction::AptExecutionManifest>,
|
|
#[serde(
|
|
default,
|
|
deserialize_with = "deserialize_windows_msi_manifest",
|
|
skip_serializing_if = "Option::is_none"
|
|
)]
|
|
#[schemars(with = "crate::windows_execution::ResolvedWindowsMsi")]
|
|
windows_msi_manifest: Option<Box<crate::windows_execution::ResolvedWindowsMsi>>,
|
|
},
|
|
ApplyUpdates {
|
|
provider: String,
|
|
packages: Vec<String>,
|
|
reboot_policy: String,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
apt_manifest: Option<crate::apt_transaction::AptExecutionManifest>,
|
|
},
|
|
AptNativeAcceptance {
|
|
recipe_id: String,
|
|
recipe_version: String,
|
|
apt_manifest: crate::apt_transaction::AptExecutionManifest,
|
|
},
|
|
UpdateAgent {
|
|
update: Box<crate::agent_update::ResolvedAgentUpdate>,
|
|
},
|
|
Reboot {
|
|
reason: String,
|
|
reconnect_timeout_seconds: u32,
|
|
dependency_group: String,
|
|
},
|
|
}
|
|
impl Action {
|
|
pub fn name(&self) -> &'static str {
|
|
match self {
|
|
Self::RunScript { .. } => "run_script",
|
|
Self::RefreshInventory { .. } => "refresh_inventory",
|
|
Self::QueryLogs { .. } => "query_logs",
|
|
Self::SetServiceState { .. } => "set_service_state",
|
|
Self::EnsurePackage { .. } => "ensure_package",
|
|
Self::ApplyUpdates { .. } => "apply_updates",
|
|
Self::AptNativeAcceptance { .. } => "apt_native_acceptance",
|
|
Self::Reboot { .. } => "reboot",
|
|
Self::UpdateAgent { .. } => "update_agent",
|
|
}
|
|
}
|
|
pub fn validate(&self) -> bool {
|
|
let valid_version = |s: &str| {
|
|
!s.is_empty()
|
|
&& s.len() <= 255
|
|
&& !s.starts_with('-')
|
|
&& s.bytes()
|
|
.all(|c| c.is_ascii_alphanumeric() || b".+~:-".contains(&c))
|
|
};
|
|
let unit = |s: &str| {
|
|
!s.is_empty()
|
|
&& s.len() <= 255
|
|
&& !s.starts_with('-')
|
|
&& s.bytes()
|
|
.all(|c| c.is_ascii_alphanumeric() || b"_.@:-".contains(&c))
|
|
};
|
|
match self {
|
|
Self::RunScript {
|
|
interpreter,
|
|
script_utf8,
|
|
arguments,
|
|
expected_stdout,
|
|
windows_execution_profile,
|
|
..
|
|
} => {
|
|
matches!(interpreter.as_str(), "posix_sh" | "bash" | "powershell")
|
|
&& (windows_execution_profile.is_none() || interpreter == "powershell")
|
|
&& (interpreter != "powershell"
|
|
|| script_utf8.is_ascii()
|
|
|| script_utf8.starts_with('\u{feff}'))
|
|
&& !script_utf8.is_empty()
|
|
&& script_utf8.len() <= 32768
|
|
&& !script_utf8.contains('\0')
|
|
&& arguments.len() <= 32
|
|
&& arguments
|
|
.iter()
|
|
.all(|a| a.len() <= 4096 && !a.contains('\0'))
|
|
&& expected_stdout.as_ref().is_none_or(|s| s.len() <= 65536)
|
|
}
|
|
Self::RefreshInventory { scope } => {
|
|
matches!(scope.as_str(), "linux.base" | "windows.base")
|
|
}
|
|
Self::QueryLogs {
|
|
unit: u,
|
|
since,
|
|
until,
|
|
max_lines,
|
|
} => {
|
|
unit(u)
|
|
&& since < until
|
|
&& *until - *since <= chrono::Duration::hours(24)
|
|
&& (u != WINDOWS_EVENT_LOG_FIXTURE_SOURCE || since.timestamp() >= 0)
|
|
&& *max_lines > 0
|
|
&& *max_lines <= 1000
|
|
}
|
|
Self::SetServiceState { unit: u, state } => {
|
|
unit(u) && matches!(state.as_str(), "running" | "stopped" | "restarted")
|
|
}
|
|
Self::EnsurePackage {
|
|
provider,
|
|
package,
|
|
version,
|
|
architecture,
|
|
recipe_version,
|
|
installation_context,
|
|
recipe_id,
|
|
apt_manifest,
|
|
windows_msi_manifest: Some(m),
|
|
} => {
|
|
m.validate()
|
|
&& provider == "msi"
|
|
&& package == crate::windows_execution::MSI_PACKAGE_ID
|
|
&& version == &m.recipe.postcondition.product_version
|
|
&& architecture == "x64"
|
|
&& installation_context == "machine"
|
|
&& recipe_version == &m.recipe.recipe_version
|
|
&& recipe_id.as_ref() == Some(&m.recipe.recipe_id)
|
|
&& apt_manifest.is_none()
|
|
}
|
|
Self::EnsurePackage {
|
|
provider,
|
|
package,
|
|
version,
|
|
architecture,
|
|
recipe_version,
|
|
installation_context,
|
|
recipe_id,
|
|
apt_manifest,
|
|
windows_msi_manifest: None,
|
|
} => {
|
|
provider == "apt"
|
|
&& unit(package)
|
|
&& valid_version(version)
|
|
&& matches!(architecture.as_str(), "amd64" | "all")
|
|
&& unit(recipe_version)
|
|
&& installation_context == "system"
|
|
&& apt_manifest.as_ref().is_some_and(|m| {
|
|
m.validate()
|
|
&& m.action == "apt-execute"
|
|
&& recipe_id.as_ref() == Some(&m.resolved_apt_transaction.recipe_id)
|
|
&& recipe_version == &m.resolved_apt_transaction.recipe_version
|
|
&& m.resolved_apt_transaction.packages.iter().any(|p| {
|
|
&p.name == package
|
|
&& &p.new_version == version
|
|
&& &p.architecture == architecture
|
|
})
|
|
})
|
|
}
|
|
Self::ApplyUpdates {
|
|
provider,
|
|
packages,
|
|
reboot_policy,
|
|
apt_manifest,
|
|
} => {
|
|
provider == "apt"
|
|
&& reboot_policy == "never"
|
|
&& !packages.is_empty()
|
|
&& packages.len() <= 100
|
|
&& apt_manifest.as_ref().is_some_and(|m| {
|
|
m.validate()
|
|
&& m.action == "apt-execute"
|
|
&& m.resolved_apt_transaction.recipe_id == "rmm-apt-fixture-update-1.1"
|
|
&& packages == &["rmm-mvp-test".to_string()]
|
|
})
|
|
}
|
|
Self::AptNativeAcceptance {
|
|
recipe_id,
|
|
recipe_version,
|
|
apt_manifest: m,
|
|
} => {
|
|
m.validate()
|
|
&& m.action == "apt-native-acceptance"
|
|
&& recipe_id == &m.resolved_apt_transaction.recipe_id
|
|
&& recipe_version == &m.resolved_apt_transaction.recipe_version
|
|
}
|
|
Self::UpdateAgent { update } => update.validate(),
|
|
Self::Reboot {
|
|
reason,
|
|
reconnect_timeout_seconds,
|
|
dependency_group,
|
|
} => {
|
|
!reason.is_empty()
|
|
&& reason.len() <= 1024
|
|
&& (60..=3600).contains(reconnect_timeout_seconds)
|
|
&& unit(dependency_group)
|
|
}
|
|
}
|
|
}
|
|
pub fn windows_msi(&self) -> Option<&crate::windows_execution::ResolvedWindowsMsi> {
|
|
match self {
|
|
Self::EnsurePackage {
|
|
windows_msi_manifest: Some(m),
|
|
..
|
|
} => Some(m.as_ref()),
|
|
_ => None,
|
|
}
|
|
}
|
|
pub fn valid_helper_denial_shape(&self, identity: &str) -> bool {
|
|
(matches!(self,Self::SetServiceState{state,..} if matches!(state.as_str(),"running"|"stopped"))
|
|
&& self.validate())
|
|
|| (identity == "system" && self.windows_msi().is_some() && self.validate())
|
|
|| (identity == "system"
|
|
&& self.full_maintenance()
|
|
&& self.script_platform() == Some("windows")
|
|
&& self.validate())
|
|
|| (identity == "system"
|
|
&& matches!(
|
|
self,
|
|
Self::Reboot {
|
|
reconnect_timeout_seconds: crate::windows_reboot::RECONNECT_SECONDS,
|
|
..
|
|
}
|
|
)
|
|
&& self.validate())
|
|
}
|
|
pub fn full_maintenance(&self) -> bool {
|
|
matches!(
|
|
self,
|
|
Self::RunScript {
|
|
privileged_script_profile: Some(PrivilegedScriptProfile::FullMaintenanceV1),
|
|
..
|
|
}
|
|
)
|
|
}
|
|
pub fn valid_execution_identity(&self, identity: &str) -> bool {
|
|
if let Self::UpdateAgent { update } = self {
|
|
return update.execution_identity() == Some(identity);
|
|
}
|
|
!self.full_maintenance()
|
|
|| matches!(
|
|
(identity, self.script_platform()),
|
|
("root", Some("linux")) | ("system", Some("windows"))
|
|
)
|
|
}
|
|
pub fn is_windows_event_log_fixture(&self) -> bool {
|
|
matches!(self, Self::QueryLogs { unit, .. } if unit == WINDOWS_EVENT_LOG_FIXTURE_SOURCE)
|
|
}
|
|
/// The outer process budget includes authenticated worker startup/cleanup;
|
|
/// its inner Event Log calls retain their own cooperative <=5s deadline.
|
|
pub fn valid_job_limits(&self, runtime_seconds: u32, output_bytes: u32) -> bool {
|
|
(1..=3600).contains(&runtime_seconds)
|
|
&& (!matches!(self, Self::UpdateAgent { .. })
|
|
|| (runtime_seconds == 600 && output_bytes <= 65536))
|
|
&& (!self.full_maintenance()
|
|
|| (output_bytes <= 65536
|
|
&& runtime_seconds
|
|
<= if self.script_platform() == Some("windows") {
|
|
120
|
|
} else {
|
|
300
|
|
}))
|
|
&& (self.windows_msi().is_none()
|
|
|| ((10..=120).contains(&runtime_seconds)
|
|
&& (1024..=65536).contains(&output_bytes)))
|
|
&& (1..=262144).contains(&output_bytes)
|
|
&& (!self.is_windows_event_log_fixture()
|
|
|| ((10..=120).contains(&runtime_seconds)
|
|
&& (1024..=65536).contains(&output_bytes)))
|
|
}
|
|
/// Interpreter identity is part of the immutable action, never inferred at execution.
|
|
pub fn script_platform(&self) -> Option<&'static str> {
|
|
match self {
|
|
Self::RunScript { interpreter, .. } => match interpreter.as_str() {
|
|
"posix_sh" | "bash" => Some("linux"),
|
|
"powershell" => Some("windows"),
|
|
_ => None,
|
|
},
|
|
_ => None,
|
|
}
|
|
}
|
|
/// Shared plan/revalidation/start gate. Passive Windows never implies job support.
|
|
pub fn available_for(&self, identity: &str, capabilities: &[String]) -> bool {
|
|
if !self.valid_execution_identity(identity)
|
|
|| (identity == "system"
|
|
&& !self.valid_helper_denial_shape(identity)
|
|
&& !matches!(self, Self::UpdateAgent { .. }))
|
|
{
|
|
return false;
|
|
}
|
|
let has = |cap: &str| capabilities.iter().any(|c| c == cap);
|
|
if !has(self.name())
|
|
|| (self.full_maintenance()
|
|
&& !(has(FULL_MAINTENANCE_CAPABILITY)
|
|
&& has("rmm.sync.v1")
|
|
&& has(&format!("{}:run_script", identity))
|
|
&& has(if identity == "root" {
|
|
"helper.root.v1"
|
|
} else {
|
|
"helper.system.v1"
|
|
})))
|
|
{
|
|
return false;
|
|
}
|
|
match self {
|
|
Self::UpdateAgent { update } => {
|
|
let linux = update.execution_identity() == Some("root");
|
|
update.validate()
|
|
&& has(crate::agent_update::APPLY_CAPABILITY)
|
|
&& has("rmm.sync.v1")
|
|
&& has(if linux {
|
|
"linux.base/1"
|
|
} else {
|
|
"windows.base/1"
|
|
})
|
|
&& !has(if linux {
|
|
"windows.base/1"
|
|
} else {
|
|
"linux.base/1"
|
|
})
|
|
&& has(if linux {
|
|
"helper.root.v1"
|
|
} else {
|
|
"helper.system.v1"
|
|
})
|
|
&& has(&format!("{}:update_agent", identity))
|
|
&& has(&format!(
|
|
"updater.binary.sha256:{}",
|
|
update.updater.binary_sha256
|
|
))
|
|
&& has(&format!(
|
|
"updater.policy.sha256:{}",
|
|
update.updater.policy_sha256
|
|
))
|
|
&& has(&format!(
|
|
"helper.binary.sha256:{}",
|
|
update.predecessor.helper_sha256
|
|
))
|
|
}
|
|
Self::Reboot {
|
|
reconnect_timeout_seconds,
|
|
..
|
|
} if identity == "system" || has("windows.base/1") => {
|
|
identity == "system"
|
|
&& *reconnect_timeout_seconds == crate::windows_reboot::RECONNECT_SECONDS
|
|
&& has("windows.base/1")
|
|
&& !has("linux.base/1")
|
|
&& has("rmm.sync.v1")
|
|
&& has("helper.system.v1")
|
|
&& has("system:reboot")
|
|
&& has(crate::windows_reboot::CAPABILITY)
|
|
}
|
|
Self::RunScript {
|
|
interpreter,
|
|
windows_execution_profile,
|
|
..
|
|
} if interpreter == "powershell" => {
|
|
(identity == "agent_service" || (identity == "system" && self.full_maintenance()))
|
|
&& has("windows.base/1")
|
|
&& !has("linux.base/1")
|
|
&& has("rmm.sync.v1")
|
|
&& has("script.powershell/1")
|
|
&& (windows_execution_profile.is_none()
|
|
|| has("script.powershell.process_remote_signed/1"))
|
|
}
|
|
Self::RunScript {
|
|
windows_execution_profile,
|
|
..
|
|
} => {
|
|
windows_execution_profile.is_none()
|
|
&& self.script_platform() == Some("linux")
|
|
&& has("linux.base/1")
|
|
&& !has("windows.base/1")
|
|
}
|
|
Self::RefreshInventory { scope } => {
|
|
(identity == "agent_service" || scope == "linux.base")
|
|
&& has(&format!("{scope}/1"))
|
|
&& !(has("linux.base/1") && has("windows.base/1"))
|
|
&& (scope != "windows.base" || has("rmm.sync.v1"))
|
|
}
|
|
Self::EnsurePackage { .. } if self.windows_msi().is_some() || has("windows.base/1") => {
|
|
self.windows_msi().is_some()
|
|
&& self.validate()
|
|
&& identity == "system"
|
|
&& has("windows.base/1")
|
|
&& !has("linux.base/1")
|
|
&& has("rmm.sync.v1")
|
|
&& has("helper.system.v1")
|
|
&& has("system:ensure_package")
|
|
&& has(crate::windows_execution::MSI_CAPABILITY)
|
|
}
|
|
Self::QueryLogs { unit, .. }
|
|
if unit == WINDOWS_EVENT_LOG_FIXTURE_SOURCE || has("windows.base/1") =>
|
|
{
|
|
identity == "agent_service"
|
|
&& unit == WINDOWS_EVENT_LOG_FIXTURE_SOURCE
|
|
&& has("windows.base/1")
|
|
&& !has("linux.base/1")
|
|
&& has("rmm.sync.v1")
|
|
&& has(WINDOWS_EVENT_LOG_FIXTURE_CAPABILITY)
|
|
}
|
|
Self::SetServiceState { state, .. }
|
|
if identity == "system" || has("windows.base/1") =>
|
|
{
|
|
identity == "system"
|
|
&& has("windows.base/1")
|
|
&& !has("linux.base/1")
|
|
&& has("rmm.sync.v1")
|
|
&& has("helper.system.v1")
|
|
&& has("system:set_service_state")
|
|
&& matches!(state.as_str(), "running" | "stopped")
|
|
}
|
|
_ => !has("windows.base/1"), // Windows adapters are separately qualified.
|
|
}
|
|
}
|
|
pub fn resource(&self) -> &'static str {
|
|
match self {
|
|
Self::EnsurePackage { .. }
|
|
| Self::ApplyUpdates { .. }
|
|
| Self::AptNativeAcceptance { .. } => "package_manager",
|
|
_ => "device_execution",
|
|
}
|
|
}
|
|
/// Old immutable catalog previews remain readable/plannable, but are never
|
|
/// executable or submit/approval eligible without the signed schema-2 body.
|
|
pub fn validate_plan_shape(&self) -> bool {
|
|
match self {
|
|
Self::EnsurePackage {
|
|
provider,
|
|
package,
|
|
version,
|
|
architecture,
|
|
recipe_version,
|
|
installation_context,
|
|
recipe_id: None,
|
|
apt_manifest: None,
|
|
windows_msi_manifest: None,
|
|
} => {
|
|
provider == "apt"
|
|
&& !package.is_empty()
|
|
&& package.len() <= 255
|
|
&& !package.starts_with('-')
|
|
&& package
|
|
.bytes()
|
|
.all(|c| c.is_ascii_alphanumeric() || b"_.:+-".contains(&c))
|
|
&& !version.is_empty()
|
|
&& version.len() <= 255
|
|
&& version
|
|
.bytes()
|
|
.all(|c| c.is_ascii_alphanumeric() || b".+~:-".contains(&c))
|
|
&& matches!(architecture.as_str(), "amd64" | "all")
|
|
&& !recipe_version.is_empty()
|
|
&& recipe_version.len() <= 255
|
|
&& installation_context == "system"
|
|
}
|
|
Self::ApplyUpdates {
|
|
provider,
|
|
packages,
|
|
reboot_policy,
|
|
apt_manifest: None,
|
|
} => {
|
|
provider == "apt"
|
|
&& reboot_policy == "never"
|
|
&& !packages.is_empty()
|
|
&& packages.len() <= 100
|
|
&& packages.iter().all(|s| {
|
|
s.split_once('=').is_some_and(|(n, v)| {
|
|
!n.is_empty()
|
|
&& !v.is_empty()
|
|
&& n.len() <= 255
|
|
&& v.len() <= 255
|
|
&& !n.starts_with('-')
|
|
&& n.bytes()
|
|
.all(|c| c.is_ascii_alphanumeric() || b"_.:+-".contains(&c))
|
|
&& v.bytes()
|
|
.all(|c| c.is_ascii_alphanumeric() || b".+~:-".contains(&c))
|
|
})
|
|
})
|
|
}
|
|
_ => self.validate(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct JobPayload {
|
|
pub schema_version: u32,
|
|
pub tenant_id: Uuid,
|
|
pub asset_id: Uuid,
|
|
pub agent_id: Uuid,
|
|
pub enrollment_generation: u64,
|
|
pub assignment_version: u64,
|
|
pub job_id: Uuid,
|
|
pub attempt_id: Uuid,
|
|
pub action: Action,
|
|
pub execution_identity: String,
|
|
pub not_before: DateTime<Utc>,
|
|
pub start_before: DateTime<Utc>,
|
|
pub max_runtime_seconds: u32,
|
|
pub max_output_bytes: u32,
|
|
}
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct PlannedJob {
|
|
pub payload: JobPayload,
|
|
pub job_payload_hash: String,
|
|
pub script_sha256: Option<String>,
|
|
}
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct PlanPayload {
|
|
pub schema_version: u32,
|
|
pub plan_id: Uuid,
|
|
pub tenant_id: Uuid,
|
|
pub principal: String,
|
|
pub reason: String,
|
|
pub jobs: Vec<PlannedJob>,
|
|
pub max_parallel: u32,
|
|
pub halt_after_failures: u32,
|
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
|
pub recipe_references: Vec<RecipeReference>,
|
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
|
pub artifact_references: Vec<JobArtifactReference>,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub script_revision: Option<ScriptRevisionReference>,
|
|
}
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct ScriptRevisionReference {
|
|
pub revision_id: Uuid,
|
|
pub name: String,
|
|
pub version: i32,
|
|
pub script_sha256: String,
|
|
}
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct ArtifactReference {
|
|
pub artifact_id: Uuid,
|
|
pub sha256: String,
|
|
pub size_bytes: u64,
|
|
}
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct JobArtifactReference {
|
|
pub job_id: Uuid,
|
|
pub attempt_id: Uuid,
|
|
pub artifact: ArtifactReference,
|
|
}
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct RecipeReference {
|
|
pub package: String,
|
|
pub version: String,
|
|
pub architecture: String,
|
|
pub recipe_version: String,
|
|
pub sha256: String,
|
|
}
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct ExecutionPermitPayload {
|
|
pub domain: String,
|
|
pub schema_version: u32,
|
|
pub grant_id: Uuid,
|
|
pub authorization_id: Uuid,
|
|
pub tenant_id: Uuid,
|
|
pub asset_id: Uuid,
|
|
pub agent_id: Uuid,
|
|
pub enrollment_generation: u64,
|
|
pub assignment_version: u64,
|
|
pub job_id: Uuid,
|
|
pub attempt_id: Uuid,
|
|
pub plan_hash: String,
|
|
pub job_payload_hash: String,
|
|
pub action: String,
|
|
pub execution_identity: String,
|
|
pub not_before: DateTime<Utc>,
|
|
pub start_before: DateTime<Utc>,
|
|
pub max_runtime_seconds: u32,
|
|
pub key_id: String,
|
|
/// Only update_agent needs its actual plan ID in the local durable handoff.
|
|
/// Omitted on every legacy action, preserving original signed grant bytes.
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub agent_update_plan_id: Option<Uuid>,
|
|
}
|
|
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
|
|
#[serde(rename_all = "snake_case")]
|
|
pub enum JobState {
|
|
Queued,
|
|
Accepted,
|
|
Running,
|
|
Verifying,
|
|
AwaitingReboot,
|
|
Succeeded,
|
|
Failed,
|
|
Cancelled,
|
|
Expired,
|
|
Unknown,
|
|
/// A human closed an unknown attempt in the WebUI. The effect stays
|
|
/// unknown; the attempt is final and is never retried or reinterpreted.
|
|
ClosedUnknown,
|
|
}
|
|
impl JobState {
|
|
pub fn terminal(self) -> bool {
|
|
matches!(
|
|
self,
|
|
Self::Succeeded | Self::Failed | Self::Cancelled | Self::Expired | Self::ClosedUnknown
|
|
)
|
|
}
|
|
pub fn allows(self, next: Self) -> bool {
|
|
use JobState::*;
|
|
match self {
|
|
Queued => matches!(next, Accepted | Cancelled | Expired | Failed),
|
|
Accepted => matches!(next, Running | Unknown | Cancelled | Expired | Failed),
|
|
Running => matches!(
|
|
next,
|
|
Verifying | AwaitingReboot | Failed | Cancelled | Unknown
|
|
),
|
|
Verifying => matches!(next, Succeeded | Failed | AwaitingReboot | Unknown),
|
|
AwaitingReboot => matches!(next, Verifying | Unknown | Failed),
|
|
Unknown => false,
|
|
_ => false,
|
|
}
|
|
}
|
|
}
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
#[test]
|
|
fn windows_system_scm_is_explicit_and_preserves_linux_service_bytes() {
|
|
let caps: Vec<String> = [
|
|
"windows.base/1",
|
|
"rmm.sync.v1",
|
|
"helper.system.v1",
|
|
"system:set_service_state",
|
|
"set_service_state",
|
|
]
|
|
.into_iter()
|
|
.map(str::to_string)
|
|
.collect();
|
|
for state in ["running", "stopped"] {
|
|
let action = Action::SetServiceState {
|
|
unit: "RmmDiscoveryFixtureService".into(),
|
|
state: state.into(),
|
|
};
|
|
assert!(action.validate() && action.available_for("system", &caps));
|
|
for missing in 0..caps.len() {
|
|
let mut incomplete = caps.clone();
|
|
incomplete.remove(missing);
|
|
assert!(!action.available_for("system", &incomplete));
|
|
}
|
|
for identity in ["root", "agent_service", "SYSTEM"] {
|
|
assert!(!action.available_for(identity, &caps));
|
|
}
|
|
let mut mixed = caps.clone();
|
|
mixed.push("linux.base/1".into());
|
|
assert!(!action.available_for("system", &mixed));
|
|
assert!(!action.available_for(
|
|
"system",
|
|
&["linux.base/1".into(), "set_service_state".into()]
|
|
));
|
|
}
|
|
let restart = Action::SetServiceState {
|
|
unit: "rmm-mvp-test.service".into(),
|
|
state: "restarted".into(),
|
|
};
|
|
assert!(!restart.available_for("system", &caps));
|
|
let linux = vec!["linux.base/1".into(), "set_service_state".into()];
|
|
for identity in ["root", "agent_service"] {
|
|
assert!(restart.available_for(identity, &linux));
|
|
}
|
|
assert_eq!(
|
|
encode(&restart).unwrap(),
|
|
br#"{"action":"set_service_state","unit":"rmm-mvp-test.service","state":"restarted"}"#
|
|
);
|
|
let script = 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: None,
|
|
};
|
|
let mut all = caps;
|
|
all.extend(["run_script".into(), "script.powershell/1".into()]);
|
|
assert!(!script.available_for("system", &all));
|
|
let posix = Action::RunScript {
|
|
interpreter: "posix_sh".into(),
|
|
script_utf8: "printf hi\n".into(),
|
|
arguments: vec![],
|
|
expected_stdout: None,
|
|
windows_execution_profile: None,
|
|
privileged_script_profile: None,
|
|
};
|
|
let reboot = Action::Reboot {
|
|
reason: "fixed test".into(),
|
|
reconnect_timeout_seconds: 180,
|
|
dependency_group: "one-test-vm".into(),
|
|
};
|
|
let linux = ["linux.base/1", "run_script", "reboot"].map(str::to_string);
|
|
assert!(!posix.available_for("system", &linux));
|
|
assert!(!reboot.available_for("system", &linux));
|
|
for identity in ["root", "agent_service"] {
|
|
assert!(posix.available_for(identity, &linux));
|
|
assert!(reboot.available_for(identity, &linux));
|
|
}
|
|
}
|
|
#[test]
|
|
fn windows_interpreter_and_capability_contract() {
|
|
let mut action = Action::RunScript {
|
|
interpreter: "powershell".into(),
|
|
script_utf8: "Write-Output 'Hello'\r\n".into(),
|
|
arguments: vec![],
|
|
expected_stdout: Some("Hello\r\n".into()),
|
|
windows_execution_profile: None,
|
|
privileged_script_profile: None,
|
|
};
|
|
let caps: Vec<String> = [
|
|
"windows.base/1",
|
|
"rmm.sync.v1",
|
|
"run_script",
|
|
"script.powershell/1",
|
|
]
|
|
.into_iter()
|
|
.map(str::to_string)
|
|
.collect();
|
|
assert!(action.validate());
|
|
assert!(action.available_for("agent_service", &caps));
|
|
for missing in 0..caps.len() {
|
|
let mut short = caps.clone();
|
|
short.remove(missing);
|
|
assert!(!action.available_for("agent_service", &short));
|
|
}
|
|
assert!(!action.available_for("root", &caps));
|
|
assert!(!action.available_for("SYSTEM", &caps));
|
|
assert!(!action.available_for(
|
|
"agent_service",
|
|
&["linux.base/1".into(), "run_script".into()]
|
|
));
|
|
let mut both = caps.clone();
|
|
both.push("linux.base/1".into());
|
|
assert!(!action.available_for("agent_service", &both));
|
|
if let Action::RunScript {
|
|
interpreter,
|
|
script_utf8,
|
|
..
|
|
} = &mut action
|
|
{
|
|
*script_utf8 = "Write-Output 'é'".into();
|
|
assert!(interpreter == "powershell");
|
|
}
|
|
assert!(!action.validate());
|
|
if let Action::RunScript { script_utf8, .. } = &mut action {
|
|
*script_utf8 = "\u{feff}Write-Output 'é'\r\n".into();
|
|
}
|
|
assert!(action.validate());
|
|
let bytes = encode(&action).unwrap();
|
|
assert_eq!(serde_json::from_slice::<Action>(&bytes).unwrap(), action);
|
|
if let Action::RunScript { interpreter, .. } = &mut action {
|
|
*interpreter = "pwsh".into();
|
|
}
|
|
assert!(!action.validate());
|
|
assert!(!action.available_for("agent_service", &caps));
|
|
let refresh = Action::RefreshInventory {
|
|
scope: "windows.base".into(),
|
|
};
|
|
assert!(refresh.validate());
|
|
assert!(refresh.available_for(
|
|
"agent_service",
|
|
&[
|
|
"windows.base/1".into(),
|
|
"rmm.sync.v1".into(),
|
|
"refresh_inventory".into()
|
|
]
|
|
));
|
|
assert!(!refresh.available_for(
|
|
"root",
|
|
&[
|
|
"windows.base/1".into(),
|
|
"rmm.sync.v1".into(),
|
|
"refresh_inventory".into()
|
|
]
|
|
));
|
|
}
|
|
#[test]
|
|
fn full_maintenance_is_explicit_strict_identity_and_capability_bound() {
|
|
let legacy = br#"{"action":"run_script","interpreter":"posix_sh","script_utf8":"id\n","arguments":[],"expected_stdout":null}"#;
|
|
let mut action: Action = serde_json::from_slice(legacy).unwrap();
|
|
assert_eq!(encode(&action).unwrap(), legacy);
|
|
for value in [
|
|
serde_json::Value::Null,
|
|
serde_json::json!({"FullMaintenanceV1":null}),
|
|
serde_json::json!("latest"),
|
|
serde_json::json!(true),
|
|
] {
|
|
let mut input: serde_json::Value = serde_json::from_slice(legacy).unwrap();
|
|
input["privileged_script_profile"] = value;
|
|
assert!(serde_json::from_value::<Action>(input).is_err());
|
|
}
|
|
if let Action::RunScript {
|
|
privileged_script_profile,
|
|
..
|
|
} = &mut action
|
|
{
|
|
*privileged_script_profile = Some(PrivilegedScriptProfile::FullMaintenanceV1);
|
|
}
|
|
assert!(action.validate());
|
|
assert!(action.valid_execution_identity("root"));
|
|
assert!(!action.valid_execution_identity("agent_service"));
|
|
assert!(!action.valid_execution_identity("system"));
|
|
assert!(action.valid_job_limits(300, 65536));
|
|
assert!(!action.valid_job_limits(301, 65536));
|
|
assert!(!action.valid_job_limits(300, 65537));
|
|
let caps: Vec<String> = [
|
|
"linux.base/1",
|
|
"rmm.sync.v1",
|
|
"helper.root.v1",
|
|
"run_script",
|
|
"root:run_script",
|
|
FULL_MAINTENANCE_CAPABILITY,
|
|
]
|
|
.into_iter()
|
|
.map(str::to_owned)
|
|
.collect();
|
|
assert!(action.available_for("root", &caps));
|
|
for missing in &caps {
|
|
assert!(
|
|
!action.available_for(
|
|
"root",
|
|
&caps
|
|
.iter()
|
|
.filter(|c| *c != missing)
|
|
.cloned()
|
|
.collect::<Vec<_>>()
|
|
)
|
|
);
|
|
}
|
|
assert!(!action.available_for("agent_service", &caps));
|
|
if let Action::RunScript {
|
|
interpreter,
|
|
script_utf8,
|
|
windows_execution_profile,
|
|
..
|
|
} = &mut action
|
|
{
|
|
*interpreter = "powershell".into();
|
|
*script_utf8 = "Write-Output 'hi'\r\n".into();
|
|
*windows_execution_profile = Some(WindowsExecutionProfile::PowerShell51RemoteSigned);
|
|
}
|
|
assert!(action.valid_helper_denial_shape("system"));
|
|
assert!(!action.valid_helper_denial_shape("root"));
|
|
assert!(action.valid_job_limits(120, 65536));
|
|
assert!(!action.valid_job_limits(121, 65536));
|
|
let caps: Vec<String> = [
|
|
"windows.base/1",
|
|
"rmm.sync.v1",
|
|
"helper.system.v1",
|
|
"run_script",
|
|
"system:run_script",
|
|
"script.powershell/1",
|
|
"script.powershell.process_remote_signed/1",
|
|
FULL_MAINTENANCE_CAPABILITY,
|
|
]
|
|
.into_iter()
|
|
.map(str::to_owned)
|
|
.collect();
|
|
assert!(action.available_for("system", &caps));
|
|
for missing in &caps {
|
|
assert!(
|
|
!action.available_for(
|
|
"system",
|
|
&caps
|
|
.iter()
|
|
.filter(|c| *c != missing)
|
|
.cloned()
|
|
.collect::<Vec<_>>()
|
|
)
|
|
);
|
|
}
|
|
assert!(!action.available_for("root", &caps));
|
|
}
|
|
#[test]
|
|
fn script_console_golden_plans_use_actual_rust_codec() {
|
|
let cases: Vec<serde_json::Value> = serde_json::from_str(include_str!(
|
|
"../../../tests/script_console/codec-golden.json"
|
|
))
|
|
.unwrap();
|
|
assert_eq!(cases.len(), 3);
|
|
for case in cases {
|
|
let bytes: Vec<u8> =
|
|
serde_json::from_value(case["plan_payload_bytes"].clone()).unwrap();
|
|
let plan: PlanPayload = serde_json::from_slice(&bytes).unwrap();
|
|
assert_eq!(encode(&plan).unwrap(), bytes);
|
|
assert_eq!(hash(&bytes), case["plan_hash"]);
|
|
let job = &plan.jobs[0];
|
|
let job_bytes = encode(&job.payload).unwrap();
|
|
assert_eq!(
|
|
serde_json::to_value(&job_bytes).unwrap(),
|
|
case["job_payload_bytes"]
|
|
);
|
|
assert_eq!(hash(&job_bytes), job.job_payload_hash);
|
|
assert_eq!(job.job_payload_hash, case["job_payload_hash"]);
|
|
assert!(job.payload.action.validate());
|
|
assert!(
|
|
job.payload
|
|
.action
|
|
.valid_execution_identity(&job.payload.execution_identity)
|
|
);
|
|
let Action::RunScript { script_utf8, .. } = &job.payload.action else {
|
|
panic!("script fixture")
|
|
};
|
|
assert_eq!(hash(script_utf8.as_bytes()), case["script_sha256"]);
|
|
}
|
|
}
|
|
#[test]
|
|
fn codec_golden_and_exact_script_bytes() {
|
|
let a = Action::RunScript {
|
|
interpreter: "posix_sh".into(),
|
|
script_utf8: "echo hi\n".into(),
|
|
arguments: vec![],
|
|
expected_stdout: None,
|
|
windows_execution_profile: None,
|
|
privileged_script_profile: None,
|
|
};
|
|
assert_eq!(
|
|
String::from_utf8(encode(&a).unwrap()).unwrap(),
|
|
r#"{"action":"run_script","interpreter":"posix_sh","script_utf8":"echo hi\n","arguments":[],"expected_stdout":null}"#
|
|
);
|
|
assert_ne!(hash(b"echo hi\n"), hash(b"echo hi\r\n"));
|
|
assert_eq!(
|
|
hash(b"abc"),
|
|
"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
|
|
);
|
|
}
|
|
#[test]
|
|
fn windows_remote_signed_profile_is_optional_exact_and_capability_bound() {
|
|
let schema = schemars::schema_for!(Action).to_value();
|
|
let script_schema = schema["oneOf"]
|
|
.as_array()
|
|
.unwrap()
|
|
.iter()
|
|
.find(|variant| {
|
|
variant["properties"]
|
|
.get("windows_execution_profile")
|
|
.is_some()
|
|
})
|
|
.unwrap();
|
|
assert_eq!(
|
|
script_schema["properties"]["windows_execution_profile"],
|
|
serde_json::json!({"$ref":"#/$defs/WindowsExecutionProfile"})
|
|
);
|
|
assert!(
|
|
!script_schema["required"]
|
|
.as_array()
|
|
.unwrap()
|
|
.contains(&serde_json::json!("windows_execution_profile"))
|
|
);
|
|
assert_eq!(schema["$defs"]["WindowsExecutionProfile"]["type"], "string");
|
|
let legacy = br#"{"action":"run_script","interpreter":"powershell","script_utf8":"Write-Output 'hi'\r\n","arguments":[],"expected_stdout":null}"#;
|
|
let mut action: Action = serde_json::from_slice(legacy).unwrap();
|
|
assert_eq!(encode(&action).unwrap(), legacy);
|
|
let inherited_hash = hash(legacy);
|
|
if let Action::RunScript {
|
|
windows_execution_profile,
|
|
..
|
|
} = &mut action
|
|
{
|
|
*windows_execution_profile = Some(WindowsExecutionProfile::PowerShell51RemoteSigned);
|
|
}
|
|
let encoded = encode(&action).unwrap();
|
|
assert_eq!(
|
|
String::from_utf8(encoded.clone()).unwrap(),
|
|
String::from_utf8(legacy[..legacy.len() - 1].to_vec()).unwrap()
|
|
+ r#","windows_execution_profile":"powershell_51_remote_signed"}"#
|
|
);
|
|
assert_ne!(hash(&encoded), inherited_hash);
|
|
assert_eq!(serde_json::from_slice::<Action>(&encoded).unwrap(), action);
|
|
let caps: Vec<String> = [
|
|
"windows.base/1",
|
|
"rmm.sync.v1",
|
|
"run_script",
|
|
"script.powershell/1",
|
|
"script.powershell.process_remote_signed/1",
|
|
]
|
|
.into_iter()
|
|
.map(str::to_string)
|
|
.collect();
|
|
assert!(action.validate());
|
|
assert!(action.available_for("agent_service", &caps));
|
|
for missing in 0..caps.len() {
|
|
let mut short = caps.clone();
|
|
short.remove(missing);
|
|
assert!(!action.available_for("agent_service", &short));
|
|
}
|
|
for identity in ["root", "system", "SYSTEM"] {
|
|
assert!(!action.available_for(identity, &caps));
|
|
}
|
|
let mut mixed = caps.clone();
|
|
mixed.push("linux.base/1".into());
|
|
assert!(!action.available_for("agent_service", &mixed));
|
|
for interpreter in ["posix_sh", "bash", "pwsh"] {
|
|
let mut invalid = action.clone();
|
|
if let Action::RunScript { interpreter: i, .. } = &mut invalid {
|
|
*i = interpreter.into();
|
|
}
|
|
assert!(!invalid.validate());
|
|
assert!(!invalid.available_for("agent_service", &caps));
|
|
assert!(!invalid.available_for("root", &["linux.base/1".into(), "run_script".into()]));
|
|
}
|
|
for profile in [
|
|
serde_json::Value::Null,
|
|
serde_json::json!(false),
|
|
serde_json::json!(1),
|
|
serde_json::json!([]),
|
|
serde_json::json!({}),
|
|
serde_json::json!({"powershell_51_remote_signed": null}),
|
|
serde_json::json!("bypass"),
|
|
serde_json::json!("RemoteSigned"),
|
|
serde_json::json!("powershell_7_remote_signed"),
|
|
] {
|
|
let mut bad = serde_json::to_value(&action).unwrap();
|
|
bad["windows_execution_profile"] = profile.clone();
|
|
assert!(serde_json::from_value::<Action>(bad).is_err(), "{profile}");
|
|
// An opt-in profile is also never metadata on another action.
|
|
assert!(
|
|
serde_json::from_value::<Action>(serde_json::json!({
|
|
"action":"refresh_inventory", "scope":"windows.base",
|
|
"windows_execution_profile":profile
|
|
}))
|
|
.is_err()
|
|
);
|
|
}
|
|
}
|
|
#[test]
|
|
fn windows_event_log_fixture_scope_limits_and_exact_24h_preserve_linux_bytes() {
|
|
let since = DateTime::parse_from_rfc3339("2026-11-14T00:00:00Z")
|
|
.unwrap()
|
|
.with_timezone(&Utc);
|
|
let mut action = Action::QueryLogs {
|
|
unit: WINDOWS_EVENT_LOG_FIXTURE_SOURCE.into(),
|
|
since,
|
|
until: since + chrono::Duration::hours(24),
|
|
max_lines: 1000,
|
|
};
|
|
let caps: Vec<String> = [
|
|
"windows.base/1",
|
|
"rmm.sync.v1",
|
|
"query_logs",
|
|
WINDOWS_EVENT_LOG_FIXTURE_CAPABILITY,
|
|
]
|
|
.into_iter()
|
|
.map(str::to_string)
|
|
.collect();
|
|
assert!(action.validate());
|
|
assert!(action.available_for("agent_service", &caps));
|
|
assert!(action.valid_job_limits(10, 1024));
|
|
assert!(action.valid_job_limits(120, 65536));
|
|
for (runtime, bytes) in [(9, 1024), (121, 1024), (10, 1023), (10, 65537)] {
|
|
assert!(!action.valid_job_limits(runtime, bytes));
|
|
}
|
|
for i in 0..caps.len() {
|
|
let mut short = caps.clone();
|
|
short.remove(i);
|
|
assert!(!action.available_for("agent_service", &short));
|
|
}
|
|
for identity in ["root", "system", "SYSTEM"] {
|
|
assert!(!action.available_for(identity, &caps));
|
|
}
|
|
let mut mixed = caps.clone();
|
|
mixed.push("linux.base/1".into());
|
|
assert!(!action.available_for("agent_service", &mixed));
|
|
assert!(!action.available_for("root", &["linux.base/1".into(), "query_logs".into()]));
|
|
for unit in [
|
|
"Application",
|
|
"Security",
|
|
"windows.eventlog.application.other",
|
|
] {
|
|
let mut wrong = action.clone();
|
|
if let Action::QueryLogs { unit: u, .. } = &mut wrong {
|
|
*u = unit.into();
|
|
}
|
|
assert!(!wrong.available_for("agent_service", &caps));
|
|
}
|
|
if let Action::QueryLogs { until, .. } = &mut action {
|
|
*until += chrono::Duration::nanoseconds(1);
|
|
}
|
|
assert!(!action.validate());
|
|
let linux = Action::QueryLogs {
|
|
unit: "rmm-test.service".into(),
|
|
since,
|
|
until: since + chrono::Duration::hours(24),
|
|
max_lines: 1000,
|
|
};
|
|
assert_eq!(
|
|
String::from_utf8(encode(&linux).unwrap()).unwrap(),
|
|
r#"{"action":"query_logs","unit":"rmm-test.service","since":"2026-11-14T00:00:00Z","until":"2026-11-15T00:00:00Z","max_lines":1000}"#
|
|
);
|
|
assert!(linux.validate());
|
|
for identity in ["root", "agent_service"] {
|
|
assert!(linux.available_for(identity, &["linux.base/1".into(), "query_logs".into()]));
|
|
}
|
|
let mut too_long = linux;
|
|
if let Action::QueryLogs { until, .. } = &mut too_long {
|
|
*until += chrono::Duration::minutes(59);
|
|
}
|
|
assert!(!too_long.validate());
|
|
let pre_epoch = Action::QueryLogs {
|
|
unit: WINDOWS_EVENT_LOG_FIXTURE_SOURCE.into(),
|
|
since: DateTime::from_timestamp(-1, 0).unwrap(),
|
|
until: DateTime::from_timestamp(0, 0).unwrap(),
|
|
max_lines: 1,
|
|
};
|
|
assert!(!pre_epoch.validate());
|
|
}
|
|
#[test]
|
|
fn no_terminal_replay_or_unknown_restart() {
|
|
assert!(!JobState::Succeeded.allows(JobState::Running));
|
|
assert!(!JobState::Unknown.allows(JobState::Running));
|
|
assert!(JobState::Accepted.allows(JobState::Unknown));
|
|
}
|
|
#[test]
|
|
fn permit_codec_golden_all_bindings() {
|
|
let id = Uuid::nil();
|
|
let epoch = DateTime::<Utc>::from_timestamp(0, 0).unwrap();
|
|
let p = ExecutionPermitPayload {
|
|
agent_update_plan_id: None,
|
|
domain: "rmm.execution-permit".into(),
|
|
schema_version: 1,
|
|
grant_id: id,
|
|
authorization_id: id,
|
|
tenant_id: id,
|
|
asset_id: id,
|
|
agent_id: id,
|
|
enrollment_generation: 1,
|
|
assignment_version: 2,
|
|
job_id: id,
|
|
attempt_id: id,
|
|
plan_hash: "plan".into(),
|
|
job_payload_hash: "job".into(),
|
|
action: "run_script".into(),
|
|
execution_identity: "agent_service".into(),
|
|
not_before: epoch,
|
|
start_before: epoch,
|
|
max_runtime_seconds: 60,
|
|
key_id: "key".into(),
|
|
};
|
|
let golden = r#"{"domain":"rmm.execution-permit","schema_version":1,"grant_id":"00000000-0000-0000-0000-000000000000","authorization_id":"00000000-0000-0000-0000-000000000000","tenant_id":"00000000-0000-0000-0000-000000000000","asset_id":"00000000-0000-0000-0000-000000000000","agent_id":"00000000-0000-0000-0000-000000000000","enrollment_generation":1,"assignment_version":2,"job_id":"00000000-0000-0000-0000-000000000000","attempt_id":"00000000-0000-0000-0000-000000000000","plan_hash":"plan","job_payload_hash":"job","action":"run_script","execution_identity":"agent_service","not_before":"1970-01-01T00:00:00Z","start_before":"1970-01-01T00:00:00Z","max_runtime_seconds":60,"key_id":"key"}"#;
|
|
assert_eq!(encode(&p).unwrap(), golden.as_bytes());
|
|
assert_eq!(
|
|
serde_json::from_slice::<ExecutionPermitPayload>(golden.as_bytes()).unwrap(),
|
|
p
|
|
);
|
|
}
|
|
#[test]
|
|
fn additive_recipe_refs_preserve_legacy_plan_bytes() {
|
|
let legacy=br#"{"schema_version":1,"plan_id":"00000000-0000-0000-0000-000000000000","tenant_id":"00000000-0000-0000-0000-000000000000","principal":"fixture","reason":"legacy","jobs":[],"max_parallel":1,"halt_after_failures":1}"#;
|
|
let decoded: PlanPayload = serde_json::from_slice(legacy).unwrap();
|
|
assert!(decoded.recipe_references.is_empty());
|
|
assert_eq!(encode(&decoded).unwrap(), legacy);
|
|
}
|
|
#[test]
|
|
fn updates_require_exact_versions_and_never_implicit_reboot() {
|
|
let exact = Action::ApplyUpdates {
|
|
provider: "apt".into(),
|
|
packages: vec!["fixture=1:2.0~rc1+test".into()],
|
|
reboot_policy: "never".into(),
|
|
apt_manifest: None,
|
|
};
|
|
assert!(exact.validate_plan_shape());
|
|
assert!(!exact.validate());
|
|
let broad = Action::ApplyUpdates {
|
|
provider: "apt".into(),
|
|
packages: vec!["fixture".into()],
|
|
reboot_policy: "never".into(),
|
|
apt_manifest: None,
|
|
};
|
|
assert!(!broad.validate());
|
|
}
|
|
}
|