Enum RelayStateParam 

pub enum RelayStateParam {
    Absent,
    PresentEmpty,
    PresentValue(RelayState),
}

RelayState represented as absent, present empty, or present with a value.

Variants

Absent

No RelayState parameter was sent.

PresentEmpty

RelayState was sent with an empty value.

PresentValue(RelayState)

RelayState was sent with a non-empty value.

Implementations

impl RelayStateParam

pub fn absent() -> Self

Construct an absent RelayState parameter.

pub fn present_empty() -> Self

Construct a present RelayState parameter with an empty value.

pub fn try_from_option( value: Option<impl Into<String>>, ) -> Result<Self, SamlError>

Preserve the exact RelayState presence state from optional caller input.

Errors

Returns SamlError::Invalid when a present non-empty value exceeds the SAML Bindings 80-byte RelayState limit.

Examples found in repository

examples/sso.rs (line 64)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    use saml_rs::{
        AcsEndpoint, AuthnRequest, BrowserInput, CertificatePem, Credentials, EntityId, IdpConfig,
        IdpDescriptor, IdpValidationPolicy, MetadataTrustPolicy, NameId, PrivateKeyPem,
        RelayStateParam, ReplayPolicy, RespondSso, Saml, SamlValidationContext, SpConfig,
        SpDescriptor, SpValidationPolicy, SsoEndpoint, SsoResponse, StartSso, Subject,
    };
    use std::time::SystemTime;

    let privkey = include_str!("../tests/fixtures/key/sp_privkey.pem");
    let cert = include_str!("../tests/fixtures/key/sp_signing_cert.cer");
    let credentials = || Credentials {
        signing_key: Some(PrivateKeyPem::new(privkey)),
        signing_certificate: Some(CertificatePem::new(cert)),
        ..Credentials::default()
    };
    // DisabledForCompatibility preserves the raw API, which has no replay cache.
    let validation =
        || SamlValidationContext::new(SystemTime::now(), ReplayPolicy::DisabledForCompatibility);

    let sp = Saml::sp(
        SpConfig::builder(EntityId::try_new("https://sp.example.com/metadata")?)
            .acs_endpoint(AcsEndpoint::post("https://sp.example.com/acs")?)
            .credentials(credentials())
            .validation(SpValidationPolicy::strict())
            .build()?,
    )?;
    let idp = Saml::idp(
        IdpConfig::builder(EntityId::try_new("https://idp.example.com/metadata")?)
            .sso_endpoint(SsoEndpoint::post("https://idp.example.com/sso")?)
            .credentials(credentials())
            .validation(IdpValidationPolicy::strict())
            .build()?,
    )?;

    let sp_descriptor = SpDescriptor::from_metadata_xml_for(
        EntityId::try_new("https://sp.example.com/metadata")?,
        sp.metadata_xml(),
        // UnsignedForCompatibility preserves an unsigned samlify-port metadata import.
        MetadataTrustPolicy::UnsignedForCompatibility,
    )?;
    let idp_descriptor = IdpDescriptor::from_metadata_xml_for(
        EntityId::try_new("https://idp.example.com/metadata")?,
        idp.metadata_xml(),
        // UnsignedForCompatibility preserves an unsigned samlify-port metadata import.
        MetadataTrustPolicy::UnsignedForCompatibility,
    )?;

    let relay_state = RelayStateParam::try_from_option(Some("demo-state".to_string()))?;
    let started = sp.start_sso(&idp_descriptor, StartSso::post().relay_state(relay_state))?;
    println!(
        "SP  -> AuthnRequest id = {}",
        started.pending.request_id().as_str()
    );

    let request = idp.receive_sso(
        &sp_descriptor,
        BrowserInput::<AuthnRequest>::post(started.outbound.post_form()?.fields().to_vec()),
        validation(),
    )?;
    println!(
        "IdP <- request issuer  = {}",
        request.message().issuer().as_str()
    );

    let response = idp.respond_sso(
        &sp_descriptor,
        &request,
        Subject::new(NameId::new("alice@example.com", None), Vec::new()),
        RespondSso::post(),
    )?;

    let session = sp.finish_sso(
        &idp_descriptor,
        &started.pending,
        BrowserInput::<SsoResponse>::post(response.post_form()?.fields().to_vec()),
        validation(),
    );
    let session = session?;
    println!("SP  <- authenticated   = {}", session.name_id().value());
    Ok(())
}

pub fn as_deref(&self) -> Option<&str>

Borrow RelayState as an optional value.

Trait Implementations

impl Clone for RelayStateParam

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RelayStateParam

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for RelayStateParam

impl Hash for RelayStateParam

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for RelayStateParam

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for RelayStateParam

impl TryFrom<Option<String>> for RelayStateParam

type Error = SamlError

The type returned in the event of a conversion error.

fn try_from(value: Option<String>) -> Result<Self, Self::Error>

Performs the conversion.