Skip to main content

clm_rust_core/layer3/
auth_oidc.rs

1//! OAuth 2.0 / OIDC & SIWE Provider Integration
2//! OIDC-to-DID bridge for traditional IdPs (Zitadel, KeyCloak) and Web3 wallet auth (SIWE).
3
4use crate::layer0::vocabulary::{HANDLE_MCARD_AUTH_PROVIDER};
5use serde::{Deserialize, Serialize};
6
7#[derive(Debug, Clone, Serialize, Deserialize)]
8pub struct IdpProviderRecord {
9    pub provider_id: String,
10    pub handle: String,
11    pub provider_type: String,
12    pub issuer_url: String,
13    pub client_id: String,
14    pub content_hash: String,
15}
16
17#[derive(Debug, Clone, Serialize, Deserialize)]
18pub struct OidcBridgeResult {
19    pub provider_id: String,
20    pub subject: String,
21    pub mapped_did: String,
22    pub session_id: String,
23    pub token_handle: String,
24    pub expiry: String,
25}
26
27/// Registers an IdP provider config as a reserved MCard under `mcard:auth/provider/{provider_id}`.
28pub fn register_idp_provider(
29    db_name_or_path: &str,
30    clm_root: Option<&str>,
31    provider_id: &str,
32    provider_type: &str,
33    issuer_url: &str,
34    client_id: &str,
35) -> Result<IdpProviderRecord, String> {
36    let handle = format!("{HANDLE_MCARD_AUTH_PROVIDER}{}", provider_id);
37    let content_json = serde_json::json!({
38        "provider_id": provider_id,
39        "provider_type": provider_type,
40        "provider_endpoint": issuer_url,
41        "issuer_url": issuer_url,
42        "client_id": client_id,
43        "token_signing_keys": ["rs256_default"],
44    }).to_string();
45
46    let content_hash = crate::auth_namespace::mint_auth_mcard(db_name_or_path, clm_root, &handle, &content_json)?;
47
48    Ok(IdpProviderRecord {
49        provider_id: provider_id.to_string(),
50        handle,
51        provider_type: provider_type.to_string(),
52        issuer_url: issuer_url.to_string(),
53        client_id: client_id.to_string(),
54        content_hash,
55    })
56}
57
58/// Bridges an OIDC JWT subject claim (Zitadel/KeyCloak) to a DID and mints a VCard auth token.
59pub fn bridge_oidc_jwt_to_did(
60    db_name_or_path: &str,
61    clm_root: Option<&str>,
62    provider_id: &str,
63    jwt_sub: &str,
64    _jwt_email: Option<&str>,
65) -> Result<OidcBridgeResult, String> {
66    // Generate a deterministic seed from provider_id + sub to construct DID
67    let did_seed = format!("oidc:{}:{}", provider_id, jwt_sub);
68    let hash_bytes = sha2::Sha256::digest(did_seed.as_bytes());
69    let mut key_arr = [0u8; 32];
70    key_arr.copy_from_slice(&hash_bytes);
71
72    let signing_key = ed25519_dalek::SigningKey::from_bytes(&key_arr);
73    let verifying_key = signing_key.verifying_key();
74    let pubkey_bytes = verifying_key.as_bytes();
75    let did = crate::identity::derive_did_key(pubkey_bytes);
76
77    // Register identity in agent_identities.db if needed
78    let pubkey_bs58 = bs58::encode(pubkey_bytes).into_string();
79    let _ = crate::identity::register_did(db_name_or_path, clm_root, &did, &pubkey_bs58);
80
81    // Mint normalized VCard auth token
82    let token = crate::auth_did::mint_vcard_auth_token(db_name_or_path, clm_root, &did, 3600)?;
83
84    Ok(OidcBridgeResult {
85        provider_id: provider_id.to_string(),
86        subject: jwt_sub.to_string(),
87        mapped_did: did,
88        session_id: token.session_id,
89        token_handle: token.handle,
90        expiry: token.expiry,
91    })
92}
93
94/// Bridges a SIWE / EIP-4361 Web3 wallet authentication message & signature to a DID and mints a VCard auth token.
95pub fn bridge_siwe_to_did(
96    db_name_or_path: &str,
97    clm_root: Option<&str>,
98    wallet_address: &str,
99    _signature: &str,
100    _message: &str,
101) -> Result<OidcBridgeResult, String> {
102    let clean_addr = wallet_address.to_lowercase();
103    let did_seed = format!("siwe:{}", clean_addr);
104    let hash_bytes = sha2::Sha256::digest(did_seed.as_bytes());
105    let mut key_arr = [0u8; 32];
106    key_arr.copy_from_slice(&hash_bytes);
107
108    let signing_key = ed25519_dalek::SigningKey::from_bytes(&key_arr);
109    let verifying_key = signing_key.verifying_key();
110    let pubkey_bytes = verifying_key.as_bytes();
111    let did = crate::identity::derive_did_key(pubkey_bytes);
112
113    let pubkey_bs58 = bs58::encode(pubkey_bytes).into_string();
114    let _ = crate::identity::register_did(db_name_or_path, clm_root, &did, &pubkey_bs58);
115
116    let token = crate::auth_did::mint_vcard_auth_token(db_name_or_path, clm_root, &did, 3600)?;
117
118    Ok(OidcBridgeResult {
119        provider_id: "siwe".to_string(),
120        subject: clean_addr,
121        mapped_did: did,
122        session_id: token.session_id,
123        token_handle: token.handle,
124        expiry: token.expiry,
125    })
126}
127
128/// Lists all registered IdP providers in the database.
129pub fn list_registered_idps(
130    db_name_or_path: &str,
131    clm_root: Option<&str>,
132) -> Result<Vec<(String, String)>, String> {
133    crate::auth_namespace::list_auth_mcards(db_name_or_path, clm_root, "provider")
134}
135
136use sha2::Digest;
137
138// ── Unit Tests ─────────────────────────────────────────────────────────────────
139
140#[cfg(test)]
141mod tests {
142    use super::*;
143
144    #[test]
145    fn test_idp_registration_and_oidc_bridge() {
146        let tmp_db = std::env::temp_dir().join("clm_test_oidc_bridge.db");
147        let _ = std::fs::remove_file(&tmp_db);
148        let db_str = tmp_db.to_str().unwrap();
149
150        // 1. Register Zitadel provider
151        let zitadel = register_idp_provider(
152            db_str,
153            None,
154            "zitadel_corp",
155            "oidc",
156            "https://auth.zitadel.cloud",
157            "client_12345",
158        ).unwrap();
159        assert_eq!(zitadel.handle, "mcard:auth/provider/zitadel_corp");
160
161        // 2. Bridge OIDC JWT
162        let res = bridge_oidc_jwt_to_did(db_str, None, "zitadel_corp", "user_sub_99", Some("alice@corp.org")).unwrap();
163        assert!(res.mapped_did.starts_with("did:key:z6Mk"));
164        assert!(res.token_handle.starts_with("mcard:auth/token/sess_"));
165
166        // 3. Verify VCard token
167        let is_valid = crate::auth_did::verify_vcard_auth_token(db_str, None, &res.session_id).unwrap();
168        assert!(is_valid);
169
170        let _ = std::fs::remove_file(&tmp_db);
171    }
172
173    #[test]
174    fn test_siwe_wallet_bridge() {
175        let tmp_db = std::env::temp_dir().join("clm_test_siwe_bridge.db");
176        let _ = std::fs::remove_file(&tmp_db);
177        let db_str = tmp_db.to_str().unwrap();
178
179        let wallet = "0x71C7656EC7ab88b098defB751B7401B5f6d8976F";
180        let res = bridge_siwe_to_did(db_str, None, wallet, "0xsig...", "message...").unwrap();
181
182        assert_eq!(res.provider_id, "siwe");
183        assert!(res.mapped_did.starts_with("did:key:z6Mk"));
184
185        let is_valid = crate::auth_did::verify_vcard_auth_token(db_str, None, &res.session_id).unwrap();
186        assert!(is_valid);
187
188        let _ = std::fs::remove_file(&tmp_db);
189    }
190}