@sd-jwt/core 0.3.0 → 2.0.4-next.58

package/src/sdjwt.ts

@@ -0,0 +1,318 @@
+import { createDecoy } from './decoy';
+import { SDJWTException, Disclosure } from '@sd-jwt/utils';
+import { Jwt } from './jwt';
+import { KBJwt } from './kbjwt';
+import {
+  DisclosureFrame,
+  Hasher,
+  HasherAndAlg,
+  SDJWTCompact,
+  SD_DECOY,
+  SD_DIGEST,
+  SD_LIST_KEY,
+  SD_SEPARATOR,
+  SaltGenerator,
+  kbHeader,
+  kbPayload,
+} from '@sd-jwt/types';
+import { createHashMapping, getSDAlgAndPayload, unpack } from '@sd-jwt/decode';
+
+export type SDJwtData<
+  Header extends Record<string, unknown>,
+  Payload extends Record<string, unknown>,
+  KBHeader extends kbHeader = kbHeader,
+  KBPayload extends kbPayload = kbPayload,
+> = {
+  jwt?: Jwt<Header, Payload>;
+  disclosures?: Array<Disclosure>;
+  kbJwt?: KBJwt<KBHeader, KBPayload>;
+};
+
+export class SDJwt<
+  Header extends Record<string, unknown> = Record<string, unknown>,
+  Payload extends Record<string, unknown> = Record<string, unknown>,
+  KBHeader extends kbHeader = kbHeader,
+  KBPayload extends kbPayload = kbPayload,
+> {
+  public jwt?: Jwt<Header, Payload>;
+  public disclosures?: Array<Disclosure>;
+  public kbJwt?: KBJwt<KBHeader, KBPayload>;
+
+  constructor(data?: SDJwtData<Header, Payload, KBHeader, KBPayload>) {
+    this.jwt = data?.jwt;
+    this.disclosures = data?.disclosures;
+    this.kbJwt = data?.kbJwt;
+  }
+
+  public static async decodeSDJwt<
+    Header extends Record<string, unknown> = Record<string, unknown>,
+    Payload extends Record<string, unknown> = Record<string, unknown>,
+    KBHeader extends kbHeader = kbHeader,
+    KBPayload extends kbPayload = kbPayload,
+  >(
+    sdjwt: SDJWTCompact,
+    hasher: Hasher,
+  ): Promise<{
+    jwt: Jwt<Header, Payload>;
+    disclosures: Array<Disclosure>;
+    kbJwt?: KBJwt<KBHeader, KBPayload>;
+  }> {
+    const [encodedJwt, ...encodedDisclosures] = sdjwt.split(SD_SEPARATOR);
+    const jwt = Jwt.fromEncode<Header, Payload>(encodedJwt);
+
+    if (!jwt.payload) {
+      throw new Error('Payload is undefined on the JWT. Invalid state reached');
+    }
+
+    if (encodedDisclosures.length === 0) {
+      return {
+        jwt,
+        disclosures: [],
+      };
+    }
+
+    const encodedKeyBindingJwt = encodedDisclosures.pop();
+    const kbJwt = encodedKeyBindingJwt
+      ? KBJwt.fromKBEncode<KBHeader, KBPayload>(encodedKeyBindingJwt)
+      : undefined;
+
+    const { _sd_alg } = getSDAlgAndPayload(jwt.payload);
+
+    const disclosures = await Promise.all(
+      (encodedDisclosures as Array<string>).map((ed) =>
+        Disclosure.fromEncode(ed, { alg: _sd_alg, hasher }),
+      ),
+    );
+
+    return {
+      jwt,
+      disclosures,
+      kbJwt,
+    };
+  }
+
+  public static async fromEncode<
+    Header extends Record<string, unknown> = Record<string, unknown>,
+    Payload extends Record<string, unknown> = Record<string, unknown>,
+    KBHeader extends kbHeader = kbHeader,
+    KBPayload extends kbPayload = kbPayload,
+  >(
+    encodedSdJwt: SDJWTCompact,
+    hasher: Hasher,
+  ): Promise<SDJwt<Header, Payload>> {
+    const { jwt, disclosures, kbJwt } = await SDJwt.decodeSDJwt<
+      Header,
+      Payload,
+      KBHeader,
+      KBPayload
+    >(encodedSdJwt, hasher);
+
+    return new SDJwt<Header, Payload, KBHeader, KBPayload>({
+      jwt,
+      disclosures,
+      kbJwt,
+    });
+  }
+
+  public async present(keys: string[], hasher: Hasher): Promise<SDJWTCompact> {
+    if (!this.jwt?.payload || !this.disclosures) {
+      throw new SDJWTException('Invalid sd-jwt: jwt or disclosures is missing');
+    }
+    const { _sd_alg: alg } = getSDAlgAndPayload(this.jwt.payload);
+    const hash = { alg, hasher };
+    const hashmap = await createHashMapping(this.disclosures, hash);
+    const { disclosureKeymap } = await unpack(
+      this.jwt.payload,
+      this.disclosures,
+      hasher,
+    );
+
+    const presentableKeys = Object.keys(disclosureKeymap);
+    const missingKeys = keys.filter((k) => !presentableKeys.includes(k));
+    if (missingKeys.length > 0) {
+      throw new SDJWTException(
+        `Invalid sd-jwt: invalid present keys: ${missingKeys.join(', ')}`,
+      );
+    }
+
+    const disclosures = keys.map((k) => hashmap[disclosureKeymap[k]]);
+    const presentSDJwt = new SDJwt({
+      jwt: this.jwt,
+      disclosures,
+      kbJwt: this.kbJwt,
+    });
+    return presentSDJwt.encodeSDJwt();
+  }
+
+  public encodeSDJwt(): SDJWTCompact {
+    const data: string[] = [];
+
+    if (!this.jwt) {
+      throw new SDJWTException('Invalid sd-jwt: jwt is missing');
+    }
+
+    const encodedJwt = this.jwt.encodeJwt();
+    data.push(encodedJwt);
+
+    if (this.disclosures && this.disclosures.length > 0) {
+      const encodeddisclosures = this.disclosures
+        .map((dc) => dc.encode())
+        .join(SD_SEPARATOR);
+      data.push(encodeddisclosures);
+    }
+
+    data.push(this.kbJwt ? this.kbJwt.encodeJwt() : '');
+    return data.join(SD_SEPARATOR);
+  }
+
+  public async keys(hasher: Hasher): Promise<string[]> {
+    return listKeys(await this.getClaims(hasher)).sort();
+  }
+
+  public async presentableKeys(hasher: Hasher): Promise<string[]> {
+    if (!this.jwt?.payload || !this.disclosures) {
+      throw new SDJWTException('Invalid sd-jwt: jwt or disclosures is missing');
+    }
+    const { disclosureKeymap } = await unpack(
+      this.jwt?.payload,
+      this.disclosures,
+      hasher,
+    );
+    return Object.keys(disclosureKeymap).sort();
+  }
+
+  public async getClaims<T>(hasher: Hasher): Promise<T> {
+    if (!this.jwt?.payload || !this.disclosures) {
+      throw new SDJWTException('Invalid sd-jwt: jwt or disclosures is missing');
+    }
+    const { unpackedObj } = await unpack(
+      this.jwt.payload,
+      this.disclosures,
+      hasher,
+    );
+    return unpackedObj as T;
+  }
+}
+
+export const listKeys = (obj: Record<string, unknown>, prefix = '') => {
+  const keys: string[] = [];
+  for (const key in obj) {
+    if (obj[key] === undefined) continue;
+    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));
+    }
+  }
+  return keys;
+};
+
+export const pack = async <T extends Record<string, unknown>>(
+  claims: T,
+  disclosureFrame: DisclosureFrame<T> | undefined,
+  hash: HasherAndAlg,
+  saltGenerator: SaltGenerator,
+): Promise<{
+  packedClaims: Record<string, unknown> | Array<Record<string, unknown>>;
+  disclosures: Array<Disclosure>;
+}> => {
+  if (!disclosureFrame) {
+    return {
+      packedClaims: claims,
+      disclosures: [],
+    };
+  }
+
+  const sd = disclosureFrame[SD_DIGEST] ?? [];
+  const decoyCount = disclosureFrame[SD_DECOY] ?? 0;
+
+  if (Array.isArray(claims)) {
+    const packedClaims: Array<Record<typeof SD_LIST_KEY, string>> = [];
+    const disclosures: Array<Disclosure> = [];
+    const recursivePackedClaims: Record<number, unknown> = {};
+
+    for (const key in disclosureFrame) {
+      if (key !== SD_DIGEST) {
+        const idx = parseInt(key);
+        const packed = await pack(
+          claims[idx],
+          disclosureFrame[idx],
+          hash,
+          saltGenerator,
+        );
+        recursivePackedClaims[idx] = packed.packedClaims;
+        disclosures.push(...packed.disclosures);
+      }
+    }
+
+    for (let i = 0; i < claims.length; i++) {
+      const claim = recursivePackedClaims[i]
+        ? recursivePackedClaims[i]
+        : claims[i];
+      // TODO: should this actually be the `i` or `claim`?
+      // @ts-ignore
+      if (sd.includes(i)) {
+        const salt = await saltGenerator(16);
+        const disclosure = new Disclosure([salt, claim]);
+        const digest = await disclosure.digest(hash);
+        packedClaims.push({ [SD_LIST_KEY]: digest });
+        disclosures.push(disclosure);
+      } else {
+        packedClaims.push(claim);
+      }
+    }
+    for (let j = 0; j < decoyCount; j++) {
+      const decoyDigest = await createDecoy(hash, saltGenerator);
+      packedClaims.push({ [SD_LIST_KEY]: decoyDigest });
+    }
+    return { packedClaims, disclosures };
+  }
+
+  const packedClaims: Record<string, unknown> = {};
+  const disclosures: Array<Disclosure> = [];
+  const recursivePackedClaims: Record<string, unknown> = {};
+
+  for (const key in disclosureFrame) {
+    if (key !== SD_DIGEST) {
+      const packed = await pack(
+        // @ts-ignore
+        claims[key],
+        disclosureFrame[key],
+        hash,
+        saltGenerator,
+      );
+      recursivePackedClaims[key] = packed.packedClaims;
+      disclosures.push(...packed.disclosures);
+    }
+  }
+
+  const _sd: string[] = [];
+
+  for (const key in claims) {
+    const claim = recursivePackedClaims[key]
+      ? recursivePackedClaims[key]
+      : claims[key];
+    // @ts-ignore
+    if (sd.includes(key)) {
+      const salt = await saltGenerator(16);
+      const disclosure = new Disclosure([salt, key, claim]);
+      const digest = await disclosure.digest(hash);
+
+      _sd.push(digest);
+      disclosures.push(disclosure);
+    } else {
+      packedClaims[key] = claim;
+    }
+  }
+
+  for (let j = 0; j < decoyCount; j++) {
+    const decoyDigest = await createDecoy(hash, saltGenerator);
+    _sd.push(decoyDigest);
+  }
+
+  if (_sd.length > 0) {
+    packedClaims[SD_DIGEST] = _sd.sort();
+  }
+  return { packedClaims, disclosures };
+};

package/src/test/decoy.spec.ts

@@ -0,0 +1,30 @@
+import { createDecoy } from '../decoy';
+import { describe, expect, test } from 'vitest';
+import { Base64urlEncode } from '@sd-jwt/utils';
+import { digest, generateSalt } from '@sd-jwt/crypto-nodejs';
+
+const hash = {
+  hasher: digest,
+  alg: 'SHA256',
+};
+
+describe('Decoy', () => {
+  test('decoy', async () => {
+    const decoyValue = await createDecoy(hash, generateSalt);
+    expect(decoyValue.length).toBe(43);
+  });
+
+  // ref https://datatracker.ietf.org/doc/draft-ietf-oauth-selective-disclosure-jwt/07/
+  //  *Claim email*:
+  //  *  SHA-256 Hash: JzYjH4svliH0R3PyEMfeZu6Jt69u5qehZo7F7EPYlSE
+  //  *  Disclosure: WyI2SWo3dE0tYTVpVlBHYm9TNXRtdlZBIiwgImVtYWlsIiwgImpvaG5kb2VAZXhhbXBsZS5jb20iXQ
+  //  *  Contents: ["6Ij7tM-a5iVPGboS5tmvVA", "email", "johndoe@example.com"]
+  test('apply hasher and saltGenerator', async () => {
+    const decoyValue = await createDecoy(hash, () =>
+      Base64urlEncode(
+        '["6Ij7tM-a5iVPGboS5tmvVA", "email", "johndoe@example.com"]',
+      ),
+    );
+    expect(decoyValue).toBe('JzYjH4svliH0R3PyEMfeZu6Jt69u5qehZo7F7EPYlSE');
+  });
+});

package/src/test/index.spec.ts

@@ -0,0 +1,379 @@
+import { SDJwtInstance } from '../index';
+import { Signer, Verifier } from '@sd-jwt/types';
+import Crypto from 'node:crypto';
+import { describe, expect, test } from 'vitest';
+import { digest, generateSalt } from '@sd-jwt/crypto-nodejs';
+
+export const createSignerVerifier = () => {
+  const { privateKey, publicKey } = Crypto.generateKeyPairSync('ed25519');
+  const signer: Signer = async (data: string) => {
+    const sig = Crypto.sign(null, Buffer.from(data), privateKey);
+    return Buffer.from(sig).toString('base64url');
+  };
+  const verifier: Verifier = async (data: string, sig: string) => {
+    return Crypto.verify(
+      null,
+      Buffer.from(data),
+      publicKey,
+      Buffer.from(sig, 'base64url'),
+    );
+  };
+  return { signer, verifier };
+};
+
+describe('index', () => {
+  test('create', async () => {
+    const sdjwt = new SDJwtInstance();
+    expect(sdjwt).toBeDefined();
+  });
+
+  test('kbJwt', async () => {
+    const { signer, verifier } = createSignerVerifier();
+    const sdjwt = new SDJwtInstance({
+      signer,
+      signAlg: 'EdDSA',
+      verifier,
+      hasher: digest,
+      saltGenerator: generateSalt,
+      kbSigner: signer,
+      kbSignAlg: 'EdDSA',
+    });
+    const credential = await sdjwt.issue(
+      {
+        foo: 'bar',
+      },
+      {
+        _sd: ['foo'],
+      },
+    );
+
+    expect(credential).toBeDefined();
+
+    const presentation = await sdjwt.present(credential, ['foo'], {
+      kb: {
+        payload: {
+          sd_hash: 'sha-256',
+          aud: '1',
+          iat: 1,
+          nonce: '342',
+        },
+      },
+    });
+
+    expect(presentation).toBeDefined();
+  });
+
+  test('issue', async () => {
+    const { signer, verifier } = createSignerVerifier();
+    const sdjwt = new SDJwtInstance({
+      signer,
+      signAlg: 'EdDSA',
+      verifier,
+      hasher: digest,
+      saltGenerator: generateSalt,
+    });
+    const credential = await sdjwt.issue(
+      {
+        foo: 'bar',
+      },
+      {
+        _sd: ['foo'],
+      },
+    );
+
+    expect(credential).toBeDefined();
+  });
+
+  test('verify failed', async () => {
+    const { signer } = createSignerVerifier();
+    const { publicKey } = Crypto.generateKeyPairSync('ed25519');
+    const failedverifier: Verifier = async (data: string, sig: string) => {
+      return Crypto.verify(
+        null,
+        Buffer.from(data),
+        publicKey,
+        Buffer.from(sig, 'base64url'),
+      );
+    };
+
+    const sdjwt = new SDJwtInstance({
+      signer,
+      signAlg: 'EdDSA',
+      verifier: failedverifier,
+      hasher: digest,
+      saltGenerator: generateSalt,
+    });
+
+    const credential = await sdjwt.issue(
+      {
+        foo: 'bar',
+      },
+      {
+        _sd: ['foo'],
+      },
+    );
+
+    try {
+      await sdjwt.verify(credential);
+    } catch (e) {
+      expect(e).toBeDefined();
+    }
+  });
+
+  test('verify failed with kbJwt', async () => {
+    const { signer, verifier } = createSignerVerifier();
+    const { publicKey } = Crypto.generateKeyPairSync('ed25519');
+    const failedverifier: Verifier = async (data: string, sig: string) => {
+      return Crypto.verify(
+        null,
+        Buffer.from(data),
+        publicKey,
+        Buffer.from(sig, 'base64url'),
+      );
+    };
+    const sdjwt = new SDJwtInstance({
+      signer,
+      signAlg: 'EdDSA',
+      verifier,
+      hasher: digest,
+      saltGenerator: generateSalt,
+      kbSigner: signer,
+      kbVerifier: failedverifier,
+      kbSignAlg: 'EdDSA',
+    });
+
+    const credential = await sdjwt.issue(
+      {
+        foo: 'bar',
+      },
+      {
+        _sd: ['foo'],
+      },
+    );
+
+    const presentation = await sdjwt.present(credential, ['foo'], {
+      kb: {
+        payload: {
+          sd_hash: '',
+          aud: '1',
+          iat: 1,
+          nonce: '342',
+        },
+      },
+    });
+
+    try {
+      await sdjwt.verify(presentation);
+    } catch (e) {
+      expect(e).toBeDefined();
+    }
+  });
+
+  test('verify with kbJwt', async () => {
+    const { signer, verifier } = createSignerVerifier();
+    const sdjwt = new SDJwtInstance({
+      signer,
+      signAlg: 'EdDSA',
+      verifier,
+      hasher: digest,
+      saltGenerator: generateSalt,
+      kbSigner: signer,
+      kbVerifier: verifier,
+      kbSignAlg: 'EdDSA',
+    });
+
+    const credential = await sdjwt.issue(
+      {
+        foo: 'bar',
+      },
+      {
+        _sd: ['foo'],
+      },
+    );
+
+    const presentation = await sdjwt.present(credential, ['foo'], {
+      kb: {
+        payload: {
+          sd_hash: 'sha-256',
+          aud: '1',
+          iat: 1,
+          nonce: '342',
+        },
+      },
+    });
+
+    const results = await sdjwt.verify(presentation, ['foo'], true);
+    expect(results).toBeDefined();
+  });
+
+  test('Hasher not found', async () => {
+    const sdjwt = new SDJwtInstance({});
+    try {
+      const credential = await sdjwt.issue(
+        {
+          foo: 'bar',
+        },
+        {
+          _sd: ['foo'],
+        },
+      );
+
+      expect(credential).toBeDefined();
+    } catch (e) {
+      expect(e).toBeDefined();
+    }
+  });
+
+  test('SaltGenerator not found', async () => {
+    const sdjwt = new SDJwtInstance({
+      hasher: digest,
+    });
+    try {
+      const credential = await sdjwt.issue(
+        {
+          foo: 'bar',
+        },
+        {
+          _sd: ['foo'],
+        },
+      );
+
+      expect(credential).toBeDefined();
+    } catch (e) {
+      expect(e).toBeDefined();
+    }
+  });
+
+  test('Signer not found', async () => {
+    const sdjwt = new SDJwtInstance({
+      hasher: digest,
+      saltGenerator: generateSalt,
+    });
+    try {
+      const credential = await sdjwt.issue(
+        {
+          foo: 'bar',
+        },
+        {
+          _sd: ['foo'],
+        },
+      );
+
+      expect(credential).toBeDefined();
+    } catch (e) {
+      expect(e).toBeDefined();
+    }
+  });
+
+  test('Verifier not found', async () => {
+    const { signer, verifier } = createSignerVerifier();
+    const sdjwt = new SDJwtInstance({
+      signer,
+      hasher: digest,
+      saltGenerator: generateSalt,
+      kbSigner: signer,
+      kbVerifier: verifier,
+      signAlg: 'EdDSA',
+      kbSignAlg: 'EdDSA',
+    });
+
+    const credential = await sdjwt.issue(
+      {
+        foo: 'bar',
+      },
+      {
+        _sd: ['foo'],
+      },
+    );
+
+    const presentation = await sdjwt.present(credential, ['foo'], {
+      kb: {
+        payload: {
+          sd_hash: 'sha-256',
+          aud: '1',
+          iat: 1,
+          nonce: '342',
+        },
+      },
+    });
+    try {
+      const results = await sdjwt.verify(presentation, ['foo'], true);
+    } catch (e) {
+      expect(e).toBeDefined();
+    }
+  });
+
+  test('kbSigner not found', async () => {
+    const { signer, verifier } = createSignerVerifier();
+    const sdjwt = new SDJwtInstance({
+      signer,
+      verifier,
+      hasher: digest,
+      saltGenerator: generateSalt,
+      kbVerifier: verifier,
+      signAlg: 'EdDSA',
+      kbSignAlg: 'EdDSA',
+    });
+
+    const credential = await sdjwt.issue(
+      {
+        foo: 'bar',
+      },
+      {
+        _sd: ['foo'],
+      },
+    );
+    try {
+      const presentation = await sdjwt.present(credential, ['foo'], {
+        kb: {
+          payload: {
+            sd_hash: 'sha-256',
+            aud: '1',
+            iat: 1,
+            nonce: '342',
+          },
+        },
+      });
+    } catch (e) {
+      expect(e).toBeDefined();
+    }
+  });
+
+  test('kbVerifier not found', async () => {
+    const { signer, verifier } = createSignerVerifier();
+    const sdjwt = new SDJwtInstance({
+      signer,
+      verifier,
+      hasher: digest,
+      saltGenerator: generateSalt,
+      kbSigner: signer,
+      signAlg: 'EdDSA',
+      kbSignAlg: 'EdDSA',
+    });
+
+    const credential = await sdjwt.issue(
+      {
+        foo: 'bar',
+      },
+      {
+        _sd: ['foo'],
+      },
+    );
+
+    const presentation = await sdjwt.present(credential, ['foo'], {
+      kb: {
+        payload: {
+          sd_hash: 'sha-256',
+          aud: '1',
+          iat: 1,
+          nonce: '342',
+        },
+      },
+    });
+    try {
+      const results = await sdjwt.verify(presentation, ['foo'], true);
+    } catch (e) {
+      expect(e).toBeDefined();
+    }
+  });
+});