1use crate::errors::{AuthError, Result};
7use crate::protocols::saml_assertions::SamlAssertionBuilder;
8use 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
17pub struct SecurityTokenService {
24 config: StsConfig,
26
27 ws_security: WsSecurityClient,
29
30 issued_tokens: HashMap<String, IssuedToken>,
32}
33
34#[derive(Debug, Clone)]
36pub struct StsConfig {
37 pub issuer: String,
39
40 pub default_token_lifetime: Duration,
42
43 pub max_token_lifetime: Duration,
45
46 pub supported_token_types: Vec<String>,
48
49 pub endpoint_url: String,
51
52 pub include_proof_tokens: bool,
54
55 pub trust_relationships: Vec<TrustRelationship>,
57
58 pub jwt_signing_secret: Zeroizing<String>,
66}
67
68#[derive(Debug, Clone)]
70pub struct TrustRelationship {
71 pub rp_identifier: String,
73
74 pub certificate: Option<Vec<u8>>,
76
77 pub allowed_token_types: Vec<String>,
79
80 pub max_token_lifetime: Option<Duration>,
82}
83
84#[derive(Clone, Serialize, Deserialize)]
86pub struct IssuedToken {
87 pub token_id: String,
89
90 pub token_type: String,
92
93 pub token_content: String,
95
96 pub issued_at: DateTime<Utc>,
98
99 pub expires_at: DateTime<Utc>,
101
102 pub subject: String,
104
105 pub audience: String,
107
108 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#[derive(Clone, Serialize, Deserialize)]
132pub struct ProofToken {
133 pub token_type: String,
135
136 pub key_material: Vec<u8>,
138
139 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#[derive(Clone, Serialize, Deserialize)]
158pub struct RequestSecurityToken {
159 pub request_type: String,
161
162 pub token_type: String,
164
165 pub applies_to: Option<String>,
167
168 pub lifetime: Option<TokenLifetime>,
170
171 pub key_type: Option<String>,
173
174 pub key_size: Option<u32>,
176
177 pub existing_token: Option<String>,
179
180 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#[derive(Debug, Clone, Serialize, Deserialize)]
204pub struct TokenLifetime {
205 pub created: DateTime<Utc>,
207
208 pub expires: DateTime<Utc>,
210}
211
212#[derive(Debug, Clone, Serialize, Deserialize)]
214pub struct AuthenticationContext {
215 pub username: String,
217
218 pub auth_method: String,
220
221 pub claims: HashMap<String, String>,
223}
224
225#[derive(Clone, Serialize, Deserialize)]
227pub struct RequestSecurityTokenResponse {
228 pub request_type: String,
230
231 pub token_type: String,
233
234 pub lifetime: TokenLifetime,
236
237 pub applies_to: Option<String>,
239
240 pub requested_security_token: String,
242
243 pub requested_proof_token: Option<ProofToken>,
245
246 pub requested_attached_reference: Option<String>,
248
249 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 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 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 fn issue_token(
311 &mut self,
312 request: RequestSecurityToken,
313 ) -> Result<RequestSecurityTokenResponse> {
314 let auth_context = request
316 .auth_context
317 .as_ref()
318 .ok_or_else(|| AuthError::auth_method("wstrust", "Authentication context required"))?;
319
320 let now = Utc::now();
322 let lifetime = if let Some(ref requested_lifetime) = request.lifetime {
323 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 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 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 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 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 if let Some(ref audience) = request.applies_to {
406 assertion_builder = assertion_builder.with_audience(audience);
407 }
408
409 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 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 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]; 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 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 let mut renewal_claims = HashMap::new();
479 let token_id = if existing_token.matches('.').count() == 2 {
480 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 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 let now = Utc::now();
521 if now >= issued_token.expires_at {
522 return Err(AuthError::auth_method("wstrust", "Token has expired"));
523 }
524
525 let new_lifetime = TokenLifetime {
527 created: now,
528 expires: now + self.config.default_token_lifetime,
529 };
530
531 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 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 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 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 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 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 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 let parts: Vec<&str> = response.requested_security_token.split('.').collect();
768 assert_eq!(parts.len(), 3, "JWT must have header.payload.signature");
769
770 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), }),
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 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 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, 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, 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); 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 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 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 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 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 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}