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.insert(
297 0,
298 Held {
299 token,
300 granted: Some(now),
301 },
302 );
303 self.tokens.truncate(Self::MAX);
304 }
305
306 pub fn adopt(&mut self, token: AccessToken) {
308 if self.tokens.iter().any(|h| h.token.verify(&token)) {
309 return;
310 }
311 self.tokens.insert(
312 0,
313 Held {
314 token,
315 granted: None,
316 },
317 );
318 self.tokens.truncate(Self::MAX);
319 }
320
321 pub fn confirm(&mut self, token: &AccessToken, now: Timestamp) -> Result<(), ConnectError> {
333 let held = self.find(token).ok_or(ConnectError::NotPaired)?;
334 if let Some(granted) = held.granted
335 && now.saturating_duration_since(granted) > PENDING_TOKEN_LIFETIME
336 {
337 return Err(ConnectError::Expired {
338 what: "access token confirmation",
339 limit: PENDING_TOKEN_LIFETIME,
340 });
341 }
342 self.tokens.clear();
343 self.tokens.push(Held {
344 token: token.clone(),
345 granted: None,
346 });
347 Ok(())
348 }
349
350 #[must_use]
357 pub fn is_pending(&self, presented: &AccessToken) -> bool {
358 self.find(presented).is_some_and(|h| h.granted.is_some())
359 }
360
361 #[must_use]
363 pub fn current(&self) -> Option<&AccessToken> {
364 self.tokens.first().map(|h| &h.token)
365 }
366
367 pub fn candidates(&self) -> impl Iterator<Item = &AccessToken> {
371 self.tokens.iter().map(|h| &h.token)
372 }
373
374 #[must_use]
376 pub fn len(&self) -> usize {
377 self.tokens.len()
378 }
379
380 #[must_use]
382 pub fn is_empty(&self) -> bool {
383 self.tokens.is_empty()
384 }
385
386 pub fn clear(&mut self) {
388 self.tokens.clear();
389 }
390}
391
392#[derive(Debug, Clone, Copy, PartialEq, Eq)]
397enum Phase {
398 Start,
399 AwaitingGrant,
400 Granted,
401 Connected,
402 Failed,
403}
404
405impl Phase {
406 const fn name(self) -> &'static str {
407 match self {
408 Phase::Start => "the start of session initiation",
409 Phase::AwaitingGrant => "the session grant",
410 Phase::Granted => "confirmation of the new access token",
411 Phase::Connected => "a completed initiation",
412 Phase::Failed => "a failed initiation",
413 }
414 }
415}
416
417#[derive(Debug)]
431pub struct SessionInitClient {
432 client_node_id: NodeId,
433 server_node_id: NodeId,
434 tokens: TokenStore,
435 s2_message_versions: Vec<ProtocolVersion>,
436 protocols: Vec<CommunicationProtocol>,
437 phase: Phase,
438 attempted: Option<AccessToken>,
440 tried: usize,
442 granted: Option<SessionGrant>,
443}
444
445impl SessionInitClient {
446 #[must_use]
448 pub fn new(client_node_id: NodeId, server_node_id: NodeId, tokens: TokenStore) -> Self {
449 Self {
450 client_node_id,
451 server_node_id,
452 tokens,
453 s2_message_versions: alloc::vec![
457 WireProfile::V1_0_0.connect_version(),
458 WireProfile::V0_0_2Beta.connect_version(),
459 ],
460 protocols: alloc::vec![CommunicationProtocol::WebSocket],
461 phase: Phase::Start,
462 attempted: None,
463 tried: 0,
464 granted: None,
465 }
466 }
467
468 #[must_use]
470 pub fn with_s2_message_versions(mut self, versions: Vec<ProtocolVersion>) -> Self {
471 self.s2_message_versions = versions;
472 self
473 }
474
475 pub fn initiate(&mut self) -> Result<(AccessToken, SessionRequest), ConnectError> {
482 if self.phase == Phase::Connected {
483 self.phase = Phase::Start;
484 }
485 self.expect(Phase::Start)?;
486 let token = self
487 .tokens
488 .candidates()
489 .nth(self.tried)
490 .cloned()
491 .ok_or(ConnectError::NotPaired)?;
492 self.attempted = Some(token.clone());
493 self.phase = Phase::AwaitingGrant;
494 Ok((
495 token,
496 SessionRequest {
497 client_node_id: self.client_node_id,
498 server_node_id: self.server_node_id,
499 supported_s2_message_versions: self.s2_message_versions.clone(),
500 supported_communication_protocols: self.protocols.clone(),
501 client_node_description: None,
502 client_endpoint_description: None,
503 },
504 ))
505 }
506
507 pub fn unauthorized(&mut self) -> Result<(), ConnectError> {
513 self.tried += 1;
514 self.phase = Phase::Start;
515 if self.tried >= self.tokens.len() {
516 self.phase = Phase::Failed;
517 return Err(ConnectError::NotPaired);
518 }
519 Ok(())
520 }
521
522 pub fn accept(&mut self, grant: SessionGrant, now: Timestamp) -> Result<(), ConnectError> {
533 self.expect(Phase::AwaitingGrant)?;
534 if !self
535 .protocols
536 .contains(&grant.selected_communication_protocol)
537 {
538 self.phase = Phase::Failed;
539 return Err(ConnectError::NoOverlap("communication protocol"));
540 }
541 if !self
542 .s2_message_versions
543 .iter()
544 .any(|v| v.matches(&grant.selected_s2_message_version))
545 {
546 self.phase = Phase::Failed;
547 return Err(ConnectError::NoOverlap("S2 message version"));
548 }
549 self.tokens.add(grant.access_token.clone(), now);
550 self.granted = Some(grant);
551 self.phase = Phase::Granted;
552 Ok(())
553 }
554
555 pub fn confirm(&mut self) -> Result<AccessToken, ConnectError> {
559 self.expect(Phase::Granted)?;
560 let grant = self.granted.as_ref().ok_or(ConnectError::OutOfOrder {
561 got: "a confirmation",
562 expected: Phase::AwaitingGrant.name(),
563 })?;
564 Ok(grant.access_token.clone())
565 }
566
567 pub fn connected(
572 &mut self,
573 details: CommunicationDetails,
574 now: Timestamp,
575 ) -> Result<SessionCredentials, ConnectError> {
576 self.expect(Phase::Granted)?;
577 let grant = self.granted.take().ok_or(ConnectError::OutOfOrder {
578 got: "communication details",
579 expected: Phase::AwaitingGrant.name(),
580 })?;
581 self.tokens.confirm(&grant.access_token, now)?;
582 self.tried = 0;
583 self.phase = Phase::Connected;
584 let CommunicationDetails::WebSocket {
585 websocket_url,
586 websocket_token,
587 } = details;
588 Ok(SessionCredentials {
589 websocket_url,
590 websocket_token,
591 profile: grant.profile(),
592 issued: now,
593 })
594 }
595
596 pub fn restart(&mut self) {
601 self.phase = Phase::Start;
602 self.attempted = None;
603 }
604
605 pub fn unpaired(&mut self) -> UnpairRequest {
607 self.tokens.clear();
608 self.phase = Phase::Failed;
609 UnpairRequest {
610 client_node_id: self.client_node_id,
611 server_node_id: self.server_node_id,
612 }
613 }
614
615 #[must_use]
617 pub fn tokens(&self) -> &TokenStore {
618 &self.tokens
619 }
620
621 fn expect(&mut self, phase: Phase) -> Result<(), ConnectError> {
622 if self.phase == phase {
623 return Ok(());
624 }
625 let got = self.phase.name();
626 self.phase = Phase::Failed;
627 Err(ConnectError::OutOfOrder {
628 got,
629 expected: phase.name(),
630 })
631 }
632}
633
634#[derive(Debug)]
643pub struct SessionInitServer {
644 node_id: NodeId,
645 peer_node_id: NodeId,
646 tokens: TokenStore,
647 websocket_url: String,
648 s2_message_versions: Vec<ProtocolVersion>,
649 protocols: Vec<CommunicationProtocol>,
650 connection: Option<IssuedConnection>,
659}
660
661#[derive(Debug, Clone)]
663struct IssuedConnection {
664 token: CommunicationToken,
665 issued: Timestamp,
666}
667
668impl SessionInitServer {
669 #[must_use]
671 pub fn new(
672 node_id: NodeId,
673 peer_node_id: NodeId,
674 tokens: TokenStore,
675 websocket_url: impl Into<String>,
676 ) -> Self {
677 Self {
678 node_id,
679 peer_node_id,
680 tokens,
681 websocket_url: websocket_url.into(),
682 s2_message_versions: alloc::vec![
686 WireProfile::V1_0_0.connect_version(),
687 WireProfile::V0_0_2Beta.connect_version(),
688 ],
689 protocols: alloc::vec![CommunicationProtocol::WebSocket],
690 connection: None,
691 }
692 }
693
694 #[must_use]
696 pub fn with_s2_message_versions(mut self, versions: Vec<ProtocolVersion>) -> Self {
697 self.s2_message_versions = versions;
698 self
699 }
700
701 #[must_use]
705 pub fn authenticates(&self, bearer: &AccessToken) -> bool {
706 self.tokens.accepts(bearer)
707 }
708
709 pub fn initiate_session(
720 &mut self,
721 bearer: &AccessToken,
722 request: &SessionRequest,
723 access_entropy: &[u8],
724 now: Timestamp,
725 ) -> Result<SessionGrant, ConnectError> {
726 if !self.tokens.accepts(bearer) {
727 return Err(ConnectError::NotPaired);
728 }
729 if request.server_node_id != self.node_id || request.client_node_id != self.peer_node_id {
730 return Err(ConnectError::SessionRefused(SessionRefused {
731 error_message: SessionErrorMessage::NoLongerPaired,
732 additional_info: None,
733 }));
734 }
735 let protocol = request
736 .supported_communication_protocols
737 .iter()
738 .find(|p| self.protocols.contains(p))
739 .copied()
740 .ok_or(ConnectError::SessionRefused(SessionRefused {
741 error_message: SessionErrorMessage::IncompatibleCommunicationProtocols,
742 additional_info: None,
743 }))?;
744 let version = request
746 .supported_s2_message_versions
747 .iter()
748 .find(|v| self.s2_message_versions.iter().any(|ours| ours.matches(v)))
749 .cloned()
750 .ok_or(ConnectError::SessionRefused(SessionRefused {
751 error_message: SessionErrorMessage::IncompatibleS2MessageVersions,
752 additional_info: None,
753 }))?;
754
755 let replacement = AccessToken::from_entropy(access_entropy)?;
756 self.tokens.add(replacement.clone(), now);
760 Ok(SessionGrant {
761 selected_communication_protocol: protocol,
762 selected_s2_message_version: version,
763 access_token: replacement,
764 server_node_description: None,
765 server_endpoint_description: None,
766 })
767 }
768
769 pub fn confirm_access_token(
774 &mut self,
775 bearer: &AccessToken,
776 communication_entropy: &[u8],
777 now: Timestamp,
778 ) -> Result<CommunicationDetails, ConnectError> {
779 if !self.tokens.is_pending(bearer) {
784 return Err(ConnectError::NotPaired);
785 }
786 self.tokens.confirm(bearer, now)?;
787 let token = CommunicationToken::from_entropy(communication_entropy)?;
788 self.connection = Some(IssuedConnection {
793 token: token.clone(),
794 issued: now,
795 });
796 Ok(CommunicationDetails::WebSocket {
797 websocket_url: self.websocket_url.clone(),
798 websocket_token: token,
799 })
800 }
801
802 pub fn unpair(
804 &mut self,
805 bearer: &AccessToken,
806 request: &UnpairRequest,
807 ) -> Result<(), ConnectError> {
808 if !self.tokens.accepts(bearer)
809 || request.server_node_id != self.node_id
810 || request.client_node_id != self.peer_node_id
811 {
812 return Err(ConnectError::NotPaired);
813 }
814 self.tokens.clear();
815 self.connection = None;
816 Ok(())
817 }
818
819 pub fn accepts_connection(&mut self, presented: &str, now: Timestamp) -> bool {
827 let Some(connection) = &self.connection else {
828 return false;
829 };
830 if now.saturating_duration_since(connection.issued) >= COMMUNICATION_TOKEN_LIFETIME {
831 self.connection = None;
832 return false;
833 }
834 if !connection.token.verify_str(presented) {
835 return false;
836 }
837 self.connection = None;
838 true
839 }
840
841 #[must_use]
843 pub fn tokens(&self) -> &TokenStore {
844 &self.tokens
845 }
846}
847
848#[cfg(test)]
849mod tests {
850 use super::*;
851 use alloc::string::ToString;
852
853 fn t(secs: i64) -> Timestamp {
854 Timestamp::from_unix(1_700_000_000 + secs, 0)
855 }
856
857 fn ids() -> (NodeId, NodeId) {
858 (
859 NodeId::parse("rm-1").expect("a legal id"),
860 NodeId::parse("cem-1").expect("a legal id"),
861 )
862 }
863
864 fn pair() -> (SessionInitClient, SessionInitServer, AccessToken) {
865 let (rm, cem) = ids();
866 let initial = AccessToken::from_entropy(&[1u8; 32]).expect("32 bytes");
867 let client = SessionInitClient::new(rm, cem, TokenStore::new(initial.clone()));
868 let server = SessionInitServer::new(
869 cem,
870 rm,
871 TokenStore::new(initial.clone()),
872 "wss://cem.example.com/s2",
873 );
874 (client, server, initial)
875 }
876
877 fn run_at(
879 client: &mut SessionInitClient,
880 server: &mut SessionInitServer,
881 new_access: u8,
882 comm: u8,
883 at: Timestamp,
884 ) -> SessionCredentials {
885 let (bearer, request) = client.initiate().unwrap();
886 let grant = server
887 .initiate_session(&bearer, &request, &[new_access; 32], at)
888 .unwrap();
889 client.accept(grant, at).unwrap();
890 let confirm = client.confirm().unwrap();
891 let details = server
892 .confirm_access_token(&confirm, &[comm; 32], at)
893 .unwrap();
894 client.connected(details, at).unwrap()
895 }
896
897 fn run(
899 client: &mut SessionInitClient,
900 server: &mut SessionInitServer,
901 new_access: u8,
902 comm: u8,
903 ) -> SessionCredentials {
904 run_at(client, server, new_access, comm, t(0))
905 }
906
907 #[test]
908 fn a_session_is_initiated_and_the_token_rotates() {
909 let (mut client, mut server, initial) = pair();
910 let creds = run(&mut client, &mut server, 2, 3);
911
912 assert_eq!(creds.websocket_url, "wss://cem.example.com/s2");
913 assert_eq!(creds.profile, Some(WireProfile::V1_0_0));
914 assert!(!creds.is_expired(t(29)));
915
916 assert!(!server.tokens().accepts(&initial));
918 assert_eq!(client.tokens().len(), 1);
919 assert!(server.tokens().accepts(client.tokens().current().unwrap()));
920 }
921
922 #[test]
923 fn the_confirmation_is_authenticated_with_the_new_token() {
924 let (mut client, mut server, initial) = pair();
926 let (bearer, request) = client.initiate().unwrap();
927 let grant = server
928 .initiate_session(&bearer, &request, &[2u8; 32], t(0))
929 .unwrap();
930 let replacement = grant.access_token.clone();
931 client.accept(grant, t(0)).unwrap();
932
933 assert!(matches!(
935 server.confirm_access_token(&initial, &[3u8; 32], t(0)),
936 Err(ConnectError::NotPaired)
937 ));
938 assert!(
940 server
941 .confirm_access_token(&replacement, &[3u8; 32], t(0))
942 .is_ok()
943 );
944 }
945
946 #[test]
947 fn a_lost_grant_does_not_strand_the_pairing() {
948 let (mut client, mut server, initial) = pair();
951 let (bearer, request) = client.initiate().unwrap();
952 let _lost = server
953 .initiate_session(&bearer, &request, &[2u8; 32], t(0))
954 .unwrap();
955
956 client.restart();
958 assert!(server.tokens().accepts(&initial));
959 let creds = run(&mut client, &mut server, 4, 5);
960 assert!(!creds.websocket_url.is_empty());
961 assert!(server.tokens().accepts(client.tokens().current().unwrap()));
962 }
963
964 #[test]
965 fn a_lost_confirmation_does_not_strand_the_pairing_either() {
966 let (mut client, mut server, initial) = pair();
968 let (bearer, request) = client.initiate().unwrap();
969 let grant = server
970 .initiate_session(&bearer, &request, &[2u8; 32], t(0))
971 .unwrap();
972 client.accept(grant, t(0)).unwrap();
973
974 assert!(server.tokens().accepts(&initial));
976 assert!(server.tokens().accepts(client.tokens().current().unwrap()));
977 assert_eq!(client.tokens().len(), 2);
978
979 client.restart();
980 let creds = run(&mut client, &mut server, 6, 7);
981 assert!(!creds.websocket_url.is_empty());
982 assert_eq!(
983 client.tokens().len(),
984 1,
985 "and the list collapses on success"
986 );
987 }
988
989 #[test]
990 fn a_client_works_down_its_list_after_a_401() {
991 let (mut client, mut server, _) = pair();
993 for entropy in [2u8, 3u8] {
994 let (bearer, request) = client.initiate().unwrap();
995 let grant = server
996 .initiate_session(&bearer, &request, &[entropy; 32], t(0))
997 .unwrap();
998 client.accept(grant, t(0)).unwrap();
999 client.restart();
1000 }
1001 assert_eq!(client.tokens().len(), 3);
1002
1003 let (rm, cem) = ids();
1006 let mut amnesiac = SessionInitServer::new(cem, rm, TokenStore::default(), "wss://x/");
1007 for _ in 0..3 {
1008 let (bearer, request) = client.initiate().unwrap();
1009 assert!(matches!(
1010 amnesiac.initiate_session(&bearer, &request, &[9u8; 32], t(0)),
1011 Err(ConnectError::NotPaired)
1012 ));
1013 if let Err(e) = client.unauthorized() {
1014 assert_eq!(e, ConnectError::NotPaired);
1015 return;
1016 }
1017 }
1018 panic!("the client should have given up after exhausting its tokens");
1019 }
1020
1021 #[test]
1022 fn a_token_the_server_never_issued_is_refused() {
1023 let (mut client, mut server, _) = pair();
1024 let (_, request) = client.initiate().unwrap();
1025 let forged = AccessToken::from_entropy(&[0xFFu8; 32]).unwrap();
1026 assert!(matches!(
1027 server.initiate_session(&forged, &request, &[2u8; 32], t(0)),
1028 Err(ConnectError::NotPaired)
1029 ));
1030 }
1031
1032 #[test]
1033 fn a_request_for_someone_elses_pairing_is_refused() {
1034 let (mut client, mut server, _) = pair();
1035 let (bearer, mut request) = client.initiate().unwrap();
1036 request.server_node_id = NodeId::parse("cem-2").unwrap();
1037 assert!(matches!(
1038 server.initiate_session(&bearer, &request, &[2u8; 32], t(0)),
1039 Err(ConnectError::SessionRefused(SessionRefused {
1040 error_message: SessionErrorMessage::NoLongerPaired,
1041 ..
1042 }))
1043 ));
1044 }
1045
1046 #[test]
1047 fn a_peer_that_spells_the_version_the_other_way_still_connects() {
1048 for spelling in ["v1.0.0", "1.0.0"] {
1053 let (client, mut server, _) = pair();
1054 let mut client =
1055 client.with_s2_message_versions(alloc::vec![ProtocolVersion::new(spelling)]);
1056 let creds = run(&mut client, &mut server, 2, 3);
1057 assert_eq!(
1058 creds.profile,
1059 Some(WireProfile::V1_0_0),
1060 "a server offering the other spelling must still resolve {spelling}"
1061 );
1062 }
1063
1064 let (mut client, server, _) = pair();
1067 let mut server =
1068 server.with_s2_message_versions(alloc::vec![ProtocolVersion::new("1.0.0")]);
1069 let creds = run(&mut client, &mut server, 2, 3);
1070 assert_eq!(creds.profile, Some(WireProfile::V1_0_0));
1071 }
1072
1073 #[test]
1074 fn a_version_neither_side_speaks_is_refused_with_the_named_reason() {
1075 let (rm, cem) = ids();
1076 let initial = AccessToken::from_entropy(&[1u8; 32]).unwrap();
1077 let mut client = SessionInitClient::new(rm, cem, TokenStore::new(initial.clone()))
1078 .with_s2_message_versions(alloc::vec![crate::types::ProtocolVersion::new("9.9.9")]);
1079 let mut server = SessionInitServer::new(cem, rm, TokenStore::new(initial), "wss://x/");
1080 let (bearer, request) = client.initiate().unwrap();
1081 assert!(matches!(
1082 server.initiate_session(&bearer, &request, &[2u8; 32], t(0)),
1083 Err(ConnectError::SessionRefused(SessionRefused {
1084 error_message: SessionErrorMessage::IncompatibleS2MessageVersions,
1085 ..
1086 }))
1087 ));
1088 }
1089
1090 #[test]
1091 fn a_communication_token_is_good_for_thirty_seconds_and_not_a_moment_more() {
1092 let (mut client, mut server, _) = pair();
1093 let (bearer, request) = client.initiate().unwrap();
1094 let grant = server
1095 .initiate_session(&bearer, &request, &[2u8; 32], t(0))
1096 .unwrap();
1097 client.accept(grant, t(0)).unwrap();
1098 let confirm = client.confirm().unwrap();
1099 let details = server
1100 .confirm_access_token(&confirm, &[3u8; 32], t(0))
1101 .unwrap();
1102 let CommunicationDetails::WebSocket {
1103 ref websocket_token,
1104 ..
1105 } = details;
1106 let presented = websocket_token.as_str().to_string();
1107 let creds = client.connected(details, t(0)).unwrap();
1108
1109 assert!(creds.is_expired(t(30)));
1110 assert_eq!(creds.expires(), t(30));
1111
1112 assert!(!server.accepts_connection("something else", t(1)));
1115 assert!(server.accepts_connection(&presented, t(29)));
1117 assert!(!server.accepts_connection(&presented, t(29)));
1119 }
1120
1121 #[test]
1122 fn a_communication_token_presented_too_late_is_refused() {
1123 let (mut client, mut server, _) = pair();
1124 let creds = run(&mut client, &mut server, 2, 3);
1125 let presented = creds.websocket_token.as_str().to_string();
1126 assert!(!server.accepts_connection(&presented, t(30)));
1127 assert!(!server.accepts_connection(&presented, t(1)));
1129 }
1130
1131 #[test]
1132 fn a_server_restarted_between_the_two_requests_still_honours_the_grant() {
1133 let (mut client, mut server, initial) = pair();
1138 let (bearer, request) = client.initiate().unwrap();
1139 let grant = server
1140 .initiate_session(&bearer, &request, &[2u8; 32], t(0))
1141 .unwrap();
1142 client.accept(grant, t(0)).unwrap();
1143 let confirm = client.confirm().unwrap();
1144
1145 let persisted = server.tokens().clone();
1148 let (rm, cem) = ids();
1149 let mut server = SessionInitServer::new(cem, rm, persisted, "wss://cem.example.com/s2");
1150
1151 let details = server
1152 .confirm_access_token(&confirm, &[3u8; 32], t(1))
1153 .expect("a restart must not lose the grant");
1154 let creds = client.connected(details, t(1)).unwrap();
1155 assert!(
1156 !server.tokens().accepts(&initial),
1157 "the old token is retired"
1158 );
1159 assert!(server.tokens().accepts(client.tokens().current().unwrap()));
1160 assert!(!creds.is_expired(t(2)));
1161 }
1162
1163 #[test]
1164 fn only_a_pending_grant_confirms_anything() {
1165 let (mut client, mut server, initial) = pair();
1169 let (bearer, request) = client.initiate().unwrap();
1170 let grant = server
1171 .initiate_session(&bearer, &request, &[2u8; 32], t(0))
1172 .unwrap();
1173 client.accept(grant, t(0)).unwrap();
1174
1175 assert!(
1176 server.tokens().accepts(&initial),
1177 "it is still a valid bearer"
1178 );
1179 assert!(
1180 matches!(
1181 server.confirm_access_token(&initial, &[3u8; 32], t(0)),
1182 Err(ConnectError::NotPaired)
1183 ),
1184 "but it is not the grant"
1185 );
1186 let confirm = client.confirm().unwrap();
1188 assert!(
1189 server
1190 .confirm_access_token(&confirm, &[3u8; 32], t(0))
1191 .is_ok()
1192 );
1193 }
1194
1195 #[test]
1196 fn a_grant_confirmed_too_late_leaves_the_old_token_in_force() {
1197 let (mut client, mut server, initial) = pair();
1202 let (bearer, request) = client.initiate().unwrap();
1203 let grant = server
1204 .initiate_session(&bearer, &request, &[2u8; 32], t(0))
1205 .unwrap();
1206 client.accept(grant, t(0)).unwrap();
1207 let confirm = client.confirm().unwrap();
1208
1209 let too_late = server.confirm_access_token(&confirm, &[3u8; 32], t(16));
1210 assert!(
1211 matches!(
1212 too_late,
1213 Err(ConnectError::Expired {
1214 what: "access token confirmation",
1215 ..
1216 })
1217 ),
1218 "{too_late:?}"
1219 );
1220 assert!(
1221 server.tokens().accepts(&initial),
1222 "the old token still works"
1223 );
1224
1225 let (mut client, mut server, initial) = pair();
1227 let (bearer, request) = client.initiate().unwrap();
1228 let grant = server
1229 .initiate_session(&bearer, &request, &[2u8; 32], t(0))
1230 .unwrap();
1231 client.accept(grant, t(0)).unwrap();
1232 let confirm = client.confirm().unwrap();
1233 let details = server
1234 .confirm_access_token(&confirm, &[3u8; 32], t(14))
1235 .expect("fourteen seconds is inside fifteen");
1236 let creds = client.connected(details, t(14)).unwrap();
1237 assert!(!server.tokens().accepts(&initial));
1238 assert_eq!(creds.profile, Some(WireProfile::V1_0_0));
1239 }
1240
1241 #[test]
1242 fn the_phases_cannot_be_taken_out_of_order() {
1243 let (mut client, _, _) = pair();
1244 assert!(matches!(
1245 client.confirm(),
1246 Err(ConnectError::OutOfOrder { .. })
1247 ));
1248 assert!(client.initiate().is_err());
1249 client.restart();
1250 assert!(client.initiate().is_ok());
1251 }
1252
1253 #[test]
1254 fn a_completed_session_can_be_followed_by_another() {
1255 let (mut client, mut server, _) = pair();
1258 run(&mut client, &mut server, 2, 3);
1259 run(&mut client, &mut server, 4, 5);
1260 run(&mut client, &mut server, 6, 7);
1261 assert_eq!(client.tokens().len(), 1);
1263 assert!(server.tokens().accepts(client.tokens().current().unwrap()));
1264 }
1265
1266 #[test]
1267 fn unpairing_forgets_the_pairing_on_both_sides() {
1268 let (mut client, mut server, _) = pair();
1269 run(&mut client, &mut server, 2, 3);
1270 let token = client.tokens().current().unwrap().clone();
1271 let request = client.unpaired();
1272 server.unpair(&token, &request).unwrap();
1273 assert!(server.tokens().is_empty());
1274 assert!(client.tokens().is_empty());
1275 assert!(!server.authenticates(&token));
1277 }
1278
1279 #[test]
1280 fn the_bodies_are_the_shape_the_openapi_defines() {
1281 let (mut client, mut server, _) = pair();
1282 let (bearer, request) = client.initiate().unwrap();
1283 let json = serde_json::to_value(&request).unwrap();
1284 for key in [
1285 "clientNodeId",
1286 "serverNodeId",
1287 "supportedS2MessageVersions",
1288 "supportedCommunicationProtocols",
1289 ] {
1290 assert!(json.get(key).is_some(), "missing required property {key}");
1291 }
1292 assert!(json.get("clientNodeDescription").is_none());
1293 assert_eq!(json["supportedCommunicationProtocols"][0], "WebSocket");
1294
1295 let grant = server
1296 .initiate_session(&bearer, &request, &[2u8; 32], t(0))
1297 .unwrap();
1298 let json = serde_json::to_value(&grant).unwrap();
1299 for key in [
1300 "selectedCommunicationProtocol",
1301 "selectedS2MessageVersion",
1302 "accessToken",
1303 ] {
1304 assert!(json.get(key).is_some(), "missing required property {key}");
1305 }
1306
1307 client.accept(grant, t(0)).unwrap();
1309 let confirm = client.confirm().unwrap();
1310 let details = server
1311 .confirm_access_token(&confirm, &[3u8; 32], t(0))
1312 .unwrap();
1313 let json = serde_json::to_value(&details).unwrap();
1314 assert_eq!(json["communicationProtocol"], "WebSocket");
1315 assert!(json.get("websocketUrl").is_some());
1316 assert!(json.get("websocketToken").is_some());
1317 }
1318}