br_crypto/

jwt.rs

use chrono::Local;
use json::{JsonValue, object};
use crate::base64::{url_decode, url_encode};
use crate::hmac::sha256;
use crate::pkey::{pri_key_sign, pub_key_verify};

#[derive(Clone)]
pub struct Jwt {}

impl Jwt {
    /// 创建
    ///
    /// * alg 加密方式
    /// * iss 签发人
    /// * jti 签发TOKEN
    /// * sub 主题
    /// * aud 受众
    /// * custom 自定义内容
    /// * nbf 生效时间 秒s
    /// * exp 过期时间 秒s
    /// * key 加密密钥 rsa 为私钥匙
    #[allow(clippy::too_many_arguments)]
    pub fn create(alg: &str, iss: &str, jti: &str, sub: &str, aud: &str, custom: JsonValue, nbf: i64, exp: i64, key: &str) -> String {
        let mut header = Header::default();
        header.set_alg(alg);
        let mut payload = Payload::new();
        payload.iss = iss.to_string();
        payload.jti = jti.to_string();
        payload.sub = sub.to_string();
        payload.aud = aud.to_string();
        payload.custom = custom;
        payload.set_nbf_exp(nbf, exp);

        let signature = format!("{}.{}", header.clone().sign(), payload.clone().sign());
        let data = match header.alg.clone() {
            Alg::HS256 => sha256(key, signature.as_str()),
            Alg::RSA => pri_key_sign(key, signature.as_str())
        };
        let sign = url_encode(data.to_string());
        let token = format!("{signature}.{sign}");
        token
    }
    /// 验证
    /// * key rsa 为公匙
    pub fn verify(token: &str, key: &str) -> Result<i64, String> {
        let mut data: Vec<&str> = token.split(".").collect();
        if data.len() != 3 {
            return Err("TOKEN格式不正确".to_string());
        }
        let header = data.remove(0);
        let payload = data.remove(0);
        let signature = format!("{header}.{payload}");
        let sign_old = data.remove(0);

        let header = Header::from(header)?;
        let sign_new = match header.alg {
            Alg::HS256 => {
                url_encode(sha256(key, signature.as_str()))
            }
            Alg::RSA => {
                let sign = url_decode(sign_old.to_string());
                if !pub_key_verify(key.to_string().clone(), signature.as_str(), sign) {
                    return Err("签名不正确".to_string());
                }
                sign_old.to_string()
            }
        };
        if sign_new != sign_old {
            return Err("签名不一致".to_string());
        }
        let payload = Payload::from(payload)?;

        let time = Local::now().timestamp();
        // 生效时间早于当前时间
        if payload.nbf > time {
            return Err(format!("未生效: {}", payload.nbf - time));
        }
        // 过期时间小于当前时间
        if time > payload.exp {
            return Err(format!("已过期: {}", payload.exp));
        }
        Ok(payload.exp - time)
    }
    /// 信息
    pub fn info(token: &str) -> Result<JsonValue, String> {
        let mut data: Vec<&str> = token.split(".").collect();
        if data.len() != 3 {
            return Err("TOKEN格式不正确".to_string());
        }
        let header = data.remove(0);
        let payload = data.remove(0);

        let mut header = Header::from(header)?;
        let mut payload = Payload::from(payload)?;
        Ok(object! {
            "header":header.json(),
            "payload":payload.json()
        })
    }
}

#[derive(Clone)]
pub enum Alg {
    HS256,
    RSA,
}

impl Alg {
    pub fn str(&mut self) -> String {
        match self {
            Alg::HS256 => "HS256",
            Alg::RSA => "RSA"
        }.to_string()
    }
    pub fn from(name: &str) -> Self {
        match name {
            "HS256" => Alg::HS256,
            "RSA" => Alg::RSA,
            _ => Alg::HS256
        }
    }
}

#[derive(Clone)]
pub struct Header {
    /// 签名方式
    alg: Alg,
    /// 令牌类型
    typ: String,
}

impl Header {
    pub fn sign(&mut self) -> String {
        let header = self.json();
        url_encode(header.to_string())
    }
    pub fn set_alg(&mut self, alg: &str) {
        if !alg.is_empty() {
            self.alg = Alg::from(alg);
        }
    }
    pub fn from(str: &str) -> Result<Header, String> {
        let mut header = Header::default();
        let header_text = url_decode(str.to_string());
        header.alg = match json::parse(header_text.as_str()) {
            Ok(e) => {
                Alg::from(e["alg"].as_str().unwrap_or(""))
            }
            Err(e) => {
                return Err(e.to_string());
            }
        };
        Ok(header)
    }
    pub fn json(&mut self) -> JsonValue {
        object! {
            alg:self.alg.str(),
            typ:self.typ.clone()
        }
    }
}

impl Default for Header {
    fn default() -> Self {
        Self {
            alg: Alg::HS256,
            typ: "JWT".to_string(),
        }
    }
}
/// 载荷
#[derive(Clone)]
pub struct Payload {
    /// 签发人
    pub iss: String,
    /// 签发时间
    pub iat: i64,
    /// 签发TOKEN
    pub jti: String,

    /// 主题
    pub sub: String,
    /// 受众
    pub aud: String,
    /// 自定义内容
    pub custom: JsonValue,

    /// 生效时间 秒s
    pub nbf: i64,
    /// 过期时间 秒s
    pub exp: i64,

}
impl Default for Payload {
    fn default() -> Self {
        Self::new()
    }
}

impl Payload {
    pub fn new() -> Self {
        Self {
            iss: "".to_string(),
            iat: Local::now().timestamp(),
            jti: "".to_string(),
            sub: "".to_string(),
            aud: "".to_string(),
            custom: JsonValue::Null,
            nbf: 0,
            exp: 0,
        }
    }
    pub fn sign(&mut self) -> String {
        let payload = self.json();
        url_encode(payload.to_string())
    }
    pub fn from(str: &str) -> Result<Payload, String> {
        let payload_text = url_decode(str.to_string());
        match json::parse(payload_text.as_str()) {
            Ok(payload) => {
                Ok(Self {
                    iss: payload["iss"].to_string(),
                    iat: payload["iat"].as_i64().unwrap_or(0),
                    jti: payload["jti"].to_string(),
                    sub: payload["sub"].to_string(),
                    aud: payload["aud"].to_string(),
                    custom: payload["custom"].clone(),
                    nbf: payload["nbf"].as_i64().unwrap_or(0),
                    exp: payload["exp"].as_i64().unwrap_or(0),
                })
            }
            Err(_) => Err("载荷错误".to_string())
        }
    }
    pub fn set_nbf_exp(&mut self, nbf: i64, exp: i64) {
        if nbf == 0 {
            self.nbf = Local::now().timestamp();
        } else {
            self.nbf = nbf;
        }
        self.exp = self.nbf + exp;
    }
    pub fn json(&mut self) -> JsonValue {
        object! {
            iss: self.iss.clone(),
            iat:  self.iat,
            jti:  self.jti.clone(),
            sub: self.sub.clone(),
            aud:  self.aud.clone(),
            custom:  self.custom.clone(),
            nbf: self.nbf,
            exp:  self.exp
        }
    }
}