zapo-js 0.1.1 → 0.2.0

package/dist/signal/session/SignalRatchet.js

@@ -59,24 +59,33 @@ async function selectMessageKey(chain, targetCounter) {
     const first = await deriveMsgKeyFromState(chain.nextMsgIndex, chainState);
     let currentMessageKey = first.messageKey;
     chainState = first.nextState;
-    let nextUnused = unused.slice();
-    if (delta > 0) {
-        let overflow = delta + unused.length - constants_1.MAX_UNUSED_KEYS;
+    if (delta === 0) {
+        return {
+            messageKey: currentMessageKey,
+            updatedChain: {
+                ratchetPubKey: chain.ratchetPubKey,
+                nextMsgIndex: targetCounter + 1,
+                chainKey: chainState.chainKey,
+                unusedMsgKeys: unused
+            }
+        };
+    }
+    const nextUnused = unused.slice();
+    let overflow = delta + unused.length - constants_1.MAX_UNUSED_KEYS;
+    if (overflow > 0) {
+        nextUnused.splice(0, overflow);
+        overflow -= unused.length;
+    }
+    for (let counter = chain.nextMsgIndex + 1; counter <= targetCounter; counter += 1) {
         if (overflow > 0) {
-            nextUnused = nextUnused.slice(overflow);
-            overflow -= unused.length;
+            overflow -= 1;
         }
-        for (let counter = chain.nextMsgIndex + 1; counter <= targetCounter; counter += 1) {
-            if (overflow > 0) {
-                overflow -= 1;
-            }
-            else {
-                nextUnused.push(currentMessageKey);
-            }
-            const derived = await deriveMsgKeyFromState(counter, chainState);
-            currentMessageKey = derived.messageKey;
-            chainState = derived.nextState;
+        else {
+            nextUnused.push(currentMessageKey);
         }
+        const derived = await deriveMsgKeyFromState(counter, chainState);
+        currentMessageKey = derived.messageKey;
+        chainState = derived.nextState;
     }
     return {
         messageKey: currentMessageKey,

package/dist/signal/session/SignalSession.js

@@ -32,16 +32,21 @@ function findMatchingSession(session, sessionBaseKey) {
     if (session.aliceBaseKey && (0, bytes_1.uint8Equal)(session.aliceBaseKey, serializedBaseKey)) {
         return session;
     }
-    const previousSessionIndex = session.prevSessions.findIndex((prev) => !!prev.aliceBaseKey && (0, bytes_1.uint8Equal)(prev.aliceBaseKey, serializedBaseKey));
-    if (previousSessionIndex !== -1) {
-        const promoted = snapshotToRecord(session.prevSessions[previousSessionIndex]);
+    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)) {
+            continue;
+        }
+        const prevSessions = [detachSession(session)];
+        for (let i = 0; i < session.prevSessions.length; i += 1) {
+            if (i !== index) {
+                prevSessions.push(session.prevSessions[i]);
+            }
+        }
         return {
-            ...promoted,
-            prevSessions: [
-                detachSession(session),
-                ...session.prevSessions.slice(0, previousSessionIndex),
-                ...session.prevSessions.slice(previousSessionIndex + 1)
-            ]
+            ...previousSession,
+            prevSessions
         };
     }
     return null;

package/dist/signal/session/resolver.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSignalSessionResolver = createSignalSessionResolver;
+const keys_1 = require("../../crypto/core/keys");
+const PromiseDedup_1 = require("../../infra/perf/PromiseDedup");
+const jid_1 = require("../../protocol/jid");
+const bytes_1 = require("../../util/bytes");
+const primitives_1 = require("../../util/primitives");
+function createSignalSessionResolver(options) {
+    const { signalProtocol, signalStore, signalIdentitySync, signalSessionSync, logger } = options;
+    const dedup = new PromiseDedup_1.PromiseDedup();
+    const ensureSessionInternal = async (address, jid, expectedIdentity, reasonIdentity = false, prefetchedBundle) => {
+        const expectedSerializedIdentity = expectedIdentity
+            ? (0, keys_1.toSerializedPubKey)(expectedIdentity)
+            : null;
+        if (reasonIdentity) {
+            await signalIdentitySync.syncIdentityKeys([jid]);
+        }
+        if (await signalStore.hasSession(address)) {
+            if (expectedSerializedIdentity) {
+                const storedIdentity = await signalStore.getRemoteIdentity(address);
+                if (!storedIdentity || !(0, bytes_1.uint8Equal)(storedIdentity, expectedSerializedIdentity)) {
+                    throw new Error('identity mismatch');
+                }
+            }
+            return null;
+        }
+        let fetched;
+        if (prefetchedBundle) {
+            fetched = {
+                jid,
+                bundle: prefetchedBundle
+            };
+        }
+        else {
+            logger.info('signal session missing, fetching remote key bundle', { jid });
+            fetched = await signalSessionSync.fetchKeyBundle({
+                jid,
+                reasonIdentity
+            });
+        }
+        const remoteIdentity = (0, keys_1.toSerializedPubKey)(fetched.bundle.identity);
+        if (reasonIdentity) {
+            const storedIdentity = await signalStore.getRemoteIdentity(address);
+            if (storedIdentity && !(0, bytes_1.uint8Equal)(remoteIdentity, storedIdentity)) {
+                throw new Error('identity mismatch');
+            }
+        }
+        if (expectedSerializedIdentity && !(0, bytes_1.uint8Equal)(remoteIdentity, expectedSerializedIdentity)) {
+            throw new Error('identity mismatch');
+        }
+        const session = await signalProtocol.establishOutgoingSession(address, fetched.bundle, {
+            reuseExisting: true
+        });
+        logger.info('signal session synchronized', {
+            jid,
+            regId: fetched.bundle.regId,
+            hasOneTimeKey: fetched.bundle.oneTimeKey !== undefined
+        });
+        return session;
+    };
+    const ensureSessionWithDedup = (address, jid, expectedIdentity, reasonIdentity = false, prefetchedBundle) => {
+        const expectedIdentityKey = expectedIdentity ? (0, bytes_1.bytesToHex)(expectedIdentity) : 'none';
+        const dedupKey = `signalSession:${(0, jid_1.signalAddressKey)(address)}:${reasonIdentity ? '1' : '0'}:${expectedIdentityKey}`;
+        return dedup.run(dedupKey, () => ensureSessionInternal(address, jid, expectedIdentity, reasonIdentity, prefetchedBundle));
+    };
+    const ensureSession = (address, jid, expectedIdentity, reasonIdentity = false) => ensureSessionWithDedup(address, jid, expectedIdentity, reasonIdentity).then(() => { });
+    const ensureSessionsBatch = async (targetJids, expectedIdentityByJid) => {
+        const seenTargetJids = new Set();
+        const normalizedTargetJids = new Array(targetJids.length);
+        const normalizedTargetAddresses = new Array(targetJids.length);
+        let normalizedTargetCount = 0;
+        for (let index = 0; index < targetJids.length; index += 1) {
+            const jid = (0, jid_1.normalizeDeviceJid)(targetJids[index]);
+            if (seenTargetJids.has(jid)) {
+                continue;
+            }
+            seenTargetJids.add(jid);
+            normalizedTargetJids[normalizedTargetCount] = jid;
+            normalizedTargetAddresses[normalizedTargetCount] = (0, jid_1.parseSignalAddressFromJid)(jid);
+            normalizedTargetCount += 1;
+        }
+        if (normalizedTargetCount === 0) {
+            return [];
+        }
+        normalizedTargetJids.length = normalizedTargetCount;
+        normalizedTargetAddresses.length = normalizedTargetCount;
+        const normalizedExpectedIdentityByJid = expectedIdentityByJid && expectedIdentityByJid.size > 0
+            ? new Map()
+            : undefined;
+        if (normalizedExpectedIdentityByJid && expectedIdentityByJid) {
+            for (const [jid, identity] of expectedIdentityByJid.entries()) {
+                try {
+                    (0, keys_1.toSerializedPubKey)(identity);
+                    normalizedExpectedIdentityByJid.set((0, jid_1.normalizeDeviceJid)(jid), identity);
+                }
+                catch (error) {
+                    logger.trace('ignoring malformed expected identity jid during batch normalization', { jid, message: (0, primitives_1.toError)(error).message });
+                }
+            }
+        }
+        const resolvedByIndex = (await signalStore.getSessionsBatch(normalizedTargetAddresses));
+        const collectResolvedTargets = () => {
+            const resolvedTargets = new Array(normalizedTargetJids.length);
+            let resolvedTargetCount = 0;
+            for (let index = 0; index < normalizedTargetJids.length; index += 1) {
+                const session = resolvedByIndex[index];
+                if (!session) {
+                    continue;
+                }
+                resolvedTargets[resolvedTargetCount] = {
+                    jid: normalizedTargetJids[index],
+                    address: normalizedTargetAddresses[index],
+                    session
+                };
+                resolvedTargetCount += 1;
+            }
+            resolvedTargets.length = resolvedTargetCount;
+            return resolvedTargets;
+        };
+        const missingIndices = [];
+        for (let index = 0; index < normalizedTargetJids.length; index += 1) {
+            const session = resolvedByIndex[index];
+            const expectedIdentity = normalizedExpectedIdentityByJid?.get(normalizedTargetJids[index]);
+            if (session && expectedIdentity) {
+                if (!(0, bytes_1.uint8Equal)(session.remote.pubKey, (0, keys_1.toSerializedPubKey)(expectedIdentity))) {
+                    throw new Error('identity mismatch');
+                }
+            }
+            if (!session) {
+                missingIndices.push(index);
+            }
+        }
+        if (missingIndices.length === 0) {
+            return collectResolvedTargets();
+        }
+        const batchRequest = new Array(missingIndices.length);
+        for (let index = 0; index < missingIndices.length; index += 1) {
+            batchRequest[index] = { jid: normalizedTargetJids[missingIndices[index]] };
+        }
+        let batchResults;
+        try {
+            batchResults = await signalSessionSync.fetchKeyBundles(batchRequest);
+        }
+        catch (error) {
+            logger.warn('signal batch key fetch failed', {
+                requested: missingIndices.length,
+                message: (0, primitives_1.toError)(error).message
+            });
+            return collectResolvedTargets();
+        }
+        const ensuredTargetIndices = new Array(missingIndices.length);
+        const ensurePromises = new Array(missingIndices.length);
+        let ensureCount = 0;
+        for (let index = 0; index < missingIndices.length; index += 1) {
+            const targetIndex = missingIndices[index];
+            const targetJid = normalizedTargetJids[targetIndex];
+            const batchResult = batchResults[index];
+            if (!batchResult?.bundle) {
+                logger.warn('signal batch key fetch returned target without bundle', {
+                    jid: targetJid,
+                    message: batchResult?.errorText ?? 'missing key bundle user in response'
+                });
+                continue;
+            }
+            const expectedIdentity = normalizedExpectedIdentityByJid?.get(targetJid);
+            ensuredTargetIndices[ensureCount] = targetIndex;
+            ensurePromises[ensureCount] = ensureSessionWithDedup(normalizedTargetAddresses[targetIndex], targetJid, expectedIdentity, false, batchResult.bundle);
+            ensureCount += 1;
+        }
+        if (ensureCount === 0) {
+            return collectResolvedTargets();
+        }
+        ensuredTargetIndices.length = ensureCount;
+        ensurePromises.length = ensureCount;
+        const ensureResults = await Promise.allSettled(ensurePromises);
+        const fallbackIndices = [];
+        for (let index = 0; index < ensuredTargetIndices.length; index += 1) {
+            const targetIndex = ensuredTargetIndices[index];
+            const ensureResult = ensureResults[index];
+            if (ensureResult.status === 'rejected') {
+                const normalized = (0, primitives_1.toError)(ensureResult.reason);
+                if (normalized.message === 'identity mismatch') {
+                    throw normalized;
+                }
+                logger.warn('signal session ensure failed during batch resolution', {
+                    jid: normalizedTargetJids[targetIndex],
+                    message: normalized.message
+                });
+                continue;
+            }
+            const session = ensureResult.value;
+            if (session) {
+                resolvedByIndex[targetIndex] = session;
+            }
+            else {
+                fallbackIndices.push(targetIndex);
+            }
+        }
+        if (fallbackIndices.length > 0) {
+            const fallbackAddresses = new Array(fallbackIndices.length);
+            for (let i = 0; i < fallbackIndices.length; i++) {
+                fallbackAddresses[i] = normalizedTargetAddresses[fallbackIndices[i]];
+            }
+            const fallbackSessions = await signalStore.getSessionsBatch(fallbackAddresses);
+            for (let i = 0; i < fallbackIndices.length; i++) {
+                const session = fallbackSessions[i];
+                if (session) {
+                    resolvedByIndex[fallbackIndices[i]] = session;
+                }
+                else {
+                    logger.warn('signal session ensure completed without persisted session', {
+                        jid: normalizedTargetJids[fallbackIndices[i]]
+                    });
+                }
+            }
+        }
+        return collectResolvedTargets();
+    };
+    return {
+        ensureSession,
+        ensureSessionsBatch
+    };
+}

package/dist/store/contracts/privacy-token.store.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });