use alloc::string::String;
use alloc::vec::Vec;
use serde::{Deserialize, Serialize};
use crate::types::{Duration, ProtocolVersion, Timestamp, WireProfile};
use super::{
AccessToken, CommunicationProtocol, CommunicationToken, ConnectError, EndpointDescription,
NodeDescription, NodeId,
};
pub const COMMUNICATION_TOKEN_LIFETIME: Duration = Duration::from_secs(30);
pub const PENDING_TOKEN_LIFETIME: Duration = Duration::from_secs(15);
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SessionRequest {
pub client_node_id: NodeId,
pub server_node_id: NodeId,
pub supported_s2_message_versions: Vec<ProtocolVersion>,
pub supported_communication_protocols: Vec<CommunicationProtocol>,
#[serde(skip_serializing_if = "Option::is_none")]
pub client_node_description: Option<NodeDescription>,
#[serde(skip_serializing_if = "Option::is_none")]
pub client_endpoint_description: Option<EndpointDescription>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SessionGrant {
pub selected_communication_protocol: CommunicationProtocol,
pub selected_s2_message_version: ProtocolVersion,
pub access_token: AccessToken,
#[serde(skip_serializing_if = "Option::is_none")]
pub server_node_description: Option<NodeDescription>,
#[serde(skip_serializing_if = "Option::is_none")]
pub server_endpoint_description: Option<EndpointDescription>,
}
impl SessionGrant {
#[must_use]
pub fn profile(&self) -> Option<WireProfile> {
self.selected_s2_message_version.wire_profile()
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "communicationProtocol")]
#[non_exhaustive]
pub enum CommunicationDetails {
WebSocket {
#[serde(rename = "websocketUrl")]
websocket_url: String,
#[serde(rename = "websocketToken")]
websocket_token: CommunicationToken,
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum SessionErrorMessage {
IncompatibleS2MessageVersions,
IncompatibleCommunicationProtocols,
NoLongerPaired,
ParsingError,
Other,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SessionRefused {
pub error_message: SessionErrorMessage,
#[serde(skip_serializing_if = "Option::is_none")]
pub additional_info: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UnpairRequest {
pub client_node_id: NodeId,
pub server_node_id: NodeId,
}
#[derive(Debug, Clone)]
pub struct SessionCredentials {
pub websocket_url: String,
pub websocket_token: CommunicationToken,
pub profile: Option<WireProfile>,
pub issued: Timestamp,
}
impl SessionCredentials {
#[must_use]
pub fn expires(&self) -> Timestamp {
self.issued
.checked_add(COMMUNICATION_TOKEN_LIFETIME)
.unwrap_or(self.issued)
}
#[must_use]
pub fn is_expired(&self, now: Timestamp) -> bool {
now >= self.expires()
}
}
#[derive(Debug, Clone)]
struct Held {
token: AccessToken,
granted: Option<Timestamp>,
}
#[derive(Debug, Clone, Default)]
pub struct TokenStore {
tokens: Vec<Held>,
}
impl TokenStore {
pub const MAX: usize = 4;
#[must_use]
pub fn new(current: AccessToken) -> Self {
Self {
tokens: alloc::vec![Held {
token: current,
granted: None,
}],
}
}
#[must_use]
pub fn accepts(&self, presented: &AccessToken) -> bool {
self.find(presented).is_some()
}
fn find(&self, presented: &AccessToken) -> Option<&Held> {
self.tokens.iter().find(|h| h.token.verify(presented))
}
pub fn add(&mut self, token: AccessToken, now: Timestamp) {
if self.tokens.iter().any(|h| h.token.verify(&token)) {
return;
}
self.tokens.retain(|held| {
held.granted.is_none_or(|granted| {
now.saturating_duration_since(granted) <= PENDING_TOKEN_LIFETIME
})
});
self.tokens.insert(
0,
Held {
token,
granted: Some(now),
},
);
self.evict();
}
fn evict(&mut self) {
while self.tokens.len() > Self::MAX {
let victim = self
.tokens
.iter()
.rposition(|held| held.granted.is_some())
.unwrap_or(self.tokens.len() - 1);
self.tokens.remove(victim);
}
}
pub fn adopt(&mut self, token: AccessToken) {
if self.tokens.iter().any(|h| h.token.verify(&token)) {
return;
}
self.tokens.insert(
0,
Held {
token,
granted: None,
},
);
self.evict();
}
pub fn confirm(&mut self, token: &AccessToken, now: Timestamp) -> Result<(), ConnectError> {
let held = self.find(token).ok_or(ConnectError::NotPaired)?;
if let Some(granted) = held.granted
&& now.saturating_duration_since(granted) > PENDING_TOKEN_LIFETIME
{
return Err(ConnectError::Expired {
what: "access token confirmation",
limit: PENDING_TOKEN_LIFETIME,
});
}
self.tokens.clear();
self.tokens.push(Held {
token: token.clone(),
granted: None,
});
Ok(())
}
#[must_use]
pub fn is_pending(&self, presented: &AccessToken) -> bool {
self.find(presented).is_some_and(|h| h.granted.is_some())
}
#[must_use]
pub fn current(&self) -> Option<&AccessToken> {
self.tokens.first().map(|h| &h.token)
}
pub fn candidates(&self) -> impl Iterator<Item = &AccessToken> {
self.tokens.iter().map(|h| &h.token)
}
#[must_use]
pub fn len(&self) -> usize {
self.tokens.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.tokens.is_empty()
}
pub fn clear(&mut self) {
self.tokens.clear();
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Phase {
Start,
AwaitingGrant,
Granted,
Connected,
Failed,
}
impl Phase {
const fn name(self) -> &'static str {
match self {
Phase::Start => "the start of session initiation",
Phase::AwaitingGrant => "the session grant",
Phase::Granted => "confirmation of the new access token",
Phase::Connected => "a completed initiation",
Phase::Failed => "a failed initiation",
}
}
}
#[derive(Debug)]
pub struct SessionInitClient {
client_node_id: NodeId,
server_node_id: NodeId,
tokens: TokenStore,
s2_message_versions: Vec<ProtocolVersion>,
protocols: Vec<CommunicationProtocol>,
phase: Phase,
attempted: Option<AccessToken>,
tried: usize,
granted: Option<SessionGrant>,
insecure_websocket: bool,
}
impl SessionInitClient {
#[must_use]
pub fn new(client_node_id: NodeId, server_node_id: NodeId, tokens: TokenStore) -> Self {
Self {
client_node_id,
server_node_id,
tokens,
s2_message_versions: alloc::vec![
WireProfile::V1_0_0.connect_version(),
WireProfile::V0_0_2Beta.connect_version(),
],
protocols: alloc::vec![CommunicationProtocol::WebSocket],
phase: Phase::Start,
attempted: None,
tried: 0,
granted: None,
insecure_websocket: false,
}
}
#[must_use]
pub fn allowing_insecure_websocket(mut self) -> Self {
self.insecure_websocket = true;
self
}
#[must_use]
pub fn with_s2_message_versions(mut self, versions: Vec<ProtocolVersion>) -> Self {
self.s2_message_versions = versions;
self
}
pub fn initiate(&mut self) -> Result<(AccessToken, SessionRequest), ConnectError> {
if self.phase == Phase::Connected {
self.phase = Phase::Start;
}
self.expect(Phase::Start)?;
let token = self
.tokens
.candidates()
.nth(self.tried)
.cloned()
.ok_or(ConnectError::NotPaired)?;
self.attempted = Some(token.clone());
self.phase = Phase::AwaitingGrant;
Ok((
token,
SessionRequest {
client_node_id: self.client_node_id,
server_node_id: self.server_node_id,
supported_s2_message_versions: self.s2_message_versions.clone(),
supported_communication_protocols: self.protocols.clone(),
client_node_description: None,
client_endpoint_description: None,
},
))
}
pub fn unauthorized(&mut self) -> Result<(), ConnectError> {
self.tried += 1;
self.phase = Phase::Start;
if self.tried >= self.tokens.len() {
self.phase = Phase::Failed;
return Err(ConnectError::NotPaired);
}
Ok(())
}
pub fn accept(&mut self, grant: SessionGrant, now: Timestamp) -> Result<(), ConnectError> {
self.expect(Phase::AwaitingGrant)?;
if !self
.protocols
.contains(&grant.selected_communication_protocol)
{
self.phase = Phase::Failed;
return Err(ConnectError::NoOverlap("communication protocol"));
}
if !self
.s2_message_versions
.iter()
.any(|v| v.matches(&grant.selected_s2_message_version))
{
self.phase = Phase::Failed;
return Err(ConnectError::NoOverlap("S2 message version"));
}
self.tokens.add(grant.access_token.clone(), now);
self.granted = Some(grant);
self.phase = Phase::Granted;
Ok(())
}
pub fn confirm(&mut self) -> Result<AccessToken, ConnectError> {
self.expect(Phase::Granted)?;
let grant = self.granted.as_ref().ok_or(ConnectError::OutOfOrder {
got: "a confirmation",
expected: Phase::AwaitingGrant.name(),
})?;
Ok(grant.access_token.clone())
}
pub fn connected(
&mut self,
details: CommunicationDetails,
now: Timestamp,
) -> Result<SessionCredentials, ConnectError> {
self.expect(Phase::Granted)?;
let grant = self.granted.take().ok_or(ConnectError::OutOfOrder {
got: "communication details",
expected: Phase::AwaitingGrant.name(),
})?;
self.tokens.confirm(&grant.access_token, now)?;
self.tried = 0;
self.phase = Phase::Connected;
let CommunicationDetails::WebSocket {
websocket_url,
websocket_token,
} = details;
let secure = websocket_url
.get(..6)
.is_some_and(|scheme| scheme.eq_ignore_ascii_case("wss://"));
if !secure && !self.insecure_websocket {
self.phase = Phase::Failed;
return Err(ConnectError::OutOfOrder {
got: "a websocketUrl that is not wss://",
expected: "an encrypted WebSocket (S2C §Encrypted connection)",
});
}
Ok(SessionCredentials {
websocket_url,
websocket_token,
profile: grant.profile(),
issued: now,
})
}
pub fn restart(&mut self) {
self.phase = Phase::Start;
self.attempted = None;
}
pub fn unpaired(&mut self) -> UnpairRequest {
self.tokens.clear();
self.phase = Phase::Failed;
UnpairRequest {
client_node_id: self.client_node_id,
server_node_id: self.server_node_id,
}
}
#[must_use]
pub fn tokens(&self) -> &TokenStore {
&self.tokens
}
fn expect(&mut self, phase: Phase) -> Result<(), ConnectError> {
if self.phase == phase {
return Ok(());
}
let got = self.phase.name();
self.phase = Phase::Failed;
Err(ConnectError::OutOfOrder {
got,
expected: phase.name(),
})
}
}
#[derive(Debug)]
pub struct SessionInitServer {
node_id: NodeId,
peer_node_id: NodeId,
tokens: TokenStore,
websocket_url: String,
s2_message_versions: Vec<ProtocolVersion>,
protocols: Vec<CommunicationProtocol>,
connection: Option<IssuedConnection>,
}
#[derive(Debug, Clone)]
struct IssuedConnection {
token: CommunicationToken,
issued: Timestamp,
}
impl SessionInitServer {
#[must_use]
pub fn new(
node_id: NodeId,
peer_node_id: NodeId,
tokens: TokenStore,
websocket_url: impl Into<String>,
) -> Self {
Self {
node_id,
peer_node_id,
tokens,
websocket_url: websocket_url.into(),
s2_message_versions: alloc::vec![
WireProfile::V1_0_0.connect_version(),
WireProfile::V0_0_2Beta.connect_version(),
],
protocols: alloc::vec![CommunicationProtocol::WebSocket],
connection: None,
}
}
#[must_use]
pub fn with_s2_message_versions(mut self, versions: Vec<ProtocolVersion>) -> Self {
self.s2_message_versions = versions;
self
}
#[must_use]
pub fn authenticates(&self, bearer: &AccessToken) -> bool {
self.tokens.accepts(bearer)
}
pub fn initiate_session(
&mut self,
bearer: &AccessToken,
request: &SessionRequest,
access_entropy: &[u8],
now: Timestamp,
) -> Result<SessionGrant, ConnectError> {
if !self.tokens.accepts(bearer) {
return Err(ConnectError::NotPaired);
}
if request.server_node_id != self.node_id || request.client_node_id != self.peer_node_id {
return Err(ConnectError::SessionRefused(SessionRefused {
error_message: SessionErrorMessage::NoLongerPaired,
additional_info: None,
}));
}
let protocol = request
.supported_communication_protocols
.iter()
.find(|p| self.protocols.contains(p))
.copied()
.ok_or(ConnectError::SessionRefused(SessionRefused {
error_message: SessionErrorMessage::IncompatibleCommunicationProtocols,
additional_info: None,
}))?;
let version = request
.supported_s2_message_versions
.iter()
.find(|v| self.s2_message_versions.iter().any(|ours| ours.matches(v)))
.cloned()
.ok_or(ConnectError::SessionRefused(SessionRefused {
error_message: SessionErrorMessage::IncompatibleS2MessageVersions,
additional_info: None,
}))?;
let replacement = AccessToken::from_entropy(access_entropy)?;
self.tokens.add(replacement.clone(), now);
Ok(SessionGrant {
selected_communication_protocol: protocol,
selected_s2_message_version: version,
access_token: replacement,
server_node_description: None,
server_endpoint_description: None,
})
}
pub fn confirm_access_token(
&mut self,
bearer: &AccessToken,
communication_entropy: &[u8],
now: Timestamp,
) -> Result<CommunicationDetails, ConnectError> {
if !self.tokens.is_pending(bearer) {
return Err(ConnectError::NotPaired);
}
self.tokens.confirm(bearer, now)?;
let token = CommunicationToken::from_entropy(communication_entropy)?;
self.connection = Some(IssuedConnection {
token: token.clone(),
issued: now,
});
Ok(CommunicationDetails::WebSocket {
websocket_url: self.websocket_url.clone(),
websocket_token: token,
})
}
pub fn unpair(
&mut self,
bearer: &AccessToken,
request: &UnpairRequest,
) -> Result<(), ConnectError> {
if !self.tokens.accepts(bearer)
|| request.server_node_id != self.node_id
|| request.client_node_id != self.peer_node_id
{
return Err(ConnectError::NotPaired);
}
self.tokens.clear();
self.connection = None;
Ok(())
}
pub fn accepts_connection(&mut self, presented: &str, now: Timestamp) -> bool {
let Some(connection) = &self.connection else {
return false;
};
if now.saturating_duration_since(connection.issued) >= COMMUNICATION_TOKEN_LIFETIME {
self.connection = None;
return false;
}
if !connection.token.verify_str(presented) {
return false;
}
self.connection = None;
true
}
#[must_use]
pub fn tokens(&self) -> &TokenStore {
&self.tokens
}
}
#[cfg(test)]
mod tests {
use super::*;
use alloc::string::ToString;
fn t(secs: i64) -> Timestamp {
Timestamp::from_unix(1_700_000_000 + secs, 0)
}
#[test]
fn four_unanswered_grants_inside_the_window_keep_the_token_in_force() {
let active = AccessToken::new("in-force");
let mut store = TokenStore::new(active.clone());
for i in 0..6 {
store.add(AccessToken::new(alloc::format!("grant-{i}")), t(i));
}
assert_eq!(store.len(), TokenStore::MAX);
assert!(
store.accepts(&active),
"the token the client holds still opens the door"
);
assert!(
store.accepts(&AccessToken::new("grant-5")),
"and the newest grant is kept"
);
}
#[test]
fn a_grant_nobody_confirmed_never_evicts_the_token_that_works() {
let live = AccessToken::from_entropy(&[9u8; 32]).expect("32 bytes");
let mut store = TokenStore::new(live.clone());
for i in 0..6u8 {
let granted = AccessToken::from_entropy(&[i; 32]).expect("32 bytes");
store.add(granted, t(i64::from(i) * 60));
}
assert!(
store.accepts(&live),
"the token the client is still holding must keep working"
);
assert_eq!(store.len(), 2, "one live token and the newest grant");
let live = AccessToken::from_entropy(&[9u8; 32]).expect("32 bytes");
let mut store = TokenStore::new(live.clone());
for i in 0..3u8 {
let granted = AccessToken::from_entropy(&[i; 32]).expect("32 bytes");
store.add(granted, t(i64::from(i)));
}
assert_eq!(store.len(), 4);
assert!(store.accepts(&live));
}
fn ids() -> (NodeId, NodeId) {
(
NodeId::parse("rm-1").expect("a legal id"),
NodeId::parse("cem-1").expect("a legal id"),
)
}
fn pair() -> (SessionInitClient, SessionInitServer, AccessToken) {
let (rm, cem) = ids();
let initial = AccessToken::from_entropy(&[1u8; 32]).expect("32 bytes");
let client = SessionInitClient::new(rm, cem, TokenStore::new(initial.clone()));
let server = SessionInitServer::new(
cem,
rm,
TokenStore::new(initial.clone()),
"wss://cem.example.com/s2",
);
(client, server, initial)
}
fn run_at(
client: &mut SessionInitClient,
server: &mut SessionInitServer,
new_access: u8,
comm: u8,
at: Timestamp,
) -> SessionCredentials {
let (bearer, request) = client.initiate().unwrap();
let grant = server
.initiate_session(&bearer, &request, &[new_access; 32], at)
.unwrap();
client.accept(grant, at).unwrap();
let confirm = client.confirm().unwrap();
let details = server
.confirm_access_token(&confirm, &[comm; 32], at)
.unwrap();
client.connected(details, at).unwrap()
}
fn run(
client: &mut SessionInitClient,
server: &mut SessionInitServer,
new_access: u8,
comm: u8,
) -> SessionCredentials {
run_at(client, server, new_access, comm, t(0))
}
#[test]
fn a_websocket_url_that_is_not_encrypted_is_refused() {
let (rm, cem) = ids();
let initial = AccessToken::from_entropy(&[1u8; 32]).expect("32 bytes");
let plaintext = |mut client: SessionInitClient| {
let mut server = SessionInitServer::new(
cem,
rm,
TokenStore::new(initial.clone()),
"ws://cem.example.com/s2",
);
let (bearer, request) = client.initiate().unwrap();
let grant = server
.initiate_session(&bearer, &request, &[2; 32], t(0))
.unwrap();
client.accept(grant, t(0)).unwrap();
let confirm = client.confirm().unwrap();
let details = server
.confirm_access_token(&confirm, &[3; 32], t(0))
.unwrap();
client.connected(details, t(0))
};
let refused = plaintext(SessionInitClient::new(
rm,
cem,
TokenStore::new(initial.clone()),
));
assert!(matches!(refused, Err(ConnectError::OutOfOrder { .. })));
let allowed = plaintext(
SessionInitClient::new(rm, cem, TokenStore::new(initial.clone()))
.allowing_insecure_websocket(),
);
assert!(allowed.is_ok(), "a loopback test may opt in");
}
#[test]
fn a_session_is_initiated_and_the_token_rotates() {
let (mut client, mut server, initial) = pair();
let creds = run(&mut client, &mut server, 2, 3);
assert_eq!(creds.websocket_url, "wss://cem.example.com/s2");
assert_eq!(creds.profile, Some(WireProfile::V1_0_0));
assert!(!creds.is_expired(t(29)));
assert!(!server.tokens().accepts(&initial));
assert_eq!(client.tokens().len(), 1);
assert!(server.tokens().accepts(client.tokens().current().unwrap()));
}
#[test]
fn the_confirmation_is_authenticated_with_the_new_token() {
let (mut client, mut server, initial) = pair();
let (bearer, request) = client.initiate().unwrap();
let grant = server
.initiate_session(&bearer, &request, &[2u8; 32], t(0))
.unwrap();
let replacement = grant.access_token.clone();
client.accept(grant, t(0)).unwrap();
assert!(matches!(
server.confirm_access_token(&initial, &[3u8; 32], t(0)),
Err(ConnectError::NotPaired)
));
assert!(
server
.confirm_access_token(&replacement, &[3u8; 32], t(0))
.is_ok()
);
}
#[test]
fn a_lost_grant_does_not_strand_the_pairing() {
let (mut client, mut server, initial) = pair();
let (bearer, request) = client.initiate().unwrap();
let _lost = server
.initiate_session(&bearer, &request, &[2u8; 32], t(0))
.unwrap();
client.restart();
assert!(server.tokens().accepts(&initial));
let creds = run(&mut client, &mut server, 4, 5);
assert!(!creds.websocket_url.is_empty());
assert!(server.tokens().accepts(client.tokens().current().unwrap()));
}
#[test]
fn a_lost_confirmation_does_not_strand_the_pairing_either() {
let (mut client, mut server, initial) = pair();
let (bearer, request) = client.initiate().unwrap();
let grant = server
.initiate_session(&bearer, &request, &[2u8; 32], t(0))
.unwrap();
client.accept(grant, t(0)).unwrap();
assert!(server.tokens().accepts(&initial));
assert!(server.tokens().accepts(client.tokens().current().unwrap()));
assert_eq!(client.tokens().len(), 2);
client.restart();
let creds = run(&mut client, &mut server, 6, 7);
assert!(!creds.websocket_url.is_empty());
assert_eq!(
client.tokens().len(),
1,
"and the list collapses on success"
);
}
#[test]
fn a_client_works_down_its_list_after_a_401() {
let (mut client, mut server, _) = pair();
for entropy in [2u8, 3u8] {
let (bearer, request) = client.initiate().unwrap();
let grant = server
.initiate_session(&bearer, &request, &[entropy; 32], t(0))
.unwrap();
client.accept(grant, t(0)).unwrap();
client.restart();
}
assert_eq!(client.tokens().len(), 3);
let (rm, cem) = ids();
let mut amnesiac = SessionInitServer::new(cem, rm, TokenStore::default(), "wss://x/");
for _ in 0..3 {
let (bearer, request) = client.initiate().unwrap();
assert!(matches!(
amnesiac.initiate_session(&bearer, &request, &[9u8; 32], t(0)),
Err(ConnectError::NotPaired)
));
if let Err(e) = client.unauthorized() {
assert_eq!(e, ConnectError::NotPaired);
return;
}
}
panic!("the client should have given up after exhausting its tokens");
}
#[test]
fn a_token_the_server_never_issued_is_refused() {
let (mut client, mut server, _) = pair();
let (_, request) = client.initiate().unwrap();
let forged = AccessToken::from_entropy(&[0xFFu8; 32]).unwrap();
assert!(matches!(
server.initiate_session(&forged, &request, &[2u8; 32], t(0)),
Err(ConnectError::NotPaired)
));
}
#[test]
fn a_request_for_someone_elses_pairing_is_refused() {
let (mut client, mut server, _) = pair();
let (bearer, mut request) = client.initiate().unwrap();
request.server_node_id = NodeId::parse("cem-2").unwrap();
assert!(matches!(
server.initiate_session(&bearer, &request, &[2u8; 32], t(0)),
Err(ConnectError::SessionRefused(SessionRefused {
error_message: SessionErrorMessage::NoLongerPaired,
..
}))
));
}
#[test]
fn a_peer_that_spells_the_version_the_other_way_still_connects() {
for spelling in ["v1.0.0", "1.0.0"] {
let (client, mut server, _) = pair();
let mut client =
client.with_s2_message_versions(alloc::vec![ProtocolVersion::new(spelling)]);
let creds = run(&mut client, &mut server, 2, 3);
assert_eq!(
creds.profile,
Some(WireProfile::V1_0_0),
"a server offering the other spelling must still resolve {spelling}"
);
}
let (mut client, server, _) = pair();
let mut server =
server.with_s2_message_versions(alloc::vec![ProtocolVersion::new("1.0.0")]);
let creds = run(&mut client, &mut server, 2, 3);
assert_eq!(creds.profile, Some(WireProfile::V1_0_0));
}
#[test]
fn a_version_neither_side_speaks_is_refused_with_the_named_reason() {
let (rm, cem) = ids();
let initial = AccessToken::from_entropy(&[1u8; 32]).unwrap();
let mut client = SessionInitClient::new(rm, cem, TokenStore::new(initial.clone()))
.with_s2_message_versions(alloc::vec![crate::types::ProtocolVersion::new("9.9.9")]);
let mut server = SessionInitServer::new(cem, rm, TokenStore::new(initial), "wss://x/");
let (bearer, request) = client.initiate().unwrap();
assert!(matches!(
server.initiate_session(&bearer, &request, &[2u8; 32], t(0)),
Err(ConnectError::SessionRefused(SessionRefused {
error_message: SessionErrorMessage::IncompatibleS2MessageVersions,
..
}))
));
}
#[test]
fn a_communication_token_is_good_for_thirty_seconds_and_not_a_moment_more() {
let (mut client, mut server, _) = pair();
let (bearer, request) = client.initiate().unwrap();
let grant = server
.initiate_session(&bearer, &request, &[2u8; 32], t(0))
.unwrap();
client.accept(grant, t(0)).unwrap();
let confirm = client.confirm().unwrap();
let details = server
.confirm_access_token(&confirm, &[3u8; 32], t(0))
.unwrap();
let CommunicationDetails::WebSocket {
ref websocket_token,
..
} = details;
let presented = websocket_token.as_str().to_string();
let creds = client.connected(details, t(0)).unwrap();
assert!(creds.is_expired(t(30)));
assert_eq!(creds.expires(), t(30));
assert!(!server.accepts_connection("something else", t(1)));
assert!(server.accepts_connection(&presented, t(29)));
assert!(!server.accepts_connection(&presented, t(29)));
}
#[test]
fn a_communication_token_presented_too_late_is_refused() {
let (mut client, mut server, _) = pair();
let creds = run(&mut client, &mut server, 2, 3);
let presented = creds.websocket_token.as_str().to_string();
assert!(!server.accepts_connection(&presented, t(30)));
assert!(!server.accepts_connection(&presented, t(1)));
}
#[test]
fn a_server_restarted_between_the_two_requests_still_honours_the_grant() {
let (mut client, mut server, initial) = pair();
let (bearer, request) = client.initiate().unwrap();
let grant = server
.initiate_session(&bearer, &request, &[2u8; 32], t(0))
.unwrap();
client.accept(grant, t(0)).unwrap();
let confirm = client.confirm().unwrap();
let persisted = server.tokens().clone();
let (rm, cem) = ids();
let mut server = SessionInitServer::new(cem, rm, persisted, "wss://cem.example.com/s2");
let details = server
.confirm_access_token(&confirm, &[3u8; 32], t(1))
.expect("a restart must not lose the grant");
let creds = client.connected(details, t(1)).unwrap();
assert!(
!server.tokens().accepts(&initial),
"the old token is retired"
);
assert!(server.tokens().accepts(client.tokens().current().unwrap()));
assert!(!creds.is_expired(t(2)));
}
#[test]
fn only_a_pending_grant_confirms_anything() {
let (mut client, mut server, initial) = pair();
let (bearer, request) = client.initiate().unwrap();
let grant = server
.initiate_session(&bearer, &request, &[2u8; 32], t(0))
.unwrap();
client.accept(grant, t(0)).unwrap();
assert!(
server.tokens().accepts(&initial),
"it is still a valid bearer"
);
assert!(
matches!(
server.confirm_access_token(&initial, &[3u8; 32], t(0)),
Err(ConnectError::NotPaired)
),
"but it is not the grant"
);
let confirm = client.confirm().unwrap();
assert!(
server
.confirm_access_token(&confirm, &[3u8; 32], t(0))
.is_ok()
);
}
#[test]
fn a_grant_confirmed_too_late_leaves_the_old_token_in_force() {
let (mut client, mut server, initial) = pair();
let (bearer, request) = client.initiate().unwrap();
let grant = server
.initiate_session(&bearer, &request, &[2u8; 32], t(0))
.unwrap();
client.accept(grant, t(0)).unwrap();
let confirm = client.confirm().unwrap();
let too_late = server.confirm_access_token(&confirm, &[3u8; 32], t(16));
assert!(
matches!(
too_late,
Err(ConnectError::Expired {
what: "access token confirmation",
..
})
),
"{too_late:?}"
);
assert!(
server.tokens().accepts(&initial),
"the old token still works"
);
let (mut client, mut server, initial) = pair();
let (bearer, request) = client.initiate().unwrap();
let grant = server
.initiate_session(&bearer, &request, &[2u8; 32], t(0))
.unwrap();
client.accept(grant, t(0)).unwrap();
let confirm = client.confirm().unwrap();
let details = server
.confirm_access_token(&confirm, &[3u8; 32], t(14))
.expect("fourteen seconds is inside fifteen");
let creds = client.connected(details, t(14)).unwrap();
assert!(!server.tokens().accepts(&initial));
assert_eq!(creds.profile, Some(WireProfile::V1_0_0));
}
#[test]
fn the_phases_cannot_be_taken_out_of_order() {
let (mut client, _, _) = pair();
assert!(matches!(
client.confirm(),
Err(ConnectError::OutOfOrder { .. })
));
assert!(client.initiate().is_err());
client.restart();
assert!(client.initiate().is_ok());
}
#[test]
fn a_completed_session_can_be_followed_by_another() {
let (mut client, mut server, _) = pair();
run(&mut client, &mut server, 2, 3);
run(&mut client, &mut server, 4, 5);
run(&mut client, &mut server, 6, 7);
assert_eq!(client.tokens().len(), 1);
assert!(server.tokens().accepts(client.tokens().current().unwrap()));
}
#[test]
fn unpairing_forgets_the_pairing_on_both_sides() {
let (mut client, mut server, _) = pair();
run(&mut client, &mut server, 2, 3);
let token = client.tokens().current().unwrap().clone();
let request = client.unpaired();
server.unpair(&token, &request).unwrap();
assert!(server.tokens().is_empty());
assert!(client.tokens().is_empty());
assert!(!server.authenticates(&token));
}
#[test]
fn the_bodies_are_the_shape_the_openapi_defines() {
let (mut client, mut server, _) = pair();
let (bearer, request) = client.initiate().unwrap();
let json = serde_json::to_value(&request).unwrap();
for key in [
"clientNodeId",
"serverNodeId",
"supportedS2MessageVersions",
"supportedCommunicationProtocols",
] {
assert!(json.get(key).is_some(), "missing required property {key}");
}
assert!(json.get("clientNodeDescription").is_none());
assert_eq!(json["supportedCommunicationProtocols"][0], "WebSocket");
let grant = server
.initiate_session(&bearer, &request, &[2u8; 32], t(0))
.unwrap();
let json = serde_json::to_value(&grant).unwrap();
for key in [
"selectedCommunicationProtocol",
"selectedS2MessageVersion",
"accessToken",
] {
assert!(json.get(key).is_some(), "missing required property {key}");
}
client.accept(grant, t(0)).unwrap();
let confirm = client.confirm().unwrap();
let details = server
.confirm_access_token(&confirm, &[3u8; 32], t(0))
.unwrap();
let json = serde_json::to_value(&details).unwrap();
assert_eq!(json["communicationProtocol"], "WebSocket");
assert!(json.get("websocketUrl").is_some());
assert!(json.get("websocketToken").is_some());
}
}