1use crate::errors::{AuthError, Result};
36use base64::Engine;
37use base64::engine::general_purpose::URL_SAFE_NO_PAD;
38use serde::{Deserialize, Serialize};
39use sha2::{Digest, Sha256};
40use std::collections::HashMap;
41
42#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
44pub enum SdHashAlgorithm {
45 #[serde(rename = "sha-256")]
47 #[default]
48 Sha256,
49}
50
51impl SdHashAlgorithm {
52 pub fn as_str(&self) -> &'static str {
54 match self {
55 Self::Sha256 => "sha-256",
56 }
57 }
58
59 fn digest(&self, input: &[u8]) -> Vec<u8> {
61 match self {
62 Self::Sha256 => Sha256::digest(input).to_vec(),
63 }
64 }
65}
66
67#[derive(Debug, Clone, Serialize, Deserialize)]
69pub struct SdJwtConfig {
70 pub hash_algorithm: SdHashAlgorithm,
72 pub signing_algorithm: jsonwebtoken::Algorithm,
74 pub issuer: String,
76 pub lifetime_secs: u64,
78 pub salt_length: usize,
80}
81
82impl Default for SdJwtConfig {
83 fn default() -> Self {
84 Self {
85 hash_algorithm: SdHashAlgorithm::default(),
86 signing_algorithm: jsonwebtoken::Algorithm::HS256,
87 issuer: "auth-framework".to_string(),
88 lifetime_secs: 3600,
89 salt_length: 16,
90 }
91 }
92}
93
94#[derive(Debug, Clone)]
96pub struct Disclosure {
97 pub encoded: String,
99 pub claim_name: String,
101 pub claim_value: serde_json::Value,
103 pub digest: String,
105}
106
107#[derive(Debug, Clone)]
110pub struct SdJwt {
111 pub jwt: String,
113 pub disclosures: Vec<Disclosure>,
115 pub key_binding_jwt: Option<String>,
117}
118
119impl SdJwt {
120 pub fn serialize(&self) -> String {
122 let mut out = self.jwt.clone();
123 for d in &self.disclosures {
124 out.push('~');
125 out.push_str(&d.encoded);
126 }
127 out.push('~');
128 if let Some(ref kb) = self.key_binding_jwt {
129 out.push_str(kb);
130 }
131 out
132 }
133
134 pub fn present(&self, claims_to_disclose: &[&str]) -> String {
136 let mut out = self.jwt.clone();
137 for d in &self.disclosures {
138 if claims_to_disclose.contains(&d.claim_name.as_str()) {
139 out.push('~');
140 out.push_str(&d.encoded);
141 }
142 }
143 out.push('~');
144 if let Some(ref kb) = self.key_binding_jwt {
145 out.push_str(kb);
146 }
147 out
148 }
149}
150
151pub struct SdJwtIssuer {
153 config: SdJwtConfig,
154}
155
156impl SdJwtIssuer {
157 pub fn new(config: SdJwtConfig) -> Self {
159 Self { config }
160 }
161
162 fn generate_salt(&self) -> Result<String> {
164 let mut salt = vec![0u8; self.config.salt_length];
165 ring::rand::SecureRandom::fill(&ring::rand::SystemRandom::new(), &mut salt)
166 .map_err(|_| AuthError::crypto("Failed to generate random salt"))?;
167 Ok(URL_SAFE_NO_PAD.encode(&salt))
168 }
169
170 fn create_disclosure(
172 &self,
173 claim_name: &str,
174 claim_value: &serde_json::Value,
175 ) -> Result<Disclosure> {
176 let salt = self.generate_salt()?;
177 let array = serde_json::json!([salt, claim_name, claim_value]);
178 let encoded = URL_SAFE_NO_PAD.encode(array.to_string().as_bytes());
179 let hash = self.config.hash_algorithm.digest(encoded.as_bytes());
180 let digest = URL_SAFE_NO_PAD.encode(&hash);
181
182 Ok(Disclosure {
183 encoded,
184 claim_name: claim_name.to_string(),
185 claim_value: claim_value.clone(),
186 digest,
187 })
188 }
189
190 pub fn issue(
198 &self,
199 claims: &serde_json::Map<String, serde_json::Value>,
200 sd_claims: &[&str],
201 signing_key: &str,
202 ) -> Result<SdJwt> {
203 if claims.is_empty() {
204 return Err(AuthError::validation("Claims map cannot be empty"));
205 }
206
207 let mut payload = serde_json::Map::new();
208 let mut disclosures = Vec::new();
209 let mut sd_digests: Vec<serde_json::Value> = Vec::new();
210
211 for (name, value) in claims {
213 if sd_claims.contains(&name.as_str()) {
214 let disclosure = self.create_disclosure(name, value)?;
215 sd_digests.push(serde_json::Value::String(disclosure.digest.clone()));
216 disclosures.push(disclosure);
217 } else {
218 payload.insert(name.clone(), value.clone());
219 }
220 }
221
222 let now = chrono::Utc::now().timestamp() as u64;
224 payload.insert("iss".to_string(), serde_json::json!(self.config.issuer));
225 payload.insert("iat".to_string(), serde_json::json!(now));
226 payload.insert(
227 "exp".to_string(),
228 serde_json::json!(now + self.config.lifetime_secs),
229 );
230
231 if !sd_digests.is_empty() {
233 payload.insert("_sd".to_string(), serde_json::Value::Array(sd_digests));
234 payload.insert(
235 "_sd_alg".to_string(),
236 serde_json::json!(self.config.hash_algorithm.as_str()),
237 );
238 }
239
240 let header = jsonwebtoken::Header::new(self.config.signing_algorithm);
242 let key = jsonwebtoken::EncodingKey::from_secret(signing_key.as_bytes());
243 let jwt = jsonwebtoken::encode(&header, &payload, &key)
244 .map_err(|e| AuthError::crypto(format!("SD-JWT signing failed: {e}")))?;
245
246 Ok(SdJwt {
247 jwt,
248 disclosures,
249 key_binding_jwt: None,
250 })
251 }
252}
253
254pub struct SdJwtVerifier {
256 config: SdJwtConfig,
257}
258
259impl SdJwtVerifier {
260 pub fn new(config: SdJwtConfig) -> Self {
262 Self { config }
263 }
264
265 pub fn parse(input: &str) -> Result<(String, Vec<String>, Option<String>)> {
267 let parts: Vec<&str> = input.split('~').collect();
268 if parts.len() < 2 {
269 return Err(AuthError::validation(
270 "Invalid SD-JWT format: must contain at least JWT~",
271 ));
272 }
273
274 let jwt = parts[0].to_string();
275 let last = *parts.last().expect("parts.len() >= 2 was checked above");
276
277 let (disclosure_parts, kb_jwt) = if last.is_empty() {
280 (&parts[1..parts.len() - 1], None)
281 } else if last.chars().filter(|&c| c == '.').count() == 2 {
282 (&parts[1..parts.len() - 1], Some(last.to_string()))
283 } else {
284 (&parts[1..], None)
285 };
286
287 let disclosures = disclosure_parts
288 .iter()
289 .filter(|s| !s.is_empty())
290 .map(|s| s.to_string())
291 .collect();
292
293 Ok((jwt, disclosures, kb_jwt))
294 }
295
296 pub fn verify(&self, sd_jwt_str: &str, verification_key: &str) -> Result<VerifiedSdJwt> {
301 let (jwt, disclosure_strings, kb_jwt) = Self::parse(sd_jwt_str)?;
302
303 let key = jsonwebtoken::DecodingKey::from_secret(verification_key.as_bytes());
305 let mut validation = jsonwebtoken::Validation::new(self.config.signing_algorithm);
306 validation.set_required_spec_claims::<&str>(&[]);
307 validation.validate_exp = true;
308 validation.set_issuer(&[&self.config.issuer]);
309
310 let token_data = jsonwebtoken::decode::<serde_json::Map<String, serde_json::Value>>(
311 &jwt,
312 &key,
313 &validation,
314 )
315 .map_err(|e| AuthError::token(format!("SD-JWT signature verification failed: {e}")))?;
316
317 let mut payload = token_data.claims;
318
319 let sd_digests: Vec<String> = payload
321 .remove("_sd")
322 .map(|v| {
323 v.as_array()
324 .unwrap_or(&vec![])
325 .iter()
326 .filter_map(|item| item.as_str().map(|s| s.to_string()))
327 .collect()
328 })
329 .unwrap_or_default();
330
331 let _sd_alg = payload.remove("_sd_alg");
332
333 let mut disclosed_claims = HashMap::new();
335 for disclosure_str in &disclosure_strings {
336 let decoded_bytes = URL_SAFE_NO_PAD
337 .decode(disclosure_str.as_bytes())
338 .map_err(|e| AuthError::validation(format!("Invalid disclosure encoding: {e}")))?;
339
340 let disclosure_array: serde_json::Value = serde_json::from_slice(&decoded_bytes)
341 .map_err(|e| AuthError::validation(format!("Invalid disclosure JSON: {e}")))?;
342
343 let arr = disclosure_array
344 .as_array()
345 .ok_or_else(|| AuthError::validation("Disclosure must be a JSON array"))?;
346
347 if arr.len() != 3 {
348 return Err(AuthError::validation(
349 "Disclosure array must have exactly 3 elements [salt, name, value]",
350 ));
351 }
352
353 let claim_name = arr[1]
354 .as_str()
355 .ok_or_else(|| AuthError::validation("Disclosure claim name must be a string"))?;
356 let claim_value = &arr[2];
357
358 let hash = self.config.hash_algorithm.digest(disclosure_str.as_bytes());
360 let digest = URL_SAFE_NO_PAD.encode(&hash);
361
362 if !sd_digests.contains(&digest) {
363 return Err(AuthError::validation(format!(
364 "Disclosure for '{}' does not match any _sd digest",
365 claim_name,
366 )));
367 }
368
369 disclosed_claims.insert(claim_name.to_string(), claim_value.clone());
370 }
371
372 Ok(VerifiedSdJwt {
373 plaintext_claims: payload,
374 disclosed_claims,
375 key_binding_jwt: kb_jwt,
376 })
377 }
378}
379
380#[derive(Debug, Clone)]
382pub struct VerifiedSdJwt {
383 pub plaintext_claims: serde_json::Map<String, serde_json::Value>,
385 pub disclosed_claims: HashMap<String, serde_json::Value>,
387 pub key_binding_jwt: Option<String>,
389}
390
391impl VerifiedSdJwt {
392 pub fn get_claim(&self, name: &str) -> Option<&serde_json::Value> {
394 self.disclosed_claims
395 .get(name)
396 .or_else(|| self.plaintext_claims.get(name))
397 }
398
399 pub fn all_claims(&self) -> serde_json::Map<String, serde_json::Value> {
401 let mut merged = self.plaintext_claims.clone();
402 for (k, v) in &self.disclosed_claims {
403 merged.insert(k.clone(), v.clone());
404 }
405 merged
406 }
407}
408
409#[cfg(test)]
410mod tests {
411 use super::*;
412
413 const TEST_KEY: &str = "test-signing-key-at-least-256-bits-long!!";
414
415 fn test_config() -> SdJwtConfig {
416 SdJwtConfig {
417 lifetime_secs: 3600,
418 ..SdJwtConfig::default()
419 }
420 }
421
422 fn sample_claims() -> serde_json::Map<String, serde_json::Value> {
423 let mut claims = serde_json::Map::new();
424 claims.insert("sub".into(), serde_json::json!("user-42"));
425 claims.insert("email".into(), serde_json::json!("user@example.com"));
426 claims.insert("name".into(), serde_json::json!("Alice"));
427 claims.insert(
428 "address".into(),
429 serde_json::json!({"street": "123 Main St", "city": "Springfield"}),
430 );
431 claims
432 }
433
434 #[test]
435 fn test_issue_and_serialize() {
436 let issuer = SdJwtIssuer::new(test_config());
437 let claims = sample_claims();
438 let sd_jwt = issuer
439 .issue(&claims, &["email", "address"], TEST_KEY)
440 .unwrap();
441
442 assert!(!sd_jwt.jwt.is_empty());
443 assert_eq!(sd_jwt.disclosures.len(), 2);
444
445 let serialized = sd_jwt.serialize();
446 assert_eq!(serialized.matches('~').count(), 3);
448 }
449
450 #[test]
451 fn test_issue_no_sd_claims() {
452 let issuer = SdJwtIssuer::new(test_config());
453 let claims = sample_claims();
454 let sd_jwt = issuer.issue(&claims, &[], TEST_KEY).unwrap();
455
456 assert!(sd_jwt.disclosures.is_empty());
457 let serialized = sd_jwt.serialize();
458 assert!(serialized.ends_with('~'));
459 }
460
461 #[test]
462 fn test_full_disclosure_roundtrip() {
463 let config = test_config();
464 let issuer = SdJwtIssuer::new(config.clone());
465 let verifier = SdJwtVerifier::new(config);
466 let claims = sample_claims();
467
468 let sd_jwt = issuer.issue(&claims, &["email", "name"], TEST_KEY).unwrap();
469 let serialized = sd_jwt.serialize();
470
471 let verified = verifier.verify(&serialized, TEST_KEY).unwrap();
472
473 assert_eq!(verified.get_claim("sub").unwrap(), "user-42");
474 assert_eq!(verified.get_claim("email").unwrap(), "user@example.com");
475 assert_eq!(verified.get_claim("name").unwrap(), "Alice");
476 }
477
478 #[test]
479 fn test_selective_disclosure() {
480 let config = test_config();
481 let issuer = SdJwtIssuer::new(config.clone());
482 let verifier = SdJwtVerifier::new(config);
483 let claims = sample_claims();
484
485 let sd_jwt = issuer
486 .issue(&claims, &["email", "name", "address"], TEST_KEY)
487 .unwrap();
488
489 let presentation = sd_jwt.present(&["email"]);
491
492 let verified = verifier.verify(&presentation, TEST_KEY).unwrap();
493
494 assert_eq!(verified.get_claim("sub").unwrap(), "user-42");
496 assert_eq!(verified.get_claim("email").unwrap(), "user@example.com");
498 assert!(verified.get_claim("name").is_none());
500 assert!(verified.get_claim("address").is_none());
501 }
502
503 #[test]
504 fn test_all_claims_merged() {
505 let config = test_config();
506 let issuer = SdJwtIssuer::new(config.clone());
507 let verifier = SdJwtVerifier::new(config);
508 let claims = sample_claims();
509
510 let sd_jwt = issuer.issue(&claims, &["email"], TEST_KEY).unwrap();
511 let serialized = sd_jwt.serialize();
512
513 let verified = verifier.verify(&serialized, TEST_KEY).unwrap();
514 let merged = verified.all_claims();
515
516 assert!(merged.contains_key("sub"));
517 assert!(merged.contains_key("email"));
518 assert!(merged.contains_key("iss"));
519 assert!(merged.contains_key("iat"));
520 assert!(merged.contains_key("exp"));
521 }
522
523 #[test]
524 fn test_reject_empty_claims() {
525 let issuer = SdJwtIssuer::new(test_config());
526 let claims = serde_json::Map::new();
527 assert!(issuer.issue(&claims, &[], TEST_KEY).is_err());
528 }
529
530 #[test]
531 fn test_reject_wrong_key() {
532 let config = test_config();
533 let issuer = SdJwtIssuer::new(config.clone());
534 let verifier = SdJwtVerifier::new(config);
535 let claims = sample_claims();
536
537 let sd_jwt = issuer.issue(&claims, &["email"], TEST_KEY).unwrap();
538 let serialized = sd_jwt.serialize();
539
540 assert!(
541 verifier
542 .verify(&serialized, "wrong-key-wrong-key-wrong-key!!!")
543 .is_err()
544 );
545 }
546
547 #[test]
548 fn test_reject_forged_disclosure() {
549 let config = test_config();
550 let issuer = SdJwtIssuer::new(config.clone());
551 let verifier = SdJwtVerifier::new(config);
552 let claims = sample_claims();
553
554 let sd_jwt = issuer.issue(&claims, &["email"], TEST_KEY).unwrap();
555
556 let forged = serde_json::json!(["fakesalt", "role", "admin"]);
558 let forged_encoded = URL_SAFE_NO_PAD.encode(forged.to_string().as_bytes());
559 let forged_sd_jwt = format!("{}~{}~", sd_jwt.jwt, forged_encoded);
560
561 assert!(verifier.verify(&forged_sd_jwt, TEST_KEY).is_err());
562 }
563
564 #[test]
565 fn test_parse_components() {
566 let input = "eyJ0eXAi.payload.sig~disc1~disc2~";
567 let (jwt, disclosures, kb) = SdJwtVerifier::parse(input).unwrap();
568 assert_eq!(jwt, "eyJ0eXAi.payload.sig");
569 assert_eq!(disclosures.len(), 2);
570 assert!(kb.is_none());
571 }
572
573 #[test]
574 fn test_parse_with_kb_jwt() {
575 let input = "eyJ0eXAi.payload.sig~disc1~header.payload.signature";
576 let (jwt, disclosures, kb) = SdJwtVerifier::parse(input).unwrap();
577 assert_eq!(jwt, "eyJ0eXAi.payload.sig");
578 assert_eq!(disclosures.len(), 1);
579 assert_eq!(kb.unwrap(), "header.payload.signature");
580 }
581
582 #[test]
583 fn test_disclosure_uniqueness() {
584 let issuer = SdJwtIssuer::new(test_config());
585 let claims = sample_claims();
586
587 let sd_jwt1 = issuer.issue(&claims, &["email"], TEST_KEY).unwrap();
588 let sd_jwt2 = issuer.issue(&claims, &["email"], TEST_KEY).unwrap();
589
590 assert_ne!(
592 sd_jwt1.disclosures[0].encoded,
593 sd_jwt2.disclosures[0].encoded
594 );
595 assert_ne!(sd_jwt1.disclosures[0].digest, sd_jwt2.disclosures[0].digest);
596 }
597
598 #[test]
599 fn test_complex_claim_value() {
600 let config = test_config();
601 let issuer = SdJwtIssuer::new(config.clone());
602 let verifier = SdJwtVerifier::new(config);
603
604 let mut claims = serde_json::Map::new();
605 claims.insert("sub".into(), serde_json::json!("user-1"));
606 claims.insert(
607 "address".into(),
608 serde_json::json!({
609 "street": "123 Main St",
610 "city": "Springfield",
611 "zip": "62701"
612 }),
613 );
614
615 let sd_jwt = issuer.issue(&claims, &["address"], TEST_KEY).unwrap();
616 let serialized = sd_jwt.serialize();
617 let verified = verifier.verify(&serialized, TEST_KEY).unwrap();
618
619 let addr = verified.get_claim("address").unwrap();
620 assert_eq!(addr["city"], "Springfield");
621 assert_eq!(addr["zip"], "62701");
622 }
623}