auth_framework/server/core/
common_jwt.rs1use crate::errors::{AuthError, Result};
7use crate::server::core::common_validation;
8use jsonwebtoken::{Algorithm, DecodingKey, EncodingKey, Header, Validation, decode, encode};
9use serde::{Deserialize, Serialize};
10use std::collections::HashMap;
11use std::time::{SystemTime, UNIX_EPOCH};
12
13#[derive(Clone)]
15pub struct JwtConfig {
16 pub algorithm: Algorithm,
18 pub signing_key: EncodingKey,
20 pub verification_key: DecodingKey,
22 pub default_expiration: u64,
24 pub issuer: String,
26 pub audiences: Vec<String>,
28}
29
30impl JwtConfig {
31 pub fn with_symmetric_key(secret: &[u8], issuer: String) -> Self {
33 Self {
34 algorithm: Algorithm::HS256,
35 signing_key: EncodingKey::from_secret(secret),
36 verification_key: DecodingKey::from_secret(secret),
37 default_expiration: 3600, issuer,
39 audiences: vec![],
40 }
41 }
42
43 pub fn with_rsa_keys(private_key: &[u8], public_key: &[u8], issuer: String) -> Result<Self> {
45 let signing_key = EncodingKey::from_rsa_pem(private_key)
46 .map_err(|e| AuthError::validation(format!("Invalid private key: {}", e)))?;
47
48 let verification_key = DecodingKey::from_rsa_pem(public_key)
49 .map_err(|e| AuthError::validation(format!("Invalid public key: {}", e)))?;
50
51 Ok(Self {
52 algorithm: Algorithm::RS256,
53 signing_key,
54 verification_key,
55 default_expiration: 3600, issuer,
57 audiences: vec![],
58 })
59 }
60
61 pub fn with_audience(mut self, audience: String) -> Self {
63 self.audiences.push(audience);
64 self
65 }
66
67 pub fn with_expiration(mut self, expiration: u64) -> Self {
69 self.default_expiration = expiration;
70 self
71 }
72}
73
74#[derive(Debug, Clone, Serialize, Deserialize)]
76pub struct CommonJwtClaims {
77 pub iss: String,
79 pub sub: String,
81 pub aud: Vec<String>,
83 pub exp: i64,
85 pub iat: i64,
87 pub nbf: Option<i64>,
89 pub jti: Option<String>,
91 #[serde(flatten)]
93 pub custom: HashMap<String, serde_json::Value>,
94}
95
96impl CommonJwtClaims {
97 pub fn new(issuer: String, subject: String, audiences: Vec<String>, expiration: i64) -> Self {
99 let now = SystemTime::now()
100 .duration_since(UNIX_EPOCH)
101 .unwrap()
102 .as_secs() as i64;
103
104 Self {
105 iss: issuer,
106 sub: subject,
107 aud: audiences,
108 exp: expiration,
109 iat: now,
110 nbf: None,
111 jti: None,
112 custom: HashMap::new(),
113 }
114 }
115
116 pub fn with_custom_claim(mut self, key: String, value: serde_json::Value) -> Self {
118 self.custom.insert(key, value);
119 self
120 }
121
122 pub fn with_jti(mut self, jti: String) -> Self {
124 self.jti = Some(jti);
125 self
126 }
127
128 pub fn with_nbf(mut self, nbf: i64) -> Self {
130 self.nbf = Some(nbf);
131 self
132 }
133}
134
135pub struct JwtManager {
214 config: JwtConfig,
215}
216
217impl JwtManager {
218 pub fn new(config: JwtConfig) -> Self {
220 Self { config }
221 }
222
223 pub fn create_token(&self, claims: &CommonJwtClaims) -> Result<String> {
225 let header = Header {
226 alg: self.config.algorithm,
227 ..Default::default()
228 };
229
230 encode(&header, claims, &self.config.signing_key)
231 .map_err(|e| AuthError::validation(format!("Failed to encode JWT: {}", e)))
232 }
233
234 pub fn create_token_with_custom_claims<T>(&self, claims: &T) -> Result<String>
236 where
237 T: Serialize,
238 {
239 let header = Header {
240 alg: self.config.algorithm,
241 ..Default::default()
242 };
243
244 encode(&header, claims, &self.config.signing_key)
245 .map_err(|e| AuthError::validation(format!("Failed to encode JWT: {}", e)))
246 }
247
248 pub fn verify_token(&self, token: &str) -> Result<CommonJwtClaims> {
250 common_validation::jwt::validate_jwt_format(token)?;
252
253 let mut validation = Validation::new(self.config.algorithm);
254 validation.set_issuer(&[&self.config.issuer]);
255
256 if !self.config.audiences.is_empty() {
257 validation.set_audience(
258 &self
259 .config
260 .audiences
261 .iter()
262 .map(String::as_str)
263 .collect::<Vec<_>>(),
264 );
265 }
266
267 let token_data =
268 decode::<CommonJwtClaims>(token, &self.config.verification_key, &validation)
269 .map_err(|e| AuthError::validation(format!("Invalid JWT: {}", e)))?;
270
271 let claims_value = serde_json::to_value(&token_data.claims)
273 .map_err(|e| AuthError::validation(format!("Failed to serialize claims: {}", e)))?;
274
275 common_validation::jwt::validate_time_claims(&claims_value)?;
276
277 Ok(token_data.claims)
278 }
279
280 pub fn verify_token_with_custom_claims<T>(&self, token: &str) -> Result<T>
282 where
283 T: for<'de> Deserialize<'de>,
284 {
285 common_validation::jwt::validate_jwt_format(token)?;
286
287 let mut validation = Validation::new(self.config.algorithm);
288 validation.set_issuer(&[&self.config.issuer]);
289
290 if !self.config.audiences.is_empty() {
291 validation.set_audience(
292 &self
293 .config
294 .audiences
295 .iter()
296 .map(String::as_str)
297 .collect::<Vec<_>>(),
298 );
299 }
300
301 let token_data = decode::<T>(token, &self.config.verification_key, &validation)
302 .map_err(|e| AuthError::validation(format!("Invalid JWT: {}", e)))?;
303
304 Ok(token_data.claims)
305 }
306
307 pub fn create_access_token(
309 &self,
310 subject: String,
311 scope: Vec<String>,
312 client_id: Option<String>,
313 ) -> Result<String> {
314 let exp = SystemTime::now()
315 .duration_since(UNIX_EPOCH)
316 .unwrap()
317 .as_secs() as i64
318 + self.config.default_expiration as i64;
319
320 let mut claims = CommonJwtClaims::new(
321 self.config.issuer.clone(),
322 subject,
323 self.config.audiences.clone(),
324 exp,
325 );
326
327 claims
328 .custom
329 .insert("scope".to_string(), serde_json::json!(scope.join(" ")));
330
331 if let Some(client_id) = client_id {
332 claims.custom.insert(
333 "client_id".to_string(),
334 serde_json::Value::String(client_id),
335 );
336 }
337
338 claims.custom.insert(
339 "token_type".to_string(),
340 serde_json::Value::String("access_token".to_string()),
341 );
342
343 self.create_token(&claims)
344 }
345
346 pub fn create_refresh_token(&self, subject: String, client_id: String) -> Result<String> {
348 let exp = SystemTime::now()
350 .duration_since(UNIX_EPOCH)
351 .unwrap()
352 .as_secs() as i64
353 + (self.config.default_expiration * 24) as i64; let mut claims = CommonJwtClaims::new(
356 self.config.issuer.clone(),
357 subject,
358 self.config.audiences.clone(),
359 exp,
360 );
361
362 claims.custom.insert(
363 "client_id".to_string(),
364 serde_json::Value::String(client_id),
365 );
366 claims.custom.insert(
367 "token_type".to_string(),
368 serde_json::Value::String("refresh_token".to_string()),
369 );
370
371 self.create_token(&claims)
372 }
373
374 pub fn create_id_token(
376 &self,
377 subject: String,
378 nonce: Option<String>,
379 auth_time: Option<i64>,
380 user_info: HashMap<String, serde_json::Value>,
381 ) -> Result<String> {
382 let exp = SystemTime::now()
383 .duration_since(UNIX_EPOCH)
384 .unwrap()
385 .as_secs() as i64
386 + 300; let mut claims = CommonJwtClaims::new(
389 self.config.issuer.clone(),
390 subject,
391 self.config.audiences.clone(),
392 exp,
393 );
394
395 claims.custom.insert(
396 "token_type".to_string(),
397 serde_json::Value::String("id_token".to_string()),
398 );
399
400 if let Some(nonce) = nonce {
401 claims
402 .custom
403 .insert("nonce".to_string(), serde_json::Value::String(nonce));
404 }
405
406 if let Some(auth_time) = auth_time {
407 claims.custom.insert(
408 "auth_time".to_string(),
409 serde_json::Value::Number(auth_time.into()),
410 );
411 }
412
413 for (key, value) in user_info {
415 claims.custom.insert(key, value);
416 }
417
418 self.create_token(&claims)
419 }
420}
421
422pub mod utils {
424 use super::*;
425
426 pub fn extract_claims_unsafe(token: &str) -> Result<serde_json::Value> {
436 common_validation::jwt::extract_claims_unsafe(token)
437 }
438
439 pub fn is_token_expired(token: &str) -> Result<bool> {
446 let claims = extract_claims_unsafe(token)?;
447
448 let now = SystemTime::now()
449 .duration_since(UNIX_EPOCH)
450 .unwrap()
451 .as_secs() as i64;
452
453 if let Some(exp) = claims.get("exp").and_then(|v| v.as_i64()) {
454 Ok(now >= exp)
455 } else {
456 Ok(false) }
458 }
459
460 pub fn get_token_expiration(token: &str) -> Result<Option<i64>> {
466 let claims = extract_claims_unsafe(token)?;
467 Ok(claims.get("exp").and_then(|v| v.as_i64()))
468 }
469
470 pub fn get_token_subject(token: &str) -> Result<Option<String>> {
476 let claims = extract_claims_unsafe(token)?;
477 Ok(claims.get("sub").and_then(|v| v.as_str()).map(String::from))
478 }
479
480 pub fn get_token_scopes(token: &str) -> Result<Vec<String>> {
486 let claims = extract_claims_unsafe(token)?;
487
488 if let Some(scope_str) = claims.get("scope").and_then(|v| v.as_str()) {
489 Ok(scope_str.split_whitespace().map(String::from).collect())
490 } else if let Some(scopes_array) = claims.get("scopes").and_then(|v| v.as_array()) {
491 Ok(scopes_array
492 .iter()
493 .filter_map(|v| v.as_str())
494 .map(String::from)
495 .collect())
496 } else {
497 Ok(vec![])
498 }
499 }
500}