wire_admission.rs (9609B)
1 use super::*; 2 use radroots_event::admission::RawEvent; 3 use radroots_event_codec::verify::{self, Nip01SignatureVerifier}; 4 use radroots_storage::event::{AdmissionStage, EventAdmission}; 5 use radroots_transport::source::{EventProvenance, ObservedEvent}; 6 7 #[derive(Clone, Copy, Debug, Eq, PartialEq)] 8 enum Variant { 9 Reordered, 10 Limit, 11 Extra, 12 Signature, 13 Duplicate, 14 Oversize, 15 } 16 17 impl Variant { 18 fn permits_admission(self) -> bool { 19 matches!(self, Self::Reordered | Self::Limit) 20 } 21 } 22 23 fn verified_admission(event: SignedEvent) -> EventAdmission { 24 let target = Target::new(TransportId::NOSTR, "wss://relay.example").expect("target"); 25 let verified = verify::signature( 26 verify::id(RawEvent::new(event.envelope().clone())).expect("identifier"), 27 &Nip01SignatureVerifier, 28 ) 29 .expect("actual Schnorr signature"); 30 let observed = ObservedEvent::new( 31 event, 32 EventProvenance::new( 33 TransportId::NOSTR, 34 target.fingerprint().clone(), 35 1_800_000_200_000, 36 ) 37 .expect("provenance"), 38 ); 39 EventAdmission::verified(observed, verified).expect("verified incoming event") 40 } 41 42 fn alternate(original: &SignedEvent, variant: Variant) -> SignedEvent { 43 let mut value: serde_json::Value = 44 serde_json::from_str(original.raw_json()).expect("wire JSON"); 45 match variant { 46 Variant::Extra => value["future_attribute"] = serde_json::json!("retained extension"), 47 Variant::Signature => { 48 value["sig"] = serde_json::json!( 49 Secp256k1::new() 50 .sign_schnorr_with_aux_rand( 51 &Message::from_digest(*original.id().as_bytes()), 52 &signing_keypair(), 53 &[2; 32], 54 ) 55 .to_string() 56 ); 57 } 58 _ => {} 59 } 60 let mut raw = serde_json::to_string_pretty(&value).expect("alternate serialization"); 61 if variant == Variant::Duplicate { 62 assert_eq!(raw.pop(), Some('}')); 63 raw.push_str(&format!(",\"id\":\"{}\"}}", original.id().to_hex())); 64 } 65 if matches!(variant, Variant::Limit | Variant::Oversize) { 66 let limit = 64 * 1024 + usize::from(variant == Variant::Oversize); 67 raw.insert_str(0, &" ".repeat(limit - raw.len())); 68 assert_eq!(raw.len(), limit); 69 } 70 let wire = radroots_event::wire::Nip01EventWire::parse_json(&raw).expect("valid identifier"); 71 SignedEvent::from_wire_verified_id(wire, raw).expect("exact raw/wire binding") 72 } 73 74 async fn exercise( 75 storage: Arc<dyn SyncStorage>, 76 variant: Variant, 77 ) -> (SignedEvent, SignedEvent, SyncId) { 78 let sink = Arc::new(ScriptedSink::new([DeliveryBehavior::Outcomes(vec![ 79 DeliveryOutcome::accepted(), 80 ])])); 81 let signer = Arc::new(MockSigner::new(SignBehavior::Success { 82 completed_at_unix_ms: 1_800_000_200_500, 83 })); 84 let engine = Engine::builder( 85 storage.clone(), 86 Arc::new(TestClock(AtomicU64::new(1_800_000_200_000))), 87 Arc::new(TestIds(AtomicU64::new(10))), 88 DeadlinePolicy::new(10_000, 10_000, 10_000).expect("deadlines"), 89 ) 90 .sink(sink.clone()) 91 .signer(signer.clone()) 92 .build() 93 .expect("engine"); 94 let push = request(119, "wss://relay.example"); 95 let signed = engine 96 .sign_prepared(push.clone()) 97 .await 98 .expect("actual signed artifact"); 99 let original = signed 100 .artifact() 101 .signed() 102 .expect("signed bytes") 103 .event() 104 .clone(); 105 let remote = alternate(&original, variant); 106 assert_ne!(remote.raw_json(), original.raw_json()); 107 assert_eq!(remote.id(), original.id()); 108 assert_eq!( 109 remote.wire() == original.wire(), 110 !matches!(variant, Variant::Extra | Variant::Signature) 111 ); 112 EventStore::admit(storage.as_ref(), verified_admission(remote.clone())) 113 .await 114 .expect("initial canonical observation"); 115 // The store's strict byte-conflict invariant remains in force. 116 assert_eq!( 117 EventStore::admit(storage.as_ref(), verified_admission(original.clone())).await, 118 Err(radroots_storage::Error::EventConflict) 119 ); 120 121 let result = engine.admit_signed(push.operation_id()).await; 122 if variant.permits_admission() { 123 assert!( 124 result 125 .expect("equivalent-wire admission") 126 .artifact() 127 .admission_state() 128 .is_admitted() 129 ); 130 assert!( 131 engine 132 .admit_signed(push.operation_id()) 133 .await 134 .expect("exact admission replay") 135 .is_replay() 136 ); 137 engine 138 .deliver_push(push.operation_id()) 139 .await 140 .expect("original delivery"); 141 let requests = sink.requests.lock().expect("delivery records"); 142 assert_eq!(requests.len(), 1); 143 assert_eq!( 144 requests[0].payload().event().raw_json(), 145 original.raw_json() 146 ); 147 } else { 148 assert_eq!(result, Err(Error::AdmissionFailed)); 149 } 150 let status = engine 151 .push_status(push.operation_id()) 152 .await 153 .expect("status") 154 .expect("retained operation"); 155 assert_eq!( 156 status 157 .artifact() 158 .signed() 159 .expect("original artifact") 160 .event() 161 .raw_json(), 162 original.raw_json() 163 ); 164 assert_eq!(signer.calls.load(Ordering::Relaxed), 1); 165 let canonical = EventStore::query_raw( 166 storage.as_ref(), 167 EventQuery::for_ids( 168 EventQueryBounds::first(1).expect("bounds"), 169 vec![*original.id()], 170 ) 171 .expect("identifier query"), 172 ) 173 .await 174 .expect("canonical event"); 175 assert_eq!(canonical.items().len(), 1); 176 assert_eq!(canonical.items()[0].event().raw_json(), remote.raw_json()); 177 assert_eq!( 178 canonical.items()[0].stage(), 179 if variant.permits_admission() { 180 AdmissionStage::Visible 181 } else { 182 AdmissionStage::Verified 183 } 184 ); 185 (original, remote, push.operation_id()) 186 } 187 188 #[test] 189 fn memory_wire_variants_preserve_both_originals_and_refuse_profile_or_signature_changes() { 190 for (generation, variant) in [ 191 (81, Variant::Reordered), 192 (82, Variant::Limit), 193 (83, Variant::Extra), 194 (84, Variant::Signature), 195 (85, Variant::Duplicate), 196 (86, Variant::Oversize), 197 ] { 198 block_on(exercise( 199 Arc::new(MemoryStorage::new( 200 SourceGeneration::new([generation; 32]).expect("generation"), 201 )), 202 variant, 203 )); 204 } 205 } 206 207 #[tokio::test] 208 async fn sqlite_wire_variants_preserve_both_originals_across_explicit_close_and_reopen() { 209 for (generation, variant) in [ 210 (91, Variant::Reordered), 211 (92, Variant::Limit), 212 (93, Variant::Extra), 213 (94, Variant::Signature), 214 (95, Variant::Duplicate), 215 (96, Variant::Oversize), 216 ] { 217 let directory = tempfile::tempdir().expect("database directory"); 218 let paths = Paths::from_directory(directory.path()).expect("paths"); 219 let storage = Arc::new( 220 SqliteStorage::open( 221 OpenOptions::new(paths.clone(), OpenMode::Create) 222 .with_source_generation( 223 SourceGeneration::new([generation; 32]).expect("generation"), 224 1, 225 ) 226 .expect("source generation"), 227 ) 228 .await 229 .expect("SQLite"), 230 ); 231 let (original, remote, operation_id) = exercise(storage.clone(), variant).await; 232 storage.close().await.expect("explicit close"); 233 let reopened = Arc::new( 234 SqliteStorage::open(OpenOptions::new(paths, OpenMode::ReadOnly)) 235 .await 236 .expect("read-only reopen"), 237 ); 238 let events = reopened 239 .query_raw(EventQuery::all(EventQueryBounds::first(1).expect("bounds"))) 240 .await 241 .expect("retained canonical row"); 242 assert_eq!(events.items().len(), 1); 243 assert_eq!(events.items()[0].event().raw_json(), remote.raw_json()); 244 assert_eq!( 245 events.items()[0].stage(), 246 if variant.permits_admission() { 247 AdmissionStage::Visible 248 } else { 249 AdmissionStage::Verified 250 } 251 ); 252 let inspection: Arc<dyn SyncStorage> = reopened.clone(); 253 let reader = Engine::builder( 254 inspection, 255 Arc::new(TestClock(AtomicU64::new(1_800_000_201_000))), 256 Arc::new(TestIds(AtomicU64::new(100))), 257 DeadlinePolicy::new(10_000, 10_000, 10_000).expect("deadlines"), 258 ) 259 .sink(Arc::new(MockSink)) 260 .build() 261 .expect("read-only inspection without signer"); 262 let status = reader 263 .push_status(operation_id) 264 .await 265 .expect("read-only status") 266 .expect("original operation"); 267 assert_eq!( 268 status 269 .artifact() 270 .signed() 271 .expect("original retained evidence") 272 .event() 273 .raw_json(), 274 original.raw_json() 275 ); 276 assert_eq!( 277 status.artifact().admission_state().is_admitted(), 278 variant.permits_admission() 279 ); 280 reopened.close().await.expect("close inspection"); 281 } 282 }