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 }