Skip to main content

clm_rust_core/services/
did_keyring.rs

1//! DID Keyring ambient service provider (CRD-03).
2//!
3//! Normative Reference:
4//!   clm/docs/spec/60-verification/crd_coeffect_taxonomy.yaml (service: did_keyring)
5
6use 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        // Try parsing did:key:z...
89        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}