lib

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

tests.rs (13234B)


      1 use super::*;
      2 use alloc::{string::String, vec::Vec};
      3 use nostr::nips::nip44::v2::{ConversationKey, decrypt_to_bytes};
      4 use radroots_signing::provider::ProviderError;
      5 use std::sync::{
      6     Mutex,
      7     atomic::{AtomicUsize, Ordering},
      8 };
      9 
     10 const NOW: u64 = 1_700_200_000;
     11 fn time(value: u64) -> NonZeroU64 {
     12     NonZeroU64::new(value).unwrap()
     13 }
     14 
     15 #[test]
     16 fn public_past_time_boundary_is_positive_bounded_and_refuses_invalid_time_or_entropy() {
     17     for now in [1, 2, PAST_SECONDS, NOW, MAX_TIME] {
     18         let selected = randomized_past_time(time(now), &Entropy::default())
     19             .unwrap()
     20             .get();
     21         assert!((now.saturating_sub(PAST_SECONDS).max(1)..=now).contains(&selected));
     22     }
     23     let source = Entropy::default();
     24     assert_eq!(
     25         randomized_past_time(time(MAX_TIME + 1), &source),
     26         Err(WrapError::InvalidTime)
     27     );
     28     assert_eq!(source.calls.load(Ordering::SeqCst), 0);
     29     let source = Entropy {
     30         fail_at: Some(0),
     31         ..Default::default()
     32     };
     33     assert_eq!(
     34         randomized_past_time(time(NOW), &source),
     35         Err(WrapError::EntropyUnavailable)
     36     );
     37 }
     38 fn keys(value: u8) -> nostr::Keys {
     39     let mut key = [0; 32];
     40     key[31] = value;
     41     nostr::Keys::new(nostr::SecretKey::from_slice(&key).unwrap())
     42 }
     43 fn identity(keys: &nostr::Keys) -> PublicKey {
     44     PublicKey::from_hex(&keys.public_key().to_hex()).unwrap()
     45 }
     46 #[derive(Default)]
     47 struct Entropy {
     48     calls: AtomicUsize,
     49     fail_at: Option<usize>,
     50     draws: Mutex<Vec<[u8; 32]>>,
     51 }
     52 impl NonceSource for Entropy {
     53     fn next_nonce(&self) -> Result<[u8; 32], ProviderError> {
     54         let call = self.calls.fetch_add(1, Ordering::SeqCst);
     55         if self.fail_at == Some(call) {
     56             return Err(ProviderError::CapabilityUnavailable);
     57         }
     58         let mut draws = self.draws.lock().unwrap();
     59         if !draws.is_empty() {
     60             Ok(draws.remove(0))
     61         } else {
     62             Ok([42 + call as u8; 32])
     63         }
     64     }
     65 }
     66 fn seal_with(
     67     author: &nostr::Keys,
     68     peer: &nostr::Keys,
     69     kind: u16,
     70     at: u64,
     71     tags: Vec<nostr::Tag>,
     72     content: Option<String>,
     73 ) -> (String, String) {
     74     let mut rumor = nostr::UnsignedEvent {
     75         id: None,
     76         pubkey: author.public_key(),
     77         created_at: nostr::Timestamp::from_secs(1_700_000_000),
     78         kind: nostr::Kind::PrivateDirectMessage,
     79         tags: nostr::Tags::from_list(vec![nostr::Tag::public_key(peer.public_key())]),
     80         content: "original café 🌱\u{0000} message".into(),
     81     };
     82     let _ = rumor.id();
     83     let original = rumor.as_json();
     84     let content = content.unwrap_or_else(|| {
     85         base64::engine::general_purpose::STANDARD.encode(
     86             super::super::private::encrypt_payload(
     87                 author.secret_key(),
     88                 &peer.public_key(),
     89                 &original,
     90                 [31; 32],
     91             )
     92             .unwrap(),
     93         )
     94     });
     95     let seal = nostr::EventBuilder::new(nostr::Kind::Custom(kind), content)
     96         .tags(tags)
     97         .custom_created_at(nostr::Timestamp::from_secs(at))
     98         .sign_with_keys(author)
     99         .unwrap();
    100     (seal.as_json(), original)
    101 }
    102 fn seal(author: &nostr::Keys, peer: &nostr::Keys) -> (String, String) {
    103     seal_with(author, peer, 13, 1_699_999_990, vec![], None)
    104 }
    105 fn decrypt(peer: &nostr::Keys, outer: &nostr::Event) -> Vec<u8> {
    106     let key = ConversationKey::derive(peer.secret_key(), &outer.pubkey).unwrap();
    107     decrypt_to_bytes(
    108         &key,
    109         &base64::engine::general_purpose::STANDARD
    110             .decode(&outer.content)
    111             .unwrap(),
    112     )
    113     .unwrap()
    114 }
    115 
    116 #[tokio::test]
    117 async fn peer_and_self_wrap_exact_retained_seals_without_participant_signing() {
    118     let author = keys(1);
    119     let peer = keys(2);
    120     for recipient in [&peer, &author] {
    121         let (raw, rumor) = seal(&author, recipient);
    122         // Whitespace belongs to obtained representation, though not NIP-01 ID.
    123         let original = format!(" \n{raw}\t");
    124         let entropy = Entropy::default();
    125         let pending =
    126             wrap_retained_seal(&original, identity(recipient), time(NOW), &entropy).unwrap();
    127         let outer = nostr::Event::from_json(pending.signed_json()).unwrap();
    128         outer.verify().unwrap();
    129         assert_eq!(outer.id.to_bytes(), pending.event_id());
    130         assert_eq!(outer.kind, nostr::Kind::GiftWrap);
    131         assert_eq!(
    132             outer.tags.as_slice(),
    133             &[nostr::Tag::public_key(recipient.public_key())]
    134         );
    135         assert_ne!(outer.pubkey, author.public_key());
    136         assert_ne!(outer.pubkey, recipient.public_key());
    137         assert!((NOW - PAST_SECONDS..=NOW).contains(&outer.created_at.as_secs()));
    138         assert_eq!(decrypt(recipient, &outer), original.as_bytes());
    139         let recovered = nostr::nips::nip59::extract_rumor(recipient, &outer)
    140             .await
    141             .unwrap();
    142         assert_eq!(recovered.sender, author.public_key());
    143         assert_eq!(recovered.rumor.as_json(), rumor);
    144         assert_eq!(pending.recipient(), identity(recipient));
    145         assert_eq!(
    146             pending.seal_digest(),
    147             sha256::Hash::hash(original.as_bytes()).to_byte_array()
    148         );
    149         assert_eq!(
    150             pending.seal_event_id(),
    151             nostr::Event::from_json(&raw).unwrap().id.to_bytes()
    152         );
    153         pending.with_wrapping_key(|key| {
    154             assert_eq!(keys_from(key).public_key(), outer.pubkey);
    155         });
    156         assert_eq!(entropy.calls.load(Ordering::SeqCst), 4);
    157         assert_eq!(format!("{pending:?}"), "PendingGiftWrap(<redacted>)");
    158         assert!(pending.signed_json().len() <= SIGNED_MAX_BYTES);
    159     }
    160 }
    161 fn keys_from(key: &[u8; 32]) -> nostr::Keys {
    162     nostr::Keys::new(nostr::SecretKey::from_slice(key).unwrap())
    163 }
    164 
    165 #[test]
    166 fn malformed_oversized_and_wrong_profile_seals_refuse_before_entropy() {
    167     let author = keys(1);
    168     let peer = keys(2);
    169     let recipient = identity(&peer);
    170     let (raw, _) = seal(&author, &peer);
    171     let mut altered: serde_json::Value = serde_json::from_str(&raw).unwrap();
    172     altered["sig"] = serde_json::Value::String("0".repeat(128));
    173     let mut extra: serde_json::Value = serde_json::from_str(&raw).unwrap();
    174     extra["extra"] = 1.into();
    175     let mut bad_id: serde_json::Value = serde_json::from_str(&raw).unwrap();
    176     bad_id["id"] = "0".repeat(64).into();
    177     let mut malformed_payload = vec![2; 98];
    178     malformed_payload[0] = 3;
    179     let cases = vec![
    180         ("".into(), WrapError::InvalidSeal),
    181         ("{}".into(), WrapError::InvalidSeal),
    182         ("x".repeat(SIGNED_MAX_BYTES + 1), WrapError::LimitExceeded),
    183         (
    184             format!("{{\"kind\":13,{}", &raw[1..]),
    185             WrapError::InvalidSeal,
    186         ),
    187         (altered.to_string(), WrapError::InvalidSeal),
    188         (extra.to_string(), WrapError::InvalidSeal),
    189         (bad_id.to_string(), WrapError::InvalidSeal),
    190         (
    191             seal_with(&author, &peer, 1059, NOW, vec![], None).0,
    192             WrapError::InvalidSeal,
    193         ),
    194         (
    195             seal_with(&author, &peer, 13, 0, vec![], None).0,
    196             WrapError::InvalidSeal,
    197         ),
    198         (
    199             seal_with(&author, &peer, 13, NOW + 1, vec![], None).0,
    200             WrapError::InvalidSeal,
    201         ),
    202         (
    203             seal_with(
    204                 &author,
    205                 &peer,
    206                 13,
    207                 NOW,
    208                 vec![nostr::Tag::public_key(peer.public_key())],
    209                 None,
    210             )
    211             .0,
    212             WrapError::InvalidSeal,
    213         ),
    214         (
    215             seal_with(&author, &peer, 13, NOW, vec![], Some("not base64".into())).0,
    216             WrapError::InvalidSeal,
    217         ),
    218         (
    219             seal_with(
    220                 &author,
    221                 &peer,
    222                 13,
    223                 NOW,
    224                 vec![],
    225                 Some(base64::engine::general_purpose::STANDARD.encode(&malformed_payload)),
    226             )
    227             .0,
    228             WrapError::InvalidSeal,
    229         ),
    230     ];
    231     for (raw, expected) in cases {
    232         let entropy = Entropy::default();
    233         assert_eq!(
    234             wrap_retained_seal(&raw, recipient, time(NOW), &entropy).unwrap_err(),
    235             expected
    236         );
    237         assert_eq!(entropy.calls.load(Ordering::SeqCst), 0);
    238     }
    239     let entropy = Entropy::default();
    240     assert_eq!(
    241         wrap_retained_seal(&raw, recipient, time(MAX_TIME + 1), &entropy).unwrap_err(),
    242         WrapError::InvalidTime
    243     );
    244     assert_eq!(entropy.calls.load(Ordering::SeqCst), 0);
    245 }
    246 
    247 #[test]
    248 fn exact_large_representation_cannot_hide_behind_small_canonical_seal() {
    249     let author = keys(1);
    250     let peer = keys(2);
    251     let (raw, _) = seal(&author, &peer);
    252     let original = format!("{}{raw}", " ".repeat(60_000));
    253     assert!(original.len() < SIGNED_MAX_BYTES);
    254     let entropy = Entropy::default();
    255     assert_eq!(
    256         wrap_retained_seal(&original, identity(&peer), time(NOW), &entropy).unwrap_err(),
    257         WrapError::LimitExceeded
    258     );
    259     assert_eq!(entropy.calls.load(Ordering::SeqCst), 0);
    260 }
    261 
    262 #[test]
    263 fn large_supported_representation_and_latest_profile_time_execute_real_crypto() {
    264     let author = keys(1);
    265     let peer = keys(2);
    266     let (raw, _) = seal(&author, &peer);
    267     let original = format!("{}{raw}", " ".repeat(40_960 - raw.len()));
    268     let pending = wrap_retained_seal(
    269         &original,
    270         identity(&peer),
    271         time(MAX_TIME),
    272         &Entropy::default(),
    273     )
    274     .unwrap();
    275     let outer = nostr::Event::from_json(pending.signed_json()).unwrap();
    276     outer.verify().unwrap();
    277     assert_eq!(decrypt(&peer, &outer), original.as_bytes());
    278     assert!((MAX_TIME - PAST_SECONDS..=MAX_TIME).contains(&outer.created_at.as_secs()));
    279     assert!(
    280         pending.signed_json().len()
    281             <= GiftWrapBudget::for_seal(original.len(), identity(&peer))
    282                 .unwrap()
    283                 .signed_max_bytes()
    284     );
    285 }
    286 
    287 #[test]
    288 fn failure_at_each_entropy_boundary_preserves_original_input() {
    289     let author = keys(1);
    290     let peer = keys(2);
    291     let (raw, _) = seal(&author, &peer);
    292     let before = raw.clone();
    293     for fail_at in 0..4 {
    294         let entropy = Entropy {
    295             fail_at: Some(fail_at),
    296             ..Default::default()
    297         };
    298         assert_eq!(
    299             wrap_retained_seal(&raw, identity(&peer), time(NOW), &entropy).unwrap_err(),
    300             WrapError::EntropyUnavailable
    301         );
    302         assert_eq!(entropy.calls.load(Ordering::SeqCst), fail_at + 1);
    303         assert_eq!(raw, before);
    304     }
    305 }
    306 
    307 #[test]
    308 fn rejection_sampling_is_bounded_and_never_uses_participant_keys() {
    309     let author = keys(1);
    310     let peer = keys(2);
    311     let mut one = [0; 32];
    312     one[31] = 1;
    313     let mut two = [0; 32];
    314     two[31] = 2;
    315     let entropy = Entropy {
    316         draws: Mutex::new(vec![[0; 32], [255; 32], one, two, [3; 32]]),
    317         ..Default::default()
    318     };
    319     let (_, generated) = wrapping_keys(&entropy, identity(&author), identity(&peer)).unwrap();
    320     assert_ne!(generated.public_key(), author.public_key());
    321     assert_ne!(generated.public_key(), peer.public_key());
    322     assert_eq!(entropy.calls.load(Ordering::SeqCst), 5);
    323     let entropy = Entropy {
    324         draws: Mutex::new(vec![[0; 32]; ENTROPY_DRAWS]),
    325         ..Default::default()
    326     };
    327     assert!(matches!(
    328         wrapping_keys(&entropy, identity(&author), identity(&peer)),
    329         Err(WrapError::EntropyUnavailable)
    330     ));
    331     assert_eq!(entropy.calls.load(Ordering::SeqCst), ENTROPY_DRAWS);
    332     let entropy = Entropy {
    333         draws: Mutex::new(vec![[0; 32]; ENTROPY_DRAWS]),
    334         ..Default::default()
    335     };
    336     assert_eq!(
    337         past_time(NOW, &entropy).unwrap_err(),
    338         WrapError::EntropyUnavailable
    339     );
    340     assert_eq!(entropy.calls.load(Ordering::SeqCst), ENTROPY_DRAWS);
    341     assert_eq!(past_time(1, &Entropy::default()).unwrap(), 1);
    342     let entropy = Entropy {
    343         draws: Mutex::new(vec![[0; 32], [255; 32]]),
    344         ..Default::default()
    345     };
    346     let at = past_time(NOW, &entropy).unwrap();
    347     assert!((NOW - PAST_SECONDS..=NOW).contains(&at));
    348     assert_eq!(entropy.calls.load(Ordering::SeqCst), 2);
    349 }
    350 
    351 #[test]
    352 fn temporary_wraps_are_separate_and_wrong_recipient_cannot_decrypt() {
    353     let author = keys(1);
    354     let peer = keys(2);
    355     let (raw, _) = seal(&author, &peer);
    356     let entropy = Entropy::default();
    357     let first = wrap_retained_seal(&raw, identity(&peer), time(NOW), &entropy).unwrap();
    358     let second = wrap_retained_seal(&raw, identity(&peer), time(NOW), &entropy).unwrap();
    359     assert_ne!(first.event_id(), second.event_id());
    360     assert_eq!(first.seal_digest(), second.seal_digest());
    361     let outer = nostr::Event::from_json(first.signed_json()).unwrap();
    362     let key = ConversationKey::derive(author.secret_key(), &outer.pubkey).unwrap();
    363     assert!(
    364         decrypt_to_bytes(
    365             &key,
    366             &base64::engine::general_purpose::STANDARD
    367                 .decode(&outer.content)
    368                 .unwrap()
    369         )
    370         .is_err()
    371     );
    372     for error in [
    373         WrapError::InvalidSeal,
    374         WrapError::LimitExceeded,
    375         WrapError::InvalidTime,
    376         WrapError::EntropyUnavailable,
    377         WrapError::CryptoFailure,
    378     ] {
    379         assert!(error.to_string().len() < 40);
    380         assert!(!error.to_string().contains(&raw));
    381     }
    382 }