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 }