#![no_std]
#[cfg(feature = "alloc")]
extern crate alloc;
pub const ID: [u8; 32] = [
0xdb, 0x45, 0x49, 0x36, 0x35, 0xef, 0x28, 0x0d, 0xfb, 0xbe, 0x73, 0x6a, 0x6d, 0xfa, 0xd8, 0xbc,
0xf8, 0x60, 0x38, 0xc2, 0xa5, 0x39, 0x74, 0xf7, 0x64, 0x1d, 0x78, 0x42, 0xb8, 0xaa, 0x41, 0x71,
];
pub const ID_STR: &str = "FkwZdsYCmzicJMtHLTkPK76bYNVG4WNwkWJBiVWNtF3W";
pub mod v2 {
use super::{Error, Token};
pub const ID: [u8; 32] = super::ID;
pub const ID_STR: &str = super::ID_STR;
pub fn read<'a>(owner: &[u8; 32], data: &'a [u8], now: i64) -> Result<Token<'a>, Error> {
Token::read_from(&ID, owner, data, now)
}
}
pub mod v1 {
use super::{Error, Token};
pub const ID: [u8; 32] = [
0x0d, 0xc9, 0x82, 0xa8, 0x4f, 0x3b, 0x4e, 0xae, 0x63, 0x8e, 0x01, 0x8f, 0xe3, 0x9a, 0x96, 0xd0,
0x6b, 0xd7, 0xe9, 0x53, 0x33, 0x1c, 0xda, 0x76, 0x0d, 0x51, 0x66, 0xb4, 0x0b, 0x34, 0x2b, 0xa3,
];
pub const ID_STR: &str = "vpWym9azbPU5f2PH2a6n8c4RfmsyUeW2dMuWr1DSHcE";
pub fn read<'a>(owner: &[u8; 32], data: &'a [u8], now: i64) -> Result<Token<'a>, Error> {
Token::read_from(&ID, owner, data, now)
}
}
pub const ISSUER_GITHUB: u8 = 0;
pub const ISSUER_GITLAB: u8 = 1;
pub const ISSUER_OTHER: u8 = 2;
pub const ISSUER_PRIVATE: u8 = 3;
pub const ISSUERS: [&[u8]; 2] = [b"https://token.actions.githubusercontent.com", b"https://gitlab.com"];
pub const MAX_JWT: usize = 8192;
pub const LATE: i64 = 3600;
pub fn fresh(exp: i64, now: i64) -> bool { now < exp.saturating_add(LATE) }
pub const T_STAGE: usize = 0;
pub const T_ISSUER: usize = 1;
pub const T_DONE: usize = 2;
pub const T_LIMBS: usize = 3;
pub const T_LEN: usize = 4;
pub const T_POFF: usize = 6;
pub const T_PLEN: usize = 8;
pub const T_EXP: usize = 10;
pub const T_KEY: usize = 18;
pub const T_PAYER: usize = 50;
pub const T_ID: usize = 82;
pub const T_X: usize = 114;
pub const T_JWT: usize = 626;
pub const VERIFIED: u8 = 2;
pub const T_IHASH: usize = T_X;
pub const T_REGISTRANT: usize = T_X + 32;
pub const K_STATE: usize = 0;
pub const K_ACTIVE: usize = 8;
pub const K_EXPIRES: usize = 16;
pub const K_FLAGS: usize = 24;
pub const K_HDR: usize = 40;
pub const F_APPROVED: u8 = 1;
pub const F_REVOKED: u8 = 2;
pub const F_GENESIS: u8 = 4;
pub const F_PRIVATE: u8 = 8;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum Error {
NotOidc = 1,
NotVerified = 2,
Stale = 3,
Private = 4,
Key = 68,
KeyNotActive = 76,
KeyExpired = 77,
KeyRevoked = 78,
Json = 61,
Duplicate = 62,
Claim = 63,
}
impl Error {
pub const fn code(self) -> u32 { self as u32 }
}
#[derive(Clone, Copy, Debug)]
pub struct Verified<'a> { pub issuer: u8, pub exp: i64, pub payload: &'a [u8] }
pub fn verified(d: &[u8]) -> Option<Verified<'_>> {
if d.len() < T_JWT || d[T_STAGE] != VERIFIED { return None; }
let off = u16::from_le_bytes([d[T_POFF], d[T_POFF + 1]]) as usize;
let len = u16::from_le_bytes([d[T_PLEN], d[T_PLEN + 1]]) as usize;
let payload = d.get(off..off + len)?;
Some(Verified { issuer: d[T_ISSUER], exp: i64::from_le_bytes(d[T_EXP..T_EXP + 8].try_into().ok()?), payload })
}
#[derive(Clone, Copy, Debug)]
pub struct Token<'a> { v: Verified<'a>, data: &'a [u8], program: [u8; 32] }
impl<'a> Token<'a> {
pub fn read(owner: &[u8; 32], data: &'a [u8], now: i64) -> Result<Token<'a>, Error> { Self::read_from(&ID, owner, data, now) }
pub fn read_from(program: &[u8; 32], owner: &[u8; 32], data: &'a [u8], now: i64) -> Result<Token<'a>, Error> {
let tok = Self::read_any_from(program, owner, data, now)?;
if tok.v.issuer > ISSUER_OTHER { return Err(Error::Private); }
Ok(tok)
}
pub fn read_any(owner: &[u8; 32], data: &'a [u8], now: i64) -> Result<Token<'a>, Error> { Self::read_any_from(&ID, owner, data, now) }
pub fn read_any_from(program: &[u8; 32], owner: &[u8; 32], data: &'a [u8], now: i64) -> Result<Token<'a>, Error> {
if owner != program { return Err(Error::NotOidc); }
let v = verified(data).ok_or(Error::NotVerified)?;
if !fresh(v.exp, now) { return Err(Error::Stale); }
Ok(Token { v, data, program: *program })
}
pub fn issuer(&self) -> u8 { self.v.issuer }
pub fn exp(&self) -> i64 { self.v.exp }
pub fn is_private(&self) -> bool { self.v.issuer > ISSUER_OTHER }
pub fn registrant(&self) -> Option<&'a [u8; 32]> {
if self.v.issuer != ISSUER_PRIVATE { return None; }
self.data[T_REGISTRANT..T_REGISTRANT + 32].try_into().ok()
}
pub fn issuer_hash(&self) -> Option<&'a [u8; 32]> {
if self.v.issuer < ISSUER_OTHER { return None; }
self.data[T_IHASH..T_IHASH + 32].try_into().ok()
}
pub fn key(&self) -> &'a [u8; 32] { self.data[T_KEY..T_KEY + 32].try_into().unwrap() }
pub fn check_key(&self, key_address: &[u8; 32], key_owner: &[u8; 32], key_data: &[u8], now: i64) -> Result<(), Error> {
if key_address != self.key() || *key_owner != self.program || key_data.len() < K_HDR || key_data[K_STATE] != 1 { return Err(Error::Key); }
let at = |o: usize| i64::from_le_bytes(key_data[o..o + 8].try_into().unwrap());
key_usable(key_data[K_FLAGS], at(K_ACTIVE), at(K_EXPIRES), now)
}
pub fn payload(&self) -> &'a [u8] { self.v.payload }
pub fn claims<const N: usize>(&self, want: [&[u8]; N]) -> Result<[Option<Raw<'a>>; N], Error> { fields(self.v.payload, want) }
pub fn claim(&self, name: &str) -> Option<Text<'a>> {
let [f] = self.claims([name.as_bytes()]).ok()?;
text(f).ok()
}
pub fn claim_u64(&self, name: &str) -> Option<u64> {
let [f] = self.claims([name.as_bytes()]).ok()?;
number(f).ok()
}
pub fn audience(&self) -> Option<Text<'a>> { self.claim("aud") }
}
pub fn key_usable(flags: u8, active_at: i64, expires_at: i64, now: i64) -> Result<(), Error> {
if flags & F_REVOKED != 0 { return Err(Error::KeyRevoked); }
if flags & (F_GENESIS | F_APPROVED | F_PRIVATE) == 0 || now < active_at { return Err(Error::KeyNotActive); }
if now >= expires_at { return Err(Error::KeyExpired); }
Ok(())
}
fn ws(b: &[u8], mut i: usize) -> usize {
while i < b.len() && matches!(b[i], b' ' | b'\t' | b'\n' | b'\r') { i += 1; }
i
}
fn jstr(b: &[u8], i: usize) -> Result<(usize, usize, usize), Error> {
if b.get(i) != Some(&b'"') { return Err(Error::Json); }
let mut k = i + 1;
while k < b.len() {
match b[k] {
b'\\' => k += 2,
b'"' => return Ok((i + 1, k, k + 1)),
_ => k += 1,
}
}
Err(Error::Json)
}
fn skip_value(b: &[u8], i: usize) -> Result<usize, Error> {
match b.get(i) {
Some(b'"') => Ok(jstr(b, i)?.2),
Some(b'{') | Some(b'[') => {
let mut depth = 0usize;
let mut k = i;
while k < b.len() {
match b[k] {
b'"' => { k = jstr(b, k)?.2; continue; }
b'{' | b'[' => depth += 1,
b'}' | b']' => { depth -= 1; if depth == 0 { return Ok(k + 1); } }
_ => {}
}
k += 1;
}
Err(Error::Json)
}
Some(_) => {
let mut k = i;
while k < b.len() && !matches!(b[k], b',' | b'}' | b']' | b' ' | b'\t' | b'\n' | b'\r') { k += 1; }
if k == i { Err(Error::Json) } else { Ok(k) }
}
None => Err(Error::Json),
}
}
#[derive(Clone, Copy, Debug)]
pub struct Raw<'a> { pub bytes: &'a [u8], pub is_str: bool }
fn key_is(raw: &[u8], escaped: bool, want: &[u8]) -> bool {
if !escaped { return raw == want; }
let (mut i, mut k) = (0, 0);
while i < raw.len() {
let Ok((c, next)) = unescape(raw, i) else { return false };
if want.get(k) != Some(&c) { return false; }
i = next; k += 1;
}
k == want.len()
}
pub fn fields<'a, const N: usize>(b: &'a [u8], want: [&[u8]; N]) -> Result<[Option<Raw<'a>>; N], Error> {
let mut got: [Option<Raw<'a>>; N] = [None; N];
let mut i = ws(b, 0);
if b.get(i) != Some(&b'{') { return Err(Error::Json); }
i = ws(b, i + 1);
if b.get(i) != Some(&b'}') {
loop {
let (ks, ke, next) = jstr(b, i)?;
i = ws(b, next);
if b.get(i) != Some(&b':') { return Err(Error::Json); }
let vs = ws(b, i + 1);
let ve = skip_value(b, vs)?;
let key = &b[ks..ke];
let escaped = key.contains(&b'\\');
for (w, g) in want.iter().zip(got.iter_mut()) {
if key_is(key, escaped, w) {
if g.is_some() { return Err(Error::Duplicate); }
*g = Some(if b[vs] == b'"' { Raw { bytes: &b[vs + 1..ve - 1], is_str: true } } else { Raw { bytes: &b[vs..ve], is_str: false } });
}
}
i = ws(b, ve);
match b.get(i) {
Some(b',') => i = ws(b, i + 1),
Some(b'}') => break,
_ => return Err(Error::Json),
}
}
}
if ws(b, i + 1) != b.len() { return Err(Error::Json); }
Ok(got)
}
fn unescape(r: &[u8], i: usize) -> Result<(u8, usize), Error> {
if r[i] != b'\\' { return Ok((r[i], i + 1)); }
match r.get(i + 1) {
Some(b'/') => Ok((b'/', i + 2)),
Some(b'\\') => Ok((b'\\', i + 2)),
Some(b'"') => Ok((b'"', i + 2)),
Some(b'u') => {
let h = r.get(i + 2..i + 6).ok_or(Error::Claim)?;
let mut v = 0u32;
for &c in h {
v = v << 4 | match c { b'0'..=b'9' => c - b'0', b'a'..=b'f' => c - b'a' + 10, b'A'..=b'F' => c - b'A' + 10, _ => return Err(Error::Claim) } as u32;
}
if !(0x20..0x7f).contains(&v) { return Err(Error::Claim); }
Ok((v as u8, i + 6))
}
_ => Err(Error::Claim),
}
}
#[derive(Clone, Copy, Debug)]
pub struct Text<'a> { raw: &'a [u8], len: usize }
impl<'a> Text<'a> {
pub fn len(&self) -> usize { self.len }
pub fn is_empty(&self) -> bool { self.len == 0 }
pub fn bytes(&self) -> TextBytes<'a> { TextBytes { raw: self.raw, at: 0 } }
pub fn is(&self, want: impl AsRef<[u8]>) -> bool {
let w = want.as_ref();
match self.as_plain() {
Some(t) => t == w,
None => w.len() == self.len && self.bytes().eq(w.iter().copied()),
}
}
pub fn starts_with(&self, prefix: impl AsRef<[u8]>) -> bool {
let p = prefix.as_ref();
match self.as_plain() {
Some(t) => t.starts_with(p),
None => p.len() <= self.len && self.bytes().take(p.len()).eq(p.iter().copied()),
}
}
pub fn as_plain(&self) -> Option<&'a [u8]> { if self.raw.len() == self.len { Some(self.raw) } else { None } }
pub fn copy_to<'b>(&self, out: &'b mut [u8]) -> Option<&'b [u8]> {
let o = out.get_mut(..self.len)?;
match self.as_plain() {
Some(t) => o.copy_from_slice(t),
None => for (d, s) in o.iter_mut().zip(self.bytes()) { *d = s; },
}
Some(o)
}
#[cfg(feature = "alloc")]
pub fn to_vec(&self) -> alloc::vec::Vec<u8> { self.bytes().collect() }
}
pub struct TextBytes<'a> { raw: &'a [u8], at: usize }
impl Iterator for TextBytes<'_> {
type Item = u8;
fn next(&mut self) -> Option<u8> {
if self.at >= self.raw.len() { return None; }
let (c, next) = unescape(self.raw, self.at).ok()?;
self.at = next;
Some(c)
}
}
pub fn text(f: Option<Raw<'_>>) -> Result<Text<'_>, Error> {
let r = match f { Some(r) if r.is_str => r.bytes, _ => return Err(Error::Claim) };
if !r.contains(&b'\\') { return Ok(Text { raw: r, len: r.len() }); }
let (mut i, mut len) = (0, 0);
while i < r.len() {
i = unescape(r, i)?.1;
len += 1;
}
Ok(Text { raw: r, len })
}
pub fn number(f: Option<Raw>) -> Result<u64, Error> {
let r = f.ok_or(Error::Claim)?;
parse_u64(r.bytes).ok_or(Error::Claim)
}
pub fn parse_u64(s: &[u8]) -> Option<u64> {
if s.is_empty() || s.len() > 18 || !s.iter().all(|c| c.is_ascii_digit()) || (s.len() > 1 && s[0] == b'0') { return None; }
Some(s.iter().fold(0u64, |a, c| a * 10 + (c - b'0') as u64))
}
pub fn is_hex(s: &[u8], len: usize) -> bool { s.len() == len && s.iter().all(|c| matches!(c, b'0'..=b'9' | b'a'..=b'f')) }
pub fn unhex32(s: &[u8]) -> Option<[u8; 32]> {
if !is_hex(s, 64) { return None; }
let v = |c: u8| if c <= b'9' { c - b'0' } else { c - b'a' + 10 };
let mut o = [0u8; 32];
for (k, b) in o.iter_mut().enumerate() { *b = v(s[2 * k]) << 4 | v(s[2 * k + 1]); }
Some(o)
}
pub fn b58_32(s: &[u8]) -> Option<[u8; 32]> {
const A: &[u8] = b"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
if s.len() < 32 || s.len() > 44 { return None; }
let mut out = [0u8; 32];
for &c in s {
let mut carry = A.iter().position(|&x| x == c)? as u32;
for b in out.iter_mut().rev() {
carry += (*b as u32) * 58;
*b = carry as u8;
carry >>= 8;
}
if carry != 0 { return None; }
}
let ones = s.iter().take_while(|&&c| c == b'1').count();
let zeros = out.iter().take_while(|&&b| b == 0).count();
if ones != zeros { return None; }
Some(out)
}
pub fn parts<const N: usize>(s: &[u8]) -> Option<[&[u8]; N]> {
let mut out: [&[u8]; N] = [&[]; N];
let mut it = s.split(|&c| c == b':');
for o in out.iter_mut() { *o = it.next()?; }
if it.next().is_some() { return None; }
Some(out)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_id_is_the_deployed_address() {
assert_eq!(b58_32(ID_STR.as_bytes()), Some(ID));
assert_eq!(b58_32(v1::ID_STR.as_bytes()), Some(v1::ID));
}
#[test]
fn every_default_is_the_second_deployment_and_the_first_is_read_only_by_name() {
assert_eq!((ID_STR, v2::ID_STR, v1::ID_STR), ("FkwZdsYCmzicJMtHLTkPK76bYNVG4WNwkWJBiVWNtF3W", "FkwZdsYCmzicJMtHLTkPK76bYNVG4WNwkWJBiVWNtF3W",
"vpWym9azbPU5f2PH2a6n8c4RfmsyUeW2dMuWr1DSHcE"));
assert!(v2::ID == ID && v1::ID != ID);
let (d, len) = account(ISSUER_GITHUB, br#"{"aud":"x","exp":1000}"#, 1000);
let d = &d[..len];
assert_eq!(Token::read(&v1::ID, d, 1000).unwrap_err(), Error::NotOidc);
assert_eq!(Token::read_any(&v1::ID, d, 1000).unwrap_err(), Error::NotOidc);
assert_eq!(v2::read(&v1::ID, d, 1000).unwrap_err(), Error::NotOidc);
assert!(v1::read(&v1::ID, d, 1000).is_ok() && Token::read_from(&v1::ID, &v1::ID, d, 1000).is_ok());
assert!(Token::read(&ID, d, 1000).is_ok() && Token::read_any(&ID, d, 1000).is_ok() && v2::read(&ID, d, 1000).is_ok());
assert_eq!(v1::read(&ID, d, 1000).unwrap_err(), Error::NotOidc);
}
#[test]
fn the_two_deployments_have_their_own_addresses_and_read_the_same_layout() {
assert_eq!(b58_32(v2::ID_STR.as_bytes()), Some(v2::ID));
assert_ne!(v2::ID, v1::ID);
let payload = br#"{"aud":"x","exp":1000}"#;
let mut d = [0u8; T_JWT + 22];
d[T_STAGE] = VERIFIED;
d[T_ISSUER] = ISSUER_GITLAB;
d[T_POFF..T_POFF + 2].copy_from_slice(&(T_JWT as u16).to_le_bytes());
d[T_PLEN..T_PLEN + 2].copy_from_slice(&(payload.len() as u16).to_le_bytes());
d[T_EXP..T_EXP + 8].copy_from_slice(&1000i64.to_le_bytes());
d[T_JWT..].copy_from_slice(payload);
let tok = v2::read(&v2::ID, &d, 1000).unwrap();
assert!(tok.issuer() == ISSUER_GITLAB && tok.exp() == 1000 && tok.audience().unwrap().is("x") && tok.claim_u64("exp") == Some(1000));
assert_eq!(v2::read(&v1::ID, &d, 1000).unwrap_err(), Error::NotOidc);
assert_eq!(v1::read(&v2::ID, &d, 1000).unwrap_err(), Error::NotOidc);
assert!(v1::read(&v1::ID, &d, 1000).is_ok() && Token::read_from(&v2::ID, &v2::ID, &d, 1000).is_ok());
assert_eq!(Token::read_from(&v2::ID, &[0; 32], &d, 1000).unwrap_err(), Error::NotOidc);
assert_eq!(v2::read(&v2::ID, &d, 1000 + LATE).unwrap_err(), Error::Stale);
d[T_STAGE] = 1;
assert_eq!(v2::read(&v2::ID, &d, 1000).unwrap_err(), Error::NotVerified);
}
fn account(issuer: u8, payload: &[u8], exp: i64) -> ([u8; T_JWT + 160], usize) {
let mut d = [0u8; T_JWT + 160];
d[T_STAGE] = VERIFIED;
d[T_ISSUER] = issuer;
d[T_POFF..T_POFF + 2].copy_from_slice(&(T_JWT as u16).to_le_bytes());
d[T_PLEN..T_PLEN + 2].copy_from_slice(&(payload.len() as u16).to_le_bytes());
d[T_EXP..T_EXP + 8].copy_from_slice(&exp.to_le_bytes());
d[T_KEY..T_KEY + 32].copy_from_slice(&[9; 32]);
d[T_JWT..T_JWT + payload.len()].copy_from_slice(payload);
(d, T_JWT + payload.len())
}
#[test]
fn a_private_token_is_refused_by_read_and_marked_for_whoever_reads_any() {
let payload = br#"{"iss":"https://token.actions.githubusercontent.com","aud":"gate:release","repository_id":"1","exp":1000}"#;
let (mut d, len) = account(ISSUER_PRIVATE, payload, 1000);
d[T_IHASH..T_IHASH + 32].copy_from_slice(&[0xaa; 32]);
d[T_REGISTRANT..T_REGISTRANT + 32].copy_from_slice(&[0xbb; 32]);
let d = &d[..len];
assert_eq!(v2::read(&v2::ID, d, 1000).unwrap_err(), Error::Private);
assert_eq!(Token::read_from(&v2::ID, &v2::ID, d, 1000).unwrap_err(), Error::Private);
let tok = Token::read_any_from(&v2::ID, &v2::ID, d, 1000).unwrap();
assert!(tok.is_private() && tok.registrant() == Some(&[0xbb; 32]) && tok.issuer_hash() == Some(&[0xaa; 32]));
assert!(tok.issuer() == ISSUER_PRIVATE && tok.issuer() != ISSUER_GITHUB);
let forgetful = |t: &Token| t.claim("iss").is_some_and(|i| i.is(ISSUERS[0])) && t.audience().is_some_and(|a| a.is("gate:release"));
assert!(forgetful(&tok));
let fooled_past_is_private = forgetful(&tok) && !tok.is_private();
let fooled_past_the_issuer = forgetful(&tok) && tok.issuer() == ISSUER_GITHUB;
assert!(!fooled_past_is_private);
assert!(!fooled_past_the_issuer);
assert_eq!(Token::read_any_from(&v2::ID, &[1; 32], d, 1000).unwrap_err(), Error::NotOidc);
assert_eq!(Token::read_any_from(&v2::ID, &v2::ID, d, 1000 + LATE).unwrap_err(), Error::Stale);
for (issuer, hash) in [(ISSUER_GITHUB, None), (ISSUER_GITLAB, None), (ISSUER_OTHER, Some(&[0xaa; 32]))] {
let (mut d, len) = account(issuer, payload, 1000);
d[T_IHASH..T_IHASH + 32].copy_from_slice(&[0xaa; 32]);
let tok = v2::read(&v2::ID, &d[..len], 1000).unwrap();
assert!(!tok.is_private() && tok.registrant().is_none() && tok.issuer_hash() == hash && tok.issuer() == issuer && tok.key() == &[9; 32]);
}
for issuer in [4u8, 200, 255] {
let (d, len) = account(issuer, payload, 1000);
assert_eq!(v2::read(&v2::ID, &d[..len], 1000).unwrap_err(), Error::Private);
assert!(Token::read_any_from(&v2::ID, &v2::ID, &d[..len], 1000).unwrap().is_private());
}
}
#[test]
fn check_key_is_knos_oidcs_rule_on_the_key_account_the_token_names() {
let (d, len) = account(ISSUER_GITHUB, br#"{"exp":1000}"#, 1000);
let tok = v2::read(&v2::ID, &d[..len], 1000).unwrap();
let key = |state: u8, flags: u8, active: i64, expires: i64| {
let mut k = [0u8; K_HDR + 8];
k[K_STATE] = state; k[K_FLAGS] = flags;
k[K_ACTIVE..K_ACTIVE + 8].copy_from_slice(&active.to_le_bytes());
k[K_EXPIRES..K_EXPIRES + 8].copy_from_slice(&expires.to_le_bytes());
k
};
let good = key(1, F_GENESIS | F_APPROVED, 500, 2000);
assert_eq!(tok.check_key(&[9; 32], &v2::ID, &good, 1000), Ok(()));
assert_eq!(tok.check_key(&[8; 32], &v2::ID, &good, 1000), Err(Error::Key)); assert_eq!(tok.check_key(&[9; 32], &[7; 32], &good, 1000), Err(Error::Key)); assert_eq!(tok.check_key(&[9; 32], &v2::ID, &good[..K_HDR - 1], 1000), Err(Error::Key));
assert_eq!(tok.check_key(&[9; 32], &v2::ID, &key(0, F_GENESIS, 500, 2000), 1000), Err(Error::Key));
assert_eq!(tok.check_key(&[9; 32], &v2::ID, &good, 499), Err(Error::KeyNotActive));
assert_eq!(tok.check_key(&[9; 32], &v2::ID, &key(1, 0, 500, 2000), 1000), Err(Error::KeyNotActive));
assert_eq!(tok.check_key(&[9; 32], &v2::ID, &good, 2000), Err(Error::KeyExpired));
assert_eq!(tok.check_key(&[9; 32], &v2::ID, &key(1, F_APPROVED | F_REVOKED, 500, 2000), 1000), Err(Error::KeyRevoked));
assert_eq!(tok.check_key(&[9; 32], &v2::ID, &key(1, F_PRIVATE, 500, 2000), 1000), Ok(()));
assert_eq!((Error::Key.code(), Error::KeyNotActive.code(), Error::KeyExpired.code(), Error::KeyRevoked.code()), (68, 76, 77, 78));
}
#[test]
fn fields_reads_a_flat_object_in_one_pass() {
let b = br#" { "a" : "x" , "n":12, "t":true, "o":{"a":"inner","k":[1,"}"]}, "s":"7" } "#;
let [a, n, t, o, s, none] = fields(b, [b"a", b"n", b"t", b"o", b"s", b"zz"]).unwrap();
assert!(text(a).unwrap().is("x") && number(n) == Ok(12) && number(s) == Ok(7) && none.is_none());
assert!(!t.unwrap().is_str && t.unwrap().bytes == b"true" && o.unwrap().bytes == br#"{"a":"inner","k":[1,"}"]}"#);
assert_eq!(text(n).unwrap_err(), Error::Claim); assert_eq!(number(t).unwrap_err(), Error::Claim);
assert!(fields(b"{}", [b"a"]).unwrap()[0].is_none());
}
#[test]
fn fields_refuses_what_knos_oidc_refuses() {
let json = |b: &[u8]| fields(b, [b"a"]).unwrap_err();
assert_eq!(json(br#"{"a":"x","a":"y"}"#), Error::Duplicate);
assert!(fields(br#"{"b":1,"b":2}"#, [b"a"]).is_ok()); let [a] = fields(br#"{"\u0061":"x"}"#, [b"a"]).unwrap();
assert!(text(a).unwrap().is("x"));
assert_eq!(json(br#"{"a":"x","\u0061":"y"}"#), Error::Duplicate);
assert!(fields(br#"{"\u0061b":"x","\n":1}"#, [b"a"]).unwrap()[0].is_none());
for bad in [&b""[..], b"[]", b"{", br#"{"a"}"#, br#"{"a":}"#, br#"{"a":"x"} x"#, br#"{"a":"x",}"#, br#"{"a":"x"#,
br#"{"a":[1,2"#,br#"{a:1}"#, br#"{"a":1 "b":2}"#] {
assert_eq!(json(bad), Error::Json, "{:?}", core::str::from_utf8(bad));
}
}
#[test]
fn text_decodes_the_escapes_of_printable_ascii_and_no_other() {
let t = |b: &'static [u8]| text(fields(b, [b"a"]).unwrap()[0]);
let v = t(br#"{"a":"octo\/widgets \u0041\u007e \\ \" end"}"#).unwrap();
let want = br#"octo/widgets A~ \ " end"#;
assert!(v.is(want) && v.len() == want.len() && v.starts_with("octo/") && !v.starts_with("octo\\"));
assert!(v.as_plain().is_none() && !v.is(&want[1..]) && !v.is("") && !v.is_empty());
let mut buf = [0u8; 64];
assert_eq!(v.copy_to(&mut buf), Some(&want[..]));
assert!(v.copy_to(&mut buf[..want.len() - 1]).is_none());
assert_eq!(t(br#"{"a":"plain"}"#).unwrap().as_plain(), Some(&b"plain"[..]));
assert!(t(br#"{"a":""}"#).unwrap().is_empty());
for bad in [&br#"{"a":"\n"}"#[..], br#"{"a":"\u001f"}"#, br#"{"a":"\u007f"}"#, br#"{"a":"\u00e9"}"#, br#"{"a":"\u00g1"}"#, br#"{"a":"\u004"}"#] {
assert_eq!(t(bad).unwrap_err(), Error::Claim, "{:?}", core::str::from_utf8(bad));
}
assert_eq!(text(None).unwrap_err(), Error::Claim);
}
#[test]
fn numbers_and_the_parts_of_an_audience() {
assert_eq!(parse_u64(b"0"), Some(0));
assert_eq!(parse_u64(b"999999999999999999"), Some(999_999_999_999_999_999));
for bad in [&b""[..], b"01", b"-1", b"1.0", b"1e3", b"1234567890123456789", b" 1"] { assert_eq!(parse_u64(bad), None); }
assert_eq!(parts::<3>(b"knos:claim:abc"), Some([&b"knos"[..], b"claim", b"abc"]));
assert!(parts::<3>(b"knos:claim").is_none() && parts::<3>(b"a:b:c:d").is_none());
assert!(is_hex(&[b'a'; 40], 40) && !is_hex(&[b'A'; 40], 40) && !is_hex(&[b'a'; 39], 40));
assert_eq!(unhex32(&[b'f'; 64]), Some([0xff; 32]));
assert!(unhex32(&[b'f'; 63]).is_none());
assert_eq!(b58_32(b"11111111111111111111111111111111"), Some([0; 32]));
assert!(b58_32(b"1111111111111111111111111111111").is_none() && b58_32(b"0OIl").is_none());
assert!(fresh(100, 100 + LATE - 1) && !fresh(100, 100 + LATE) && fresh(i64::MAX, 0));
assert_eq!((Error::Json.code(), Error::Duplicate.code(), Error::Claim.code()), (61, 62, 63));
}
}