//! Windows MSI fixture contract. No legacy Linux codec is changed. //! Fixed1.0 first installation/noop and separate1.0→1.1 major-upgrade/noop //! recipes only. No implicit REINSTALL, repair, downgrade or fresh1.1 mode. use serde::{Deserialize, Serialize}; use sha2::{Digest, Sha256}; use uuid::Uuid; pub const MSI_PACKAGE_ID: &str = "rmm-windows-msi-fixture"; pub const MSI_CAPABILITY: &str = "package.msi.fixture/1"; pub const MSI_RECIPE_ID: &str = "rmm-windows-msi-fixture-install-1.0"; pub const MSI_PRODUCT_CODE: &str = "{3F070B4B-9C08-4D65-BD41-13D81B884AEC}"; pub const MSI_UPGRADE_CODE: &str = "{C9BF1FB8-E31D-4BD7-BA0D-AB46539BBBAA}"; pub const MSI_VERSION: &str = "1.0.0"; pub const MSI_PAYLOAD: &str = r"C:\Program Files\RustDiscoveryFixtures\msi-payload.txt"; pub const MSI_UPGRADE_RECIPE_ID: &str = "rmm-windows-msi-fixture-upgrade-1.1"; pub const MSI_UPGRADE_PRODUCT_CODE: &str = "{D42BD387-079B-4BBF-A134-0DA7B7A97011}"; pub const MSI_UPGRADE_VERSION: &str = "1.1.0"; pub const MSI_PAYLOAD_BYTES: u64 = 33; pub const MSI_PAYLOAD_10_SHA256: &str = "0c90c4fc7233017cc88c0e925095d6662ac57abdb303c7527ef59d02b454fca0"; pub const MSI_PAYLOAD_11_SHA256: &str = "ba0c83deff9eed014009bcd45369b2a356ae909ebf0c1434dc836b0e6d759c49"; pub const MSI_OLD_PRODUCTS: &str = "RMM_OLD_PRODUCTS"; pub const MSI_ALL_PRODUCTS: &str = "RMM_ALL_PRODUCTS"; pub const MSI_UPGRADE_CONDITION: &str = "Installed OR (RMM_OLD_PRODUCTS = \"{3F070B4B-9C08-4D65-BD41-13D81B884AEC}\" AND RMM_ALL_PRODUCTS = \"{3F070B4B-9C08-4D65-BD41-13D81B884AEC}\")"; #[derive(Clone, Debug, PartialEq, Eq, Serialize, schemars::JsonSchema)] #[serde(rename_all = "snake_case")] pub enum Architecture { X64, } #[derive(Clone, Debug, PartialEq, Eq, Serialize, schemars::JsonSchema)] #[serde(rename_all = "snake_case")] pub enum InstallContext { Machine, } #[derive(Clone, Debug, PartialEq, Eq, Serialize, schemars::JsonSchema)] #[serde(rename_all = "snake_case")] pub enum MsiCommandProfile { FixtureQuietNoRebootV1, } impl<'de> Deserialize<'de> for Architecture { fn deserialize>(deserializer: D) -> Result { let value = String::deserialize(deserializer)?; if value == "x64" { Ok(Self::X64) } else { Err(serde::de::Error::unknown_variant(&value, &["x64"])) } } } impl<'de> Deserialize<'de> for InstallContext { fn deserialize>(deserializer: D) -> Result { let value = String::deserialize(deserializer)?; if value == "machine" { Ok(Self::Machine) } else { Err(serde::de::Error::unknown_variant(&value, &["machine"])) } } } impl<'de> Deserialize<'de> for MsiCommandProfile { fn deserialize>(deserializer: D) -> Result { let value = String::deserialize(deserializer)?; if value == "fixture_quiet_no_reboot_v1" { Ok(Self::FixtureQuietNoRebootV1) } else { Err(serde::de::Error::unknown_variant( &value, &["fixture_quiet_no_reboot_v1"], )) } } } #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)] #[serde(deny_unknown_fields)] pub struct MsiArtifact { pub artifact_id: Uuid, pub sha256: String, pub bytes: u64, } #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)] #[serde(deny_unknown_fields)] pub struct MsiPostcondition { pub product_code: String, pub product_version: String, pub payload_path: String, pub payload_sha256: String, pub payload_bytes: u64, } #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)] #[serde(deny_unknown_fields)] pub struct WindowsMsiRecipe { pub schema_version: u32, pub recipe_id: String, pub recipe_version: String, pub platform: String, pub upgrade_code: String, pub architecture: Architecture, pub context: InstallContext, pub command_profile: MsiCommandProfile, pub artifact: MsiArtifact, pub postcondition: MsiPostcondition, pub no_reboot: bool, // Appended opt-in metadata: old1.0 recipes retain exactly their old bytes. #[serde(default, skip_serializing_if = "Option::is_none")] pub package_code: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub predecessor: Option, } #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)] #[serde(deny_unknown_fields)] pub struct ResolvedWindowsMsi { pub recipe: WindowsMsiRecipe, /// SHA256 of exactly serde_json::to_vec(recipe), not a self-reference. pub recipe_sha256: String, } pub fn digest(value: &str) -> bool { value.len() == 64 && value .bytes() .all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b)) } pub fn valid_package_code(value: &str) -> bool { Uuid::parse_str(value).is_ok_and(|id| { !id.is_nil() && value == format!("{{{}}}", id.to_string().to_uppercase()) && ![MSI_PRODUCT_CODE, MSI_UPGRADE_PRODUCT_CODE, MSI_UPGRADE_CODE].contains(&value) }) } impl WindowsMsiRecipe { pub fn validate(&self) -> bool { self.schema_version == 1 && self.recipe_version == "1" && self.platform == "windows" && self.upgrade_code == MSI_UPGRADE_CODE && self.no_reboot && !self.artifact.artifact_id.is_nil() && digest(&self.artifact.sha256) && (1..=262144).contains(&self.artifact.bytes) && self.postcondition.payload_path == MSI_PAYLOAD && digest(&self.postcondition.payload_sha256) && (1..=65536).contains(&self.postcondition.payload_bytes) && match self.recipe_id.as_str() { MSI_RECIPE_ID => { self.postcondition.product_code == MSI_PRODUCT_CODE && self.postcondition.product_version == MSI_VERSION && self.package_code.is_none() && self.predecessor.is_none() } MSI_UPGRADE_RECIPE_ID => { self.postcondition.product_code == MSI_UPGRADE_PRODUCT_CODE && self.postcondition.product_version == MSI_UPGRADE_VERSION && self.postcondition.payload_sha256 == MSI_PAYLOAD_11_SHA256 && self.postcondition.payload_bytes == MSI_PAYLOAD_BYTES && self.package_code.as_deref().is_some_and(valid_package_code) && self.predecessor.as_ref().is_some_and(|old| { old.product_code == MSI_PRODUCT_CODE && old.product_version == MSI_VERSION && old.payload_path == MSI_PAYLOAD && old.payload_sha256 == MSI_PAYLOAD_10_SHA256 && old.payload_bytes == MSI_PAYLOAD_BYTES }) } _ => false, } } pub fn sha256(&self) -> Result { Ok(format!("{:x}", Sha256::digest(serde_json::to_vec(self)?))) } } impl ResolvedWindowsMsi { pub fn validate(&self) -> bool { self.recipe.validate() && digest(&self.recipe_sha256) && self .recipe .sha256() .is_ok_and(|sha| sha == self.recipe_sha256) } } #[cfg(test)] mod tests { use super::*; fn recipe() -> WindowsMsiRecipe { WindowsMsiRecipe { schema_version: 1, recipe_id: MSI_RECIPE_ID.into(), recipe_version: "1".into(), platform: "windows".into(), upgrade_code: MSI_UPGRADE_CODE.into(), architecture: Architecture::X64, context: InstallContext::Machine, command_profile: MsiCommandProfile::FixtureQuietNoRebootV1, artifact: MsiArtifact { artifact_id: Uuid::new_v4(), sha256: "ab".repeat(32), bytes: 1234, }, postcondition: MsiPostcondition { product_code: MSI_PRODUCT_CODE.into(), product_version: MSI_VERSION.into(), payload_path: MSI_PAYLOAD.into(), payload_sha256: "cd".repeat(32), payload_bytes: 20, }, no_reboot: true, package_code: None, predecessor: None, } } #[test] fn ensure_msi_action_is_strict_opt_in_and_system_windows_only_without_linux_byte_changes() { use crate::jobs::{Action, encode}; let old=br#"{"action":"ensure_package","provider":"apt","package":"rmm-test","version":"1.0","architecture":"amd64","recipe_version":"1","installation_context":"system"}"#; let legacy: Action = serde_json::from_slice(old).unwrap(); assert!(legacy.validate_plan_shape()); assert!(legacy.windows_msi().is_none()); assert_eq!(encode(&legacy).unwrap(), old); let recipe = recipe(); let m = ResolvedWindowsMsi { recipe_sha256: recipe.sha256().unwrap(), recipe, }; let action = Action::EnsurePackage { provider: "msi".into(), package: MSI_PACKAGE_ID.into(), version: MSI_VERSION.into(), architecture: "x64".into(), recipe_version: "1".into(), installation_context: "machine".into(), recipe_id: Some(MSI_RECIPE_ID.into()), apt_manifest: None, windows_msi_manifest: Some(Box::new(m)), }; assert!(action.validate()); assert!(action.valid_helper_denial_shape("system")); assert!(!action.valid_helper_denial_shape("root")); let caps: Vec = [ "ensure_package", "windows.base/1", "rmm.sync.v1", "helper.system.v1", "system:ensure_package", MSI_CAPABILITY, ] .into_iter() .map(str::to_owned) .collect(); assert!(action.available_for("system", &caps)); for identity in ["root", "agent_service"] { assert!(!action.available_for(identity, &caps)); } for i in 0..caps.len() { let mut short = caps.clone(); short.remove(i); assert!(!action.available_for("system", &short)); } let mut mixed = caps; mixed.push("linux.base/1".into()); assert!(!action.available_for("system", &mixed)); for (key, value) in [ ("provider", serde_json::json!("apt")), ("architecture", serde_json::json!("amd64")), ("installation_context", serde_json::json!("system")), ("version", serde_json::json!("1.1.0")), ] { let mut bad = serde_json::to_value(&action).unwrap(); bad[key] = value; assert!(!serde_json::from_value::(bad).unwrap().validate()); } for value in [ serde_json::Value::Null, serde_json::json!(false), serde_json::json!(1), serde_json::json!([]), serde_json::json!({}), ] { let mut bad = serde_json::to_value(&action).unwrap(); bad["windows_msi_manifest"] = value; assert!(serde_json::from_value::(bad).is_err()); } for (key, value) in [ ("architecture", "x64"), ("context", "machine"), ("command_profile", "fixture_quiet_no_reboot_v1"), ] { let mut bad = serde_json::to_value(&action).unwrap(); bad["windows_msi_manifest"]["recipe"][key] = serde_json::json!({value:null}); assert!(serde_json::from_value::(bad).is_err()); } for (runtime, bytes) in [(9, 4096), (121, 4096), (10, 1023), (10, 65537)] { assert!(!action.valid_job_limits(runtime, bytes)); } let schema = schemars::schema_for!(Action).to_value(); let pkg = schema["oneOf"] .as_array() .unwrap() .iter() .find(|v| v["properties"].get("windows_msi_manifest").is_some()) .unwrap(); assert_eq!( pkg["properties"]["windows_msi_manifest"], serde_json::json!({"$ref":"#/$defs/ResolvedWindowsMsi"}) ); assert!( !pkg["required"] .as_array() .unwrap() .contains(&serde_json::json!("windows_msi_manifest")) ); } #[test] fn major_upgrade_requires_explicit_exact_predecessor_new_package_and_same_family() { let old = recipe(); let old_bytes = serde_json::to_vec(&old).unwrap(); assert!( !String::from_utf8(old_bytes.clone()) .unwrap() .contains("predecessor") ); assert_eq!( serde_json::to_vec(&serde_json::from_slice::(&old_bytes).unwrap()) .unwrap(), old_bytes ); let mut r = old.clone(); r.recipe_id = MSI_UPGRADE_RECIPE_ID.into(); r.package_code = Some("{8475C4D1-6EE2-4C3A-B41D-D834A20F4135}".into()); r.postcondition.product_code = MSI_UPGRADE_PRODUCT_CODE.into(); r.postcondition.product_version = MSI_UPGRADE_VERSION.into(); r.postcondition.payload_sha256 = MSI_PAYLOAD_11_SHA256.into(); r.postcondition.payload_bytes = MSI_PAYLOAD_BYTES; r.predecessor = Some(MsiPostcondition { product_code: MSI_PRODUCT_CODE.into(), product_version: MSI_VERSION.into(), payload_path: MSI_PAYLOAD.into(), payload_sha256: MSI_PAYLOAD_10_SHA256.into(), payload_bytes: MSI_PAYLOAD_BYTES, }); assert!(r.validate()); assert_ne!(r.sha256().unwrap(), old.sha256().unwrap()); for case in 0..8 { let mut bad = r.clone(); match case { 0 => bad.predecessor = None, 1 => bad.package_code = None, 2 => bad.package_code = Some(MSI_PRODUCT_CODE.into()), 3 => bad.upgrade_code = Uuid::new_v4().to_string(), 4 => { bad.predecessor.as_mut().unwrap().product_code = MSI_UPGRADE_PRODUCT_CODE.into() } 5 => bad.predecessor.as_mut().unwrap().payload_sha256 = "aa".repeat(32), 6 => bad.postcondition.product_version = "1.2.0".into(), _ => bad.postcondition.payload_sha256 = MSI_PAYLOAD_10_SHA256.into(), }; assert!(!bad.validate()); } } #[test] fn immutable_fixture_recipe_rejects_reboot_url_transform_and_implicit_upgrade() { let recipe = recipe(); let bound = ResolvedWindowsMsi { recipe_sha256: recipe.sha256().unwrap(), recipe: recipe.clone(), }; assert!(bound.validate()); let mut changed = bound.clone(); changed.recipe.artifact.bytes += 1; assert!(!changed.validate()); for case in 0..6 { let mut r = recipe.clone(); match case { 0 => r.no_reboot = false, 1 => r.postcondition.product_code = Uuid::new_v4().to_string(), 2 => r.postcondition.product_version = "1.1.0".into(), 3 => r.postcondition.payload_path = r"\\server\share\payload".into(), 4 => r.artifact.bytes = 262145, _ => r.platform = "linux".into(), }; assert!(!r.validate()); } let mut value = serde_json::to_value(recipe).unwrap(); value["transforms"] = serde_json::json!(["unapproved.mst"]); assert!(serde_json::from_value::(value).is_err()); } }