opening_tests.rs (17492B)
1 use super::*; 2 use nostr::JsonUtil; 3 use nostr::{ 4 signer::{SignerBackend, SignerError}, 5 util::BoxedFuture, 6 }; 7 use serde_json::{Value, json}; 8 use std::sync::atomic::{AtomicUsize, Ordering}; 9 10 struct ObservedSigner { 11 keys: nostr::Keys, 12 switch_at: usize, 13 observations: AtomicUsize, 14 decryptions: AtomicUsize, 15 } 16 impl core::fmt::Debug for ObservedSigner { 17 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { 18 f.write_str("ObservedSigner") 19 } 20 } 21 impl NostrSigner for ObservedSigner { 22 fn backend(&self) -> SignerBackend<'_> { 23 SignerBackend::Keys 24 } 25 fn get_public_key(&self) -> BoxedFuture<'_, Result<PublicKey, SignerError>> { 26 Box::pin(async move { 27 let n = self.observations.fetch_add(1, Ordering::SeqCst); 28 Ok(if n >= self.switch_at { 29 keys(4).public_key() 30 } else { 31 self.keys.public_key() 32 }) 33 }) 34 } 35 fn sign_event(&self, value: UnsignedEvent) -> BoxedFuture<'_, Result<Event, SignerError>> { 36 self.keys.sign_event(value) 37 } 38 fn nip04_encrypt<'a>( 39 &'a self, 40 key: &'a PublicKey, 41 text: &'a str, 42 ) -> BoxedFuture<'a, Result<String, SignerError>> { 43 self.keys.nip04_encrypt(key, text) 44 } 45 fn nip04_decrypt<'a>( 46 &'a self, 47 key: &'a PublicKey, 48 text: &'a str, 49 ) -> BoxedFuture<'a, Result<String, SignerError>> { 50 self.keys.nip04_decrypt(key, text) 51 } 52 fn nip44_encrypt<'a>( 53 &'a self, 54 key: &'a PublicKey, 55 text: &'a str, 56 ) -> BoxedFuture<'a, Result<String, SignerError>> { 57 self.keys.nip44_encrypt(key, text) 58 } 59 fn nip44_decrypt<'a>( 60 &'a self, 61 key: &'a PublicKey, 62 text: &'a str, 63 ) -> BoxedFuture<'a, Result<String, SignerError>> { 64 self.decryptions.fetch_add(1, Ordering::SeqCst); 65 self.keys.nip44_decrypt(key, text) 66 } 67 } 68 69 fn keys(value: u8) -> nostr::Keys { 70 let mut secret = [0; 32]; 71 secret[31] = value; 72 nostr::Keys::new(nostr::SecretKey::from_slice(&secret).unwrap()) 73 } 74 async fn envelope(sender: &nostr::Keys, recipient: &nostr::Keys, raw: &str) -> Event { 75 let encrypted = sender 76 .nip44_encrypt(&recipient.public_key(), raw) 77 .await 78 .unwrap(); 79 let seal = EventBuilder::new(Kind::Seal, encrypted) 80 .custom_created_at(Timestamp::from_secs(1_700_000_001)) 81 .sign_with_keys(sender) 82 .unwrap(); 83 EventBuilder::gift_wrap_from_seal(&recipient.public_key(), &seal, []).unwrap() 84 } 85 86 #[tokio::test] 87 async fn raw_rumor_kinds_and_identity_never_normalize_into_an_accepted_message() { 88 let sender = keys(1); 89 let recipient = keys(2); 90 let message = Message { 91 recipients: vec![radroots_event::social::message::MessageRecipient { 92 public_key: recipient.public_key().to_hex(), 93 relay_url: None, 94 }], 95 content: "Synthetic bounded opening regression".into(), 96 reply_to: None, 97 subject: None, 98 }; 99 let parts = message_encode::to_wire_parts(&message).unwrap(); 100 let mut rumor = rumor_from_parts(parts, sender.public_key(), Some(1_700_000_000)).unwrap(); 101 let _ = rumor.id(); 102 let original: Value = serde_json::from_str(&rumor.as_json()).unwrap(); 103 let valid = envelope(&sender, &recipient, &original.to_string()).await; 104 assert!(unwrap_gift_wrap(&recipient, &valid).await.is_ok()); 105 let mut accepted = Vec::new(); 106 for (name, field, value) in [ 107 ("u16 overflow kind", "kind", json!(65_550)), 108 ("u32 overflow kind", "kind", json!(4_294_967_310u64)), 109 ("wrong rumor identity", "id", json!("00".repeat(32))), 110 ("unknown rumor field", "future_private_field", json!(true)), 111 ] { 112 let mut changed = original.clone(); 113 changed[field] = value; 114 let outer = envelope(&sender, &recipient, &changed.to_string()).await; 115 if unwrap_gift_wrap(&recipient, &outer).await.is_ok() { 116 accepted.push(name); 117 } 118 } 119 assert!( 120 accepted.is_empty(), 121 "accepted malformed representations: {accepted:?}" 122 ); 123 } 124 125 fn rumor(sender: &nostr::Keys, recipient: &nostr::Keys, content: &str) -> UnsignedEvent { 126 let mut rumor = UnsignedEvent { 127 id: None, 128 pubkey: sender.public_key(), 129 created_at: Timestamp::from_secs(1_700_000_000), 130 kind: Kind::PrivateDirectMessage, 131 tags: nostr::Tags::from_list(vec![Tag::public_key(recipient.public_key())]), 132 content: content.into(), 133 }; 134 let _ = rumor.id(); 135 rumor 136 } 137 138 async fn wrap_raw_seal(recipient: &nostr::Keys, raw: &str, tags: Vec<Tag>) -> Event { 139 let ephemeral = keys(3); 140 let content = ephemeral 141 .nip44_encrypt(&recipient.public_key(), raw) 142 .await 143 .unwrap(); 144 EventBuilder::new(Kind::GiftWrap, content) 145 .tags(tags) 146 .custom_created_at(Timestamp::from_secs(1_700_000_002)) 147 .sign_with_keys(&ephemeral) 148 .unwrap() 149 } 150 151 #[tokio::test] 152 async fn authenticated_outer_recipient_and_closed_seal_are_required() { 153 let sender = keys(1); 154 let recipient = keys(2); 155 let original = rumor(&sender, &recipient, "Synthetic carrier validation"); 156 let content = sender 157 .nip44_encrypt(&recipient.public_key(), &original.as_json()) 158 .await 159 .unwrap(); 160 let seal = EventBuilder::new(Kind::Seal, content.clone()) 161 .custom_created_at(Timestamp::from_secs(1_700_000_001)) 162 .sign_with_keys(&sender) 163 .unwrap(); 164 let valid = wrap_raw_seal( 165 &recipient, 166 &seal.as_json(), 167 vec![Tag::public_key(recipient.public_key())], 168 ) 169 .await; 170 assert!(unwrap_gift_wrap(&recipient, &valid).await.is_ok()); 171 for tags in [ 172 vec![], 173 vec![Tag::public_key(sender.public_key())], 174 vec![ 175 Tag::public_key(recipient.public_key()), 176 Tag::public_key(sender.public_key()), 177 ], 178 ] { 179 let outer = wrap_raw_seal(&recipient, &seal.as_json(), tags).await; 180 assert!(matches!( 181 unwrap_gift_wrap(&recipient, &outer).await, 182 Err(Error::InvalidRecipient) 183 )); 184 } 185 let mut invalid_id = valid.clone(); 186 invalid_id.id = nostr::EventId::from_hex(&"00".repeat(32)).unwrap(); 187 assert!(matches!( 188 unwrap_gift_wrap(&recipient, &invalid_id).await, 189 Err(Error::GiftWrap) 190 )); 191 let mut invalid_sig = valid; 192 invalid_sig.sig = nostr::secp256k1::schnorr::Signature::from_slice(&[0; 64]).unwrap(); 193 assert!(matches!( 194 unwrap_gift_wrap(&recipient, &invalid_sig).await, 195 Err(Error::GiftWrap) 196 )); 197 for (kind, tags) in [ 198 (Kind::TextNote, vec![]), 199 (Kind::Seal, vec![Tag::public_key(recipient.public_key())]), 200 ] { 201 let wrong = EventBuilder::new(kind, content.clone()) 202 .tags(tags) 203 .custom_created_at(Timestamp::from_secs(1_700_000_001)) 204 .sign_with_keys(&sender) 205 .unwrap(); 206 let outer = wrap_raw_seal( 207 &recipient, 208 &wrong.as_json(), 209 vec![Tag::public_key(recipient.public_key())], 210 ) 211 .await; 212 assert!(matches!( 213 unwrap_gift_wrap(&recipient, &outer).await, 214 Err(Error::GiftWrap) 215 )); 216 } 217 for changed in [format!("{{\"kind\":13,{}", &seal.as_json()[1..]), { 218 let mut value: Value = serde_json::from_str(&seal.as_json()).unwrap(); 219 value["extra"] = json!(true); 220 value.to_string() 221 }] { 222 let outer = wrap_raw_seal( 223 &recipient, 224 &changed, 225 vec![Tag::public_key(recipient.public_key())], 226 ) 227 .await; 228 assert!(matches!( 229 unwrap_gift_wrap(&recipient, &outer).await, 230 Err(Error::GiftWrap) 231 )); 232 } 233 } 234 235 #[tokio::test] 236 async fn known_rumor_shape_author_id_recipient_and_complete_size_are_checked() { 237 let sender = keys(1); 238 let recipient = keys(2); 239 let other = keys(4); 240 let original = rumor(&sender, &recipient, "Synthetic rumor validation"); 241 let raw = original.as_json(); 242 let mut missing: Value = serde_json::from_str(&raw).unwrap(); 243 missing.as_object_mut().unwrap().remove("id"); 244 for raw in [ 245 missing.to_string(), 246 format!("{{\"kind\":14,{}", &raw[1..]), 247 "[]".into(), 248 rumor(&other, &recipient, "Wrong author").as_json(), 249 rumor(&sender, &other, "Wrong recipient").as_json(), 250 rumor( 251 &sender, 252 &recipient, 253 &"a".repeat(radroots_protocol::chat::RUMOR_MAX_BYTES), 254 ) 255 .as_json(), 256 ] { 257 let outer = envelope(&sender, &recipient, &raw).await; 258 assert!(unwrap_gift_wrap(&recipient, &outer).await.is_err()); 259 } 260 let peer = envelope(&sender, &recipient, &original.as_json()).await; 261 let self_copy = envelope(&sender, &sender, &original.as_json()).await; 262 for (participant, event) in [(&recipient, peer), (&sender, self_copy)] { 263 let Rumor::Message(message) = unwrap_gift_wrap(participant, &event).await.unwrap() else { 264 panic!("expected chat") 265 }; 266 assert_eq!(message.id, original.id.unwrap().to_hex()); 267 assert_eq!(message.data.content, original.content); 268 assert_eq!( 269 message.data.recipients[0].public_key, 270 recipient.public_key().to_hex() 271 ); 272 } 273 } 274 275 #[tokio::test] 276 async fn identity_changes_stop_opening_and_invalid_outer_never_invokes_the_signer() { 277 let sender = keys(1); 278 let recipient = keys(2); 279 let original = rumor(&sender, &recipient, "Synthetic scoped identity"); 280 let outer = envelope(&sender, &recipient, &original.as_json()).await; 281 for switch_at in [1, 2, usize::MAX] { 282 let observed = ObservedSigner { 283 keys: keys(2), 284 switch_at, 285 observations: AtomicUsize::new(0), 286 decryptions: AtomicUsize::new(0), 287 }; 288 let result = unwrap_gift_wrap(&observed, &outer).await; 289 if switch_at == usize::MAX { 290 assert!(result.is_ok()); 291 } else { 292 assert!(matches!(result, Err(Error::Signer))); 293 } 294 assert_eq!( 295 observed.decryptions.load(Ordering::SeqCst), 296 switch_at.min(2) 297 ); 298 } 299 let observed = ObservedSigner { 300 keys: keys(2), 301 switch_at: usize::MAX, 302 observations: AtomicUsize::new(0), 303 decryptions: AtomicUsize::new(0), 304 }; 305 let mut invalid = outer; 306 invalid.id = nostr::EventId::from_hex(&"00".repeat(32)).unwrap(); 307 assert!(matches!( 308 unwrap_gift_wrap(&observed, &invalid).await, 309 Err(Error::GiftWrap) 310 )); 311 assert_eq!(observed.observations.load(Ordering::SeqCst), 0); 312 assert_eq!(observed.decryptions.load(Ordering::SeqCst), 0); 313 } 314 315 #[tokio::test] 316 async fn authentic_unknown_kind_is_unsupported_before_chat_tag_interpretation() { 317 let sender = keys(1); 318 let recipient = keys(2); 319 let mut value = rumor(&sender, &recipient, "Future private protocol content"); 320 value.kind = Kind::Custom(u16::MAX); 321 value.tags = nostr::Tags::default(); 322 value.id = None; 323 let _ = value.id(); 324 let outer = envelope(&sender, &recipient, &value.as_json()).await; 325 assert!(matches!( 326 unwrap_gift_wrap(&recipient, &outer).await, 327 Err(Error::UnsupportedRumorKind { kind: 65535 }) 328 )); 329 } 330 331 #[tokio::test] 332 async fn invalid_outer_tag_structure_is_rejected_before_provider_callbacks() { 333 let sender = keys(1); 334 let recipient = keys(2); 335 let original = rumor(&sender, &recipient, "Synthetic structural admission"); 336 let content = sender 337 .nip44_encrypt(&recipient.public_key(), &original.as_json()) 338 .await 339 .unwrap(); 340 let seal = EventBuilder::new(Kind::Seal, content) 341 .custom_created_at(Timestamp::from_secs(1_700_000_001)) 342 .sign_with_keys(&sender) 343 .unwrap(); 344 let outer = wrap_raw_seal( 345 &recipient, 346 &seal.as_json(), 347 vec![ 348 Tag::public_key(recipient.public_key()), 349 Tag::parse(["", "invalid tag key"]).unwrap(), 350 ], 351 ) 352 .await; 353 outer.verify().unwrap(); 354 let observed = ObservedSigner { 355 keys: keys(2), 356 switch_at: usize::MAX, 357 observations: AtomicUsize::new(0), 358 decryptions: AtomicUsize::new(0), 359 }; 360 assert!(matches!( 361 unwrap_gift_wrap(&observed, &outer).await, 362 Err(Error::GiftWrap) 363 )); 364 assert_eq!(observed.observations.load(Ordering::SeqCst), 0); 365 assert_eq!(observed.decryptions.load(Ordering::SeqCst), 0); 366 } 367 368 #[tokio::test] 369 async fn opening_admission_scalar_and_participant_negatives_are_not_normalized() { 370 let sender = keys(1); 371 let recipient = keys(2); 372 let original = rumor(&sender, &recipient, "Synthetic exact scalar checks"); 373 let original_value: Value = serde_json::from_str(&original.as_json()).unwrap(); 374 for (field, value) in [ 375 ("created_at", json!(253_402_300_800u64)), 376 ("tags", json!({})), 377 ("content", json!(0)), 378 ("id", json!(original.id.unwrap().to_hex().to_uppercase())), 379 ] { 380 let mut changed = original_value.clone(); 381 changed[field] = value; 382 let outer = envelope(&sender, &recipient, &changed.to_string()).await; 383 assert!( 384 matches!( 385 unwrap_gift_wrap(&recipient, &outer).await, 386 Err(Error::GiftWrap) 387 ), 388 "{field}" 389 ); 390 } 391 for tags in [ 392 vec![Tag::parse(["p"]).unwrap()], 393 vec![Tag::parse(["p", &recipient.public_key().to_hex(), "relay", "extra"]).unwrap()], 394 vec![Tag::parse(["p", &recipient.public_key().to_hex().to_uppercase()]).unwrap()], 395 vec![ 396 Tag::public_key(recipient.public_key()), 397 Tag::public_key(recipient.public_key()), 398 ], 399 vec![], 400 ] { 401 let mut changed = original.clone(); 402 changed.tags = nostr::Tags::from_list(tags); 403 changed.id = None; 404 let _ = changed.id(); 405 let outer = envelope(&sender, &recipient, &changed.as_json()).await; 406 assert!(matches!( 407 unwrap_gift_wrap(&recipient, &outer).await, 408 Err(Error::InvalidRecipient) 409 )); 410 } 411 let mut self_without_peers = original; 412 self_without_peers.tags = nostr::Tags::default(); 413 self_without_peers.id = None; 414 let _ = self_without_peers.id(); 415 let outer = envelope(&sender, &sender, &self_without_peers.as_json()).await; 416 assert!(matches!( 417 unwrap_gift_wrap(&sender, &outer).await, 418 Err(Error::InvalidRecipient) 419 )); 420 } 421 422 #[tokio::test] 423 async fn opening_admission_outer_budgets_reject_before_provider_callbacks() { 424 let recipient = keys(2); 425 let ephemeral = keys(3); 426 let limits = radroots_event::wire::EventWireLimits::default(); 427 let empty = String::new(); 428 let large_content = "a".repeat(radroots_protocol::chat::SIGNED_MAX_BYTES + 1); 429 let too_many_tags = vec![Tag::parse(["x"]).unwrap(); limits.max_tag_count + 1]; 430 let too_many_fields = vec![Tag::parse(vec!["x"; limits.max_total_tag_elements + 1]).unwrap()]; 431 let too_many_bytes = vec![ 432 Tag::parse(vec![ 433 "x".repeat(limits.max_tag_element_bytes); 434 limits.max_total_tag_bytes 435 / limits.max_tag_element_bytes 436 + 1 437 ]) 438 .unwrap(), 439 ]; 440 let large_field = 441 vec![Tag::parse(["x".into(), "a".repeat(limits.max_tag_element_bytes + 1)]).unwrap()]; 442 let mut long_p = vec!["p".into(), recipient.public_key().to_hex()]; 443 long_p.extend(["relay".into(), "extra".into()]); 444 let cases = [ 445 ( 446 Kind::TextNote, 447 &empty, 448 vec![Tag::public_key(recipient.public_key())], 449 ), 450 ( 451 Kind::GiftWrap, 452 &large_content, 453 vec![Tag::public_key(recipient.public_key())], 454 ), 455 (Kind::GiftWrap, &empty, too_many_tags), 456 (Kind::GiftWrap, &empty, too_many_fields), 457 (Kind::GiftWrap, &empty, too_many_bytes), 458 (Kind::GiftWrap, &empty, large_field), 459 ]; 460 for (kind, content, tags) in cases { 461 let outer = EventBuilder::new(kind, content) 462 .tags(tags) 463 .custom_created_at(Timestamp::from_secs(1_700_000_002)) 464 .sign_with_keys(&ephemeral) 465 .unwrap(); 466 outer.verify().unwrap(); 467 let observed = ObservedSigner { 468 keys: keys(2), 469 switch_at: usize::MAX, 470 observations: AtomicUsize::new(0), 471 decryptions: AtomicUsize::new(0), 472 }; 473 assert!(matches!( 474 unwrap_gift_wrap(&observed, &outer).await, 475 Err(Error::GiftWrap) 476 )); 477 assert_eq!(observed.observations.load(Ordering::SeqCst), 0); 478 assert_eq!(observed.decryptions.load(Ordering::SeqCst), 0); 479 } 480 let outer = EventBuilder::new(Kind::GiftWrap, empty) 481 .tags([Tag::parse(long_p).unwrap()]) 482 .custom_created_at(Timestamp::from_secs(1_700_000_002)) 483 .sign_with_keys(&ephemeral) 484 .unwrap(); 485 let observed = ObservedSigner { 486 keys: keys(2), 487 switch_at: usize::MAX, 488 observations: AtomicUsize::new(0), 489 decryptions: AtomicUsize::new(0), 490 }; 491 assert!(matches!( 492 unwrap_gift_wrap(&observed, &outer).await, 493 Err(Error::InvalidRecipient) 494 )); 495 assert_eq!(observed.decryptions.load(Ordering::SeqCst), 0); 496 }