use base64::Engine;
use serde::Deserialize;
use serde_json::{Map, Value};
pub const MAX_TOKEN_BYTES: usize = 8 * 1024;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, thiserror::Error)]
#[non_exhaustive]
pub enum VerifyError {
#[error("the token is malformed")]
Malformed,
#[error("no key matched the token")]
UnknownKey,
#[error("the signature is invalid")]
Signature,
#[error("the claims are not acceptable")]
Claims,
}
#[derive(Debug, Deserialize)]
pub(crate) struct Header {
pub(crate) alg: String,
pub(crate) kid: Option<String>,
crit: Option<Value>,
b64: Option<bool>,
}
pub(crate) const B64: base64::engine::general_purpose::GeneralPurpose =
base64::engine::general_purpose::URL_SAFE_NO_PAD;
pub(crate) fn split(token: &str) -> Result<(&str, &str, &str), VerifyError> {
if token.len() > MAX_TOKEN_BYTES {
return Err(VerifyError::Malformed);
}
let mut parts = token.split('.');
let (header, payload, signature) = (
parts.next().ok_or(VerifyError::Malformed)?,
parts.next().ok_or(VerifyError::Malformed)?,
parts.next().ok_or(VerifyError::Malformed)?,
);
if parts.next().is_some() || header.is_empty() || payload.is_empty() || signature.is_empty() {
return Err(VerifyError::Malformed);
}
Ok((header, payload, signature))
}
pub(crate) fn header(encoded: &str) -> Result<Header, VerifyError> {
let bytes = B64.decode(encoded).map_err(|_| VerifyError::Malformed)?;
let header: Header = serde_json::from_slice(&bytes).map_err(|_| VerifyError::Malformed)?;
if header.alg != "RS256" || header.crit.is_some() || header.b64 == Some(false) {
return Err(VerifyError::Malformed);
}
Ok(header)
}
pub(crate) fn signature(
n: &str,
e: &str,
signed: &str,
encoded_signature: &str,
) -> Result<(), VerifyError> {
let components = ring::signature::RsaPublicKeyComponents {
n: B64.decode(n).map_err(|_| VerifyError::UnknownKey)?,
e: B64.decode(e).map_err(|_| VerifyError::UnknownKey)?,
};
let signature = B64
.decode(encoded_signature)
.map_err(|_| VerifyError::Malformed)?;
components
.verify(
&ring::signature::RSA_PKCS1_2048_8192_SHA256,
signed.as_bytes(),
&signature,
)
.map_err(|_| VerifyError::Signature)
}
pub(crate) fn payload(encoded: &str) -> Result<Map<String, Value>, VerifyError> {
let bytes = B64.decode(encoded).map_err(|_| VerifyError::Malformed)?;
serde_json::from_slice(&bytes).map_err(|_| VerifyError::Malformed)
}
pub(crate) fn audience_matches(claims: &Map<String, Value>, accepted: &[String]) -> bool {
let is_accepted = |audience: &str| accepted.iter().any(|candidate| candidate == audience);
match claims.get("aud") {
Some(Value::String(audience)) => is_accepted(audience),
Some(Value::Array(audiences)) => {
audiences.iter().filter_map(Value::as_str).any(is_accepted)
}
Some(_) => false,
None => claims
.get("client_id")
.and_then(Value::as_str)
.is_some_and(is_accepted),
}
}