130 lines
4.0 KiB
Rust
130 lines
4.0 KiB
Rust
use base64::{decode_config, encode_config, URL_SAFE_NO_PAD};
|
|
use Component;
|
|
use error::Error;
|
|
use serde::{Deserialize, Serialize};
|
|
use serde_json;
|
|
use serde_json::value::{Value};
|
|
use super::Result;
|
|
|
|
/// A default claim set, including the standard, or registered, claims and the ability to specify
|
|
/// your own as private claims.
|
|
#[derive(Debug, Default, PartialEq)]
|
|
pub struct Claims<T: Serialize + Deserialize> {
|
|
pub reg: Registered,
|
|
pub private: T
|
|
}
|
|
|
|
/// The registered claims from the spec.
|
|
#[derive(Debug, Default, PartialEq, Serialize, Deserialize)]
|
|
pub struct Registered {
|
|
pub iss: Option<String>,
|
|
pub sub: Option<String>,
|
|
pub aud: Option<String>,
|
|
pub exp: Option<u64>,
|
|
pub nbf: Option<u64>,
|
|
pub iat: Option<u64>,
|
|
pub jti: Option<String>,
|
|
}
|
|
|
|
impl<T: Serialize + Deserialize> Claims<T>{
|
|
/// Convenience factory method
|
|
pub fn new(reg: Registered, private: T) -> Claims<T> {
|
|
Claims {
|
|
reg: reg,
|
|
private: private
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T: Serialize + Deserialize> Component for Claims<T> {
|
|
/// This implementation simply parses the base64 data twice, each time applying it to the
|
|
/// registered and private claims.
|
|
fn from_base64(raw: &str) -> Result<Claims<T>> {
|
|
let data = decode_config(raw, URL_SAFE_NO_PAD)?;
|
|
let reg_claims: Registered = serde_json::from_slice(&data)?;
|
|
|
|
let pri_claims: T = serde_json::from_slice(&data)?;
|
|
|
|
|
|
Ok(Claims {
|
|
reg: reg_claims,
|
|
private: pri_claims
|
|
})
|
|
}
|
|
|
|
/// Renders both the registered and private claims into a single consolidated JSON
|
|
/// representation before encoding.
|
|
fn to_base64(&self) -> Result<String> {
|
|
if let Value::Object(mut reg_map) = serde_json::to_value(&self.reg)? {
|
|
if let Value::Object(pri_map) = serde_json::to_value(&self.private)? {
|
|
reg_map.extend(pri_map);
|
|
let s = serde_json::to_string(®_map)?;
|
|
let enc = encode_config((&*s).as_bytes(), URL_SAFE_NO_PAD);
|
|
Ok(enc)
|
|
} else {
|
|
Err(Error::Custom("Could not access registered claims.".to_owned()))
|
|
}
|
|
} else {
|
|
Err(Error::Custom("Could not access private claims.".to_owned()))
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use std::default::Default;
|
|
use claims::{Claims, Registered};
|
|
use Component;
|
|
|
|
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
|
|
struct EmptyClaim { }
|
|
|
|
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
|
|
struct NonEmptyClaim {
|
|
user_id: String,
|
|
is_admin: bool,
|
|
first_name: Option<String>,
|
|
last_name: Option<String>
|
|
}
|
|
|
|
#[test]
|
|
fn from_base64() {
|
|
let enc = "eyJpc3MiOiJleGFtcGxlLmNvbSIsImV4cCI6MTMwMjMxOTEwMH0";
|
|
let claims: Claims<EmptyClaim> = Claims::from_base64(enc).unwrap();
|
|
|
|
assert_eq!(claims.reg.iss.unwrap(), "example.com");
|
|
assert_eq!(claims.reg.exp.unwrap(), 1302319100);
|
|
}
|
|
|
|
#[test]
|
|
fn multiple_types() {
|
|
let enc = "eyJpc3MiOiJleGFtcGxlLmNvbSIsImV4cCI6MTMwMjMxOTEwMH0";
|
|
let claims = Registered::from_base64(enc).unwrap();
|
|
|
|
assert_eq!(claims.iss.unwrap(), "example.com");
|
|
assert_eq!(claims.exp.unwrap(), 1302319100);
|
|
}
|
|
|
|
#[test]
|
|
fn roundtrip() {
|
|
let mut claims: Claims<EmptyClaim> = Default::default();
|
|
claims.reg.iss = Some("example.com".into());
|
|
claims.reg.exp = Some(1302319100);
|
|
let enc = claims.to_base64().unwrap();
|
|
assert_eq!(claims, Claims::from_base64(&*enc).unwrap());
|
|
}
|
|
|
|
#[test]
|
|
fn roundtrip_custom() {
|
|
let mut claims: Claims<NonEmptyClaim> = Default::default();
|
|
claims.reg.iss = Some("example.com".into());
|
|
claims.reg.exp = Some(1302319100);
|
|
claims.private.user_id = "123456".into();
|
|
claims.private.is_admin = false;
|
|
claims.private.first_name = Some("Random".into());
|
|
let enc = claims.to_base64().unwrap();
|
|
assert_eq!(claims, Claims::<NonEmptyClaim>::from_base64(&*enc).unwrap());
|
|
}
|
|
}
|