use core::marker::PhantomData;
use super::bindings::{LogoutBinding, SsoRequestBinding, SsoResponseBinding};
use super::endpoints::AcsEndpoint;
use super::outbound::Outbound;
use crate::config::EntityId;
use crate::constants::Binding;
use crate::error::SamlError;
use crate::model::{
AuthnRequest, EndpointUrl, LogoutRequest, MessageId, RelayStateParam, SamlInstant,
};
mod sealed {
pub trait Sealed {}
}
#[doc(hidden)]
pub trait PendingMessage: sealed::Sealed {
type Details: Clone + core::fmt::Debug + PartialEq + Eq;
type RequestBinding: Copy + core::fmt::Debug + PartialEq + Eq;
type ResponseBinding: Copy + core::fmt::Debug + PartialEq + Eq;
}
#[doc(hidden)]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AuthnPendingDetails {
request_binding: Option<SsoRequestBinding>,
response_binding: SsoResponseBinding,
acs: AcsEndpoint,
}
#[doc(hidden)]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct LogoutPendingDetails {
binding: LogoutBinding,
}
impl sealed::Sealed for AuthnRequest {}
impl PendingMessage for AuthnRequest {
type Details = AuthnPendingDetails;
type RequestBinding = SsoRequestBinding;
type ResponseBinding = SsoResponseBinding;
}
impl sealed::Sealed for LogoutRequest {}
impl PendingMessage for LogoutRequest {
type Details = LogoutPendingDetails;
type RequestBinding = LogoutBinding;
type ResponseBinding = LogoutBinding;
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PendingSnapshot<Message: PendingMessage> {
pub id: String,
pub relay_state: RelayStateParam,
pub peer_entity_id: String,
pub expected_binding: String,
pub request_binding: Option<String>,
pub acs_url: String,
pub acs_binding: String,
pub acs_index: Option<u16>,
pub acs_is_default: bool,
pub issued_at: Option<SamlInstant>,
pub expires_at: Option<SamlInstant>,
_message: PhantomData<Message>,
}
impl PendingSnapshot<AuthnRequest> {
pub fn authn_request(
id: impl Into<String>,
relay_state: RelayStateParam,
peer_entity_id: impl Into<String>,
expected_binding: impl Into<String>,
acs_url: impl Into<String>,
acs_binding: impl Into<String>,
) -> Self {
Self {
id: id.into(),
relay_state,
peer_entity_id: peer_entity_id.into(),
expected_binding: expected_binding.into(),
request_binding: None,
acs_url: acs_url.into(),
acs_binding: acs_binding.into(),
acs_index: None,
acs_is_default: false,
issued_at: None,
expires_at: None,
_message: PhantomData,
}
}
}
impl PendingSnapshot<LogoutRequest> {
pub fn logout_request(
id: impl Into<String>,
relay_state: RelayStateParam,
peer_entity_id: impl Into<String>,
binding: LogoutBinding,
) -> Self {
Self {
id: id.into(),
relay_state,
peer_entity_id: peer_entity_id.into(),
expected_binding: binding.as_binding().short_name().to_string(),
request_binding: Some(binding.as_binding().short_name().to_string()),
acs_url: String::new(),
acs_binding: String::new(),
acs_index: None,
acs_is_default: false,
issued_at: None,
expires_at: None,
_message: PhantomData,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Pending<Message: PendingMessage> {
id: MessageId,
relay_state: RelayStateParam,
details: Message::Details,
peer_entity_id: EntityId,
issued_at: Option<SamlInstant>,
expires_at: Option<SamlInstant>,
_message: PhantomData<Message>,
}
pub type PendingAuthnRequest = Pending<AuthnRequest>;
pub type PendingLogoutRequest = Pending<LogoutRequest>;
impl<Message: PendingMessage> Pending<Message> {
pub(crate) fn with_local_lifetime(
mut self,
now: std::time::SystemTime,
lifetime: std::time::Duration,
) -> Result<Self, SamlError> {
let field = crate::error::TimeWindowField::PendingRequestExpiration;
if lifetime.is_zero() {
return Err(SamlError::TimeWindowInvalid { field });
}
let expires_at = now
.checked_add(lifetime)
.ok_or(SamlError::TimeWindowInvalid { field })?;
let now = crate::validator::offset_datetime_from_system_time(now)
.map_err(|_| SamlError::TimeWindowInvalid { field })?;
let expires_at = crate::validator::offset_datetime_from_system_time(expires_at)
.map_err(|_| SamlError::TimeWindowInvalid { field })?;
let serialize = |instant: time::OffsetDateTime| {
let seconds = crate::entity::format_saml_utc_date_time(instant);
SamlInstant::try_new(format!(
"{}.{:09}Z",
seconds.trim_end_matches('Z'),
instant.nanosecond()
))
};
if self.issued_at.is_none() {
self.issued_at = Some(serialize(now)?);
}
let existing = self.completion_deadline()?;
if existing.is_none_or(|deadline| deadline > expires_at) {
self.expires_at = Some(serialize(expires_at)?);
}
Ok(self)
}
fn validate_common(
relay_state: &RelayStateParam,
peer_entity_id: &EntityId,
) -> Result<(), SamlError> {
relay_state.validate()?;
EntityId::try_new(peer_entity_id.as_str().to_string())?;
Ok(())
}
fn validate_snapshot_timing(
issued_at: &Option<SamlInstant>,
expires_at: &Option<SamlInstant>,
) -> Result<(), SamlError> {
if expires_at.is_some() && issued_at.is_none() {
return Err(SamlError::Invalid(
"pending snapshot expiration requires an issue instant".into(),
));
}
Ok(())
}
pub fn with_issue_instant(mut self, issued_at: SamlInstant) -> Self {
self.issued_at = Some(issued_at);
self
}
pub fn with_expiration(mut self, expires_at: SamlInstant) -> Self {
self.expires_at = Some(expires_at);
self
}
pub fn id(&self) -> &MessageId {
&self.id
}
pub fn relay_state(&self) -> &RelayStateParam {
&self.relay_state
}
pub fn peer_entity_id(&self) -> &EntityId {
&self.peer_entity_id
}
pub fn issued_at(&self) -> Option<&SamlInstant> {
self.issued_at.as_ref()
}
pub fn expires_at(&self) -> Option<&SamlInstant> {
self.expires_at.as_ref()
}
pub(crate) fn validate_at(&self, now: std::time::SystemTime) -> Result<(), SamlError> {
let now = crate::validator::offset_datetime_from_system_time(now)?;
if let Some(deadline) = &self.expires_at {
let deadline = time::OffsetDateTime::parse(
deadline.as_str(),
&time::format_description::well_known::Rfc3339,
)
.map_err(|_| SamlError::TimeWindowInvalid {
field: crate::error::TimeWindowField::PendingRequestExpiration,
})?;
if now >= deadline {
return Err(SamlError::TimeWindowInvalid {
field: crate::error::TimeWindowField::PendingRequestExpiration,
});
}
}
Ok(())
}
pub(crate) fn completion_deadline(&self) -> Result<Option<time::OffsetDateTime>, SamlError> {
self.expires_at
.as_ref()
.map(|deadline| {
time::OffsetDateTime::parse(
deadline.as_str(),
&time::format_description::well_known::Rfc3339,
)
.map_err(|_| SamlError::TimeWindowInvalid {
field: crate::error::TimeWindowField::PendingRequestExpiration,
})
})
.transpose()
}
}
impl Pending<AuthnRequest> {
pub fn try_new(
request_id: MessageId,
relay_state: RelayStateParam,
acs: AcsEndpoint,
response_binding: SsoResponseBinding,
idp_entity_id: EntityId,
) -> Result<Self, SamlError> {
Self::validate_common(&relay_state, &idp_entity_id)?;
if acs.binding() != response_binding {
return Err(SamlError::Invalid(
"ACS binding must match expected response binding".into(),
));
}
Ok(Self {
id: request_id,
relay_state,
details: AuthnPendingDetails {
request_binding: None,
response_binding,
acs,
},
peer_entity_id: idp_entity_id,
issued_at: None,
expires_at: None,
_message: PhantomData,
})
}
pub fn with_request_binding(mut self, request_binding: SsoRequestBinding) -> Self {
self.details.request_binding = Some(request_binding);
self
}
pub fn from_snapshot(snapshot: PendingSnapshot<AuthnRequest>) -> Result<Self, SamlError> {
snapshot.relay_state.validate()?;
Self::validate_snapshot_timing(&snapshot.issued_at, &snapshot.expires_at)?;
let request_id = MessageId::try_new(snapshot.id)?;
let idp_entity_id = EntityId::try_new(snapshot.peer_entity_id)?;
let response_binding =
sso_response_binding_from_snapshot_value(&snapshot.expected_binding)?;
let acs_binding = sso_response_binding_from_snapshot_value(&snapshot.acs_binding)?;
let mut acs = AcsEndpoint::new(acs_binding, EndpointUrl::try_new(snapshot.acs_url)?)
.with_default_flag(snapshot.acs_is_default);
if let Some(index) = snapshot.acs_index {
acs = acs.with_index(index);
}
let request_binding = snapshot
.request_binding
.as_deref()
.map(sso_request_binding_from_snapshot_value)
.transpose()?;
let mut pending = Self::try_new(
request_id,
snapshot.relay_state,
acs,
response_binding,
idp_entity_id,
)?;
pending.details.request_binding = request_binding;
pending.issued_at = snapshot.issued_at;
pending.expires_at = snapshot.expires_at;
Ok(pending)
}
pub fn snapshot(&self) -> PendingSnapshot<AuthnRequest> {
let mut snapshot = PendingSnapshot::authn_request(
self.id.as_str(),
self.relay_state.clone(),
self.peer_entity_id.as_str(),
self.details.response_binding.as_binding().short_name(),
self.details.acs.location().as_str(),
self.details.acs.binding().as_binding().short_name(),
);
snapshot.request_binding = self
.details
.request_binding
.map(|binding| binding.as_binding().short_name().to_string());
snapshot.acs_index = self.details.acs.index();
snapshot.acs_is_default = self.details.acs.is_default();
snapshot.issued_at = self.issued_at.clone();
snapshot.expires_at = self.expires_at.clone();
snapshot
}
pub fn request_id(&self) -> &MessageId {
&self.id
}
pub fn request_binding(&self) -> Option<SsoRequestBinding> {
self.details.request_binding
}
pub fn response_binding(&self) -> SsoResponseBinding {
self.details.response_binding
}
pub fn acs(&self) -> &AcsEndpoint {
&self.details.acs
}
pub fn idp_entity_id(&self) -> &EntityId {
&self.peer_entity_id
}
}
impl Pending<LogoutRequest> {
pub fn try_new(
request_id: MessageId,
relay_state: RelayStateParam,
binding: LogoutBinding,
peer_entity_id: EntityId,
) -> Result<Self, SamlError> {
Self::validate_common(&relay_state, &peer_entity_id)?;
Ok(Self {
id: request_id,
relay_state,
details: LogoutPendingDetails { binding },
peer_entity_id,
issued_at: None,
expires_at: None,
_message: PhantomData,
})
}
pub fn from_snapshot(snapshot: PendingSnapshot<LogoutRequest>) -> Result<Self, SamlError> {
snapshot.relay_state.validate()?;
Self::validate_snapshot_timing(&snapshot.issued_at, &snapshot.expires_at)?;
let request_id = MessageId::try_new(snapshot.id)?;
let peer_entity_id = EntityId::try_new(snapshot.peer_entity_id)?;
let response_binding = logout_binding_from_snapshot_value(&snapshot.expected_binding)?;
let request_binding = snapshot
.request_binding
.as_deref()
.map(logout_binding_from_snapshot_value)
.transpose()?
.unwrap_or(response_binding);
if request_binding != response_binding {
return Err(SamlError::Invalid(
"logout request and response bindings must match".into(),
));
}
let mut pending = Self::try_new(
request_id,
snapshot.relay_state,
response_binding,
peer_entity_id,
)?;
pending.issued_at = snapshot.issued_at;
pending.expires_at = snapshot.expires_at;
Ok(pending)
}
pub fn snapshot(&self) -> PendingSnapshot<LogoutRequest> {
let mut snapshot = PendingSnapshot::logout_request(
self.id.as_str(),
self.relay_state.clone(),
self.peer_entity_id.as_str(),
self.details.binding,
);
snapshot.issued_at = self.issued_at.clone();
snapshot.expires_at = self.expires_at.clone();
snapshot
}
pub fn request_binding(&self) -> LogoutBinding {
self.details.binding
}
pub fn response_binding(&self) -> LogoutBinding {
self.details.binding
}
}
fn sso_response_binding_from_snapshot_value(value: &str) -> Result<SsoResponseBinding, SamlError> {
let binding = Binding::from_short_name(value)
.or_else(|| Binding::from_urn(value))
.ok_or(SamlError::UndefinedBinding)?;
SsoResponseBinding::try_from(binding)
}
fn sso_request_binding_from_snapshot_value(value: &str) -> Result<SsoRequestBinding, SamlError> {
let binding = Binding::from_short_name(value)
.or_else(|| Binding::from_urn(value))
.ok_or(SamlError::UndefinedBinding)?;
SsoRequestBinding::try_from(binding)
}
fn logout_binding_from_snapshot_value(value: &str) -> Result<LogoutBinding, SamlError> {
let binding = Binding::from_short_name(value)
.or_else(|| Binding::from_urn(value))
.ok_or(SamlError::UndefinedBinding)?;
LogoutBinding::try_from(binding)
}
#[derive(Debug, Clone)]
pub struct Started<Message: PendingMessage> {
pub pending: Pending<Message>,
pub outbound: Outbound<Message>,
}