zapo-js 0.1.1 → 0.2.0

package/dist/esm/signal/{store/sqlite.js → encoding.js}

@@ -1,6 +1,7 @@
-import { proto } from '../../proto.js';
-import { WA_DEFAULTS } from '../../protocol/constants.js';
-import { asBytes, asNumber, asOptionalBytes, asOptionalNumber, asString, toBoolOrUndef } from '../../util/coercion.js';
+import { proto } from '../proto.js';
+import { WA_DEFAULTS } from '../protocol/constants.js';
+import { assertByteLength } from '../util/bytes.js';
+import { asBytes, asNumber, asOptionalBytes, asOptionalNumber, asString, toBoolOrUndef } from '../util/coercion.js';
 export function toSignalAddressParts(address) {
     return {
         user: address.user,
@@ -55,7 +56,13 @@ function encodeSignalSessionSnapshot(session) {
         rootKey: session.rootKey,
         previousCounter: session.prevSendChainHighestIndex,
         senderChain: encodeSignalSendChain(session.sendChain),
-        receiverChains: session.recvChains.map((chain) => encodeSignalRecvChain(chain)),
+        receiverChains: (() => {
+            const src = session.recvChains;
+            const arr = new Array(src.length);
+            for (let i = 0; i < src.length; i += 1)
+                arr[i] = encodeSignalRecvChain(src[i]);
+            return arr;
+        })(),
         pendingPreKey: session.initialExchangeInfo
             ? {
                 preKeyId: session.initialExchangeInfo.remoteOneTimeId ?? undefined,
@@ -84,27 +91,29 @@ function encodeSignalRecvChain(chain) {
             index: chain.nextMsgIndex,
             key: chain.chainKey
         },
-        messageKeys: (chain.unusedMsgKeys ?? []).map((messageKey) => ({
-            index: messageKey.index,
-            cipherKey: messageKey.cipherKey,
-            macKey: messageKey.macKey,
-            iv: messageKey.iv
-        }))
+        messageKeys: (() => {
+            const src = chain.unusedMsgKeys ?? [];
+            const arr = new Array(src.length);
+            for (let i = 0; i < src.length; i += 1) {
+                const messageKey = src[i];
+                arr[i] = {
+                    index: messageKey.index,
+                    cipherKey: messageKey.cipherKey,
+                    macKey: messageKey.macKey,
+                    iv: messageKey.iv
+                };
+            }
+            return arr;
+        })()
     };
 }
 function decodeSignalMessageKey(messageKey, field) {
     const cipherKey = asBytes(messageKey.cipherKey, `${field}.cipherKey`);
-    if (cipherKey.byteLength !== 32) {
-        throw new Error(`invalid ${field}.cipherKey length ${cipherKey.byteLength}`);
-    }
+    assertByteLength(cipherKey, 32, `invalid ${field}.cipherKey length ${cipherKey.byteLength}`);
     const macKey = asBytes(messageKey.macKey, `${field}.macKey`);
-    if (macKey.byteLength !== 32) {
-        throw new Error(`invalid ${field}.macKey length ${macKey.byteLength}`);
-    }
+    assertByteLength(macKey, 32, `invalid ${field}.macKey length ${macKey.byteLength}`);
     const iv = asBytes(messageKey.iv, `${field}.iv`);
-    if (iv.byteLength !== 16) {
-        throw new Error(`invalid ${field}.iv length ${iv.byteLength}`);
-    }
+    assertByteLength(iv, 16, `invalid ${field}.iv length ${iv.byteLength}`);
     return {
         index: asNumber(messageKey.index, `${field}.index`),
         cipherKey,
@@ -118,18 +127,20 @@ function decodeSignalRecvChain(chain, field) {
         throw new Error(`missing ${field}.chainKey`);
     }
     const ratchetPubKey = asBytes(chain.senderRatchetKey, `${field}.senderRatchetKey`);
-    if (ratchetPubKey.byteLength !== 33) {
-        throw new Error(`invalid ${field}.senderRatchetKey length ${ratchetPubKey.byteLength}`);
-    }
+    assertByteLength(ratchetPubKey, 33, `invalid ${field}.senderRatchetKey length ${ratchetPubKey.byteLength}`);
     const chainKeyBytes = asBytes(chainKey.key, `${field}.chainKey.key`);
-    if (chainKeyBytes.byteLength !== 32) {
-        throw new Error(`invalid ${field}.chainKey.key length ${chainKeyBytes.byteLength}`);
-    }
+    assertByteLength(chainKeyBytes, 32, `invalid ${field}.chainKey.key length ${chainKeyBytes.byteLength}`);
     return {
         ratchetPubKey,
         nextMsgIndex: asNumber(chainKey.index, `${field}.chainKey.index`),
         chainKey: chainKeyBytes,
-        unusedMsgKeys: (chain.messageKeys ?? []).map((messageKey, index) => decodeSignalMessageKey(messageKey, `${field}.messageKeys[${index}]`))
+        unusedMsgKeys: (() => {
+            const src = chain.messageKeys ?? [];
+            const arr = new Array(src.length);
+            for (let i = 0; i < src.length; i += 1)
+                arr[i] = decodeSignalMessageKey(src[i], `${field}.messageKeys[${i}]`);
+            return arr;
+        })()
     };
 }
 function decodeSignalSendChain(chain, field) {
@@ -141,17 +152,11 @@ function decodeSignalSendChain(chain, field) {
     if (!privateKey) {
         throw new Error(`missing ${field}.senderRatchetKeyPrivate`);
     }
-    if (privateKey.byteLength !== 32) {
-        throw new Error(`invalid ${field}.senderRatchetKeyPrivate length ${privateKey.byteLength}`);
-    }
+    assertByteLength(privateKey, 32, `invalid ${field}.senderRatchetKeyPrivate length ${privateKey.byteLength}`);
     const ratchetPubKey = asBytes(chain.senderRatchetKey, `${field}.senderRatchetKey`);
-    if (ratchetPubKey.byteLength !== 33) {
-        throw new Error(`invalid ${field}.senderRatchetKey length ${ratchetPubKey.byteLength}`);
-    }
+    assertByteLength(ratchetPubKey, 33, `invalid ${field}.senderRatchetKey length ${ratchetPubKey.byteLength}`);
     const chainKeyBytes = asBytes(chainKey.key, `${field}.chainKey.key`);
-    if (chainKeyBytes.byteLength !== 32) {
-        throw new Error(`invalid ${field}.chainKey.key length ${chainKeyBytes.byteLength}`);
-    }
+    assertByteLength(chainKeyBytes, 32, `invalid ${field}.chainKey.key length ${chainKeyBytes.byteLength}`);
     return {
         ratchetKey: {
             pubKey: ratchetPubKey,
@@ -168,26 +173,20 @@ function decodeSignalSessionSnapshot(session, field) {
     }
     const pendingPreKey = session.pendingPreKey;
     const localPubKey = asBytes(session.localIdentityPublic, `${field}.localIdentityPublic`);
-    if (localPubKey.byteLength !== 33) {
-        throw new Error(`invalid ${field}.localIdentityPublic length ${localPubKey.byteLength}`);
-    }
+    assertByteLength(localPubKey, 33, `invalid ${field}.localIdentityPublic length ${localPubKey.byteLength}`);
     const remotePubKey = asBytes(session.remoteIdentityPublic, `${field}.remoteIdentityPublic`);
-    if (remotePubKey.byteLength !== 33) {
-        throw new Error(`invalid ${field}.remoteIdentityPublic length ${remotePubKey.byteLength}`);
-    }
+    assertByteLength(remotePubKey, 33, `invalid ${field}.remoteIdentityPublic length ${remotePubKey.byteLength}`);
     const rootKey = asBytes(session.rootKey, `${field}.rootKey`);
-    if (rootKey.byteLength !== 32) {
-        throw new Error(`invalid ${field}.rootKey length ${rootKey.byteLength}`);
-    }
+    assertByteLength(rootKey, 32, `invalid ${field}.rootKey length ${rootKey.byteLength}`);
     const localOneTimePubKey = pendingPreKey
         ? asBytes(pendingPreKey.baseKey, `${field}.pendingPreKey.baseKey`)
         : null;
-    if (localOneTimePubKey && localOneTimePubKey.byteLength !== 33) {
-        throw new Error(`invalid ${field}.pendingPreKey.baseKey length ${localOneTimePubKey.byteLength}`);
+    if (localOneTimePubKey) {
+        assertByteLength(localOneTimePubKey, 33, `invalid ${field}.pendingPreKey.baseKey length ${localOneTimePubKey.byteLength}`);
     }
     const aliceBaseKey = asOptionalBytes(session.aliceBaseKey, `${field}.aliceBaseKey`) ?? null;
-    if (aliceBaseKey && aliceBaseKey.byteLength !== 33) {
-        throw new Error(`invalid ${field}.aliceBaseKey length ${aliceBaseKey.byteLength}`);
+    if (aliceBaseKey) {
+        assertByteLength(aliceBaseKey, 33, `invalid ${field}.aliceBaseKey length ${aliceBaseKey.byteLength}`);
     }
     return {
         local: {
@@ -200,7 +199,13 @@ function decodeSignalSessionSnapshot(session, field) {
         },
         rootKey,
         sendChain: decodeSignalSendChain(senderChain, `${field}.senderChain`),
-        recvChains: (session.receiverChains ?? []).map((chain, index) => decodeSignalRecvChain(chain, `${field}.receiverChains[${index}]`)),
+        recvChains: (() => {
+            const src = session.receiverChains ?? [];
+            const arr = new Array(src.length);
+            for (let i = 0; i < src.length; i += 1)
+                arr[i] = decodeSignalRecvChain(src[i], `${field}.receiverChains[${i}]`);
+            return arr;
+        })(),
         initialExchangeInfo: pendingPreKey
             ? {
                 remoteOneTimeId: asOptionalNumber(pendingPreKey.preKeyId, `${field}.pendingPreKey.preKeyId`) ??
@@ -216,7 +221,13 @@ function decodeSignalSessionSnapshot(session, field) {
 export function encodeSignalSessionRecord(record) {
     return proto.RecordStructure.encode({
         currentSession: encodeSignalSessionSnapshot(record),
-        previousSessions: record.prevSessions.map((session) => encodeSignalSessionSnapshot(session))
+        previousSessions: (() => {
+            const src = record.prevSessions;
+            const arr = new Array(src.length);
+            for (let i = 0; i < src.length; i += 1)
+                arr[i] = encodeSignalSessionSnapshot(src[i]);
+            return arr;
+        })()
     }).finish();
 }
 export function decodeSignalSessionRecord(raw) {
@@ -227,7 +238,13 @@ export function decodeSignalSessionRecord(raw) {
     const current = decodeSignalSessionSnapshot(decoded.currentSession, 'signal_sessions.currentSession');
     return {
         ...current,
-        prevSessions: (decoded.previousSessions ?? []).map((session, index) => decodeSignalSessionSnapshot(session, `signal_sessions.previousSessions[${index}]`))
+        prevSessions: (() => {
+            const src = decoded.previousSessions ?? [];
+            const arr = new Array(src.length);
+            for (let i = 0; i < src.length; i += 1)
+                arr[i] = decodeSignalSessionSnapshot(src[i], `signal_sessions.previousSessions[${i}]`);
+            return arr;
+        })()
     };
 }
 export function encodeSenderKeyRecord(record) {
@@ -243,10 +260,18 @@ export function encodeSenderKeyRecord(record) {
                     public: record.signingPublicKey,
                     private: record.signingPrivateKey
                 },
-                senderMessageKeys: (record.unusedMessageKeys ?? []).map((messageKey) => ({
-                    iteration: messageKey.iteration,
-                    seed: messageKey.seed
-                }))
+                senderMessageKeys: (() => {
+                    const src = record.unusedMessageKeys ?? [];
+                    const arr = new Array(src.length);
+                    for (let i = 0; i < src.length; i += 1) {
+                        const messageKey = src[i];
+                        arr[i] = {
+                            iteration: messageKey.iteration,
+                            seed: messageKey.seed
+                        };
+                    }
+                    return arr;
+                })()
             }
         ]
     }).finish();
@@ -266,10 +291,18 @@ function decodeSenderKeyState(state, field) {
         signingPrivateKey: state.senderSigningKey.private !== null && state.senderSigningKey.private !== undefined
             ? asBytes(state.senderSigningKey.private, `${field}.senderSigningKey.private`)
             : undefined,
-        unusedMessageKeys: (state.senderMessageKeys ?? []).map((messageKey, index) => ({
-            iteration: asNumber(messageKey.iteration, `${field}.senderMessageKeys[${index}].iteration`),
-            seed: asBytes(messageKey.seed, `${field}.senderMessageKeys[${index}].seed`)
-        }))
+        unusedMessageKeys: (() => {
+            const src = state.senderMessageKeys ?? [];
+            const arr = new Array(src.length);
+            for (let i = 0; i < src.length; i += 1) {
+                const messageKey = src[i];
+                arr[i] = {
+                    iteration: asNumber(messageKey.iteration, `${field}.senderMessageKeys[${i}].iteration`),
+                    seed: asBytes(messageKey.seed, `${field}.senderMessageKeys[${i}].seed`)
+                };
+            }
+            return arr;
+        })()
     };
 }
 export function decodeSenderKeyRecord(raw, groupId, sender) {
@@ -302,7 +335,7 @@ export function decodeSenderKeyDistributionRow(row) {
         timestampMs: asNumber(row.timestamp_ms, 'sender_key_distribution.timestamp_ms')
     };
 }
-export function decodeSqliteCount(row, field) {
+export function decodeStoreCount(row, field) {
     return row ? asNumber(row.count, field) : 0;
 }
 export function decodeSignalRemoteIdentity(raw) {

package/dist/esm/signal/group/SenderKeyChain.js

@@ -1,6 +1,6 @@
 import { hkdf, importHmacKey, hmacSign } from '../../crypto/index.js';
 import { CHAIN_KEY_LABEL, MAX_UNUSED_KEYS, MESSAGE_KEY_LABEL, SENDER_KEY_FUTURE_MESSAGES_MAX, WHISPER_GROUP_INFO } from '../constants.js';
-import { removeAt } from '../../util/bytes.js';
+import { assertByteLength, removeAt } from '../../util/bytes.js';
 export async function selectMessageKey(senderKey, targetIteration) {
     const delta = targetIteration - senderKey.iteration;
     if (delta > SENDER_KEY_FUTURE_MESSAGES_MAX) {
@@ -26,24 +26,33 @@ export async function selectMessageKey(senderKey, targetIteration) {
     const firstDerived = await deriveSenderKeyMsgKeyFromState(senderKey.iteration, chainState);
     chainState = firstDerived.nextState;
     let messageKey = firstDerived.messageKey;
-    let nextUnused = currentUnused.slice();
-    if (delta > 0) {
-        let overflow = delta + currentUnused.length - MAX_UNUSED_KEYS;
+    if (delta === 0) {
+        return {
+            messageKey,
+            updatedRecord: {
+                ...senderKey,
+                iteration: targetIteration + 1,
+                chainKey: chainState.chainKey,
+                unusedMessageKeys: currentUnused
+            }
+        };
+    }
+    const nextUnused = currentUnused.slice();
+    let overflow = delta + currentUnused.length - MAX_UNUSED_KEYS;
+    if (overflow > 0) {
+        nextUnused.splice(0, overflow);
+        overflow -= currentUnused.length;
+    }
+    for (let iteration = senderKey.iteration + 1; iteration <= targetIteration; iteration += 1) {
         if (overflow > 0) {
-            nextUnused = nextUnused.slice(overflow);
-            overflow -= currentUnused.length;
+            overflow -= 1;
         }
-        for (let iteration = senderKey.iteration + 1; iteration <= targetIteration; iteration += 1) {
-            if (overflow > 0) {
-                overflow -= 1;
-            }
-            else {
-                nextUnused.push(messageKey);
-            }
-            const derived = await deriveSenderKeyMsgKeyFromState(iteration, chainState);
-            chainState = derived.nextState;
-            messageKey = derived.messageKey;
+        else {
+            nextUnused.push(messageKey);
         }
+        const derived = await deriveSenderKeyMsgKeyFromState(iteration, chainState);
+        chainState = derived.nextState;
+        messageKey = derived.messageKey;
     }
     return {
         messageKey,
@@ -64,20 +73,16 @@ export async function deriveSenderKeyMsgKey(iteration, chainKey) {
     };
 }
 async function createSenderChainState(chainKey) {
-    if (chainKey.length !== 32) {
-        throw new Error('sender key chainKey must be 32 bytes');
-    }
+    assertByteLength(chainKey, 32, 'sender key chainKey must be 32 bytes');
     return {
         chainKey,
         hmacKey: await importHmacKey(chainKey)
     };
 }
 async function deriveSenderKeyMsgKeyFromState(iteration, state) {
-    const nextChainRawPromise = hmacSign(state.hmacKey, CHAIN_KEY_LABEL);
-    const messageInputKeyPromise = hmacSign(state.hmacKey, MESSAGE_KEY_LABEL);
     const [nextChainRaw, messageInputKey] = await Promise.all([
-        nextChainRawPromise,
-        messageInputKeyPromise
+        hmacSign(state.hmacKey, CHAIN_KEY_LABEL),
+        hmacSign(state.hmacKey, MESSAGE_KEY_LABEL)
     ]);
     const nextChainKey = nextChainRaw.subarray(0, 32);
     const [nextHmacKey, messageSeed] = await Promise.all([

package/dist/esm/signal/group/SenderKeyCodec.js

@@ -1,7 +1,8 @@
 import { readVersionedContent, toSerializedPubKey } from '../../crypto/index.js';
 import { proto } from '../../proto.js';
-import { SIGNATURE_SIZE, SIGNAL_GROUP_VERSION } from '../constants.js';
-import { toBytesView } from '../../util/bytes.js';
+import { SIGNAL_SIGNATURE_LENGTH } from '../api/constants.js';
+import { SIGNAL_GROUP_VERSION } from '../constants.js';
+import { assertByteLength, toBytesView } from '../../util/bytes.js';
 export function parseDistributionPayload(payload) {
     const body = readVersionedContent(payload, SIGNAL_GROUP_VERSION, 0);
     const decoded = proto.SenderKeyDistributionMessage.decode(body);
@@ -16,9 +17,7 @@ export function parseDistributionPayload(payload) {
         throw new Error('invalid sender key distribution message');
     }
     const chainKey = toBytesView(decoded.chainKey);
-    if (chainKey.length !== 32) {
-        throw new Error('sender key distribution chainKey must be 32 bytes');
-    }
+    assertByteLength(chainKey, 32, 'sender key distribution chainKey must be 32 bytes');
     return {
         keyId: decoded.id,
         iteration: decoded.iteration,
@@ -27,7 +26,7 @@ export function parseDistributionPayload(payload) {
     };
 }
 export function parseSenderKeyMessage(versionContentMac) {
-    const body = readVersionedContent(versionContentMac, SIGNAL_GROUP_VERSION, SIGNATURE_SIZE);
+    const body = readVersionedContent(versionContentMac, SIGNAL_GROUP_VERSION, SIGNAL_SIGNATURE_LENGTH);
     const decoded = proto.SenderKeyMessage.decode(body);
     if (decoded.id === null ||
         decoded.id === undefined ||