lib

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

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 }