@pryv/encryption 3.10.0

package/test/aes-text-base64.test.js

@@ -0,0 +1,106 @@
+/**
+ * @license
+ * [BSD-3-Clause](https://github.com/pryv/lib-js/blob/master/LICENSE)
+ */
+/* global describe, it, expect */
+
+const aesText = require('../src/methods/aes-text-base64');
+const { EventsCipher, Keyring } = require('../src');
+const { base64ToBytes, bytesToBase64 } = require('../src/lib/base64');
+const fixture = require('./fixtures/aes-text-base64.json');
+
+describe('[ENCL] aes-text-base64 (legacy, decrypt-only)', function () {
+  describe('[ENCLV] known-answer vectors', function () {
+    fixture.vectors.forEach(function (vec, i) {
+      it(`[ENCLV${i}] vector ${i} decrypts to the exact material object`, async function () {
+        const material = await aesText.decrypt({ payload: vec.payload }, vec.passphrase);
+        expect(material).to.deep.equal(vec.plaintextObject);
+      });
+    });
+  });
+
+  describe('[ENCLN] negative cases (must reject)', function () {
+    const vec = fixture.vectors[0];
+
+    it('[ENCLNA] wrong passphrase throws', async function () {
+      let threw = false;
+      try {
+        await aesText.decrypt({ payload: vec.payload }, 'not the passphrase');
+      } catch (e) { threw = true; }
+      expect(threw).to.equal(true);
+    });
+
+    it('[ENCLNB] missing Salted__ prefix throws', async function () {
+      // Re-base64 the payload bytes with the 8-byte "Salted__" magic stripped.
+      const bytes = base64ToBytes(vec.payload);
+      const noMagic = bytes.slice(8);
+      let threw = false;
+      try {
+        await aesText.decrypt({ payload: bytesToBase64(noMagic) }, vec.passphrase);
+      } catch (e) { threw = true; }
+      expect(threw).to.equal(true);
+    });
+
+    it('[ENCLNC] truncated payload throws', async function () {
+      const truncated = vec.payload.slice(0, 24);
+      let threw = false;
+      try {
+        await aesText.decrypt({ payload: truncated }, vec.passphrase);
+      } catch (e) { threw = true; }
+      expect(threw).to.equal(true);
+    });
+
+    it('[ENCLND] missing payload throws', async function () {
+      let threw = false;
+      try {
+        await aesText.decrypt({}, vec.passphrase);
+      } catch (e) { threw = true; }
+      expect(threw).to.equal(true);
+    });
+  });
+
+  describe('[ENCLC] via EventsCipher', function () {
+    const vec = fixture.vectors[0];
+    const KEY_REF = 'legacy-passphrase';
+
+    it('[ENCLCA] decrypts an encrypted/aes-text-base64 event with the passphrase in the keyring', async function () {
+      const keyring = new Keyring({ [KEY_REF]: vec.passphrase });
+      const cipher = new EventsCipher(keyring);
+      const event = {
+        id: 'legacy-1',
+        streamIds: ['journal'],
+        type: 'encrypted/aes-text-base64',
+        content: { payload: vec.payload, keyRef: KEY_REF }
+      };
+      const dec = await cipher.decryptEvent(event);
+      expect(dec.type).to.equal(vec.plaintextObject.type);
+      expect(dec.content).to.deep.equal(vec.plaintextObject.content);
+      expect(dec.decryptedFrom).to.equal(event);
+    });
+
+    it('[ENCLCB] encryptEvent throws — the method is decrypt-only', async function () {
+      const keyring = new Keyring({ [KEY_REF]: vec.passphrase });
+      const cipher = new EventsCipher(keyring);
+      await expect(cipher.encryptEvent(
+        { type: 'note/txt', content: 'x' },
+        { method: 'aes-text-base64', keyRef: KEY_REF }
+      )).to.be.rejected;
+    });
+
+    it('[ENCLCC] encryptEventContent throws — the method is decrypt-only', async function () {
+      const keyring = new Keyring({ [KEY_REF]: vec.passphrase });
+      const cipher = new EventsCipher(keyring);
+      await expect(cipher.encryptEventContent(
+        { type: 'note/txt', content: 'x' },
+        { method: 'aes-text-base64', keyRef: KEY_REF }
+      )).to.be.rejected;
+    });
+  });
+
+  describe('[ENCLM] module shape', function () {
+    it('[ENCLMA] exposes decrypt but no encrypt (decrypt-only)', function () {
+      expect(aesText.decrypt).to.be.a('function');
+      expect(aesText.encrypt).to.equal(undefined);
+    });
+  });
+});

package/test/attachments.test.js

@@ -0,0 +1,244 @@
+/**
+ * @license
+ * [BSD-3-Clause](https://github.com/pryv/lib-js/blob/master/LICENSE)
+ */
+/* global describe, it, before, expect */
+
+const aes = require('../src/methods/aes-256-gcm');
+const ecies = require('../src/methods/ecies-aes-256-gcm');
+const { EventsCipher, Keyring } = require('../src');
+const { base64ToBytes } = require('../src/lib/base64');
+const aesVector = require('./fixtures/aes-256-gcm.json');
+const eciesFixture = require('./fixtures/ecies-aes-256-gcm.json');
+
+/**
+ * Fill a Uint8Array of the requested length with random bytes, chunked to stay
+ * within the 65 536-byte-per-call quota of `crypto.getRandomValues`.
+ */
+function randomBytes (n) {
+  const bytes = new Uint8Array(n);
+  for (let offset = 0; offset < n; offset += 65536) {
+    globalThis.crypto.getRandomValues(bytes.subarray(offset, Math.min(offset + 65536, n)));
+  }
+  return bytes;
+}
+
+/** Deep-equal comparison of two byte arrays (as plain arrays for a clear diff). */
+function sameBytes (a, b) {
+  expect(Array.from(a)).to.deep.equal(Array.from(b));
+}
+
+async function expectThrows (promiseFactory) {
+  let threw = false;
+  try { await promiseFactory(); } catch (e) { threw = true; }
+  expect(threw).to.equal(true);
+}
+
+const AES_KEY = aesVector.keyBase64;
+const BIG = 100 * 1024; // ~100 KB
+
+describe('[ENCF] encrypted attachments (raw-byte primitives)', function () {
+  this.timeout(20000);
+
+  // A pair holding BOTH sides of the fixed ecies recipient so a single keyRef
+  // resolves for encrypt (public) and decrypt (private).
+  const eciesPair = { publicKey: eciesFixture.recipient.publicKey, privateKey: eciesFixture.recipient.privateKey };
+
+  describe('[ENCFB] aes-256-gcm byte primitives', function () {
+    it('[ENCFBA] round-trips random bytes', async function () {
+      const bytes = randomBytes(1234);
+      const enc = await aes.encryptBytes(bytes, AES_KEY);
+      expect(enc).to.be.an.instanceOf(Uint8Array);
+      const back = await aes.decryptBytes(enc, AES_KEY);
+      sameBytes(back, bytes);
+    });
+
+    it('[ENCFBB] round-trips empty bytes', async function () {
+      const bytes = new Uint8Array(0);
+      const enc = await aes.encryptBytes(bytes, AES_KEY);
+      const back = await aes.decryptBytes(enc, AES_KEY);
+      sameBytes(back, bytes);
+    });
+
+    it('[ENCFBC] round-trips ~100 KB', async function () {
+      const bytes = randomBytes(BIG);
+      const enc = await aes.encryptBytes(bytes, AES_KEY);
+      const back = await aes.decryptBytes(enc, AES_KEY);
+      sameBytes(back, bytes);
+    });
+
+    it('[ENCFBD] does not mutate the input bytes', async function () {
+      const bytes = randomBytes(64);
+      const copy = bytes.slice();
+      await aes.encryptBytes(bytes, AES_KEY);
+      sameBytes(bytes, copy);
+    });
+
+    it('[ENCFBE] tampered ciphertext rejects', async function () {
+      const enc = await aes.encryptBytes(randomBytes(64), AES_KEY);
+      enc[enc.length - 1] ^= 0xff;
+      await expectThrows(() => aes.decryptBytes(enc, AES_KEY));
+    });
+
+    it('[ENCFBF] truncated bytes reject', async function () {
+      const enc = await aes.encryptBytes(randomBytes(64), AES_KEY);
+      await expectThrows(() => aes.decryptBytes(enc.slice(0, 8), AES_KEY));
+    });
+
+    it('[ENCFBG] wrong key rejects', async function () {
+      const enc = await aes.encryptBytes(randomBytes(64), AES_KEY);
+      const wrong = new Uint8Array(32).fill(9);
+      await expectThrows(() => aes.decryptBytes(enc, wrong));
+    });
+  });
+
+  describe('[ENCFE] ecies-aes-256-gcm byte primitives', function () {
+    const pub = eciesFixture.recipient.publicKey;
+    const priv = eciesFixture.recipient.privateKey;
+
+    it('[ENCFEA] round-trips random bytes', async function () {
+      const bytes = randomBytes(2048);
+      const enc = await ecies.encryptBytes(bytes, pub);
+      expect(enc).to.be.an.instanceOf(Uint8Array);
+      const back = await ecies.decryptBytes(enc, priv);
+      sameBytes(back, bytes);
+    });
+
+    it('[ENCFEB] round-trips empty bytes', async function () {
+      const bytes = new Uint8Array(0);
+      const enc = await ecies.encryptBytes(bytes, pub);
+      const back = await ecies.decryptBytes(enc, priv);
+      sameBytes(back, bytes);
+    });
+
+    it('[ENCFEC] round-trips ~100 KB', async function () {
+      const bytes = randomBytes(BIG);
+      const enc = await ecies.encryptBytes(bytes, pub);
+      const back = await ecies.decryptBytes(enc, priv);
+      sameBytes(back, bytes);
+    });
+
+    it('[ENCFED] tampered / truncated / wrong-key reject', async function () {
+      const enc = await ecies.encryptBytes(randomBytes(64), pub);
+      const tampered = enc.slice();
+      tampered[tampered.length - 1] ^= 0xff;
+      await expectThrows(() => ecies.decryptBytes(tampered, priv));
+      await expectThrows(() => ecies.decryptBytes(enc.slice(0, 10), priv));
+      const other = await ecies.generateKeyPair();
+      await expectThrows(() => ecies.decryptBytes(enc, other.privateKey));
+    });
+  });
+
+  describe('[ENCFC] cross-consistency: payload === base64(encryptBytes)', function () {
+    it('[ENCFCA] aes: decryptBytes(base64ToBytes(payload)) yields the UTF-8 JSON bytes', async function () {
+      const material = { type: 'note/txt', content: 'cross check' };
+      const content = await aes.encrypt(material, AES_KEY);
+      const plainBytes = await aes.decryptBytes(base64ToBytes(content.payload), AES_KEY);
+      const expected = new TextEncoder().encode(JSON.stringify(material));
+      sameBytes(plainBytes, expected);
+    });
+
+    it('[ENCFCB] ecies: decryptBytes(base64ToBytes(payload)) yields the UTF-8 JSON bytes', async function () {
+      const material = { type: 'note/txt', content: 'cross check' };
+      const content = await ecies.encrypt(material, eciesFixture.recipient.publicKey);
+      const plainBytes = await ecies.decryptBytes(base64ToBytes(content.payload), eciesFixture.recipient.privateKey);
+      const expected = new TextEncoder().encode(JSON.stringify(material));
+      sameBytes(plainBytes, expected);
+    });
+  });
+
+  describe('[ENCFH] EventsCipher attachment helpers', function () {
+    const AES_REF = 'att-key';
+    const ECIES_REF = 'att-recipient';
+    let aesCipher;
+    let eciesCipher;
+
+    before(function () {
+      aesCipher = new EventsCipher(new Keyring({ [AES_REF]: AES_KEY }));
+      eciesCipher = new EventsCipher(new Keyring({ [ECIES_REF]: eciesPair }));
+    });
+
+    it('[ENCFHA] aes: encryptAttachmentData -> decryptAttachmentData round-trips', async function () {
+      const bytes = randomBytes(4096);
+      const enc = await aesCipher.encryptAttachmentData(bytes, { method: 'aes-256-gcm', keyRef: AES_REF });
+      expect(enc).to.be.an.instanceOf(Uint8Array);
+      const event = await aesCipher.encryptEvent({ type: 'note/txt', content: 'x' }, { method: 'aes-256-gcm', keyRef: AES_REF });
+      const back = await aesCipher.decryptAttachmentData(event, enc);
+      sameBytes(back, bytes);
+    });
+
+    it('[ENCFHB] ecies: encryptAttachmentData -> decryptAttachmentData round-trips', async function () {
+      const bytes = randomBytes(4096);
+      const enc = await eciesCipher.encryptAttachmentData(bytes, { method: 'ecies-aes-256-gcm', keyRef: ECIES_REF });
+      const event = await eciesCipher.encryptEvent({ type: 'note/txt', content: 'x' }, { method: 'ecies-aes-256-gcm', keyRef: ECIES_REF });
+      const back = await eciesCipher.decryptAttachmentData(event, enc);
+      sameBytes(back, bytes);
+    });
+
+    it('[ENCFHC] decryptAttachmentData accepts an already-decrypted event (unwrap path)', async function () {
+      const bytes = randomBytes(512);
+      const enc = await aesCipher.encryptAttachmentData(bytes, { method: 'aes-256-gcm', keyRef: AES_REF });
+      const event = await aesCipher.encryptEvent({ type: 'note/txt', content: 'x' }, { method: 'aes-256-gcm', keyRef: AES_REF });
+      const decryptedEvent = await aesCipher.decryptEvent(event);
+      expect(decryptedEvent.decryptedFrom).to.equal(event); // sanity: it is the unwrapped form
+      const back = await aesCipher.decryptAttachmentData(decryptedEvent, enc);
+      sameBytes(back, bytes);
+    });
+
+    it('[ENCFHD] does not mutate the input bytes', async function () {
+      const bytes = randomBytes(64);
+      const copy = bytes.slice();
+      await aesCipher.encryptAttachmentData(bytes, { method: 'aes-256-gcm', keyRef: AES_REF });
+      sameBytes(bytes, copy);
+    });
+
+    it('[ENCFHE] legacy method has no byte support -> throws', async function () {
+      const ring = new Keyring({ legacy: 'passphrase' });
+      const cipher = new EventsCipher(ring);
+      await expectThrows(() => cipher.encryptAttachmentData(randomBytes(16), { method: 'aes-text-base64', keyRef: 'legacy' }));
+      const legacyEvent = { type: 'encrypted/aes-text-base64', content: { payload: 'x', keyRef: 'legacy' } };
+      await expectThrows(() => cipher.decryptAttachmentData(legacyEvent, randomBytes(16)));
+    });
+
+    it('[ENCFHF] unknown method throws', async function () {
+      await expectThrows(() => aesCipher.encryptAttachmentData(randomBytes(16), { method: 'nope', keyRef: AES_REF }));
+      const badEvent = { type: 'encrypted/nope', content: { payload: 'x' } };
+      await expectThrows(() => aesCipher.decryptAttachmentData(badEvent, randomBytes(16)));
+    });
+
+    it('[ENCFHG] missing key throws', async function () {
+      const cipher = new EventsCipher(new Keyring());
+      await expectThrows(() => cipher.encryptAttachmentData(randomBytes(16), { method: 'aes-256-gcm', keyRef: 'absent' }));
+      const event = { type: 'encrypted/aes-256-gcm', content: { payload: 'x', keyRef: 'absent' } };
+      await expectThrows(() => cipher.decryptAttachmentData(event, randomBytes(16)));
+    });
+
+    it('[ENCFHH] non-encrypted event throws on decrypt', async function () {
+      const plainEvent = { type: 'note/txt', content: 'plain' };
+      await expectThrows(() => aesCipher.decryptAttachmentData(plainEvent, randomBytes(16)));
+    });
+
+    it('[ENCFHI] a custom method may provide byte primitives', async function () {
+      // Identity "cipher" — enough to exercise the registration + validation path.
+      const custom = {
+        encrypt: async (m) => ({ payload: 'noop' }),
+        decrypt: async () => ({ type: 'note/txt', content: 'noop' }),
+        encryptBytes: async (bytes) => bytes,
+        decryptBytes: async (bytes) => bytes
+      };
+      const ring = new Keyring({ k: 'anything' });
+      const cipher = new EventsCipher(ring).registerMethod('passthrough', custom);
+      const bytes = randomBytes(32);
+      const enc = await cipher.encryptAttachmentData(bytes, { method: 'passthrough', keyRef: 'k' });
+      const event = { type: 'encrypted/passthrough', content: { keyRef: 'k' } };
+      const back = await cipher.decryptAttachmentData(event, enc);
+      sameBytes(back, bytes);
+    });
+
+    it('[ENCFHJ] registerMethod rejects a non-function encryptBytes/decryptBytes', function () {
+      const cipher = new EventsCipher(new Keyring());
+      expect(() => cipher.registerMethod('bad', { decrypt: async () => {}, encryptBytes: 123 })).to.throw();
+      expect(() => cipher.registerMethod('bad', { decrypt: async () => {}, decryptBytes: 'x' })).to.throw();
+    });
+  });
+});

package/test/ecies-aes-256-gcm.test.js

@@ -0,0 +1,203 @@
+/**
+ * @license
+ * [BSD-3-Clause](https://github.com/pryv/lib-js/blob/master/LICENSE)
+ */
+/* global describe, it, before, expect */
+
+const ecies = require('../src/methods/ecies-aes-256-gcm');
+const { EventsCipher, Keyring } = require('../src');
+const { base64ToBytes, bytesToBase64 } = require('../src/lib/base64');
+const fixture = require('./fixtures/ecies-aes-256-gcm.json');
+
+const subtle = globalThis.crypto.subtle;
+
+// Various encodings of the fixed recipient key, prepared once.
+let rawPubBytes; // Uint8Array, 65-byte SEC1 uncompressed public key
+let rawPubBase64;
+let pkcs8Bytes; // Uint8Array, PKCS#8 private key
+let pkcs8Base64;
+let pubCryptoKey; // ECDH public CryptoKey
+let privCryptoKey; // ECDH private CryptoKey
+
+before(async function () {
+  pubCryptoKey = await subtle.importKey('jwk', fixture.recipient.publicKey, { name: 'ECDH', namedCurve: 'P-256' }, true, []);
+  privCryptoKey = await subtle.importKey('jwk', fixture.recipient.privateKey, { name: 'ECDH', namedCurve: 'P-256' }, true, ['deriveBits']);
+  rawPubBytes = new Uint8Array(await subtle.exportKey('raw', pubCryptoKey));
+  rawPubBase64 = bytesToBase64(rawPubBytes);
+  pkcs8Bytes = new Uint8Array(await subtle.exportKey('pkcs8', privCryptoKey));
+  pkcs8Base64 = bytesToBase64(pkcs8Bytes);
+});
+
+describe('[ENCP] ecies-aes-256-gcm (asymmetric)', function () {
+  describe('[ENCPV] known-answer decrypt vector', function () {
+    it('[ENCPVA] decrypts the committed vector byte-exactly (JWK private key)', async function () {
+      const material = await ecies.decrypt({ payload: fixture.payload }, fixture.recipient.privateKey);
+      expect(material).to.deep.equal(fixture.plaintextObject);
+    });
+  });
+
+  describe('[ENCPG] generateKeyPair + full cycle', function () {
+    it('[ENCPGA] mint -> encrypt(public) -> decrypt(private) round-trips', async function () {
+      const pair = await ecies.generateKeyPair();
+      expect(pair.publicKey).to.have.property('kty', 'EC');
+      expect(pair.privateKey).to.have.property('d');
+      const material = { type: 'note/txt', content: 'minted round trip' };
+      const content = await ecies.encrypt(material, pair.publicKey);
+      expect(content).to.have.property('payload').that.is.a('string');
+      const back = await ecies.decrypt(content, pair.privateKey);
+      expect(back).to.deep.equal(material);
+    });
+
+    it('[ENCPGB] two encryptions of the same material differ (random ephemeral + IV)', async function () {
+      const material = { type: 'note/txt', content: 'nonce check' };
+      const a = await ecies.encrypt(material, fixture.recipient.publicKey);
+      const b = await ecies.encrypt(material, fixture.recipient.publicKey);
+      expect(a.payload).to.not.equal(b.payload);
+    });
+  });
+
+  describe('[ENCPR] round-trips across key-material shapes', function () {
+    const material = { type: 'mass/kg', content: { value: 7 } };
+
+    it('[ENCPRA] JWK public -> JWK private', async function () {
+      const c = await ecies.encrypt(material, fixture.recipient.publicKey);
+      const back = await ecies.decrypt(c, fixture.recipient.privateKey);
+      expect(back).to.deep.equal(material);
+    });
+
+    it('[ENCPRB] CryptoKey public -> CryptoKey private', async function () {
+      const c = await ecies.encrypt(material, pubCryptoKey);
+      const back = await ecies.decrypt(c, privCryptoKey);
+      expect(back).to.deep.equal(material);
+    });
+
+    it('[ENCPRC] raw 65-byte public (Uint8Array) -> PKCS#8 private (Uint8Array)', async function () {
+      const c = await ecies.encrypt(material, rawPubBytes);
+      const back = await ecies.decrypt(c, pkcs8Bytes);
+      expect(back).to.deep.equal(material);
+    });
+
+    it('[ENCPRD] raw public (base64) -> PKCS#8 private (base64)', async function () {
+      const c = await ecies.encrypt(material, rawPubBase64);
+      const back = await ecies.decrypt(c, pkcs8Base64);
+      expect(back).to.deep.equal(material);
+    });
+
+    it('[ENCPRE] pair object -> pair object (each side picked by usage)', async function () {
+      const pair = { publicKey: fixture.recipient.publicKey, privateKey: fixture.recipient.privateKey };
+      const c = await ecies.encrypt(material, pair);
+      const back = await ecies.decrypt(c, pair);
+      expect(back).to.deep.equal(material);
+    });
+
+    it('[ENCPRF] pair object of CryptoKeys', async function () {
+      const pair = { publicKey: pubCryptoKey, privateKey: privCryptoKey };
+      const c = await ecies.encrypt(material, pair);
+      const back = await ecies.decrypt(c, pair);
+      expect(back).to.deep.equal(material);
+    });
+  });
+
+  describe('[ENCPK] normalizeKey', function () {
+    it('[ENCPKA] usage=encrypt accepts JWK public, CryptoKey, raw bytes, base64, pair', async function () {
+      for (const m of [fixture.recipient.publicKey, pubCryptoKey, rawPubBytes, rawPubBase64,
+        { publicKey: fixture.recipient.publicKey }]) {
+        const k = await ecies.normalizeKey(m, 'encrypt');
+        expect(k).to.be.an.instanceOf(CryptoKey);
+        expect(k.type).to.equal('public');
+      }
+    });
+
+    it('[ENCPKB] usage=decrypt accepts JWK private, CryptoKey, PKCS#8 bytes, base64, pair', async function () {
+      for (const m of [fixture.recipient.privateKey, privCryptoKey, pkcs8Bytes, pkcs8Base64,
+        { privateKey: fixture.recipient.privateKey }]) {
+        const k = await ecies.normalizeKey(m, 'decrypt');
+        expect(k).to.be.an.instanceOf(CryptoKey);
+        expect(k.type).to.equal('private');
+      }
+    });
+
+    it('[ENCPKC] throws on null/unsupported material', async function () {
+      let threw = false;
+      try { await ecies.normalizeKey(null, 'encrypt'); } catch (e) { threw = true; }
+      expect(threw).to.equal(true);
+    });
+
+    it('[ENCPKD] throws on unknown usage', async function () {
+      let threw = false;
+      try { await ecies.normalizeKey(fixture.recipient.publicKey, 'sign'); } catch (e) { threw = true; }
+      expect(threw).to.equal(true);
+    });
+  });
+
+  describe('[ENCPN] negative cases (must reject)', function () {
+    it('[ENCPNA] wrong private key fails authentication', async function () {
+      const other = await ecies.generateKeyPair();
+      let threw = false;
+      try {
+        await ecies.decrypt({ payload: fixture.payload }, other.privateKey);
+      } catch (e) { threw = true; }
+      expect(threw).to.equal(true);
+    });
+
+    it('[ENCPNB] tampered tag fails', async function () {
+      const bytes = base64ToBytes(fixture.payload);
+      bytes[bytes.length - 1] ^= 0xff;
+      let threw = false;
+      try {
+        await ecies.decrypt({ payload: bytesToBase64(bytes) }, fixture.recipient.privateKey);
+      } catch (e) { threw = true; }
+      expect(threw).to.equal(true);
+    });
+
+    it('[ENCPNC] truncated payload fails', async function () {
+      const truncated = fixture.payload.slice(0, 40);
+      let threw = false;
+      try {
+        await ecies.decrypt({ payload: truncated }, fixture.recipient.privateKey);
+      } catch (e) { threw = true; }
+      expect(threw).to.equal(true);
+    });
+
+    it('[ENCPND] missing payload throws', async function () {
+      let threw = false;
+      try { await ecies.decrypt({}, fixture.recipient.privateKey); } catch (e) { threw = true; }
+      expect(threw).to.equal(true);
+    });
+  });
+
+  describe('[ENCPC] via EventsCipher (sender/recipient split)', function () {
+    it('[ENCPCA] encrypt with public key in one keyring -> decrypt with private key in a DIFFERENT keyring', async function () {
+      const KEY_REF = 'recipient-alice';
+      const senderRing = new Keyring({ [KEY_REF]: fixture.recipient.publicKey });
+      const senderCipher = new EventsCipher(senderRing);
+      const recipientRing = new Keyring({ [KEY_REF]: fixture.recipient.privateKey });
+      const recipientCipher = new EventsCipher(recipientRing);
+
+      const plain = { streamIds: ['shared'], type: 'note/txt', content: 'for alice only' };
+      const enc = await senderCipher.encryptEvent(plain, { method: 'ecies-aes-256-gcm', keyRef: KEY_REF });
+      expect(enc.type).to.equal('encrypted/ecies-aes-256-gcm');
+      expect(enc.content).to.have.property('keyRef', KEY_REF);
+
+      const dec = await recipientCipher.decryptEvent(enc);
+      expect(dec.type).to.equal('note/txt');
+      expect(dec.content).to.equal('for alice only');
+      expect(dec.decryptedFrom).to.equal(enc);
+    });
+
+    it('[ENCPCB] decrypt failure (only public key available) falls back to the same ref', async function () {
+      const KEY_REF = 'recipient-alice';
+      const senderRing = new Keyring({ [KEY_REF]: fixture.recipient.publicKey });
+      const senderCipher = new EventsCipher(senderRing);
+      const plain = { streamIds: ['shared'], type: 'note/txt', content: 'no private key here' };
+      const enc = await senderCipher.encryptEvent(plain, { method: 'ecies-aes-256-gcm', keyRef: KEY_REF });
+
+      // The sender's keyring only holds the PUBLIC key, so decrypt cannot succeed.
+      const errors = [];
+      const cipher = new EventsCipher(senderRing, { onDecryptError: () => errors.push(1) });
+      const out = await cipher.decryptEvent(enc);
+      expect(out).to.equal(enc);
+      expect(errors).to.have.length(1);
+    });
+  });
+});