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

package/dist/index.d.mts

@@ -376,6 +376,11 @@ declare class KBJwt<Header extends kbHeader = kbHeader, Payload extends kbPayloa
         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;
     }): Promise<{
         payload: Payload;
         header: Header;

package/dist/index.d.ts

@@ -376,6 +376,11 @@ declare class KBJwt<Header extends kbHeader = kbHeader, Payload extends kbPayloa
         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;
     }): Promise<{
         payload: Payload;
         header: Header;

package/dist/index.js

@@ -730,18 +730,13 @@ var KBJwt = class _KBJwt extends Jwt {
       !(this.payload.sd_hash || "_sd_hash" in this.payload && this.payload._sd_hash)) {
         throw new SDJWTException("Invalid Key Binding Jwt");
       }
-      const data = this.getUnsignedToken();
-      const verified = yield 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");
       }
+      yield this.verify(
+        (data, sig) => values.verifier(data, sig, values.payload),
+        values.options
+      );
       return { payload: this.payload, header: this.header };
     });
   }
@@ -1259,7 +1254,8 @@ var _SDJwtInstance = class _SDJwtInstance {
       const kb = yield sdjwt.kbJwt.verifyKB({
         verifier: this.userConfig.kbVerifier,
         payload,
-        nonce: options.keyBindingNonce
+        nonce: options.keyBindingNonce,
+        options
       });
       if (!kb) {
         throw new Error("signature is not valid");
@@ -1390,7 +1386,8 @@ var _SDJwtInstance = class _SDJwtInstance {
             const kbResult = yield sdjwt.kbJwt.verifyKB({
               verifier: this.userConfig.kbVerifier,
               payload,
-              nonce: options.keyBindingNonce
+              nonce: options.keyBindingNonce,
+              options
             });
             if (!kbResult) {
               addError(
@@ -1690,7 +1687,8 @@ var SDJwtGeneralJSONInstance = class {
       const kb = yield sdjwt.kbJwt.verifyKB({
         verifier: this.userConfig.kbVerifier,
         payload,
-        nonce: options.keyBindingNonce
+        nonce: options.keyBindingNonce,
+        options
       });
       if (!kb) {
         throw new Error("signature is not valid");

package/dist/index.mjs

@@ -671,18 +671,13 @@ var KBJwt = class _KBJwt extends Jwt {
       !(this.payload.sd_hash || "_sd_hash" in this.payload && this.payload._sd_hash)) {
         throw new SDJWTException("Invalid Key Binding Jwt");
       }
-      const data = this.getUnsignedToken();
-      const verified = yield 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");
       }
+      yield this.verify(
+        (data, sig) => values.verifier(data, sig, values.payload),
+        values.options
+      );
       return { payload: this.payload, header: this.header };
     });
   }
@@ -1200,7 +1195,8 @@ var _SDJwtInstance = class _SDJwtInstance {
       const kb = yield sdjwt.kbJwt.verifyKB({
         verifier: this.userConfig.kbVerifier,
         payload,
-        nonce: options.keyBindingNonce
+        nonce: options.keyBindingNonce,
+        options
       });
       if (!kb) {
         throw new Error("signature is not valid");
@@ -1331,7 +1327,8 @@ var _SDJwtInstance = class _SDJwtInstance {
             const kbResult = yield sdjwt.kbJwt.verifyKB({
               verifier: this.userConfig.kbVerifier,
               payload,
-              nonce: options.keyBindingNonce
+              nonce: options.keyBindingNonce,
+              options
             });
             if (!kbResult) {
               addError(
@@ -1631,7 +1628,8 @@ var SDJwtGeneralJSONInstance = class {
       const kb = yield sdjwt.kbJwt.verifyKB({
         verifier: this.userConfig.kbVerifier,
         payload,
-        nonce: options.keyBindingNonce
+        nonce: options.keyBindingNonce,
+        options
       });
       if (!kb) {
         throw new Error("signature is not valid");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sd-jwt/core",
-  "version": "0.19.1-next.10+fe18c35",
+  "version": "0.19.1-next.11+9e9bca1",
   "description": "sd-jwt draft 7 implementation in typescript",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -58,5 +58,5 @@
       "esm"
     ]
   },
-  "gitHead": "fe18c3572055c3307d05f43f738c1d3c3f15de38"
+  "gitHead": "9e9bca10de3ad8574bfcbc875c85e37cee541505"
 }

package/src/index.ts

@@ -242,6 +242,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 +415,7 @@ export class SDJwtInstance<ExtendedPayload extends SdJwtPayload, T = unknown> {
             verifier: this.userConfig.kbVerifier,
             payload,
             nonce: options.keyBindingNonce,
+            options,
           });
           if (!kbResult) {
             addError(
@@ -774,6 +776,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');

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

@@ -269,6 +269,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 {

package/src/test/kbjwt.spec.ts

@@ -6,6 +6,7 @@ import {
   type JwtPayload,
   KB_JWT_TYP,
   type KbVerifier,
+  type kbPayload,
   type Signer,
 } from '../types';
 import type { SDJWTException } from '../utils';
@@ -287,6 +288,216 @@ describe('KB JWT', () => {
     }
   });
 
+  test('verify failed with expired exp claim', async () => {
+    const { privateKey, publicKey } = Crypto.generateKeyPairSync('ed25519');
+    const testSigner: Signer = async (data: string) => {
+      const sig = Crypto.sign(null, Buffer.from(data), privateKey);
+      return Buffer.from(sig).toString('base64url');
+    };
+
+    const payload = {
+      cnf: {
+        jwk: await exportJWK(publicKey),
+      },
+    };
+    const testVerifier: KbVerifier = async (
+      data: string,
+      sig: string,
+      payload: JwtPayload,
+    ) => {
+      const publicKey = payload.cnf?.jwk;
+      return Crypto.verify(
+        null,
+        Buffer.from(data),
+        (await importJWK(publicKey as JWK, 'EdDSA')) as KeyLike,
+        Buffer.from(sig, 'base64url'),
+      );
+    };
+
+    const kbJwt = new KBJwt({
+      header: {
+        typ: KB_JWT_TYP,
+        alg: 'EdDSA',
+      },
+      payload: {
+        iat: 1,
+        aud: 'aud',
+        nonce: 'nonce',
+        sd_hash: 'hash',
+        // expired one hour before the current date used below
+        exp: 1000,
+      } as kbPayload,
+    });
+    const encodedKbJwt = await kbJwt.sign(testSigner);
+    const decoded = KBJwt.fromKBEncode(encodedKbJwt);
+
+    await expect(
+      decoded.verifyKB({
+        verifier: testVerifier,
+        payload,
+        nonce: 'nonce',
+        options: { currentDate: 5000 },
+      }),
+    ).rejects.toThrow('Verify Error: JWT is expired');
+  });
+
+  test('verify failed with iat in the future', async () => {
+    const { privateKey, publicKey } = Crypto.generateKeyPairSync('ed25519');
+    const testSigner: Signer = async (data: string) => {
+      const sig = Crypto.sign(null, Buffer.from(data), privateKey);
+      return Buffer.from(sig).toString('base64url');
+    };
+
+    const payload = {
+      cnf: {
+        jwk: await exportJWK(publicKey),
+      },
+    };
+    const testVerifier: KbVerifier = async (
+      data: string,
+      sig: string,
+      payload: JwtPayload,
+    ) => {
+      const publicKey = payload.cnf?.jwk;
+      return Crypto.verify(
+        null,
+        Buffer.from(data),
+        (await importJWK(publicKey as JWK, 'EdDSA')) as KeyLike,
+        Buffer.from(sig, 'base64url'),
+      );
+    };
+
+    const kbJwt = new KBJwt({
+      header: {
+        typ: KB_JWT_TYP,
+        alg: 'EdDSA',
+      },
+      payload: {
+        iat: 5000,
+        aud: 'aud',
+        nonce: 'nonce',
+        sd_hash: 'hash',
+      },
+    });
+    const encodedKbJwt = await kbJwt.sign(testSigner);
+    const decoded = KBJwt.fromKBEncode(encodedKbJwt);
+
+    await expect(
+      decoded.verifyKB({
+        verifier: testVerifier,
+        payload,
+        nonce: 'nonce',
+        // iat (5000) is after the current date (1000)
+        options: { currentDate: 1000 },
+      }),
+    ).rejects.toThrow('Verify Error: JWT is not yet valid');
+  });
+
+  test('verify failed with nbf in the future', async () => {
+    const { privateKey, publicKey } = Crypto.generateKeyPairSync('ed25519');
+    const testSigner: Signer = async (data: string) => {
+      const sig = Crypto.sign(null, Buffer.from(data), privateKey);
+      return Buffer.from(sig).toString('base64url');
+    };
+
+    const payload = {
+      cnf: {
+        jwk: await exportJWK(publicKey),
+      },
+    };
+    const testVerifier: KbVerifier = async (
+      data: string,
+      sig: string,
+      payload: JwtPayload,
+    ) => {
+      const publicKey = payload.cnf?.jwk;
+      return Crypto.verify(
+        null,
+        Buffer.from(data),
+        (await importJWK(publicKey as JWK, 'EdDSA')) as KeyLike,
+        Buffer.from(sig, 'base64url'),
+      );
+    };
+
+    const kbJwt = new KBJwt({
+      header: {
+        typ: KB_JWT_TYP,
+        alg: 'EdDSA',
+      },
+      payload: {
+        iat: 1,
+        aud: 'aud',
+        nonce: 'nonce',
+        sd_hash: 'hash',
+        nbf: 5000,
+      } as kbPayload,
+    });
+    const encodedKbJwt = await kbJwt.sign(testSigner);
+    const decoded = KBJwt.fromKBEncode(encodedKbJwt);
+
+    await expect(
+      decoded.verifyKB({
+        verifier: testVerifier,
+        payload,
+        nonce: 'nonce',
+        options: { currentDate: 1000 },
+      }),
+    ).rejects.toThrow('Verify Error: JWT is not yet valid');
+  });
+
+  test('verify succeeds for expired exp within the allowed skew', async () => {
+    const { privateKey, publicKey } = Crypto.generateKeyPairSync('ed25519');
+    const testSigner: Signer = async (data: string) => {
+      const sig = Crypto.sign(null, Buffer.from(data), privateKey);
+      return Buffer.from(sig).toString('base64url');
+    };
+
+    const payload = {
+      cnf: {
+        jwk: await exportJWK(publicKey),
+      },
+    };
+    const testVerifier: KbVerifier = async (
+      data: string,
+      sig: string,
+      payload: JwtPayload,
+    ) => {
+      const publicKey = payload.cnf?.jwk;
+      return Crypto.verify(
+        null,
+        Buffer.from(data),
+        (await importJWK(publicKey as JWK, 'EdDSA')) as KeyLike,
+        Buffer.from(sig, 'base64url'),
+      );
+    };
+
+    const kbJwt = new KBJwt({
+      header: {
+        typ: KB_JWT_TYP,
+        alg: 'EdDSA',
+      },
+      payload: {
+        iat: 1,
+        aud: 'aud',
+        nonce: 'nonce',
+        sd_hash: 'hash',
+        exp: 1000,
+      } as kbPayload,
+    });
+    const encodedKbJwt = await kbJwt.sign(testSigner);
+    const decoded = KBJwt.fromKBEncode(encodedKbJwt);
+
+    // exp (1000) is before the current date (1100) but within the 200s skew
+    const verified = await decoded.verifyKB({
+      verifier: testVerifier,
+      payload,
+      nonce: 'nonce',
+      options: { currentDate: 1100, skewSeconds: 200 },
+    });
+
+    expect(verified.payload.exp).toBe(1000);
+  });
+
   test('compatibility test for version 06', async () => {
     const { privateKey, publicKey } = Crypto.generateKeyPairSync('ed25519');
     const testSigner: Signer = async (data: string) => {