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::hazmat::PrehashVerifier;
use p256::ecdsa::Signature;
use sha2::{Digest, Sha256};
use crate::error::VerifyError;
use crate::keys::{pubkey_from_did, pubkey_from_multibase};
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> {
let genesis_pubkey = pubkey_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 signature =
decode_signature(&payload.embedded_genesis_roster.self_signed_by_genesis_key)?;
genesis_pubkey
.verify_prehash(&prehash, &signature)
.map_err(|_| VerifyError::GenesisSignatureInvalid)
}
pub fn check_roster_chain(payload: &MidJwtPayload) -> 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(),
});
}
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<(), 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_pubkey = pubkey_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 signature = decode_signature(&entry.signed_by_signer_in_prior_roster)?;
signer_pubkey
.verify_prehash(&prehash, &signature)
.map_err(|_| VerifyError::ChainSignatureInvalid { entry_version: entry.version })
}
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)?;
current_pubkey
.verify_prehash(&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 { .. })
));
}
}