Skip to main content

rustbasic_passport/
jwt.rs

1use 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}