context.rs (14265B)
1 use radroots_domain::*; 2 use radroots_identity::PublicKey; 3 #[cfg(feature = "serde")] 4 use serde_json::{Value, json}; 5 use std::str::FromStr; 6 7 const KEY: &str = "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"; 8 fn actor() -> ActorRef { 9 ActorRef::new( 10 PublicKey::from_str(KEY).unwrap(), 11 ActorRole::Buyer, 12 None, 13 Some(GrantId::from_bytes([4; 32])), 14 ) 15 } 16 fn checkpoint() -> CheckpointRef { 17 CheckpointRef::new( 18 CheckpointDigest::from_bytes([8; 32]), 19 Sequence::new(0).unwrap(), 20 Coverage::Partial, 21 vec![SourceId::from_bytes([9; 32])], 22 ) 23 .unwrap() 24 } 25 fn context() -> CommandContextData { 26 CommandContextData::new( 27 OperationId::from_bytes([1; 32]), 28 actor(), 29 WorkspaceId::from_bytes([2; 32]), 30 AuthorityRef::new( 31 ExecutorId::from_bytes([3; 32]), 32 Generation::new(9_007_199_254_740_993).unwrap(), 33 ), 34 RouteDigest::from_bytes([5; 32]), 35 None, 36 None, 37 UnixSeconds::new(1_900_000_000).unwrap(), 38 None, 39 ) 40 .unwrap() 41 } 42 43 #[cfg(feature = "serde")] 44 #[test] 45 fn profile_keys_require_canonical_spelling_in_direct_actor_and_context_decoding() { 46 let uppercase = KEY.to_ascii_uppercase(); 47 assert!(PublicKey::from_hex(&uppercase).is_ok()); 48 let mut descriptor = serde_json::to_value(actor()).unwrap(); 49 descriptor["organization"] = json!(KEY); 50 assert!(serde_json::from_value::<ActorRef>(descriptor.clone()).is_ok()); 51 for field in ["participant", "organization"] { 52 let mut altered = descriptor.clone(); 53 altered[field] = json!(uppercase); 54 assert!( 55 serde_json::from_value::<ActorRef>(altered.clone()).is_err(), 56 "{field}" 57 ); 58 let mut command = serde_json::to_value(context()).unwrap(); 59 command["actor"] = altered; 60 assert!( 61 serde_json::from_value::<CommandContextData>(command).is_err(), 62 "context {field}" 63 ); 64 } 65 } 66 67 #[cfg(feature = "serde")] 68 #[test] 69 fn context_descriptors_require_objects_when_decoded_directly() { 70 fn check<T>(value: T, fields: &[&str]) 71 where 72 T: serde::Serialize + serde::de::DeserializeOwned + PartialEq + std::fmt::Debug, 73 { 74 let object = serde_json::to_value(&value).unwrap(); 75 assert_eq!(serde_json::from_value::<T>(object.clone()).unwrap(), value); 76 let array = Value::Array(fields.iter().map(|field| object[field].clone()).collect()); 77 assert!(serde_json::from_value::<T>(array).is_err()); 78 } 79 check( 80 actor(), 81 &["participant", "role", "organization", "grant_id"], 82 ); 83 check(context().authority(), &["executor_id", "generation"]); 84 check(checkpoint(), &["digest", "sequence", "coverage", "missing"]); 85 check( 86 Approval::new( 87 ApprovalIntentDigest::from_bytes([6; 32]), 88 "inbox.inquire", 89 UnixSeconds::new(190).unwrap(), 90 ) 91 .unwrap(), 92 &["intent_digest", "scope", "expires_at"], 93 ); 94 check( 95 ExpectedOrder::new( 96 OrderId::from_bytes([7; 32]), 97 None, 98 Sequence::new(4).unwrap(), 99 None, 100 checkpoint(), 101 ), 102 &[ 103 "order_id", 104 "agreement", 105 "seller_sequence", 106 "buyer_head", 107 "checkpoint", 108 ], 109 ); 110 check( 111 context(), 112 &[ 113 "operation_id", 114 "actor", 115 "workspace_id", 116 "authority", 117 "route_digest", 118 "approval", 119 "expected", 120 "not_after", 121 "correlation_id", 122 ], 123 ); 124 } 125 126 #[test] 127 fn exact_integers_never_round_or_accept_numeric_json_coercions() { 128 for value in [0, 1, 9_007_199_254_740_993, i64::MAX as u64] { 129 let sequence = Sequence::new(value).unwrap(); 130 assert_eq!(sequence.get(), value); 131 assert_eq!(sequence.to_string().parse::<Sequence>(), Ok(sequence)); 132 #[cfg(feature = "serde")] 133 { 134 assert_eq!( 135 serde_json::to_value(sequence).unwrap(), 136 json!(value.to_string()) 137 ); 138 assert_eq!( 139 serde_json::from_value::<Sequence>(json!(value.to_string())).unwrap(), 140 sequence 141 ); 142 assert!(serde_json::from_value::<Sequence>(json!(value)).is_err()); 143 } 144 if value > 0 { 145 let generation = Generation::new(value).unwrap(); 146 assert_eq!(generation.get(), value); 147 assert_eq!(generation.to_string().parse::<Generation>(), Ok(generation)); 148 #[cfg(feature = "serde")] 149 assert_eq!( 150 serde_json::from_value::<Generation>(json!(value.to_string())).unwrap(), 151 generation 152 ); 153 } 154 } 155 for text in [ 156 "", 157 "00", 158 "01", 159 "-1", 160 "+1", 161 "1.0", 162 "1e2", 163 " 1", 164 "1 ", 165 "1", 166 "18446744073709551616", 167 "9223372036854775808", 168 ] { 169 assert!(text.parse::<Sequence>().is_err(), "{text:?}"); 170 assert!(text.parse::<Generation>().is_err()); 171 #[cfg(feature = "serde")] 172 assert!(serde_json::from_value::<Sequence>(json!(text)).is_err()); 173 } 174 assert!(Generation::new(0).is_err()); 175 assert!("0".parse::<Generation>().is_err()); 176 assert!(Sequence::new(u64::MAX).is_err()); 177 assert!(Generation::new(u64::MAX).is_err()); 178 for value in [0, 1, 253_402_300_799] { 179 let timestamp = UnixSeconds::new(value).unwrap(); 180 assert_eq!(timestamp.get(), value); 181 assert_eq!(timestamp.to_string().parse::<UnixSeconds>(), Ok(timestamp)); 182 #[cfg(feature = "serde")] 183 { 184 assert_eq!( 185 serde_json::from_value::<UnixSeconds>(json!(value.to_string())).unwrap(), 186 timestamp 187 ); 188 assert_eq!( 189 serde_json::to_value(timestamp).unwrap(), 190 json!(value.to_string()) 191 ); 192 } 193 } 194 assert!(UnixSeconds::new(253_402_300_800).is_err()); 195 assert!("253402300800".parse::<UnixSeconds>().is_err()); 196 #[cfg(feature = "serde")] 197 assert!(serde_json::from_value::<UnixSeconds>(json!(1)).is_err()); 198 } 199 200 #[test] 201 fn captured_descriptors_preserve_every_field_and_explicit_null() { 202 let data = context(); 203 #[cfg(feature = "serde")] 204 let wire = { 205 let wire = serde_json::to_value(&data).unwrap(); 206 assert_eq!(wire["operation_id"], json!("01".repeat(32))); 207 assert_eq!(wire["authority"]["generation"], json!("9007199254740993")); 208 for name in ["approval", "expected", "correlation_id"] { 209 assert!(wire[name].is_null()); 210 } 211 assert_eq!( 212 serde_json::from_value::<CommandContextData>(wire.clone()).unwrap(), 213 data 214 ); 215 wire 216 }; 217 assert_eq!(data.operation_id(), OperationId::from_bytes([1; 32])); 218 assert_eq!(data.actor(), actor()); 219 assert_eq!(data.workspace_id(), WorkspaceId::from_bytes([2; 32])); 220 assert_eq!( 221 data.authority().executor_id(), 222 ExecutorId::from_bytes([3; 32]) 223 ); 224 assert_eq!(data.authority().generation().get(), 9_007_199_254_740_993); 225 assert_eq!(data.route_digest(), RouteDigest::from_bytes([5; 32])); 226 assert_eq!(data.not_after().get(), 1_900_000_000); 227 assert!( 228 data.approval().is_none() && data.expected().is_none() && data.correlation_id().is_none() 229 ); 230 assert_eq!( 231 data.actor().participant(), 232 PublicKey::from_str(KEY).unwrap() 233 ); 234 assert_eq!(data.actor().role(), ActorRole::Buyer); 235 assert_eq!(data.actor().organization(), None); 236 assert_eq!(data.actor().grant_id(), Some(GrantId::from_bytes([4; 32]))); 237 #[cfg(feature = "serde")] 238 { 239 for field in ["approval", "expected", "correlation_id"] { 240 let mut missing = wire.clone(); 241 missing.as_object_mut().unwrap().remove(field); 242 assert!( 243 serde_json::from_value::<CommandContextData>(missing).is_err(), 244 "required {field}" 245 ); 246 } 247 for field in ["organization", "grant_id"] { 248 let mut missing = wire.clone(); 249 missing["actor"].as_object_mut().unwrap().remove(field); 250 assert!( 251 serde_json::from_value::<CommandContextData>(missing).is_err(), 252 "required actor {field}" 253 ); 254 } 255 let raw = serde_json::to_string(&data).unwrap(); 256 let duplicate = format!("{{\"operation_id\":\"{}\",{}", "ff".repeat(32), &raw[1..]); 257 assert!(serde_json::from_str::<CommandContextData>(&duplicate).is_err()); 258 let mut unknown = wire.clone(); 259 unknown["authenticated"] = json!(true); 260 assert!(serde_json::from_value::<CommandContextData>(unknown).is_err()); 261 let mut unknown = wire; 262 unknown["actor"]["role"] = json!("operator"); 263 assert!(serde_json::from_value::<CommandContextData>(unknown).is_err()); 264 } 265 assert!(!format!("{data:?}").contains(KEY)); 266 } 267 268 #[test] 269 fn complete_preconditions_and_approval_data_remain_untrusted_bounded_values() { 270 let approval = Approval::new( 271 ApprovalIntentDigest::from_bytes([6; 32]), 272 "orders.accept", 273 UnixSeconds::new(1_900_000_000).unwrap(), 274 ) 275 .unwrap(); 276 assert_eq!( 277 approval.intent_digest(), 278 ApprovalIntentDigest::from_bytes([6; 32]) 279 ); 280 assert_eq!(approval.scope(), "orders.accept"); 281 assert_eq!(approval.expires_at().get(), 1_900_000_000); 282 let expected = ExpectedOrder::new( 283 OrderId::from_bytes([7; 32]), 284 Some(RecordId::from_bytes([10; 32])), 285 Sequence::new(4).unwrap(), 286 Some(RecordId::from_bytes([11; 32])), 287 checkpoint(), 288 ); 289 assert_eq!(expected.order_id(), OrderId::from_bytes([7; 32])); 290 assert_eq!(expected.agreement(), Some(RecordId::from_bytes([10; 32]))); 291 assert_eq!(expected.seller_sequence().get(), 4); 292 assert_eq!(expected.buyer_head(), Some(RecordId::from_bytes([11; 32]))); 293 assert_eq!( 294 expected.checkpoint().digest(), 295 CheckpointDigest::from_bytes([8; 32]) 296 ); 297 assert_eq!(expected.checkpoint().sequence().get(), 0); 298 assert_eq!(expected.checkpoint().coverage(), Coverage::Partial); 299 assert_eq!( 300 expected.checkpoint().missing(), 301 &[SourceId::from_bytes([9; 32])] 302 ); 303 #[cfg(feature = "serde")] 304 { 305 let mut wire = serde_json::to_value(context()).unwrap(); 306 wire["approval"] = serde_json::to_value(&approval).unwrap(); 307 wire["expected"] = serde_json::to_value(&expected).unwrap(); 308 wire["correlation_id"] = json!("synthetic diagnostic"); 309 let data: CommandContextData = serde_json::from_value(wire.clone()).unwrap(); 310 assert_eq!(data.approval(), Some(&approval)); 311 assert_eq!(data.expected(), Some(&expected)); 312 assert_eq!( 313 data.correlation_id().unwrap().as_str(), 314 "synthetic diagnostic" 315 ); 316 assert_eq!(serde_json::to_value(&data).unwrap(), wire); 317 for field in ["agreement", "buyer_head"] { 318 let mut missing = wire.clone(); 319 missing["expected"].as_object_mut().unwrap().remove(field); 320 assert!(serde_json::from_value::<CommandContextData>(missing).is_err()); 321 } 322 for nested in ["authority", "approval", "expected"] { 323 let mut changed = wire.clone(); 324 changed[nested]["extra"] = Value::Bool(true); 325 assert!(serde_json::from_value::<CommandContextData>(changed).is_err()); 326 } 327 assert!(!format!("{data:?}").contains("synthetic diagnostic")); 328 } 329 assert!(!format!("{approval:?}").contains("orders.accept")); 330 } 331 332 #[test] 333 fn bounds_and_coverage_claims_fail_without_echoing_sensitive_text() { 334 assert!(CorrelationId::new("é".repeat(64)).is_ok()); 335 assert!(CorrelationId::new("é".repeat(65)).is_err()); 336 assert!(CorrelationId::new("diagnostic\nsecret").is_err()); 337 #[cfg(feature = "serde")] 338 { 339 assert_eq!( 340 serde_json::from_str::<CorrelationId>("\"hello\"") 341 .unwrap() 342 .as_str(), 343 "hello" 344 ); 345 assert!(serde_json::from_value::<CorrelationId>(json!("x".repeat(129))).is_err()); 346 } 347 assert!( 348 !format!("{:?}", CorrelationId::new("private diagnostic").unwrap()) 349 .contains("private diagnostic") 350 ); 351 for scope in [String::new(), "x".repeat(161), "private\ncontext".into()] { 352 let error = Approval::new( 353 ApprovalIntentDigest::from_bytes([1; 32]), 354 scope.clone(), 355 UnixSeconds::new(1).unwrap(), 356 ) 357 .unwrap_err(); 358 assert_eq!(error, ContextError::InvalidText); 359 assert!(!error.to_string().contains(&scope) || scope.is_empty()); 360 } 361 assert!( 362 Approval::new( 363 ApprovalIntentDigest::from_bytes([1; 32]), 364 "valid", 365 UnixSeconds::new(0).unwrap() 366 ) 367 .is_err() 368 ); 369 let digest = CheckpointDigest::from_bytes([2; 32]); 370 let sequence = Sequence::new(0).unwrap(); 371 assert!( 372 CheckpointRef::new( 373 digest, 374 sequence, 375 Coverage::Partial, 376 vec![SourceId::from_bytes([1; 32]); 128] 377 ) 378 .is_ok() 379 ); 380 assert_eq!( 381 CheckpointRef::new( 382 digest, 383 sequence, 384 Coverage::Partial, 385 vec![SourceId::from_bytes([1; 32]); 129] 386 ) 387 .unwrap_err(), 388 ContextError::TooManyReferences 389 ); 390 assert_eq!( 391 CheckpointRef::new( 392 digest, 393 sequence, 394 Coverage::ScopeSatisfied, 395 vec![SourceId::from_bytes([1; 32])] 396 ) 397 .unwrap_err(), 398 ContextError::InconsistentCoverage 399 ); 400 assert!(CheckpointRef::new(digest, sequence, Coverage::ScopeSatisfied, vec![]).is_ok()); 401 #[cfg(feature = "serde")] 402 { 403 let mut invalid = serde_json::to_value(context()).unwrap(); 404 invalid["not_after"] = json!("0"); 405 assert!(serde_json::from_value::<CommandContextData>(invalid).is_err()); 406 } 407 }