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