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.last().expect("parts.len() >= 2 was checked above");
300
301 let (disclosure_parts, kb_jwt) = if last.is_empty() {
304 (&parts[1..parts.len() - 1], None)
305 } else if last.chars().filter(|&c| c == '.').count() == 2 {
306 (&parts[1..parts.len() - 1], Some(last.to_string()))
307 } else {
308 (&parts[1..], None)
309 };
310
311 let disclosures = disclosure_parts
312 .iter()
313 .filter(|s| !s.is_empty())
314 .map(|s| s.to_string())
315 .collect();
316
317 Ok((jwt, disclosures, kb_jwt))
318 }
319
320 pub fn verify(&self, sd_jwt_str: &str, verification_key: &str) -> Result<VerifiedSdJwt> {
325 let (jwt, disclosure_strings, kb_jwt) = Self::parse(sd_jwt_str)?;
326
327 let key = jsonwebtoken::DecodingKey::from_secret(verification_key.as_bytes());
329 let mut validation = jsonwebtoken::Validation::new(self.config.signing_algorithm);
330 validation.set_required_spec_claims::<&str>(&[]);
331 validation.validate_exp = true;
332 validation.set_issuer(&[&self.config.issuer]);
333
334 let token_data = jsonwebtoken::decode::<serde_json::Map<String, serde_json::Value>>(
335 &jwt,
336 &key,
337 &validation,
338 )
339 .map_err(|e| AuthError::token(format!("SD-JWT signature verification failed: {e}")))?;
340
341 let mut payload = token_data.claims;
342
343 let sd_digests: Vec<String> = payload
345 .remove("_sd")
346 .map(|v| {
347 v.as_array()
348 .unwrap_or(&vec![])
349 .iter()
350 .filter_map(|item| item.as_str().map(|s| s.to_string()))
351 .collect()
352 })
353 .unwrap_or_default();
354
355 let _sd_alg = payload.remove("_sd_alg");
356
357 let mut disclosed_claims = HashMap::new();
359 for disclosure_str in &disclosure_strings {
360 let decoded_bytes = URL_SAFE_NO_PAD
361 .decode(disclosure_str.as_bytes())
362 .map_err(|e| AuthError::validation(format!("Invalid disclosure encoding: {e}")))?;
363
364 let disclosure_array: serde_json::Value = serde_json::from_slice(&decoded_bytes)
365 .map_err(|e| AuthError::validation(format!("Invalid disclosure JSON: {e}")))?;
366
367 let arr = disclosure_array
368 .as_array()
369 .ok_or_else(|| AuthError::validation("Disclosure must be a JSON array"))?;
370
371 if arr.len() != 3 {
372 return Err(AuthError::validation(
373 "Disclosure array must have exactly 3 elements [salt, name, value]",
374 ));
375 }
376
377 let claim_name = arr[1]
378 .as_str()
379 .ok_or_else(|| AuthError::validation("Disclosure claim name must be a string"))?;
380 let claim_value = &arr[2];
381
382 let hash = self.config.hash_algorithm.digest(disclosure_str.as_bytes());
384 let digest = URL_SAFE_NO_PAD.encode(&hash);
385
386 if !sd_digests.contains(&digest) {
387 return Err(AuthError::validation(format!(
388 "Disclosure for '{}' does not match any _sd digest",
389 claim_name,
390 )));
391 }
392
393 disclosed_claims.insert(claim_name.to_string(), claim_value.clone());
394 }
395
396 Ok(VerifiedSdJwt {
397 plaintext_claims: payload,
398 disclosed_claims,
399 key_binding_jwt: kb_jwt,
400 })
401 }
402}
403
404#[derive(Clone)]
406pub struct VerifiedSdJwt {
407 pub plaintext_claims: serde_json::Map<String, serde_json::Value>,
409 pub disclosed_claims: HashMap<String, serde_json::Value>,
411 pub key_binding_jwt: Option<String>,
413}
414
415impl std::fmt::Debug for VerifiedSdJwt {
416 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
417 let mut d = f.debug_struct("VerifiedSdJwt");
418 d.field("plaintext_claims", &self.plaintext_claims);
419 d.field("disclosed_claims", &self.disclosed_claims);
420 d.field(
421 "key_binding_jwt",
422 &crate::utils::redact::redacted(&self.key_binding_jwt),
423 );
424 d.finish()
425 }
426}
427
428impl VerifiedSdJwt {
429 pub fn get_claim(&self, name: &str) -> Option<&serde_json::Value> {
431 self.disclosed_claims
432 .get(name)
433 .or_else(|| self.plaintext_claims.get(name))
434 }
435
436 pub fn all_claims(&self) -> serde_json::Map<String, serde_json::Value> {
438 let mut merged = self.plaintext_claims.clone();
439 for (k, v) in &self.disclosed_claims {
440 merged.insert(k.clone(), v.clone());
441 }
442 merged
443 }
444}
445
446#[cfg(test)]
447mod tests {
448 use super::*;
449
450 const TEST_KEY: &str = "test-signing-key-at-least-256-bits-long!!";
451
452 fn test_config() -> SdJwtConfig {
453 SdJwtConfig {
454 lifetime_secs: 3600,
455 ..SdJwtConfig::default()
456 }
457 }
458
459 fn sample_claims() -> serde_json::Map<String, serde_json::Value> {
460 let mut claims = serde_json::Map::new();
461 claims.insert("sub".into(), serde_json::json!("user-42"));
462 claims.insert("email".into(), serde_json::json!("user@example.com"));
463 claims.insert("name".into(), serde_json::json!("Alice"));
464 claims.insert(
465 "address".into(),
466 serde_json::json!({"street": "123 Main St", "city": "Springfield"}),
467 );
468 claims
469 }
470
471 #[test]
472 fn test_issue_and_serialize() {
473 let issuer = SdJwtIssuer::new(test_config());
474 let claims = sample_claims();
475 let sd_jwt = issuer
476 .issue(&claims, &["email", "address"], TEST_KEY)
477 .unwrap();
478
479 assert!(!sd_jwt.jwt.is_empty());
480 assert_eq!(sd_jwt.disclosures.len(), 2);
481
482 let serialized = sd_jwt.serialize();
483 assert_eq!(serialized.matches('~').count(), 3);
485 }
486
487 #[test]
488 fn test_issue_no_sd_claims() {
489 let issuer = SdJwtIssuer::new(test_config());
490 let claims = sample_claims();
491 let sd_jwt = issuer.issue(&claims, &[], TEST_KEY).unwrap();
492
493 assert!(sd_jwt.disclosures.is_empty());
494 let serialized = sd_jwt.serialize();
495 assert!(serialized.ends_with('~'));
496 }
497
498 #[test]
499 fn test_full_disclosure_roundtrip() {
500 let config = test_config();
501 let issuer = SdJwtIssuer::new(config.clone());
502 let verifier = SdJwtVerifier::new(config);
503 let claims = sample_claims();
504
505 let sd_jwt = issuer.issue(&claims, &["email", "name"], TEST_KEY).unwrap();
506 let serialized = sd_jwt.serialize();
507
508 let verified = verifier.verify(&serialized, TEST_KEY).unwrap();
509
510 assert_eq!(verified.get_claim("sub").unwrap(), "user-42");
511 assert_eq!(verified.get_claim("email").unwrap(), "user@example.com");
512 assert_eq!(verified.get_claim("name").unwrap(), "Alice");
513 }
514
515 #[test]
516 fn test_selective_disclosure() {
517 let config = test_config();
518 let issuer = SdJwtIssuer::new(config.clone());
519 let verifier = SdJwtVerifier::new(config);
520 let claims = sample_claims();
521
522 let sd_jwt = issuer
523 .issue(&claims, &["email", "name", "address"], TEST_KEY)
524 .unwrap();
525
526 let presentation = sd_jwt.present(&["email"]);
528
529 let verified = verifier.verify(&presentation, TEST_KEY).unwrap();
530
531 assert_eq!(verified.get_claim("sub").unwrap(), "user-42");
533 assert_eq!(verified.get_claim("email").unwrap(), "user@example.com");
535 assert!(verified.get_claim("name").is_none());
537 assert!(verified.get_claim("address").is_none());
538 }
539
540 #[test]
541 fn test_all_claims_merged() {
542 let config = test_config();
543 let issuer = SdJwtIssuer::new(config.clone());
544 let verifier = SdJwtVerifier::new(config);
545 let claims = sample_claims();
546
547 let sd_jwt = issuer.issue(&claims, &["email"], TEST_KEY).unwrap();
548 let serialized = sd_jwt.serialize();
549
550 let verified = verifier.verify(&serialized, TEST_KEY).unwrap();
551 let merged = verified.all_claims();
552
553 assert!(merged.contains_key("sub"));
554 assert!(merged.contains_key("email"));
555 assert!(merged.contains_key("iss"));
556 assert!(merged.contains_key("iat"));
557 assert!(merged.contains_key("exp"));
558 }
559
560 #[test]
561 fn test_reject_empty_claims() {
562 let issuer = SdJwtIssuer::new(test_config());
563 let claims = serde_json::Map::new();
564 assert!(issuer.issue(&claims, &[], TEST_KEY).is_err());
565 }
566
567 #[test]
568 fn test_reject_wrong_key() {
569 let config = test_config();
570 let issuer = SdJwtIssuer::new(config.clone());
571 let verifier = SdJwtVerifier::new(config);
572 let claims = sample_claims();
573
574 let sd_jwt = issuer.issue(&claims, &["email"], TEST_KEY).unwrap();
575 let serialized = sd_jwt.serialize();
576
577 assert!(
578 verifier
579 .verify(&serialized, "wrong-key-wrong-key-wrong-key!!!")
580 .is_err()
581 );
582 }
583
584 #[test]
585 fn test_reject_forged_disclosure() {
586 let config = test_config();
587 let issuer = SdJwtIssuer::new(config.clone());
588 let verifier = SdJwtVerifier::new(config);
589 let claims = sample_claims();
590
591 let sd_jwt = issuer.issue(&claims, &["email"], TEST_KEY).unwrap();
592
593 let forged = serde_json::json!(["fakesalt", "role", "admin"]);
595 let forged_encoded = URL_SAFE_NO_PAD.encode(forged.to_string().as_bytes());
596 let forged_sd_jwt = format!("{}~{}~", sd_jwt.jwt, forged_encoded);
597
598 assert!(verifier.verify(&forged_sd_jwt, TEST_KEY).is_err());
599 }
600
601 #[test]
602 fn test_parse_components() {
603 let input = "eyJ0eXAi.payload.sig~disc1~disc2~";
604 let (jwt, disclosures, kb) = SdJwtVerifier::parse(input).unwrap();
605 assert_eq!(jwt, "eyJ0eXAi.payload.sig");
606 assert_eq!(disclosures.len(), 2);
607 assert!(kb.is_none());
608 }
609
610 #[test]
611 fn test_parse_with_kb_jwt() {
612 let input = "eyJ0eXAi.payload.sig~disc1~header.payload.signature";
613 let (jwt, disclosures, kb) = SdJwtVerifier::parse(input).unwrap();
614 assert_eq!(jwt, "eyJ0eXAi.payload.sig");
615 assert_eq!(disclosures.len(), 1);
616 assert_eq!(kb.unwrap(), "header.payload.signature");
617 }
618
619 #[test]
620 fn test_disclosure_uniqueness() {
621 let issuer = SdJwtIssuer::new(test_config());
622 let claims = sample_claims();
623
624 let sd_jwt1 = issuer.issue(&claims, &["email"], TEST_KEY).unwrap();
625 let sd_jwt2 = issuer.issue(&claims, &["email"], TEST_KEY).unwrap();
626
627 assert_ne!(
629 sd_jwt1.disclosures[0].encoded,
630 sd_jwt2.disclosures[0].encoded
631 );
632 assert_ne!(sd_jwt1.disclosures[0].digest, sd_jwt2.disclosures[0].digest);
633 }
634
635 #[test]
636 fn test_complex_claim_value() {
637 let config = test_config();
638 let issuer = SdJwtIssuer::new(config.clone());
639 let verifier = SdJwtVerifier::new(config);
640
641 let mut claims = serde_json::Map::new();
642 claims.insert("sub".into(), serde_json::json!("user-1"));
643 claims.insert(
644 "address".into(),
645 serde_json::json!({
646 "street": "123 Main St",
647 "city": "Springfield",
648 "zip": "62701"
649 }),
650 );
651
652 let sd_jwt = issuer.issue(&claims, &["address"], TEST_KEY).unwrap();
653 let serialized = sd_jwt.serialize();
654 let verified = verifier.verify(&serialized, TEST_KEY).unwrap();
655
656 let addr = verified.get_claim("address").unwrap();
657 assert_eq!(addr["city"], "Springfield");
658 assert_eq!(addr["zip"], "62701");
659 }
660}