Skip to main content

auth_framework/protocols/
sd_jwt.rs

1//! SD-JWT (Selective Disclosure JWT) implementation.
2//!
3//! Implements the IETF SD-JWT specification (draft-ietf-oauth-selective-disclosure-jwt)
4//! for creating JWTs whose claims can be selectively disclosed by the holder.
5//!
6//! # Architecture
7//!
8//! - **Issuer**: Creates an SD-JWT with selectively disclosable claims hashed into
9//!   the `_sd` array. Each claim becomes a separate disclosure.
10//! - **Holder**: Receives the full SD-JWT and can present a subset of disclosures
11//!   to a verifier, revealing only the claims they choose.
12//! - **Verifier**: Validates the JWT signature and reconstructs disclosed claims
13//!   by matching disclosure hashes against the `_sd` array.
14//!
15//! # Example
16//!
17//! ```rust,no_run
18//! use auth_framework::protocols::sd_jwt::{SdJwtIssuer, SdJwtConfig};
19//!
20//! let config = SdJwtConfig::default();
21//! let issuer = SdJwtIssuer::new(config);
22//!
23//! let mut claims = serde_json::Map::new();
24//! claims.insert("sub".into(), serde_json::json!("user-42"));
25//! claims.insert("email".into(), serde_json::json!("user@example.com"));
26//!
27//! // "email" is selectively disclosable; "sub" stays in the clear
28//! let sd_jwt = issuer.issue(
29//!     &claims,
30//!     &["email"],
31//!     "signing-secret-key",
32//! ).unwrap();
33//! ```
34
35use 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/// Hash algorithm used for disclosure digests.
43#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
44pub enum SdHashAlgorithm {
45    /// SHA-256 (default, recommended).
46    #[serde(rename = "sha-256")]
47    #[default]
48    Sha256,
49}
50
51impl SdHashAlgorithm {
52    /// Return the `_sd_alg` string value.
53    pub fn as_str(&self) -> &'static str {
54        match self {
55            Self::Sha256 => "sha-256",
56        }
57    }
58
59    /// Compute the digest of `input` using this algorithm.
60    fn digest(&self, input: &[u8]) -> Vec<u8> {
61        match self {
62            Self::Sha256 => Sha256::digest(input).to_vec(),
63        }
64    }
65}
66
67/// Configuration for SD-JWT operations.
68#[derive(Debug, Clone, Serialize, Deserialize)]
69pub struct SdJwtConfig {
70    /// Hash algorithm for disclosure digests.
71    pub hash_algorithm: SdHashAlgorithm,
72    /// JWT signing algorithm.
73    pub signing_algorithm: jsonwebtoken::Algorithm,
74    /// Issuer claim value.
75    pub issuer: String,
76    /// Token lifetime in seconds.
77    pub lifetime_secs: u64,
78    /// Salt length in bytes (minimum 16 recommended by spec).
79    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/// A single disclosure: the base64url-encoded `[salt, claim_name, claim_value]` array.
95#[derive(Clone)]
96pub struct Disclosure {
97    /// The base64url-encoded disclosure string.
98    pub encoded: String,
99    /// The claim name this disclosure reveals.
100    pub claim_name: String,
101    /// The claim value.
102    pub claim_value: serde_json::Value,
103    /// The hash digest of the encoded disclosure (for inclusion in `_sd`).
104    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/// The issued SD-JWT: a compact JWT, the tilde-separated disclosures, and
119/// an optional key-binding JWT.
120#[derive(Clone)]
121pub struct SdJwt {
122    /// The signed JWT containing `_sd` digests.
123    pub jwt: String,
124    /// All disclosures produced by the issuer.
125    pub disclosures: Vec<Disclosure>,
126    /// Optional holder key-binding JWT.
127    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    /// Serialize to the SD-JWT compact format: `<JWT>~<Disclosure1>~...~<DisclosureN>~[KB-JWT]`.
145    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    /// Create a presentation with only the selected claim names disclosed.
159    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
175/// SD-JWT issuer: creates SD-JWTs with selectively disclosable claims.
176pub struct SdJwtIssuer {
177    config: SdJwtConfig,
178}
179
180impl SdJwtIssuer {
181    /// Create a new issuer with the given configuration.
182    pub fn new(config: SdJwtConfig) -> Self {
183        Self { config }
184    }
185
186    /// Generate a cryptographically random salt.
187    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    /// Build a disclosure for a single claim and return its digest.
195    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    /// Issue an SD-JWT.
215    ///
216    /// * `claims` — all claims to include in the token.
217    /// * `sd_claims` — names of claims that should be selectively disclosable.
218    ///   Claims not listed here are included in the JWT payload in the clear.
219    /// * `signing_key` — the symmetric key (for HMAC algorithms) or PEM-encoded
220    ///   private key (for RSA/EC algorithms).
221    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        // Separate plaintext claims from selectively-disclosable claims.
236        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        // Add standard JWT claims.
247        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        // Add the `_sd` array and `_sd_alg`.
256        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        // Sign the JWT.
265        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
278/// SD-JWT verifier: validates SD-JWTs and reconstructs disclosed claims.
279pub struct SdJwtVerifier {
280    config: SdJwtConfig,
281}
282
283impl SdJwtVerifier {
284    /// Create a new verifier.
285    pub fn new(config: SdJwtConfig) -> Self {
286        Self { config }
287    }
288
289    /// Parse a serialized SD-JWT string into its components.
290    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        // If the last part is empty, there is no key-binding JWT.
304        // If the last part looks like a JWT (has dots), treat it as KB-JWT.
305        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    /// Verify an SD-JWT and return the disclosed claims.
323    ///
324    /// * `sd_jwt_str` — the compact SD-JWT string.
325    /// * `verification_key` — the symmetric key or public key for signature verification.
326    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        // Verify JWT signature and decode payload.
330        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        // Extract `_sd` digests and `_sd_alg`.
346        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        // Process disclosures: decode, hash, and match against `_sd`.
360        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            // Verify the disclosure hash is in the `_sd` array.
385            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/// Result of verifying an SD-JWT.
407#[derive(Clone)]
408pub struct VerifiedSdJwt {
409    /// Claims that were in the JWT payload in the clear.
410    pub plaintext_claims: serde_json::Map<String, serde_json::Value>,
411    /// Claims reconstructed from the presented disclosures.
412    pub disclosed_claims: HashMap<String, serde_json::Value>,
413    /// The optional key-binding JWT, if present.
414    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    /// Get a claim by name, checking disclosed claims first, then plaintext.
432    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    /// Merge all claims into a single map.
439    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        // JWT + 2 disclosures + trailing tilde
486        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        // Present only "email", omitting "name" and "address"
529        let presentation = sd_jwt.present(&["email"]);
530
531        let verified = verifier.verify(&presentation, TEST_KEY).unwrap();
532
533        // "sub" is plaintext — always visible
534        assert_eq!(verified.get_claim("sub").unwrap(), "user-42");
535        // "email" was disclosed
536        assert_eq!(verified.get_claim("email").unwrap(), "user@example.com");
537        // "name" and "address" were NOT disclosed
538        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        // Forge a disclosure that isn't in the _sd array
596        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        // Different salts produce different disclosures
630        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}