lib

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

graph_tests.rs (14063B)


      1 #[cfg(test)]
      2 mod cases {
      3     use super::super::*;
      4     use crate::workspace::tests::issuance_records::delivery_data;
      5     use nostr::JsonUtil;
      6     use radroots_domain::EnvelopeEventId;
      7     use radroots_protocol::chat::{ChatRumor, ChatSeal, ChatSigningPlan};
      8     use radroots_protocol::nip59::CapturedDmRoute;
      9     use radroots_transport::{Target, TargetSet};
     10 
     11     fn route_plan(
     12         original: BoundSigningPlan,
     13         raw: &str,
     14         source: EnvelopeEventId,
     15         selected: &[String],
     16     ) -> BoundSigningPlan {
     17         let transaction = original.transaction_id();
     18         let time = original.bound_at();
     19         let (prepared, captured) = original.into_parts();
     20         let plan = captured.chat().unwrap();
     21         let command = prepared.request().chat_command().unwrap();
     22         let rumor = ChatRumor::from_command(command, plan.created_at()).unwrap();
     23         let seals = plan
     24             .seals()
     25             .iter()
     26             .map(|seal| {
     27                 ChatSeal::new(
     28                     &rumor,
     29                     seal.recipient(),
     30                     radroots_domain::UnixSeconds::new(seal.fields().created_at).unwrap(),
     31                     seal.fields().content,
     32                 )
     33                 .unwrap()
     34             })
     35             .collect();
     36         let route = CapturedDmRoute::from_observed_descriptor(
     37             plan.routes()[0].participant(),
     38             source,
     39             raw,
     40             selected,
     41         )
     42         .unwrap();
     43         let replacement = ChatSigningPlan::new(
     44             command,
     45             plan.created_at(),
     46             seals,
     47             vec![route],
     48             plan.replay(),
     49         )
     50         .unwrap();
     51         BoundSigningPlan::from_committed_store(prepared, replacement, transaction, time).unwrap()
     52     }
     53     fn signed(kind: u16, time: u64, scalar: u8, tags: Vec<nostr::Tag>) -> nostr::Event {
     54         let mut bytes = [0; 32];
     55         bytes[31] = scalar;
     56         let keys = nostr::Keys::new(nostr::SecretKey::from_slice(&bytes).unwrap());
     57         nostr::UnsignedEvent {
     58             id: None,
     59             pubkey: keys.public_key(),
     60             created_at: nostr::Timestamp::from_secs(time),
     61             kind: nostr::Kind::Custom(kind),
     62             tags: nostr::Tags::from_list(tags),
     63             content: String::new(),
     64         }
     65         .sign_with_keys(&keys)
     66         .unwrap()
     67     }
     68     fn relay() -> nostr::Tag {
     69         nostr::Tag::parse(["relay", "wss://route.example/"]).unwrap()
     70     }
     71 
     72     #[tokio::test]
     73     async fn original_route_authentication_refuses_invalid_sources_and_unadvertised_selection() {
     74         let mut data = delivery_data().await;
     75         let artifact = data.report.work().target();
     76         let recipient = artifact.recipient();
     77         let selected = [String::from("wss://route.example/")];
     78         assert!(
     79             allowed_routes(&data.bound().await, artifact)
     80                 .unwrap()
     81                 .contains_key(&recipient)
     82         );
     83         for event in [
     84             signed(14, 99, 1, vec![relay()]),
     85             signed(10050, 99, 2, vec![relay()]),
     86             signed(10050, 0, 1, vec![relay()]),
     87             signed(10050, 253_402_300_800, 1, vec![relay()]),
     88             signed(10050, 99, 1, vec![nostr::Tag::parse(["relay"]).unwrap()]),
     89             signed(
     90                 10050,
     91                 99,
     92                 1,
     93                 vec![nostr::Tag::parse(["relay", "wss://route.example/", "extra"]).unwrap()],
     94             ),
     95             signed(
     96                 10050,
     97                 99,
     98                 1,
     99                 vec![
    100                     nostr::Tag::parse([
    101                         "relay",
    102                         &format!("wss://route.example/{}", "x".repeat(2048)),
    103                     ])
    104                     .unwrap(),
    105                 ],
    106             ),
    107         ] {
    108             let source = EnvelopeEventId::from_bytes(*event.id.as_bytes());
    109             let bound = route_plan(data.bound().await, &event.as_json(), source, &selected);
    110             assert!(allowed_routes(&bound, artifact).is_err());
    111         }
    112         let event = signed(10050, 99, 1, vec![relay()]);
    113         let source = EnvelopeEventId::from_bytes(*event.id.as_bytes());
    114         let bound = route_plan(
    115             data.bound().await,
    116             &event.as_json(),
    117             EnvelopeEventId::from_bytes([0; 32]),
    118             &selected,
    119         );
    120         assert!(allowed_routes(&bound, artifact).is_err());
    121         let missing = [String::from("wss://unadvertised.example/")];
    122         let bound = route_plan(data.bound().await, &event.as_json(), source, &missing);
    123         assert!(matches!(
    124             allowed_routes(&bound, artifact),
    125             Err(OperationError::UnverifiedApproval)
    126         ));
    127         let mut raw: serde_json::Value = serde_json::from_str(&event.as_json()).unwrap();
    128         raw["sig"] = serde_json::Value::String("0".repeat(128));
    129         let bound = route_plan(data.bound().await, &raw.to_string(), source, &selected);
    130         assert!(allowed_routes(&bound, artifact).is_err());
    131         let metadata = signed(
    132             10050,
    133             99,
    134             1,
    135             vec![
    136                 nostr::Tag::parse(["client", "wss://unadvertised.example/"]).unwrap(),
    137                 nostr::Tag::parse(["metadata"]).unwrap(),
    138                 relay(),
    139             ],
    140         );
    141         let source = EnvelopeEventId::from_bytes(*metadata.id.as_bytes());
    142         let bound = route_plan(data.bound().await, &metadata.as_json(), source, &selected);
    143         assert!(
    144             allowed_routes(&bound, artifact)
    145                 .unwrap()
    146                 .contains_key(&recipient)
    147         );
    148         let bound = route_plan(data.bound().await, &metadata.as_json(), source, &missing);
    149         assert!(matches!(
    150             allowed_routes(&bound, artifact),
    151             Err(OperationError::UnverifiedApproval)
    152         ));
    153         let unrelated =
    154             PublicKey::from_bytes(signed(10050, 99, 2, vec![relay()]).pubkey.to_bytes()).unwrap();
    155         assert!(
    156             allowed_routes(&data.bound().await, unrelated.into())
    157                 .unwrap()
    158                 .is_empty()
    159         );
    160     }
    161 
    162     #[tokio::test]
    163     async fn route_scope_budget_and_complete_fact_count_fences_are_independent() {
    164         let mut data = delivery_data().await;
    165         let artifact = data.report.work().target();
    166         let recipient = artifact.recipient();
    167         let mut graph = Graph {
    168             attempts: vec![],
    169             facts: vec![],
    170             parts: 0,
    171             counters: BTreeMap::new(),
    172             routes: BTreeMap::new(),
    173         };
    174         assert!(
    175             graph
    176                 .validate_routes(artifact, data.report.intent())
    177                 .is_err()
    178         );
    179         graph
    180             .authorize_routes(&data.bound().await, artifact)
    181             .unwrap();
    182         let unrelated =
    183             PublicKey::from_bytes(signed(10050, 99, 2, vec![relay()]).pubkey.to_bytes()).unwrap();
    184         assert!(matches!(
    185             graph.authorize_routes(&data.bound().await, unrelated.into()),
    186             Err(OperationError::UnverifiedApproval)
    187         ));
    188         assert_eq!(graph.ordinals(artifact, data.report.intent()).unwrap(), [1]);
    189         let set = TargetSet::new(vec![
    190             Target::nostr_relay("wss://unadvertised.example/").unwrap(),
    191         ])
    192         .unwrap();
    193         let foreign = DeliveryIntent::new(
    194             data.report.intent().request_id().as_str(),
    195             data.report.intent().event_id(),
    196             &set,
    197             data.report.intent().policy(),
    198             data.report.intent().deadline_unix_ms(),
    199         )
    200         .unwrap();
    201         assert!(graph.validate_routes(artifact, &foreign).is_err());
    202         graph.counters.insert(
    203             (
    204                 recipient,
    205                 data.report.intent().targets().targets()[0]
    206                     .uri()
    207                     .as_str()
    208                     .to_owned(),
    209             ),
    210             (1..=12).collect(),
    211         );
    212         assert!(matches!(
    213             graph.ordinals(artifact, data.report.intent()),
    214             Err(OperationError::DeliveryAttemptLimit)
    215         ));
    216         let selected = data.selection();
    217         graph
    218             .unchanged(
    219                 &mut data.database,
    220                 &selected,
    221                 data.report.work().evidence().operation_id(),
    222             )
    223             .await
    224             .unwrap();
    225         graph.parts = 1;
    226         assert!(
    227             graph
    228                 .unchanged(
    229                     &mut data.database,
    230                     &selected,
    231                     data.report.work().evidence().operation_id()
    232                 )
    233                 .await
    234                 .is_err()
    235         );
    236     }
    237 
    238     #[tokio::test]
    239     async fn observation_keys_ciphertexts_and_excess_counts_cannot_escape_the_actual_graph_fence() {
    240         use crate::workspace::delivery::{codec, observation};
    241         use radroots_storage::command::DeliveryObservation;
    242         use radroots_transport::{outcome::DeliveryOutcome, sink::DeliveryTargetReceipt};
    243         let mut data = delivery_data().await;
    244         let selected = data.selection();
    245         let e = data.report.work().evidence();
    246         let request = codec::request_key(data.report.intent().request_id().as_str());
    247         let report = DeliveryAttempt::from_store_report(
    248             data.report.work(),
    249             data.report.intent().clone(),
    250             data.report.raw_json(),
    251             data.report.transaction_id(),
    252             data.report.retained_at(),
    253             data.report.target_ordinals().to_vec(),
    254         )
    255         .unwrap();
    256         let graph = Graph {
    257             attempts: vec![report],
    258             facts: vec![],
    259             parts: 0,
    260             counters: BTreeMap::new(),
    261             routes: BTreeMap::new(),
    262         };
    263         let target = graph.attempts[0].intent().targets().targets()[0].clone();
    264         let original = DeliveryObservation::from_store_report(
    265             &graph.attempts[0],
    266             &DeliveryTargetReceipt::attempted(target, DeliveryOutcome::accepted()),
    267             None,
    268         )
    269         .unwrap();
    270         let protected = observation::protect(original.clone(), &data.crypto)
    271             .await
    272             .unwrap();
    273         protected.insert(&mut data.database).await.unwrap();
    274         let observed = observation::Observations::read(
    275             &mut data.database,
    276             &graph,
    277             &selected,
    278             e.operation_id(),
    279             &data.crypto,
    280         )
    281         .await
    282         .unwrap();
    283         observed
    284             .unchanged(&mut data.database, &selected, e.operation_id())
    285             .await
    286             .unwrap();
    287         for statement in [
    288             "UPDATE artifact_delivery_observations SET artifact_key=zeroblob(31)",
    289             "UPDATE artifact_delivery_observations SET artifact_key=zeroblob(32)",
    290             "UPDATE artifact_delivery_observations SET request_key=zeroblob(32)",
    291             "UPDATE artifact_delivery_observations SET target_key=zeroblob(31)",
    292             "UPDATE artifact_delivery_observations SET kind=7",
    293             "UPDATE artifact_delivery_observations SET protected=zeroblob(262145)",
    294             "UPDATE artifact_delivery_observations SET protected=zeroblob(1)",
    295         ] {
    296             sqlx::query(statement)
    297                 .execute(&mut data.database)
    298                 .await
    299                 .unwrap();
    300             let error = observation::Observations::read(
    301                 &mut data.database,
    302                 &graph,
    303                 &selected,
    304                 e.operation_id(),
    305                 &data.crypto,
    306             )
    307             .await
    308             .err()
    309             .expect("malformed observation must fail");
    310             assert_eq!(error.code(), "recovery_required", "{statement}");
    311             assert!(
    312                 observed
    313                     .unchanged(&mut data.database, &selected, e.operation_id())
    314                     .await
    315                     .is_err()
    316             );
    317             sqlx::query("DELETE FROM artifact_delivery_observations")
    318                 .execute(&mut data.database)
    319                 .await
    320                 .unwrap();
    321             protected.insert(&mut data.database).await.unwrap();
    322         }
    323         sqlx::query("DELETE FROM artifact_delivery_observations")
    324             .execute(&mut data.database)
    325             .await
    326             .unwrap();
    327         assert!(
    328             observed
    329                 .unchanged(&mut data.database, &selected, e.operation_id())
    330                 .await
    331                 .is_err()
    332         );
    333         protected.insert(&mut data.database).await.unwrap();
    334         sqlx::query("BEGIN")
    335             .execute(&mut data.database)
    336             .await
    337             .unwrap();
    338         sqlx::query("DELETE FROM artifact_delivery_observations")
    339             .execute(&mut data.database)
    340             .await
    341             .unwrap();
    342         for index in 0..2305u32 {
    343             let mut target = [0; 32];
    344             target[..4].copy_from_slice(&index.to_be_bytes());
    345             sqlx::query("INSERT INTO artifact_delivery_observations(workspace,operation_id,artifact_key,request_key,target_key,kind,protected) VALUES(?,?,?,?,?,1,x'01')").bind(e.workspace_id().as_bytes().as_slice()).bind(e.operation_id().as_bytes().as_slice()).bind(e.recipient().unwrap().as_bytes().as_slice()).bind(request.as_slice()).bind(target.as_slice()).execute(&mut data.database).await.unwrap();
    346         }
    347         let error = observation::Observations::read(
    348             &mut data.database,
    349             &graph,
    350             &selected,
    351             e.operation_id(),
    352             &data.crypto,
    353         )
    354         .await
    355         .err()
    356         .expect("excess observation keys must fail");
    357         assert_eq!(error.code(), "recovery_required");
    358         sqlx::query("ROLLBACK")
    359             .execute(&mut data.database)
    360             .await
    361             .unwrap();
    362         let restored = observation::Observations::read(
    363             &mut data.database,
    364             &graph,
    365             &selected,
    366             e.operation_id(),
    367             &data.crypto,
    368         )
    369         .await
    370         .unwrap();
    371         assert_eq!(restored.reports, [original]);
    372     }
    373 }