rustbasic-passport 0.1.1

OAuth2 server and personal access tokens for Rust applications, a port of laravel/passport for the RustBasic ecosystem.
Documentation
use std::time::{SystemTime, UNIX_EPOCH};

use jsonwebtoken::{Algorithm, DecodingKey, EncodingKey, Header, Validation, decode, encode};
use rsa::pkcs8::{EncodePrivateKey, EncodePublicKey, LineEnding};
use rsa::{RsaPrivateKey, RsaPublicKey};
use serde::{Deserialize, Serialize};

use crate::error::Error;

pub fn now_secs() -> i64 {
    SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .map(|d| d.as_secs() as i64)
        .unwrap_or(0)
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AccessTokenClaims {
    pub iss: String,
    pub sub: String,
    pub aud: String,
    pub jti: String,
    pub iat: i64,
    pub nbf: i64,
    pub exp: i64,
    pub scopes: Vec<String>,
    pub client_id: String,
}

#[derive(Debug, Clone)]
pub struct SigningKey {
    pub key_id: String,
    pub private_pem: String,
    pub public_pem: String,
}

impl SigningKey {
    pub fn from_pem(
        key_id: impl Into<String>,
        private_pem: impl Into<String>,
        public_pem: impl Into<String>,
    ) -> Self {
        Self {
            key_id: key_id.into(),
            private_pem: private_pem.into(),
            public_pem: public_pem.into(),
        }
    }

    pub fn generate(key_id: impl Into<String>) -> Result<Self, Error> {
        let mut rng = rand::thread_rng();
        let private = RsaPrivateKey::new(&mut rng, 2048)?;
        let public = RsaPublicKey::from(&private);
        Ok(Self {
            key_id: key_id.into(),
            private_pem: private.to_pkcs8_pem(LineEnding::LF)?.to_string(),
            public_pem: public.to_public_key_pem(LineEnding::LF)?.to_string(),
        })
    }
}

pub fn sign_access_token(key: &SigningKey, claims: AccessTokenClaims) -> Result<String, Error> {
    let mut header = Header::new(Algorithm::RS256);
    header.kid = Some(key.key_id.clone());
    let encoding = EncodingKey::from_rsa_pem(key.private_pem.as_bytes())?;
    Ok(encode(&header, &claims, &encoding)?)
}

pub fn verify_access_token(
    key: &SigningKey,
    token: &str,
    issuer: &str,
    audience: &str,
) -> Result<AccessTokenClaims, Error> {
    let mut validation = Validation::new(Algorithm::RS256);
    validation.set_issuer(&[issuer]);
    validation.set_audience(&[audience]);
    validation.leeway = 0;
    let decoding = DecodingKey::from_rsa_pem(key.public_pem.as_bytes())?;
    let data = decode::<AccessTokenClaims>(token, &decoding, &validation)?;
    if data.header.kid.as_deref() != Some(key.key_id.as_str()) {
        return Err(Error::Unauthorized("unknown key id".into()));
    }
    Ok(data.claims)
}