1use alloc::string::String;
48use alloc::vec::Vec;
49
50use serde::{Deserialize, Serialize};
51
52use crate::types::{Duration, ProtocolVersion, Timestamp, WireProfile};
53
54use super::{
55 AccessToken, CommunicationProtocol, CommunicationToken, ConnectError, EndpointDescription,
56 NodeDescription, NodeId,
57};
58
59pub const COMMUNICATION_TOKEN_LIFETIME: Duration = Duration::from_secs(30);
63
64pub const PENDING_TOKEN_LIFETIME: Duration = Duration::from_secs(15);
71
72#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
78#[serde(rename_all = "camelCase")]
79pub struct SessionRequest {
80 pub client_node_id: NodeId,
82 pub server_node_id: NodeId,
84 pub supported_s2_message_versions: Vec<ProtocolVersion>,
86 pub supported_communication_protocols: Vec<CommunicationProtocol>,
88 #[serde(skip_serializing_if = "Option::is_none")]
90 pub client_node_description: Option<NodeDescription>,
91 #[serde(skip_serializing_if = "Option::is_none")]
93 pub client_endpoint_description: Option<EndpointDescription>,
94}
95
96#[derive(Debug, Clone, Serialize, Deserialize)]
98#[serde(rename_all = "camelCase")]
99pub struct SessionGrant {
100 pub selected_communication_protocol: CommunicationProtocol,
102 pub selected_s2_message_version: ProtocolVersion,
109 pub access_token: AccessToken,
111 #[serde(skip_serializing_if = "Option::is_none")]
113 pub server_node_description: Option<NodeDescription>,
114 #[serde(skip_serializing_if = "Option::is_none")]
116 pub server_endpoint_description: Option<EndpointDescription>,
117}
118
119impl SessionGrant {
120 #[must_use]
122 pub fn profile(&self) -> Option<WireProfile> {
123 self.selected_s2_message_version.wire_profile()
127 }
128}
129
130#[derive(Debug, Clone, Serialize, Deserialize)]
135#[serde(tag = "communicationProtocol")]
136#[non_exhaustive]
137pub enum CommunicationDetails {
138 WebSocket {
140 #[serde(rename = "websocketUrl")]
142 websocket_url: String,
143 #[serde(rename = "websocketToken")]
148 websocket_token: CommunicationToken,
149 },
150}
151
152#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
155#[non_exhaustive]
156pub enum SessionErrorMessage {
157 IncompatibleS2MessageVersions,
159 IncompatibleCommunicationProtocols,
161 NoLongerPaired,
163 ParsingError,
165 Other,
167}
168
169#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
171#[serde(rename_all = "camelCase")]
172pub struct SessionRefused {
173 pub error_message: SessionErrorMessage,
175 #[serde(skip_serializing_if = "Option::is_none")]
177 pub additional_info: Option<String>,
178}
179
180#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
182#[serde(rename_all = "camelCase")]
183pub struct UnpairRequest {
184 pub client_node_id: NodeId,
186 pub server_node_id: NodeId,
188}
189
190#[derive(Debug, Clone)]
192pub struct SessionCredentials {
193 pub websocket_url: String,
195 pub websocket_token: CommunicationToken,
197 pub profile: Option<WireProfile>,
199 pub issued: Timestamp,
201}
202
203impl SessionCredentials {
204 #[must_use]
206 pub fn expires(&self) -> Timestamp {
207 self.issued
208 .checked_add(COMMUNICATION_TOKEN_LIFETIME)
209 .unwrap_or(self.issued)
210 }
211
212 #[must_use]
218 pub fn is_expired(&self, now: Timestamp) -> bool {
219 now >= self.expires()
220 }
221}
222
223#[derive(Debug, Clone)]
229struct Held {
230 token: AccessToken,
231 granted: Option<Timestamp>,
235}
236
237#[derive(Debug, Clone, Default)]
250pub struct TokenStore {
251 tokens: Vec<Held>,
253}
254
255impl TokenStore {
256 pub const MAX: usize = 4;
261
262 #[must_use]
264 pub fn new(current: AccessToken) -> Self {
265 Self {
266 tokens: alloc::vec![Held {
267 token: current,
268 granted: None,
269 }],
270 }
271 }
272
273 #[must_use]
278 pub fn accepts(&self, presented: &AccessToken) -> bool {
279 self.find(presented).is_some()
280 }
281
282 fn find(&self, presented: &AccessToken) -> Option<&Held> {
283 self.tokens.iter().find(|h| h.token.verify(presented))
284 }
285
286 pub fn add(&mut self, token: AccessToken, now: Timestamp) {
293 if self.tokens.iter().any(|h| h.token.verify(&token)) {
294 return;
295 }
296 self.tokens.retain(|held| {
304 held.granted.is_none_or(|granted| {
305 now.saturating_duration_since(granted) <= PENDING_TOKEN_LIFETIME
306 })
307 });
308 self.tokens.insert(
309 0,
310 Held {
311 token,
312 granted: Some(now),
313 },
314 );
315 self.tokens.truncate(Self::MAX);
316 }
317
318 pub fn adopt(&mut self, token: AccessToken) {
320 if self.tokens.iter().any(|h| h.token.verify(&token)) {
321 return;
322 }
323 self.tokens.insert(
324 0,
325 Held {
326 token,
327 granted: None,
328 },
329 );
330 self.tokens.truncate(Self::MAX);
331 }
332
333 pub fn confirm(&mut self, token: &AccessToken, now: Timestamp) -> Result<(), ConnectError> {
345 let held = self.find(token).ok_or(ConnectError::NotPaired)?;
346 if let Some(granted) = held.granted
347 && now.saturating_duration_since(granted) > PENDING_TOKEN_LIFETIME
348 {
349 return Err(ConnectError::Expired {
350 what: "access token confirmation",
351 limit: PENDING_TOKEN_LIFETIME,
352 });
353 }
354 self.tokens.clear();
355 self.tokens.push(Held {
356 token: token.clone(),
357 granted: None,
358 });
359 Ok(())
360 }
361
362 #[must_use]
369 pub fn is_pending(&self, presented: &AccessToken) -> bool {
370 self.find(presented).is_some_and(|h| h.granted.is_some())
371 }
372
373 #[must_use]
375 pub fn current(&self) -> Option<&AccessToken> {
376 self.tokens.first().map(|h| &h.token)
377 }
378
379 pub fn candidates(&self) -> impl Iterator<Item = &AccessToken> {
383 self.tokens.iter().map(|h| &h.token)
384 }
385
386 #[must_use]
388 pub fn len(&self) -> usize {
389 self.tokens.len()
390 }
391
392 #[must_use]
394 pub fn is_empty(&self) -> bool {
395 self.tokens.is_empty()
396 }
397
398 pub fn clear(&mut self) {
400 self.tokens.clear();
401 }
402}
403
404#[derive(Debug, Clone, Copy, PartialEq, Eq)]
409enum Phase {
410 Start,
411 AwaitingGrant,
412 Granted,
413 Connected,
414 Failed,
415}
416
417impl Phase {
418 const fn name(self) -> &'static str {
419 match self {
420 Phase::Start => "the start of session initiation",
421 Phase::AwaitingGrant => "the session grant",
422 Phase::Granted => "confirmation of the new access token",
423 Phase::Connected => "a completed initiation",
424 Phase::Failed => "a failed initiation",
425 }
426 }
427}
428
429#[derive(Debug)]
443pub struct SessionInitClient {
444 client_node_id: NodeId,
445 server_node_id: NodeId,
446 tokens: TokenStore,
447 s2_message_versions: Vec<ProtocolVersion>,
448 protocols: Vec<CommunicationProtocol>,
449 phase: Phase,
450 attempted: Option<AccessToken>,
452 tried: usize,
454 granted: Option<SessionGrant>,
455}
456
457impl SessionInitClient {
458 #[must_use]
460 pub fn new(client_node_id: NodeId, server_node_id: NodeId, tokens: TokenStore) -> Self {
461 Self {
462 client_node_id,
463 server_node_id,
464 tokens,
465 s2_message_versions: alloc::vec![
469 WireProfile::V1_0_0.connect_version(),
470 WireProfile::V0_0_2Beta.connect_version(),
471 ],
472 protocols: alloc::vec![CommunicationProtocol::WebSocket],
473 phase: Phase::Start,
474 attempted: None,
475 tried: 0,
476 granted: None,
477 }
478 }
479
480 #[must_use]
482 pub fn with_s2_message_versions(mut self, versions: Vec<ProtocolVersion>) -> Self {
483 self.s2_message_versions = versions;
484 self
485 }
486
487 pub fn initiate(&mut self) -> Result<(AccessToken, SessionRequest), ConnectError> {
494 if self.phase == Phase::Connected {
495 self.phase = Phase::Start;
496 }
497 self.expect(Phase::Start)?;
498 let token = self
499 .tokens
500 .candidates()
501 .nth(self.tried)
502 .cloned()
503 .ok_or(ConnectError::NotPaired)?;
504 self.attempted = Some(token.clone());
505 self.phase = Phase::AwaitingGrant;
506 Ok((
507 token,
508 SessionRequest {
509 client_node_id: self.client_node_id,
510 server_node_id: self.server_node_id,
511 supported_s2_message_versions: self.s2_message_versions.clone(),
512 supported_communication_protocols: self.protocols.clone(),
513 client_node_description: None,
514 client_endpoint_description: None,
515 },
516 ))
517 }
518
519 pub fn unauthorized(&mut self) -> Result<(), ConnectError> {
525 self.tried += 1;
526 self.phase = Phase::Start;
527 if self.tried >= self.tokens.len() {
528 self.phase = Phase::Failed;
529 return Err(ConnectError::NotPaired);
530 }
531 Ok(())
532 }
533
534 pub fn accept(&mut self, grant: SessionGrant, now: Timestamp) -> Result<(), ConnectError> {
545 self.expect(Phase::AwaitingGrant)?;
546 if !self
547 .protocols
548 .contains(&grant.selected_communication_protocol)
549 {
550 self.phase = Phase::Failed;
551 return Err(ConnectError::NoOverlap("communication protocol"));
552 }
553 if !self
554 .s2_message_versions
555 .iter()
556 .any(|v| v.matches(&grant.selected_s2_message_version))
557 {
558 self.phase = Phase::Failed;
559 return Err(ConnectError::NoOverlap("S2 message version"));
560 }
561 self.tokens.add(grant.access_token.clone(), now);
562 self.granted = Some(grant);
563 self.phase = Phase::Granted;
564 Ok(())
565 }
566
567 pub fn confirm(&mut self) -> Result<AccessToken, ConnectError> {
571 self.expect(Phase::Granted)?;
572 let grant = self.granted.as_ref().ok_or(ConnectError::OutOfOrder {
573 got: "a confirmation",
574 expected: Phase::AwaitingGrant.name(),
575 })?;
576 Ok(grant.access_token.clone())
577 }
578
579 pub fn connected(
584 &mut self,
585 details: CommunicationDetails,
586 now: Timestamp,
587 ) -> Result<SessionCredentials, ConnectError> {
588 self.expect(Phase::Granted)?;
589 let grant = self.granted.take().ok_or(ConnectError::OutOfOrder {
590 got: "communication details",
591 expected: Phase::AwaitingGrant.name(),
592 })?;
593 self.tokens.confirm(&grant.access_token, now)?;
594 self.tried = 0;
595 self.phase = Phase::Connected;
596 let CommunicationDetails::WebSocket {
597 websocket_url,
598 websocket_token,
599 } = details;
600 Ok(SessionCredentials {
601 websocket_url,
602 websocket_token,
603 profile: grant.profile(),
604 issued: now,
605 })
606 }
607
608 pub fn restart(&mut self) {
613 self.phase = Phase::Start;
614 self.attempted = None;
615 }
616
617 pub fn unpaired(&mut self) -> UnpairRequest {
619 self.tokens.clear();
620 self.phase = Phase::Failed;
621 UnpairRequest {
622 client_node_id: self.client_node_id,
623 server_node_id: self.server_node_id,
624 }
625 }
626
627 #[must_use]
629 pub fn tokens(&self) -> &TokenStore {
630 &self.tokens
631 }
632
633 fn expect(&mut self, phase: Phase) -> Result<(), ConnectError> {
634 if self.phase == phase {
635 return Ok(());
636 }
637 let got = self.phase.name();
638 self.phase = Phase::Failed;
639 Err(ConnectError::OutOfOrder {
640 got,
641 expected: phase.name(),
642 })
643 }
644}
645
646#[derive(Debug)]
655pub struct SessionInitServer {
656 node_id: NodeId,
657 peer_node_id: NodeId,
658 tokens: TokenStore,
659 websocket_url: String,
660 s2_message_versions: Vec<ProtocolVersion>,
661 protocols: Vec<CommunicationProtocol>,
662 connection: Option<IssuedConnection>,
671}
672
673#[derive(Debug, Clone)]
675struct IssuedConnection {
676 token: CommunicationToken,
677 issued: Timestamp,
678}
679
680impl SessionInitServer {
681 #[must_use]
683 pub fn new(
684 node_id: NodeId,
685 peer_node_id: NodeId,
686 tokens: TokenStore,
687 websocket_url: impl Into<String>,
688 ) -> Self {
689 Self {
690 node_id,
691 peer_node_id,
692 tokens,
693 websocket_url: websocket_url.into(),
694 s2_message_versions: alloc::vec![
698 WireProfile::V1_0_0.connect_version(),
699 WireProfile::V0_0_2Beta.connect_version(),
700 ],
701 protocols: alloc::vec![CommunicationProtocol::WebSocket],
702 connection: None,
703 }
704 }
705
706 #[must_use]
708 pub fn with_s2_message_versions(mut self, versions: Vec<ProtocolVersion>) -> Self {
709 self.s2_message_versions = versions;
710 self
711 }
712
713 #[must_use]
717 pub fn authenticates(&self, bearer: &AccessToken) -> bool {
718 self.tokens.accepts(bearer)
719 }
720
721 pub fn initiate_session(
732 &mut self,
733 bearer: &AccessToken,
734 request: &SessionRequest,
735 access_entropy: &[u8],
736 now: Timestamp,
737 ) -> Result<SessionGrant, ConnectError> {
738 if !self.tokens.accepts(bearer) {
739 return Err(ConnectError::NotPaired);
740 }
741 if request.server_node_id != self.node_id || request.client_node_id != self.peer_node_id {
742 return Err(ConnectError::SessionRefused(SessionRefused {
743 error_message: SessionErrorMessage::NoLongerPaired,
744 additional_info: None,
745 }));
746 }
747 let protocol = request
748 .supported_communication_protocols
749 .iter()
750 .find(|p| self.protocols.contains(p))
751 .copied()
752 .ok_or(ConnectError::SessionRefused(SessionRefused {
753 error_message: SessionErrorMessage::IncompatibleCommunicationProtocols,
754 additional_info: None,
755 }))?;
756 let version = request
758 .supported_s2_message_versions
759 .iter()
760 .find(|v| self.s2_message_versions.iter().any(|ours| ours.matches(v)))
761 .cloned()
762 .ok_or(ConnectError::SessionRefused(SessionRefused {
763 error_message: SessionErrorMessage::IncompatibleS2MessageVersions,
764 additional_info: None,
765 }))?;
766
767 let replacement = AccessToken::from_entropy(access_entropy)?;
768 self.tokens.add(replacement.clone(), now);
772 Ok(SessionGrant {
773 selected_communication_protocol: protocol,
774 selected_s2_message_version: version,
775 access_token: replacement,
776 server_node_description: None,
777 server_endpoint_description: None,
778 })
779 }
780
781 pub fn confirm_access_token(
786 &mut self,
787 bearer: &AccessToken,
788 communication_entropy: &[u8],
789 now: Timestamp,
790 ) -> Result<CommunicationDetails, ConnectError> {
791 if !self.tokens.is_pending(bearer) {
796 return Err(ConnectError::NotPaired);
797 }
798 self.tokens.confirm(bearer, now)?;
799 let token = CommunicationToken::from_entropy(communication_entropy)?;
800 self.connection = Some(IssuedConnection {
805 token: token.clone(),
806 issued: now,
807 });
808 Ok(CommunicationDetails::WebSocket {
809 websocket_url: self.websocket_url.clone(),
810 websocket_token: token,
811 })
812 }
813
814 pub fn unpair(
816 &mut self,
817 bearer: &AccessToken,
818 request: &UnpairRequest,
819 ) -> Result<(), ConnectError> {
820 if !self.tokens.accepts(bearer)
821 || request.server_node_id != self.node_id
822 || request.client_node_id != self.peer_node_id
823 {
824 return Err(ConnectError::NotPaired);
825 }
826 self.tokens.clear();
827 self.connection = None;
828 Ok(())
829 }
830
831 pub fn accepts_connection(&mut self, presented: &str, now: Timestamp) -> bool {
839 let Some(connection) = &self.connection else {
840 return false;
841 };
842 if now.saturating_duration_since(connection.issued) >= COMMUNICATION_TOKEN_LIFETIME {
843 self.connection = None;
844 return false;
845 }
846 if !connection.token.verify_str(presented) {
847 return false;
848 }
849 self.connection = None;
850 true
851 }
852
853 #[must_use]
855 pub fn tokens(&self) -> &TokenStore {
856 &self.tokens
857 }
858}
859
860#[cfg(test)]
861mod tests {
862 use super::*;
863 use alloc::string::ToString;
864
865 fn t(secs: i64) -> Timestamp {
866 Timestamp::from_unix(1_700_000_000 + secs, 0)
867 }
868
869 #[test]
870 fn a_grant_nobody_confirmed_never_evicts_the_token_that_works() {
871 let live = AccessToken::from_entropy(&[9u8; 32]).expect("32 bytes");
877 let mut store = TokenStore::new(live.clone());
878 for i in 0..6u8 {
879 let granted = AccessToken::from_entropy(&[i; 32]).expect("32 bytes");
880 store.add(granted, t(i64::from(i) * 60));
882 }
883 assert!(
884 store.accepts(&live),
885 "the token the client is still holding must keep working"
886 );
887 assert_eq!(store.len(), 2, "one live token and the newest grant");
888
889 let live = AccessToken::from_entropy(&[9u8; 32]).expect("32 bytes");
892 let mut store = TokenStore::new(live.clone());
893 for i in 0..3u8 {
894 let granted = AccessToken::from_entropy(&[i; 32]).expect("32 bytes");
895 store.add(granted, t(i64::from(i)));
896 }
897 assert_eq!(store.len(), 4);
898 assert!(store.accepts(&live));
899 }
900
901 fn ids() -> (NodeId, NodeId) {
902 (
903 NodeId::parse("rm-1").expect("a legal id"),
904 NodeId::parse("cem-1").expect("a legal id"),
905 )
906 }
907
908 fn pair() -> (SessionInitClient, SessionInitServer, AccessToken) {
909 let (rm, cem) = ids();
910 let initial = AccessToken::from_entropy(&[1u8; 32]).expect("32 bytes");
911 let client = SessionInitClient::new(rm, cem, TokenStore::new(initial.clone()));
912 let server = SessionInitServer::new(
913 cem,
914 rm,
915 TokenStore::new(initial.clone()),
916 "wss://cem.example.com/s2",
917 );
918 (client, server, initial)
919 }
920
921 fn run_at(
923 client: &mut SessionInitClient,
924 server: &mut SessionInitServer,
925 new_access: u8,
926 comm: u8,
927 at: Timestamp,
928 ) -> SessionCredentials {
929 let (bearer, request) = client.initiate().unwrap();
930 let grant = server
931 .initiate_session(&bearer, &request, &[new_access; 32], at)
932 .unwrap();
933 client.accept(grant, at).unwrap();
934 let confirm = client.confirm().unwrap();
935 let details = server
936 .confirm_access_token(&confirm, &[comm; 32], at)
937 .unwrap();
938 client.connected(details, at).unwrap()
939 }
940
941 fn run(
943 client: &mut SessionInitClient,
944 server: &mut SessionInitServer,
945 new_access: u8,
946 comm: u8,
947 ) -> SessionCredentials {
948 run_at(client, server, new_access, comm, t(0))
949 }
950
951 #[test]
952 fn a_session_is_initiated_and_the_token_rotates() {
953 let (mut client, mut server, initial) = pair();
954 let creds = run(&mut client, &mut server, 2, 3);
955
956 assert_eq!(creds.websocket_url, "wss://cem.example.com/s2");
957 assert_eq!(creds.profile, Some(WireProfile::V1_0_0));
958 assert!(!creds.is_expired(t(29)));
959
960 assert!(!server.tokens().accepts(&initial));
962 assert_eq!(client.tokens().len(), 1);
963 assert!(server.tokens().accepts(client.tokens().current().unwrap()));
964 }
965
966 #[test]
967 fn the_confirmation_is_authenticated_with_the_new_token() {
968 let (mut client, mut server, initial) = pair();
970 let (bearer, request) = client.initiate().unwrap();
971 let grant = server
972 .initiate_session(&bearer, &request, &[2u8; 32], t(0))
973 .unwrap();
974 let replacement = grant.access_token.clone();
975 client.accept(grant, t(0)).unwrap();
976
977 assert!(matches!(
979 server.confirm_access_token(&initial, &[3u8; 32], t(0)),
980 Err(ConnectError::NotPaired)
981 ));
982 assert!(
984 server
985 .confirm_access_token(&replacement, &[3u8; 32], t(0))
986 .is_ok()
987 );
988 }
989
990 #[test]
991 fn a_lost_grant_does_not_strand_the_pairing() {
992 let (mut client, mut server, initial) = pair();
995 let (bearer, request) = client.initiate().unwrap();
996 let _lost = server
997 .initiate_session(&bearer, &request, &[2u8; 32], t(0))
998 .unwrap();
999
1000 client.restart();
1002 assert!(server.tokens().accepts(&initial));
1003 let creds = run(&mut client, &mut server, 4, 5);
1004 assert!(!creds.websocket_url.is_empty());
1005 assert!(server.tokens().accepts(client.tokens().current().unwrap()));
1006 }
1007
1008 #[test]
1009 fn a_lost_confirmation_does_not_strand_the_pairing_either() {
1010 let (mut client, mut server, initial) = pair();
1012 let (bearer, request) = client.initiate().unwrap();
1013 let grant = server
1014 .initiate_session(&bearer, &request, &[2u8; 32], t(0))
1015 .unwrap();
1016 client.accept(grant, t(0)).unwrap();
1017
1018 assert!(server.tokens().accepts(&initial));
1020 assert!(server.tokens().accepts(client.tokens().current().unwrap()));
1021 assert_eq!(client.tokens().len(), 2);
1022
1023 client.restart();
1024 let creds = run(&mut client, &mut server, 6, 7);
1025 assert!(!creds.websocket_url.is_empty());
1026 assert_eq!(
1027 client.tokens().len(),
1028 1,
1029 "and the list collapses on success"
1030 );
1031 }
1032
1033 #[test]
1034 fn a_client_works_down_its_list_after_a_401() {
1035 let (mut client, mut server, _) = pair();
1037 for entropy in [2u8, 3u8] {
1038 let (bearer, request) = client.initiate().unwrap();
1039 let grant = server
1040 .initiate_session(&bearer, &request, &[entropy; 32], t(0))
1041 .unwrap();
1042 client.accept(grant, t(0)).unwrap();
1043 client.restart();
1044 }
1045 assert_eq!(client.tokens().len(), 3);
1046
1047 let (rm, cem) = ids();
1050 let mut amnesiac = SessionInitServer::new(cem, rm, TokenStore::default(), "wss://x/");
1051 for _ in 0..3 {
1052 let (bearer, request) = client.initiate().unwrap();
1053 assert!(matches!(
1054 amnesiac.initiate_session(&bearer, &request, &[9u8; 32], t(0)),
1055 Err(ConnectError::NotPaired)
1056 ));
1057 if let Err(e) = client.unauthorized() {
1058 assert_eq!(e, ConnectError::NotPaired);
1059 return;
1060 }
1061 }
1062 panic!("the client should have given up after exhausting its tokens");
1063 }
1064
1065 #[test]
1066 fn a_token_the_server_never_issued_is_refused() {
1067 let (mut client, mut server, _) = pair();
1068 let (_, request) = client.initiate().unwrap();
1069 let forged = AccessToken::from_entropy(&[0xFFu8; 32]).unwrap();
1070 assert!(matches!(
1071 server.initiate_session(&forged, &request, &[2u8; 32], t(0)),
1072 Err(ConnectError::NotPaired)
1073 ));
1074 }
1075
1076 #[test]
1077 fn a_request_for_someone_elses_pairing_is_refused() {
1078 let (mut client, mut server, _) = pair();
1079 let (bearer, mut request) = client.initiate().unwrap();
1080 request.server_node_id = NodeId::parse("cem-2").unwrap();
1081 assert!(matches!(
1082 server.initiate_session(&bearer, &request, &[2u8; 32], t(0)),
1083 Err(ConnectError::SessionRefused(SessionRefused {
1084 error_message: SessionErrorMessage::NoLongerPaired,
1085 ..
1086 }))
1087 ));
1088 }
1089
1090 #[test]
1091 fn a_peer_that_spells_the_version_the_other_way_still_connects() {
1092 for spelling in ["v1.0.0", "1.0.0"] {
1097 let (client, mut server, _) = pair();
1098 let mut client =
1099 client.with_s2_message_versions(alloc::vec![ProtocolVersion::new(spelling)]);
1100 let creds = run(&mut client, &mut server, 2, 3);
1101 assert_eq!(
1102 creds.profile,
1103 Some(WireProfile::V1_0_0),
1104 "a server offering the other spelling must still resolve {spelling}"
1105 );
1106 }
1107
1108 let (mut client, server, _) = pair();
1111 let mut server =
1112 server.with_s2_message_versions(alloc::vec![ProtocolVersion::new("1.0.0")]);
1113 let creds = run(&mut client, &mut server, 2, 3);
1114 assert_eq!(creds.profile, Some(WireProfile::V1_0_0));
1115 }
1116
1117 #[test]
1118 fn a_version_neither_side_speaks_is_refused_with_the_named_reason() {
1119 let (rm, cem) = ids();
1120 let initial = AccessToken::from_entropy(&[1u8; 32]).unwrap();
1121 let mut client = SessionInitClient::new(rm, cem, TokenStore::new(initial.clone()))
1122 .with_s2_message_versions(alloc::vec![crate::types::ProtocolVersion::new("9.9.9")]);
1123 let mut server = SessionInitServer::new(cem, rm, TokenStore::new(initial), "wss://x/");
1124 let (bearer, request) = client.initiate().unwrap();
1125 assert!(matches!(
1126 server.initiate_session(&bearer, &request, &[2u8; 32], t(0)),
1127 Err(ConnectError::SessionRefused(SessionRefused {
1128 error_message: SessionErrorMessage::IncompatibleS2MessageVersions,
1129 ..
1130 }))
1131 ));
1132 }
1133
1134 #[test]
1135 fn a_communication_token_is_good_for_thirty_seconds_and_not_a_moment_more() {
1136 let (mut client, mut server, _) = pair();
1137 let (bearer, request) = client.initiate().unwrap();
1138 let grant = server
1139 .initiate_session(&bearer, &request, &[2u8; 32], t(0))
1140 .unwrap();
1141 client.accept(grant, t(0)).unwrap();
1142 let confirm = client.confirm().unwrap();
1143 let details = server
1144 .confirm_access_token(&confirm, &[3u8; 32], t(0))
1145 .unwrap();
1146 let CommunicationDetails::WebSocket {
1147 ref websocket_token,
1148 ..
1149 } = details;
1150 let presented = websocket_token.as_str().to_string();
1151 let creds = client.connected(details, t(0)).unwrap();
1152
1153 assert!(creds.is_expired(t(30)));
1154 assert_eq!(creds.expires(), t(30));
1155
1156 assert!(!server.accepts_connection("something else", t(1)));
1159 assert!(server.accepts_connection(&presented, t(29)));
1161 assert!(!server.accepts_connection(&presented, t(29)));
1163 }
1164
1165 #[test]
1166 fn a_communication_token_presented_too_late_is_refused() {
1167 let (mut client, mut server, _) = pair();
1168 let creds = run(&mut client, &mut server, 2, 3);
1169 let presented = creds.websocket_token.as_str().to_string();
1170 assert!(!server.accepts_connection(&presented, t(30)));
1171 assert!(!server.accepts_connection(&presented, t(1)));
1173 }
1174
1175 #[test]
1176 fn a_server_restarted_between_the_two_requests_still_honours_the_grant() {
1177 let (mut client, mut server, initial) = pair();
1182 let (bearer, request) = client.initiate().unwrap();
1183 let grant = server
1184 .initiate_session(&bearer, &request, &[2u8; 32], t(0))
1185 .unwrap();
1186 client.accept(grant, t(0)).unwrap();
1187 let confirm = client.confirm().unwrap();
1188
1189 let persisted = server.tokens().clone();
1192 let (rm, cem) = ids();
1193 let mut server = SessionInitServer::new(cem, rm, persisted, "wss://cem.example.com/s2");
1194
1195 let details = server
1196 .confirm_access_token(&confirm, &[3u8; 32], t(1))
1197 .expect("a restart must not lose the grant");
1198 let creds = client.connected(details, t(1)).unwrap();
1199 assert!(
1200 !server.tokens().accepts(&initial),
1201 "the old token is retired"
1202 );
1203 assert!(server.tokens().accepts(client.tokens().current().unwrap()));
1204 assert!(!creds.is_expired(t(2)));
1205 }
1206
1207 #[test]
1208 fn only_a_pending_grant_confirms_anything() {
1209 let (mut client, mut server, initial) = pair();
1213 let (bearer, request) = client.initiate().unwrap();
1214 let grant = server
1215 .initiate_session(&bearer, &request, &[2u8; 32], t(0))
1216 .unwrap();
1217 client.accept(grant, t(0)).unwrap();
1218
1219 assert!(
1220 server.tokens().accepts(&initial),
1221 "it is still a valid bearer"
1222 );
1223 assert!(
1224 matches!(
1225 server.confirm_access_token(&initial, &[3u8; 32], t(0)),
1226 Err(ConnectError::NotPaired)
1227 ),
1228 "but it is not the grant"
1229 );
1230 let confirm = client.confirm().unwrap();
1232 assert!(
1233 server
1234 .confirm_access_token(&confirm, &[3u8; 32], t(0))
1235 .is_ok()
1236 );
1237 }
1238
1239 #[test]
1240 fn a_grant_confirmed_too_late_leaves_the_old_token_in_force() {
1241 let (mut client, mut server, initial) = pair();
1246 let (bearer, request) = client.initiate().unwrap();
1247 let grant = server
1248 .initiate_session(&bearer, &request, &[2u8; 32], t(0))
1249 .unwrap();
1250 client.accept(grant, t(0)).unwrap();
1251 let confirm = client.confirm().unwrap();
1252
1253 let too_late = server.confirm_access_token(&confirm, &[3u8; 32], t(16));
1254 assert!(
1255 matches!(
1256 too_late,
1257 Err(ConnectError::Expired {
1258 what: "access token confirmation",
1259 ..
1260 })
1261 ),
1262 "{too_late:?}"
1263 );
1264 assert!(
1265 server.tokens().accepts(&initial),
1266 "the old token still works"
1267 );
1268
1269 let (mut client, mut server, initial) = pair();
1271 let (bearer, request) = client.initiate().unwrap();
1272 let grant = server
1273 .initiate_session(&bearer, &request, &[2u8; 32], t(0))
1274 .unwrap();
1275 client.accept(grant, t(0)).unwrap();
1276 let confirm = client.confirm().unwrap();
1277 let details = server
1278 .confirm_access_token(&confirm, &[3u8; 32], t(14))
1279 .expect("fourteen seconds is inside fifteen");
1280 let creds = client.connected(details, t(14)).unwrap();
1281 assert!(!server.tokens().accepts(&initial));
1282 assert_eq!(creds.profile, Some(WireProfile::V1_0_0));
1283 }
1284
1285 #[test]
1286 fn the_phases_cannot_be_taken_out_of_order() {
1287 let (mut client, _, _) = pair();
1288 assert!(matches!(
1289 client.confirm(),
1290 Err(ConnectError::OutOfOrder { .. })
1291 ));
1292 assert!(client.initiate().is_err());
1293 client.restart();
1294 assert!(client.initiate().is_ok());
1295 }
1296
1297 #[test]
1298 fn a_completed_session_can_be_followed_by_another() {
1299 let (mut client, mut server, _) = pair();
1302 run(&mut client, &mut server, 2, 3);
1303 run(&mut client, &mut server, 4, 5);
1304 run(&mut client, &mut server, 6, 7);
1305 assert_eq!(client.tokens().len(), 1);
1307 assert!(server.tokens().accepts(client.tokens().current().unwrap()));
1308 }
1309
1310 #[test]
1311 fn unpairing_forgets_the_pairing_on_both_sides() {
1312 let (mut client, mut server, _) = pair();
1313 run(&mut client, &mut server, 2, 3);
1314 let token = client.tokens().current().unwrap().clone();
1315 let request = client.unpaired();
1316 server.unpair(&token, &request).unwrap();
1317 assert!(server.tokens().is_empty());
1318 assert!(client.tokens().is_empty());
1319 assert!(!server.authenticates(&token));
1321 }
1322
1323 #[test]
1324 fn the_bodies_are_the_shape_the_openapi_defines() {
1325 let (mut client, mut server, _) = pair();
1326 let (bearer, request) = client.initiate().unwrap();
1327 let json = serde_json::to_value(&request).unwrap();
1328 for key in [
1329 "clientNodeId",
1330 "serverNodeId",
1331 "supportedS2MessageVersions",
1332 "supportedCommunicationProtocols",
1333 ] {
1334 assert!(json.get(key).is_some(), "missing required property {key}");
1335 }
1336 assert!(json.get("clientNodeDescription").is_none());
1337 assert_eq!(json["supportedCommunicationProtocols"][0], "WebSocket");
1338
1339 let grant = server
1340 .initiate_session(&bearer, &request, &[2u8; 32], t(0))
1341 .unwrap();
1342 let json = serde_json::to_value(&grant).unwrap();
1343 for key in [
1344 "selectedCommunicationProtocol",
1345 "selectedS2MessageVersion",
1346 "accessToken",
1347 ] {
1348 assert!(json.get(key).is_some(), "missing required property {key}");
1349 }
1350
1351 client.accept(grant, t(0)).unwrap();
1353 let confirm = client.confirm().unwrap();
1354 let details = server
1355 .confirm_access_token(&confirm, &[3u8; 32], t(0))
1356 .unwrap();
1357 let json = serde_json::to_value(&details).unwrap();
1358 assert_eq!(json["communicationProtocol"], "WebSocket");
1359 assert!(json.get("websocketUrl").is_some());
1360 assert!(json.get("websocketToken").is_some());
1361 }
1362}