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(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
107impl std::fmt::Debug for Disclosure {
108 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
109 let mut d = f.debug_struct("Disclosure");
110 d.field("encoded", &crate::utils::redact::redacted(&self.encoded));
111 d.field("claim_name", &self.claim_name);
112 d.field("claim_value", &self.claim_value);
113 d.field("digest", &self.digest);
114 d.finish()
115 }
116}
117
118#[derive(Clone)]
121pub struct SdJwt {
122 pub jwt: String,
124 pub disclosures: Vec<Disclosure>,
126 pub key_binding_jwt: Option<String>,
128}
129
130impl std::fmt::Debug for SdJwt {
131 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
132 let mut d = f.debug_struct("SdJwt");
133 d.field("jwt", &crate::utils::redact::redacted(&self.jwt));
134 d.field("disclosures", &self.disclosures);
135 d.field(
136 "key_binding_jwt",
137 &crate::utils::redact::redacted(&self.key_binding_jwt),
138 );
139 d.finish()
140 }
141}
142
143impl SdJwt {
144 pub fn serialize(&self) -> String {
146 let mut out = self.jwt.clone();
147 for d in &self.disclosures {
148 out.push('~');
149 out.push_str(&d.encoded);
150 }
151 out.push('~');
152 if let Some(ref kb) = self.key_binding_jwt {
153 out.push_str(kb);
154 }
155 out
156 }
157
158 pub fn present(&self, claims_to_disclose: &[&str]) -> String {
160 let mut out = self.jwt.clone();
161 for d in &self.disclosures {
162 if claims_to_disclose.contains(&d.claim_name.as_str()) {
163 out.push('~');
164 out.push_str(&d.encoded);
165 }
166 }
167 out.push('~');
168 if let Some(ref kb) = self.key_binding_jwt {
169 out.push_str(kb);
170 }
171 out
172 }
173}
174
175pub struct SdJwtIssuer {
177 config: SdJwtConfig,
178}
179
180impl SdJwtIssuer {
181 pub fn new(config: SdJwtConfig) -> Self {
183 Self { config }
184 }
185
186 fn generate_salt(&self) -> Result<String> {
188 let mut salt = vec![0u8; self.config.salt_length];
189 ring::rand::SecureRandom::fill(&ring::rand::SystemRandom::new(), &mut salt)
190 .map_err(|_| AuthError::crypto("Failed to generate random salt"))?;
191 Ok(URL_SAFE_NO_PAD.encode(&salt))
192 }
193
194 fn create_disclosure(
196 &self,
197 claim_name: &str,
198 claim_value: &serde_json::Value,
199 ) -> Result<Disclosure> {
200 let salt = self.generate_salt()?;
201 let array = serde_json::json!([salt, claim_name, claim_value]);
202 let encoded = URL_SAFE_NO_PAD.encode(array.to_string().as_bytes());
203 let hash = self.config.hash_algorithm.digest(encoded.as_bytes());
204 let digest = URL_SAFE_NO_PAD.encode(&hash);
205
206 Ok(Disclosure {
207 encoded,
208 claim_name: claim_name.to_string(),
209 claim_value: claim_value.clone(),
210 digest,
211 })
212 }
213
214 pub fn issue(
222 &self,
223 claims: &serde_json::Map<String, serde_json::Value>,
224 sd_claims: &[&str],
225 signing_key: &str,
226 ) -> Result<SdJwt> {
227 if claims.is_empty() {
228 return Err(AuthError::validation("Claims map cannot be empty"));
229 }
230
231 let mut payload = serde_json::Map::new();
232 let mut disclosures = Vec::new();
233 let mut sd_digests: Vec<serde_json::Value> = Vec::new();
234
235 for (name, value) in claims {
237 if sd_claims.contains(&name.as_str()) {
238 let disclosure = self.create_disclosure(name, value)?;
239 sd_digests.push(serde_json::Value::String(disclosure.digest.clone()));
240 disclosures.push(disclosure);
241 } else {
242 payload.insert(name.clone(), value.clone());
243 }
244 }
245
246 let now = chrono::Utc::now().timestamp() as u64;
248 payload.insert("iss".to_string(), serde_json::json!(self.config.issuer));
249 payload.insert("iat".to_string(), serde_json::json!(now));
250 payload.insert(
251 "exp".to_string(),
252 serde_json::json!(now + self.config.lifetime_secs),
253 );
254
255 if !sd_digests.is_empty() {
257 payload.insert("_sd".to_string(), serde_json::Value::Array(sd_digests));
258 payload.insert(
259 "_sd_alg".to_string(),
260 serde_json::json!(self.config.hash_algorithm.as_str()),
261 );
262 }
263
264 let header = jsonwebtoken::Header::new(self.config.signing_algorithm);
266 let key = jsonwebtoken::EncodingKey::from_secret(signing_key.as_bytes());
267 let jwt = jsonwebtoken::encode(&header, &payload, &key)
268 .map_err(|e| AuthError::crypto(format!("SD-JWT signing failed: {e}")))?;
269
270 Ok(SdJwt {
271 jwt,
272 disclosures,
273 key_binding_jwt: None,
274 })
275 }
276}
277
278pub struct SdJwtVerifier {
280 config: SdJwtConfig,
281}
282
283impl SdJwtVerifier {
284 pub fn new(config: SdJwtConfig) -> Self {
286 Self { config }
287 }
288
289 pub fn parse(input: &str) -> Result<(String, Vec<String>, Option<String>)> {
291 let parts: Vec<&str> = input.split('~').collect();
292 if parts.len() < 2 {
293 return Err(AuthError::validation(
294 "Invalid SD-JWT format: must contain at least JWT~",
295 ));
296 }
297
298 let jwt = parts[0].to_string();
299 let last = *parts
300 .last()
301 .ok_or_else(|| AuthError::validation("Invalid SD-JWT format: no parts"))?;
302
303 let (disclosure_parts, kb_jwt) = if last.is_empty() {
306 (&parts[1..parts.len() - 1], None)
307 } else if last.chars().filter(|&c| c == '.').count() == 2 {
308 (&parts[1..parts.len() - 1], Some(last.to_string()))
309 } else {
310 (&parts[1..], None)
311 };
312
313 let disclosures = disclosure_parts
314 .iter()
315 .filter(|s| !s.is_empty())
316 .map(|s| s.to_string())
317 .collect();
318
319 Ok((jwt, disclosures, kb_jwt))
320 }
321
322 pub fn verify(&self, sd_jwt_str: &str, verification_key: &str) -> Result<VerifiedSdJwt> {
327 let (jwt, disclosure_strings, kb_jwt) = Self::parse(sd_jwt_str)?;
328
329 let key = jsonwebtoken::DecodingKey::from_secret(verification_key.as_bytes());
331 let mut validation = jsonwebtoken::Validation::new(self.config.signing_algorithm);
332 validation.set_required_spec_claims::<&str>(&[]);
333 validation.validate_exp = true;
334 validation.set_issuer(&[&self.config.issuer]);
335
336 let token_data = jsonwebtoken::decode::<serde_json::Map<String, serde_json::Value>>(
337 &jwt,
338 &key,
339 &validation,
340 )
341 .map_err(|e| AuthError::token(format!("SD-JWT signature verification failed: {e}")))?;
342
343 let mut payload = token_data.claims;
344
345 let sd_digests: Vec<String> = payload
347 .remove("_sd")
348 .map(|v| {
349 v.as_array()
350 .unwrap_or(&vec![])
351 .iter()
352 .filter_map(|item| item.as_str().map(|s| s.to_string()))
353 .collect()
354 })
355 .unwrap_or_default();
356
357 let _sd_alg = payload.remove("_sd_alg");
358
359 let mut disclosed_claims = HashMap::new();
361 for disclosure_str in &disclosure_strings {
362 let decoded_bytes = URL_SAFE_NO_PAD
363 .decode(disclosure_str.as_bytes())
364 .map_err(|e| AuthError::validation(format!("Invalid disclosure encoding: {e}")))?;
365
366 let disclosure_array: serde_json::Value = serde_json::from_slice(&decoded_bytes)
367 .map_err(|e| AuthError::validation(format!("Invalid disclosure JSON: {e}")))?;
368
369 let arr = disclosure_array
370 .as_array()
371 .ok_or_else(|| AuthError::validation("Disclosure must be a JSON array"))?;
372
373 if arr.len() != 3 {
374 return Err(AuthError::validation(
375 "Disclosure array must have exactly 3 elements [salt, name, value]",
376 ));
377 }
378
379 let claim_name = arr[1]
380 .as_str()
381 .ok_or_else(|| AuthError::validation("Disclosure claim name must be a string"))?;
382 let claim_value = &arr[2];
383
384 let hash = self.config.hash_algorithm.digest(disclosure_str.as_bytes());
386 let digest = URL_SAFE_NO_PAD.encode(&hash);
387
388 if !sd_digests.contains(&digest) {
389 return Err(AuthError::validation(format!(
390 "Disclosure for '{}' does not match any _sd digest",
391 claim_name,
392 )));
393 }
394
395 disclosed_claims.insert(claim_name.to_string(), claim_value.clone());
396 }
397
398 Ok(VerifiedSdJwt {
399 plaintext_claims: payload,
400 disclosed_claims,
401 key_binding_jwt: kb_jwt,
402 })
403 }
404}
405
406#[derive(Clone)]
408pub struct VerifiedSdJwt {
409 pub plaintext_claims: serde_json::Map<String, serde_json::Value>,
411 pub disclosed_claims: HashMap<String, serde_json::Value>,
413 pub key_binding_jwt: Option<String>,
415}
416
417impl std::fmt::Debug for VerifiedSdJwt {
418 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
419 let mut d = f.debug_struct("VerifiedSdJwt");
420 d.field("plaintext_claims", &self.plaintext_claims);
421 d.field("disclosed_claims", &self.disclosed_claims);
422 d.field(
423 "key_binding_jwt",
424 &crate::utils::redact::redacted(&self.key_binding_jwt),
425 );
426 d.finish()
427 }
428}
429
430impl VerifiedSdJwt {
431 pub fn get_claim(&self, name: &str) -> Option<&serde_json::Value> {
433 self.disclosed_claims
434 .get(name)
435 .or_else(|| self.plaintext_claims.get(name))
436 }
437
438 pub fn all_claims(&self) -> serde_json::Map<String, serde_json::Value> {
440 let mut merged = self.plaintext_claims.clone();
441 for (k, v) in &self.disclosed_claims {
442 merged.insert(k.clone(), v.clone());
443 }
444 merged
445 }
446}
447
448#[cfg(test)]
449mod tests {
450 use super::*;
451
452 const TEST_KEY: &str = "test-signing-key-at-least-256-bits-long!!";
453
454 fn test_config() -> SdJwtConfig {
455 SdJwtConfig {
456 lifetime_secs: 3600,
457 ..SdJwtConfig::default()
458 }
459 }
460
461 fn sample_claims() -> serde_json::Map<String, serde_json::Value> {
462 let mut claims = serde_json::Map::new();
463 claims.insert("sub".into(), serde_json::json!("user-42"));
464 claims.insert("email".into(), serde_json::json!("user@example.com"));
465 claims.insert("name".into(), serde_json::json!("Alice"));
466 claims.insert(
467 "address".into(),
468 serde_json::json!({"street": "123 Main St", "city": "Springfield"}),
469 );
470 claims
471 }
472
473 #[test]
474 fn test_issue_and_serialize() {
475 let issuer = SdJwtIssuer::new(test_config());
476 let claims = sample_claims();
477 let sd_jwt = issuer
478 .issue(&claims, &["email", "address"], TEST_KEY)
479 .unwrap();
480
481 assert!(!sd_jwt.jwt.is_empty());
482 assert_eq!(sd_jwt.disclosures.len(), 2);
483
484 let serialized = sd_jwt.serialize();
485 assert_eq!(serialized.matches('~').count(), 3);
487 }
488
489 #[test]
490 fn test_issue_no_sd_claims() {
491 let issuer = SdJwtIssuer::new(test_config());
492 let claims = sample_claims();
493 let sd_jwt = issuer.issue(&claims, &[], TEST_KEY).unwrap();
494
495 assert!(sd_jwt.disclosures.is_empty());
496 let serialized = sd_jwt.serialize();
497 assert!(serialized.ends_with('~'));
498 }
499
500 #[test]
501 fn test_full_disclosure_roundtrip() {
502 let config = test_config();
503 let issuer = SdJwtIssuer::new(config.clone());
504 let verifier = SdJwtVerifier::new(config);
505 let claims = sample_claims();
506
507 let sd_jwt = issuer.issue(&claims, &["email", "name"], TEST_KEY).unwrap();
508 let serialized = sd_jwt.serialize();
509
510 let verified = verifier.verify(&serialized, TEST_KEY).unwrap();
511
512 assert_eq!(verified.get_claim("sub").unwrap(), "user-42");
513 assert_eq!(verified.get_claim("email").unwrap(), "user@example.com");
514 assert_eq!(verified.get_claim("name").unwrap(), "Alice");
515 }
516
517 #[test]
518 fn test_selective_disclosure() {
519 let config = test_config();
520 let issuer = SdJwtIssuer::new(config.clone());
521 let verifier = SdJwtVerifier::new(config);
522 let claims = sample_claims();
523
524 let sd_jwt = issuer
525 .issue(&claims, &["email", "name", "address"], TEST_KEY)
526 .unwrap();
527
528 let presentation = sd_jwt.present(&["email"]);
530
531 let verified = verifier.verify(&presentation, TEST_KEY).unwrap();
532
533 assert_eq!(verified.get_claim("sub").unwrap(), "user-42");
535 assert_eq!(verified.get_claim("email").unwrap(), "user@example.com");
537 assert!(verified.get_claim("name").is_none());
539 assert!(verified.get_claim("address").is_none());
540 }
541
542 #[test]
543 fn test_all_claims_merged() {
544 let config = test_config();
545 let issuer = SdJwtIssuer::new(config.clone());
546 let verifier = SdJwtVerifier::new(config);
547 let claims = sample_claims();
548
549 let sd_jwt = issuer.issue(&claims, &["email"], TEST_KEY).unwrap();
550 let serialized = sd_jwt.serialize();
551
552 let verified = verifier.verify(&serialized, TEST_KEY).unwrap();
553 let merged = verified.all_claims();
554
555 assert!(merged.contains_key("sub"));
556 assert!(merged.contains_key("email"));
557 assert!(merged.contains_key("iss"));
558 assert!(merged.contains_key("iat"));
559 assert!(merged.contains_key("exp"));
560 }
561
562 #[test]
563 fn test_reject_empty_claims() {
564 let issuer = SdJwtIssuer::new(test_config());
565 let claims = serde_json::Map::new();
566 assert!(issuer.issue(&claims, &[], TEST_KEY).is_err());
567 }
568
569 #[test]
570 fn test_reject_wrong_key() {
571 let config = test_config();
572 let issuer = SdJwtIssuer::new(config.clone());
573 let verifier = SdJwtVerifier::new(config);
574 let claims = sample_claims();
575
576 let sd_jwt = issuer.issue(&claims, &["email"], TEST_KEY).unwrap();
577 let serialized = sd_jwt.serialize();
578
579 assert!(
580 verifier
581 .verify(&serialized, "wrong-key-wrong-key-wrong-key!!!")
582 .is_err()
583 );
584 }
585
586 #[test]
587 fn test_reject_forged_disclosure() {
588 let config = test_config();
589 let issuer = SdJwtIssuer::new(config.clone());
590 let verifier = SdJwtVerifier::new(config);
591 let claims = sample_claims();
592
593 let sd_jwt = issuer.issue(&claims, &["email"], TEST_KEY).unwrap();
594
595 let forged = serde_json::json!(["fakesalt", "role", "admin"]);
597 let forged_encoded = URL_SAFE_NO_PAD.encode(forged.to_string().as_bytes());
598 let forged_sd_jwt = format!("{}~{}~", sd_jwt.jwt, forged_encoded);
599
600 assert!(verifier.verify(&forged_sd_jwt, TEST_KEY).is_err());
601 }
602
603 #[test]
604 fn test_parse_components() {
605 let input = "eyJ0eXAi.payload.sig~disc1~disc2~";
606 let (jwt, disclosures, kb) = SdJwtVerifier::parse(input).unwrap();
607 assert_eq!(jwt, "eyJ0eXAi.payload.sig");
608 assert_eq!(disclosures.len(), 2);
609 assert!(kb.is_none());
610 }
611
612 #[test]
613 fn test_parse_with_kb_jwt() {
614 let input = "eyJ0eXAi.payload.sig~disc1~header.payload.signature";
615 let (jwt, disclosures, kb) = SdJwtVerifier::parse(input).unwrap();
616 assert_eq!(jwt, "eyJ0eXAi.payload.sig");
617 assert_eq!(disclosures.len(), 1);
618 assert_eq!(kb.unwrap(), "header.payload.signature");
619 }
620
621 #[test]
622 fn test_disclosure_uniqueness() {
623 let issuer = SdJwtIssuer::new(test_config());
624 let claims = sample_claims();
625
626 let sd_jwt1 = issuer.issue(&claims, &["email"], TEST_KEY).unwrap();
627 let sd_jwt2 = issuer.issue(&claims, &["email"], TEST_KEY).unwrap();
628
629 assert_ne!(
631 sd_jwt1.disclosures[0].encoded,
632 sd_jwt2.disclosures[0].encoded
633 );
634 assert_ne!(sd_jwt1.disclosures[0].digest, sd_jwt2.disclosures[0].digest);
635 }
636
637 #[test]
638 fn test_complex_claim_value() {
639 let config = test_config();
640 let issuer = SdJwtIssuer::new(config.clone());
641 let verifier = SdJwtVerifier::new(config);
642
643 let mut claims = serde_json::Map::new();
644 claims.insert("sub".into(), serde_json::json!("user-1"));
645 claims.insert(
646 "address".into(),
647 serde_json::json!({
648 "street": "123 Main St",
649 "city": "Springfield",
650 "zip": "62701"
651 }),
652 );
653
654 let sd_jwt = issuer.issue(&claims, &["address"], TEST_KEY).unwrap();
655 let serialized = sd_jwt.serialize();
656 let verified = verifier.verify(&serialized, TEST_KEY).unwrap();
657
658 let addr = verified.get_claim("address").unwrap();
659 assert_eq!(addr["city"], "Springfield");
660 assert_eq!(addr["zip"], "62701");
661 }
662}