use p256::ecdsa::VerifyingKey;
use crate::error::VerifyError;
pub fn pubkey_from_did(did: &str) -> Result<VerifyingKey, VerifyError> {
let suffix = did
.strip_prefix("did:mata:")
.ok_or_else(|| VerifyError::MalformedDid { did: did.to_string() })?;
let bytes = bs58::decode(suffix)
.into_vec()
.map_err(|_| VerifyError::MalformedDid { did: did.to_string() })?;
if bytes.len() != 33 {
return Err(VerifyError::MalformedDid { did: did.to_string() });
}
VerifyingKey::from_sec1_bytes(&bytes)
.map_err(|_| VerifyError::MalformedDid { did: did.to_string() })
}
pub fn pubkey_from_multibase(mb: &str, vm_id: &str) -> Result<VerifyingKey, VerifyError> {
let suffix = mb
.strip_prefix('z')
.ok_or_else(|| VerifyError::MalformedVmPubkey { vm_id: vm_id.to_string() })?;
let bytes = bs58::decode(suffix)
.into_vec()
.map_err(|_| VerifyError::MalformedVmPubkey { vm_id: vm_id.to_string() })?;
if bytes.len() != 33 {
return Err(VerifyError::MalformedVmPubkey { vm_id: vm_id.to_string() });
}
VerifyingKey::from_sec1_bytes(&bytes)
.map_err(|_| VerifyError::MalformedVmPubkey { vm_id: vm_id.to_string() })
}
pub fn did_from_pubkey(verifying_key: &VerifyingKey) -> String {
let encoded = verifying_key.to_encoded_point(true); let bytes = encoded.as_bytes();
debug_assert_eq!(bytes.len(), 33);
format!("did:mata:{}", bs58::encode(bytes).into_string())
}
pub fn multibase_from_pubkey(verifying_key: &VerifyingKey) -> String {
let encoded = verifying_key.to_encoded_point(true);
let bytes = encoded.as_bytes();
debug_assert_eq!(bytes.len(), 33);
format!("z{}", bs58::encode(bytes).into_string())
}
#[cfg(test)]
mod tests {
use super::*;
use p256::ecdsa::SigningKey;
use sha2::{Digest, Sha256};
fn test_key(seed: &str) -> SigningKey {
let mut hasher = Sha256::new();
hasher.update(seed.as_bytes());
hasher.update(b"-mid-verify-test-seed");
let bytes: [u8; 32] = hasher.finalize().into();
SigningKey::from_bytes(&bytes.into()).unwrap()
}
#[test]
fn round_trip_pubkey_through_did() {
let sk = test_key("device-A");
let vk = *sk.verifying_key();
let did = did_from_pubkey(&vk);
let recovered = pubkey_from_did(&did).unwrap();
assert_eq!(vk.to_encoded_point(true), recovered.to_encoded_point(true));
}
#[test]
fn round_trip_pubkey_through_multibase() {
let sk = test_key("device-A");
let vk = *sk.verifying_key();
let mb = multibase_from_pubkey(&vk);
let recovered = pubkey_from_multibase(&mb, "did:mata:abc#dev").unwrap();
assert_eq!(vk.to_encoded_point(true), recovered.to_encoded_point(true));
}
#[test]
fn pubkey_from_did_rejects_non_mata_prefix() {
let err = pubkey_from_did("did:key:zFakeKey").unwrap_err();
matches!(err, VerifyError::MalformedDid { .. });
}
#[test]
fn pubkey_from_did_rejects_uuid_suffix() {
let err = pubkey_from_did("did:mata:550e8400-e29b-41d4-a716-446655440000").unwrap_err();
matches!(err, VerifyError::MalformedDid { .. });
}
#[test]
fn pubkey_from_did_rejects_random_base58() {
let err = pubkey_from_did("did:mata:abc123").unwrap_err();
matches!(err, VerifyError::MalformedDid { .. });
}
#[test]
fn pubkey_from_multibase_rejects_missing_z_prefix() {
let sk = test_key("device-A");
let vk = *sk.verifying_key();
let mb_no_z = bs58::encode(vk.to_encoded_point(true).as_bytes()).into_string();
let err = pubkey_from_multibase(&mb_no_z, "test#vm").unwrap_err();
matches!(err, VerifyError::MalformedVmPubkey { .. });
}
#[test]
fn two_different_keys_produce_different_dids() {
let sk_a = test_key("device-A");
let sk_b = test_key("device-B");
let did_a = did_from_pubkey(sk_a.verifying_key());
let did_b = did_from_pubkey(sk_b.verifying_key());
assert_ne!(did_a, did_b);
}
}