@sd-jwt/core 0.19.1-next.0 → 0.19.1-next.10

package/src/index.ts

@@ -1,34 +1,42 @@
-import { getSDAlgAndPayload } from '@sd-jwt/decode';
+import { getSDAlgAndPayload } from './decode';
+import { FlattenJSON } from './flattenJSON';
+import { GeneralJSON } from './generalJSON';
+import { Jwt, type VerifierOptions } from './jwt';
+import { KBJwt } from './kbjwt';
+import { pack, SDJwt } from './sdjwt';
 import {
   type DisclosureFrame,
   type Hasher,
   IANA_HASH_ALGORITHMS,
-  type JwtPayload,
   KB_JWT_TYP,
   type KBOptions,
   type PresentationFrame,
+  type SafeVerifyResult,
   type SDJWTCompact,
   type SDJWTConfig,
   type Signer,
-} from '@sd-jwt/types';
+  type VerificationError,
+  type VerificationErrorCode,
+} from './types';
 import {
   base64urlDecode,
   base64urlEncode,
+  ensureError,
   SDJWTException,
   uint8ArrayToBase64Url,
-} from '@sd-jwt/utils';
-import { FlattenJSON } from './flattenJSON';
-import { GeneralJSON } from './generalJSON';
-import { Jwt, type VerifierOptions } from './jwt';
-import { KBJwt } from './kbjwt';
-import { pack, SDJwt } from './sdjwt';
+} from './utils';
 
+export * from './decode';
 export * from './decoy';
 export * from './flattenJSON';
 export * from './generalJSON';
 export * from './jwt';
 export * from './kbjwt';
+export * from './present';
 export * from './sdjwt';
+// Re-export all types, utils, decode, and present functionality
+export * from './types';
+export * from './utils';
 
 export type SdJwtPayload = Record<string, unknown>;
 
@@ -232,7 +240,7 @@ export class SDJwtInstance<ExtendedPayload extends SdJwtPayload, T = unknown> {
     }
     const kb = await sdjwt.kbJwt.verifyKB({
       verifier: this.userConfig.kbVerifier,
-      payload: payload as JwtPayload,
+      payload,
       nonce: options.keyBindingNonce,
     });
     if (!kb) {
@@ -259,6 +267,211 @@ export class SDJwtInstance<ExtendedPayload extends SdJwtPayload, T = unknown> {
     return { payload, header, kb };
   }
 
+  /**
+   * Safe verification that collects all errors instead of failing fast.
+   * Returns a result object with either the verified data or an array of all errors.
+   *
+   * @param encodedSDJwt - The encoded SD-JWT to verify
+   * @param options - Verification options
+   * @returns A SafeVerifyResult containing either success data or collected errors
+   */
+  public async safeVerify(
+    encodedSDJwt: string,
+    options?: T & VerifierOptions,
+  ): Promise<
+    SafeVerifyResult<{
+      payload: ExtendedPayload;
+      header: Record<string, unknown> | undefined;
+      kb?: {
+        payload: Record<string, unknown>;
+        header: Record<string, unknown>;
+      };
+    }>
+  > {
+    const errors: VerificationError[] = [];
+
+    // Helper to add errors
+    const addError = (
+      code: VerificationErrorCode,
+      message: string,
+      details?: unknown,
+    ) => {
+      errors.push({ code, message, details });
+    };
+
+    // Helper to convert exception to error code
+    const exceptionToCode = (error: Error): VerificationErrorCode => {
+      const message = error.message.toLowerCase();
+      if (message.includes('hasher not found')) return 'HASHER_NOT_FOUND';
+      if (message.includes('verifier not found')) return 'VERIFIER_NOT_FOUND';
+      if (message.includes('invalid sd jwt') || message.includes('invalid jwt'))
+        return 'INVALID_SD_JWT';
+      if (message.includes('not yet valid')) return 'JWT_NOT_YET_VALID';
+      if (message.includes('expired')) return 'JWT_EXPIRED';
+      if (message.includes('signature')) return 'INVALID_JWT_SIGNATURE';
+      if (message.includes('missing required claim'))
+        return 'MISSING_REQUIRED_CLAIMS';
+      if (message.includes('key binding jwt not exist'))
+        return 'KEY_BINDING_JWT_MISSING';
+      if (message.includes('key binding verifier not found'))
+        return 'KEY_BINDING_VERIFIER_NOT_FOUND';
+      if (message.includes('sd_hash')) return 'KEY_BINDING_SD_HASH_INVALID';
+      return 'UNKNOWN_ERROR';
+    };
+
+    // Check basic configuration first
+    if (!this.userConfig.hasher) {
+      addError('HASHER_NOT_FOUND', 'Hasher not found');
+    }
+    if (!this.userConfig.verifier) {
+      addError('VERIFIER_NOT_FOUND', 'Verifier not found');
+    }
+
+    // If basic config is missing, return early
+    if (errors.length > 0) {
+      return { success: false, errors };
+    }
+
+    if (!this.userConfig.hasher) {
+      throw new SDJWTException('Hasher not found');
+    }
+
+    // hasher and verifier are guaranteed to be defined here
+    const hasher = this.userConfig.hasher;
+
+    // Try to decode and validate the SD-JWT
+    let sdjwt: SDJwt | undefined;
+    let payload: ExtendedPayload | undefined;
+    let header: Record<string, unknown> | undefined;
+
+    try {
+      sdjwt = await SDJwt.fromEncode(encodedSDJwt, hasher);
+      if (!sdjwt.jwt || !sdjwt.jwt.payload) {
+        addError('INVALID_SD_JWT', 'Invalid SD JWT: missing JWT or payload');
+      }
+    } catch (e) {
+      const error = ensureError(e);
+      addError(
+        'INVALID_SD_JWT',
+        `Failed to decode SD-JWT: ${error.message}`,
+        error,
+      );
+    }
+
+    // Validate signature and claims
+    if (sdjwt?.jwt) {
+      try {
+        const result = await this.VerifyJwt(sdjwt.jwt, options);
+        header = result.header;
+        const claims = await sdjwt.getClaims(hasher);
+        payload = claims as ExtendedPayload;
+      } catch (e) {
+        const error = ensureError(e);
+        const code = exceptionToCode(error);
+        addError(code, error.message, error);
+      }
+    }
+
+    // Check required claim keys
+    if (sdjwt && options?.requiredClaimKeys) {
+      try {
+        const keys = await sdjwt.keys(hasher);
+        const missingKeys = options.requiredClaimKeys.filter(
+          (k) => !keys.includes(k),
+        );
+        if (missingKeys.length > 0) {
+          addError(
+            'MISSING_REQUIRED_CLAIMS',
+            `Missing required claim keys: ${missingKeys.join(', ')}`,
+            { missingKeys },
+          );
+        }
+      } catch (e) {
+        const error = ensureError(e);
+        addError(
+          'UNKNOWN_ERROR',
+          `Failed to check required claims: ${error.message}`,
+          error,
+        );
+      }
+    }
+
+    // Verify key binding if requested
+    let kb:
+      | { payload: Record<string, unknown>; header: Record<string, unknown> }
+      | undefined;
+    if (options?.keyBindingNonce && sdjwt) {
+      if (!sdjwt.kbJwt) {
+        addError('KEY_BINDING_JWT_MISSING', 'Key Binding JWT not exist');
+      } else if (!this.userConfig.kbVerifier) {
+        addError(
+          'KEY_BINDING_VERIFIER_NOT_FOUND',
+          'Key Binding Verifier not found',
+        );
+      } else if (payload) {
+        try {
+          const kbResult = await sdjwt.kbJwt.verifyKB({
+            verifier: this.userConfig.kbVerifier,
+            payload,
+            nonce: options.keyBindingNonce,
+          });
+          if (!kbResult) {
+            addError(
+              'KEY_BINDING_SIGNATURE_INVALID',
+              'Key binding signature is not valid',
+            );
+          } else {
+            kb = kbResult;
+
+            // Verify sd_hash
+            const sdjwtWithoutKb = new SDJwt({
+              jwt: sdjwt.jwt,
+              disclosures: sdjwt.disclosures,
+            });
+            const presentSdJwtWithoutKb = sdjwtWithoutKb.encodeSDJwt();
+            const sdHashStr = await this.calculateSDHash(
+              presentSdJwtWithoutKb,
+              sdjwt,
+              hasher,
+            );
+
+            if (sdHashStr !== kbResult.payload.sd_hash) {
+              addError(
+                'KEY_BINDING_SD_HASH_INVALID',
+                'Invalid sd_hash in Key Binding JWT',
+                {
+                  expected: sdHashStr,
+                  received: kbResult.payload.sd_hash,
+                },
+              );
+            }
+          }
+        } catch (e) {
+          const error = ensureError(e);
+          addError(
+            'KEY_BINDING_SIGNATURE_INVALID',
+            `Key binding verification failed: ${error.message}`,
+            error,
+          );
+        }
+      }
+    }
+
+    // Return result
+    if (errors.length > 0) {
+      return { success: false, errors };
+    }
+
+    return {
+      success: true,
+      data: {
+        payload: payload as ExtendedPayload,
+        header,
+        kb,
+      },
+    };
+  }
+
   private async calculateSDHash(
     presentSdJwtWithoutKb: string,
     sdjwt: SDJwt,
@@ -292,7 +505,7 @@ export class SDJwtInstance<ExtendedPayload extends SdJwtPayload, T = unknown> {
     }
 
     const verifiedPayloads = await this.VerifyJwt(sdjwt.jwt, options);
-    const claims = await sdjwt.getClaims(hasher);
+    const claims = await sdjwt.getClaims<ExtendedPayload>(hasher);
     return { payload: claims, header: verifiedPayloads.header };
   }
 
@@ -559,8 +772,8 @@ export class SDJwtGeneralJSONInstance<ExtendedPayload extends SdJwtPayload> {
     }
     const kb = await sdjwt.kbJwt.verifyKB({
       verifier: this.userConfig.kbVerifier,
-      payload: payload as JwtPayload,
-      nonce: options.keyBindingNonce as string,
+      payload,
+      nonce: options.keyBindingNonce,
     });
     if (!kb) {
       throw new Error('signature is not valid');
@@ -636,7 +849,7 @@ export class SDJwtGeneralJSONInstance<ExtendedPayload extends SdJwtPayload> {
       throw new SDJWTException('Invalid SD JWT');
     }
 
-    const claims = await sdjwt.getClaims(hasher);
+    const claims = await sdjwt.getClaims<ExtendedPayload>(hasher);
     return { payload: claims, headers: results.map((r) => r.header) };
   }
 

package/src/jwt.ts

@@ -1,6 +1,6 @@
-import { decodeJwt } from '@sd-jwt/decode';
-import type { Base64urlString, Signer, Verifier } from '@sd-jwt/types';
-import { base64urlEncode, SDJWTException } from '@sd-jwt/utils';
+import { decodeJwt } from './decode';
+import type { Base64urlString, Signer, Verifier } from './types';
+import { base64urlEncode, SDJWTException } from './utils';
 
 export type JwtData<
   Header extends Record<string, unknown>,
@@ -154,23 +154,18 @@ export class Jwt<
   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);
-    if (
-      this.payload?.iat &&
-      (this.payload.iat as number) - skew > currentDate
-    ) {
+    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');
     }
 
-    if (
-      this.payload?.nbf &&
-      (this.payload.nbf as number) - skew > currentDate
-    ) {
+    if (typeof nbf === 'number' && nbf - skew > currentDate) {
       throw new SDJWTException('Verify Error: JWT is not yet valid');
     }
-    if (
-      this.payload?.exp &&
-      (this.payload.exp as number) + skew < currentDate
-    ) {
+    if (typeof exp === 'number' && exp + skew < currentDate) {
       throw new SDJWTException('Verify Error: JWT is expired');
     }
 

package/src/kbjwt.ts

@@ -1,12 +1,11 @@
+import { Jwt } from './jwt';
 import {
-  type JwtPayload,
   KB_JWT_TYP,
   type KbVerifier,
   type kbHeader,
   type kbPayload,
-} from '@sd-jwt/types';
-import { SDJWTException } from '@sd-jwt/utils';
-import { Jwt } from './jwt';
+} from './types';
+import { SDJWTException } from './utils';
 
 export class KBJwt<
   Header extends kbHeader = kbHeader,
@@ -16,7 +15,7 @@ export class KBJwt<
   // the type unknown is not good, but we don't know at this point how to get the public key of the signer, this is defined in the kbVerifier
   public async verifyKB(values: {
     verifier: KbVerifier;
-    payload: JwtPayload;
+    payload: Record<string, unknown>;
     nonce: string;
   }) {
     if (!this.header || !this.payload || !this.signature) {
@@ -34,7 +33,7 @@ export class KBJwt<
       // this is for backward compatibility with version 06
       !(
         this.payload.sd_hash ||
-        (this.payload as Record<string, unknown> | undefined)?._sd_hash
+        ('_sd_hash' in this.payload && this.payload._sd_hash)
       )
     ) {
       throw new SDJWTException('Invalid Key Binding Jwt');

package/src/present/index.ts

@@ -0,0 +1 @@
+export * from './present';

package/src/present/present.ts

@@ -0,0 +1,210 @@
+import {
+  createHashMapping,
+  createHashMappingSync,
+  decodeSdJwt,
+  decodeSdJwtSync,
+  getSDAlgAndPayload,
+  splitSdJwt,
+  unpack,
+  unpackObj,
+  unpackSync,
+} from '../decode';
+import type { Extensible, HasherSync } from '../types';
+import { type Hasher, type PresentationFrame, SD_SEPARATOR } from '../types';
+import { Disclosure, SDJWTException } from '../utils';
+
+// Presentable keys
+// The presentable keys are the path of JSON object that are presentable in the SD JWT
+// e.g. if the SD JWT has the following payload and set sd like this:
+// {
+//   "foo": "bar",  // sd
+//   "arr": [       // sd
+//     "1",         // sd
+//     "2",
+//     {
+//       "a": "1"   // sd
+//     }
+//   ],
+//   "test": {
+//     "zzz": "xxx" // sd
+//   }
+// }
+// The presentable keys are: ["arr", "arr.0", "arr.2.a", "foo", "test.zzz"]
+export const presentableKeys = async (
+  rawPayload: Record<string, unknown>,
+  disclosures: Array<Disclosure>,
+  hasher: Hasher,
+): Promise<string[]> => {
+  const { disclosureKeymap } = await unpack(rawPayload, disclosures, hasher);
+  return Object.keys(disclosureKeymap).sort();
+};
+
+export const presentableKeysSync = (
+  rawPayload: Record<string, unknown>,
+  disclosures: Array<Disclosure>,
+  hasher: HasherSync,
+): string[] => {
+  const { disclosureKeymap } = unpackSync(rawPayload, disclosures, hasher);
+  return Object.keys(disclosureKeymap).sort();
+};
+
+export const present = async <T extends Record<string, unknown>>(
+  sdJwt: string,
+  presentFrame: PresentationFrame<T>,
+  hasher: Hasher,
+): Promise<string> => {
+  const { jwt, kbJwt } = splitSdJwt(sdJwt);
+  const {
+    jwt: { payload },
+    disclosures,
+  } = await decodeSdJwt(sdJwt, hasher);
+
+  const { _sd_alg: alg } = getSDAlgAndPayload(payload);
+  const hash = { alg, hasher };
+  const keys = transformPresentationFrame(presentFrame);
+
+  // hashmap: <digest> => <disclosure>
+  // to match the digest with the disclosure
+  const hashmap = await createHashMapping(disclosures, hash);
+  const { disclosureKeymap } = await unpack(payload, disclosures, hasher);
+  const presentedDisclosures = keys
+    .map((k) => hashmap[disclosureKeymap[k]])
+    .filter((d) => d !== undefined);
+
+  return [
+    jwt,
+    ...presentedDisclosures.map((d) => d.encode()),
+    kbJwt ?? '',
+  ].join(SD_SEPARATOR);
+};
+
+export const presentSync = <T extends Record<string, unknown>>(
+  sdJwt: string,
+  presentFrame: PresentationFrame<T>,
+  hasher: HasherSync,
+): string => {
+  const { jwt, kbJwt } = splitSdJwt(sdJwt);
+  const {
+    jwt: { payload },
+    disclosures,
+  } = decodeSdJwtSync(sdJwt, hasher);
+
+  const { _sd_alg: alg } = getSDAlgAndPayload(payload);
+  const hash = { alg, hasher };
+  const keys = transformPresentationFrame(presentFrame);
+
+  // hashmap: <digest> => <disclosure>
+  // to match the digest with the disclosure
+  const hashmap = createHashMappingSync(disclosures, hash);
+  const { disclosureKeymap } = unpackSync(payload, disclosures, hasher);
+
+  const presentedDisclosures = keys
+    .map((k) => hashmap[disclosureKeymap[k]])
+    .filter((d) => d !== undefined);
+
+  return [
+    jwt,
+    ...presentedDisclosures.map((d) => d.encode()),
+    kbJwt ?? '',
+  ].join(SD_SEPARATOR);
+};
+
+/**
+ * Transform the object keys into an array of strings. We are not sorting the array in any way.
+ * @param obj The object to transform
+ * @param prefix The prefix to add to the keys
+ * @returns
+ */
+export const transformPresentationFrame = (
+  obj: PresentationFrame<Extensible>,
+  prefix = '',
+): string[] => {
+  return Object.entries(obj).reduce<string[]>((acc, [key, value]) => {
+    const newPrefix = prefix ? `${prefix}.${key}` : key;
+    if (typeof value === 'boolean') {
+      // only add it, when it's true
+      if (value) {
+        acc.push(newPrefix);
+      }
+    } else if (typeof value === 'object' && value !== null) {
+      acc.push(
+        newPrefix,
+        ...transformPresentationFrame(
+          value as PresentationFrame<Extensible>,
+          newPrefix,
+        ),
+      );
+    }
+    return acc;
+  }, []);
+};
+
+export type SerializedDisclosure = {
+  digest: string;
+  encoded: string;
+  salt: string;
+  key: string | undefined;
+  value: unknown;
+};
+
+export const createHashMappingForSerializedDisclosure = (
+  disclosures: SerializedDisclosure[],
+) => {
+  const map: Record<string, Disclosure> = {};
+  for (let i = 0; i < disclosures.length; i++) {
+    const disclosure = disclosures[i];
+    const { digest, encoded, key, salt, value } = disclosure;
+    // we made Disclosure to fit the interface of unpack
+    map[digest] = Disclosure.fromArray(
+      key ? [salt, key, value] : [salt, value],
+      { digest, encoded },
+    );
+  }
+  return map;
+};
+
+/**
+ * This function selects the serialized disclosures from the payload
+ * and array of serialized disclosure based on the presentation frame.
+ * If you want to know what is serialized disclosures, check type SerializedDisclosure.
+ * @param payload: Record<string, unknown>
+ * @param disclosures: SerializedDisclosure[]
+ * @param presentationFrame: PresentationFrame<T>
+ */
+export const selectDisclosures = <T extends Record<string, unknown>>(
+  payload: Record<string, unknown>,
+  disclosures: SerializedDisclosure[],
+  presentationFrame: PresentationFrame<T>,
+) => {
+  if (disclosures.length === 0) {
+    return [];
+  }
+
+  const hashmap = createHashMappingForSerializedDisclosure(disclosures);
+  const { disclosureKeymap } = unpackObj(payload, hashmap);
+  const keys = transformPresentationFrame(presentationFrame);
+
+  const presentedDisclosures = keys
+    .map((k) => hashmap[disclosureKeymap[k]])
+    .filter((d) => d !== undefined);
+
+  const selectedDisclosures: SerializedDisclosure[] = presentedDisclosures.map(
+    (d) => {
+      const { salt, key, value, _digest } = d;
+      if (!_digest) {
+        throw new SDJWTException(
+          'Implementation error: _digest is not defined',
+        );
+      }
+      return {
+        digest: _digest,
+        encoded: d.encode(),
+        salt,
+        key,
+        value,
+      };
+    },
+  );
+
+  return selectedDisclosures;
+};

package/src/sdjwt.ts

@@ -1,5 +1,8 @@
-import { createHashMapping, getSDAlgAndPayload, unpack } from '@sd-jwt/decode';
-import { transformPresentationFrame } from '@sd-jwt/present';
+import { createHashMapping, getSDAlgAndPayload, unpack } from './decode';
+import { createDecoy } from './decoy';
+import { Jwt } from './jwt';
+import { KBJwt } from './kbjwt';
+import { transformPresentationFrame } from './present';
 import {
   type DisclosureFrame,
   type Hasher,
@@ -13,11 +16,8 @@ import {
   SD_LIST_KEY,
   SD_SEPARATOR,
   type SDJWTCompact,
-} from '@sd-jwt/types';
-import { Disclosure, SDJWTException } from '@sd-jwt/utils';
-import { createDecoy } from './decoy';
-import { Jwt } from './jwt';
-import { KBJwt } from './kbjwt';
+} from './types';
+import { Disclosure, SDJWTException } from './utils';
 
 export type SDJwtData<
   Header extends Record<string, unknown>,
@@ -81,7 +81,7 @@ export class SDJwt<
     const { _sd_alg } = getSDAlgAndPayload(jwt.payload);
 
     const disclosures = await Promise.all(
-      (encodedDisclosures as Array<string>).map((ed) =>
+      encodedDisclosures.map((ed) =>
         Disclosure.fromEncode(ed, { alg: _sd_alg, hasher }),
       ),
     );
@@ -221,8 +221,9 @@ export const listKeys = (obj: Record<string, unknown>, prefix = '') => {
     const newKey = prefix ? `${prefix}.${key}` : key;
     keys.push(newKey);
 
-    if (obj[key] && typeof obj[key] === 'object' && obj[key] !== null) {
-      keys.push(...listKeys(obj[key] as Record<string, unknown>, newKey));
+    const value = obj[key];
+    if (value && typeof value === 'object') {
+      keys.push(...listKeys(value as Record<string, unknown>, newKey));
     }
   }
   return keys;