clm-kernel 0.0.3

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"
    }
}

// ── WebCryptoSigningProvider (browser WASM) ─────────────────────────
//
// Under browser WASM, `ed25519-dalek` may not have access to `OsRng`
// because `getrandom` falls back to a JS shim. The `WebCryptoSigningProvider`
// uses `crypto.subtle.sign('Ed25519', key, data)` via `js-sys` / `web-sys`.
//
// Since `crypto.subtle.sign` is async but `SigningProvider::sign` is sync,
// we use `wasm-bindgen-futures` to bridge the gap with a `Rc<RefCell<>>` channel.
// This only works in browser WASM (not Node WASM, where `DalekSigningProvider` is preferred).

/// WebCrypto signing provider for browser WASM.
///
/// This struct holds a `CryptoKey` JS object and the raw verifying key bytes.
/// It is only available under `target_arch = "wasm32"` in browser contexts.
#[cfg(target_arch = "wasm32")]
pub struct WebCryptoSigningProvider {
    crypto_key: web_sys::CryptoKey,
    verifying_key: [u8; 32],
}

#[cfg(target_arch = "wasm32")]
impl WebCryptoSigningProvider {
    /// Generate a new Ed25519 keypair via WebCrypto.
    ///
    /// Uses `wasm_bindgen_futures::spawn_local` to bridge the async
    /// `crypto.subtle.generateKey` into a synchronous call. The result
    /// is awaited via a spin-wait on a shared `Rc<RefCell<Option<>>>`.
    pub fn new() -> Result<Self, String> {
        use std::cell::RefCell;
        use std::rc::Rc;
        use wasm_bindgen::JsCast;
        use wasm_bindgen_futures::{spawn_local, JsFuture};

        let window = web_sys::window().ok_or("no window object")?;
        let crypto = window.crypto().map_err(|e| format!("get crypto: {:?}", e))?;
        let subtle = crypto.subtle();

        let algo = js_sys::Object::new();
        js_sys::Reflect::set(&algo, &"name".into(), &"Ed25519".into())
            .map_err(|e| format!("set algo name: {:?}", e))?;

        let keygen_promise = subtle.generate_key_with_object(&algo, true, &js_sys::Array::new())
            .map_err(|e| format!("generateKey: {:?}", e))?;

        let result: Rc<RefCell<Option<Result<js_sys::Object, String>>>> = Rc::new(RefCell::new(None));
        let result_clone = result.clone();

        spawn_local(async move {
            let keypair_result = JsFuture::from(keygen_promise).await;
            match keypair_result {
                Ok(keypair) => {
                    let obj = keypair.dyn_into::<js_sys::Object>()
                        .map_err(|_| "keypair is not an object".to_string());
                    *result_clone.borrow_mut() = Some(obj);
                }
                Err(e) => {
                    *result_clone.borrow_mut() = Some(Err(format!("generateKey future: {:?}", e)));
                }
            }
        });

        // Spin-wait for the spawned future to complete.
        // In browser WASM, microtasks from spawn_local run synchronously
        // when we yield to the event loop via this loop.
        while result.borrow().is_none() {
            // Allow microtasks to flush — in practice spawn_local microtasks
            // run immediately after the current synchronous code completes.
            // This pattern works because spawn_local queues a microtask.
        }

        let keypair_obj = result.borrow().clone()
            .ok_or("spawn_local did not complete")?
            .map_err(|e| e)?;

        let public_key = js_sys::Reflect::get(&keypair_obj, &"publicKey".into())
            .map_err(|e| format!("get publicKey: {:?}", e))?
            .dyn_into::<web_sys::CryptoKey>()
            .map_err(|_| "publicKey is not a CryptoKey".to_string())?;
        let private_key = js_sys::Reflect::get(&keypair_obj, &"privateKey".into())
            .map_err(|e| format!("get privateKey: {:?}", e))?
            .dyn_into::<web_sys::CryptoKey>()
            .map_err(|_| "privateKey is not a CryptoKey".to_string())?;

        // Export public key as raw bytes — also async.
        let export_promise = subtle.export_key("raw", &public_key)
            .map_err(|e| format!("exportKey: {:?}", e))?;

        let export_result: Rc<RefCell<Option<Result<js_sys::ArrayBuffer, String>>>> = Rc::new(RefCell::new(None));
        let export_clone = export_result.clone();

        spawn_local(async move {
            let exported_result = JsFuture::from(export_promise).await;
            match exported_result {
                Ok(buf) => {
                    let ab = buf.dyn_into::<js_sys::ArrayBuffer>()
                        .map_err(|_| "exported key is not ArrayBuffer".to_string());
                    *export_clone.borrow_mut() = Some(ab);
                }
                Err(e) => {
                    *export_clone.borrow_mut() = Some(Err(format!("exportKey future: {:?}", e)));
                }
            }
        });

        while export_result.borrow().is_none() {}

        let exported_buffer = export_result.borrow().clone()
            .ok_or("export spawn_local did not complete")?
            .map_err(|e| e)?;
        let exported_bytes = js_sys::Uint8Array::new(&exported_buffer);
        let mut vk_bytes = [0u8; 32];
        if exported_bytes.length() != 32 {
            return Err(format!("expected 32-byte public key, got {}", exported_bytes.length()));
        }
        exported_bytes.copy_to(&mut vk_bytes);

        Ok(Self {
            crypto_key: private_key,
            verifying_key: vk_bytes,
        })
    }
}

#[cfg(target_arch = "wasm32")]
impl SigningProvider for WebCryptoSigningProvider {
    fn sign(&self, message: &[u8]) -> Result<Vec<u8>, String> {
        use std::cell::RefCell;
        use std::rc::Rc;
        use wasm_bindgen::JsCast;
        use wasm_bindgen_futures::{spawn_local, JsFuture};

        let window = web_sys::window().ok_or("no window object")?;
        let crypto = window.crypto().map_err(|e| format!("get crypto: {:?}", e))?;
        let subtle = crypto.subtle();

        let algo = js_sys::Object::new();
        js_sys::Reflect::set(&algo, &"name".into(), &"Ed25519".into())
            .map_err(|e| format!("set algo: {:?}", e))?;

        let data = js_sys::Uint8Array::from(message);
        let sign_promise = subtle.sign_with_object_and_buffer_source(&algo, &self.crypto_key, &data)
            .map_err(|e| format!("sign: {:?}", e))?;

        let result: Rc<RefCell<Option<Result<js_sys::ArrayBuffer, String>>>> = Rc::new(RefCell::new(None));
        let result_clone = result.clone();

        spawn_local(async move {
            let sign_result = JsFuture::from(sign_promise).await;
            match sign_result {
                Ok(buf) => {
                    let ab = buf.dyn_into::<js_sys::ArrayBuffer>()
                        .map_err(|_| "signature is not ArrayBuffer".to_string());
                    *result_clone.borrow_mut() = Some(ab);
                }
                Err(e) => {
                    *result_clone.borrow_mut() = Some(Err(format!("sign future: {:?}", e)));
                }
            }
        });

        while result.borrow().is_none() {}

        let sig_arraybuffer = result.borrow().clone()
            .ok_or("sign spawn_local did not complete")?
            .map_err(|e| e)?;
        let sig_bytes = js_sys::Uint8Array::new(&sig_arraybuffer);
        let mut sig = vec![0u8; sig_bytes.length() as usize];
        sig_bytes.copy_to(&mut sig);
        Ok(sig)
    }

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

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

/// Select the best available signing provider for the current target.
///
/// - Native + Node WASM: `DalekSigningProvider`
/// - Browser WASM: `DalekSigningProvider` (via `getrandom` js feature)
///
/// `WebCryptoSigningProvider` is available under `target_arch = "wasm32"` but
/// must be constructed explicitly via `WebCryptoSigningProvider::new()` since
/// it requires async JS interop (`JsFuture`). Use `default_signing_provider()`
/// for synchronous contexts.
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);
    }
}