@nuggetslife/vc 0.0.21 → 0.0.23

package/test_fuzz.mjs

@@ -0,0 +1,202 @@
+import { strict as assert } from 'assert';
+
+// Import NAPI bindings - matching patterns from test.mjs and test_jose.mjs
+import {
+  JsonLd,
+  BbsBlsSignature2020,
+  BbsBlsSignatureProof2020,
+  Bls12381G2KeyPair,
+  generateJwk,
+  generateKeyPair,
+  generalEncryptJson,
+  decryptJson,
+  compactSignJson,
+  compactJsonVerify,
+  flattenedSignJson,
+  jsonVerify,
+  JoseNamedCurve,
+  JoseKeyEncryption,
+  JoseContentEncryption,
+  JoseSigningAlgorithm,
+} from './index.js';
+
+let passed = 0;
+let failed = 0;
+
+async function test(name, fn) {
+  try {
+    await fn();
+    passed++;
+    console.log(`  PASS: ${name}`);
+  } catch (e) {
+    failed++;
+    console.log(`  FAIL: ${name}`);
+    console.log(`    ${e.message}`);
+  }
+}
+
+function randomJson(depth = 0) {
+  if (depth > 3) return Math.random().toString(36);
+  const type = Math.floor(Math.random() * 5);
+  switch (type) {
+    case 0: return null;
+    case 1: return Math.random() * 1000 - 500;
+    case 2: return Math.random().toString(36).substring(2);
+    case 3: {
+      const arr = [];
+      for (let i = 0; i < Math.floor(Math.random() * 4); i++) arr.push(randomJson(depth + 1));
+      return arr;
+    }
+    case 4: {
+      const obj = {};
+      for (let i = 0; i < Math.floor(Math.random() * 4); i++) {
+        obj[Math.random().toString(36).substring(2, 7)] = randomJson(depth + 1);
+      }
+      return obj;
+    }
+  }
+}
+
+console.log('\n=== NAPI Fuzz Tests ===\n');
+
+// Category 1: Random JSON to JsonLd operations (should not crash)
+console.log('--- JSON-LD with random inputs ---');
+for (let i = 0; i < 20; i++) {
+  await test(`JsonLd.expand random input #${i}`, async () => {
+    const jsonld = new JsonLd();
+    try {
+      await jsonld.expand(randomJson());
+    } catch (e) {
+      // Errors are fine, crashes are not
+      assert.ok(e instanceof Error, 'should throw Error, not crash');
+    }
+  });
+}
+
+for (let i = 0; i < 10; i++) {
+  await test(`JsonLd.compact random input #${i}`, async () => {
+    const jsonld = new JsonLd();
+    try {
+      await jsonld.compact(randomJson(), randomJson());
+    } catch (e) {
+      assert.ok(e instanceof Error);
+    }
+  });
+}
+
+for (let i = 0; i < 10; i++) {
+  await test(`JsonLd.frame random input #${i}`, async () => {
+    const jsonld = new JsonLd();
+    try {
+      await jsonld.frame(randomJson(), randomJson());
+    } catch (e) {
+      assert.ok(e instanceof Error);
+    }
+  });
+}
+
+// Category 2: Invalid key pairs to BBS operations
+console.log('\n--- BBS with invalid inputs ---');
+
+await test('BbsBlsSignature2020.createProof with no key (verifier-only)', async () => {
+  try {
+    const suite = new BbsBlsSignature2020();
+    await suite.createProof({ document: {}, contexts: {} });
+  } catch (e) {
+    assert.ok(e instanceof Error);
+  }
+});
+
+await test('BbsBlsSignature2020.verifyProof with random proof', async () => {
+  try {
+    const suite = new BbsBlsSignature2020();
+    await suite.verifyProof({ document: randomJson(), contexts: {} });
+  } catch (e) {
+    assert.ok(e instanceof Error);
+  }
+});
+
+// Category 3: Empty/null/undefined arguments
+console.log('\n--- Null/undefined arguments ---');
+
+await test('JsonLd.expand with null', async () => {
+  const jsonld = new JsonLd();
+  try { await jsonld.expand(null); } catch (e) { assert.ok(e instanceof Error); }
+});
+
+await test('JsonLd.expand with undefined', async () => {
+  const jsonld = new JsonLd();
+  try { await jsonld.expand(undefined); } catch (e) { assert.ok(e instanceof Error); }
+});
+
+await test('JsonLd.compact with null context', async () => {
+  const jsonld = new JsonLd();
+  try { await jsonld.compact({}, null); } catch (e) { assert.ok(e instanceof Error); }
+});
+
+await test('generateJwk with invalid enum value', async () => {
+  try { generateJwk(999); } catch (e) { assert.ok(e instanceof Error); }
+});
+
+// Category 4: JOSE with random inputs
+console.log('\n--- JOSE with random inputs ---');
+
+await test('compactSignJson with random payload', async () => {
+  try {
+    const key = generateJwk(JoseNamedCurve.P256);
+    compactSignJson(JoseSigningAlgorithm.Es256, randomJson(), key);
+  } catch (e) {
+    assert.ok(e instanceof Error);
+  }
+});
+
+await test('compactJsonVerify with random JWS string', async () => {
+  try {
+    const key = generateJwk(JoseNamedCurve.P256);
+    compactJsonVerify('not.a.jws', key);
+  } catch (e) {
+    assert.ok(e instanceof Error);
+  }
+});
+
+await test('decryptJson with random JWE', async () => {
+  try {
+    const key = generateJwk(JoseNamedCurve.X25519);
+    decryptJson(randomJson(), key);
+  } catch (e) {
+    assert.ok(e instanceof Error);
+  }
+});
+
+// Category 5: Concurrent calls
+console.log('\n--- Concurrent operations ---');
+
+await test('50 concurrent JsonLd.expand calls', async () => {
+  const jsonld = new JsonLd();
+  const doc = {"@context": {"name": "http://schema.org/name"}, "name": "test"};
+  const promises = Array.from({length: 50}, () => jsonld.expand(doc).catch(() => null));
+  const results = await Promise.all(promises);
+  // All should succeed or gracefully fail
+  assert.ok(results.length === 50);
+});
+
+await test('50 concurrent JOSE sign operations', async () => {
+  const key = generateJwk(JoseNamedCurve.P256);
+  const payload = {sub: "test", iat: Date.now()};
+  const results = [];
+  for (let i = 0; i < 50; i++) {
+    try {
+      results.push(compactSignJson(JoseSigningAlgorithm.Es256, payload, key));
+    } catch (e) {
+      results.push(null);
+    }
+  }
+  assert.ok(results.length === 50);
+  // All should have succeeded
+  const successes = results.filter(r => r !== null);
+  assert.ok(successes.length === 50, `Expected 50 successes, got ${successes.length}`);
+});
+
+// Summary
+console.log(`\n=== Results: ${passed} passed, ${failed} failed out of ${passed + failed} ===`);
+if (failed > 0) process.exit(1);

package/test_jose.mjs

@@ -0,0 +1,497 @@
+import test from 'node:test';
+import assert from 'node:assert';
+import { randomBytes } from 'node:crypto';
+import {
+    JoseNamedCurve,
+    JoseContentEncryption,
+    JoseKeyEncryption,
+    JoseSigningAlgorithm,
+    generateJwk,
+    generateKeyPair,
+    joseEncrypt,
+    joseDecrypt,
+    generalEncryptJson,
+    decryptJson,
+    compactSignJson,
+    compactJsonVerify,
+    flattenedSignJson,
+    jsonVerify,
+    generalSignJson,
+} from './index.js';
+
+
+// =====================================================================
+// Key Generation — Task 15
+// =====================================================================
+
+test('generateJwk with P-256 returns EC JWK', () => {
+    const jwk = generateJwk(JoseNamedCurve.P256);
+    assert.ok(jwk, 'generateJwk returned a result');
+    assert.equal(jwk.kty, 'EC', 'key type is EC');
+    assert.equal(jwk.crv, 'P-256', 'curve is P-256');
+    assert.ok(jwk.x, 'has x coordinate');
+    assert.ok(jwk.y, 'has y coordinate');
+    assert.ok(jwk.d, 'has private key (d)');
+});
+
+test('generateJwk with P-384 returns EC JWK', () => {
+    const jwk = generateJwk(JoseNamedCurve.P384);
+    assert.equal(jwk.kty, 'EC');
+    assert.equal(jwk.crv, 'P-384');
+    assert.ok(jwk.d, 'has private key');
+});
+
+test('generateJwk with P-521 returns EC JWK', () => {
+    const jwk = generateJwk(JoseNamedCurve.P521);
+    assert.equal(jwk.kty, 'EC');
+    assert.equal(jwk.crv, 'P-521');
+    assert.ok(jwk.x, 'has x coordinate');
+    assert.ok(jwk.y, 'has y coordinate');
+    assert.ok(jwk.d, 'has private key');
+});
+
+test('compactSignJson + compactJsonVerify with ES512 (P-521)', () => {
+    const jwk = generateJwk(JoseNamedCurve.P521);
+    const payload = { alg: 'ES512 test', curve: 'P-521' };
+
+    const jws = compactSignJson(JoseSigningAlgorithm.Es512, payload, jwk);
+    const verified = compactJsonVerify(jws, jwk);
+    assert.deepStrictEqual(verified, payload);
+});
+
+test('generateJwk with Ed25519 returns OKP JWK', () => {
+    const jwk = generateJwk(JoseNamedCurve.Ed25519);
+    assert.equal(jwk.kty, 'OKP', 'key type is OKP');
+    assert.equal(jwk.crv, 'Ed25519', 'curve is Ed25519');
+    assert.ok(jwk.x, 'has public key (x)');
+    assert.ok(jwk.d, 'has private key (d)');
+});
+
+test('generateJwk with X25519 returns OKP JWK', () => {
+    const jwk = generateJwk(JoseNamedCurve.X25519);
+    assert.equal(jwk.kty, 'OKP');
+    assert.equal(jwk.crv, 'X25519');
+    assert.ok(jwk.x, 'has public key');
+    assert.ok(jwk.d, 'has private key');
+});
+
+test('generateKeyPair with P-256 returns full key pair', () => {
+    const kp = generateKeyPair(JoseNamedCurve.P256);
+    assert.ok(kp, 'generateKeyPair returned a result');
+    assert.ok(kp.jwk_key_pair, 'has jwk_key_pair');
+    assert.ok(kp.jwk_private_key, 'has jwk_private_key');
+    assert.ok(kp.jwk_public_key, 'has jwk_public_key');
+    assert.ok(kp.pem_private_key, 'has pem_private_key');
+    assert.ok(kp.pem_public_key, 'has pem_public_key');
+    assert.ok(kp.der_private_key, 'has der_private_key');
+    assert.ok(kp.der_public_key, 'has der_public_key');
+});
+
+test('generateKeyPair with Ed25519 returns full key pair', () => {
+    const kp = generateKeyPair(JoseNamedCurve.Ed25519);
+    assert.ok(kp.jwk_key_pair, 'has jwk_key_pair');
+    assert.ok(kp.jwk_public_key, 'has jwk_public_key');
+    assert.ok(kp.pem_private_key, 'has pem_private_key');
+});
+
+test('generateJwk generates unique keys each time', () => {
+    const jwk1 = generateJwk(JoseNamedCurve.P256);
+    const jwk2 = generateJwk(JoseNamedCurve.P256);
+    assert.notEqual(jwk1.d, jwk2.d, 'private keys should differ');
+    assert.notEqual(jwk1.x, jwk2.x, 'public keys should differ');
+});
+
+test('generateKeyPair public key has no private component', () => {
+    const kp = generateKeyPair(JoseNamedCurve.P256);
+    assert.ok(!kp.jwk_public_key.d, 'public JWK should not have d');
+    assert.ok(kp.jwk_private_key.d, 'private JWK should have d');
+});
+
+
+// =====================================================================
+// Symmetric Encrypt/Decrypt — Task 16
+// =====================================================================
+
+test('joseEncrypt + joseDecrypt round-trip with A256GCM', () => {
+    // A256GCM requires 32-byte key, 12-byte IV
+    const key = randomBytes(32).toString('hex');
+    const iv = randomBytes(12).toString('hex');
+    const plaintext = Buffer.from('Hello, JOSE!').toString('base64');
+
+    const encrypted = joseEncrypt(JoseContentEncryption.A256gcm, key, iv, plaintext);
+    assert.ok(encrypted.ciphertext, 'has ciphertext');
+    assert.ok(encrypted.tag, 'GCM has tag');
+
+    const decrypted = joseDecrypt(
+        JoseContentEncryption.A256gcm, key, iv,
+        encrypted.ciphertext, null, encrypted.tag,
+    );
+    assert.equal(decrypted, plaintext, 'decrypted matches original plaintext');
+});
+
+test('joseEncrypt + joseDecrypt round-trip with A128GCM', () => {
+    const key = randomBytes(16).toString('hex');
+    const iv = randomBytes(12).toString('hex');
+    const plaintext = Buffer.from('test message 128').toString('base64');
+
+    const encrypted = joseEncrypt(JoseContentEncryption.A128gcm, key, iv, plaintext);
+    assert.ok(encrypted.ciphertext);
+    assert.ok(encrypted.tag);
+
+    const decrypted = joseDecrypt(
+        JoseContentEncryption.A128gcm, key, iv,
+        encrypted.ciphertext, null, encrypted.tag,
+    );
+    assert.equal(decrypted, plaintext);
+});
+
+test('joseEncrypt + joseDecrypt with AAD', () => {
+    const key = randomBytes(32).toString('hex');
+    const iv = randomBytes(12).toString('hex');
+    const plaintext = Buffer.from('AAD test').toString('base64');
+    const aad = 'additional-authenticated-data';
+
+    const encrypted = joseEncrypt(JoseContentEncryption.A256gcm, key, iv, plaintext, aad);
+    assert.ok(encrypted.ciphertext);
+
+    const decrypted = joseDecrypt(
+        JoseContentEncryption.A256gcm, key, iv,
+        encrypted.ciphertext, aad, encrypted.tag,
+    );
+    assert.equal(decrypted, plaintext, 'decrypted with AAD matches');
+});
+
+test('joseEncrypt + joseDecrypt with A256CBC-HS512', () => {
+    // A256CBC-HS512 requires 64-byte key, 16-byte IV
+    const key = randomBytes(64).toString('hex');
+    const iv = randomBytes(16).toString('hex');
+    const plaintext = Buffer.from('CBC mode test').toString('base64');
+
+    const encrypted = joseEncrypt(JoseContentEncryption.A256cbcHs512, key, iv, plaintext);
+    assert.ok(encrypted.ciphertext, 'has ciphertext');
+
+    const decrypted = joseDecrypt(
+        JoseContentEncryption.A256cbcHs512, key, iv,
+        encrypted.ciphertext, null, encrypted.tag,
+    );
+    assert.equal(decrypted, plaintext);
+});
+
+test('joseDecrypt with wrong key fails', () => {
+    const key = randomBytes(32).toString('hex');
+    const wrongKey = randomBytes(32).toString('hex');
+    const iv = randomBytes(12).toString('hex');
+    const plaintext = Buffer.from('secret').toString('base64');
+
+    const encrypted = joseEncrypt(JoseContentEncryption.A256gcm, key, iv, plaintext);
+
+    assert.throws(
+        () => joseDecrypt(JoseContentEncryption.A256gcm, wrongKey, iv, encrypted.ciphertext, null, encrypted.tag),
+        /joseDecrypt failed/,
+        'wrong key should fail',
+    );
+});
+
+
+// =====================================================================
+// JWE — Encrypt/Decrypt JSON — Task 17
+// =====================================================================
+
+test('generalEncryptJson + decryptJson round-trip with ECDH-ES+A256KW', () => {
+    const jwk = generateJwk(JoseNamedCurve.P256);
+    // JWK needs a kid for encryption
+    jwk.kid = 'test-key-1';
+
+    const payload = { hello: 'world', number: 42 };
+
+    const jwe = generalEncryptJson(
+        JoseKeyEncryption.EcdhEsA256kw,
+        JoseContentEncryption.A256gcm,
+        payload,
+        [jwk],
+    );
+
+    assert.ok(jwe, 'generalEncryptJson returned a result');
+    assert.ok(jwe.protected, 'JWE has protected header');
+    assert.ok(jwe.recipients, 'JWE has recipients');
+    assert.ok(jwe.iv, 'JWE has IV');
+    assert.ok(jwe.ciphertext, 'JWE has ciphertext');
+    assert.ok(jwe.tag, 'JWE has tag');
+
+    const decrypted = decryptJson(jwe, jwk);
+    assert.deepStrictEqual(decrypted, payload, 'decrypted payload matches original');
+});
+
+test('generalEncryptJson + decryptJson with X25519', () => {
+    const jwk = generateJwk(JoseNamedCurve.X25519);
+    jwk.kid = 'x25519-key';
+
+    const payload = { msg: 'encrypted with X25519' };
+
+    const jwe = generalEncryptJson(
+        JoseKeyEncryption.EcdhEsA256kw,
+        JoseContentEncryption.A256gcm,
+        payload,
+        [jwk],
+    );
+
+    const decrypted = decryptJson(jwe, jwk);
+    assert.deepStrictEqual(decrypted, payload);
+});
+
+test('generalEncryptJson with didcomm flag', () => {
+    const jwk = generateJwk(JoseNamedCurve.P256);
+    jwk.kid = 'didcomm-key';
+
+    const payload = { type: 'didcomm-message' };
+
+    const jwe = generalEncryptJson(
+        JoseKeyEncryption.EcdhEsA256kw,
+        JoseContentEncryption.A256gcm,
+        payload,
+        [jwk],
+        true, // didcomm flag
+    );
+
+    assert.ok(jwe, 'didcomm JWE created');
+    const decrypted = decryptJson(jwe, jwk);
+    assert.deepStrictEqual(decrypted, payload);
+});
+
+test('generalEncryptJson with multiple recipients', () => {
+    const jwk1 = generateJwk(JoseNamedCurve.P256);
+    jwk1.kid = 'recipient-1';
+    const jwk2 = generateJwk(JoseNamedCurve.P256);
+    jwk2.kid = 'recipient-2';
+
+    const payload = { data: 'for multiple recipients' };
+
+    const jwe = generalEncryptJson(
+        JoseKeyEncryption.EcdhEsA256kw,
+        JoseContentEncryption.A256gcm,
+        payload,
+        [jwk1, jwk2],
+    );
+
+    assert.ok(jwe.recipients, 'has recipients');
+    assert.equal(jwe.recipients.length, 2, 'has 2 recipients');
+
+    // Both recipients can decrypt
+    const decrypted1 = decryptJson(jwe, jwk1);
+    assert.deepStrictEqual(decrypted1, payload, 'recipient 1 can decrypt');
+
+    const decrypted2 = decryptJson(jwe, jwk2);
+    assert.deepStrictEqual(decrypted2, payload, 'recipient 2 can decrypt');
+});
+
+
+// =====================================================================
+// JWS Compact — Sign/Verify — Task 18
+// =====================================================================
+
+test('compactSignJson + compactJsonVerify round-trip with ES256', () => {
+    const jwk = generateJwk(JoseNamedCurve.P256);
+    const payload = { sub: '1234567890', name: 'Test User', iat: 1516239022 };
+
+    const jws = compactSignJson(JoseSigningAlgorithm.Es256, payload, jwk);
+
+    assert.ok(typeof jws === 'string', 'compact JWS is a string');
+    assert.equal(jws.split('.').length, 3, 'JWS has 3 parts (header.payload.signature)');
+
+    const verified = compactJsonVerify(jws, jwk);
+    assert.deepStrictEqual(verified, payload, 'verified payload matches original');
+});
+
+test('compactSignJson + compactJsonVerify with EdDSA', () => {
+    const jwk = generateJwk(JoseNamedCurve.Ed25519);
+    const payload = { claim: 'EdDSA signed' };
+
+    const jws = compactSignJson(JoseSigningAlgorithm.Eddsa, payload, jwk);
+    const verified = compactJsonVerify(jws, jwk);
+    assert.deepStrictEqual(verified, payload);
+});
+
+test('compactSignJson + compactJsonVerify with ES384', () => {
+    const jwk = generateJwk(JoseNamedCurve.P384);
+    const payload = { alg: 'ES384 test' };
+
+    const jws = compactSignJson(JoseSigningAlgorithm.Es384, payload, jwk);
+    const verified = compactJsonVerify(jws, jwk);
+    assert.deepStrictEqual(verified, payload);
+});
+
+test('compactSignJson with didcomm flag', () => {
+    const jwk = generateJwk(JoseNamedCurve.Ed25519);
+    const payload = { type: 'didcomm-signed' };
+
+    const jws = compactSignJson(JoseSigningAlgorithm.Eddsa, payload, jwk, true);
+    assert.ok(typeof jws === 'string');
+
+    const verified = compactJsonVerify(jws, jwk);
+    assert.deepStrictEqual(verified, payload);
+});
+
+test('compactJsonVerify with wrong key fails', () => {
+    const jwk1 = generateJwk(JoseNamedCurve.P256);
+    const jwk2 = generateJwk(JoseNamedCurve.P256);
+    const payload = { msg: 'should fail' };
+
+    const jws = compactSignJson(JoseSigningAlgorithm.Es256, payload, jwk1);
+
+    assert.throws(
+        () => compactJsonVerify(jws, jwk2),
+        /compactJsonVerify failed/,
+        'wrong key should fail verification',
+    );
+});
+
+
+// =====================================================================
+// JWS Flattened — Sign/Verify
+// =====================================================================
+
+test('flattenedSignJson + jsonVerify round-trip with ES256', () => {
+    const jwk = generateJwk(JoseNamedCurve.P256);
+    jwk.kid = 'flattened-key-1';
+    const payload = { data: 'flattened sign test' };
+
+    const jws = flattenedSignJson(JoseSigningAlgorithm.Es256, payload, jwk);
+
+    assert.ok(jws, 'flattenedSignJson returned a result');
+    assert.ok(jws.protected, 'has protected header');
+    assert.ok(jws.payload, 'has payload');
+    assert.ok(jws.signature, 'has signature');
+
+    const verified = jsonVerify(jws, jwk);
+    assert.deepStrictEqual(verified, payload, 'verified payload matches original');
+});
+
+test('flattenedSignJson + jsonVerify with EdDSA', () => {
+    const jwk = generateJwk(JoseNamedCurve.Ed25519);
+    jwk.kid = 'ed-flattened';
+    const payload = { curve: 'Ed25519', format: 'flattened' };
+
+    const jws = flattenedSignJson(JoseSigningAlgorithm.Eddsa, payload, jwk);
+    const verified = jsonVerify(jws, jwk);
+    assert.deepStrictEqual(verified, payload);
+});
+
+
+// =====================================================================
+// JWS General — Sign/Verify (multiple signers)
+// =====================================================================
+
+test('generalSignJson + jsonVerify round-trip with single signer', () => {
+    const jwk = generateJwk(JoseNamedCurve.P256);
+    jwk.kid = 'general-signer-1';
+    jwk.alg = 'ES256';
+    const payload = { data: 'general sign test' };
+
+    const jws = generalSignJson(payload, [jwk]);
+
+    assert.ok(jws, 'generalSignJson returned a result');
+    assert.ok(jws.signatures, 'has signatures array');
+    assert.equal(jws.signatures.length, 1, 'has 1 signature');
+    assert.ok(jws.payload, 'has payload');
+
+    const verified = jsonVerify(jws, jwk);
+    assert.deepStrictEqual(verified, payload, 'verified payload matches original');
+});
+
+test('generalSignJson + jsonVerify with multiple signers', () => {
+    const jwk1 = generateJwk(JoseNamedCurve.P256);
+    jwk1.kid = 'multi-signer-1';
+    jwk1.alg = 'ES256';
+    const jwk2 = generateJwk(JoseNamedCurve.P384);
+    jwk2.kid = 'multi-signer-2';
+    jwk2.alg = 'ES384';
+
+    const payload = { data: 'multi-signer test' };
+
+    const jws = generalSignJson(payload, [jwk1, jwk2]);
+    assert.equal(jws.signatures.length, 2, 'has 2 signatures');
+
+    // Each signer can independently verify
+    const verified1 = jsonVerify(jws, jwk1);
+    assert.deepStrictEqual(verified1, payload, 'signer 1 verifies');
+
+    const verified2 = jsonVerify(jws, jwk2);
+    assert.deepStrictEqual(verified2, payload, 'signer 2 verifies');
+});
+
+test('generalSignJson with didcomm flag', () => {
+    const jwk = generateJwk(JoseNamedCurve.Ed25519);
+    jwk.kid = 'didcomm-signer';
+    jwk.alg = 'EdDSA';
+    const payload = { type: 'didcomm-general' };
+
+    const jws = generalSignJson(payload, [jwk], true);
+    assert.ok(jws.signatures);
+
+    const verified = jsonVerify(jws, jwk);
+    assert.deepStrictEqual(verified, payload);
+});
+
+
+// =====================================================================
+// Enum values match ffi-jose
+// =====================================================================
+
+test('JoseNamedCurve enum values', () => {
+    assert.equal(JoseNamedCurve.P256, 0);
+    assert.equal(JoseNamedCurve.P384, 1);
+    assert.equal(JoseNamedCurve.P521, 2);
+    assert.equal(JoseNamedCurve.Secp256k1, 3);
+    assert.equal(JoseNamedCurve.Ed25519, 4);
+    assert.equal(JoseNamedCurve.Ed448, 5);
+    assert.equal(JoseNamedCurve.X25519, 6);
+    assert.equal(JoseNamedCurve.X448, 7);
+});
+
+test('JoseContentEncryption enum values', () => {
+    assert.equal(JoseContentEncryption.A128gcm, 0);
+    assert.equal(JoseContentEncryption.A192gcm, 1);
+    assert.equal(JoseContentEncryption.A256gcm, 2);
+    assert.equal(JoseContentEncryption.A128cbcHs256, 3);
+    assert.equal(JoseContentEncryption.A192cbcHs384, 4);
+    assert.equal(JoseContentEncryption.A256cbcHs512, 5);
+});
+
+test('JoseKeyEncryption enum values', () => {
+    assert.equal(JoseKeyEncryption.Dir, 0);
+    assert.equal(JoseKeyEncryption.EcdhEs, 1);
+    assert.equal(JoseKeyEncryption.EcdhEsA128kw, 2);
+    assert.equal(JoseKeyEncryption.EcdhEsA192kw, 3);
+    assert.equal(JoseKeyEncryption.EcdhEsA256kw, 4);
+    assert.equal(JoseKeyEncryption.Rsa1_5, 5);
+    assert.equal(JoseKeyEncryption.RsaOaep, 6);
+    assert.equal(JoseKeyEncryption.RsaOaep256, 7);
+    assert.equal(JoseKeyEncryption.RsaOaep384, 8);
+    assert.equal(JoseKeyEncryption.RsaOaep512, 9);
+    assert.equal(JoseKeyEncryption.Pbes2Hs256A128kw, 10);
+    assert.equal(JoseKeyEncryption.Pbes2Hs384A192kw, 11);
+    assert.equal(JoseKeyEncryption.Pbes2Hs512A256kw, 12);
+    assert.equal(JoseKeyEncryption.A128kw, 13);
+    assert.equal(JoseKeyEncryption.A192kw, 14);
+    assert.equal(JoseKeyEncryption.A256kw, 15);
+    assert.equal(JoseKeyEncryption.A128gcmkw, 16);
+    assert.equal(JoseKeyEncryption.A192gcmkw, 17);
+    assert.equal(JoseKeyEncryption.A256gcmkw, 18);
+});
+
+test('JoseSigningAlgorithm enum values', () => {
+    assert.equal(JoseSigningAlgorithm.Es256, 0);
+    assert.equal(JoseSigningAlgorithm.Es384, 1);
+    assert.equal(JoseSigningAlgorithm.Es512, 2);
+    assert.equal(JoseSigningAlgorithm.Es256k, 3);
+    assert.equal(JoseSigningAlgorithm.Eddsa, 4);
+    assert.equal(JoseSigningAlgorithm.Hs256, 5);
+    assert.equal(JoseSigningAlgorithm.Hs384, 6);
+    assert.equal(JoseSigningAlgorithm.Hs512, 7);
+    assert.equal(JoseSigningAlgorithm.Rs256, 8);
+    assert.equal(JoseSigningAlgorithm.Rs384, 9);
+    assert.equal(JoseSigningAlgorithm.Rs512, 10);
+    assert.equal(JoseSigningAlgorithm.Ps256, 11);
+    assert.equal(JoseSigningAlgorithm.Ps384, 12);
+    assert.equal(JoseSigningAlgorithm.Ps512, 13);
+});

package/test_jsonld_crossverify.mjs

@@ -21,7 +21,7 @@ const jsonld = require('jsonld');
 const { extendContextLoader } = require('jsonld-signatures');
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const dataDir = resolve(__dirname, '../../../jsonld-signatures-bbs/sample/ts-node/src/data');
+const dataDir = resolve(__dirname, 'test-data');
 const loadJson = (name) => JSON.parse(readFileSync(resolve(dataDir, name), 'utf8'));
 
 const inputDocument = loadJson('inputDocument.json');