receipt_delivery_validation.rs (15552B)
1 //! Untrusted data projections must not bypass the retained native graph. 2 use super::*; 3 use radroots_domain::TransactionId; 4 use radroots_storage::command::{ 5 DeliveryAttemptSummary, OperationSnapshot, PrivateEnvelopeCandidate, 6 }; 7 use radroots_transport::{ 8 Target, TransportId, outcome::DeliveryOutcome, sink::DeliveryTargetReceipt, target::TargetScope, 9 }; 10 11 fn targets(urls: &[&str]) -> TargetSet { 12 TargetSet::new( 13 urls.iter() 14 .map(|url| Target::nostr_relay(url).unwrap()) 15 .collect(), 16 ) 17 .unwrap() 18 } 19 fn intent(set: &TargetSet, policy: TargetPolicy) -> Result<DeliveryIntent, OperationError> { 20 DeliveryIntent::new( 21 &"01".repeat(32), 22 EnvelopeEventId::from_bytes([3; 32]), 23 set, 24 &SatisfactionPolicy::new(SatisfactionClass::Accepted, policy), 25 NonZeroU64::new(1_000).unwrap(), 26 ) 27 } 28 29 #[test] 30 fn delivery_intent_bounds_and_selection_preserve_the_full_publication_criterion() { 31 let set = targets(&["wss://a.example", "wss://b.example"]); 32 let original = intent(&set, TargetPolicy::all()).unwrap(); 33 for id in [ 34 String::new(), 35 "01".repeat(31), 36 "AA".repeat(32), 37 "gg".repeat(32), 38 ] { 39 assert_eq!( 40 DeliveryIntent::new( 41 &id, 42 original.event_id(), 43 &set, 44 original.policy(), 45 original.deadline_unix_ms() 46 ), 47 Err(OperationError::InvalidCommand) 48 ); 49 } 50 let too_many = TargetSet::new( 51 (0..17) 52 .map(|i| Target::nostr_relay(format!("wss://r{i}.example")).unwrap()) 53 .collect(), 54 ) 55 .unwrap(); 56 let duplicate_endpoint = TargetSet::new(vec![ 57 Target::nostr_relay_with_metadata( 58 "wss://a.example", 59 Some(TargetScope::parse("first").unwrap()), 60 None, 61 ) 62 .unwrap(), 63 Target::nostr_relay_with_metadata( 64 "wss://a.example/", 65 Some(TargetScope::parse("second").unwrap()), 66 None, 67 ) 68 .unwrap(), 69 ]) 70 .unwrap(); 71 let other_transport = TargetSet::new(vec![ 72 Target::new(TransportId::LOCAL, "test://endpoint").unwrap(), 73 ]) 74 .unwrap(); 75 assert!(TargetSet::new(vec![]).is_err()); 76 for rejected in [too_many, duplicate_endpoint, other_transport] { 77 assert_eq!( 78 intent(&rejected, TargetPolicy::all()), 79 Err(OperationError::InvalidCommand) 80 ); 81 } 82 assert!( 83 DeliveryIntent::new( 84 original.request_id().as_str(), 85 original.event_id(), 86 &set, 87 original.policy(), 88 NonZeroU64::new(253_402_300_800_000).unwrap() 89 ) 90 .is_err() 91 ); 92 assert!( 93 DeliveryIntent::new( 94 original.request_id().as_str(), 95 original.event_id(), 96 &set, 97 &SatisfactionPolicy::new(SatisfactionClass::Delivered, TargetPolicy::all()), 98 original.deadline_unix_ms() 99 ) 100 .is_err() 101 ); 102 assert!(intent(&set, TargetPolicy::quorum(3).unwrap()).is_err()); 103 let foreign = targets(&["wss://foreign.example"]); 104 assert!( 105 intent( 106 &set, 107 TargetPolicy::required(vec![foreign.targets()[0].fingerprint().clone()]).unwrap() 108 ) 109 .is_err() 110 ); 111 assert!(original.clone().with_selection(&foreign).is_err()); 112 let selected = original 113 .clone() 114 .with_selection(&TargetSet::new(vec![set.targets()[1].clone()]).unwrap()) 115 .unwrap(); 116 assert_eq!(selected.targets(), original.targets()); 117 assert_eq!( 118 selected.publication_policy_digest(), 119 original.publication_policy_digest() 120 ); 121 assert_ne!(selected.digest(), original.digest()); 122 assert_eq!( 123 selected.selected_target_set().unwrap().targets(), 124 &[set.targets()[1].clone()] 125 ); 126 assert!(intent(&set, TargetPolicy::any()).is_ok()); 127 assert!(intent(&set, TargetPolicy::quorum(2).unwrap()).is_ok()); 128 } 129 130 fn outer_variant(ready: &Ready, kind: u16, time: u64, recipient: Option<u8>) -> String { 131 let original = nostr::Event::from_json(ready.candidate.raw_json()).unwrap(); 132 let signer = keys(3); 133 nostr::UnsignedEvent { 134 id: None, 135 pubkey: signer.public_key(), 136 created_at: nostr::Timestamp::from_secs(time), 137 kind: nostr::Kind::Custom(kind), 138 tags: nostr::Tags::from_list( 139 recipient 140 .map(|id| nostr::Tag::public_key(keys(id).public_key())) 141 .into_iter() 142 .collect(), 143 ), 144 content: original.content, 145 } 146 .sign_with_keys(&signer) 147 .unwrap() 148 .as_json() 149 } 150 fn report( 151 original: &DeliveryAttempt, 152 intent: DeliveryIntent, 153 raw: &str, 154 at: UnixSeconds, 155 ordinals: Vec<u8>, 156 ) -> Result<DeliveryAttempt, OperationError> { 157 DeliveryAttempt::from_store_report( 158 original.work(), 159 intent, 160 raw, 161 TransactionId::from_bytes([88; 32]), 162 at, 163 ordinals, 164 ) 165 } 166 fn observation(attempt: &DeliveryAttempt, outcome: DeliveryOutcome) -> DeliveryObservation { 167 DeliveryObservation::from_store_report( 168 attempt, 169 &DeliveryTargetReceipt::attempted( 170 attempt.intent().selected_targets().next().unwrap().clone(), 171 outcome, 172 ), 173 None, 174 ) 175 .unwrap() 176 } 177 async fn snapshot(ready: &Ready) -> OperationSnapshot { 178 ready 179 .store 180 .operation_snapshot( 181 ready.binding.clone(), 182 ready.work.evidence().operation_id(), 183 None, 184 copy(&ready.proof), 185 ) 186 .await 187 .unwrap() 188 .unwrap() 189 } 190 191 #[tokio::test] 192 async fn work_independent_envelope_binds_original_recipient_and_retains_exact_native_bytes() { 193 let ready = Ready::new(&[String::from("ws://127.0.0.1:9")], 245).await; 194 let obtained = ready.candidate.with_wrapping_key(|key| { 195 PrivateEnvelopeCandidate::from_obtained( 196 ready.work.recipient(), 197 ready.candidate.raw_json(), 198 key, 199 ) 200 .unwrap() 201 }); 202 let copied = obtained.retained_copy(); 203 drop(obtained); 204 let bound = EnvelopeCandidate::from_private(ready.work, copied).unwrap(); 205 let DeliveryAttemptOutcome::Claimed(retained) = ready 206 .store 207 .prepare_delivery_attempt(ready.request(1), copy(&ready.proof), Some(&bound)) 208 .await 209 .unwrap() 210 else { 211 panic!("actual original envelope must be retained before transport"); 212 }; 213 assert_eq!(retained.raw_json(), ready.candidate.raw_json()); 214 assert_eq!(retained.intent().event_id(), bound.event_id()); 215 assert_eq!( 216 ready 217 .query(&ready.store, retained.intent().request_id()) 218 .await 219 .raw_json(), 220 bound.raw_json() 221 ); 222 assert_ne!(ready.work.recipient(), key()); 223 let foreign = PrivateEnvelopeCandidate::from_obtained( 224 key(), 225 &outer_variant(&ready, 1059, retained.retained_at().get(), Some(1)), 226 &[3; 32], 227 ) 228 .unwrap(); 229 assert!(matches!( 230 EnvelopeCandidate::from_private(ready.work, foreign), 231 Err(OperationError::InvalidEvidence) 232 )); 233 ready.store.close().await.unwrap(); 234 } 235 236 #[tokio::test] 237 async fn malformed_carriers_and_reconstructed_attempts_cannot_replace_original_native_bytes() { 238 let ready = Ready::new(&[String::from("ws://127.0.0.1:9")], 246).await; 239 let retained = ready.retain(1).await; 240 let wrapping_key = [3; 32]; 241 let time = retained.retained_at().get(); 242 for raw in [ 243 " ".repeat(65_537), 244 outer_variant(&ready, 14, time, Some(2)), 245 outer_variant(&ready, 1059, 0, Some(2)), 246 outer_variant(&ready, 1059, 253_402_300_800, Some(2)), 247 outer_variant(&ready, 1059, time, None), 248 outer_variant(&ready, 1059, time, Some(1)), 249 ] { 250 assert!(matches!( 251 PrivateEnvelopeCandidate::from_obtained(ready.work.recipient(), &raw, &wrapping_key), 252 Err(OperationError::InvalidEvidence) 253 )); 254 assert!(matches!( 255 EnvelopeCandidate::from_obtained(ready.work, &raw, &wrapping_key), 256 Err(OperationError::InvalidEvidence) 257 )); 258 } 259 for field in ["id", "sig"] { 260 let mut wire: serde_json::Value = serde_json::from_str(ready.candidate.raw_json()).unwrap(); 261 wire[field] = "0".repeat(if field == "id" { 64 } else { 128 }).into(); 262 assert!( 263 EnvelopeCandidate::from_obtained(ready.work, &wire.to_string(), &wrapping_key).is_err() 264 ); 265 } 266 assert_eq!(ready.candidate.work(), ready.work); 267 assert_eq!( 268 ready.candidate.created_at().get(), 269 nostr::Event::from_json(ready.candidate.raw_json()) 270 .unwrap() 271 .created_at 272 .as_secs() 273 ); 274 let mismatched = DeliveryIntent::new( 275 retained.intent().request_id().as_str(), 276 EnvelopeEventId::from_bytes([44; 32]), 277 retained.intent().targets(), 278 retained.intent().policy(), 279 retained.intent().deadline_unix_ms(), 280 ) 281 .unwrap(); 282 assert!( 283 report( 284 &retained, 285 mismatched, 286 retained.raw_json(), 287 retained.retained_at(), 288 vec![1] 289 ) 290 .is_err() 291 ); 292 assert!( 293 report( 294 &retained, 295 retained.intent().clone(), 296 retained.raw_json(), 297 UnixSeconds::new(ready.work.queued_at().get() - 1).unwrap(), 298 vec![1] 299 ) 300 .is_err() 301 ); 302 for ordinals in [vec![], vec![0], vec![13]] { 303 assert!( 304 report( 305 &retained, 306 retained.intent().clone(), 307 retained.raw_json(), 308 retained.retained_at(), 309 ordinals 310 ) 311 .is_err() 312 ); 313 } 314 let expired = DeliveryIntent::new( 315 retained.intent().request_id().as_str(), 316 retained.intent().event_id(), 317 retained.intent().targets(), 318 retained.intent().policy(), 319 NonZeroU64::new(time * 1000).unwrap(), 320 ) 321 .unwrap(); 322 assert!( 323 report( 324 &retained, 325 expired, 326 retained.raw_json(), 327 retained.retained_at(), 328 vec![1] 329 ) 330 .is_err() 331 ); 332 let future = outer_variant(&ready, 1059, time + 1, Some(2)); 333 let future_candidate = 334 EnvelopeCandidate::from_obtained(ready.work, &future, &wrapping_key).unwrap(); 335 let future_intent = DeliveryIntent::new( 336 retained.intent().request_id().as_str(), 337 future_candidate.event_id(), 338 retained.intent().targets(), 339 retained.intent().policy(), 340 retained.intent().deadline_unix_ms(), 341 ) 342 .unwrap(); 343 assert!( 344 report( 345 &retained, 346 future_intent, 347 &future, 348 retained.retained_at(), 349 vec![1] 350 ) 351 .is_err() 352 ); 353 assert_eq!( 354 ready 355 .query(&ready.store, retained.intent().request_id()) 356 .await 357 .raw_json(), 358 retained.raw_json() 359 ); 360 ready.store.close().await.unwrap(); 361 } 362 363 #[tokio::test] 364 async fn delivery_projections_reject_foreign_payloads_targets_ordinals_and_duplicate_facts() { 365 let ready = Ready::new(&[String::from("ws://127.0.0.1:9")], 247).await; 366 let retained = ready.retain(1).await; 367 let summary = DeliveryAttemptSummary::from_attempt(&retained); 368 let accepted = observation(&retained, DeliveryOutcome::accepted()); 369 assert!(!summary.acceptance_satisfied(&[]).unwrap()); 370 assert!( 371 summary 372 .acceptance_satisfied(std::slice::from_ref(&accepted)) 373 .unwrap() 374 ); 375 assert_eq!(summary.work(), retained.work()); 376 assert_eq!(summary.transaction_id(), retained.transaction_id()); 377 assert_eq!(summary.retained_at(), retained.retained_at()); 378 assert_eq!(summary.target_ordinals(), retained.target_ordinals()); 379 let foreign = Target::nostr_relay("wss://foreign.example").unwrap(); 380 assert!( 381 DeliveryObservation::from_store_report( 382 &retained, 383 &DeliveryTargetReceipt::attempted(foreign, DeliveryOutcome::accepted()), 384 None 385 ) 386 .is_err() 387 ); 388 let target = retained.intent().targets().targets()[0].clone(); 389 assert!( 390 DeliveryObservation::from_store_report( 391 &retained, 392 &DeliveryTargetReceipt::attempted(target.clone(), DeliveryOutcome::delivered()), 393 None 394 ) 395 .is_err() 396 ); 397 assert!( 398 DeliveryObservation::from_store_report( 399 &retained, 400 &DeliveryTargetReceipt::attempted(target, DeliveryOutcome::accepted()), 401 NonZeroU64::new(253_402_300_800_000) 402 ) 403 .is_err() 404 ); 405 let different_bytes = report( 406 &retained, 407 retained.intent().clone(), 408 &format!("{} ", retained.raw_json()), 409 retained.retained_at(), 410 vec![1], 411 ) 412 .unwrap(); 413 let wrong_payload = observation(&different_bytes, DeliveryOutcome::accepted()); 414 assert!( 415 summary 416 .acceptance_satisfied(std::slice::from_ref(&wrong_payload)) 417 .is_err() 418 ); 419 assert!( 420 snapshot(&ready) 421 .await 422 .with_delivery(vec![summary.clone()], vec![wrong_payload]) 423 .is_err() 424 ); 425 let wrong_ordinal = report( 426 &retained, 427 retained.intent().clone(), 428 retained.raw_json(), 429 retained.retained_at(), 430 vec![2], 431 ) 432 .unwrap(); 433 assert!( 434 snapshot(&ready) 435 .await 436 .with_delivery( 437 vec![DeliveryAttemptSummary::from_attempt(&wrong_ordinal)], 438 vec![] 439 ) 440 .is_err() 441 ); 442 assert!( 443 snapshot(&ready) 444 .await 445 .with_delivery( 446 vec![summary.clone()], 447 vec![observation(&wrong_ordinal, DeliveryOutcome::accepted())] 448 ) 449 .is_err() 450 ); 451 assert!( 452 snapshot(&ready) 453 .await 454 .with_delivery(vec![summary.clone(), summary.clone()], vec![]) 455 .is_err() 456 ); 457 assert!( 458 snapshot(&ready) 459 .await 460 .with_delivery( 461 vec![summary.clone()], 462 vec![accepted.clone(), accepted.clone()] 463 ) 464 .is_err() 465 ); 466 assert!( 467 snapshot(&ready) 468 .await 469 .with_delivery(vec![summary.clone(); 385], vec![]) 470 .is_err() 471 ); 472 assert!( 473 snapshot(&ready) 474 .await 475 .with_delivery(vec![summary.clone()], vec![accepted.clone(); 2305]) 476 .is_err() 477 ); 478 assert!( 479 snapshot(&ready) 480 .await 481 .with_installation(None, vec![]) 482 .is_err() 483 ); 484 let missing = snapshot(&ready) 485 .await 486 .with_delivery(vec![], vec![]) 487 .unwrap(); 488 assert!(!missing.publication_accepted(ready.work).unwrap()); 489 let projected = snapshot(&ready) 490 .await 491 .with_delivery(vec![summary], vec![accepted]) 492 .unwrap(); 493 assert!(projected.publication_accepted(ready.work).unwrap()); 494 assert_eq!(projected.delivery_attempts().len(), 1); 495 assert!( 496 ready 497 .observations(&ready.store, retained.intent().request_id()) 498 .await 499 .is_empty() 500 ); 501 ready.store.close().await.unwrap(); 502 }