lib

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

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 }