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