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