clm-kernel 0.0.15

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
//! DID Keyring ambient service provider (CRD-03).
//!
//! Normative Reference:
//!   clm/docs/spec/60-verification/crd_coeffect_taxonomy.yaml (service: did_keyring)

use dashmap::DashMap;
use ed25519_dalek::{Signer, SigningKey, Verifier, VerifyingKey};
use rand::rngs::OsRng;
use std::sync::Arc;

pub type KeyError = String;

pub trait DidKeyringService: Send + Sync {
    fn sign(&self, did: &str, payload: &[u8]) -> Result<Vec<u8>, KeyError>;
    fn verify(&self, did: &str, payload: &[u8], sig: &[u8]) -> Result<bool, KeyError>;
    fn get_public_key(&self, did: &str) -> Result<Vec<u8>, KeyError>;
}

pub struct InMemoryDidKeyring {
    keys: Arc<DashMap<String, (SigningKey, [u8; 32])>>,
}

impl InMemoryDidKeyring {
    pub fn new() -> Self {
        Self {
            keys: Arc::new(DashMap::new()),
        }
    }

    pub fn generate_keypair(&self) -> String {
        let mut csprng = OsRng;
        let signing_key = SigningKey::generate(&mut csprng);
        let pub_bytes = signing_key.verifying_key().to_bytes();
        let did = crate::identity::derive_did_key(&pub_bytes);
        self.keys.insert(did.clone(), (signing_key, pub_bytes));
        did
    }

    pub fn register_key(&self, signing_key: SigningKey) -> String {
        let pub_bytes = signing_key.verifying_key().to_bytes();
        let did = crate::identity::derive_did_key(&pub_bytes);
        self.keys.insert(did.clone(), (signing_key, pub_bytes));
        did
    }
}

impl Default for InMemoryDidKeyring {
    fn default() -> Self {
        Self::new()
    }
}

impl DidKeyringService for InMemoryDidKeyring {
    fn sign(&self, did: &str, payload: &[u8]) -> Result<Vec<u8>, KeyError> {
        let entry = self
            .keys
            .get(did)
            .ok_or_else(|| format!("DID '{}' not registered in keyring", did))?;
        let (signing_key, _) = entry.value();
        let sig = signing_key.sign(payload);
        Ok(sig.to_vec())
    }

    fn verify(&self, did: &str, payload: &[u8], sig: &[u8]) -> Result<bool, KeyError> {
        let pub_bytes = self.get_public_key(did)?;
        if pub_bytes.len() != 32 {
            return Ok(false);
        }
        let mut arr = [0u8; 32];
        arr.copy_from_slice(&pub_bytes);

        let verifying_key = VerifyingKey::from_bytes(&arr).map_err(|e| e.to_string())?;
        if sig.len() != 64 {
            return Ok(false);
        }
        let mut sig_arr = [0u8; 64];
        sig_arr.copy_from_slice(sig);
        let signature = ed25519_dalek::Signature::from_bytes(&sig_arr);

        Ok(verifying_key.verify(payload, &signature).is_ok())
    }

    fn get_public_key(&self, did: &str) -> Result<Vec<u8>, KeyError> {
        if let Some(entry) = self.keys.get(did) {
            return Ok(entry.value().1.to_vec());
        }

        // Try parsing did:key:z...
        if did.starts_with("did:key:z") {
            let b58_part = &did[9..];
            let decoded = bs58::decode(b58_part).into_vec().map_err(|e| e.to_string())?;
            if decoded.len() >= 34 && decoded[0] == 0xed && decoded[1] == 0x01 {
                return Ok(decoded[2..34].to_vec());
            }
        }
        Err(format!("Could not extract public key for DID: {}", did))
    }
}