1use 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
27pub 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
58pub 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 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 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 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
94pub 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
128pub 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#[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 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 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 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}