clm-kernel 0.0.11

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
//! SigningProvider trait for Stage 1.3.
//!
//! Abstracts Ed25519 signing across native, Node WASM, and browser WASM:
//! - `DalekSigningProvider`: uses `ed25519-dalek` (native + Node WASM).
//! - `WebCryptoSigningProvider`: uses `crypto.subtle.sign` (browser WASM).
//!
//! The `SigningProvider` trait allows VCard sealing to work uniformly
//! regardless of the target platform.

use ed25519_dalek::{Signature, SigningKey, Verifier, VerifyingKey};

/// A signing key pair that can produce Ed25519 signatures.
pub trait SigningProvider: Send + Sync {
    /// Sign a message and return the signature bytes.
    fn sign(&self, message: &[u8]) -> Result<Vec<u8>, String>;

    /// Return the verifying (public) key bytes.
    fn verifying_key_bytes(&self) -> [u8; 32];

    /// Return the provider name (e.g. "dalek", "webcrypto").
    fn name(&self) -> &str;
}

/// Verify a signature against a verifying key.
pub fn verify_signature(
    verifying_key_bytes: &[u8; 32],
    message: &[u8],
    signature_bytes: &[u8],
) -> Result<bool, String> {
    let verifying_key = VerifyingKey::from_bytes(verifying_key_bytes)
        .map_err(|e| format!("invalid verifying key: {e}"))?;
    let signature = Signature::from_slice(signature_bytes)
        .map_err(|e| format!("invalid signature: {e}"))?;
    Ok(verifying_key.verify(message, &signature).is_ok())
}

// ── DalekSigningProvider ────────────────────────────────────────────

/// Ed25519 signing using `ed25519-dalek` (works in native and Node WASM).
pub struct DalekSigningProvider {
    signing_key: SigningKey,
    verifying_key: VerifyingKey,
}

impl DalekSigningProvider {
    /// Generate a new ephemeral keypair.
    pub fn generate() -> Self {
        use rand::rngs::OsRng;
        let signing_key = SigningKey::generate(&mut OsRng);
        let verifying_key = signing_key.verifying_key();
        Self {
            signing_key,
            verifying_key,
        }
    }

    /// Create from an existing seed (32 bytes).
    pub fn from_seed(seed: &[u8; 32]) -> Self {
        let signing_key = SigningKey::from_bytes(seed);
        let verifying_key = signing_key.verifying_key();
        Self {
            signing_key,
            verifying_key,
        }
    }

    /// Return the verifying key.
    pub fn verifying_key(&self) -> &VerifyingKey {
        &self.verifying_key
    }
}

impl SigningProvider for DalekSigningProvider {
    fn sign(&self, message: &[u8]) -> Result<Vec<u8>, String> {
        use ed25519_dalek::Signer;
        let sig: Signature = self.signing_key.sign(message);
        Ok(sig.to_bytes().to_vec())
    }

    fn verifying_key_bytes(&self) -> [u8; 32] {
        self.verifying_key.to_bytes()
    }

    fn name(&self) -> &str {
        "dalek"
    }
}

/// Select the default signing provider using Dalek ed25519.
pub fn default_signing_provider() -> Box<dyn SigningProvider> {
    Box::new(DalekSigningProvider::generate())
}

// ── Tests ───────────────────────────────────────────────────────────

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_dalek_sign_and_verify() {
        let provider = DalekSigningProvider::generate();
        let message = b"hello world";
        let sig = provider.sign(message).unwrap();
        let vk_bytes = provider.verifying_key_bytes();
        let valid = verify_signature(&vk_bytes, message, &sig).unwrap();
        assert!(valid);
    }

    #[test]
    fn test_dalek_verify_rejects_tampered() {
        let provider = DalekSigningProvider::generate();
        let message = b"hello world";
        let mut sig = provider.sign(message).unwrap();
        // Tamper with signature
        sig[0] ^= 0xff;
        let vk_bytes = provider.verifying_key_bytes();
        let valid = verify_signature(&vk_bytes, message, &sig).unwrap();
        assert!(!valid);
    }

    #[test]
    fn test_dalek_from_seed_deterministic() {
        let seed = [42u8; 32];
        let p1 = DalekSigningProvider::from_seed(&seed);
        let p2 = DalekSigningProvider::from_seed(&seed);
        assert_eq!(p1.verifying_key_bytes(), p2.verifying_key_bytes());

        let message = b"deterministic test";
        let s1 = p1.sign(message).unwrap();
        let s2 = p2.sign(message).unwrap();
        assert_eq!(s1, s2);
    }

    #[test]
    fn test_default_signing_provider() {
        let provider = default_signing_provider();
        assert_eq!(provider.name(), "dalek");
        let message = b"default provider test";
        let sig = provider.sign(message).unwrap();
        let vk = provider.verifying_key_bytes();
        assert!(verify_signature(&vk, message, &sig).unwrap());
    }

    #[test]
    fn test_signing_provider_trait_object() {
        let provider: Box<dyn SigningProvider> = Box::new(DalekSigningProvider::generate());
        let message = b"trait object test";
        let sig = provider.sign(message).unwrap();
        assert_eq!(sig.len(), 64); // Ed25519 signatures are 64 bytes
        let vk = provider.verifying_key_bytes();
        assert_eq!(vk.len(), 32); // Ed25519 public keys are 32 bytes
    }

    #[test]
    fn test_verify_rejects_wrong_key() {
        let p1 = DalekSigningProvider::generate();
        let p2 = DalekSigningProvider::generate();
        let message = b"wrong key test";
        let sig = p1.sign(message).unwrap();
        let wrong_vk = p2.verifying_key_bytes();
        let valid = verify_signature(&wrong_vk, message, &sig).unwrap();
        assert!(!valid);
    }
}