auth.rs (22425B)
1 //! Explicit NIP-42 relay authentication state. 2 3 use crate::{Error, NostrTransport, RelayUrl}; 4 use nostr_sdk::prelude::{ClientMessage, Event}; 5 use radroots_transport::BoxFuture; 6 use std::collections::BTreeMap; 7 use std::fmt; 8 use std::sync::{Arc, Mutex}; 9 10 const MAX_CHALLENGE_BYTES: usize = 1_024; 11 const MAX_CHALLENGE_LIFETIME_MS: u64 = 600_000; 12 13 #[derive(Clone, Eq, PartialEq)] 14 struct PendingAuth { 15 challenge: String, 16 required_at_unix_ms: u64, 17 expires_at_unix_ms: u64, 18 } 19 20 impl fmt::Debug for PendingAuth { 21 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { 22 formatter 23 .debug_struct("PendingAuth") 24 .field("challenge", &"[redacted]") 25 .field("required_at_unix_ms", &self.required_at_unix_ms) 26 .field("expires_at_unix_ms", &self.expires_at_unix_ms) 27 .finish() 28 } 29 } 30 31 pub(crate) trait AuthClient: Send + Sync { 32 fn submit<'a>(&'a self, relay: RelayUrl, event: Event) -> BoxFuture<'a, Result<(), Error>>; 33 } 34 35 #[derive(Clone, Debug)] 36 pub(crate) struct LiveAuthClient { 37 client: nostr_sdk::client::Client, 38 } 39 40 impl LiveAuthClient { 41 pub(crate) const fn new(client: nostr_sdk::client::Client) -> Self { 42 Self { client } 43 } 44 } 45 46 impl AuthClient for LiveAuthClient { 47 // Relay submission is external SDK I/O; the state machine and submission 48 // outcomes are covered through the injected AuthClient boundary. 49 #[cfg_attr(coverage_nightly, coverage(off))] 50 fn submit<'a>(&'a self, relay: RelayUrl, event: Event) -> BoxFuture<'a, Result<(), Error>> { 51 Box::pin(async move { 52 let expected = relay.as_str().trim_end_matches('/'); 53 let output = self 54 .client 55 .send_msg(ClientMessage::auth(event)) 56 .to([relay.as_str()]) 57 .await 58 .map_err(|_| Error::AuthTransport)?; 59 if output 60 .success 61 .keys() 62 .any(|url| url.to_string().trim_end_matches('/') == expected) 63 { 64 Ok(()) 65 } else { 66 Err(Error::AuthTransport) 67 } 68 }) 69 } 70 } 71 72 pub(crate) struct AuthFlow { 73 client: Arc<dyn AuthClient>, 74 pending: Mutex<Option<BTreeMap<RelayUrl, PendingAuth>>>, 75 } 76 77 impl AuthFlow { 78 pub(crate) fn new(client: Arc<dyn AuthClient>) -> Self { 79 Self { 80 client, 81 pending: Mutex::new(Some(BTreeMap::new())), 82 } 83 } 84 85 pub(crate) fn close(&self) { 86 // Disposal never reads or reuses possibly poisoned authentication state. 87 *self 88 .pending 89 .lock() 90 .unwrap_or_else(std::sync::PoisonError::into_inner) = None; 91 } 92 93 #[cfg(test)] 94 pub(crate) fn isolated() -> Self { 95 let client = nostr_sdk::client::Client::default(); 96 Self::new(Arc::new(LiveAuthClient::new(client))) 97 } 98 99 fn begin( 100 &self, 101 relay: RelayUrl, 102 challenge: &str, 103 required_at_unix_ms: u64, 104 expires_at_unix_ms: u64, 105 ) -> Result<String, Error> { 106 validate_challenge(challenge, required_at_unix_ms, expires_at_unix_ms)?; 107 let pending = PendingAuth { 108 challenge: challenge.to_owned(), 109 required_at_unix_ms, 110 expires_at_unix_ms, 111 }; 112 let mut state = self 113 .pending 114 .lock() 115 .map_err(|_| Error::AuthStateUnavailable)?; 116 let state = state.as_mut().ok_or(Error::TransportClosed)?; 117 match state.get(&relay) { 118 Some(existing) if existing == &pending => {} 119 Some(_) => return Err(Error::AuthChallengeConflict), 120 None => { 121 state.insert(relay.clone(), pending); 122 } 123 } 124 serde_json::to_string(&serde_json::json!({ 125 "content": "", 126 "created_at_max_unix_ms": expires_at_unix_ms, 127 "created_at_min_unix_ms": required_at_unix_ms, 128 "kind": 22242, 129 "tags": [ 130 ["challenge", challenge], 131 ["relay", relay.as_str()], 132 ], 133 })) 134 .map_err(|_| Error::AuthStateUnavailable) 135 } 136 137 fn pending(&self, relay: &RelayUrl, challenge: &str) -> Result<PendingAuth, Error> { 138 let state = self 139 .pending 140 .lock() 141 .map_err(|_| Error::AuthStateUnavailable)?; 142 let state = state.as_ref().ok_or(Error::TransportClosed)?; 143 let pending = state.get(relay).ok_or(Error::AuthChallengeMissing)?; 144 if pending.challenge != challenge { 145 return Err(Error::AuthResponseMismatch); 146 } 147 Ok(pending.clone()) 148 } 149 150 fn remove(&self, relay: &RelayUrl, challenge: &str, obtained: bool) -> Result<(), Error> { 151 let mut state = self 152 .pending 153 .lock() 154 .map_err(|_| Error::AuthStateUnavailable)?; 155 let Some(state) = state.as_mut() else { 156 // A response obtained from already-started work remains an observed 157 // success even when shutdown disposed its pending challenge. 158 return if obtained { 159 Ok(()) 160 } else { 161 Err(Error::TransportClosed) 162 }; 163 }; 164 match state.get(relay) { 165 Some(pending) if pending.challenge == challenge => { 166 state.remove(relay); 167 Ok(()) 168 } 169 Some(_) => Err(Error::AuthResponseMismatch), 170 None => Err(Error::AuthChallengeMissing), 171 } 172 } 173 } 174 175 impl fmt::Debug for AuthFlow { 176 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { 177 let pending_count = self 178 .pending 179 .lock() 180 .map(|pending| pending.as_ref().map_or(0, BTreeMap::len)) 181 .unwrap_or_default(); 182 formatter 183 .debug_struct("AuthFlow") 184 .field("pending_count", &pending_count) 185 .finish_non_exhaustive() 186 } 187 } 188 189 impl NostrTransport { 190 /// Records an exact relay challenge and returns bounded signing input. 191 pub fn begin_authentication( 192 &self, 193 relay: &RelayUrl, 194 challenge: impl AsRef<str>, 195 required_at_unix_ms: u64, 196 expires_at_unix_ms: u64, 197 ) -> Result<String, Error> { 198 if self.admission_is_closed() { 199 return Err(Error::TransportClosed); 200 } 201 if !self.config().relays().contains(relay) { 202 return Err(Error::AuthResponseMismatch); 203 } 204 self.auth.begin( 205 relay.clone(), 206 challenge.as_ref(), 207 required_at_unix_ms, 208 expires_at_unix_ms, 209 ) 210 } 211 212 /// Verifies and submits one host-signed NIP-42 response without retrying. 213 pub fn complete_authentication<'a>( 214 &'a self, 215 relay: &'a RelayUrl, 216 challenge: &'a str, 217 signed_event_json: Option<&'a str>, 218 now_unix_ms: u64, 219 ) -> BoxFuture<'a, Result<(), Error>> { 220 Box::pin(async move { 221 let _operation = self.connections.begin().map_err(|error| match error { 222 radroots_transport::Error::TransportClosed => Error::TransportClosed, 223 _ => Error::AuthStateUnavailable, 224 })?; 225 let pending = self.auth.pending(relay, challenge)?; 226 if now_unix_ms > pending.expires_at_unix_ms { 227 self.auth.remove(relay, challenge, false)?; 228 return Err(Error::AuthChallengeExpired); 229 } 230 let signed_event_json = signed_event_json.ok_or(Error::AuthSignerUnavailable)?; 231 let signed = radroots_event_codec::decode::signed_event(signed_event_json) 232 .map_err(|_| Error::AuthResponseInvalid)?; 233 if radroots_nostr::event::verify(signed.envelope()) 234 != radroots_nostr::event::Verification::Verified 235 { 236 return Err(Error::AuthResponseInvalid); 237 } 238 let created_at_ms = signed.created_at().saturating_mul(1_000); 239 if signed.kind() != 22242 240 || !signed.content().is_empty() 241 || created_at_ms < pending.required_at_unix_ms 242 || created_at_ms > pending.expires_at_unix_ms 243 || !has_exact_tag(signed.tags_as_vec().as_slice(), "challenge", challenge) 244 || !has_exact_tag(signed.tags_as_vec().as_slice(), "relay", relay.as_str()) 245 { 246 return Err(Error::AuthResponseMismatch); 247 } 248 let event = 249 Event::from_json(signed.raw_json()).map_err(|_| Error::AuthResponseInvalid)?; 250 self.auth.client.submit(relay.clone(), event).await?; 251 self.auth.remove(relay, challenge, true) 252 }) 253 } 254 255 /// Rejects and consumes one exact pending challenge without relay access. 256 pub fn reject_authentication(&self, relay: &RelayUrl, challenge: &str) -> Result<(), Error> { 257 self.auth.remove(relay, challenge, false) 258 } 259 260 #[cfg(test)] 261 fn with_auth_client(mut self, client: Arc<dyn AuthClient>) -> Self { 262 self.auth = Arc::new(AuthFlow::new(client)); 263 self 264 } 265 } 266 267 fn validate_challenge( 268 challenge: &str, 269 required_at_unix_ms: u64, 270 expires_at_unix_ms: u64, 271 ) -> Result<(), Error> { 272 if challenge.is_empty() 273 || challenge.len() > MAX_CHALLENGE_BYTES 274 || challenge != challenge.trim() 275 || challenge.chars().any(char::is_control) 276 || required_at_unix_ms == 0 277 || expires_at_unix_ms <= required_at_unix_ms 278 || expires_at_unix_ms - required_at_unix_ms > MAX_CHALLENGE_LIFETIME_MS 279 { 280 return Err(Error::InvalidAuthChallenge); 281 } 282 Ok(()) 283 } 284 285 fn has_exact_tag(tags: &[Vec<String>], name: &str, value: &str) -> bool { 286 tags.iter().any(|tag| { 287 tag.len() == 2 && tag.first().is_some_and(|item| item == name) && tag[1] == value 288 }) 289 } 290 291 #[cfg(test)] 292 mod tests { 293 use super::*; 294 use crate::{Config, RelayUrlPolicy}; 295 use nostr_sdk::prelude::{EventBuilder, FinalizeEvent, Keys, Kind, Tag, Timestamp}; 296 use std::sync::atomic::{AtomicUsize, Ordering}; 297 298 #[derive(Debug)] 299 struct MockAuthClient(AtomicUsize); 300 301 impl AuthClient for MockAuthClient { 302 fn submit<'a>( 303 &'a self, 304 _relay: RelayUrl, 305 _event: Event, 306 ) -> BoxFuture<'a, Result<(), Error>> { 307 self.0.fetch_add(1, Ordering::SeqCst); 308 Box::pin(async { Ok(()) }) 309 } 310 } 311 312 fn transport() -> (NostrTransport, Arc<MockAuthClient>, RelayUrl) { 313 let relay = 314 RelayUrl::parse("wss://relay.example.com", RelayUrlPolicy::Public).expect("relay"); 315 let config = Config::from_profile( 316 crate::profile::test_profile( 317 crate::RelayProfileKind::Public, 318 RelayUrlPolicy::Public, 319 [relay.as_str()], 320 ) 321 .expect("profile"), 322 ); 323 let client = Arc::new(MockAuthClient(AtomicUsize::new(0))); 324 let transport = crate::test_host::transport(config).with_auth_client(client.clone()); 325 (transport, client, relay) 326 } 327 328 fn signed_response(relay: &RelayUrl, challenge: &str, created_at: u64) -> String { 329 EventBuilder::new(Kind::Authentication, "") 330 .tags([ 331 Tag::parse(["relay", relay.as_str()]).expect("relay tag"), 332 Tag::parse(["challenge", challenge]).expect("challenge tag"), 333 ]) 334 .custom_created_at(Timestamp::from_secs(created_at)) 335 .finalize(&Keys::generate()) 336 .expect("signed auth event") 337 .as_json() 338 } 339 340 #[test] 341 fn shutdown_disposes_pending_auth_without_discarding_an_already_obtained_success() { 342 struct DelayedAuth { 343 started: AtomicUsize, 344 completion: Mutex<Option<futures::channel::oneshot::Receiver<()>>>, 345 } 346 impl AuthClient for DelayedAuth { 347 fn submit<'a>( 348 &'a self, 349 _relay: RelayUrl, 350 _event: Event, 351 ) -> BoxFuture<'a, Result<(), Error>> { 352 self.started.fetch_add(1, Ordering::SeqCst); 353 let completion = self.completion.lock().unwrap().take().unwrap(); 354 Box::pin(async move { 355 completion.await.unwrap(); 356 Ok(()) 357 }) 358 } 359 } 360 let (transport, _, relay) = transport(); 361 let (complete, completion) = futures::channel::oneshot::channel(); 362 let client = Arc::new(DelayedAuth { 363 started: AtomicUsize::new(0), 364 completion: Mutex::new(Some(completion)), 365 }); 366 let transport = transport.with_auth_client(client.clone()); 367 transport 368 .begin_authentication(&relay, "late response", 1_000_000, 1_600_000) 369 .unwrap(); 370 let response = signed_response(&relay, "late response", 1200); 371 let mut pending = 372 transport.complete_authentication(&relay, "late response", Some(&response), 1_300_000); 373 assert!(matches!( 374 pending 375 .as_mut() 376 .poll(&mut std::task::Context::from_waker(std::task::Waker::noop())), 377 std::task::Poll::Pending 378 )); 379 assert_eq!(client.started.load(Ordering::SeqCst), 1); 380 futures::executor::block_on(transport.shutdown()); 381 assert!(transport.admission_is_closed()); 382 assert!(transport.auth.pending.lock().unwrap().is_none()); 383 complete.send(()).unwrap(); 384 assert_eq!(futures::executor::block_on(pending), Ok(())); 385 assert_eq!( 386 transport.reject_authentication(&relay, "late response"), 387 Err(Error::TransportClosed) 388 ); 389 assert_eq!(client.started.load(Ordering::SeqCst), 1); 390 } 391 392 #[test] 393 fn invalid_auth_responses_never_submit_or_consume_the_pending_challenge() { 394 let (transport, client, relay) = transport(); 395 transport 396 .begin_authentication(&relay, "retained-challenge", 1_000_000, 1_600_000) 397 .unwrap(); 398 for (kind, content, created_at) in [ 399 (Kind::TextNote, "", 1_200), 400 (Kind::Authentication, "unexpected content", 1_200), 401 (Kind::Authentication, "", 999), 402 (Kind::Authentication, "", 1_601), 403 ] { 404 let response = EventBuilder::new(kind, content) 405 .tags([ 406 Tag::parse(["relay", relay.as_str()]).unwrap(), 407 Tag::parse(["challenge", "retained-challenge"]).unwrap(), 408 ]) 409 .custom_created_at(Timestamp::from_secs(created_at)) 410 .finalize(&Keys::generate()) 411 .unwrap() 412 .as_json(); 413 assert_eq!( 414 futures::executor::block_on(transport.complete_authentication( 415 &relay, 416 "retained-challenge", 417 Some(&response), 418 1_300_000, 419 )), 420 Err(Error::AuthResponseMismatch) 421 ); 422 assert_eq!(client.0.load(Ordering::SeqCst), 0); 423 } 424 let valid = signed_response(&relay, "retained-challenge", 1_200); 425 let mut tampered: serde_json::Value = serde_json::from_str(&valid).unwrap(); 426 tampered["sig"] = serde_json::Value::String("0".repeat(128)); 427 assert_eq!( 428 futures::executor::block_on(transport.complete_authentication( 429 &relay, 430 "retained-challenge", 431 Some(&tampered.to_string()), 432 1_300_000, 433 )), 434 Err(Error::AuthResponseInvalid) 435 ); 436 assert_eq!(client.0.load(Ordering::SeqCst), 0); 437 futures::executor::block_on(transport.complete_authentication( 438 &relay, 439 "retained-challenge", 440 Some(&valid), 441 1_300_000, 442 )) 443 .unwrap(); 444 assert_eq!(client.0.load(Ordering::SeqCst), 1); 445 } 446 447 #[test] 448 fn challenge_response_is_exact_bounded_and_single_use() { 449 let (transport, client, relay) = transport(); 450 let input = transport 451 .begin_authentication(&relay, "challenge-a", 1_000_000, 1_600_000) 452 .expect("challenge"); 453 assert!(input.contains("\"kind\":22242")); 454 assert!(input.contains("challenge-a")); 455 let response = signed_response(&relay, "challenge-a", 1_200); 456 futures::executor::block_on(transport.complete_authentication( 457 &relay, 458 "challenge-a", 459 Some(response.as_str()), 460 1_300_000, 461 )) 462 .expect("complete auth"); 463 assert_eq!(client.0.load(Ordering::SeqCst), 1); 464 assert_eq!( 465 futures::executor::block_on(transport.complete_authentication( 466 &relay, 467 "challenge-a", 468 Some(response.as_str()), 469 1_300_000, 470 )), 471 Err(Error::AuthChallengeMissing) 472 ); 473 } 474 475 #[test] 476 fn wrong_relay_timeout_rejection_and_no_signer_fail_closed() { 477 let (transport, client, relay) = transport(); 478 transport 479 .begin_authentication(&relay, "challenge-a", 1_000_000, 1_600_000) 480 .expect("challenge"); 481 assert_eq!( 482 futures::executor::block_on(transport.complete_authentication( 483 &relay, 484 "challenge-a", 485 None, 486 1_100_000, 487 )), 488 Err(Error::AuthSignerUnavailable) 489 ); 490 let wrong = signed_response(&relay, "challenge-b", 1_200); 491 assert_eq!( 492 futures::executor::block_on(transport.complete_authentication( 493 &relay, 494 "challenge-a", 495 Some(wrong.as_str()), 496 1_300_000, 497 )), 498 Err(Error::AuthResponseMismatch) 499 ); 500 let wrong_relay = RelayUrl::parse("wss://other.example.com", RelayUrlPolicy::Public) 501 .expect("other relay"); 502 let wrong = signed_response(&wrong_relay, "challenge-a", 1_200); 503 assert_eq!( 504 futures::executor::block_on(transport.complete_authentication( 505 &relay, 506 "challenge-a", 507 Some(wrong.as_str()), 508 1_300_000, 509 )), 510 Err(Error::AuthResponseMismatch) 511 ); 512 let valid = signed_response(&relay, "challenge-a", 1_200); 513 assert_eq!( 514 futures::executor::block_on(transport.complete_authentication( 515 &relay, 516 "challenge-a", 517 Some(valid.as_str()), 518 1_700_000, 519 )), 520 Err(Error::AuthChallengeExpired) 521 ); 522 assert_eq!(client.0.load(Ordering::SeqCst), 0); 523 524 transport 525 .begin_authentication(&relay, "challenge-b", 2_000_000, 2_600_000) 526 .expect("second challenge"); 527 transport 528 .reject_authentication(&relay, "challenge-b") 529 .expect("reject"); 530 assert_eq!( 531 transport.reject_authentication(&relay, "challenge-b"), 532 Err(Error::AuthChallengeMissing) 533 ); 534 } 535 536 #[test] 537 fn challenge_debug_is_redacted_and_conflicts_are_rejected() { 538 let (transport, _, relay) = transport(); 539 transport 540 .begin_authentication(&relay, "secret-challenge", 1_000, 2_000) 541 .expect("challenge"); 542 assert!(!format!("{:?}", transport.auth).contains("secret-challenge")); 543 assert_eq!( 544 transport.begin_authentication(&relay, "different", 1_000, 2_000), 545 Err(Error::AuthChallengeConflict) 546 ); 547 assert_eq!( 548 transport.reject_authentication(&relay, "different"), 549 Err(Error::AuthResponseMismatch) 550 ); 551 transport 552 .begin_authentication(&relay, "secret-challenge", 1_000, 2_000) 553 .expect("idempotent challenge"); 554 } 555 556 #[test] 557 fn challenge_validation_rejects_each_invalid_boundary() { 558 for (challenge, required, expires) in [ 559 ("", 1, 2), 560 (&"a".repeat(MAX_CHALLENGE_BYTES + 1), 1, 2), 561 (" challenge", 1, 2), 562 ("challenge ", 1, 2), 563 ("chall\nenge", 1, 2), 564 ("challenge", 0, 2), 565 ("challenge", 2, 2), 566 ("challenge", 2, 1), 567 ("challenge", 1, MAX_CHALLENGE_LIFETIME_MS + 2), 568 ] { 569 assert_eq!( 570 validate_challenge(challenge, required, expires), 571 Err(Error::InvalidAuthChallenge) 572 ); 573 } 574 assert!(validate_challenge("challenge", 1, MAX_CHALLENGE_LIFETIME_MS + 1).is_ok()); 575 576 assert!(has_exact_tag( 577 &[vec!["challenge".into(), "value".into()]], 578 "challenge", 579 "value" 580 )); 581 assert!(!has_exact_tag(&[], "challenge", "value")); 582 assert!(!has_exact_tag( 583 &[vec!["challenge".into()]], 584 "challenge", 585 "value" 586 )); 587 assert!(!has_exact_tag( 588 &[vec!["other".into(), "value".into()]], 589 "challenge", 590 "value" 591 )); 592 assert!(!has_exact_tag( 593 &[vec!["challenge".into(), "other".into()]], 594 "challenge", 595 "value" 596 )); 597 } 598 599 #[test] 600 fn authentication_rejects_unconfigured_and_malformed_responses() { 601 let (transport, _, relay) = transport(); 602 let other = 603 RelayUrl::parse("wss://other.example.com", RelayUrlPolicy::Public).expect("other"); 604 assert_eq!( 605 transport.begin_authentication(&other, "challenge", 1, 2), 606 Err(Error::AuthResponseMismatch) 607 ); 608 transport 609 .begin_authentication(&relay, "challenge", 1_000, 2_000) 610 .expect("begin"); 611 assert_eq!( 612 futures::executor::block_on(transport.complete_authentication( 613 &relay, 614 "wrong", 615 Some("{}"), 616 1_500 617 )), 618 Err(Error::AuthResponseMismatch) 619 ); 620 assert_eq!( 621 futures::executor::block_on(transport.complete_authentication( 622 &relay, 623 "challenge", 624 Some("{}"), 625 1_500 626 )), 627 Err(Error::AuthResponseInvalid) 628 ); 629 } 630 }