@sd-jwt/core 0.19.1-next.9 → 0.20.1-next.0

package/src/decode/decode.ts

@@ -1,12 +1,15 @@
-import type { HasherAndAlgSync, HasherSync } from '../types';
 import {
   type Hasher,
   type HasherAndAlg,
+  type HasherAndAlgSync,
+  type HasherSync,
+  IANA_HASH_ALGORITHMS,
   SD_DIGEST,
   SD_LIST_KEY,
   SD_SEPARATOR,
 } from '../types';
-import { base64urlDecode, Disclosure, SDJWTException } from '../utils';
+import { Disclosure, SDJWTException } from '../utils';
+import { decodeBase64urlJsonStrict } from '../utils/strict-json';
 
 export const decodeJwt = <
   H extends Record<string, unknown>,
@@ -20,8 +23,8 @@ export const decodeJwt = <
   }
 
   return {
-    header: JSON.parse(base64urlDecode(header)),
-    payload: JSON.parse(base64urlDecode(payload)),
+    header: decodeBase64urlJsonStrict(header, 'Invalid JWT as input'),
+    payload: decodeBase64urlJsonStrict(payload, 'Invalid JWT as input'),
     signature: signature,
   };
 };
@@ -319,6 +322,13 @@ export const getSDAlgAndPayload = (SdJwtPayload: Record<string, unknown>) => {
     // This is for compatibility
     return { _sd_alg: 'sha-256', payload };
   }
+  if (
+    !IANA_HASH_ALGORITHMS.includes(
+      _sd_alg as (typeof IANA_HASH_ALGORITHMS)[number],
+    )
+  ) {
+    throw new SDJWTException(`Invalid _sd_alg: ${_sd_alg}`);
+  }
   return { _sd_alg, payload };
 };
 

package/src/index.ts

@@ -12,6 +12,8 @@ import {
   type KBOptions,
   type PresentationFrame,
   type SafeVerifyResult,
+  SD_DECOY,
+  SD_DIGEST,
   type SDJWTCompact,
   type SDJWTConfig,
   type Signer,
@@ -19,12 +21,12 @@ import {
   type VerificationErrorCode,
 } from './types';
 import {
-  base64urlDecode,
   base64urlEncode,
   ensureError,
   SDJWTException,
   uint8ArrayToBase64Url,
 } from './utils';
+import { decodeBase64urlJsonStrict } from './utils/strict-json';
 
 export * from './decode';
 export * from './decoy';
@@ -120,9 +122,8 @@ export class SDJwtInstance<ExtendedPayload extends SdJwtPayload, T = unknown> {
       throw new SDJWTException('sign alogrithm not specified');
     }
 
-    if (disclosureFrame) {
-      this.validateReservedFields<Payload>(disclosureFrame);
-    }
+    this.validateReservedFields<Payload>(payload);
+    this.validateDisclosureFrame<Payload>(disclosureFrame);
 
     const hasher = this.userConfig.hasher;
     const hashAlg = this.userConfig.hashAlg ?? SDJwtInstance.DEFAULT_hashAlg;
@@ -157,12 +158,35 @@ export class SDJwtInstance<ExtendedPayload extends SdJwtPayload, T = unknown> {
   }
 
   /**
-   * Validates if the disclosureFrame contains any reserved fields. If so it will throw an error.
-   * @param disclosureFrame
+   * Validates if the payload contains any reserved claim names. If so it will throw an error.
+   * @param payload
    * @returns
    */
-  protected validateReservedFields<T extends ExtendedPayload>(
-    _disclosureFrame: DisclosureFrame<T>,
+  protected validateReservedFields<T extends ExtendedPayload>(payload: T) {
+    const reservedFields = new Set([SD_DIGEST, '_sd_alg', SD_DECOY]);
+
+    const visit = (node: unknown) => {
+      if (!node || typeof node !== 'object') {
+        return;
+      }
+
+      for (const [key, value] of Object.entries(
+        node as Record<string, unknown>,
+      )) {
+        if (reservedFields.has(key)) {
+          throw new SDJWTException(
+            `Reserved field name "${key}" is not allowed`,
+          );
+        }
+        visit(value);
+      }
+    };
+
+    visit(payload);
+  }
+
+  protected validateDisclosureFrame<T extends ExtendedPayload>(
+    _disclosureFrame?: DisclosureFrame<T>,
   ) {
     return;
   }
@@ -242,6 +266,7 @@ export class SDJwtInstance<ExtendedPayload extends SdJwtPayload, T = unknown> {
       verifier: this.userConfig.kbVerifier,
       payload,
       nonce: options.keyBindingNonce,
+      options,
     });
     if (!kb) {
       throw new Error('signature is not valid');
@@ -414,6 +439,7 @@ export class SDJwtInstance<ExtendedPayload extends SdJwtPayload, T = unknown> {
             verifier: this.userConfig.kbVerifier,
             payload,
             nonce: options.keyBindingNonce,
+            options,
           });
           if (!kbResult) {
             addError(
@@ -627,9 +653,8 @@ export class SDJwtGeneralJSONInstance<ExtendedPayload extends SdJwtPayload> {
       throw new SDJWTException('SaltGenerator not found');
     }
 
-    if (disclosureFrame) {
-      this.validateReservedFields<Payload>(disclosureFrame);
-    }
+    this.validateReservedFields<Payload>(payload);
+    this.validateDisclosureFrame<Payload>(disclosureFrame);
 
     const hasher = this.userConfig.hasher;
     const hashAlg = this.userConfig.hashAlg ?? SDJwtInstance.DEFAULT_hashAlg;
@@ -641,12 +666,15 @@ export class SDJwtGeneralJSONInstance<ExtendedPayload extends SdJwtPayload> {
       this.userConfig.saltGenerator,
     );
 
-    const encodedDisclosures = disclosures.map((d) => d.encode());
     const encodedSDJwtPayload = this.encodeObj({
       ...packedClaims,
       _sd_alg: disclosureFrame ? hashAlg : undefined,
     });
 
+    const encodedDisclosures = disclosures.map((disclosure) =>
+      disclosure.encode(),
+    );
+
     const signatures = await Promise.all(
       options.sigs.map(async (s) => {
         const { signer, alg, kid, header } = s;
@@ -658,7 +686,6 @@ export class SDJwtGeneralJSONInstance<ExtendedPayload extends SdJwtPayload> {
 
         return {
           protected: encodedProtectedHeader,
-          kid,
           signature,
         };
       }),
@@ -674,12 +701,35 @@ export class SDJwtGeneralJSONInstance<ExtendedPayload extends SdJwtPayload> {
   }
 
   /**
-   * Validates if the disclosureFrame contains any reserved fields. If so it will throw an error.
-   * @param disclosureFrame
+   * Validates if the payload contains any reserved claim names. If so it will throw an error.
+   * @param payload
    * @returns
    */
-  protected validateReservedFields<T extends ExtendedPayload>(
-    _disclosureFrame: DisclosureFrame<T>,
+  protected validateReservedFields<T extends ExtendedPayload>(payload: T) {
+    const reservedFields = new Set([SD_DIGEST, '_sd_alg', SD_DECOY]);
+
+    const visit = (node: unknown) => {
+      if (!node || typeof node !== 'object') {
+        return;
+      }
+
+      for (const [key, value] of Object.entries(
+        node as Record<string, unknown>,
+      )) {
+        if (reservedFields.has(key)) {
+          throw new SDJWTException(
+            `Reserved field name "${key}" is not allowed`,
+          );
+        }
+        visit(value);
+      }
+    };
+
+    visit(payload);
+  }
+
+  protected validateDisclosureFrame<T extends ExtendedPayload>(
+    _disclosureFrame?: DisclosureFrame<T>,
   ) {
     return;
   }
@@ -774,6 +824,7 @@ export class SDJwtGeneralJSONInstance<ExtendedPayload extends SdJwtPayload> {
       verifier: this.userConfig.kbVerifier,
       payload,
       nonce: options.keyBindingNonce,
+      options,
     });
     if (!kb) {
       throw new Error('signature is not valid');
@@ -833,7 +884,7 @@ export class SDJwtGeneralJSONInstance<ExtendedPayload extends SdJwtPayload> {
           `${encodedHeader}.${payload}`,
           signature,
         );
-        const header = JSON.parse(base64urlDecode(encodedHeader));
+        const header = decodeBase64urlJsonStrict(encodedHeader, 'Invalid JWT');
         return { verified, header };
       }),
     );

package/src/jwt.ts

@@ -37,6 +37,13 @@ export type VerifierOptions = {
    */
   keyBindingNonce?: string;
 
+  /**
+   * disable the verification of the status claim in the payload.
+   *
+   * @default false
+   */
+  disableStatusVerification?: boolean;
+
   /**
    * any other custom options
    */

package/src/kbjwt.ts

@@ -1,4 +1,4 @@
-import { Jwt } from './jwt';
+import { Jwt, type VerifierOptions } from './jwt';
 import {
   KB_JWT_TYP,
   type KbVerifier,
@@ -17,6 +17,11 @@ export class KBJwt<
     verifier: KbVerifier;
     payload: Record<string, unknown>;
     nonce: string;
+    /**
+     * Options forwarded to the common JWT verification, e.g. currentDate and
+     * skewSeconds used to validate the iat, nbf and exp claims.
+     */
+    options?: VerifierOptions;
   }) {
     if (!this.header || !this.payload || !this.signature) {
       throw new SDJWTException('Verify Error: Invalid JWT');
@@ -39,19 +44,19 @@ export class KBJwt<
       throw new SDJWTException('Invalid Key Binding Jwt');
     }
 
-    const data = this.getUnsignedToken();
-    const verified = await values.verifier(
-      data,
-      this.signature,
-      values.payload,
-    );
-    if (!verified) {
-      throw new SDJWTException('Verify Error: Invalid JWT Signature');
-    }
     if (this.payload.nonce !== values.nonce) {
       throw new SDJWTException('Verify Error: Invalid Nonce');
     }
 
+    // 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
+    // forward values.payload instead of the base verifier's options argument.
+    await this.verify(
+      (data, sig) => values.verifier(data, sig, values.payload),
+      values.options,
+    );
+
     return { payload: this.payload, header: this.header };
   }
 

package/src/test/index.spec.ts

@@ -100,6 +100,32 @@ describe('index', () => {
     expect(credential).toBeDefined();
   });
 
+  test('issue rejects reserved disclosure frame keys', async () => {
+    const { signer, verifier } = createSignerVerifier();
+    const sdjwt = new SDJwtInstance<SdJwtPayload>({
+      signer,
+      signAlg: 'EdDSA',
+      verifier,
+      hasher: digest,
+      saltGenerator: generateSalt,
+    });
+
+    await expect(
+      sdjwt.issue(
+        {
+          foo: 'bar',
+          _sd: 'reserved',
+          iss: 'Issuer',
+          iat: Math.floor(Date.now() / 1000),
+          vct: '',
+        },
+        {
+          _sd: ['foo'],
+        },
+      ),
+    ).rejects.toThrow('Reserved field name "_sd" is not allowed');
+  });
+
   test('verify failed', async () => {
     const { signer } = createSignerVerifier();
     const { publicKey } = Crypto.generateKeyPairSync('ed25519');
@@ -269,6 +295,140 @@ describe('index', () => {
     expect(results).toBeDefined();
   });
 
+  test('verify rejects an expired kbJwt during full verification', async () => {
+    const { signer, verifier } = createSignerVerifier();
+    const { privateKey, publicKey } = Crypto.generateKeyPairSync('ed25519');
+
+    const kbVerifier: KbVerifier = async (
+      data: string,
+      sig: string,
+      payload: JwtPayload,
+    ) => {
+      if (!payload.cnf) throw Error('key binding not supported');
+      return Crypto.verify(
+        null,
+        Buffer.from(data),
+        (await importJWK(payload.cnf.jwk as JWK, 'EdDSA')) as KeyLike,
+        Buffer.from(sig, 'base64url'),
+      );
+    };
+
+    const kbSigner = (data: string) => {
+      const sig = Crypto.sign(null, Buffer.from(data), privateKey);
+      return Buffer.from(sig).toString('base64url');
+    };
+
+    const sdjwt = new SDJwtInstance<SdJwtPayload>({
+      signer,
+      signAlg: 'EdDSA',
+      verifier,
+      hasher: digest,
+      saltGenerator: generateSalt,
+      kbSigner,
+      kbVerifier,
+      kbSignAlg: 'EdDSA',
+    });
+
+    const now = Math.floor(Date.now() / 1000);
+    const credential = await sdjwt.issue(
+      {
+        foo: 'bar',
+        iat: now,
+        cnf: { jwk: await exportJWK(publicKey) },
+      },
+      { _sd: ['foo'] },
+    );
+
+    const presentation = await sdjwt.present(
+      credential,
+      { foo: true },
+      {
+        kb: {
+          payload: {
+            aud: '1',
+            iat: now - 7200,
+            nonce: '342',
+            // kb+jwt expired one hour ago
+            exp: now - 3600,
+          } as never,
+        },
+      },
+    );
+
+    await expect(
+      sdjwt.verify(presentation, {
+        requiredClaimKeys: ['foo'],
+        keyBindingNonce: '342',
+      }),
+    ).rejects.toThrow('Verify Error: JWT is expired');
+  });
+
+  test('verify accepts a kbJwt with a future exp during full verification', async () => {
+    const { signer, verifier } = createSignerVerifier();
+    const { privateKey, publicKey } = Crypto.generateKeyPairSync('ed25519');
+
+    const kbVerifier: KbVerifier = async (
+      data: string,
+      sig: string,
+      payload: JwtPayload,
+    ) => {
+      if (!payload.cnf) throw Error('key binding not supported');
+      return Crypto.verify(
+        null,
+        Buffer.from(data),
+        (await importJWK(payload.cnf.jwk as JWK, 'EdDSA')) as KeyLike,
+        Buffer.from(sig, 'base64url'),
+      );
+    };
+
+    const kbSigner = (data: string) => {
+      const sig = Crypto.sign(null, Buffer.from(data), privateKey);
+      return Buffer.from(sig).toString('base64url');
+    };
+
+    const sdjwt = new SDJwtInstance<SdJwtPayload>({
+      signer,
+      signAlg: 'EdDSA',
+      verifier,
+      hasher: digest,
+      saltGenerator: generateSalt,
+      kbSigner,
+      kbVerifier,
+      kbSignAlg: 'EdDSA',
+    });
+
+    const now = Math.floor(Date.now() / 1000);
+    const credential = await sdjwt.issue(
+      {
+        foo: 'bar',
+        iat: now,
+        cnf: { jwk: await exportJWK(publicKey) },
+      },
+      { _sd: ['foo'] },
+    );
+
+    const presentation = await sdjwt.present(
+      credential,
+      { foo: true },
+      {
+        kb: {
+          payload: {
+            aud: '1',
+            iat: now,
+            nonce: '342',
+            exp: now + 3600,
+          } as never,
+        },
+      },
+    );
+
+    const results = await sdjwt.verify(presentation, {
+      requiredClaimKeys: ['foo'],
+      keyBindingNonce: '342',
+    });
+    expect(results.kb).toBeDefined();
+  });
+
   test('Hasher not found', async () => {
     const sdjwt = new SDJwtInstance<SdJwtPayload>({});
     try {
@@ -290,6 +450,38 @@ describe('index', () => {
     }
   });
 
+  test('decode rejects invalid _sd_alg values', async () => {
+    const { signer, verifier } = createSignerVerifier();
+    const sdjwt = new SDJwtInstance<SdJwtPayload>({
+      signer,
+      signAlg: 'EdDSA',
+      verifier,
+      hasher: digest,
+      saltGenerator: generateSalt,
+    });
+
+    const credential = await sdjwt.issue(
+      {
+        foo: 'bar',
+        iss: 'Issuer',
+        iat: Math.floor(Date.now() / 1000),
+        vct: '',
+      },
+      {
+        _sd: ['foo'],
+      },
+    );
+
+    const parts = credential.split('.');
+    const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString());
+    payload._sd_alg = 'SHA-256';
+    parts[1] = Buffer.from(JSON.stringify(payload)).toString('base64url');
+
+    await expect(sdjwt.decode(parts.join('.'))).rejects.toThrow(
+      'Invalid _sd_alg: SHA-256',
+    );
+  });
+
   test('SaltGenerator not found', async () => {
     const sdjwt = new SDJwtInstance<SdJwtPayload>({
       hasher: digest,