@sd-jwt/sd-jwt-vc 0.1.0

package/test/app-e2e.spec.ts

@@ -0,0 +1,286 @@
+import Crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { hasher as digest, generateSalt } from '@owf/crypto';
+import type {
+  DisclosureFrame,
+  PresentationFrame,
+  Signer,
+  Verifier,
+} from '@sd-jwt/core';
+import { describe, expect, test } from 'vitest';
+import { SDJwtVcInstance } from '../src/index';
+
+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 };
+};
+
+const iss = 'ExampleIssuer';
+const vct = 'ExampleCredentials';
+const iat = Math.floor(Date.now() / 1000); // current time in seconds
+
+describe('App', () => {
+  test('Example', async () => {
+    const { signer, verifier } = createSignerVerifier();
+    const sdjwt = new SDJwtVcInstance({
+      signer,
+      signAlg: 'EdDSA',
+      verifier,
+      hasher: digest,
+      hashAlg: 'sha-256',
+      saltGenerator: generateSalt,
+    });
+
+    const claims = {
+      firstname: 'John',
+      lastname: 'Doe',
+      ssn: '123-45-6789',
+      id: '1234',
+      data: {
+        firstname: 'John',
+        lastname: 'Doe',
+        ssn: '123-45-6789',
+        list: [{ r: '1' }, 'b', 'c'],
+      },
+      data2: {
+        hi: 'bye',
+      },
+      iat,
+      iss,
+      vct,
+    };
+    const disclosureFrame: DisclosureFrame<typeof claims> = {
+      _sd: ['firstname', 'id', 'data2'],
+      data: {
+        _sd: ['list'],
+        _sd_decoy: 2,
+        list: {
+          _sd: [0, 2],
+          _sd_decoy: 1,
+          0: {
+            _sd: ['r'],
+          },
+        },
+      },
+      data2: {
+        _sd: ['hi'],
+      },
+    };
+
+    const encodedSdjwt = await sdjwt.issue(claims, disclosureFrame);
+    expect(encodedSdjwt).toBeDefined();
+    const validated = await sdjwt.validate(encodedSdjwt);
+    expect(validated).toBeDefined();
+
+    const decoded = await sdjwt.decode(encodedSdjwt);
+    const keys = await decoded.keys(digest);
+    expect(keys).toEqual([
+      'data',
+      'data.firstname',
+      'data.lastname',
+      'data.list',
+      'data.list.0',
+      'data.list.0.r',
+      'data.list.1',
+      'data.list.2',
+      'data.ssn',
+      'data2',
+      'data2.hi',
+      'firstname',
+      'iat',
+      'id',
+      'iss',
+      'lastname',
+      'ssn',
+      'vct',
+    ]);
+    const payloads = await decoded.getClaims(digest);
+    expect(payloads).toEqual(claims);
+    const presentableKeys = await decoded.presentableKeys(digest);
+    expect(presentableKeys).toEqual([
+      'data.list',
+      'data.list.0',
+      'data.list.0.r',
+      'data.list.2',
+      'data2',
+      'data2.hi',
+      'firstname',
+      'id',
+    ]);
+
+    const presentationFrame = {
+      firstname: true,
+      id: true,
+    };
+    const presentedSDJwt = await sdjwt.present<typeof claims>(
+      encodedSdjwt,
+      presentationFrame,
+    );
+    expect(presentedSDJwt).toBeDefined();
+
+    const presentationClaims = await sdjwt.getClaims(presentedSDJwt);
+    expect(presentationClaims).toBeDefined();
+    expect(presentationClaims).toEqual({
+      lastname: 'Doe',
+      ssn: '123-45-6789',
+      data: { firstname: 'John', lastname: 'Doe', ssn: '123-45-6789' },
+      id: '1234',
+      firstname: 'John',
+      iat,
+      iss,
+      vct,
+    });
+
+    const requiredClaimKeys = ['firstname', 'id', 'data.ssn'];
+    const verified = await sdjwt.verify(encodedSdjwt, {
+      requiredClaimKeys,
+    });
+    expect(verified).toBeDefined();
+  });
+
+  test('From JSON (complex)', async () => {
+    await JSONtest('./complex.json');
+  });
+
+  test('From JSON (array_data_types)', async () => {
+    await JSONtest('./array_data_types.json');
+  });
+
+  test('From JSON (array_full_sd)', async () => {
+    await JSONtest('./array_full_sd.json');
+  });
+
+  test('From JSON (array_in_sd)', async () => {
+    await JSONtest('./array_in_sd.json');
+  });
+
+  test('From JSON (array_recursive_sd_some_disclosed)', async () => {
+    await JSONtest('./array_recursive_sd_some_disclosed.json');
+  });
+
+  test('From JSON (header_mod)', async () => {
+    await JSONtest('./header_mod.json');
+  });
+
+  test('From JSON (json_serialization)', async () => {
+    await JSONtest('./json_serialization.json');
+  });
+
+  test('From JSON (key_binding)', async () => {
+    await JSONtest('./key_binding.json');
+  });
+
+  test('From JSON (no_sd)', async () => {
+    await JSONtest('./no_sd.json');
+  });
+
+  test('From JSON (object_data_types)', async () => {
+    await JSONtest('./object_data_types.json');
+  });
+
+  test('From JSON (recursions)', async () => {
+    await JSONtest('./recursions.json');
+  });
+
+  test('From JSON (array_recursive_sd)', async () => {
+    await JSONtest('./array_recursive_sd.json');
+  });
+
+  test('From JSON (array_of_scalars)', async () => {
+    await JSONtest('./array_of_scalars.json');
+  });
+
+  test('From JSON (array_of_objects)', async () => {
+    await JSONtest('./array_of_objects.json');
+  });
+
+  test('From JSON (array_of_nulls)', async () => {
+    await JSONtest('./array_of_nulls.json');
+  });
+
+  test('From JSON (array_nested_in_plain)', async () => {
+    await JSONtest('./array_nested_in_plain.json');
+  });
+});
+
+async function JSONtest(filename: string) {
+  const test = loadTestJsonFile(filename);
+  const { signer, verifier } = createSignerVerifier();
+  const sdjwt = new SDJwtVcInstance({
+    signer,
+    signAlg: 'EdDSA',
+    verifier,
+    hasher: digest,
+    hashAlg: 'sha-256',
+    saltGenerator: generateSalt,
+  });
+
+  const payload = { iss, vct, iat, ...test.claims };
+  const encodedSdjwt = await sdjwt.issue(payload, test.disclosureFrame);
+
+  expect(encodedSdjwt).toBeDefined();
+
+  const validated = await sdjwt.validate(encodedSdjwt);
+
+  expect(validated).toBeDefined();
+  expect(validated).toStrictEqual({
+    header: { alg: 'EdDSA', typ: 'dc+sd-jwt' },
+    payload,
+  });
+
+  const presentedSDJwt = await sdjwt.present(
+    encodedSdjwt,
+    test.presentationFrames,
+  );
+
+  expect(presentedSDJwt).toBeDefined();
+
+  const presentationClaims = await sdjwt.getClaims(presentedSDJwt);
+
+  expect(presentationClaims).toEqual({
+    ...test.presentedClaims,
+    iat,
+    iss,
+    vct,
+  });
+
+  const verified = await sdjwt.verify(encodedSdjwt, {
+    requiredClaimKeys: test.requiredClaimKeys,
+  });
+
+  expect(verified).toBeDefined();
+  expect(verified).toStrictEqual({
+    header: { alg: 'EdDSA', typ: 'dc+sd-jwt' },
+    kb: undefined,
+    payload,
+  });
+}
+
+type TestJson = {
+  claims: object;
+  // biome-ignore lint/complexity/noBannedTypes: we want an empty object in this case
+  disclosureFrame: DisclosureFrame<{}>;
+  // biome-ignore lint/complexity/noBannedTypes: we want an empty object in this case
+  presentationFrames: PresentationFrame<{}>;
+  presentedClaims: object;
+  requiredClaimKeys: string[];
+};
+
+function loadTestJsonFile(filename: string) {
+  const filepath = path.join(__dirname, filename);
+  const fileContents = fs.readFileSync(filepath, 'utf8');
+  return JSON.parse(fileContents) as TestJson;
+}

package/test/array_data_types.json

@@ -0,0 +1,31 @@
+{
+  "claims": {
+    "data_types": [null, 42, 3.14, "foo", ["Test"], { "foo": "bar" }]
+  },
+  "disclosureFrame": {
+    "data_types": {
+      "_sd": [0, 1, 2, 3, 4, 5]
+    }
+  },
+  "presentationFrames": {
+    "data_types": {
+      "0": true,
+      "1": true,
+      "2": true,
+      "3": true,
+      "4": true,
+      "5": true
+    }
+  },
+  "presentedClaims": {
+    "data_types": [null, 42, 3.14, "foo", ["Test"], { "foo": "bar" }]
+  },
+  "requiredClaimKeys": [
+    "data_types.0",
+    "data_types.1",
+    "data_types.2",
+    "data_types.3",
+    "data_types.4",
+    "data_types.5"
+  ]
+}

package/test/array_full_sd.json

@@ -0,0 +1,21 @@
+{
+  "claims": {
+    "is_over": {
+      "13": true,
+      "18": false,
+      "21": false
+    }
+  },
+  "disclosureFrame": {
+    "is_over": {
+      "_sd": ["13", "18", "21"]
+    }
+  },
+  "presentationFrames": { "is_over": { "18": true } },
+  "presentedClaims": {
+    "is_over": {
+      "18": false
+    }
+  },
+  "requiredClaimKeys": ["is_over.18"]
+}

package/test/array_in_sd.json

@@ -0,0 +1,13 @@
+{
+  "claims": {
+    "sd_array": ["32", "23"]
+  },
+  "disclosureFrame": {
+    "_sd": ["sd_array"]
+  },
+  "presentationFrames": { "sd_array": true },
+  "presentedClaims": {
+    "sd_array": ["32", "23"]
+  },
+  "requiredClaimKeys": ["sd_array"]
+}

package/test/array_nested_in_plain.json

@@ -0,0 +1,29 @@
+{
+  "claims": {
+    "nested_array": [["foo", "bar"], ["baz", "qux"]]
+  },
+  "disclosureFrame": {
+    "nested_array": {
+      "0": {
+        "_sd": [0, 1]
+      },
+      "1": {
+        "_sd": [0, 1]
+      }
+    }
+  },
+  "presentationFrames": {
+    "nested_array": {
+      "0": {
+        "0": true
+      },
+      "1": {
+        "1": true
+      }
+    }
+  },
+  "presentedClaims": {
+    "nested_array": [["foo"], ["qux"]]
+  },
+  "requiredClaimKeys": ["nested_array.0.0", "nested_array.1.0"]
+}

package/test/array_none_disclosed.json

@@ -0,0 +1,17 @@
+{
+  "claims": {
+    "is_over": {
+      "13": false,
+      "18": true,
+      "21": false
+    }
+  },
+  "disclosureFrame": {
+    "is_over": {
+      "_sd": ["13", "18", "21"]
+    }
+  },
+  "presentationFrames": {},
+  "presentedClaims": {},
+  "requiredClaimKeys": []
+}

package/test/array_of_nulls.json

@@ -0,0 +1,15 @@
+{
+  "claims": {
+    "null_values": [null, null, null, null]
+  },
+  "disclosureFrame": {
+    "null_values": {
+      "_sd": [1, 2]
+    }
+  },
+  "presentationFrames": {},
+  "presentedClaims": {
+    "null_values": [null, null]
+  },
+  "requiredClaimKeys": ["null_values.0", "null_values.1"]
+}

package/test/array_of_objects.json

@@ -0,0 +1,65 @@
+{
+  "claims": {
+    "addresses": [
+      {
+        "street": "123 Main St",
+        "city": "Anytown",
+        "state": "NY",
+        "zip": "12345",
+        "type": "main_address"
+      },
+      {
+        "street": "456 Main St",
+        "city": "Anytown",
+        "state": "NY",
+        "zip": "12345",
+        "type": "secondary_address"
+      }
+    ],
+    "array_with_one_sd_object": {
+      "foo": "bar"
+    }
+  },
+  "disclosureFrame": {
+    "addresses": {
+      "_sd": [1]
+    },
+    "array_with_one_sd_object": {
+      "_sd": ["foo"]
+    }
+  },
+  "presentationFrames": {
+    "addresses": {
+      "1": true
+    },
+    "array_with_one_sd_object": {
+      "foo": true
+    }
+  },
+  "presentedClaims": {
+    "addresses": [
+      {
+        "street": "123 Main St",
+        "city": "Anytown",
+        "state": "NY",
+        "zip": "12345",
+        "type": "main_address"
+      },
+      {
+        "street": "456 Main St",
+        "city": "Anytown",
+        "state": "NY",
+        "zip": "12345",
+        "type": "secondary_address"
+      }
+    ],
+    "array_with_one_sd_object": {
+      "foo": "bar"
+    }
+  },
+  "requiredClaimKeys": [
+    "addresses.0.type",
+    "addresses.1.city",
+    "array_with_one_sd_object.foo"
+  ]
+}

package/test/array_of_scalars.json

@@ -0,0 +1,19 @@
+{
+  "claims": {
+    "nationalities": ["US", "CA", "DE"]
+  },
+  "disclosureFrame": {
+    "nationalities": {
+      "_sd": [0, 1]
+    }
+  },
+  "presentationFrames": {
+    "nationalities": {
+      "1": true
+    }
+  },
+  "presentedClaims": {
+    "nationalities": ["CA", "DE"]
+  },
+  "requiredClaimKeys": ["nationalities.0", "nationalities.1"]
+}

package/test/array_recursive_sd.json

@@ -0,0 +1,35 @@
+{
+  "claims": {
+    "array_with_recursive_sd": [
+      "boring",
+      {
+        "foo": "bar",
+        "baz": {
+          "qux": "quxx"
+        }
+      },
+      ["foo", "bar"]
+    ],
+    "test2": ["foo", "bar"]
+  },
+  "disclosureFrame": {
+    "array_with_recursive_sd": {
+      "_sd": [1],
+      "1": {
+        "_sd": ["baz"]
+      },
+      "2": {
+        "_sd": [0, 1]
+      }
+    },
+    "test2": {
+      "_sd": [0, 1]
+    }
+  },
+  "presentationFrames": {},
+  "presentedClaims": {
+    "array_with_recursive_sd": ["boring", []],
+    "test2": []
+  },
+  "requiredClaimKeys": ["array_with_recursive_sd.0", "test2"]
+}

package/test/array_recursive_sd_some_disclosed.json

@@ -0,0 +1,63 @@
+{
+  "claims": {
+    "array_with_recursive_sd": [
+      "boring",
+      {
+        "foo": "bar",
+        "baz": {
+          "qux": "quxx"
+        }
+      },
+      ["foo", "bar"]
+    ],
+    "test2": ["foo", "bar"]
+  },
+  "disclosureFrame": {
+    "array_with_recursive_sd": {
+      "1": {
+        "_sd": ["baz"]
+      },
+      "2": {
+        "_sd": [0, 1]
+      }
+    },
+    "test2": {
+      "_sd": [0, 1]
+    }
+  },
+  "presentationFrames": {
+    "array_with_recursive_sd": {
+      "1": {
+        "baz": true
+      },
+      "2": {
+        "1": true
+      }
+    },
+    "test2": {
+      "0": true,
+      "1": true
+    }
+  },
+  "presentedClaims": {
+    "array_with_recursive_sd": [
+      "boring",
+      {
+        "foo": "bar",
+        "baz": {
+          "qux": "quxx"
+        }
+      },
+      ["bar"]
+    ],
+    "test2": ["foo", "bar"]
+  },
+  "requiredClaimKeys": [
+    "array_with_recursive_sd.1",
+    "array_with_recursive_sd.2",
+    "array_with_recursive_sd.1.baz",
+    "array_with_recursive_sd.2.1",
+    "test2.0",
+    "test2.1"
+  ]
+}

package/test/complex.json

@@ -0,0 +1,43 @@
+{
+  "claims": {
+    "firstname": "John",
+    "lastname": "Doe",
+    "ssn": "123-45-6789",
+    "id": "1234",
+    "data": {
+      "firstname": "John",
+      "lastname": "Doe",
+      "ssn": "123-45-6789",
+      "list": [{ "r": "1" }, "b", "c"]
+    },
+    "data2": {
+      "hi": "bye"
+    }
+  },
+  "disclosureFrame": {
+    "_sd": ["firstname", "id", "data2"],
+    "data": {
+      "_sd": ["list"],
+      "_sd_decoy": 2,
+      "list": {
+        "_sd": [0, 2],
+        "_sd_decoy": 1,
+        "0": {
+          "_sd": ["r"]
+        }
+      }
+    },
+    "data2": {
+      "_sd": ["hi"]
+    }
+  },
+  "presentationFrames": { "firstname": true, "id": true },
+  "presentedClaims": {
+    "lastname": "Doe",
+    "ssn": "123-45-6789",
+    "data": { "firstname": "John", "lastname": "Doe", "ssn": "123-45-6789" },
+    "id": "1234",
+    "firstname": "John"
+  },
+  "requiredClaimKeys": ["firstname", "id", "data.ssn"]
+}

package/test/header_mod.json

@@ -0,0 +1,48 @@
+{
+  "claims": {
+    "sub": "john_deo_42",
+    "given_name": "John",
+    "family_name": "Deo",
+    "email": "johndeo@example.com",
+    "phone": "+1-202-555-0101",
+    "address": {
+      "street_address": "123 Main St",
+      "locality": "Anytown",
+      "region": "Anystate",
+      "country": "US"
+    },
+    "birthdate": "1940-01-01"
+  },
+  "disclosureFrame": {
+    "_sd": [
+      "sub",
+      "given_name",
+      "family_name",
+      "email",
+      "phone",
+      "address",
+      "birthdate"
+    ]
+  },
+  "presentationFrames": {
+    "given_name": true,
+    "family_name": true,
+    "address": true
+  },
+  "presentedClaims": {
+    "given_name": "John",
+    "family_name": "Deo",
+    "address": {
+      "street_address": "123 Main St",
+      "locality": "Anytown",
+      "region": "Anystate",
+      "country": "US"
+    }
+  },
+  "requiredClaimKeys": [
+    "given_name",
+    "family_name",
+    "address.street_address",
+    "address.country"
+  ]
+}