use core::fmt;
use base64::Engine as _;
use base64::engine::general_purpose::STANDARD;
use indexmap::IndexMap;
use serde::de::DeserializeOwned;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use super::{Jwk, JwsAlgorithm, JwsError, JwsVerifier, SignError, VerificationError, base64url};
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct JwsHeader {
pub alg: JwsAlgorithm,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub typ: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub cty: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub kid: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub jwk: Option<Jwk>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub crit: Option<Vec<String>>,
#[serde(flatten)]
pub additional: IndexMap<String, Value>,
}
impl JwsHeader {
pub fn new(alg: JwsAlgorithm) -> Self {
Self {
alg,
typ: None,
cty: None,
kid: None,
jwk: None,
crit: None,
additional: IndexMap::new(),
}
}
#[must_use]
pub fn with_kid(mut self, kid: impl Into<String>) -> Self {
self.kid = Some(kid.into());
self
}
#[must_use]
pub fn with_typ(mut self, typ: impl Into<String>) -> Self {
self.typ = Some(typ.into());
self
}
#[must_use]
pub fn with_x5c<C: AsRef<[u8]>>(mut self, chain: &[C]) -> Self {
let chain = chain
.iter()
.map(|certificate| Value::String(STANDARD.encode(certificate)))
.collect();
self.additional
.insert("x5c".to_owned(), Value::Array(chain));
self
}
pub fn for_signer(signer: &dyn Signer) -> Self {
let header = Self::new(signer.alg());
match signer.x5c().filter(|chain| !chain.is_empty()) {
Some(chain) => header.with_x5c(chain),
None => Self {
kid: signer.kid().map(str::to_owned),
..header
},
}
}
}
#[derive(Debug, Clone)]
pub struct CompactJws {
token: String,
signing_input_end: usize,
header: JwsHeader,
payload: Vec<u8>,
signature: Vec<u8>,
}
impl CompactJws {
pub fn decode(token: &str) -> Result<Self, JwsError> {
let mut parts = token.split('.');
let (Some(header_b64), Some(payload_b64), Some(signature_b64), None) =
(parts.next(), parts.next(), parts.next(), parts.next())
else {
return Err(JwsError::InvalidFormat {
parts: token.split('.').count(),
});
};
let header_json = base64url::decode(header_b64)
.map_err(|_| JwsError::InvalidBase64Url { part: "header" })?;
let header = parse_header(&header_json)?;
let payload = base64url::decode(payload_b64)
.map_err(|_| JwsError::InvalidBase64Url { part: "payload" })?;
let signature = base64url::decode(signature_b64)
.map_err(|_| JwsError::InvalidBase64Url { part: "signature" })?;
Ok(Self {
token: token.to_owned(),
signing_input_end: header_b64.len() + 1 + payload_b64.len(),
header,
payload,
signature,
})
}
pub fn header(&self) -> &JwsHeader {
&self.header
}
pub fn alg(&self) -> JwsAlgorithm {
self.header.alg
}
pub fn kid(&self) -> Option<&str> {
self.header.kid.as_deref()
}
pub fn signing_input(&self) -> &[u8] {
&self.token.as_bytes()[..self.signing_input_end]
}
pub fn payload(&self) -> &[u8] {
&self.payload
}
pub fn signature(&self) -> &[u8] {
&self.signature
}
pub fn claims<T: DeserializeOwned>(&self) -> Result<T, JwsError> {
serde_json::from_slice(&self.payload).map_err(|e| JwsError::InvalidPayload {
reason: "not JSON of the expected shape".to_owned(),
source: Some(e),
})
}
pub fn as_str(&self) -> &str {
&self.token
}
pub fn verify<V: JwsVerifier + ?Sized>(
&self,
verifier: &V,
key: &Jwk,
) -> Result<(), VerificationError> {
verifier.verify(self.alg(), self.signing_input(), &self.signature, key)
}
}
impl fmt::Display for CompactJws {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.token)
}
}
impl AsRef<str> for CompactJws {
fn as_ref(&self) -> &str {
&self.token
}
}
fn header_error(reason: &str, source: serde_json::Error) -> JwsError {
JwsError::InvalidHeader {
reason: reason.to_owned(),
source: Some(source),
}
}
fn parse_header(json: &[u8]) -> Result<JwsHeader, JwsError> {
let value: Value = serde_json::from_slice(json).map_err(|e| header_error("not JSON", e))?;
let Some(object) = value.as_object() else {
return Err(JwsError::InvalidHeader {
reason: "not a JSON object".to_owned(),
source: None,
});
};
match object.get("alg") {
Some(Value::String(alg)) if alg.parse::<JwsAlgorithm>().is_ok() => {}
Some(Value::String(alg)) => return Err(JwsError::UnsupportedAlgorithm(alg.clone())),
Some(other) => return Err(JwsError::UnsupportedAlgorithm(other.to_string())),
None => {
return Err(JwsError::InvalidHeader {
reason: "missing `alg`".to_owned(),
source: None,
});
}
}
if object
.get("b64")
.is_some_and(|b64| b64 != &Value::Bool(true))
{
return Err(JwsError::UnencodedPayload);
}
let header: JwsHeader =
serde_json::from_value(value).map_err(|e| header_error("a member is malformed", e))?;
if let Some(crit) = &header.crit {
return Err(JwsError::UnsupportedCritical(crit.clone()));
}
Ok(header)
}
#[async_trait::async_trait]
pub trait Signer: Send + Sync {
fn alg(&self) -> JwsAlgorithm;
fn kid(&self) -> Option<&str>;
fn x5c(&self) -> Option<&[Vec<u8>]> {
None
}
async fn sign(&self, signing_input: &[u8]) -> Result<Vec<u8>, SignError>;
}
macro_rules! forward_signer {
($($ty:ty),* $(,)?) => {$(
#[async_trait::async_trait]
#[deny(clippy::missing_trait_methods)]
impl<T: Signer + ?Sized> Signer for $ty {
fn alg(&self) -> JwsAlgorithm {
(**self).alg()
}
fn kid(&self) -> Option<&str> {
(**self).kid()
}
fn x5c(&self) -> Option<&[Vec<u8>]> {
(**self).x5c()
}
async fn sign(&self, signing_input: &[u8]) -> Result<Vec<u8>, SignError> {
(**self).sign(signing_input).await
}
}
)*};
}
forward_signer!(&T, Box<T>, std::sync::Arc<T>);
#[derive(Debug, Clone)]
pub struct CertifiedSigner<S> {
signer: S,
chain: Vec<Vec<u8>>,
}
impl<S: Signer> CertifiedSigner<S> {
pub fn new(signer: S, chain: Vec<Vec<u8>>) -> Self {
Self { signer, chain }
}
pub fn signer(&self) -> &S {
&self.signer
}
}
#[async_trait::async_trait]
impl<S: Signer> Signer for CertifiedSigner<S> {
fn alg(&self) -> JwsAlgorithm {
self.signer.alg()
}
fn kid(&self) -> Option<&str> {
self.signer.kid()
}
fn x5c(&self) -> Option<&[Vec<u8>]> {
Some(&self.chain)
}
async fn sign(&self, signing_input: &[u8]) -> Result<Vec<u8>, SignError> {
self.signer.sign(signing_input).await
}
}
pub async fn encode_compact(
header: &JwsHeader,
payload: &[u8],
signer: &dyn Signer,
) -> Result<String, JwsError> {
if header.alg != signer.alg() {
return Err(JwsError::AlgorithmMismatch {
header: header.alg,
signer: signer.alg(),
});
}
let header_json =
serde_json::to_vec(header).map_err(|e| header_error("not serializable", e))?;
let mut token = base64url::encode(&header_json);
token.push('.');
token.push_str(&base64url::encode(payload));
let signature = signer
.sign(token.as_bytes())
.await
.map_err(JwsError::Signer)?;
token.push('.');
token.push_str(&base64url::encode(&signature));
Ok(token)
}