use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine as _};
use mid_issuer::canonical;
use mid_issuer::{EmbeddedRosterChainEntry, MidJwtPayload, VerificationMethod};
use p256::ecdsa::Signature;
use sha2::{Digest, Sha256};
use crate::error::VerifyError;
use crate::keys::{
key_bytes_from_did, key_bytes_from_multibase, point_for_did, point_for_vm,
pubkey_from_multibase,
};
mod verified {
use std::collections::HashSet;
use std::sync::{Mutex, OnceLock};
use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine as _};
pub(super) type Entry = [u8; 33 + 32 + 64];
const CAP: usize = 4096;
fn set() -> &'static Mutex<HashSet<Entry>> {
static SET: OnceLock<Mutex<HashSet<Entry>>> = OnceLock::new();
SET.get_or_init(Default::default)
}
pub(super) fn entry(key: &[u8; 33], prehash: &[u8; 32], sig_b64: &str) -> Option<Entry> {
let mut sig = [0u8; 66];
match URL_SAFE_NO_PAD.decode_slice(sig_b64, &mut sig) {
Ok(64) => {}
_ => return None,
}
let mut e = [0u8; 33 + 32 + 64];
e[..33].copy_from_slice(key);
e[33..65].copy_from_slice(prehash);
e[65..].copy_from_slice(&sig[..64]);
Some(e)
}
pub(super) fn verified_before(e: &Entry) -> bool {
set().lock().map(|s| s.contains(e)).unwrap_or(false)
}
pub(super) fn remember(e: Entry) {
if let Ok(mut s) = set().lock() {
if s.len() >= CAP {
s.clear();
}
s.insert(e);
}
}
}
fn decode_signature(b64: &str) -> Result<Signature, VerifyError> {
let bytes = URL_SAFE_NO_PAD.decode(b64).map_err(|source| VerifyError::Base64Decode {
segment: "signature",
source,
})?;
signature_from_raw(&bytes)
}
fn signature_from_raw(bytes: &[u8]) -> Result<Signature, VerifyError> {
if bytes.len() != 64 {
return Err(VerifyError::SignatureWrongLength {
actual: bytes.len(),
});
}
if bytes.iter().all(|&b| b == 0) {
return Err(VerifyError::SignatureInvalidScalars);
}
Signature::from_slice(bytes).map_err(|_| VerifyError::SignatureInvalidScalars)
}
pub fn check_genesis_self_signature(payload: &MidJwtPayload) -> Result<(), VerifyError> {
genesis_verified_hash(payload).map(|_| ())
}
pub(crate) fn genesis_verified_hash(payload: &MidJwtPayload) -> Result<[u8; 32], VerifyError> {
let genesis_key = key_bytes_from_did(&payload.iss)?;
let canonical_bytes = canonical::genesis_canonical_bytes(&payload.embedded_genesis_roster);
let prehash: [u8; 32] = Sha256::digest(&canonical_bytes).into();
let sig_b64 = &payload.embedded_genesis_roster.self_signed_by_genesis_key;
let seen = verified::entry(&genesis_key, &prehash, sig_b64);
if seen.as_ref().is_some_and(verified::verified_before) {
return Ok(prehash);
}
let genesis_pubkey = point_for_did(&genesis_key, &payload.iss)?;
let signature = decode_signature(sig_b64)?;
mata_ecdsa::verify_prehash(&genesis_pubkey, &prehash, &signature)
.map_err(|_| VerifyError::GenesisSignatureInvalid)?;
if let Some(e) = seen {
verified::remember(e);
}
Ok(prehash)
}
pub fn check_roster_chain(payload: &MidJwtPayload) -> Result<(), VerifyError> {
roster_chain_hashes(payload, &mut Vec::new())
}
pub(crate) fn roster_chain_hashes(
payload: &MidJwtPayload,
out: &mut Vec<(u64, [u8; 32])>,
) -> Result<(), VerifyError> {
let mut prior_vms: &[VerificationMethod] =
&payload.embedded_genesis_roster.verification_methods;
let mut prior_version: u64 = payload.embedded_genesis_roster.version;
for entry in &payload.embedded_roster_chain {
if entry.did != payload.iss {
return Err(VerifyError::ChainEntryDidMismatch {
entry_version: entry.version,
entry_did: entry.did.clone(),
});
}
out.push((entry.version, check_one_chain_entry(entry, prior_vms, prior_version)?));
prior_vms = &entry.verification_methods;
prior_version = entry.version;
}
Ok(())
}
fn check_one_chain_entry(
entry: &EmbeddedRosterChainEntry,
prior_vms: &[VerificationMethod],
prior_version: u64,
) -> Result<[u8; 32], VerifyError> {
if entry.version <= prior_version {
return Err(VerifyError::ChainVersionNotMonotonic {
entry_version: entry.version,
prior_version,
});
}
let signer_id = format!("{}#{}", entry.did, entry.signer_kid);
let signer_vm = prior_vms
.iter()
.find(|vm| vm.id == signer_id)
.ok_or_else(|| VerifyError::ChainSignerNotInPriorRoster {
entry_version: entry.version,
signer_kid: entry.signer_kid.clone(),
})?;
let signer_key = key_bytes_from_multibase(&signer_vm.public_key_multibase, &signer_vm.id)?;
let canonical_bytes = canonical::chain_entry_canonical_bytes(entry);
let prehash: [u8; 32] = Sha256::digest(&canonical_bytes).into();
let sig_b64 = &entry.signed_by_signer_in_prior_roster;
let seen = verified::entry(&signer_key, &prehash, sig_b64);
if seen.as_ref().is_some_and(verified::verified_before) {
return Ok(prehash);
}
let signer_pubkey = point_for_vm(&signer_key, &signer_vm.id)?;
let signature = decode_signature(sig_b64)?;
mata_ecdsa::verify_prehash(&signer_pubkey, &prehash, &signature)
.map_err(|_| VerifyError::ChainSignatureInvalid { entry_version: entry.version })?;
if let Some(e) = seen {
verified::remember(e);
}
Ok(prehash)
}
pub fn check_current_vm_in_head(payload: &MidJwtPayload) -> Result<(), VerifyError> {
let head_vms: &[VerificationMethod] = match payload.embedded_roster_chain.last() {
Some(head) => &head.verification_methods,
None => &payload.embedded_genesis_roster.verification_methods,
};
let current = &payload.embedded_verification_method;
let current_id = ¤t.id;
let rostered = head_vms.iter().any(|vm| {
vm.id == current.id
&& vm.public_key_multibase == current.public_key_multibase
&& vm.vm_type == current.vm_type
&& vm.controller == current.controller
});
if !rostered {
return Err(VerifyError::CurrentVmNotInHeadRoster {
vm_id: current_id.clone(),
});
}
Ok(())
}
pub fn check_jws_signature(
payload: &MidJwtPayload,
signing_input: &str,
signature_b64: &str,
) -> Result<(), VerifyError> {
let current_vm = &payload.embedded_verification_method;
let current_pubkey = pubkey_from_multibase(¤t_vm.public_key_multibase, ¤t_vm.id)?;
let prehash: [u8; 32] = Sha256::digest(signing_input.as_bytes()).into();
let signature_bytes =
URL_SAFE_NO_PAD.decode(signature_b64).map_err(|source| VerifyError::Base64Decode {
segment: "signature",
source,
})?;
let signature = signature_from_raw(&signature_bytes)?;
mata_ecdsa::verify_prehash(¤t_pubkey, &prehash, &signature)
.map_err(|_| VerifyError::JwtSignatureInvalid)
}
pub fn split_jws(jwt: &str) -> Result<JwsParts<'_>, VerifyError> {
let segments: Vec<&str> = jwt.split('.').collect();
if segments.len() != 3 {
return Err(VerifyError::InvalidJwsShape(segments.len()));
}
let header_b64 = segments[0];
let payload_b64 = segments[1];
let signature_b64 = segments[2];
let signing_input_end = header_b64.len() + 1 + payload_b64.len();
let signing_input = &jwt[..signing_input_end];
let header_bytes = URL_SAFE_NO_PAD.decode(header_b64).map_err(|source| {
VerifyError::Base64Decode { segment: "header", source }
})?;
let payload_bytes = URL_SAFE_NO_PAD.decode(payload_b64).map_err(|source| {
VerifyError::Base64Decode { segment: "payload", source }
})?;
Ok(JwsParts {
header_bytes,
payload_bytes,
signing_input,
signature_b64,
})
}
pub struct JwsParts<'a> {
pub header_bytes: Vec<u8>,
pub payload_bytes: Vec<u8>,
pub signing_input: &'a str,
pub signature_b64: &'a str,
}
pub fn validate_jws_header(header_bytes: &[u8]) -> Result<(), VerifyError> {
let header: serde_json::Value =
serde_json::from_slice(header_bytes).map_err(|_| VerifyError::InvalidJwsHeader)?;
let alg = header.get("alg").and_then(|v| v.as_str()).ok_or(VerifyError::InvalidJwsHeader)?;
let typ = header.get("typ").and_then(|v| v.as_str()).ok_or(VerifyError::InvalidJwsHeader)?;
if alg != "ES256" || typ != "JWT" {
return Err(VerifyError::InvalidJwsHeader);
}
Ok(())
}
#[cfg(test)]
mod signature_tests {
use super::*;
#[test]
fn all_zero_signature_is_rejected() {
let zeros = [0u8; 64];
assert!(matches!(
signature_from_raw(&zeros),
Err(VerifyError::SignatureInvalidScalars)
));
}
#[test]
fn wrong_length_is_reported_as_length_not_scalars() {
assert!(matches!(
signature_from_raw(&[1u8; 63]),
Err(VerifyError::SignatureWrongLength { actual: 63 })
));
}
#[test]
fn a_nonzero_64_byte_input_passes_the_zero_check() {
let mut sig = [0u8; 64];
sig[0] = 1;
sig[32] = 1;
assert!(!matches!(
signature_from_raw(&sig),
Err(VerifyError::SignatureWrongLength { .. })
));
}
}