1use crate::errors::{AuthError, Result};
7use crate::protocols::saml_assertions::SamlAssertionBuilder;
8use 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
19pub struct SecurityTokenService {
30 config: StsConfig,
32
33 ws_security: WsSecurityClient,
35
36 issued_tokens: HashMap<String, IssuedToken>,
38
39 storage: Option<Arc<dyn AuthStorage>>,
41}
42
43const TOKEN_KEY_PREFIX: &str = "wstrust:token:";
45
46fn 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#[derive(Debug, Clone)]
58pub struct StsConfig {
59 pub issuer: String,
61
62 pub default_token_lifetime: Duration,
64
65 pub max_token_lifetime: Duration,
67
68 pub supported_token_types: Vec<String>,
70
71 pub endpoint_url: String,
73
74 pub include_proof_tokens: bool,
76
77 pub trust_relationships: Vec<TrustRelationship>,
79
80 pub jwt_signing_secret: Zeroizing<String>,
88}
89
90#[derive(Debug, Clone)]
92pub struct TrustRelationship {
93 pub rp_identifier: String,
95
96 pub certificate: Option<Vec<u8>>,
98
99 pub allowed_token_types: Vec<String>,
101
102 pub max_token_lifetime: Option<Duration>,
104}
105
106#[derive(Clone, Serialize, Deserialize)]
108pub struct IssuedToken {
109 pub token_id: String,
111
112 pub token_type: String,
114
115 pub token_content: String,
117
118 pub issued_at: DateTime<Utc>,
120
121 pub expires_at: DateTime<Utc>,
123
124 pub subject: String,
126
127 pub audience: String,
129
130 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#[derive(Clone, Serialize, Deserialize)]
154pub struct ProofToken {
155 pub token_type: String,
157
158 pub key_material: Vec<u8>,
160
161 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#[derive(Clone, Serialize, Deserialize)]
180pub struct RequestSecurityToken {
181 pub request_type: String,
183
184 pub token_type: String,
186
187 pub applies_to: Option<String>,
189
190 pub lifetime: Option<TokenLifetime>,
192
193 pub key_type: Option<String>,
195
196 pub key_size: Option<u32>,
198
199 pub existing_token: Option<String>,
201
202 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#[derive(Debug, Clone, Serialize, Deserialize)]
226pub struct TokenLifetime {
227 pub created: DateTime<Utc>,
229
230 pub expires: DateTime<Utc>,
232}
233
234#[derive(Debug, Clone, Serialize, Deserialize)]
236pub struct AuthenticationContext {
237 pub username: String,
239
240 pub auth_method: String,
242
243 pub claims: HashMap<String, String>,
245}
246
247#[derive(Clone, Serialize, Deserialize)]
249pub struct RequestSecurityTokenResponse {
250 pub request_type: String,
252
253 pub token_type: String,
255
256 pub lifetime: TokenLifetime,
258
259 pub applies_to: Option<String>,
261
262 pub requested_security_token: String,
264
265 pub requested_proof_token: Option<ProofToken>,
267
268 pub requested_attached_reference: Option<String>,
270
271 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 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 pub fn with_storage(mut self, storage: Arc<dyn AuthStorage>) -> Self {
316 self.storage = Some(storage);
317 self
318 }
319
320 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 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 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 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 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 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 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 fn issue_token(
476 &mut self,
477 request: RequestSecurityToken,
478 ) -> Result<RequestSecurityTokenResponse> {
479 let auth_context = request
481 .auth_context
482 .as_ref()
483 .ok_or_else(|| AuthError::auth_method("wstrust", "Authentication context required"))?;
484
485 let now = Utc::now();
487 let lifetime = if let Some(ref requested_lifetime) = request.lifetime {
488 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 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 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 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 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 if let Some(ref audience) = request.applies_to {
571 assertion_builder = assertion_builder.with_audience(audience);
572 }
573
574 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 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 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]; 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 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 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 let now = Utc::now();
651 if now >= issued_token.expires_at {
652 return Err(AuthError::auth_method("wstrust", "Token has expired"));
653 }
654
655 let new_lifetime = TokenLifetime {
657 created: now,
658 expires: now + self.config.default_token_lifetime,
659 };
660
661 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 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 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 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 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 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 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 let parts: Vec<&str> = response.requested_security_token.split('.').collect();
898 assert_eq!(parts.len(), 3, "JWT must have header.payload.signature");
899
900 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), }),
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 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 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, 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, 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); 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 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 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 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 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 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}