cassproject 5.0.20 → 5.0.23

package/src/test/1.EcAssertion.decrypt.test.js

@@ -0,0 +1,98 @@
+require('../../index.js');
+const chai = require('chai');
+const sinon = require('sinon');
+const EcAssertion = require('../org/cass/profile/EcAssertion.js');
+const Assertion = require('../org/cassproject/schema/cass/profile/Assertion.js');
+
+const assert = chai.assert;
+
+const GETTERS = ['getSubject', 'getAgent', 'getAssertionDate', 'getExpirationDate', 'getEvidences', 'getNegative', 'getDecayFunction'];
+const fakePk = (pem) => ({ toPem: () => pem });
+// copyFrom revives these fields as EcEncryptedValues, so give each a recognisable payload.
+const sealed = (payload) => ({ "@type": "EncryptedValue", "@context": "https://schema.cassproject.org/kbac/0.4", payload });
+
+function newAssertion() {
+    const a = new EcAssertion();
+    a.competency = 'https://x/competency';
+    a.level = 'https://x/level';
+    a.confidence = 0.75;
+    a.subject = sealed('subject');
+    a.agent = sealed('agent');
+    a.assertionDate = sealed('date');
+    a.expirationDate = sealed('expiration');
+    a.evidence = [sealed('evidence')];
+    a.negative = sealed('negative');
+    a.decayFunction = sealed('decay');
+    return a;
+}
+
+describe('EcAssertion.decrypt', () => {
+    afterEach(() => sinon.restore());
+
+    it('returns a plain Assertion with the decrypted fields', async () => {
+        const a = newAssertion();
+        sinon.stub(a, 'getSubject').resolves(fakePk('SUBJECT'));
+        sinon.stub(a, 'getAgent').resolves(fakePk('AGENT'));
+        sinon.stub(a, 'getAssertionDate').resolves(123);
+        sinon.stub(a, 'getExpirationDate').resolves(456);
+        sinon.stub(a, 'getEvidences').resolves(['e1', 'e2']);
+        sinon.stub(a, 'getNegative').resolves(true);
+        sinon.stub(a, 'getDecayFunction').resolves('t');
+        const d = await a.decrypt();
+        assert.instanceOf(d, Assertion);
+        assert.notInstanceOf(d, EcAssertion);
+        assert.equal(d.subject, 'SUBJECT');
+        assert.equal(d.agent, 'AGENT');
+        assert.equal(d.assertionDate, 123);
+        assert.equal(d.expirationDate, 456);
+        assert.deepEqual(d.evidence, ['e1', 'e2']);
+        assert.strictEqual(d.negative, true);
+        assert.equal(d.decayFunction, 't');
+        assert.equal(d.competency, 'https://x/competency');
+        assert.equal(d.level, 'https://x/level');
+        assert.equal(d.confidence, 0.75);
+    });
+
+    it('keeps the copied value when a getter resolves to something falsy', async () => {
+        const a = newAssertion();
+        sinon.stub(a, 'getSubject').resolves(null);
+        sinon.stub(a, 'getAgent').resolves(undefined);
+        sinon.stub(a, 'getAssertionDate').resolves(0);
+        sinon.stub(a, 'getExpirationDate').resolves(null);
+        sinon.stub(a, 'getEvidences').resolves(null);
+        sinon.stub(a, 'getNegative').resolves(false);
+        sinon.stub(a, 'getDecayFunction').resolves('');
+        const d = await a.decrypt();
+        assert.equal(d.subject.payload, 'subject');
+        assert.equal(d.agent.payload, 'agent');
+        assert.equal(d.assertionDate.payload, 'date');
+        assert.equal(d.expirationDate.payload, 'expiration');
+        assert.equal(d.evidence[0].payload, 'evidence');
+        assert.equal(d.negative.payload, 'negative');
+        assert.equal(d.decayFunction.payload, 'decay');
+    });
+
+    it('starts every decryption before waiting on any of them', async () => {
+        const a = newAssertion();
+        let release;
+        const gate = new Promise((resolve) => { release = resolve; });
+        const stubs = GETTERS.map((g) => sinon.stub(a, g).returns(gate.then(() => null)));
+        const eim = {};
+        const pending = a.decrypt(eim);
+        for (const s of stubs) {
+            assert.isTrue(s.calledOnce, s.toString());
+            assert.strictEqual(s.firstCall.args[0], eim);
+        }
+        release();
+        await pending;
+    });
+
+    it('rejects when a decryption fails', async () => {
+        const a = newAssertion();
+        for (const g of GETTERS) sinon.stub(a, g).resolves(null);
+        a.getAgent.rejects(new Error('agent failed'));
+        let error;
+        try { await a.decrypt(); } catch (e) { error = e; }
+        assert.equal(error && error.message, 'agent failed');
+    });
+});

package/src/test/1.EcAssertion.pinned.test.js

@@ -0,0 +1,160 @@
+require("../../index.js");
+const { expect } = require("chai");
+const sinon = require("sinon");
+
+describe("EcAssertion setters (pinned behaviour)", () => {
+	afterEach(() => sinon.restore());
+	let pk = (pem) => ({ toPem: () => pem });
+	let mk = () => {
+		let a = new EcAssertion();
+		a.id = "http://x/api/data/a/guid/1";
+		return a;
+	};
+
+	describe("setSubject / setSubjectAsync", () => {
+		for (let async of [false, true]) {
+			let label = async ? "setSubjectAsync" : "setSubject";
+			let run = async (a, p) => {
+				if (!async) return a.setSubject(p);
+				let success = sinon.spy();
+				await a.setSubjectAsync(p, success, "FAIL");
+				expect(success.calledOnceWithExactly()).to.equal(true);
+			};
+			let stubEncrypt = () => async
+				? sinon.stub(EcEncryptedValue, "encryptValueAsync").callsFake((text, id, owners, readers, s, f) => {
+					expect(f).to.equal("FAIL");
+					s({ enc: text, owners, readers });
+				})
+				: sinon.stub(EcEncryptedValue, "encryptValue").callsFake(async (text, id, owners, readers) => ({ enc: text, owners, readers }));
+			it(`${label}: encrypts the pem for owners and a copy of the readers`, async () => {
+				let enc = stubEncrypt();
+				let a = mk();
+				a.owner = ["o1"];
+				a.reader = ["r1"];
+				await run(a, pk("PEM"));
+				expect(a.subject).to.deep.equal({ enc: "PEM", owners: ["o1"], readers: ["r1", "PEM"] });
+				expect(a.reader).to.deep.equal(["r1"]);
+				expect(enc.firstCall.args[1]).to.equal(a.id);
+				expect(enc.firstCall.args[3]).to.not.equal(a.reader);
+			});
+			it(`${label}: merges the previous subject's owners and readers`, async () => {
+				stubEncrypt();
+				let a = mk();
+				a.owner = ["o1"];
+				a.reader = [{ k: "r1" }];
+				a.subject = { owner: ["so"], reader: ["sr"] };
+				await run(a, pk("PEM"));
+				expect(a.subject).to.deep.equal({ enc: "PEM", owners: ["so", "o1"], readers: [{ k: "r1" }, "sr", "PEM"] });
+				expect(a.subject.readers[0]).to.not.equal(a.reader[0]);
+			});
+			it(`${label}: copies a Proxy-wrapped reader array (as reactive UI state would hold)`, async () => {
+				stubEncrypt();
+				let a = mk();
+				a.reader = new Proxy(["r1"], {});
+				await run(a, pk("PEM"));
+				expect(a.subject.readers).to.deep.equal(["r1", "PEM"]);
+				expect(Array.isArray(a.subject.readers)).to.equal(true);
+			});
+			it(`${label}: works without owners or readers`, async () => {
+				stubEncrypt();
+				let a = mk();
+				await run(a, pk("PEM"));
+				expect(a.subject).to.deep.equal({ enc: "PEM", owners: [], readers: ["PEM"] });
+			});
+		}
+	});
+
+	describe("encrypted field setters", () => {
+		let fields = [
+			["setAgent", "agent", pk("APEM"), "APEM"],
+			["setAssertionDate", "assertionDate", 1234, "1234"],
+			["setExpirationDate", "expirationDate", 5678, "5678"],
+			["setDecayFunction", "decayFunction", "t^2", "t^2"],
+			["setNegative", "negative", true, "true"],
+		];
+		for (let [method, field, value, text] of fields) {
+			it(`${method} encrypts with the subject's owners and readers`, async () => {
+				let enc = sinon.stub(EcEncryptedValue, "encryptValue").callsFake(async (t, id, o, r) => ({ t, id, o, r }));
+				let a = mk();
+				a.subject = { owner: ["so"], reader: ["sr"] };
+				let ret = await a[method](value);
+				expect(ret).to.equal(undefined);
+				expect(a[field]).to.deep.equal({ t: text, id: a.id, o: ["so"], r: ["sr"] });
+				expect(enc.calledOnce).to.equal(true);
+			});
+			it(`${method}Async sets the field from the callback and then calls success`, () => {
+				let order = [];
+				sinon.stub(EcEncryptedValue, "encryptValueAsync").callsFake((t, id, o, r, s, f) => {
+					expect(f).to.equal("FAIL");
+					s({ t, id, o, r });
+					return "RET";
+				});
+				let a = mk();
+				a.subject = { owner: ["so"], reader: ["sr"] };
+				let ret = a[method + "Async"](value, () => order.push(JSON.stringify(a[field])), "FAIL");
+				expect(ret).to.equal("RET");
+				expect(order).to.deep.equal([JSON.stringify({ t: text, id: a.id, o: ["so"], r: ["sr"] })]);
+			});
+		}
+		it("setEvidence encrypts each evidence in order", async () => {
+			let calls = [];
+			sinon.stub(EcEncryptedValue, "encryptValue").callsFake(async (t) => {
+				calls.push(t);
+				return "E:" + t;
+			});
+			let a = mk();
+			a.subject = { owner: ["so"], reader: ["sr"] };
+			await a.setEvidence(["e1", "e2", "e3"]);
+			expect(calls).to.deep.equal(["e1", "e2", "e3"]);
+			expect(a.evidence).to.deep.equal(["E:e1", "E:e2", "E:e3"]);
+			await a.setEvidence([]);
+			expect(a.evidence).to.deep.equal([]);
+		});
+		it("setEvidence leaves evidence unchanged if an encryption fails", async () => {
+			sinon.stub(EcEncryptedValue, "encryptValue")
+				.onFirstCall().resolves("ok")
+				.onSecondCall().rejects(new Error("bad"));
+			let a = mk();
+			a.subject = { owner: [], reader: [] };
+			a.evidence = ["old"];
+			let err = null;
+			try {
+				await a.setEvidence(["e1", "e2"]);
+			} catch (e) {
+				err = e;
+			}
+			expect(err.message).to.equal("bad");
+			expect(a.evidence).to.deep.equal(["old"]);
+		});
+	});
+
+	describe("addReader / removeReader", () => {
+		for (let method of ["addReader", "removeReader"]) {
+			it(`${method} updates every encrypted field, each evidence in order, then the object`, async () => {
+				let calls = [];
+				let ev = (name) => ({ [method]: async (r, eim) => calls.push([name, r, eim]) });
+				let a = mk();
+				a.agent = ev("agent");
+				a.assertionDate = ev("assertionDate");
+				a.decayFunction = ev("decayFunction");
+				a.evidence = [ev("e1"), ev("e2")];
+				a.expirationDate = ev("expirationDate");
+				a.negative = ev("negative");
+				a.subject = ev("subject");
+				a.reader = ["x"];
+				let reader = { toPem: () => "R" };
+				await a[method](reader, "EIM");
+				expect(calls.map((c) => c[0])).to.deep.equal(
+					["agent", "assertionDate", "decayFunction", "e1", "e2", "expirationDate", "negative", "subject"]);
+				expect(calls.every((c) => c[1] === reader && c[2] === "EIM")).to.equal(true);
+				expect(a.reader).to.deep.equal(method == "addReader" ? ["x", "R"] : ["x"]);
+			});
+			it(`${method} with no encrypted fields only updates the object`, async () => {
+				let a = mk();
+				a.evidence = [];
+				await a[method]({ toPem: () => "R" });
+				expect(a.reader).to.deep.equal(method == "addReader" ? ["R"] : []);
+			});
+		}
+	});
+});

package/src/test/1.EcCrypto.formats.test.js

@@ -0,0 +1,293 @@
+require('../../index.js');
+const chai = require('chai');
+const sinon = require('sinon');
+const forge = require('node-forge');
+const EcPpk = require('../com/eduworks/ec/crypto/EcPpk.js');
+const EcPk = require('../com/eduworks/ec/crypto/EcPk.js');
+const EcRsaOaepAsync = require('../com/eduworks/ec/crypto/EcRsaOaepAsync.js');
+const EcRsaOaepAsyncWorker = require('../com/eduworks/ec/crypto/EcRsaOaepAsyncWorker.js');
+const EcAesCtrAsync = require('../com/eduworks/ec/crypto/EcAesCtrAsync.js');
+const EcCrypto = require('../com/eduworks/ec/crypto/EcCrypto.js');
+
+const assert = chai.assert;
+const isNode = typeof process !== 'undefined' && process.versions?.node != null && typeof window === 'undefined';
+
+const PEM = "-----BEGIN RSA PRIVATE KEY-----MIIEpAIBAAKCAQEAz4BiFucFE9bNcKfGD+e6aPRHl402YM4Z6nrurDRNlnwsWpsCoZasPLkjC314pVtHAI2duZo+esGKDloBsiLxASRJo3R2XiXVh2Y8U1RcHA5mWL4tMG5UY2d0libpNEHbHPNBmooVYpA2yhxN/vGibIk8x69uZWxJcFOxOg6zWG8EjF8UMgGnRCVSMTY3THhTlfZ0cGUzvrfb7OvHUgdCe285XkmYkj/V9P/m7hbWoOyJAJSTOm4/s6fIKpl72lblfN7bKaxTCsJp6/rQdmUeo+PIaa2lDOfo7dWbuTMcqkZ93kispNfYYhsEGUGlCsrrVWhlve8MenO4GdLsFP+HRwIDAQABAoIBAGaQpOuBIYde44lNxJ7UAdYi+Mg2aqyK81Btl0/TQo6hriLTAAfzPAt/z4y8ZkgFyCDD3zSAw2VWCPFzF+d/UfUohKWgyWlb9iHJLQRbbHQJwhkXV6raviesWXpmnVrROocizkie/FcNxac9OmhL8+cGJt7lHgJP9jTpiW6TGZ8ZzM8KBH2l80x9AWdvCjsICuPIZRjc706HtkKZzTROtq6Z/F4Gm0uWRnwAZrHTRpnh8qjtdBLYFrdDcUoFtzOM6UVRmocTfsNe4ntPpvwY2aGTWY7EmTj1kteMJ+fCQFIS+KjyMWQHsN8yQNfD5/j2uv6/BdSkO8uorGSJT6DwmTECgYEA8ydoQ4i58+A1udqA+fujM0Zn46++NTehFe75nqIt8rfQgoduBam3lE5IWj2U2tLQeWxQyr1ZJkLbITtrAI3PgfMnuFAii+cncwFo805Fss/nbKx8K49vBuCEAq3MRhLjWy3ZvIgUHj67jWvl50dbNqc7TUguxhS4BxGr/cPPkP0CgYEA2nbJPGzSKhHTETL37NWIUAdU9q/6NVRISRRXeRqZYwE1VPzs2sIUxA8zEDBHX7OtvCKzvZy1Lg5Unx1nh4nCEVkbW/8npLlRG2jOcZJF6NRfhzwLz3WMIrP6j9SmjJaB+1mnrTjfsg36tDEPDjjJLjJHCx9z/qRJh1v4bh4aPpMCgYACG31T2IOEEZVlnvcvM3ceoqWT25oSbAEBZ6jSLyWmzOEJwJK7idUFfAg0gAQiQWF9K+snVqzHIB02FIXA43nA7pKRjmA+RiqZXJHEShFgk1y2HGiXGA8mSBvcyhTTJqbBy4vvjl5eRLzrZNwBPSUVPC3PZajCHrvZk9WhxWivIQKBgQCzCu1MH2dy4R7ZlqsIJ8zKweeJMZpfQI7pjclO0FTrhh7+Yzd+5db9A/P2jYrBTVHSwaILgTYf49DIguHJfEZXz26TzB7iapqlWxTukVHISt1ryPNo+E58VoLAhChnSiaHJ+g7GESE+d4A9cAACNwgh0YgQIvhIyW70M1e+j7KDwKBgQDQSBLFDFmvvTP3sIRAr1+0OZWd1eRcwdhs0U9GwootoCoUP/1Y64pqukT6B9oIB/No9Nyn8kUX3/ZDtCslaGKEUGMJXQ4hc5J+lq0tSi9ZWBdhqOuMPEfUF3IxW+9yeILP4ppUBn1m5MVOWg5CvuuEeCmy4bhMaUErUlHZ78t5cA==-----END RSA PRIVATE KEY-----";
+const PK_PEM = "-----BEGIN PUBLIC KEY-----MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAz4BiFucFE9bNcKfGD+e6aPRHl402YM4Z6nrurDRNlnwsWpsCoZasPLkjC314pVtHAI2duZo+esGKDloBsiLxASRJo3R2XiXVh2Y8U1RcHA5mWL4tMG5UY2d0libpNEHbHPNBmooVYpA2yhxN/vGibIk8x69uZWxJcFOxOg6zWG8EjF8UMgGnRCVSMTY3THhTlfZ0cGUzvrfb7OvHUgdCe285XkmYkj/V9P/m7hbWoOyJAJSTOm4/s6fIKpl72lblfN7bKaxTCsJp6/rQdmUeo+PIaa2lDOfo7dWbuTMcqkZ93kispNfYYhsEGUGlCsrrVWhlve8MenO4GdLsFP+HRwIDAQAB-----END PUBLIC KEY-----";
+const PK_PKCS1_PEM = "-----BEGIN RSA PUBLIC KEY-----MIIBCgKCAQEAz4BiFucFE9bNcKfGD+e6aPRHl402YM4Z6nrurDRNlnwsWpsCoZasPLkjC314pVtHAI2duZo+esGKDloBsiLxASRJo3R2XiXVh2Y8U1RcHA5mWL4tMG5UY2d0libpNEHbHPNBmooVYpA2yhxN/vGibIk8x69uZWxJcFOxOg6zWG8EjF8UMgGnRCVSMTY3THhTlfZ0cGUzvrfb7OvHUgdCe285XkmYkj/V9P/m7hbWoOyJAJSTOm4/s6fIKpl72lblfN7bKaxTCsJp6/rQdmUeo+PIaa2lDOfo7dWbuTMcqkZ93kispNfYYhsEGUGlCsrrVWhlve8MenO4GdLsFP+HRwIDAQAB-----END RSA PUBLIC KEY-----";
+const TEXT = "hello ᚠ world";
+const SIG_SHA1 = "d5IBsi6/wwUEfF+3IuYMoac7yOaSm/r8+1YfRqKKk9rxgep9cjO1Y0Pyk1rbOzQIpQ4fO8SIqigdag9pbx5kxClPm452SfQplpzj05kPnFv58YB9ZWA/wb7nSFV7cLqHGfiRqAr/+hvedbVToLBUsc8UVLauq36WZW0M7cbqR74ZUxRPNftc7b/gGlIsiHNb0KA2H+HF4XcoDVRKaGIrJk0w3ThW9swSD9gU04131WRFw/KVGhfUnmUAuuVYt6JiKx2Rj5MZvzKtedksP6ytJPqiDKahBRZBiwCnNplEQXJKxSRucMUzmwyVPSHxQhihl0MQZZU4otVcE8EJFASEEw==";
+const SIG_SHA256 = "xZZkzhAqea1SuQFWR9KoDGo2sMY17wb40azbWbnF1iEnf3RNb3wQgKnsMWfNCuaEuc6wLC8dvhFFFrgOPB70/xDgnNjBsXREFCQ+sZyeJvMA4sg4m5reu9bm6XpPaVzL/S7liHlseb6U15Tr+TbucajZieMdwNNhQjUR0R5+WxJBkhUoAtMao2HNnMbAQ3A7ILJHWp1HkaJpabp7zTlHERMB/6ymqMQFGpzSZnZpdl5NxDi/qWf7v6G+TsTGv26NTb0/jfGkCUcy7jvjR79qXP1G0zVB4K7cnxrEHiilkfmPMPC7bxdW6s1eA/gwrV4+4qPqtLJW5de60gpOCJJ3gQ==";
+const AES_SECRET = "AAECAwQFBgcICQoLDA0ODw==";
+const AES_IV = "EBESExQVFhcYGRobHB0eHw==";
+
+const sha256 = (s) => forge.md.sha256.create().update(typeof s === 'string' ? s : JSON.stringify(s), 'utf8').digest().toHex();
+
+describe('EcPk and EcPpk encodings', () => {
+    it('EcPpk PEM and JWK encodings are unchanged', () => {
+        const ppk = EcPpk.fromPem(PEM);
+        delete ppk.defaultPem;
+        delete ppk.jwk;
+        assert.equal(sha256(ppk.toPem()), 'f08b141ee4e918684781eca1aa13cf16a3631674d56d8f65b70e9ba8bbbd8b3a');
+        assert.equal(ppk.toPem(), PEM);
+        assert.equal(sha256(ppk.toPkcs1Pem()), 'f08b141ee4e918684781eca1aa13cf16a3631674d56d8f65b70e9ba8bbbd8b3a');
+        assert.equal(sha256(ppk.toPkcs8Pem()), 'aedcee9d0922723128ede50a0390df163b04fc71e87884d7609ac10d5f2f1b3d');
+        assert.notMatch(ppk.toPkcs8Pem(), /[\r\n]/);
+        assert.match(ppk.toPkcs8Pem(), /^-----BEGIN PRIVATE KEY-----[A-Za-z0-9+/=]+-----END PRIVATE KEY-----$/);
+        assert.equal(sha256(ppk.toJwk()), '4b912898e05a4c2001d5cca115590491efd85b8a19de8f18be486d46642fec69');
+        for (const v of Object.values(ppk.toJwk()))
+            assert.notMatch(v, /[+/=]/);
+    });
+    it('EcPk PEM and JWK encodings are unchanged', () => {
+        const pk = EcPpk.fromPem(PEM).toPk();
+        delete pk.defaultPem;
+        delete pk.jwk;
+        assert.equal(pk.toPem(), PK_PEM);
+        assert.equal(sha256(pk.toPem()), '9b54f7aa5d9949eb22252c69f0894dfe280d2cf999f60b30a4d9fa90f45c23d4');
+        assert.equal(pk.toPkcs1Pem(), PK_PKCS1_PEM);
+        assert.equal(sha256(pk.toPkcs1Pem()), '0076d5976edd7de19feb6c0e1d49a8845a66afb35916aeeb5d765601e145f15f');
+        assert.equal(pk.toPkcs8Pem(), PK_PEM);
+        assert.equal(sha256(pk.toJwk()), 'd8899e312b58f4b3284a4bde1a8c31af0d025fb04e6401dbf55cd34f4ff71b51');
+        assert.deepEqual(Object.keys(pk.toJwk()), ['kty', 'n', 'e']);
+        assert.equal(pk.toJwk().e, 'AQAB');
+    });
+});
+
+describe('EcRsaOaepAsync signatures', () => {
+    it('sign (sha1) gives the same signature with and without a cached key', async () => {
+        const ppk = EcPpk.fromPem(PEM);
+        delete ppk.signKey;
+        assert.equal(await EcRsaOaepAsync.sign(ppk, TEXT), SIG_SHA1);
+        assert.equal(await EcRsaOaepAsync.sign(ppk, TEXT), SIG_SHA1);
+    });
+    it('sign (sha1) passes the signature to the success callback', async () => {
+        const ppk = EcPpk.fromPem(PEM);
+        delete ppk.signKey;
+        let seen = null;
+        const r = await EcRsaOaepAsync.sign(ppk, TEXT, (s) => { seen = s; return 'cb'; }, null);
+        assert.equal(seen, SIG_SHA1);
+        assert.equal(r, 'cb');
+    });
+    it('signSha256 gives the same signature with and without a cached key', async () => {
+        const ppk = EcPpk.fromPem(PEM);
+        delete ppk.signKey256;
+        assert.equal(await EcRsaOaepAsync.signSha256(ppk, TEXT), SIG_SHA256);
+        assert.equal(await EcRsaOaepAsync.signSha256(ppk, TEXT), SIG_SHA256);
+    });
+    it('verify (sha1) with and without a cached key', async () => {
+        const pk = EcPk.fromPem(PK_PEM);
+        delete pk.signKey;
+        assert.strictEqual(await EcRsaOaepAsync.verify(pk, TEXT, SIG_SHA1), true);
+        assert.isDefined(pk.signKey);
+        assert.strictEqual(await EcRsaOaepAsync.verify(pk, TEXT, SIG_SHA1), true);
+        assert.strictEqual(await EcRsaOaepAsync.verify(pk, TEXT + "x", SIG_SHA1), false);
+        delete pk.signKey;
+        assert.strictEqual(await EcRsaOaepAsync.verify(pk, TEXT + "x", SIG_SHA1), false);
+    });
+    it('verifySha256 with and without a cached key', async () => {
+        const pk = EcPk.fromPem(PK_PEM);
+        delete pk.signKey256;
+        assert.strictEqual(await EcRsaOaepAsync.verifySha256(pk, TEXT, SIG_SHA256), true);
+        assert.isDefined(pk.signKey256);
+        assert.strictEqual(await EcRsaOaepAsync.verifySha256(pk, TEXT, SIG_SHA256), true);
+        assert.strictEqual(await EcRsaOaepAsync.verifySha256(pk, TEXT, SIG_SHA1), false);
+        delete pk.signKey256;
+        assert.strictEqual(await EcRsaOaepAsync.verifySha256(pk, TEXT, SIG_SHA1), false);
+    });
+    it('verify rejects when the key cannot be imported', async () => {
+        const pk = EcPk.fromPem(PK_PEM);
+        const saved = pk.signKey;
+        delete pk.signKey;
+        const jwk = sinon.stub(pk, 'toJwk').returns({ kty: 'RSA' });
+        try {
+            let failed = false;
+            await EcRsaOaepAsync.verify(pk, TEXT, SIG_SHA1).catch(() => { failed = true; });
+            assert.isTrue(failed);
+        } finally {
+            jwk.restore();
+            pk.signKey = saved;
+        }
+    });
+});
+
+describe('EcAesCtrAsync', () => {
+    let caching;
+    beforeEach(() => { caching = EcCrypto.caching; });
+    afterEach(() => { EcCrypto.caching = caching; });
+
+    it('encrypts to the pinned ciphertext', async () => {
+        assert.equal(await EcAesCtrAsync.encrypt("plain ascii text", AES_SECRET, AES_IV), "d5KOHY/1Yh3zZ4cx+vHq5w==");
+        assert.equal(await EcAesCtrAsync.encrypt(TEXT, AES_SECRET, AES_IV), "b5uDGI714vQwLpl+/Pj2");
+    });
+    it('encrypt passes the ciphertext to the success callback', async () => {
+        let seen = null;
+        await EcAesCtrAsync.encrypt(TEXT, AES_SECRET, AES_IV, (c) => { seen = c; }, null);
+        assert.equal(seen, "b5uDGI714vQwLpl+/Pj2");
+    });
+    it('decrypts without caching', async () => {
+        EcCrypto.caching = false;
+        delete EcCrypto.decryptionCache[AES_SECRET + AES_IV + "b5uDGI714vQwLpl+/Pj2"];
+        assert.equal(await EcAesCtrAsync.decrypt("b5uDGI714vQwLpl+/Pj2", AES_SECRET, AES_IV), TEXT);
+        assert.isUndefined(EcCrypto.decryptionCache[AES_SECRET + AES_IV + "b5uDGI714vQwLpl+/Pj2"]);
+    });
+    it('decrypts with caching and fills the cache', async () => {
+        EcCrypto.caching = true;
+        const key = AES_SECRET + AES_IV + "b5uDGI714vQwLpl+/Pj2";
+        delete EcCrypto.decryptionCache[key];
+        assert.equal(await EcAesCtrAsync.decrypt("b5uDGI714vQwLpl+/Pj2", AES_SECRET, AES_IV), TEXT);
+        assert.equal(EcCrypto.decryptionCache[key], TEXT);
+        delete EcCrypto.decryptionCache[key];
+    });
+    it('decrypt rejects on a bad key', async () => {
+        EcCrypto.caching = false;
+        let failed = null;
+        await EcAesCtrAsync.decrypt("b5uDGI714vQwLpl+/Pj2", "AAEC", AES_IV, null, (e) => { failed = e; });
+        assert.isNotNull(failed);
+    });
+});
+
+(isNode ? describe : describe.skip)('EcAesCtrAsync FIPS toggling errors', () => {
+    const realCrypto = isNode ? require('crypto') : null;
+    const modulePath = isNode ? require.resolve('../com/eduworks/ec/crypto/EcAesCtrAsync.js') : null;
+    let fips;
+    function freshModule() {
+        // The module keeps fipsForced / inWorker flags; load a private copy so they don't leak.
+        const saved = require.cache[modulePath];
+        delete require.cache[modulePath];
+        try {
+            return require(modulePath);
+        } finally {
+            require.cache[modulePath] = saved;
+        }
+    }
+    beforeEach(() => {
+        fips = process.env.FIPS;
+        process.env.FIPS = "1";
+    });
+    afterEach(() => {
+        if (fips === undefined) delete process.env.FIPS;
+        else process.env.FIPS = fips;
+        sinon.restore();
+    });
+
+    for (const [method, current] of [['fipsOn', 0], ['fipsOff', 1]]) {
+        it(method + ': ERR_CRYPTO_FIPS_FORCED stops further toggling', () => {
+            const M = freshModule();
+            sinon.stub(realCrypto, 'getFips').returns(current);
+            const set = sinon.stub(realCrypto, 'setFips').throws(new Error("boom ERR_CRYPTO_FIPS_FORCED"));
+            const report = sinon.stub(global.auditLogger, 'report');
+            M[method]();
+            assert.equal(set.callCount, 1);
+            assert.deepEqual(set.firstCall.args, [current == 0]);
+            M.fipsOn();
+            M.fipsOff();
+            assert.equal(set.callCount, 1);
+            assert.equal(realCrypto.getFips.callCount, 1);
+            assert.equal(report.callCount, 0);
+        });
+        it(method + ': ERR_WORKER_UNSUPPORTED_OPERATION stops further toggling', () => {
+            const M = freshModule();
+            sinon.stub(realCrypto, 'getFips').returns(current);
+            const set = sinon.stub(realCrypto, 'setFips').throws(new Error("ERR_WORKER_UNSUPPORTED_OPERATION here"));
+            const report = sinon.stub(global.auditLogger, 'report');
+            M[method]();
+            M[method]();
+            M.fipsOn();
+            assert.equal(set.callCount, 1);
+            assert.equal(report.callCount, 0);
+        });
+        it(method + ': other errors are reported and toggling continues', () => {
+            const M = freshModule();
+            sinon.stub(realCrypto, 'getFips').returns(current);
+            const err = new Error("something else");
+            const set = sinon.stub(realCrypto, 'setFips').throws(err);
+            const report = sinon.stub(global.auditLogger, 'report');
+            M[method]();
+            M[method]();
+            assert.equal(set.callCount, 2);
+            assert.equal(report.callCount, 2);
+            assert.deepEqual(report.firstCall.args.slice(2), ["EcAesCtrAsyncFips", "ERR_CRYPTO_FIPS", err]);
+        });
+        it(method + ': does nothing when FIPS is already in the wanted state', () => {
+            const M = freshModule();
+            sinon.stub(realCrypto, 'getFips').returns(1 - current);
+            const set = sinon.stub(realCrypto, 'setFips');
+            M[method]();
+            assert.equal(set.callCount, 0);
+        });
+    }
+    it('does nothing when FIPS is not requested', () => {
+        delete process.env.FIPS;
+        const M = freshModule();
+        const get = sinon.stub(realCrypto, 'getFips').returns(0);
+        const set = sinon.stub(realCrypto, 'setFips');
+        M.fipsOn();
+        M.fipsOff();
+        assert.equal(get.callCount, 0);
+        assert.equal(set.callCount, 0);
+    });
+});
+
+(isNode ? describe : describe.skip)('EcRsaOaepAsyncWorker.createWorker', () => {
+    const path = isNode ? require('path') : null;
+    const url = isNode ? require('url') : null;
+    let savedWorker, savedW;
+    beforeEach(() => {
+        savedWorker = global.Worker;
+        savedW = EcRsaOaepAsyncWorker.w;
+    });
+    afterEach(() => {
+        global.Worker = savedWorker;
+        EcRsaOaepAsyncWorker.w = savedW;
+        sinon.restore();
+    });
+
+    it('falls back through the worker scripts and replaces a worker that errors', () => {
+        const created = [];
+        global.Worker = class FakeWorker {
+            constructor(arg) {
+                created.push(arg);
+                if (created.length <= 2) throw new Error("no worker " + created.length);
+                this.arg = arg;
+            }
+            addEventListener() { }
+        };
+        const report = sinon.stub(global.auditLogger, 'report');
+        EcRsaOaepAsyncWorker.w = [];
+        EcRsaOaepAsyncWorker.createWorker(3);
+        const dir = path.dirname(require.resolve('../com/eduworks/ec/crypto/EcRsaOaepAsyncWorker.js'));
+        assert.equal(created.length, 3);
+        assert.equal(created[0].href, url.pathToFileURL(path.resolve(dir, 'forgeAsyncNode.js')).href);
+        assert.equal(created[1].href, url.pathToFileURL(path.resolve(dir, 'forgeAsync.js')).href);
+        assert.equal(created[2], path.resolve(dir, 'forgeAsync.js'));
+        assert.equal(report.callCount, 2);
+        const first = EcRsaOaepAsyncWorker.w[3];
+        assert.equal(first._worker.arg, created[2]);
+
+        first._worker.onerror({ type: 'error' });
+        assert.equal(created.length, 4);
+        assert.equal(created[3], path.resolve(dir, 'cass-editor/forgeAsync.js'));
+        assert.notStrictEqual(EcRsaOaepAsyncWorker.w[3], first);
+        assert.equal(EcRsaOaepAsyncWorker.w[3]._worker.arg, created[3]);
+        assert.equal(report.callCount, 3);
+    });
+});
+
+(isNode ? describe : describe.skip)('forgeAsyncNode worker messages', () => {
+    after(() => EcRsaOaepAsyncWorker.teardown());
+    it('answers unknown commands and reports command errors', async () => {
+        EcRsaOaepAsyncWorker.initWorker();
+        const w = EcRsaOaepAsyncWorker.w[0];
+        assert.equal(await w.postMessage({ cmd: 'nope', origin: 'cassproject' }), 'Unknown command: undefined');
+        const r = await w.postMessage({ cmd: 'signRsaOaep', ppk: 'not a pem', text: 'x', origin: 'cassproject' });
+        assert.property(r, 'error');
+        assert.equal(await w.postMessage({ cmd: 'signRsaOaep', ppk: PEM, text: TEXT, origin: 'cassproject' }), SIG_SHA1);
+    });
+    it('passes a rejected promise back as an error', async () => {
+        EcRsaOaepAsyncWorker.initWorker();
+        const w = EcRsaOaepAsyncWorker.w[1];
+        let failed = null;
+        await w.postMessage({ cmd: 'decryptAesCtr', text: 'b5uDGI714vQwLpl+/Pj2', secret: 'AAEC', iv: AES_IV, origin: 'cassproject' }).catch((e) => { failed = e; });
+        assert.instanceOf(failed, Error);
+    });
+});

package/src/test/1.EcCrypto.generateUUID.test.js

@@ -0,0 +1,47 @@
+require('../../index.js');
+const chai = require('chai');
+const sinon = require('sinon');
+const realCrypto = require('crypto');
+const EcCrypto = require('../com/eduworks/ec/crypto/EcCrypto.js');
+
+const assert = chai.assert;
+
+const UUID = /^[0-9a-f]{8}-c455-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+
+// Fixes the clock and the random source (whichever one the implementation uses) to
+// the nibble k, so the output is deterministic.
+function withFixedEntropy(k, fn) {
+    const clock = sinon.useFakeTimers({ now: 1700000000000 });
+    const stubs = [sinon.stub(Math, 'random').returns(k / 16)];
+    const fill = (array) => { array.fill(k); return array; };
+    stubs.push(sinon.stub(globalThis.crypto, 'getRandomValues').callsFake(fill));
+    // Bundled for the browser, the crypto module has no webcrypto.
+    if (realCrypto.webcrypto && realCrypto.webcrypto !== globalThis.crypto)
+        stubs.push(sinon.stub(realCrypto.webcrypto, 'getRandomValues').callsFake(fill));
+    try {
+        return fn();
+    } finally {
+        stubs.forEach((s) => s.restore());
+        clock.restore();
+    }
+}
+
+for (const [name, generate] of [['EcCrypto.generateUUID', () => EcCrypto.generateUUID()], ['global.generateUUID', () => global.generateUUID()]]) {
+    describe(name, () => {
+        it('has the c455 version-4 layout', () => {
+            for (let i = 0; i < 200; i++)
+                assert.match(generate(), UUID);
+        });
+        it('does not repeat', () => {
+            const seen = new Set();
+            for (let i = 0; i < 2000; i++)
+                seen.add(generate());
+            assert.equal(seen.size, 2000);
+        });
+        it('mixes the timestamp into the leading digits', () => {
+            assert.equal(withFixedEntropy(0, generate), '00865efc-c455-4b81-8000-000000000000');
+            assert.equal(withFixedEntropy(9, generate), '991fe785-c455-441a-9999-999999999999');
+            assert.equal(withFixedEntropy(15, generate), 'ff754deb-c455-4a70-bfff-ffffffffffff');
+        });
+    });
+}