@sd-jwt/core 0.20.1-next.4 → 0.20.1-next.6

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sd-jwt/core",
-  "version": "0.20.1-next.4+4d3c70e",
-  "description": "sd-jwt draft 7 implementation in typescript",
+  "version": "0.20.1-next.6+c7cf23d",
+  "description": "SD-JWT RFC 9901 implementation in TypeScript",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -58,5 +58,5 @@
       "esm"
     ]
   },
-  "gitHead": "4d3c70e1913dcceabe67b338b3987c2af603e7ae"
+  "gitHead": "c7cf23dbc1b8e35532f0e287ec5d1a852195eba7"
 }

package/src/decode/decode.ts

@@ -1,4 +1,7 @@
 import {
+  DEFAULT_SECURE_HASH_ALGORITHMS,
+  encodePathSegment,
+  type HashAlgorithm,
   type Hasher,
   type HasherAndAlg,
   type HasherAndAlgSync,
@@ -39,12 +42,7 @@ export const splitSdJwt = (
 ): { jwt: string; disclosures: string[]; kbJwt?: string } => {
   const [encodedJwt, ...encodedDisclosures] = sdjwt.split(SD_SEPARATOR);
   if (encodedDisclosures.length === 0) {
-    // if input is just jwt, then return here.
-    // This is for compatibility with jwt
-    return {
-      jwt: encodedJwt,
-      disclosures: [],
-    };
+    throw new SDJWTException('Invalid SD-JWT: missing SD-JWT separator');
   }
 
   const encodedKeyBindingJwt = encodedDisclosures.pop();
@@ -65,12 +63,7 @@ export const decodeSdJwt = async (
   const jwt = decodeJwt(encodedJwt);
 
   if (encodedDisclosures.length === 0) {
-    // if input is just jwt, then return here.
-    // This is for compatibility with jwt
-    return {
-      jwt,
-      disclosures: [],
-    };
+    throw new SDJWTException('Invalid SD-JWT: missing SD-JWT separator');
   }
 
   const encodedKeyBindingJwt = encodedDisclosures.pop();
@@ -101,12 +94,7 @@ export const decodeSdJwtSync = (
   const jwt = decodeJwt(encodedJwt);
 
   if (encodedDisclosures.length === 0) {
-    // if input is just jwt, then return here.
-    // This is for compatibility with jwt
-    return {
-      jwt,
-      disclosures: [],
-    };
+    throw new SDJWTException('Invalid SD-JWT: missing SD-JWT separator');
   }
 
   const encodedKeyBindingJwt = encodedDisclosures.pop();
@@ -163,7 +151,10 @@ const unpackArray = (
   arr.forEach((item, idx) => {
     if (isRecord(item)) {
       const hash = item[SD_LIST_KEY];
-      if (typeof hash === 'string') {
+      if (SD_LIST_KEY in item) {
+        if (Object.keys(item).length !== 1 || typeof hash !== 'string') {
+          throw new SDJWTException('Invalid array disclosure placeholder');
+        }
         // RFC 9901 Section 7.1 step 4: reject duplicate digests
         if (seenDigests) {
           if (seenDigests.has(hash)) {
@@ -175,6 +166,11 @@ const unpackArray = (
         }
         const disclosed = map[hash];
         if (disclosed) {
+          if (typeof disclosed.key === 'string') {
+            throw new SDJWTException(
+              'Object-property disclosure cannot be used as an array element',
+            );
+          }
           const presentKey = prefix ? `${prefix}.${idx}` : `${idx}`;
           keys[presentKey] = hash;
 
@@ -232,12 +228,16 @@ const unpackObjInternal = (
 
     const record = obj as Record<string, unknown>;
     for (const key in record) {
+      if (prefix && key === '_sd_alg') {
+        throw new SDJWTException('Nested _sd_alg is not allowed');
+      }
       if (
         key !== SD_DIGEST &&
         key !== SD_LIST_KEY &&
         typeof record[key] === 'object'
       ) {
-        const newKey = prefix ? `${prefix}.${key}` : key;
+        const escapedKey = encodePathSegment(key);
+        const newKey = prefix ? `${prefix}.${escapedKey}` : escapedKey;
         const { unpackedObj, disclosureKeymap: disclosureKeys } =
           unpackObjInternal(record[key], map, newKey, seenDigests);
         record[key] = unpackedObj;
@@ -249,7 +249,15 @@ const unpackObjInternal = (
       _sd?: Array<string>;
     };
     const claims: Record<string, unknown> = {};
-    if (_sd) {
+    if (_sd !== undefined) {
+      if (
+        !Array.isArray(_sd) ||
+        !_sd.every((hash) => typeof hash === 'string')
+      ) {
+        throw new SDJWTException(
+          'Invalid _sd claim: expected array of strings',
+        );
+      }
       for (const hash of _sd) {
         // RFC 9901 Section 7.1 step 4: reject duplicate digests
         if (seenDigests) {
@@ -261,17 +269,26 @@ const unpackObjInternal = (
           seenDigests.add(hash);
         }
         const disclosed = map[hash];
-        if (disclosed?.key) {
+        if (disclosed) {
+          if (typeof disclosed.key !== 'string') {
+            throw new SDJWTException(
+              'Array disclosure cannot be used as an object property',
+            );
+          }
           // RFC 9901 Section 7.1 step 3c.ii.3: reject if claim name already exists
           if (disclosed.key in payload) {
             throw new SDJWTException(
               `Disclosed claim name "${disclosed.key}" conflicts with existing payload key`,
             );
           }
+          if (disclosed.key in claims) {
+            throw new SDJWTException(
+              `Disclosed claim name "${disclosed.key}" conflicts with another disclosure`,
+            );
+          }
 
-          const presentKey = prefix
-            ? `${prefix}.${disclosed.key}`
-            : disclosed.key;
+          const escapedKey = encodePathSegment(disclosed.key);
+          const presentKey = prefix ? `${prefix}.${escapedKey}` : escapedKey;
           keys[presentKey] = hash;
 
           const { unpackedObj, disclosureKeymap: disclosureKeys } =
@@ -297,6 +314,9 @@ export const createHashMapping = async (
   for (let i = 0; i < disclosures.length; i++) {
     const disclosure = disclosures[i];
     const digest = await disclosure.digest(hash);
+    if (digest in map) {
+      throw new SDJWTException('Duplicate disclosure digest detected');
+    }
     map[digest] = disclosure;
   }
   return map;
@@ -310,18 +330,26 @@ export const createHashMappingSync = (
   for (let i = 0; i < disclosures.length; i++) {
     const disclosure = disclosures[i];
     const digest = disclosure.digestSync(hash);
+    if (digest in map) {
+      throw new SDJWTException('Duplicate disclosure digest detected');
+    }
     map[digest] = disclosure;
   }
   return map;
 };
 
 // Extract _sd_alg. If it is not present, it is assumed to be sha-256
-export const getSDAlgAndPayload = (SdJwtPayload: Record<string, unknown>) => {
+export const getSDAlgAndPayload = (
+  SdJwtPayload: Record<string, unknown>,
+  allowedAlgorithms: ReadonlyArray<HashAlgorithm> = DEFAULT_SECURE_HASH_ALGORITHMS,
+) => {
   const { _sd_alg, ...payload } = SdJwtPayload;
-  if (typeof _sd_alg !== 'string') {
-    // This is for compatibility
+  if (_sd_alg === undefined) {
     return { _sd_alg: 'sha-256', payload };
   }
+  if (typeof _sd_alg !== 'string') {
+    throw new SDJWTException('Invalid _sd_alg: expected string');
+  }
   if (
     !IANA_HASH_ALGORITHMS.includes(
       _sd_alg as (typeof IANA_HASH_ALGORITHMS)[number],
@@ -329,6 +357,9 @@ export const getSDAlgAndPayload = (SdJwtPayload: Record<string, unknown>) => {
   ) {
     throw new SDJWTException(`Invalid _sd_alg: ${_sd_alg}`);
   }
+  if (!allowedAlgorithms.includes(_sd_alg as HashAlgorithm)) {
+    throw new SDJWTException(`Disallowed _sd_alg: ${_sd_alg}`);
+  }
   return { _sd_alg, payload };
 };
 

package/src/generalJSON.ts

@@ -20,6 +20,7 @@ export type GeneralJSONSerialized = {
       disclosures?: Array<string>;
       kid?: string;
       kb_jwt?: string;
+      [key: string]: unknown;
     };
     protected: string;
     signature: string;
@@ -68,6 +69,14 @@ export class GeneralJSON {
     if (!json.signatures[0]) {
       throw new SDJWTException('Invalid JSON');
     }
+    for (let index = 1; index < json.signatures.length; index++) {
+      const header = json.signatures[index].header;
+      if (header && ('disclosures' in header || 'kb_jwt' in header)) {
+        throw new SDJWTException(
+          'disclosures and kb_jwt MUST only appear in the first unprotected header',
+        );
+      }
+    }
     const disclosures = json.signatures[0].header?.disclosures ?? [];
     const kb_jwt = json.signatures[0].header?.kb_jwt;
     return new GeneralJSON({

package/src/index.ts

@@ -1,10 +1,11 @@
 import { getSDAlgAndPayload } from './decode';
 import { FlattenJSON } from './flattenJSON';
 import { GeneralJSON } from './generalJSON';
-import { Jwt, type VerifierOptions } from './jwt';
+import { Jwt, type VerifierOptions, validateJwtPayload } from './jwt';
 import { KBJwt } from './kbjwt';
 import { pack, SDJwt } from './sdjwt';
 import {
+  DEFAULT_SECURE_HASH_ALGORITHMS,
   type DisclosureFrame,
   type Hasher,
   IANA_HASH_ALGORITHMS,
@@ -87,6 +88,17 @@ export class SDJwtInstance<ExtendedPayload extends SdJwtPayload, T = unknown> {
           `Invalid hash algorithm: ${userConfig.hashAlg}`,
         );
       }
+      const allowedDisclosureHashAlgorithms =
+        userConfig.allowedDisclosureHashAlgorithms ??
+        DEFAULT_SECURE_HASH_ALGORITHMS;
+      if (
+        userConfig.hashAlg &&
+        !allowedDisclosureHashAlgorithms.includes(userConfig.hashAlg)
+      ) {
+        throw new SDJWTException(
+          `Disallowed hash algorithm: ${userConfig.hashAlg}`,
+        );
+      }
       this.userConfig = userConfig;
     }
   }
@@ -148,12 +160,21 @@ export class SDJwtInstance<ExtendedPayload extends SdJwtPayload, T = unknown> {
     if (!this.userConfig.signAlg) {
       throw new SDJWTException('sign alogrithm not specified');
     }
+    if (this.userConfig.signAlg === 'none') {
+      throw new SDJWTException('sign algorithm "none" is not allowed');
+    }
 
     this.validateReservedFields<Payload>(payload);
     this.validateDisclosureFrame<Payload>(disclosureFrame);
 
     const hasher = this.userConfig.hasher;
     const hashAlg = this.userConfig.hashAlg ?? SDJwtInstance.DEFAULT_hashAlg;
+    const allowedDisclosureHashAlgorithms =
+      this.userConfig.allowedDisclosureHashAlgorithms ??
+      DEFAULT_SECURE_HASH_ALGORITHMS;
+    if (!allowedDisclosureHashAlgorithms.includes(hashAlg)) {
+      throw new SDJWTException(`Disallowed hash algorithm: ${hashAlg}`);
+    }
 
     const { packedClaims, disclosures } = await pack(
       payload,
@@ -212,6 +233,9 @@ export class SDJwtInstance<ExtendedPayload extends SdJwtPayload, T = unknown> {
     const hasher = this.userConfig.hasher;
 
     const sdjwt = await SDJwt.fromEncode(encodedSDJwt, hasher);
+    if (sdjwt.kbJwt) {
+      throw new SDJWTException('Holder cannot present an SD-JWT with KB-JWT');
+    }
 
     if (!sdjwt.jwt?.payload) throw new SDJWTException('Payload not found');
     const presentSdJwtWithoutKb = await sdjwt.present(
@@ -394,10 +418,14 @@ export class SDJwtInstance<ExtendedPayload extends SdJwtPayload, T = unknown> {
     // Validate signature and claims
     if (sdjwt?.jwt) {
       try {
-        const result = await this.VerifyJwt(sdjwt.jwt, options);
+        const result = await this.VerifyJwt(sdjwt.jwt, {
+          ...options,
+          skipJwtClaimValidation: true,
+        } as T & VerifierOptions);
         header = result.header;
         const claims = await sdjwt.getClaims(hasher);
         payload = claims as ExtendedPayload;
+        validateJwtPayload(payload, options);
       } catch (e) {
         const error = ensureError(e);
         const code = exceptionToCode(error);
@@ -538,10 +566,14 @@ export class SDJwtInstance<ExtendedPayload extends SdJwtPayload, T = unknown> {
       throw new SDJWTException('Invalid SD JWT');
     }
 
-    const verifiedPayloads = await this.VerifyJwt(sdjwt.jwt, options);
+    const verifiedPayloads = await this.VerifyJwt(sdjwt.jwt, {
+      ...options,
+      skipJwtClaimValidation: true,
+    } as T & VerifierOptions);
     const claims = await sdjwt.getClaims<ExtendedPayload>(hasher);
     // Validate that unpacked claims do not contain reserved field names
     validateReservedFieldsInternal(claims);
+    validateJwtPayload(claims, options);
     return { payload: claims, header: verifiedPayloads.header };
   }
 
@@ -611,6 +643,17 @@ export class SDJwtGeneralJSONInstance<ExtendedPayload extends SdJwtPayload> {
           `Invalid hash algorithm: ${userConfig.hashAlg}`,
         );
       }
+      const allowedDisclosureHashAlgorithms =
+        userConfig.allowedDisclosureHashAlgorithms ??
+        DEFAULT_SECURE_HASH_ALGORITHMS;
+      if (
+        userConfig.hashAlg &&
+        !allowedDisclosureHashAlgorithms.includes(userConfig.hashAlg)
+      ) {
+        throw new SDJWTException(
+          `Disallowed hash algorithm: ${userConfig.hashAlg}`,
+        );
+      }
       this.userConfig = userConfig;
     }
   }
@@ -738,6 +781,9 @@ export class SDJwtGeneralJSONInstance<ExtendedPayload extends SdJwtPayload> {
     const hasher = this.userConfig.hasher;
     const encodedSDJwt = generalJSON.toEncoded(0);
     const sdjwt = await SDJwt.fromEncode(encodedSDJwt, hasher);
+    if (sdjwt.kbJwt) {
+      throw new SDJWTException('Holder cannot present an SD-JWT with KB-JWT');
+    }
 
     if (!sdjwt.jwt?.payload) throw new SDJWTException('Payload not found');
     const disclosures = await sdjwt.getPresentDisclosures(
@@ -781,7 +827,7 @@ export class SDJwtGeneralJSONInstance<ExtendedPayload extends SdJwtPayload> {
     }
     const hasher = this.userConfig.hasher;
 
-    const { payload, headers } = await this.validate(generalJSON);
+    const { payload, headers } = await this.validate(generalJSON, options);
 
     const encodedSDJwt = generalJSON.toEncoded(0);
     const sdjwt = await SDJwt.fromEncode(encodedSDJwt, hasher);
@@ -856,7 +902,7 @@ export class SDJwtGeneralJSONInstance<ExtendedPayload extends SdJwtPayload> {
 
   // This function is for validating the SD JWT
   // Just checking signature and return its the claims
-  public async validate(generalJSON: GeneralJSON) {
+  public async validate(generalJSON: GeneralJSON, options?: VerifierOptions) {
     if (!this.userConfig.hasher) {
       throw new SDJWTException('Hasher not found');
     }
@@ -874,8 +920,23 @@ export class SDJwtGeneralJSONInstance<ExtendedPayload extends SdJwtPayload> {
         const verified = await verifier(
           `${encodedHeader}.${payload}`,
           signature,
+          { ...options, skipJwtClaimValidation: true },
+        );
+        const header = decodeBase64urlJsonStrict<Record<string, unknown>>(
+          encodedHeader,
+          'Invalid JWT',
         );
-        const header = decodeBase64urlJsonStrict(encodedHeader, 'Invalid JWT');
+        if (typeof header.alg !== 'string' || header.alg === 'none') {
+          throw new SDJWTException('Verify Error: alg "none" is not allowed');
+        }
+        if (
+          options?.allowedIssuerAlgorithms &&
+          !options.allowedIssuerAlgorithms.includes(header.alg)
+        ) {
+          throw new SDJWTException(
+            `Verify Error: Disallowed alg ${header.alg}`,
+          );
+        }
         return { verified, header };
       }),
     );
@@ -894,6 +955,7 @@ export class SDJwtGeneralJSONInstance<ExtendedPayload extends SdJwtPayload> {
     const claims = await sdjwt.getClaims<ExtendedPayload>(hasher);
     // Validate that unpacked claims do not contain reserved field names
     validateReservedFieldsInternal(claims);
+    validateJwtPayload(claims, options);
     return { payload: claims, headers: results.map((r) => r.header) };
   }
 

package/src/jwt.ts

@@ -32,11 +32,37 @@ export type VerifierOptions = {
    */
   requiredClaimKeys?: string[];
 
+  /**
+   * Expected audience for the processed SD-JWT payload.
+   */
+  expectedAudience?: string | string[];
+
+  /**
+   * Allowed JOSE algorithms for issuer-signed JWTs. `none` is always rejected.
+   */
+  allowedIssuerAlgorithms?: string[];
+
   /**
    * nonce used to verify the key binding jwt to prevent replay attacks.
    */
   keyBindingNonce?: string;
 
+  /**
+   * Expected audience for the Key Binding JWT.
+   */
+  expectedKeyBindingAudience?: string | string[];
+
+  /**
+   * Maximum acceptable age of the Key Binding JWT, in seconds.
+   */
+  keyBindingMaxAgeSeconds?: number;
+
+  /**
+   * Internal option used by SD-JWT validation to defer claim checks until after
+   * disclosures are processed.
+   */
+  skipJwtClaimValidation?: boolean;
+
   /**
    * disable the verification of the status claim in the payload.
    *
@@ -50,6 +76,75 @@ export type VerifierOptions = {
   [key: string]: unknown;
 };
 
+const isStringArray = (value: unknown): value is string[] =>
+  Array.isArray(value) && value.every((item) => typeof item === 'string');
+
+const validateNumericDate = (
+  payload: Record<string, unknown>,
+  claim: 'iat' | 'nbf' | 'exp',
+) => {
+  const value = payload[claim];
+  if (value === undefined) return undefined;
+  if (typeof value !== 'number' || !Number.isFinite(value)) {
+    throw new SDJWTException(`Verify Error: JWT ${claim} must be a number`);
+  }
+  return value;
+};
+
+const getAudiences = (audience: unknown): string[] | undefined => {
+  if (typeof audience === 'string') return [audience];
+  if (isStringArray(audience)) return audience;
+  return undefined;
+};
+
+const validateAudience = (
+  payload: Record<string, unknown>,
+  expectedAudience: string | string[] | undefined,
+) => {
+  if (expectedAudience === undefined) return;
+
+  const expectedAudiences = Array.isArray(expectedAudience)
+    ? expectedAudience
+    : [expectedAudience];
+  const audiences = getAudiences(payload.aud);
+
+  if (
+    !audiences ||
+    !expectedAudiences.some((expected) => audiences.includes(expected))
+  ) {
+    throw new SDJWTException('Verify Error: Invalid audience');
+  }
+};
+
+export const validateJwtPayload = (
+  payload: Record<string, unknown> | undefined,
+  options?: VerifierOptions,
+) => {
+  if (!payload) {
+    throw new SDJWTException('Verify Error: JWT payload is missing');
+  }
+
+  const skew = options?.skewSeconds ? options.skewSeconds : 0;
+  const currentDate = options?.currentDate ?? Math.floor(Date.now() / 1000);
+  const iat = validateNumericDate(payload, 'iat');
+  const nbf = validateNumericDate(payload, 'nbf');
+  const exp = validateNumericDate(payload, 'exp');
+
+  if (iat !== undefined && iat - skew > currentDate) {
+    throw new SDJWTException('Verify Error: JWT is not yet valid');
+  }
+
+  if (nbf !== undefined && nbf - skew > currentDate) {
+    throw new SDJWTException('Verify Error: JWT is not yet valid');
+  }
+
+  if (exp !== undefined && exp + skew <= currentDate) {
+    throw new SDJWTException('Verify Error: JWT is expired');
+  }
+
+  validateAudience(payload, options?.expectedAudience);
+};
+
 // This class is used to create and verify JWT
 // Contains header, payload, and signature
 export class Jwt<
@@ -127,6 +222,9 @@ export class Jwt<
   }
 
   public async sign(signer: Signer) {
+    if (!this.header || this.header.alg === 'none') {
+      throw new SDJWTException('Sign Error: alg "none" is not allowed');
+    }
     const data = this.getUnsignedToken();
     this.signature = await signer(data);
 
@@ -159,21 +257,19 @@ export class Jwt<
    * @returns
    */
   public async verify<T>(verifier: Verifier<T>, options?: T & VerifierOptions) {
-    const skew = options?.skewSeconds ? options.skewSeconds : 0;
-    const currentDate = options?.currentDate ?? Math.floor(Date.now() / 1000);
-    const iat = this.payload?.iat;
-    const nbf = this.payload?.nbf;
-    const exp = this.payload?.exp;
-
-    if (typeof iat === 'number' && iat - skew > currentDate) {
-      throw new SDJWTException('Verify Error: JWT is not yet valid');
+    const alg = this.header?.alg;
+    if (typeof alg !== 'string' || alg === 'none') {
+      throw new SDJWTException('Verify Error: alg "none" is not allowed');
     }
-
-    if (typeof nbf === 'number' && nbf - skew > currentDate) {
-      throw new SDJWTException('Verify Error: JWT is not yet valid');
+    if (
+      options?.allowedIssuerAlgorithms &&
+      !options.allowedIssuerAlgorithms.includes(alg)
+    ) {
+      throw new SDJWTException(`Verify Error: Disallowed alg ${alg}`);
     }
-    if (typeof exp === 'number' && exp + skew < currentDate) {
-      throw new SDJWTException('Verify Error: JWT is expired');
+
+    if (!options?.skipJwtClaimValidation) {
+      validateJwtPayload(this.payload, options);
     }
 
     if (!this.signature) {

package/src/kbjwt.ts

@@ -28,18 +28,15 @@ export class KBJwt<
     }
 
     if (
-      !this.header.alg ||
+      typeof this.header.alg !== 'string' ||
       this.header.alg === 'none' ||
-      !this.header.typ ||
+      typeof this.header.typ !== 'string' ||
       this.header.typ !== KB_JWT_TYP ||
-      !this.payload.iat ||
-      !this.payload.aud ||
-      !this.payload.nonce ||
-      // this is for backward compatibility with version 06
-      !(
-        this.payload.sd_hash ||
-        ('_sd_hash' in this.payload && this.payload._sd_hash)
-      )
+      typeof this.payload.iat !== 'number' ||
+      typeof this.payload.aud !== 'string' ||
+      typeof this.payload.nonce !== 'string' ||
+      typeof this.payload.sd_hash !== 'string' ||
+      this.payload.sd_hash.length === 0
     ) {
       throw new SDJWTException('Invalid Key Binding Jwt');
     }
@@ -48,6 +45,29 @@ export class KBJwt<
       throw new SDJWTException('Verify Error: Invalid Nonce');
     }
 
+    if (values.options?.expectedKeyBindingAudience !== undefined) {
+      const expectedAudiences = Array.isArray(
+        values.options.expectedKeyBindingAudience,
+      )
+        ? values.options.expectedKeyBindingAudience
+        : [values.options.expectedKeyBindingAudience];
+      if (!expectedAudiences.includes(this.payload.aud)) {
+        throw new SDJWTException('Verify Error: Invalid Key Binding audience');
+      }
+    }
+
+    if (values.options?.keyBindingMaxAgeSeconds !== undefined) {
+      const currentDate =
+        values.options.currentDate ?? Math.floor(Date.now() / 1000);
+      const skew = values.options.skewSeconds ?? 0;
+      if (
+        this.payload.iat + values.options.keyBindingMaxAgeSeconds + skew <
+        currentDate
+      ) {
+        throw new SDJWTException('Verify Error: Key Binding JWT is too old');
+      }
+    }
+
     // Delegate signature verification and common JWT claim validation
     // (iat, nbf, exp) to the shared Jwt.verify implementation. The kbVerifier
     // needs the kb+jwt payload (e.g. the holder's cnf key), so we wrap it to

package/src/present/present.ts

@@ -10,7 +10,12 @@ import {
   unpackSync,
 } from '../decode';
 import type { Extensible, HasherSync } from '../types';
-import { type Hasher, type PresentationFrame, SD_SEPARATOR } from '../types';
+import {
+  encodePath,
+  type Hasher,
+  type PresentationFrame,
+  SD_SEPARATOR,
+} from '../types';
 import { Disclosure, SDJWTException } from '../utils';
 
 // Presentable keys
@@ -117,18 +122,19 @@ export const presentSync = <T extends Record<string, unknown>>(
  */
 export const transformPresentationFrame = (
   obj: PresentationFrame<Extensible>,
-  prefix = '',
+  prefix: string[] = [],
 ): string[] => {
   return Object.entries(obj).reduce<string[]>((acc, [key, value]) => {
-    const newPrefix = prefix ? `${prefix}.${key}` : key;
+    const newPrefix = [...prefix, key];
+    const encodedPrefix = encodePath(newPrefix);
     if (typeof value === 'boolean') {
       // only add it, when it's true
       if (value) {
-        acc.push(newPrefix);
+        acc.push(encodedPrefix);
       }
     } else if (typeof value === 'object' && value !== null) {
       acc.push(
-        newPrefix,
+        encodedPrefix,
         ...transformPresentationFrame(
           value as PresentationFrame<Extensible>,
           newPrefix,