runtime_ownership.rs (13494B)
1 //! Runtime input ownership data. Output declarations never exempt source from audits. 2 use serde::Deserialize; 3 use std::collections::BTreeSet; 4 5 pub const MAP_PATH: &str = "config/repository/runtime-ownership.v1.json"; 6 7 #[derive(Clone, Copy, Debug, Deserialize, Eq, Ord, PartialEq, PartialOrd)] 8 #[serde(rename_all = "snake_case")] 9 pub enum Owner { 10 Native, 11 Web, 12 Interop, 13 Governance, 14 } 15 16 #[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq)] 17 #[serde(rename_all = "snake_case")] 18 enum Kind { 19 Exact, 20 Prefix, 21 } 22 23 #[derive(Debug, Deserialize)] 24 #[serde(deny_unknown_fields)] 25 struct Rule { 26 path: String, 27 kind: Kind, 28 owners: Vec<Owner>, 29 } 30 31 #[derive(Debug, Deserialize)] 32 #[serde(deny_unknown_fields)] 33 pub struct OwnershipMap { 34 schema_version: u32, 35 owners: Vec<Owner>, 36 inputs: Vec<Rule>, 37 outputs: Vec<Rule>, 38 } 39 40 #[derive(Debug, Eq, PartialEq)] 41 pub struct Classification { 42 pub owners: Vec<Owner>, 43 pub reason: Option<String>, 44 } 45 46 fn validate_path(path: &str) -> Result<(), String> { 47 if path.is_empty() 48 || path 49 .chars() 50 .any(|c| c.is_control() || matches!(c, '\\' | ':' | '%' | '*' | '?')) 51 || path.split('/').any(|part| matches!(part, "" | "." | "..")) 52 { 53 return Err(format!( 54 "invalid repository-relative ownership path: {path:?}" 55 )); 56 } 57 Ok(()) 58 } 59 60 // Ownership declarations forbid glob syntax. Inventory paths are literal file 61 // identities: brackets in Svelte routes are never interpreted as patterns. 62 fn validate_declaration_path(path: &str) -> Result<(), String> { 63 validate_path(path)?; 64 if path.contains(['[', ']']) { 65 return Err(format!( 66 "invalid repository-relative ownership declaration: {path:?}" 67 )); 68 } 69 Ok(()) 70 } 71 72 impl Rule { 73 fn matches(&self, path: &str) -> bool { 74 path == self.path 75 || (self.kind == Kind::Prefix 76 && path 77 .strip_prefix(&self.path) 78 .is_some_and(|rest| rest.starts_with('/'))) 79 } 80 } 81 82 impl OwnershipMap { 83 pub fn parse(source: &str) -> Result<Self, String> { 84 // No escaped path aliases, including unicode-escaped separators or field names. 85 if source.contains('\\') { 86 return Err("ownership JSON escapes are not allowed".to_owned()); 87 } 88 let map: Self = serde_json::from_str(source) 89 .map_err(|error| format!("invalid ownership JSON: {error}"))?; 90 if map.schema_version != 1 { 91 return Err("unsupported ownership schema version".to_owned()); 92 } 93 if map.owners.len() != 4 || map.owners.iter().copied().collect::<BTreeSet<_>>().len() != 4 { 94 return Err( 95 "ownership map must declare each of the four owners exactly once".to_owned(), 96 ); 97 } 98 for rules in [&map.inputs, &map.outputs] { 99 if rules.is_empty() { 100 return Err("ownership rule list is empty".to_owned()); 101 } 102 for (index, rule) in rules.iter().enumerate() { 103 validate_declaration_path(&rule.path)?; 104 if rule.owners.is_empty() 105 || rule.owners.iter().copied().collect::<BTreeSet<_>>().len() 106 != rule.owners.len() 107 { 108 return Err(format!("empty or duplicate owners for {}", rule.path)); 109 } 110 for previous in &rules[..index] { 111 if previous.matches(&rule.path) || rule.matches(&previous.path) { 112 return Err(format!( 113 "overlapping ownership declarations: {} and {}", 114 previous.path, rule.path 115 )); 116 } 117 } 118 } 119 } 120 Ok(map) 121 } 122 123 pub fn classify(&self, path: &str) -> Result<Classification, String> { 124 validate_path(path)?; 125 match self.inputs.iter().find(|rule| rule.matches(path)) { 126 Some(rule) => Ok(Classification { 127 owners: rule.owners.clone(), 128 reason: None, 129 }), 130 None => Ok(Classification { 131 owners: self.owners.clone(), 132 reason: Some(format!( 133 "unclassified input {path}: conservatively select all potential owners" 134 )), 135 }), 136 } 137 } 138 139 pub fn validate_native_inputs(&self, paths: &[String]) -> Result<(), String> { 140 for required in required_native_inputs() { 141 if !paths.iter().any(|path| path == required) { 142 return Err(format!("required native input is missing: {required}")); 143 } 144 } 145 for path in paths { 146 if required_native_inputs().contains(&path.as_str()) 147 || [ 148 "app/", 149 "core/", 150 "gradle/", 151 "build-logic/", 152 "tools/design_catalog/", 153 "tools/xtask/", 154 ] 155 .iter() 156 .any(|prefix| path.starts_with(prefix)) 157 { 158 let classification = self.classify(path)?; 159 if classification.reason.is_some() 160 || !classification.owners.contains(&Owner::Native) 161 { 162 return Err(format!("native input has no explicit native owner: {path}")); 163 } 164 } 165 } 166 Ok(()) 167 } 168 } 169 170 fn required_native_inputs() -> Vec<&'static str> { 171 vec![ 172 "build.gradle.kts", 173 "settings.gradle.kts", 174 "gradle.properties", 175 "gradlew", 176 "gradlew.bat", 177 "radroots.lib.source-lock.v1.toml", 178 "config/design/harvestcircle-v1.toml", 179 "config/detekt/detekt.yml", 180 "config/licenses/allowed-licenses.json", 181 "config/product/harvestcircle-v1.properties", 182 "config/verification/lanes-v3.properties", 183 "contracts/release/harvestcircle-artifact-contract.v3.json", 184 "contracts/rshr-201-step-gates.v1.json", 185 "tools/rshr_201_step_gate.py", 186 "tools/run-linux-x86_64-development-check.sh", 187 "tools/test-build-logic-stability.sh", 188 "tools/test-build-modes.sh", 189 "tools/verify-storage-api.sh", 190 "core/Cargo.toml", 191 "core/Cargo.lock", 192 "core/rust-toolchain.toml", 193 "core/deny.toml", 194 "core/provenance/harvestcircle-v1.toml", 195 "tools/xtask/Cargo.toml", 196 "tools/xtask/Cargo.lock", 197 "gradle/libs.versions.toml", 198 "gradle/verification-metadata.xml", 199 "gradle/wrapper/gradle-wrapper.jar", 200 "gradle/wrapper/gradle-wrapper.properties", 201 "build-logic/settings.gradle.kts", 202 "build-logic/contracts/build.gradle.kts", 203 "build-logic/plugins/build.gradle.kts", 204 "app/design_system/build.gradle.kts", 205 "app/shared/build.gradle.kts", 206 "app/desktop/build.gradle.kts", 207 "tools/design_catalog/build.gradle.kts", 208 "Makefile", 209 ] 210 } 211 212 #[cfg(test)] 213 mod tests { 214 use super::*; 215 const MAP: &str = include_str!("../../../config/repository/runtime-ownership.v1.json"); 216 217 #[test] 218 fn rejects_malformed_unknown_and_duplicate_json() { 219 for source in [ 220 "{", 221 &MAP.replace("\"schema_version\": 1", "\"schema_version\": 2"), 222 &MAP.replace( 223 "\"schema_version\": 1", 224 "\"schema_version\": 1, \"extra\": true", 225 ), 226 &MAP.replace( 227 "\"schema_version\": 1", 228 "\"schema_version\": 1, \"schema_version\": 1", 229 ), 230 &MAP.replace("\"native\"", "\"invented\""), 231 ] { 232 assert!(OwnershipMap::parse(source).is_err(), "accepted {source}"); 233 } 234 } 235 236 #[test] 237 fn rejects_traversal_absolutes_backslashes_and_escapes() { 238 for path in [ 239 "../app", 240 "/app", 241 "app/../core", 242 "app/./src", 243 "app//src", 244 "app/", 245 "C:/app", 246 "app\\src", 247 "app/*", 248 "app/%2e%2e", 249 "app\\u002fcore", 250 ] { 251 let source = MAP.replacen("\"app\"", &format!("\"{path}\""), 1); 252 assert!(OwnershipMap::parse(&source).is_err(), "accepted {path}"); 253 } 254 } 255 256 #[test] 257 fn rejects_ambiguous_declarations_and_accepts_explicit_shared_owners() { 258 let map = OwnershipMap::parse(MAP).unwrap(); 259 let shared = map.classify("tools/xtask/Cargo.lock").unwrap(); 260 assert!(shared.owners.contains(&Owner::Native)); 261 assert!(shared.owners.contains(&Owner::Governance)); 262 let rule = r#"{"path":"app/src", "kind":"prefix", "owners":["web"]}"#; 263 let source = MAP.replacen("\"inputs\": [", &format!("\"inputs\": [{rule},"), 1); 264 assert!(OwnershipMap::parse(&source).is_err()); 265 assert!( 266 OwnershipMap::parse(&MAP.replacen( 267 "\"owners\": [\n \"native\"", 268 "\"owners\": [\n \"native\", \"native\"", 269 1 270 )) 271 .is_err() 272 ); 273 } 274 275 #[test] 276 fn prefix_boundaries_and_unknown_inputs_widen_with_reason() { 277 let map = OwnershipMap::parse(MAP).unwrap(); 278 assert_eq!( 279 map.classify("app/src/test.kt").unwrap().owners, 280 vec![Owner::Native] 281 ); 282 for path in [ 283 "application/src/test.kt", 284 "config/new.json", 285 "tools/new.rs", 286 "contracts/new.json", 287 "new_runtime/main.rs", 288 ] { 289 let result = map.classify(path).unwrap(); 290 assert_eq!(result.owners.len(), 4); 291 assert!(result.reason.unwrap().contains(path)); 292 } 293 assert!(map.classify("../app").is_err()); 294 assert!( 295 map.classify("web/src/main.ts") 296 .unwrap() 297 .owners 298 .contains(&Owner::Web) 299 ); 300 assert!( 301 map.classify("contracts/interop/food.json") 302 .unwrap() 303 .owners 304 .contains(&Owner::Interop) 305 ); 306 } 307 308 #[test] 309 fn current_repository_native_inputs_are_explicitly_covered() { 310 let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../.."); 311 let inventory = crate::Inventory::load(&root).unwrap(); 312 let mut findings = Vec::new(); 313 crate::runtime_ownership_audit(&root, &inventory, &mut findings); 314 assert!(findings.is_empty(), "{findings:?}"); 315 } 316 317 #[test] 318 fn outputs_do_not_exempt_tracked_inputs_and_exact_paths_do_not_expand() { 319 let map = OwnershipMap::parse(MAP).unwrap(); 320 let output = map.classify("core/target/tracked-malicious.rs").unwrap(); 321 assert_eq!(output.owners, vec![Owner::Native]); 322 assert!(map.classify("gradlew-extra").unwrap().reason.is_some()); 323 assert!( 324 map.classify("config/design/harvestcircle-v1.toml/child") 325 .unwrap() 326 .reason 327 .is_some() 328 ); 329 } 330 331 #[test] 332 fn literal_svelte_route_inputs_are_classified_without_glob_declarations() { 333 let map = OwnershipMap::parse(MAP).unwrap(); 334 for path in [ 335 "web/src/routes/messages/[conversationId=local_id]/+page.svelte", 336 "web/src/routes/my/listings/[listingId=local_id]/+page.svelte", 337 "web/src/routes/[id]/+page.svelte", 338 ] { 339 let result = map.classify(path).unwrap(); 340 assert_eq!(result.owners, vec![Owner::Web]); 341 assert!(result.reason.is_none()); 342 } 343 let literal = "new_runtime/[literal].rs"; 344 let unknown = map.classify(literal).unwrap(); 345 assert_eq!(unknown.owners.len(), 4); 346 assert!(unknown.reason.unwrap().contains(literal)); 347 for declaration in ["app/[id]", "app/[[optional]]", "app/[a-z]"] { 348 let source = MAP.replacen("\"app\"", &format!("\"{declaration}\""), 1); 349 assert!( 350 OwnershipMap::parse(&source).is_err(), 351 "accepted {declaration}" 352 ); 353 } 354 for hostile in [ 355 "web/../[id]", 356 "web//[id]", 357 "/web/[id]", 358 "web/[id]\\child", 359 "web/[id]%2fchild", 360 "web/[id]*", 361 "web/[id]?", 362 ] { 363 assert!(map.classify(hostile).is_err(), "accepted {hostile}"); 364 } 365 } 366 367 #[test] 368 fn rejects_uncovered_and_missing_native_inputs() { 369 let map = OwnershipMap::parse(MAP).unwrap(); 370 let paths = required_native_inputs() 371 .into_iter() 372 .map(str::to_owned) 373 .collect::<Vec<_>>(); 374 assert!(map.validate_native_inputs(&paths).is_ok()); 375 for missing in [ 376 "core/Cargo.lock", 377 "tools/xtask/Cargo.lock", 378 "core/rust-toolchain.toml", 379 ] { 380 let partial = paths 381 .iter() 382 .filter(|path| path.as_str() != missing) 383 .cloned() 384 .collect::<Vec<_>>(); 385 assert!( 386 map.validate_native_inputs(&partial).is_err(), 387 "accepted missing {missing}" 388 ); 389 } 390 let wrong = OwnershipMap::parse(&MAP.replace("\"core\",", "\"elsewhere\",")).unwrap(); 391 assert!(wrong.validate_native_inputs(&paths).is_err()); 392 } 393 }