//! Additive bounded passive metadata; the strict original Inventory stays intact. use chrono::{DateTime, Utc}; use serde::Deserialize; use serde_json::Value; #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct Observation { scope: String, source_id: String, observed_at: DateTime, quality: String, completeness: String, truncated: bool, error_code: Option, data: Value, } pub fn validate(bytes: &[u8], now: DateTime) -> Result { validate_for_scope(bytes, now, "linux.base") } /// Snapshot scope is supplied by the authenticated ingestion path, never inferred /// from an arbitrary observation's label. Windows does not manufacture inodes. pub fn validate_for_scope( bytes: &[u8], now: DateTime, scope: &str, ) -> Result { let prefix = match scope { "linux.base" => "linux.", "windows.base" => "windows.", _ => return Err("UNSUPPORTED_INVENTORY_SCOPE"), }; if bytes.len() > 512 * 1024 { return Err("INVENTORY_SIZE"); } let value: Value = serde_json::from_slice(bytes).map_err(|_| "INVALID_INVENTORY_JSON")?; let mut base = value.as_object().cloned().ok_or("INVENTORY_OBJECT")?; let observations = base.remove("observations"); let started = base.remove("collection_started_at"); let completed = base.remove("collection_completed_at"); if scope == "windows.base" { #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct WindowsInventory { os: String, hostname: String, architecture: String, root_total_bytes: u64, root_available_bytes: u64, root_available_inodes: Option, } let inventory: WindowsInventory = serde_json::from_value(Value::Object(base)).map_err(|_| "INVALID_BASE_INVENTORY")?; if !inventory.os.starts_with("Windows") || inventory.os.len() > 4096 || inventory.hostname.is_empty() || inventory.hostname.len() > 255 || inventory.architecture != "x86_64" || inventory.root_total_bytes == 0 || inventory.root_available_bytes > inventory.root_total_bytes || inventory.root_available_inodes.is_some() { return Err("INVALID_WINDOWS_BASE_INVENTORY"); } } else { let inventory: crate::Inventory = serde_json::from_value(Value::Object(base)).map_err(|_| "INVALID_BASE_INVENTORY")?; if !inventory.validate() { return Err("INVALID_BASE_INVENTORY"); } } if let Some(observations) = observations { let started: DateTime = serde_json::from_value(started.ok_or("COLLECTION_WINDOW_REQUIRED")?) .map_err(|_| "INVALID_COLLECTION_TIME")?; let completed: DateTime = serde_json::from_value(completed.ok_or("COLLECTION_WINDOW_REQUIRED")?) .map_err(|_| "INVALID_COLLECTION_TIME")?; if started > completed || (completed - started).num_seconds() > 3600 || (now - started).num_seconds() > 72 * 3600 || (completed - now).num_seconds() > 45 { return Err("INVALID_COLLECTION_WINDOW"); } let observations = observations.as_array().ok_or("OBSERVATION_ARRAY")?; if observations.len() > 32 { return Err("OBSERVATION_COUNT"); } let mut scopes = std::collections::BTreeSet::new(); for item in observations { if serde_json::to_vec(item) .map_err(|_| "INVALID_OBSERVATION")? .len() > 32768 { return Err("OBSERVATION_SIZE"); } let o: Observation = serde_json::from_value(item.clone()).map_err(|_| "INVALID_OBSERVATION")?; if !o.scope.starts_with(prefix) || o.scope.len() > 64 || !(o .scope .bytes() .all(|c| c.is_ascii_lowercase() || b"._".contains(&c)) || (scope == "linux.base" && o.scope == "linux.apt.recovery-planning")) || !scopes.insert(o.scope) { return Err("INVALID_OBSERVATION_SCOPE"); } if o.source_id.is_empty() || o.source_id.len() > 255 || o.source_id.contains('\0') || o.observed_at < started - chrono::Duration::seconds(1) || o.observed_at > completed + chrono::Duration::seconds(1) || !matches!( o.quality.as_str(), "valid" | "unknown" | "unsupported" | "permission_denied" | "error" ) || !matches!(o.completeness.as_str(), "complete" | "partial" | "unknown") || (o.truncated && o.completeness == "complete") || o.error_code.as_ref().is_some_and(|s| s.len() > 128) || (o.quality == "valid" && o.data.is_null()) { return Err("INVALID_OBSERVATION_METADATA"); } } } else if started.is_some() || completed.is_some() { return Err("OBSERVATIONS_REQUIRED"); } Ok(value) } #[cfg(test)] mod tests { use super::*; use serde_json::json; fn base() -> Value { json!({"os":"Linux","hostname":"fixture","architecture":"x86_64","root_total_bytes":2,"root_available_bytes":1,"root_available_inodes":1}) } #[test] fn additive_metadata_and_bounds() { let now = Utc::now(); let mut v = base(); assert!(validate(&serde_json::to_vec(&v).unwrap(), now).is_ok()); v["observations"] = json!([{"scope":"linux.smart","source_id":"linux.smart","observed_at":now,"quality":"unsupported","completeness":"unknown","truncated":false,"error_code":"NOT_SUPPORTED","data":null}]); v["collection_started_at"] = json!(now); v["collection_completed_at"] = json!(now); assert_eq!(validate(&serde_json::to_vec(&v).unwrap(), now).unwrap(), v); v["observations"][0]["data"] = json!("x".repeat(32768)); assert_eq!( validate(&serde_json::to_vec(&v).unwrap(), now).unwrap_err(), "OBSERVATION_SIZE" ); let mut unknown = base(); unknown["tenant_id"] = json!("forged"); assert!(validate(&serde_json::to_vec(&unknown).unwrap(), now).is_err()); } #[test] fn windows_scope_does_not_weaken_linux_or_accept_platform_spoofing() { let now = Utc::now(); let mut v = base(); v["os"] = json!("Windows 11 Pro"); v["root_available_inodes"] = Value::Null; let bytes = serde_json::to_vec(&v).unwrap(); assert!(validate(&bytes, now).is_err()); assert!(validate_for_scope(&bytes, now, "windows.base").is_ok()); assert!(validate_for_scope(&bytes, now, "arbitrary.base").is_err()); v["root_available_inodes"] = json!(0); assert!(validate_for_scope(&serde_json::to_vec(&v).unwrap(), now, "windows.base").is_err()); v["root_available_inodes"] = Value::Null; v["collection_started_at"] = json!(now); v["collection_completed_at"] = json!(now); v["observations"] = json!([{"scope":"linux.os","source_id":"windows.native","observed_at":now,"quality":"valid","completeness":"partial","truncated":false,"error_code":null,"data":{}}]); assert_eq!( validate_for_scope(&serde_json::to_vec(&v).unwrap(), now, "windows.base").unwrap_err(), "INVALID_OBSERVATION_SCOPE" ); v["observations"][0]["scope"] = json!("windows.os"); assert!(validate_for_scope(&serde_json::to_vec(&v).unwrap(), now, "windows.base").is_ok()); } #[test] fn exact_linux_recovery_scope_does_not_admit_other_hyphens_or_windows() { let now = Utc::now(); let mut v = base(); v["collection_started_at"] = json!(now); v["collection_completed_at"] = json!(now); v["observations"] = json!([{"scope":"linux.apt.recovery-planning","source_id":"root-helper:apt_recovery_planning_v1","observed_at":now,"quality":"valid","completeness":"complete","truncated":false,"error_code":null,"data":{"native_recovery":{"schema_version":1}}}]); let original = serde_json::to_vec(&v).unwrap(); assert_eq!(validate(&original, now).unwrap(), v); for rejected in [ "linux.apt.other-planning", "linux.apt.recovery-planning-extra", "linux.other-scope", ] { v["observations"][0]["scope"] = json!(rejected); assert_eq!( validate(&serde_json::to_vec(&v).unwrap(), now).unwrap_err(), "INVALID_OBSERVATION_SCOPE" ); } v["os"] = json!("Windows 11 Pro"); v["root_available_inodes"] = Value::Null; for rejected in [ "linux.apt.recovery-planning", "windows.apt.recovery-planning", ] { v["observations"][0]["scope"] = json!(rejected); assert_eq!( validate_for_scope(&serde_json::to_vec(&v).unwrap(), now, "windows.base") .unwrap_err(), "INVALID_OBSERVATION_SCOPE" ); } } }