clm_rust_core/services/
did_keyring.rs1use dashmap::DashMap;
7use ed25519_dalek::{Signer, SigningKey, Verifier, VerifyingKey};
8use rand::rngs::OsRng;
9use std::sync::Arc;
10
11pub type KeyError = String;
12
13pub trait DidKeyringService: Send + Sync {
14 fn sign(&self, did: &str, payload: &[u8]) -> Result<Vec<u8>, KeyError>;
15 fn verify(&self, did: &str, payload: &[u8], sig: &[u8]) -> Result<bool, KeyError>;
16 fn get_public_key(&self, did: &str) -> Result<Vec<u8>, KeyError>;
17}
18
19pub struct InMemoryDidKeyring {
20 keys: Arc<DashMap<String, (SigningKey, [u8; 32])>>,
21}
22
23impl InMemoryDidKeyring {
24 pub fn new() -> Self {
25 Self {
26 keys: Arc::new(DashMap::new()),
27 }
28 }
29
30 pub fn generate_keypair(&self) -> String {
31 let mut csprng = OsRng;
32 let signing_key = SigningKey::generate(&mut csprng);
33 let pub_bytes = signing_key.verifying_key().to_bytes();
34 let did = crate::identity::derive_did_key(&pub_bytes);
35 self.keys.insert(did.clone(), (signing_key, pub_bytes));
36 did
37 }
38
39 pub fn register_key(&self, signing_key: SigningKey) -> String {
40 let pub_bytes = signing_key.verifying_key().to_bytes();
41 let did = crate::identity::derive_did_key(&pub_bytes);
42 self.keys.insert(did.clone(), (signing_key, pub_bytes));
43 did
44 }
45}
46
47impl Default for InMemoryDidKeyring {
48 fn default() -> Self {
49 Self::new()
50 }
51}
52
53impl DidKeyringService for InMemoryDidKeyring {
54 fn sign(&self, did: &str, payload: &[u8]) -> Result<Vec<u8>, KeyError> {
55 let entry = self
56 .keys
57 .get(did)
58 .ok_or_else(|| format!("DID '{}' not registered in keyring", did))?;
59 let (signing_key, _) = entry.value();
60 let sig = signing_key.sign(payload);
61 Ok(sig.to_vec())
62 }
63
64 fn verify(&self, did: &str, payload: &[u8], sig: &[u8]) -> Result<bool, KeyError> {
65 let pub_bytes = self.get_public_key(did)?;
66 if pub_bytes.len() != 32 {
67 return Ok(false);
68 }
69 let mut arr = [0u8; 32];
70 arr.copy_from_slice(&pub_bytes);
71
72 let verifying_key = VerifyingKey::from_bytes(&arr).map_err(|e| e.to_string())?;
73 if sig.len() != 64 {
74 return Ok(false);
75 }
76 let mut sig_arr = [0u8; 64];
77 sig_arr.copy_from_slice(sig);
78 let signature = ed25519_dalek::Signature::from_bytes(&sig_arr);
79
80 Ok(verifying_key.verify(payload, &signature).is_ok())
81 }
82
83 fn get_public_key(&self, did: &str) -> Result<Vec<u8>, KeyError> {
84 if let Some(entry) = self.keys.get(did) {
85 return Ok(entry.value().1.to_vec());
86 }
87
88 if did.starts_with(crate::layer0::vocabulary_identities::DID_KEY_Z) {
90 let b58_part = &did[9..];
91 let decoded = bs58::decode(b58_part).into_vec().map_err(|e| e.to_string())?;
92 if decoded.len() >= 34 && decoded[0] == 0xed && decoded[1] == 0x01 {
93 return Ok(decoded[2..34].to_vec());
94 }
95 }
96 Err(format!("Could not extract public key for DID: {}", did))
97 }
98}