zapo-js 0.1.2 → 0.3.0

package/dist/signal/session/SignalProtocol.js

@@ -3,7 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SignalProtocol = void 0;
 const _crypto_1 = require("../../crypto/index.js");
 const ConsoleLogger_1 = require("../../infra/log/ConsoleLogger");
+const StoreLock_1 = require("../../infra/perf/StoreLock");
 const constants_1 = require("../constants");
+const encoding_1 = require("../encoding");
 const SignalRatchet_1 = require("../session/SignalRatchet");
 const SignalSerializer_1 = require("../session/SignalSerializer");
 const SignalSession_1 = require("../session/SignalSession");
@@ -11,26 +13,37 @@ const bytes_1 = require("../../util/bytes");
 function signalAddressMapKey(address) {
     return `${address.user}\u0001${address.server ?? ''}\u0001${address.device}`;
 }
+function signalAddressLockKey(address) {
+    return `signal:${signalAddressMapKey(address)}`;
+}
 class SignalProtocol {
-    constructor(store, logger = new ConsoleLogger_1.ConsoleLogger('info')) {
-        this.store = store;
+    constructor(stores, logger = new ConsoleLogger_1.ConsoleLogger('info')) {
+        this.stores = stores;
         this.logger = logger;
+        this.sessionMutationLock = new StoreLock_1.StoreLock();
     }
-    async hasSession(address) {
-        return this.store.hasSession(address);
-    }
-    async hasSessions(addresses) {
-        return this.store.hasSessions(addresses);
-    }
-    async establishOutgoingSession(address, remoteBundle) {
-        const [local, localOneTimeBase] = await Promise.all([
-            (0, SignalSession_1.requireLocalIdentity)(this.store),
-            (0, SignalSession_1.generateSerializedKeyPair)()
-        ]);
-        const session = await (0, SignalSession_1.initiateSessionOutgoing)(local, remoteBundle, localOneTimeBase);
-        await this.store.setRemoteIdentity(address, session.remote.pubKey);
-        await this.store.setSession(address, session);
-        return session;
+    async establishOutgoingSession(address, remoteBundle, options = {}) {
+        return this.runWithAddressLock(address, async () => {
+            if (options.reuseExisting) {
+                const existing = await this.stores.session.getSession(address);
+                if (existing) {
+                    const remoteIdentity = (0, _crypto_1.toSerializedPubKey)(remoteBundle.identity);
+                    if (!(0, bytes_1.uint8Equal)(existing.remote.pubKey, remoteIdentity)) {
+                        throw new Error('identity mismatch');
+                    }
+                    return existing;
+                }
+            }
+            const [local, localOneTimeBase] = await Promise.all([
+                (0, SignalSession_1.requireLocalIdentity)(this.stores.signal),
+                (0, SignalSession_1.generateSerializedKeyPair)()
+            ]);
+            const session = await (0, SignalSession_1.initiateSessionOutgoing)(local, remoteBundle, localOneTimeBase);
+            // Keep writes ordered: a stored session without matching remote identity causes false mismatch checks.
+            await this.stores.identity.setRemoteIdentity(address, session.remote.pubKey);
+            await this.stores.session.setSession(address, session);
+            return session;
+        });
     }
     async encryptMessage(address, plaintext, expectedIdentity) {
         const [encrypted] = await this.encryptMessagesBatch([
@@ -38,77 +51,140 @@ class SignalProtocol {
         ]);
         return encrypted;
     }
-    async encryptMessagesBatch(requests) {
+    async encryptMessagesBatch(requests, prefetchedSessions) {
         if (requests.length === 0) {
             return [];
         }
-        const addresses = requests.map((request) => request.address);
-        const storedSessions = await this.store.getSessionsBatch(addresses);
-        const latestSessionByAddress = new Map();
-        const sessionUpdatesByAddress = new Map();
-        const identityUpdatesByAddress = new Map();
-        const results = new Array(requests.length);
-        for (let index = 0; index < requests.length; index += 1) {
-            const request = requests[index];
-            const address = request.address;
-            const addressKey = signalAddressMapKey(address);
-            const session = latestSessionByAddress.get(addressKey) ?? storedSessions[index];
-            if (!session) {
-                throw new Error('signal session not found');
+        const lockKeySet = new Set();
+        for (let i = 0; i < requests.length; i += 1)
+            lockKeySet.add(signalAddressLockKey(requests[i].address));
+        const lockKeys = [...lockKeySet];
+        return this.sessionMutationLock.runMany(lockKeys, async () => {
+            const prefetchedByAddress = new Map();
+            if (prefetchedSessions && prefetchedSessions.length > 0) {
+                for (let index = 0; index < prefetchedSessions.length; index += 1) {
+                    const entry = prefetchedSessions[index];
+                    prefetchedByAddress.set(signalAddressMapKey(entry.address), entry.session);
+                }
             }
-            if (request.expectedIdentity &&
-                !(0, bytes_1.uint8Equal)((0, _crypto_1.toSerializedPubKey)(request.expectedIdentity), session.remote.pubKey)) {
-                throw new Error('identity mismatch');
+            const uniqueAddressKeys = new Array(requests.length);
+            const uniqueAddresses = new Array(requests.length);
+            let uniqueAddressCount = 0;
+            for (let index = 0; index < requests.length; index += 1) {
+                const address = requests[index].address;
+                const addressKey = signalAddressMapKey(address);
+                let isDuplicate = false;
+                for (let dedupIndex = 0; dedupIndex < uniqueAddressCount; dedupIndex += 1) {
+                    if (uniqueAddressKeys[dedupIndex] === addressKey) {
+                        isDuplicate = true;
+                        break;
+                    }
+                }
+                if (isDuplicate) {
+                    continue;
+                }
+                uniqueAddressKeys[uniqueAddressCount] = addressKey;
+                uniqueAddresses[uniqueAddressCount] = address;
+                uniqueAddressCount += 1;
             }
-            const [updatedSession, encrypted] = await (0, SignalRatchet_1.encryptMsg)(session, request.plaintext);
-            latestSessionByAddress.set(addressKey, updatedSession);
-            sessionUpdatesByAddress.set(addressKey, {
-                address,
-                session: updatedSession
-            });
-            if (!(0, bytes_1.uint8Equal)(updatedSession.remote.pubKey, session.remote.pubKey)) {
-                identityUpdatesByAddress.set(addressKey, {
+            uniqueAddressKeys.length = uniqueAddressCount;
+            uniqueAddresses.length = uniqueAddressCount;
+            const currentSessions = await this.stores.session.getSessionsBatch(uniqueAddresses);
+            const latestSessionByAddress = new Map();
+            for (let index = 0; index < uniqueAddressCount; index += 1) {
+                const addressKey = uniqueAddressKeys[index];
+                const current = currentSessions[index];
+                if (current) {
+                    latestSessionByAddress.set(addressKey, current);
+                    continue;
+                }
+                const prefetched = prefetchedByAddress.get(addressKey);
+                if (prefetched) {
+                    latestSessionByAddress.set(addressKey, prefetched);
+                }
+            }
+            const sessionUpdatesByAddress = new Map();
+            const identityUpdatesByAddress = new Map();
+            const results = new Array(requests.length);
+            for (let index = 0; index < requests.length; index += 1) {
+                const request = requests[index];
+                const address = request.address;
+                const addressKey = signalAddressMapKey(address);
+                const session = latestSessionByAddress.get(addressKey);
+                if (!session) {
+                    throw new Error('signal session not found');
+                }
+                if (request.expectedIdentity &&
+                    !(0, bytes_1.uint8Equal)((0, _crypto_1.toSerializedPubKey)(request.expectedIdentity), session.remote.pubKey)) {
+                    throw new Error('identity mismatch');
+                }
+                const [updatedSession, encrypted] = await (0, SignalRatchet_1.encryptMsg)(session, request.plaintext);
+                latestSessionByAddress.set(addressKey, updatedSession);
+                sessionUpdatesByAddress.set(addressKey, {
                     address,
-                    identityKey: updatedSession.remote.pubKey
+                    session: updatedSession
                 });
+                if (!(0, bytes_1.uint8Equal)(updatedSession.remote.pubKey, session.remote.pubKey)) {
+                    identityUpdatesByAddress.set(addressKey, {
+                        address,
+                        identityKey: updatedSession.remote.pubKey
+                    });
+                }
+                results[index] = {
+                    ...encrypted,
+                    baseKey: updatedSession.aliceBaseKey
+                };
             }
-            results[index] = {
-                ...encrypted,
-                baseKey: updatedSession.aliceBaseKey
-            };
-        }
-        await this.store.setSessionsBatch([...sessionUpdatesByAddress.values()]);
-        if (identityUpdatesByAddress.size > 0) {
-            await this.store.setRemoteIdentities([...identityUpdatesByAddress.values()]);
-        }
-        return results;
+            // Persist remote identities first when needed so session writes never commit ahead of identity data.
+            if (identityUpdatesByAddress.size > 0) {
+                const identityUpdates = new Array(identityUpdatesByAddress.size);
+                let identityIndex = 0;
+                for (const update of identityUpdatesByAddress.values()) {
+                    identityUpdates[identityIndex] = update;
+                    identityIndex += 1;
+                }
+                await this.stores.identity.setRemoteIdentities(identityUpdates);
+            }
+            const sessionUpdates = new Array(sessionUpdatesByAddress.size);
+            let sessionIndex = 0;
+            for (const update of sessionUpdatesByAddress.values()) {
+                sessionUpdates[sessionIndex] = update;
+                sessionIndex += 1;
+            }
+            await this.stores.session.setSessionsBatch(sessionUpdates);
+            return results;
+        });
     }
     async decryptMessage(address, envelope) {
-        const currentSession = await this.store.getSession(address);
-        let outcome;
-        if (envelope.type === 'pkmsg') {
-            const parsedPk = (0, SignalSerializer_1.deserializePkMsg)(envelope.ciphertext);
-            outcome = await this.decryptPkMsg(currentSession, parsedPk);
-        }
-        else {
-            const parsed = (0, SignalSerializer_1.deserializeMsg)(envelope.ciphertext);
-            outcome = await this.decryptMsgInternal(currentSession, parsed);
-        }
-        const nextRemoteIdentity = outcome.newSessionInfo?.newIdentity ?? outcome.updatedSession.remote.pubKey;
-        if (!currentSession || !(0, bytes_1.uint8Equal)(currentSession.remote.pubKey, nextRemoteIdentity)) {
-            await this.store.setRemoteIdentity(address, nextRemoteIdentity);
-        }
-        await this.store.setSession(address, outcome.updatedSession);
-        return outcome.plaintext;
-    }
-    async decryptMsgInternal(session, parsed) {
-        return (0, SignalRatchet_1.decryptMsg)(session, parsed, (error, previousSessionIndex) => {
-            this.logger.debug('signal decrypt fallback session failed', {
-                previousSessionIndex,
-                message: error.message
-            });
+        return this.runWithAddressLock(address, async () => {
+            const currentSession = await this.stores.session.getSession(address);
+            let outcome;
+            if (envelope.type === 'pkmsg') {
+                const parsedPk = (0, SignalSerializer_1.deserializePkMsg)(envelope.ciphertext);
+                outcome = await this.decryptPkMsg(currentSession, parsedPk);
+            }
+            else {
+                const parsed = (0, SignalSerializer_1.deserializeMsg)(envelope.ciphertext);
+                outcome = await (0, SignalRatchet_1.decryptMsg)(currentSession, parsed, (error, previousSessionIndex) => {
+                    this.logger.debug('signal decrypt fallback session failed', {
+                        previousSessionIndex,
+                        message: error.message
+                    });
+                });
+            }
+            const nextRemoteIdentity = outcome.newSessionInfo?.newIdentity ?? outcome.updatedSession.remote.pubKey;
+            const identityChanged = !currentSession || !(0, bytes_1.uint8Equal)(currentSession.remote.pubKey, nextRemoteIdentity);
+            // Keep writes ordered for consistency with resolver identity checks.
+            if (identityChanged) {
+                await this.stores.identity.setRemoteIdentity(address, nextRemoteIdentity);
+            }
+            await this.stores.session.setSession(address, outcome.updatedSession);
+            return outcome.plaintext;
         });
     }
+    runWithAddressLock(address, task) {
+        return this.sessionMutationLock.run(signalAddressLockKey(address), task);
+    }
     async decryptPkMsg(currentSession, parsed) {
         const matchingSession = (0, SignalSession_1.findMatchingSession)(currentSession, parsed.sessionBaseKey);
         if (matchingSession) {
@@ -120,11 +196,11 @@ class SignalProtocol {
             };
         }
         const [local, signedPreKey, oneTimePreKey] = await Promise.all([
-            (0, SignalSession_1.requireLocalIdentity)(this.store),
-            (0, SignalSerializer_1.requireSignedPreKey)(this.store, parsed.localSignedPreKeyId),
+            (0, SignalSession_1.requireLocalIdentity)(this.stores.signal),
+            (0, SignalSerializer_1.requireSignedPreKey)(this.stores.signal, parsed.localSignedPreKeyId),
             parsed.localOneTimeKeyId === null || parsed.localOneTimeKeyId === undefined
                 ? Promise.resolve(null)
-                : (0, SignalSerializer_1.requirePreKey)(this.store, parsed.localOneTimeKeyId)
+                : (0, SignalSerializer_1.requirePreKey)(this.stores.preKey, parsed.localOneTimeKeyId)
         ]);
         const incoming = await (0, SignalSession_1.initiateSessionIncoming)(local, parsed.remote, parsed.sessionBaseKey, {
             signed: (0, SignalSession_1.toSerializedKeyPair)(signedPreKey.keyPair),
@@ -138,14 +214,15 @@ class SignalProtocol {
             ? {
                 ...incoming,
                 prevSessions: [
-                    (0, SignalSession_1.detachSession)(currentSession),
+                    (0, encoding_1.encodeSignalSessionSnapshot)((0, SignalSession_1.detachSession)(currentSession)),
                     ...currentSession.prevSessions.slice(0, constants_1.MAX_PREV_SESSIONS - 1)
                 ]
             }
             : incoming;
         const [updatedSession, plaintext] = await (0, SignalRatchet_1.decryptMsgFromSession)(baseSession, parsed);
+        // Only consume one-time prekeys after successful decrypt/session materialization.
         if (parsed.localOneTimeKeyId !== null && parsed.localOneTimeKeyId !== undefined) {
-            await this.store.consumePreKeyById(parsed.localOneTimeKeyId);
+            await this.stores.preKey.consumePreKeyById(parsed.localOneTimeKeyId);
         }
         return {
             updatedSession,

package/dist/signal/session/SignalRatchet.js

@@ -9,6 +9,7 @@ exports.decryptMsgFromSession = decryptMsgFromSession;
 const _crypto_1 = require("../../crypto/index.js");
 const _proto_1 = require("../../proto.js");
 const constants_1 = require("../constants");
+const encoding_1 = require("../encoding");
 const SignalSession_1 = require("../session/SignalSession");
 const bytes_1 = require("../../util/bytes");
 const primitives_1 = require("../../util/primitives");
@@ -43,7 +44,7 @@ async function selectMessageKey(chain, targetCounter) {
         if (idx === -1) {
             throw new Error('duplicate message');
         }
-        const messageKey = unused[idx];
+        const messageKey = (0, encoding_1.decodeSignalMessageKey)(unused[idx], `unusedMsgKeys[${idx}]`);
         const nextUnused = (0, bytes_1.removeAt)(unused, idx);
         return {
             messageKey,
@@ -81,7 +82,12 @@ async function selectMessageKey(chain, targetCounter) {
             overflow -= 1;
         }
         else {
-            nextUnused.push(currentMessageKey);
+            nextUnused.push({
+                index: currentMessageKey.index,
+                cipherKey: currentMessageKey.cipherKey,
+                macKey: currentMessageKey.macKey,
+                iv: currentMessageKey.iv
+            });
         }
         const derived = await deriveMsgKeyFromState(counter, chainState);
         currentMessageKey = derived.messageKey;
@@ -182,13 +188,14 @@ async function decryptMsg(session, parsed, onPrevSessionDecryptError) {
     }
     catch (error) {
         for (let i = 0; i < session.prevSessions.length; i += 1) {
-            const prevSession = (0, SignalSession_1.snapshotToRecord)(session.prevSessions[i]);
+            const decodedPrev = (0, encoding_1.decodeSignalSessionSnapshot)(session.prevSessions[i], `prevSessions[${i}]`);
+            const prevSession = (0, SignalSession_1.snapshotToRecord)(decodedPrev);
             try {
                 const [updatedPrev, plaintext] = await decryptMsgFromSession(prevSession, parsed);
                 const updatedSession = {
                     ...updatedPrev,
                     prevSessions: [
-                        (0, SignalSession_1.detachSession)(session),
+                        (0, encoding_1.encodeSignalSessionSnapshot)((0, SignalSession_1.detachSession)(session)),
                         ...session.prevSessions.slice(0, i),
                         ...session.prevSessions.slice(i + 1)
                     ]
@@ -215,7 +222,10 @@ async function decryptMsg(session, parsed, onPrevSessionDecryptError) {
 }
 async function decryptMsgFromSession(session, message) {
     const ratchetPubKey = (0, _crypto_1.toSerializedPubKey)(message.ratchetPubKey);
-    const recvChainIndex = session.recvChains.findIndex((entry) => (0, bytes_1.uint8Equal)(entry.ratchetPubKey, ratchetPubKey));
+    const recvChainIndex = session.recvChains.findIndex((raw) => {
+        const key = raw.senderRatchetKey;
+        return key !== null && key !== undefined && (0, bytes_1.uint8Equal)(key, ratchetPubKey);
+    });
     let selectedMessageKey;
     let updatedSession;
     if (recvChainIndex === -1) {
@@ -233,7 +243,7 @@ async function decryptMsgFromSession(session, message) {
         selectedMessageKey = selected.messageKey;
         const sendRatchet = await (0, SignalSession_1.calculateRatchet)(recvRatchet.rootKey, newSendRatchet, ratchetPubKey);
         const nextRecvChains = session.recvChains.slice(-MAX_TRACKED_RECV_CHAINS);
-        nextRecvChains.push(selected.updatedChain);
+        nextRecvChains.push((0, encoding_1.encodeSignalRecvChain)(selected.updatedChain));
         updatedSession = {
             ...session,
             rootKey: sendRatchet.rootKey,
@@ -248,10 +258,11 @@ async function decryptMsgFromSession(session, message) {
         };
     }
     else {
-        const selected = await selectMessageKey(session.recvChains[recvChainIndex], message.counter);
+        const decoded = (0, encoding_1.decodeSignalRecvChain)(session.recvChains[recvChainIndex], `recvChains[${recvChainIndex}]`);
+        const selected = await selectMessageKey(decoded, message.counter);
         selectedMessageKey = selected.messageKey;
         const nextRecvChains = session.recvChains.slice();
-        nextRecvChains[recvChainIndex] = selected.updatedChain;
+        nextRecvChains[recvChainIndex] = (0, encoding_1.encodeSignalRecvChain)(selected.updatedChain);
         updatedSession = {
             ...session,
             recvChains: nextRecvChains

package/dist/signal/session/SignalSerializer.js

@@ -7,7 +7,6 @@ exports.requirePreKey = requirePreKey;
 const _crypto_1 = require("../../crypto/index.js");
 const _proto_1 = require("../../proto.js");
 const constants_1 = require("../constants");
-const bytes_1 = require("../../util/bytes");
 function deserializeMsg(versionContentMac) {
     const content = (0, _crypto_1.readVersionedContent)(versionContentMac, constants_1.SIGNAL_VERSION, constants_1.SIGNAL_MAC_SIZE);
     const parsed = _proto_1.proto.SignalMessage.decode(content);
@@ -20,9 +19,9 @@ function deserializeMsg(versionContentMac) {
         throw new Error('invalid signal message');
     }
     return {
-        ratchetPubKey: (0, _crypto_1.toSerializedPubKey)((0, bytes_1.toBytesView)(parsed.ratchetKey)),
+        ratchetPubKey: (0, _crypto_1.toSerializedPubKey)(parsed.ratchetKey),
         counter: parsed.counter,
-        ciphertext: (0, bytes_1.toBytesView)(parsed.ciphertext),
+        ciphertext: parsed.ciphertext,
         versionContentMac
     };
 }
@@ -41,14 +40,14 @@ function deserializePkMsg(versionContent) {
         parsed.message === undefined) {
         throw new Error('invalid prekey signal message');
     }
-    const signal = deserializeMsg((0, bytes_1.toBytesView)(parsed.message));
+    const signal = deserializeMsg(parsed.message);
     return {
         ...signal,
         remote: {
             regId: parsed.registrationId,
-            pubKey: (0, _crypto_1.toSerializedPubKey)((0, bytes_1.toBytesView)(parsed.identityKey))
+            pubKey: (0, _crypto_1.toSerializedPubKey)(parsed.identityKey)
         },
-        sessionBaseKey: (0, _crypto_1.toSerializedPubKey)((0, bytes_1.toBytesView)(parsed.baseKey)),
+        sessionBaseKey: (0, _crypto_1.toSerializedPubKey)(parsed.baseKey),
         localSignedPreKeyId: parsed.signedPreKeyId,
         localOneTimeKeyId: parsed.preKeyId ?? null
     };

package/dist/signal/session/SignalSession.js

@@ -12,6 +12,7 @@ exports.toSerializedKeyPair = toSerializedKeyPair;
 exports.ecdh = ecdh;
 const _crypto_1 = require("../../crypto/index.js");
 const constants_1 = require("../constants");
+const encoding_1 = require("../encoding");
 const bytes_1 = require("../../util/bytes");
 function snapshotToRecord(snapshot) {
     return {
@@ -33,19 +34,21 @@ function findMatchingSession(session, sessionBaseKey) {
         return session;
     }
     for (let index = 0; index < session.prevSessions.length; index += 1) {
-        const previousSession = session.prevSessions[index];
-        if (!previousSession.aliceBaseKey ||
-            !(0, bytes_1.uint8Equal)(previousSession.aliceBaseKey, serializedBaseKey)) {
+        const rawPrev = session.prevSessions[index];
+        if (!rawPrev.aliceBaseKey || !(0, bytes_1.uint8Equal)(rawPrev.aliceBaseKey, serializedBaseKey)) {
             continue;
         }
-        const prevSessions = [detachSession(session)];
+        const decoded = (0, encoding_1.decodeSignalSessionSnapshot)(rawPrev, `prevSessions[${index}]`);
+        const prevSessions = [
+            (0, encoding_1.encodeSignalSessionSnapshot)(detachSession(session))
+        ];
         for (let i = 0; i < session.prevSessions.length; i += 1) {
             if (i !== index) {
                 prevSessions.push(session.prevSessions[i]);
             }
         }
         return {
-            ...previousSession,
+            ...decoded,
             prevSessions
         };
     }
@@ -85,10 +88,9 @@ async function initiateSessionOutgoing(local, remoteBundle, localOneTimeBase) {
     ]);
     const [rootKey, chainKey] = await (0, _crypto_1.hkdfSplit)(secret, null, 'WhisperText');
     const recvChain = {
-        ratchetPubKey: remoteRatchetKey,
-        nextMsgIndex: 0,
-        chainKey,
-        unusedMsgKeys: []
+        senderRatchetKey: remoteRatchetKey,
+        chainKey: { index: 0, key: chainKey },
+        messageKeys: []
     };
     const sendRatchet = await generateSerializedKeyPair();
     const sendRatchetResult = await calculateRatchet(rootKey, sendRatchet, remoteRatchetKey);