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)
}