Skip to main content

auth_framework/protocols/
ws_trust.rs

1//! WS-Trust 1.3 Security Token Service (STS) Support
2//!
3//! This module provides WS-Trust 1.3 Security Token Service functionality for token exchange,
4//! issuance, and validation scenarios.
5
6use crate::errors::{AuthError, Result};
7use crate::protocols::saml_assertions::SamlAssertionBuilder;
8// SamlAssertion removed from import - not currently used but may be needed later
9use crate::protocols::ws_security::{PasswordType, WsSecurityClient, WsSecurityConfig};
10use base64::Engine as _;
11use chrono::{DateTime, Duration, Utc};
12use jsonwebtoken::{Algorithm, EncodingKey, Header, encode as jwt_encode};
13use serde::{Deserialize, Serialize};
14use std::collections::HashMap;
15use zeroize::Zeroizing;
16
17/// WS-Trust Security Token Service
18///
19/// **Note:** Issued tokens are stored in an in-memory `HashMap`. They will be
20/// lost on restart and are not shared across STS instances. For production
21/// multi-instance deployments, integrate with the `StorageBackend` KV store
22/// for persistent/shared token state.
23pub struct SecurityTokenService {
24    /// STS configuration
25    config: StsConfig,
26
27    /// WS-Security client for generating secure headers
28    ws_security: WsSecurityClient,
29
30    /// Issued tokens cache
31    issued_tokens: HashMap<String, IssuedToken>,
32}
33
34/// STS Configuration
35#[derive(Debug, Clone)]
36pub struct StsConfig {
37    /// STS issuer identifier
38    pub issuer: String,
39
40    /// Default token lifetime
41    pub default_token_lifetime: Duration,
42
43    /// Maximum token lifetime
44    pub max_token_lifetime: Duration,
45
46    /// Supported token types
47    pub supported_token_types: Vec<String>,
48
49    /// STS endpoint URL
50    pub endpoint_url: String,
51
52    /// Whether to include proof tokens
53    pub include_proof_tokens: bool,
54
55    /// Trust relationships
56    pub trust_relationships: Vec<TrustRelationship>,
57
58    /// HMAC-HS256 signing secret used when issuing JWT tokens.
59    ///
60    /// **Must be set to a strong, randomly-generated value in production.**
61    /// `StsConfig::default()` generates a cryptographically random secret
62    /// automatically; override this field when you need a stable / shared
63    /// signing key (e.g. for multi-node deployments that share the same
64    /// validator).
65    pub jwt_signing_secret: Zeroizing<String>,
66}
67
68/// Trust relationship with relying parties
69#[derive(Debug, Clone)]
70pub struct TrustRelationship {
71    /// Relying party identifier
72    pub rp_identifier: String,
73
74    /// Certificate for encryption/signing
75    pub certificate: Option<Vec<u8>>,
76
77    /// Allowed token types
78    pub allowed_token_types: Vec<String>,
79
80    /// Maximum token lifetime for this RP
81    pub max_token_lifetime: Option<Duration>,
82}
83
84/// Issued token information
85#[derive(Debug, Clone, Serialize, Deserialize)]
86pub struct IssuedToken {
87    /// Token ID
88    pub token_id: String,
89
90    /// Token type
91    pub token_type: String,
92
93    /// Token content (SAML assertion, JWT, etc.)
94    pub token_content: String,
95
96    /// Issue time
97    pub issued_at: DateTime<Utc>,
98
99    /// Expiration time
100    pub expires_at: DateTime<Utc>,
101
102    /// Subject identifier
103    pub subject: String,
104
105    /// Audience/relying party
106    pub audience: String,
107
108    /// Proof token (if any)
109    pub proof_token: Option<ProofToken>,
110}
111
112/// Proof token for holder-of-key scenarios
113#[derive(Debug, Clone, Serialize, Deserialize)]
114pub struct ProofToken {
115    /// Proof token type (symmetric key, certificate, etc.)
116    pub token_type: String,
117
118    /// Key material
119    pub key_material: Vec<u8>,
120
121    /// Key identifier
122    pub key_identifier: String,
123}
124
125/// WS-Trust Request Security Token (RST)
126#[derive(Debug, Clone, Serialize, Deserialize)]
127pub struct RequestSecurityToken {
128    /// Request type (Issue, Renew, Cancel, Validate)
129    pub request_type: String,
130
131    /// Token type being requested
132    pub token_type: String,
133
134    /// Applies to (target service/audience)
135    pub applies_to: Option<String>,
136
137    /// Lifetime requirements
138    pub lifetime: Option<TokenLifetime>,
139
140    /// Key type (Bearer, Symmetric, Asymmetric)
141    pub key_type: Option<String>,
142
143    /// Key size for symmetric keys
144    pub key_size: Option<u32>,
145
146    /// Existing token (for renew/validate operations)
147    pub existing_token: Option<String>,
148
149    /// Authentication context
150    pub auth_context: Option<AuthenticationContext>,
151}
152
153/// Token lifetime specification
154#[derive(Debug, Clone, Serialize, Deserialize)]
155pub struct TokenLifetime {
156    /// Created time
157    pub created: DateTime<Utc>,
158
159    /// Expires time
160    pub expires: DateTime<Utc>,
161}
162
163/// Authentication context for token requests
164#[derive(Debug, Clone, Serialize, Deserialize)]
165pub struct AuthenticationContext {
166    /// Username
167    pub username: String,
168
169    /// Authentication method
170    pub auth_method: String,
171
172    /// Additional claims
173    pub claims: HashMap<String, String>,
174}
175
176/// WS-Trust Request Security Token Response (RSTR)
177#[derive(Debug, Clone, Serialize, Deserialize)]
178pub struct RequestSecurityTokenResponse {
179    /// Request type being responded to
180    pub request_type: String,
181
182    /// Token type issued
183    pub token_type: String,
184
185    /// Lifetime of issued token
186    pub lifetime: TokenLifetime,
187
188    /// Applies to (target audience)
189    pub applies_to: Option<String>,
190
191    /// Requested security token
192    pub requested_security_token: String,
193
194    /// Requested proof token
195    pub requested_proof_token: Option<ProofToken>,
196
197    /// Token reference for future operations
198    pub requested_attached_reference: Option<String>,
199
200    /// Token reference for external use
201    pub requested_unattached_reference: Option<String>,
202}
203
204impl SecurityTokenService {
205    /// Create a new Security Token Service
206    pub fn new(config: StsConfig) -> Self {
207        let ws_security_config = WsSecurityConfig::default();
208        let ws_security = WsSecurityClient::new(ws_security_config);
209
210        Self {
211            config,
212            ws_security,
213            issued_tokens: HashMap::new(),
214        }
215    }
216
217    /// Process a WS-Trust Request Security Token
218    pub fn process_request(
219        &mut self,
220        request: RequestSecurityToken,
221    ) -> Result<RequestSecurityTokenResponse> {
222        match request.request_type.as_str() {
223            "http://docs.oasis-open.org/ws-sx/ws-trust/200512/Issue" => self.issue_token(request),
224            "http://docs.oasis-open.org/ws-sx/ws-trust/200512/Renew" => self.renew_token(request),
225            "http://docs.oasis-open.org/ws-sx/ws-trust/200512/Cancel" => self.cancel_token(request),
226            "http://docs.oasis-open.org/ws-sx/ws-trust/200512/Validate" => {
227                self.validate_token(request)
228            }
229            _ => Err(AuthError::auth_method(
230                "wstrust",
231                "Unsupported request type",
232            )),
233        }
234    }
235
236    /// Issue a new security token
237    fn issue_token(
238        &mut self,
239        request: RequestSecurityToken,
240    ) -> Result<RequestSecurityTokenResponse> {
241        // Validate authentication context
242        let auth_context = request
243            .auth_context
244            .as_ref()
245            .ok_or_else(|| AuthError::auth_method("wstrust", "Authentication context required"))?;
246
247        // Determine token lifetime
248        let now = Utc::now();
249        let lifetime = if let Some(ref requested_lifetime) = request.lifetime {
250            // Validate requested lifetime
251            let max_expires = now + self.config.max_token_lifetime;
252            let expires = if requested_lifetime.expires > max_expires {
253                max_expires
254            } else {
255                requested_lifetime.expires
256            };
257
258            TokenLifetime {
259                created: now,
260                expires,
261            }
262        } else {
263            TokenLifetime {
264                created: now,
265                expires: now + self.config.default_token_lifetime,
266            }
267        };
268
269        // Generate token based on type
270        let token_content = match request.token_type.as_str() {
271            "urn:oasis:names:tc:SAML:2.0:assertion" => {
272                self.issue_saml_token(auth_context, &request, &lifetime)?
273            }
274            "urn:ietf:params:oauth:token-type:jwt" => {
275                self.issue_jwt_token(auth_context, &request, &lifetime)?
276            }
277            _ => {
278                return Err(AuthError::auth_method("wstrust", "Unsupported token type"));
279            }
280        };
281
282        // Generate proof token if required
283        let proof_token = if self.config.include_proof_tokens
284            && request.key_type.as_deref()
285                == Some("http://docs.oasis-open.org/ws-sx/ws-trust/200512/SymmetricKey")
286        {
287            Some(self.generate_proof_token()?)
288        } else {
289            None
290        };
291
292        // Store issued token
293        let token_id = format!("token-{}", uuid::Uuid::new_v4());
294        let issued_token = IssuedToken {
295            token_id: token_id.clone(),
296            token_type: request.token_type.clone(),
297            token_content: token_content.clone(),
298            issued_at: lifetime.created,
299            expires_at: lifetime.expires,
300            subject: auth_context.username.clone(),
301            audience: request.applies_to.clone().unwrap_or_default(),
302            proof_token: proof_token.clone(),
303        };
304
305        self.issued_tokens.insert(token_id.clone(), issued_token);
306
307        Ok(RequestSecurityTokenResponse {
308            request_type: request.request_type,
309            token_type: request.token_type,
310            lifetime,
311            applies_to: request.applies_to,
312            requested_security_token: token_content,
313            requested_proof_token: proof_token,
314            requested_attached_reference: Some(format!("#{}", token_id)),
315            requested_unattached_reference: Some(token_id),
316        })
317    }
318
319    /// Issue a SAML 2.0 assertion token
320    fn issue_saml_token(
321        &self,
322        auth_context: &AuthenticationContext,
323        request: &RequestSecurityToken,
324        lifetime: &TokenLifetime,
325    ) -> Result<String> {
326        let mut assertion_builder = SamlAssertionBuilder::new(&self.config.issuer)
327            .with_validity_period(lifetime.created, lifetime.expires)
328            .with_attribute("username", &auth_context.username)
329            .with_attribute("auth_method", &auth_context.auth_method);
330
331        // Add audience if specified
332        if let Some(ref audience) = request.applies_to {
333            assertion_builder = assertion_builder.with_audience(audience);
334        }
335
336        // Add additional claims as attributes
337        for (key, value) in &auth_context.claims {
338            assertion_builder = assertion_builder.with_attribute(key, value);
339        }
340
341        let assertion = assertion_builder.build();
342        assertion.to_xml()
343    }
344
345    /// Issue a JWT token signed with HMAC-HS256 using `StsConfig::jwt_signing_secret`.
346    fn issue_jwt_token(
347        &self,
348        auth_context: &AuthenticationContext,
349        request: &RequestSecurityToken,
350        lifetime: &TokenLifetime,
351    ) -> Result<String> {
352        #[derive(Serialize)]
353        struct WsTrustClaims<'a> {
354            iss: &'a str,
355            sub: &'a str,
356            aud: &'a str,
357            iat: i64,
358            exp: i64,
359            auth_method: &'a str,
360            #[serde(skip_serializing_if = "std::collections::HashMap::is_empty")]
361            claims: &'a HashMap<String, String>,
362        }
363
364        let jwt_claims = WsTrustClaims {
365            iss: &self.config.issuer,
366            sub: &auth_context.username,
367            aud: request.applies_to.as_deref().unwrap_or(""),
368            iat: lifetime.created.timestamp(),
369            exp: lifetime.expires.timestamp(),
370            auth_method: &auth_context.auth_method,
371            claims: &auth_context.claims,
372        };
373
374        let encoding_key = EncodingKey::from_secret(self.config.jwt_signing_secret.as_bytes());
375
376        jwt_encode(&Header::new(Algorithm::HS256), &jwt_claims, &encoding_key)
377            .map_err(|e| AuthError::internal(format!("WS-Trust JWT signing failed: {e}")))
378    }
379
380    /// Generate a proof token for holder-of-key scenarios
381    fn generate_proof_token(&self) -> Result<ProofToken> {
382        use rand::Rng;
383        let mut rng = rand::rng();
384        let mut key_material = vec![0u8; 32]; // 256-bit symmetric key
385        rng.fill_bytes(&mut key_material);
386
387        Ok(ProofToken {
388            token_type: "SymmetricKey".to_string(),
389            key_material,
390            key_identifier: format!("key-{}", uuid::Uuid::new_v4()),
391        })
392    }
393
394    /// Renew an existing token
395    fn renew_token(
396        &mut self,
397        request: RequestSecurityToken,
398    ) -> Result<RequestSecurityTokenResponse> {
399        let existing_token = request.existing_token.ok_or_else(|| {
400            AuthError::auth_method("wstrust", "Existing token required for renewal")
401        })?;
402
403        // Find the token — try direct lookup first, then attempt JWT parsing
404        // to extract claims from the existing token if it looks like a JWT.
405        let mut renewal_claims = HashMap::new();
406        let token_id = if existing_token.matches('.').count() == 2 {
407            // Token looks like a JWT — extract claims from payload
408            if let Some(payload_b64) = existing_token.split('.').nth(1) {
409                if let Ok(payload_bytes) = base64::engine::general_purpose::URL_SAFE_NO_PAD
410                    .decode(payload_b64)
411                    .or_else(|_| base64::engine::general_purpose::STANDARD.decode(payload_b64))
412                {
413                    if let Ok(claims) =
414                        serde_json::from_slice::<HashMap<String, serde_json::Value>>(&payload_bytes)
415                    {
416                        for (k, v) in &claims {
417                            if let Some(s) = v.as_str() {
418                                renewal_claims.insert(k.clone(), s.to_string());
419                            }
420                        }
421                        // Use "jti" or "sub" as token ID for lookup
422                        claims
423                            .get("jti")
424                            .or_else(|| claims.get("sub"))
425                            .and_then(|v| v.as_str())
426                            .unwrap_or(&existing_token)
427                            .to_string()
428                    } else {
429                        existing_token.clone()
430                    }
431                } else {
432                    existing_token.clone()
433                }
434            } else {
435                existing_token.clone()
436            }
437        } else {
438            existing_token.clone()
439        };
440
441        let issued_token = self
442            .issued_tokens
443            .get(&token_id)
444            .ok_or_else(|| AuthError::auth_method("wstrust", "Token not found"))?;
445
446        // Check if token is still valid
447        let now = Utc::now();
448        if now >= issued_token.expires_at {
449            return Err(AuthError::auth_method("wstrust", "Token has expired"));
450        }
451
452        // Create renewed token with new lifetime
453        let new_lifetime = TokenLifetime {
454            created: now,
455            expires: now + self.config.default_token_lifetime,
456        };
457
458        // Issue new token (carry forward original claims where available)
459        let auth_context = AuthenticationContext {
460            username: issued_token.subject.clone(),
461            auth_method: "token_renewal".to_string(),
462            claims: if renewal_claims.is_empty() {
463                HashMap::new()
464            } else {
465                renewal_claims
466            },
467        };
468
469        let new_request = RequestSecurityToken {
470            request_type: "http://docs.oasis-open.org/ws-sx/ws-trust/200512/Issue".to_string(),
471            token_type: issued_token.token_type.clone(),
472            applies_to: Some(issued_token.audience.clone()),
473            lifetime: Some(new_lifetime.clone()),
474            key_type: None,
475            key_size: None,
476            existing_token: None,
477            auth_context: Some(auth_context),
478        };
479
480        self.issue_token(new_request)
481    }
482
483    /// Cancel an existing token
484    fn cancel_token(
485        &mut self,
486        request: RequestSecurityToken,
487    ) -> Result<RequestSecurityTokenResponse> {
488        let existing_token = request
489            .existing_token
490            .ok_or_else(|| AuthError::auth_method("wstrust", "Token required for cancellation"))?;
491
492        // Remove token from cache
493        self.issued_tokens.remove(&existing_token);
494
495        Ok(RequestSecurityTokenResponse {
496            request_type: request.request_type,
497            token_type: "Cancelled".to_string(),
498            lifetime: TokenLifetime {
499                created: Utc::now(),
500                expires: Utc::now(),
501            },
502            applies_to: None,
503            requested_security_token: "Token cancelled".to_string(),
504            requested_proof_token: None,
505            requested_attached_reference: None,
506            requested_unattached_reference: None,
507        })
508    }
509
510    /// Validate an existing token
511    fn validate_token(
512        &self,
513        request: RequestSecurityToken,
514    ) -> Result<RequestSecurityTokenResponse> {
515        let existing_token = request
516            .existing_token
517            .ok_or_else(|| AuthError::auth_method("wstrust", "Token required for validation"))?;
518
519        // Find and validate token
520        let token_id = existing_token;
521        let issued_token = self
522            .issued_tokens
523            .get(&token_id)
524            .ok_or_else(|| AuthError::auth_method("wstrust", "Token not found"))?;
525
526        let now = Utc::now();
527        let is_valid = now < issued_token.expires_at;
528
529        let status = if is_valid { "Valid" } else { "Invalid" };
530
531        Ok(RequestSecurityTokenResponse {
532            request_type: request.request_type,
533            token_type: "ValidationResponse".to_string(),
534            lifetime: TokenLifetime {
535                created: issued_token.issued_at,
536                expires: issued_token.expires_at,
537            },
538            applies_to: Some(issued_token.audience.clone()),
539            requested_security_token: status.to_string(),
540            requested_proof_token: None,
541            requested_attached_reference: None,
542            requested_unattached_reference: None,
543        })
544    }
545
546    /// Create a complete WS-Trust SOAP request
547    pub fn create_rst_soap_request(
548        &self,
549        request: &RequestSecurityToken,
550        username: &str,
551        password: Option<&str>,
552    ) -> Result<String> {
553        let header = self.ws_security.create_username_token_header(
554            username,
555            password,
556            PasswordType::PasswordText,
557        )?;
558
559        let security_header = self.ws_security.header_to_xml(&header)?;
560
561        let soap_request = format!(
562            r#"<?xml version="1.0" encoding="UTF-8"?>
563<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
564               xmlns:wst="http://docs.oasis-open.org/ws-sx/ws-trust/200512"
565               xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">
566    <soap:Header>
567        {}
568    </soap:Header>
569    <soap:Body>
570        <wst:RequestSecurityToken>
571            <wst:RequestType>{}</wst:RequestType>
572            <wst:TokenType>{}</wst:TokenType>
573            {}
574            {}
575            {}
576        </wst:RequestSecurityToken>
577    </soap:Body>
578</soap:Envelope>"#,
579            security_header,
580            request.request_type,
581            request.token_type,
582            request.applies_to.as_ref().map(|a| format!("<wsp:AppliesTo><wsp:EndpointReference><wsp:Address>{}</wsp:Address></wsp:EndpointReference></wsp:AppliesTo>", a)).unwrap_or_default(),
583            request.lifetime.as_ref().map(|l| format!("<wst:Lifetime><wsu:Created>{}</wsu:Created><wsu:Expires>{}</wsu:Expires></wst:Lifetime>",
584                l.created.format("%Y-%m-%dT%H:%M:%S%.3fZ"),
585                l.expires.format("%Y-%m-%dT%H:%M:%S%.3fZ"))).unwrap_or_default(),
586            request.key_type.as_ref().map(|k| format!("<wst:KeyType>{}</wst:KeyType>", k)).unwrap_or_default()
587        );
588
589        Ok(soap_request)
590    }
591}
592
593impl Default for StsConfig {
594    fn default() -> Self {
595        use ring::rand::{SecureRandom, SystemRandom};
596        // SAFETY: CSPRNG failure at initialization is terminal; the framework
597        // cannot operate without entropy.
598        let rng = SystemRandom::new();
599        let mut bytes = [0u8; 32];
600        rng.fill(&mut bytes)
601            .expect("AuthFramework fatal: system CSPRNG unavailable — the operating system cannot provide cryptographic randomness");
602        let jwt_signing_secret = bytes.iter().fold(String::with_capacity(64), |mut s, b| {
603            s.push_str(&format!("{b:02x}"));
604            s
605        });
606
607        Self {
608            issuer: "https://sts.example.com".to_string(),
609            default_token_lifetime: Duration::hours(1),
610            max_token_lifetime: Duration::hours(8),
611            supported_token_types: vec![
612                "urn:oasis:names:tc:SAML:2.0:assertion".to_string(),
613                "urn:ietf:params:oauth:token-type:jwt".to_string(),
614            ],
615            endpoint_url: "https://sts.example.com/trust".to_string(),
616            include_proof_tokens: false,
617            trust_relationships: Vec::new(),
618            jwt_signing_secret: jwt_signing_secret.into(),
619        }
620    }
621}
622
623#[cfg(test)]
624mod tests {
625    use super::*;
626
627    #[test]
628    fn test_sts_issue_saml_token() {
629        let config = StsConfig::default();
630        let mut sts = SecurityTokenService::new(config);
631
632        let auth_context = AuthenticationContext {
633            username: "testuser".to_string(),
634            auth_method: "password".to_string(),
635            claims: {
636                let mut claims = HashMap::new();
637                claims.insert("role".to_string(), "admin".to_string());
638                claims
639            },
640        };
641
642        let request = RequestSecurityToken {
643            request_type: "http://docs.oasis-open.org/ws-sx/ws-trust/200512/Issue".to_string(),
644            token_type: "urn:oasis:names:tc:SAML:2.0:assertion".to_string(),
645            applies_to: Some("https://rp.example.com".to_string()),
646            lifetime: None,
647            key_type: None,
648            key_size: None,
649            existing_token: None,
650            auth_context: Some(auth_context),
651        };
652
653        let response = sts.process_request(request).unwrap();
654
655        assert_eq!(response.token_type, "urn:oasis:names:tc:SAML:2.0:assertion");
656        assert!(
657            response
658                .requested_security_token
659                .contains("<saml:Assertion")
660        );
661        assert!(response.requested_security_token.contains("testuser"));
662    }
663
664    #[test]
665    fn test_sts_issue_jwt_token() {
666        use jsonwebtoken::{Algorithm, DecodingKey, Validation, decode as jwt_decode};
667
668        let config = StsConfig::default();
669        let signing_secret = config.jwt_signing_secret.clone();
670        let mut sts = SecurityTokenService::new(config);
671
672        let auth_context = AuthenticationContext {
673            username: "testuser".to_string(),
674            auth_method: "certificate".to_string(),
675            claims: HashMap::new(),
676        };
677
678        let request = RequestSecurityToken {
679            request_type: "http://docs.oasis-open.org/ws-sx/ws-trust/200512/Issue".to_string(),
680            token_type: "urn:ietf:params:oauth:token-type:jwt".to_string(),
681            applies_to: Some("https://api.example.com".to_string()),
682            lifetime: None,
683            key_type: None,
684            key_size: None,
685            existing_token: None,
686            auth_context: Some(auth_context),
687        };
688
689        let response = sts.process_request(request).unwrap();
690
691        assert_eq!(response.token_type, "urn:ietf:params:oauth:token-type:jwt");
692
693        // Verify the issued JWT has exactly 3 Base64URL parts.
694        let parts: Vec<&str> = response.requested_security_token.split('.').collect();
695        assert_eq!(parts.len(), 3, "JWT must have header.payload.signature");
696
697        // Verify the signature is valid by decoding with the same secret.
698        let decoding_key = DecodingKey::from_secret(signing_secret.as_bytes());
699        let mut validation = Validation::new(Algorithm::HS256);
700        validation.set_audience(&["https://api.example.com"]);
701        let token_data = jwt_decode::<serde_json::Value>(
702            &response.requested_security_token,
703            &decoding_key,
704            &validation,
705        )
706        .expect("Issued WS-Trust JWT must be verifiable with the config signing secret");
707        assert_eq!(token_data.claims["sub"], "testuser");
708        assert_eq!(token_data.claims["auth_method"], "certificate");
709    }
710
711    #[test]
712    fn test_sts_soap_request_generation() {
713        let config = StsConfig::default();
714        let sts = SecurityTokenService::new(config);
715
716        let request = RequestSecurityToken {
717            request_type: "http://docs.oasis-open.org/ws-sx/ws-trust/200512/Issue".to_string(),
718            token_type: "urn:oasis:names:tc:SAML:2.0:assertion".to_string(),
719            applies_to: Some("https://rp.example.com".to_string()),
720            lifetime: None,
721            key_type: Some("http://docs.oasis-open.org/ws-sx/ws-trust/200512/Bearer".to_string()),
722            key_size: None,
723            existing_token: None,
724            auth_context: None,
725        };
726
727        let soap_request = sts
728            .create_rst_soap_request(&request, "test_user", Some("test_pass"))
729            .unwrap();
730
731        assert!(soap_request.contains("<soap:Envelope"));
732        assert!(soap_request.contains("<wsse:Security"));
733        assert!(soap_request.contains("<wst:RequestSecurityToken"));
734        assert!(soap_request.contains("https://rp.example.com"));
735        assert!(soap_request.contains("</soap:Envelope>"));
736    }
737
738    #[test]
739    fn test_unsupported_request_type() {
740        let mut sts = SecurityTokenService::new(StsConfig::default());
741
742        let request = RequestSecurityToken {
743            request_type: "http://invalid/BadRequest".to_string(),
744            token_type: "urn:oasis:names:tc:SAML:2.0:assertion".to_string(),
745            applies_to: None,
746            lifetime: None,
747            key_type: None,
748            key_size: None,
749            existing_token: None,
750            auth_context: None,
751        };
752
753        let err = sts.process_request(request).unwrap_err();
754        let msg = format!("{err}");
755        assert!(msg.contains("Unsupported request type"), "got: {msg}");
756    }
757
758    #[test]
759    fn test_issue_missing_auth_context() {
760        let mut sts = SecurityTokenService::new(StsConfig::default());
761
762        let request = RequestSecurityToken {
763            request_type: "http://docs.oasis-open.org/ws-sx/ws-trust/200512/Issue".to_string(),
764            token_type: "urn:oasis:names:tc:SAML:2.0:assertion".to_string(),
765            applies_to: None,
766            lifetime: None,
767            key_type: None,
768            key_size: None,
769            existing_token: None,
770            auth_context: None,
771        };
772
773        let err = sts.process_request(request).unwrap_err();
774        let msg = format!("{err}");
775        assert!(
776            msg.contains("Authentication context required"),
777            "got: {msg}"
778        );
779    }
780
781    #[test]
782    fn test_issue_unsupported_token_type() {
783        let mut sts = SecurityTokenService::new(StsConfig::default());
784
785        let request = RequestSecurityToken {
786            request_type: "http://docs.oasis-open.org/ws-sx/ws-trust/200512/Issue".to_string(),
787            token_type: "urn:unknown:token:type".to_string(),
788            applies_to: None,
789            lifetime: None,
790            key_type: None,
791            key_size: None,
792            existing_token: None,
793            auth_context: Some(AuthenticationContext {
794                username: "user".to_string(),
795                auth_method: "password".to_string(),
796                claims: HashMap::new(),
797            }),
798        };
799
800        let err = sts.process_request(request).unwrap_err();
801        let msg = format!("{err}");
802        assert!(msg.contains("Unsupported token type"), "got: {msg}");
803    }
804
805    #[test]
806    fn test_lifetime_clamped_to_max() {
807        let config = StsConfig {
808            max_token_lifetime: Duration::hours(2),
809            ..Default::default()
810        };
811        let mut sts = SecurityTokenService::new(config);
812
813        let now = Utc::now();
814        let request = RequestSecurityToken {
815            request_type: "http://docs.oasis-open.org/ws-sx/ws-trust/200512/Issue".to_string(),
816            token_type: "urn:ietf:params:oauth:token-type:jwt".to_string(),
817            applies_to: Some("https://rp.example.com".to_string()),
818            lifetime: Some(TokenLifetime {
819                created: now,
820                expires: now + Duration::hours(999), // way beyond max
821            }),
822            key_type: None,
823            key_size: None,
824            existing_token: None,
825            auth_context: Some(AuthenticationContext {
826                username: "user".to_string(),
827                auth_method: "password".to_string(),
828                claims: HashMap::new(),
829            }),
830        };
831
832        let resp = sts.process_request(request).unwrap();
833        // Expires must be clamped to ~2 h from now, not 999 h
834        let delta = resp.lifetime.expires - now;
835        assert!(
836            delta <= Duration::hours(2) + Duration::seconds(5),
837            "lifetime should be clamped to max_token_lifetime, got {delta}"
838        );
839    }
840
841    #[test]
842    fn test_cancel_nonexistent_token() {
843        let mut sts = SecurityTokenService::new(StsConfig::default());
844
845        let request = RequestSecurityToken {
846            request_type: "http://docs.oasis-open.org/ws-sx/ws-trust/200512/Cancel".to_string(),
847            token_type: "".to_string(),
848            applies_to: None,
849            lifetime: None,
850            key_type: None,
851            key_size: None,
852            existing_token: Some("nonexistent-id".to_string()),
853            auth_context: None,
854        };
855
856        // Cancel of a non-existent token should succeed silently (idempotent)
857        let resp = sts.process_request(request).unwrap();
858        assert_eq!(resp.requested_security_token, "Token cancelled");
859    }
860
861    #[test]
862    fn test_cancel_missing_existing_token_field() {
863        let mut sts = SecurityTokenService::new(StsConfig::default());
864
865        let request = RequestSecurityToken {
866            request_type: "http://docs.oasis-open.org/ws-sx/ws-trust/200512/Cancel".to_string(),
867            token_type: "".to_string(),
868            applies_to: None,
869            lifetime: None,
870            key_type: None,
871            key_size: None,
872            existing_token: None, // missing
873            auth_context: None,
874        };
875
876        let err = sts.process_request(request).unwrap_err();
877        let msg = format!("{err}");
878        assert!(
879            msg.contains("Token required for cancellation"),
880            "got: {msg}"
881        );
882    }
883
884    #[test]
885    fn test_validate_nonexistent_token() {
886        let mut sts = SecurityTokenService::new(StsConfig::default());
887
888        let request = RequestSecurityToken {
889            request_type: "http://docs.oasis-open.org/ws-sx/ws-trust/200512/Validate".to_string(),
890            token_type: "".to_string(),
891            applies_to: None,
892            lifetime: None,
893            key_type: None,
894            key_size: None,
895            existing_token: Some("does-not-exist".to_string()),
896            auth_context: None,
897        };
898
899        let err = sts.process_request(request).unwrap_err();
900        let msg = format!("{err}");
901        assert!(msg.contains("Token not found"), "got: {msg}");
902    }
903
904    #[test]
905    fn test_renew_missing_existing_token() {
906        let mut sts = SecurityTokenService::new(StsConfig::default());
907
908        let request = RequestSecurityToken {
909            request_type: "http://docs.oasis-open.org/ws-sx/ws-trust/200512/Renew".to_string(),
910            token_type: "".to_string(),
911            applies_to: None,
912            lifetime: None,
913            key_type: None,
914            key_size: None,
915            existing_token: None, // missing
916            auth_context: None,
917        };
918
919        let err = sts.process_request(request).unwrap_err();
920        let msg = format!("{err}");
921        assert!(
922            msg.contains("Existing token required for renewal"),
923            "got: {msg}"
924        );
925    }
926
927    #[test]
928    fn test_issue_with_proof_token_symmetric_key() {
929        let config = StsConfig {
930            include_proof_tokens: true,
931            ..Default::default()
932        };
933        let mut sts = SecurityTokenService::new(config);
934
935        let request = RequestSecurityToken {
936            request_type: "http://docs.oasis-open.org/ws-sx/ws-trust/200512/Issue".to_string(),
937            token_type: "urn:ietf:params:oauth:token-type:jwt".to_string(),
938            applies_to: Some("https://rp.example.com".to_string()),
939            lifetime: None,
940            key_type: Some(
941                "http://docs.oasis-open.org/ws-sx/ws-trust/200512/SymmetricKey".to_string(),
942            ),
943            key_size: None,
944            existing_token: None,
945            auth_context: Some(AuthenticationContext {
946                username: "keyuser".to_string(),
947                auth_method: "certificate".to_string(),
948                claims: HashMap::new(),
949            }),
950        };
951
952        let resp = sts.process_request(request).unwrap();
953        let proof = resp
954            .requested_proof_token
955            .expect("proof token should be present for symmetric key request");
956        assert_eq!(proof.token_type, "SymmetricKey");
957        assert_eq!(proof.key_material.len(), 32); // 256-bit key
958        assert!(proof.key_identifier.starts_with("key-"));
959    }
960
961    #[test]
962    fn test_issue_and_validate_roundtrip() {
963        let mut sts = SecurityTokenService::new(StsConfig::default());
964
965        // Issue
966        let issue_req = RequestSecurityToken {
967            request_type: "http://docs.oasis-open.org/ws-sx/ws-trust/200512/Issue".to_string(),
968            token_type: "urn:ietf:params:oauth:token-type:jwt".to_string(),
969            applies_to: Some("https://rp.example.com".to_string()),
970            lifetime: None,
971            key_type: None,
972            key_size: None,
973            existing_token: None,
974            auth_context: Some(AuthenticationContext {
975                username: "roundtrip_user".to_string(),
976                auth_method: "password".to_string(),
977                claims: HashMap::new(),
978            }),
979        };
980
981        let issue_resp = sts.process_request(issue_req).unwrap();
982        let token_id = issue_resp
983            .requested_unattached_reference
984            .expect("token id should be returned");
985
986        // Validate
987        let validate_req = RequestSecurityToken {
988            request_type: "http://docs.oasis-open.org/ws-sx/ws-trust/200512/Validate".to_string(),
989            token_type: "".to_string(),
990            applies_to: None,
991            lifetime: None,
992            key_type: None,
993            key_size: None,
994            existing_token: Some(token_id),
995            auth_context: None,
996        };
997
998        let validate_resp = sts.process_request(validate_req).unwrap();
999        assert_eq!(validate_resp.requested_security_token, "Valid");
1000        assert_eq!(
1001            validate_resp.applies_to.as_deref(),
1002            Some("https://rp.example.com")
1003        );
1004    }
1005
1006    #[test]
1007    fn test_issue_and_cancel_then_validate_fails() {
1008        let mut sts = SecurityTokenService::new(StsConfig::default());
1009
1010        // Issue
1011        let issue_req = RequestSecurityToken {
1012            request_type: "http://docs.oasis-open.org/ws-sx/ws-trust/200512/Issue".to_string(),
1013            token_type: "urn:oasis:names:tc:SAML:2.0:assertion".to_string(),
1014            applies_to: None,
1015            lifetime: None,
1016            key_type: None,
1017            key_size: None,
1018            existing_token: None,
1019            auth_context: Some(AuthenticationContext {
1020                username: "cancelme".to_string(),
1021                auth_method: "password".to_string(),
1022                claims: HashMap::new(),
1023            }),
1024        };
1025
1026        let issue_resp = sts.process_request(issue_req).unwrap();
1027        let token_id = issue_resp
1028            .requested_unattached_reference
1029            .expect("should have token id");
1030
1031        // Cancel
1032        let cancel_req = RequestSecurityToken {
1033            request_type: "http://docs.oasis-open.org/ws-sx/ws-trust/200512/Cancel".to_string(),
1034            token_type: "".to_string(),
1035            applies_to: None,
1036            lifetime: None,
1037            key_type: None,
1038            key_size: None,
1039            existing_token: Some(token_id.clone()),
1040            auth_context: None,
1041        };
1042        sts.process_request(cancel_req).unwrap();
1043
1044        // Validate should now fail (token was removed)
1045        let validate_req = RequestSecurityToken {
1046            request_type: "http://docs.oasis-open.org/ws-sx/ws-trust/200512/Validate".to_string(),
1047            token_type: "".to_string(),
1048            applies_to: None,
1049            lifetime: None,
1050            key_type: None,
1051            key_size: None,
1052            existing_token: Some(token_id),
1053            auth_context: None,
1054        };
1055
1056        let err = sts.process_request(validate_req).unwrap_err();
1057        let msg = format!("{err}");
1058        assert!(msg.contains("Token not found"), "got: {msg}");
1059    }
1060}