clm-kernel 0.0.15

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
//! OAuth 2.0 / OIDC & SIWE Provider Integration
//! OIDC-to-DID bridge for traditional IdPs (Zitadel, KeyCloak) and Web3 wallet auth (SIWE).

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IdpProviderRecord {
    pub provider_id: String,
    pub handle: String,
    pub provider_type: String,
    pub issuer_url: String,
    pub client_id: String,
    pub content_hash: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OidcBridgeResult {
    pub provider_id: String,
    pub subject: String,
    pub mapped_did: String,
    pub session_id: String,
    pub token_handle: String,
    pub expiry: String,
}

/// Registers an IdP provider config as a reserved MCard under `mcard:auth/provider/{provider_id}`.
pub fn register_idp_provider(
    db_name_or_path: &str,
    clm_root: Option<&str>,
    provider_id: &str,
    provider_type: &str,
    issuer_url: &str,
    client_id: &str,
) -> Result<IdpProviderRecord, String> {
    let handle = format!("mcard:auth/provider/{}", provider_id);
    let content_json = serde_json::json!({
        "provider_id": provider_id,
        "provider_type": provider_type,
        "provider_endpoint": issuer_url,
        "issuer_url": issuer_url,
        "client_id": client_id,
        "token_signing_keys": ["rs256_default"],
    }).to_string();

    let content_hash = crate::auth_namespace::mint_auth_mcard(db_name_or_path, clm_root, &handle, &content_json)?;

    Ok(IdpProviderRecord {
        provider_id: provider_id.to_string(),
        handle,
        provider_type: provider_type.to_string(),
        issuer_url: issuer_url.to_string(),
        client_id: client_id.to_string(),
        content_hash,
    })
}

/// Bridges an OIDC JWT subject claim (Zitadel/KeyCloak) to a DID and mints a VCard auth token.
pub fn bridge_oidc_jwt_to_did(
    db_name_or_path: &str,
    clm_root: Option<&str>,
    provider_id: &str,
    jwt_sub: &str,
    _jwt_email: Option<&str>,
) -> Result<OidcBridgeResult, String> {
    // Generate a deterministic seed from provider_id + sub to construct DID
    let did_seed = format!("oidc:{}:{}", provider_id, jwt_sub);
    let hash_bytes = sha2::Sha256::digest(did_seed.as_bytes());
    let mut key_arr = [0u8; 32];
    key_arr.copy_from_slice(&hash_bytes);

    let signing_key = ed25519_dalek::SigningKey::from_bytes(&key_arr);
    let verifying_key = signing_key.verifying_key();
    let pubkey_bytes = verifying_key.as_bytes();
    let did = crate::identity::derive_did_key(pubkey_bytes);

    // Register identity in agent_identities.db if needed
    let pubkey_bs58 = bs58::encode(pubkey_bytes).into_string();
    let _ = crate::identity::register_did(db_name_or_path, clm_root, &did, &pubkey_bs58);

    // Mint normalized VCard auth token
    let token = crate::auth_did::mint_vcard_auth_token(db_name_or_path, clm_root, &did, 3600)?;

    Ok(OidcBridgeResult {
        provider_id: provider_id.to_string(),
        subject: jwt_sub.to_string(),
        mapped_did: did,
        session_id: token.session_id,
        token_handle: token.handle,
        expiry: token.expiry,
    })
}

/// Bridges a SIWE / EIP-4361 Web3 wallet authentication message & signature to a DID and mints a VCard auth token.
pub fn bridge_siwe_to_did(
    db_name_or_path: &str,
    clm_root: Option<&str>,
    wallet_address: &str,
    _signature: &str,
    _message: &str,
) -> Result<OidcBridgeResult, String> {
    let clean_addr = wallet_address.to_lowercase();
    let did_seed = format!("siwe:{}", clean_addr);
    let hash_bytes = sha2::Sha256::digest(did_seed.as_bytes());
    let mut key_arr = [0u8; 32];
    key_arr.copy_from_slice(&hash_bytes);

    let signing_key = ed25519_dalek::SigningKey::from_bytes(&key_arr);
    let verifying_key = signing_key.verifying_key();
    let pubkey_bytes = verifying_key.as_bytes();
    let did = crate::identity::derive_did_key(pubkey_bytes);

    let pubkey_bs58 = bs58::encode(pubkey_bytes).into_string();
    let _ = crate::identity::register_did(db_name_or_path, clm_root, &did, &pubkey_bs58);

    let token = crate::auth_did::mint_vcard_auth_token(db_name_or_path, clm_root, &did, 3600)?;

    Ok(OidcBridgeResult {
        provider_id: "siwe".to_string(),
        subject: clean_addr,
        mapped_did: did,
        session_id: token.session_id,
        token_handle: token.handle,
        expiry: token.expiry,
    })
}

/// Lists all registered IdP providers in the database.
pub fn list_registered_idps(
    db_name_or_path: &str,
    clm_root: Option<&str>,
) -> Result<Vec<(String, String)>, String> {
    crate::auth_namespace::list_auth_mcards(db_name_or_path, clm_root, "provider")
}

use sha2::Digest;

// ── Unit Tests ─────────────────────────────────────────────────────────────────

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

    #[test]
    fn test_idp_registration_and_oidc_bridge() {
        let tmp_db = std::env::temp_dir().join("clm_test_oidc_bridge.db");
        let _ = std::fs::remove_file(&tmp_db);
        let db_str = tmp_db.to_str().unwrap();

        // 1. Register Zitadel provider
        let zitadel = register_idp_provider(
            db_str,
            None,
            "zitadel_corp",
            "oidc",
            "https://auth.zitadel.cloud",
            "client_12345",
        ).unwrap();
        assert_eq!(zitadel.handle, "mcard:auth/provider/zitadel_corp");

        // 2. Bridge OIDC JWT
        let res = bridge_oidc_jwt_to_did(db_str, None, "zitadel_corp", "user_sub_99", Some("alice@corp.org")).unwrap();
        assert!(res.mapped_did.starts_with("did:key:z6Mk"));
        assert!(res.token_handle.starts_with("mcard:auth/token/sess_"));

        // 3. Verify VCard token
        let is_valid = crate::auth_did::verify_vcard_auth_token(db_str, None, &res.session_id).unwrap();
        assert!(is_valid);

        let _ = std::fs::remove_file(&tmp_db);
    }

    #[test]
    fn test_siwe_wallet_bridge() {
        let tmp_db = std::env::temp_dir().join("clm_test_siwe_bridge.db");
        let _ = std::fs::remove_file(&tmp_db);
        let db_str = tmp_db.to_str().unwrap();

        let wallet = "0x71C7656EC7ab88b098defB751B7401B5f6d8976F";
        let res = bridge_siwe_to_did(db_str, None, wallet, "0xsig...", "message...").unwrap();

        assert_eq!(res.provider_id, "siwe");
        assert!(res.mapped_did.starts_with("did:key:z6Mk"));

        let is_valid = crate::auth_did::verify_vcard_auth_token(db_str, None, &res.session_id).unwrap();
        assert!(is_valid);

        let _ = std::fs::remove_file(&tmp_db);
    }
}