rustbasic_passport/
jwt.rs1use std::time::{SystemTime, UNIX_EPOCH};
2
3use jsonwebtoken::{Algorithm, DecodingKey, EncodingKey, Header, Validation, decode, encode};
4use rsa::pkcs8::{EncodePrivateKey, EncodePublicKey, LineEnding};
5use rsa::{RsaPrivateKey, RsaPublicKey};
6use serde::{Deserialize, Serialize};
7
8use crate::error::Error;
9
10pub fn now_secs() -> i64 {
11 SystemTime::now()
12 .duration_since(UNIX_EPOCH)
13 .map(|d| d.as_secs() as i64)
14 .unwrap_or(0)
15}
16
17#[derive(Debug, Clone, Serialize, Deserialize)]
18pub struct AccessTokenClaims {
19 pub iss: String,
20 pub sub: String,
21 pub aud: String,
22 pub jti: String,
23 pub iat: i64,
24 pub nbf: i64,
25 pub exp: i64,
26 pub scopes: Vec<String>,
27 pub client_id: String,
28}
29
30#[derive(Debug, Clone)]
31pub struct SigningKey {
32 pub key_id: String,
33 pub private_pem: String,
34 pub public_pem: String,
35}
36
37impl SigningKey {
38 pub fn from_pem(
39 key_id: impl Into<String>,
40 private_pem: impl Into<String>,
41 public_pem: impl Into<String>,
42 ) -> Self {
43 Self {
44 key_id: key_id.into(),
45 private_pem: private_pem.into(),
46 public_pem: public_pem.into(),
47 }
48 }
49
50 pub fn generate(key_id: impl Into<String>) -> Result<Self, Error> {
51 let mut rng = rand::thread_rng();
52 let private = RsaPrivateKey::new(&mut rng, 2048)?;
53 let public = RsaPublicKey::from(&private);
54 Ok(Self {
55 key_id: key_id.into(),
56 private_pem: private.to_pkcs8_pem(LineEnding::LF)?.to_string(),
57 public_pem: public.to_public_key_pem(LineEnding::LF)?.to_string(),
58 })
59 }
60}
61
62pub fn sign_access_token(key: &SigningKey, claims: AccessTokenClaims) -> Result<String, Error> {
63 let mut header = Header::new(Algorithm::RS256);
64 header.kid = Some(key.key_id.clone());
65 let encoding = EncodingKey::from_rsa_pem(key.private_pem.as_bytes())?;
66 Ok(encode(&header, &claims, &encoding)?)
67}
68
69pub fn verify_access_token(
70 key: &SigningKey,
71 token: &str,
72 issuer: &str,
73 audience: &str,
74) -> Result<AccessTokenClaims, Error> {
75 let mut validation = Validation::new(Algorithm::RS256);
76 validation.set_issuer(&[issuer]);
77 validation.set_audience(&[audience]);
78 validation.leeway = 0;
79 let decoding = DecodingKey::from_rsa_pem(key.public_pem.as_bytes())?;
80 let data = decode::<AccessTokenClaims>(token, &decoding, &validation)?;
81 if data.header.kid.as_deref() != Some(key.key_id.as_str()) {
82 return Err(Error::Unauthorized("unknown key id".into()));
83 }
84 Ok(data.claims)
85}