use p256::ecdsa::VerifyingKey;
use crate::error::VerifyError;
pub fn pubkey_from_did(did: &str) -> Result<VerifyingKey, VerifyError> {
point_for_did(&key_bytes_from_did(did)?, did)
}
pub(crate) fn key_bytes_from_did(did: &str) -> Result<[u8; 33], 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() })?;
bytes.try_into().map_err(|_| VerifyError::MalformedDid { did: did.to_string() })
}
pub(crate) fn point_for_did(bytes: &[u8; 33], did: &str) -> Result<VerifyingKey, VerifyError> {
decoded_point(bytes).ok_or_else(|| VerifyError::MalformedDid { did: did.to_string() })
}
fn decoded_point(bytes: &[u8; 33]) -> Option<VerifyingKey> {
use std::collections::HashMap;
use std::sync::{Mutex, OnceLock};
const CAP: usize = 4096;
static POINTS: OnceLock<Mutex<HashMap<[u8; 33], VerifyingKey>>> = OnceLock::new();
let points = POINTS.get_or_init(Default::default);
if let Some(k) = points.lock().ok().and_then(|m| m.get(bytes).copied()) {
return Some(k);
}
let key = VerifyingKey::from_sec1_bytes(bytes).ok()?;
if let Ok(mut m) = points.lock() {
if m.len() >= CAP {
m.clear();
}
m.insert(*bytes, key);
}
Some(key)
}
pub fn pubkey_from_multibase(mb: &str, vm_id: &str) -> Result<VerifyingKey, VerifyError> {
point_for_vm(&key_bytes_from_multibase(mb, vm_id)?, vm_id)
}
pub(crate) fn key_bytes_from_multibase(mb: &str, vm_id: &str) -> Result<[u8; 33], 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() })?;
bytes.try_into().map_err(|_| VerifyError::MalformedVmPubkey { vm_id: vm_id.to_string() })
}
pub(crate) fn point_for_vm(bytes: &[u8; 33], vm_id: &str) -> Result<VerifyingKey, VerifyError> {
decoded_point(bytes).ok_or_else(|| 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);
}
}