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

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) => {

package/src/utils/disclosure.ts

@@ -1,10 +1,7 @@
 import type { DisclosureData, HasherAndAlg, HasherAndAlgSync } from '../types';
-import {
-  base64urlDecode,
-  base64urlEncode,
-  uint8ArrayToBase64Url,
-} from './base64url';
+import { base64urlEncode, uint8ArrayToBase64Url } from './base64url';
 import { SDJWTException } from './error';
+import { decodeBase64urlJsonStrict } from './strict-json';
 
 export class Disclosure<T = unknown> {
   public salt: string;
@@ -42,7 +39,10 @@ export class Disclosure<T = unknown> {
     const { hasher, alg } = hash;
     const digest = await hasher(s, alg);
     const digestStr = uint8ArrayToBase64Url(digest);
-    const item = JSON.parse(base64urlDecode(s)) as DisclosureData<T>;
+    const item = decodeBase64urlJsonStrict<DisclosureData<T>>(
+      s,
+      'Invalid disclosure data',
+    );
     return Disclosure.fromArray<T>(item, { digest: digestStr, encoded: s });
   }
 
@@ -50,7 +50,10 @@ export class Disclosure<T = unknown> {
     const { hasher, alg } = hash;
     const digest = hasher(s, alg);
     const digestStr = uint8ArrayToBase64Url(digest);
-    const item = JSON.parse(base64urlDecode(s)) as DisclosureData<T>;
+    const item = decodeBase64urlJsonStrict<DisclosureData<T>>(
+      s,
+      'Invalid disclosure data',
+    );
     return Disclosure.fromArray<T>(item, { digest: digestStr, encoded: s });
   }
 

package/src/utils/strict-json.ts

@@ -0,0 +1,17 @@
+import { base64UrlToUint8Array } from './base64url';
+import { SDJWTException } from './error';
+
+const utf8Decoder = new TextDecoder('utf-8', { fatal: true });
+
+export const decodeBase64urlJsonStrict = <T>(
+  encoded: string,
+  errorMessage: string,
+): T => {
+  try {
+    const bytes = base64UrlToUint8Array(encoded);
+    const decoded = utf8Decoder.decode(bytes);
+    return JSON.parse(decoded) as T;
+  } catch {
+    throw new SDJWTException(errorMessage);
+  }
+};

package/test/app-e2e.spec.ts

@@ -135,6 +135,37 @@ describe('App', () => {
     expect(verified).toBeDefined();
   });
 
+  test('rejects tampered disclosure bytes', async () => {
+    const { signer, verifier } = createSignerVerifier();
+    const sdjwt = new SDJwtInstance<SdJwtPayload>({
+      signer,
+      signAlg: 'EdDSA',
+      verifier,
+      hasher: digest,
+      hashAlg: 'sha-256',
+      saltGenerator: generateSalt,
+    });
+
+    const claims = {
+      firstname: 'John',
+      lastname: 'Doe',
+    };
+    const disclosureFrame: DisclosureFrame<typeof claims> = {
+      _sd: ['firstname', 'lastname'],
+    };
+
+    const encodedSdjwt = await sdjwt.issue(claims, disclosureFrame);
+    const parts = encodedSdjwt.split('~');
+    const disclosureBytes = Buffer.from(parts[1], 'base64url');
+    disclosureBytes[2] = 0xf2;
+    parts[1] = Buffer.from(disclosureBytes).toString('base64url');
+    const tamperedSdjwt = parts.join('~');
+
+    await expect(sdjwt.verify(tamperedSdjwt)).rejects.toThrow(
+      'Invalid disclosure data',
+    );
+  });
+
   test('From JSON (complex)', async () => {
     await JSONtest('./complex.json');
   });