lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

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 }