workspace.rs (16351B)
1 use radroots_domain::{ 2 ActorRef, ActorRole, AuthorityRef, CheckpointDigest, CheckpointRef, Coverage, ExecutorId, 3 Generation, GrantId, PublicKey, RouteDigest, Sequence, UnixSeconds, WorkspaceId, 4 }; 5 use radroots_storage::workspace::{ 6 AttachmentInput, AttachmentProof, WorkspaceBinding, WorkspaceError, 7 }; 8 #[cfg(feature = "protected_outbox")] 9 #[path = "workspace/inventory_abort.rs"] 10 mod inventory_abort; 11 #[cfg(feature = "protected_outbox")] 12 #[path = "workspace/inventory_envelope.rs"] 13 mod inventory_envelope; 14 #[cfg(feature = "protected_outbox")] 15 #[path = "workspace/inventory_evidence.rs"] 16 mod inventory_evidence; 17 fn key() -> PublicKey { 18 PublicKey::from_hex("79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798").unwrap() 19 } 20 fn input() -> AttachmentInput { 21 AttachmentInput::new( 22 WorkspaceId::from_bytes([1; 32]), 23 AuthorityRef::new(ExecutorId::from_bytes([2; 32]), Generation::new(1).unwrap()), 24 key(), 25 "local://workspace/selector", 26 key(), 27 GrantId::from_bytes([3; 32]), 28 CheckpointRef::new( 29 CheckpointDigest::from_bytes([4; 32]), 30 Sequence::new(0).unwrap(), 31 Coverage::Partial, 32 vec![], 33 ) 34 .unwrap(), 35 RouteDigest::from_bytes([5; 32]), 36 ) 37 .unwrap() 38 } 39 40 #[cfg(feature = "protected_outbox")] 41 #[test] 42 fn declared_stock_grants_are_explicit_bounded_and_never_expand_empty_or_reordered_scopes() { 43 use radroots_domain::PoolId; 44 use radroots_storage::workspace::seller_stock::{ 45 StockAction::*, StockGrantScope, StockResources, 46 }; 47 let first = PoolId::from_bytes([1; 32]); 48 let second = PoolId::from_bytes([2; 32]); 49 assert!(StockResources::pools(vec![]).is_err()); 50 assert!(StockResources::pools(vec![first, first]).is_err()); 51 assert!(StockResources::pools(vec![second, first]).is_err()); 52 assert!(StockResources::pools((0..65).map(|n| PoolId::from_bytes([n; 32])).collect()).is_err()); 53 assert!(StockGrantScope::new(StockResources::all_pools(), vec![]).is_err()); 54 for actions in [ 55 vec![AddStock], 56 vec![ReadPools, AddStock], 57 vec![ReadOperations, AddStock], 58 vec![ReadOperations, ReadPools], 59 vec![ReadPools, ReadPools], 60 ] { 61 assert!(StockGrantScope::new(StockResources::all_pools(), actions).is_err()); 62 } 63 let scope = StockGrantScope::new( 64 StockResources::pools(vec![first]).unwrap(), 65 vec![ReadPools, ReadOperations, AddStock], 66 ) 67 .unwrap(); 68 assert!(scope.allows(AddStock, first)); 69 assert!(!scope.allows(AddStock, second)); 70 assert!(!scope.allows(RemoveStock, first)); 71 assert!(!scope.allows(SpoilStock, first)); 72 assert_eq!(scope.actions(), vec![ReadPools, ReadOperations, AddStock]); 73 assert_eq!(scope.resources().selected_pools(), Some(&[first][..])); 74 let readonly = 75 StockGrantScope::new(StockResources::pools(vec![first]).unwrap(), vec![ReadPools]).unwrap(); 76 assert!(readonly.allows(ReadPools, first)); 77 assert!(!readonly.allows(ReadOperations, first)); 78 assert!(!readonly.allows(AddStock, first)); 79 let full = StockGrantScope::full_inventory(); 80 assert_eq!( 81 full.actions(), 82 vec![ 83 ReadPools, 84 ReadOperations, 85 CreatePool, 86 AddStock, 87 RemoveStock, 88 SpoilStock 89 ] 90 ); 91 assert!(full.allows(SpoilStock, second)); 92 assert_eq!( 93 format!("{scope:?}"), 94 "StockGrantScope(<untrusted descriptor>)" 95 ); 96 assert_eq!( 97 format!("{:?}", scope.resources()), 98 "StockResources(<redacted>)" 99 ); 100 } 101 102 #[cfg(all(feature = "protected_outbox", feature = "serde"))] 103 #[test] 104 fn closed_stock_scope_codecs_reject_aliases_extras_and_implicit_wildcards() { 105 use radroots_storage::workspace::seller_stock::StockGrantScope; 106 use serde_json::json; 107 let valid = json!({"actions":["read_pools","read_operations","add_stock"],"resources":{"type":"pools","ids":["01".repeat(32)]}}); 108 let scope: StockGrantScope = serde_json::from_value(valid.clone()).unwrap(); 109 assert_eq!(serde_json::to_value(scope).unwrap(), valid); 110 for invalid in [ 111 json!({"actions":[],"resources":{"type":"all_pools"}}), 112 json!({"actions":["add_stock"],"resources":{"type":"all_pools"}}), 113 json!({"actions":["read_pools"],"resources":{"type":"pools","ids":[]}}), 114 json!({"actions":["read_pools"],"resources":{"type":"all_pools","ids":null}}), 115 json!({"actions":["read_pools"],"resources":{"type":"all_pools","ids":[]}}), 116 json!({"actions":["read_pools"],"resources":{"type":"all_pools","ignored":true}}), 117 json!({"actions":[{"read_pools":null}],"resources":{"type":"all_pools"}}), 118 json!({"actions":["admin"],"resources":{"type":"all_pools"}}), 119 json!({"actions":["read_pools"],"resources":{"type":"all_pools"},"admin":true}), 120 json!([{"type":"all_pools"},["read_pools"]]), 121 json!({"actions":vec!["read_pools";7],"resources":{"type":"all_pools"}}), 122 ] { 123 assert!(serde_json::from_value::<StockGrantScope>(invalid).is_err()); 124 } 125 let mut excessive = valid; 126 excessive["resources"]["ids"] = json!( 127 (0..65) 128 .map(|n| format!("{n:02x}").repeat(32)) 129 .collect::<Vec<_>>() 130 ); 131 assert!(serde_json::from_value::<StockGrantScope>(excessive).is_err()); 132 } 133 134 #[cfg(feature = "protected_outbox")] 135 #[test] 136 fn seller_namespace_selection_excludes_only_the_caller_grant_without_minting_permission() { 137 use radroots_storage::workspace::seller_stock::{SellerAuthoritySelection, SellerStockConfig}; 138 let (original, proof, record) = SellerStockConfig::new( 139 key(), 140 key(), 141 "namespace-owner", 142 UnixSeconds::new(200).unwrap(), 143 ) 144 .unwrap() 145 .enroll( 146 UnixSeconds::new(100).unwrap(), 147 WorkspaceId::from_bytes([1; 32]), 148 ExecutorId::from_bytes([2; 32]), 149 GrantId::from_bytes([3; 32]), 150 AttachmentProof::from_protected_input(&[7; 32]).unwrap(), 151 ) 152 .unwrap(); 153 let selected = SellerAuthoritySelection::from_attachment(&original); 154 let caller = selected.attachment(GrantId::from_bytes([9; 32])).unwrap(); 155 assert_ne!(caller.grant_id(), original.grant_id()); 156 assert_eq!(SellerAuthoritySelection::from_attachment(&caller), selected); 157 assert!(selected.matches_attachment(&original)); 158 assert!(selected.matches_attachment(&caller)); 159 assert!( 160 record 161 .authenticate(&original, &proof, UnixSeconds::new(100).unwrap()) 162 .is_ok() 163 ); 164 assert!( 165 record 166 .authenticate(&caller, &proof, UnixSeconds::new(100).unwrap()) 167 .is_err() 168 ); 169 assert_eq!(selected.workspace_id(), original.workspace_id()); 170 assert_eq!(selected.authority(), original.authority()); 171 assert_eq!(selected.participant(), original.participant()); 172 assert_eq!(selected.endpoint(), original.endpoint()); 173 assert_eq!(selected.endpoint_identity(), original.endpoint_identity()); 174 assert_eq!(selected.checkpoint(), original.checkpoint()); 175 assert_eq!(selected.route_digest(), original.route_digest()); 176 assert_eq!( 177 format!("{selected:?}"), 178 "SellerAuthoritySelection(<untrusted descriptor>)" 179 ); 180 } 181 182 #[cfg(all(feature = "protected_outbox", feature = "serde"))] 183 #[test] 184 fn seller_namespace_selection_is_a_closed_object_and_retains_every_namespace_binding() { 185 use radroots_storage::workspace::seller_stock::SellerAuthoritySelection; 186 use serde_json::json; 187 let original = input(); 188 let selection = SellerAuthoritySelection::from_attachment(&original); 189 let value = serde_json::to_value(&selection).unwrap(); 190 assert!(value.get("grant_id").is_none()); 191 assert_eq!( 192 serde_json::from_value::<SellerAuthoritySelection>(value.clone()).unwrap(), 193 selection 194 ); 195 for field in [ 196 "workspace_id", 197 "authority", 198 "participant", 199 "endpoint", 200 "endpoint_identity", 201 "checkpoint", 202 "route_digest", 203 ] { 204 let mut changed = value.clone(); 205 changed.as_object_mut().unwrap().remove(field); 206 assert!( 207 serde_json::from_value::<SellerAuthoritySelection>(changed).is_err(), 208 "{field}" 209 ); 210 } 211 let other_key = "c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5"; 212 for (path, bad) in [ 213 ("/workspace_id", json!("0b".repeat(32))), 214 ("/authority/executor_id", json!("0b".repeat(32))), 215 ("/authority/generation", json!("2")), 216 ("/participant", json!(other_key)), 217 ("/endpoint", json!("local://another-namespace")), 218 ("/endpoint_identity", json!(other_key)), 219 ("/checkpoint/digest", json!("0b".repeat(32))), 220 ("/route_digest", json!("0b".repeat(32))), 221 ] { 222 let mut changed = value.clone(); 223 *changed.pointer_mut(path).unwrap() = bad; 224 let changed: SellerAuthoritySelection = serde_json::from_value(changed).unwrap(); 225 assert!(!changed.matches_attachment(&original), "{path}"); 226 } 227 for bad in [json!(""), json!("x".repeat(2049)), json!("local://bad\n")] { 228 let mut changed = value.clone(); 229 changed["endpoint"] = bad; 230 assert!(serde_json::from_value::<SellerAuthoritySelection>(changed).is_err()); 231 } 232 let mut changed = value.clone(); 233 changed["grant_id"] = json!(null); 234 for bad in [ 235 json!(null), 236 json!({"id":"radroots.seller_stock.native_inventory","version":"2"}), 237 json!({"id":"radroots.seller_stock.native_inventory","version":1}), 238 json!(["radroots.seller_stock.native_inventory", "1"]), 239 ] { 240 let mut invalid = value.clone(); 241 invalid["capability_contract"] = bad; 242 assert!(serde_json::from_value::<SellerAuthoritySelection>(invalid).is_err()); 243 } 244 245 assert!(serde_json::from_value::<SellerAuthoritySelection>(changed).is_err()); 246 assert!( 247 serde_json::from_value::<SellerAuthoritySelection>(json!([ 248 value["workspace_id"], 249 value["authority"] 250 ])) 251 .is_err() 252 ); 253 } 254 fn actor() -> ActorRef { 255 ActorRef::new(key(), ActorRole::Buyer, None, Some(input().grant_id())) 256 } 257 258 #[test] 259 fn proof_has_exact_width_explicit_exposure_and_redacted_diagnostics() { 260 for bytes in [&[][..], &[7; 31][..], &[7; 33][..]] { 261 assert_eq!( 262 AttachmentProof::from_protected_input(bytes).unwrap_err(), 263 WorkspaceError::InvalidInput 264 ); 265 } 266 let proof = AttachmentProof::from_protected_input(&[7; 32]).unwrap(); 267 proof.with_secret(|bytes| assert_eq!(bytes, &[7; 32])); 268 assert_eq!(format!("{proof:?}"), "AttachmentProof(<redacted>)"); 269 } 270 #[test] 271 fn selections_are_bounded_untrusted_data_with_complete_getters() { 272 let input = input(); 273 assert_eq!(input.workspace_id(), WorkspaceId::from_bytes([1; 32])); 274 assert_eq!( 275 input.authority().executor_id(), 276 ExecutorId::from_bytes([2; 32]) 277 ); 278 assert_eq!(input.participant(), key()); 279 assert_eq!(input.endpoint_identity(), key()); 280 assert_eq!(input.endpoint(), "local://workspace/selector"); 281 assert_eq!(input.grant_id(), GrantId::from_bytes([3; 32])); 282 assert_eq!(input.checkpoint().sequence().get(), 0); 283 assert_eq!(input.route_digest(), RouteDigest::from_bytes([5; 32])); 284 for endpoint in [String::new(), "x".repeat(2049), "local://bad\n".into()] { 285 assert_eq!( 286 AttachmentInput::new( 287 input.workspace_id(), 288 input.authority(), 289 input.participant(), 290 endpoint, 291 input.endpoint_identity(), 292 input.grant_id(), 293 input.checkpoint().clone(), 294 input.route_digest() 295 ) 296 .unwrap_err(), 297 WorkspaceError::InvalidInput 298 ); 299 } 300 assert_eq!( 301 format!("{input:?}"), 302 "AttachmentInput(<untrusted descriptor>)" 303 ); 304 } 305 #[test] 306 fn host_observations_validate_internal_binding_without_authenticating_metadata() { 307 let binding = |actor, principal: &str, revision, expiry, observed| { 308 WorkspaceBinding::from_authenticated_host( 309 input(), 310 radroots_storage::workspace::WorkspaceScope::NewBuyerOutbox, 311 actor, 312 principal, 313 Sequence::new(revision).unwrap(), 314 UnixSeconds::new(expiry).unwrap(), 315 UnixSeconds::new(observed).unwrap(), 316 ) 317 }; 318 let observed = binding(actor(), "device", 1, 200, 100).unwrap(); 319 assert_eq!(observed.input(), &input()); 320 assert_eq!( 321 observed.scope(), 322 radroots_storage::workspace::WorkspaceScope::NewBuyerOutbox 323 ); 324 assert_eq!(observed.actor(), actor()); 325 assert_eq!(observed.principal_id(), "device"); 326 assert_eq!(observed.grant_revision().get(), 1); 327 assert_eq!(observed.expires_at().get(), 200); 328 assert_eq!(observed.observed_at().get(), 100); 329 assert_eq!(format!("{observed:?}"), "WorkspaceBinding(<redacted>)"); 330 for principal in [String::new(), "x".repeat(129), "device\n".into()] { 331 assert_eq!( 332 binding(actor(), principal.as_str(), 1, 200, 100).unwrap_err(), 333 WorkspaceError::InvalidInput 334 ); 335 } 336 for (revision, expiry, observed) in [ 337 (0, 200, 100), 338 (1, 0, 100), 339 (1, 100, 0), 340 (1, 100, 100), 341 (1, 99, 100), 342 ] { 343 assert_eq!( 344 binding(actor(), "device", revision, expiry, observed).unwrap_err(), 345 WorkspaceError::InvalidInput 346 ); 347 } 348 let other_key = 349 PublicKey::from_hex("c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5") 350 .unwrap(); 351 for invalid in [ 352 ActorRef::new(key(), ActorRole::Seller, None, Some(input().grant_id())), 353 ActorRef::new( 354 key(), 355 ActorRole::Coordinator, 356 None, 357 Some(input().grant_id()), 358 ), 359 ActorRef::new( 360 key(), 361 ActorRole::Buyer, 362 Some(key()), 363 Some(input().grant_id()), 364 ), 365 ActorRef::new(other_key, ActorRole::Buyer, None, Some(input().grant_id())), 366 ActorRef::new(key(), ActorRole::Buyer, None, None), 367 ActorRef::new( 368 key(), 369 ActorRole::Buyer, 370 None, 371 Some(GrantId::from_bytes([9; 32])), 372 ), 373 ] { 374 assert_eq!( 375 binding(invalid, "device", 1, 200, 100).unwrap_err(), 376 WorkspaceError::InvalidInput 377 ); 378 } 379 } 380 #[cfg(feature = "serde")] 381 #[test] 382 fn selection_json_rejects_missing_duplicate_unknown_and_invalid_data() { 383 let input = input(); 384 let encoded = serde_json::to_string(&input).unwrap(); 385 assert_eq!( 386 serde_json::from_str::<AttachmentInput>(&encoded).unwrap(), 387 input 388 ); 389 let value = serde_json::to_value(&input).unwrap(); 390 for field in value.as_object().unwrap().keys() { 391 let mut missing = value.clone(); 392 missing.as_object_mut().unwrap().remove(field); 393 assert!(serde_json::from_value::<AttachmentInput>(missing).is_err()); 394 let duplicate = format!("{{\"{field}\":{},{}", value[field], &encoded[1..]); 395 assert!(serde_json::from_str::<AttachmentInput>(&duplicate).is_err()); 396 } 397 let mut unknown = value.clone(); 398 unknown["unexpected"] = serde_json::json!(true); 399 assert!(serde_json::from_value::<AttachmentInput>(unknown).is_err()); 400 for invalid in ["", "bad\n"] { 401 let mut data = value.clone(); 402 data["endpoint"] = serde_json::json!(invalid); 403 assert!(serde_json::from_value::<AttachmentInput>(data).is_err()); 404 } 405 } 406 #[test] 407 fn workspace_failures_have_fixed_bounded_codes_and_no_sources() { 408 use WorkspaceError::*; 409 for error in [ 410 InvalidInput, 411 Unavailable, 412 NamespaceUnavailable, 413 WriterActive, 414 WrongNamespace, 415 RecoveryRequired, 416 Unauthorized, 417 GrantExpired, 418 GrantRevoked, 419 StaleAuthority, 420 StaleCheckpoint, 421 Closed, 422 StorageFailure, 423 CommitUnknown, 424 ] { 425 assert_eq!(error.to_string(), error.code()); 426 assert!(error.code().len() <= 32); 427 let source: &dyn core::error::Error = &error; 428 assert!(source.source().is_none()); 429 } 430 }