zapo-js 0.3.0 → 1.0.0

package/dist/signal/api/SignalSessionSyncApi.js

@@ -11,6 +11,11 @@ const query_1 = require("../../transport/node/query");
 function isKeyBundleResultPreferred(result) {
     return 'bundle' in result;
 }
+/**
+ * Fetches per-device prekey bundles required to start a Signal session.
+ * Use {@link fetchKeyBundle} for single-JID calls or {@link fetchKeyBundles}
+ * for batched encryption.
+ */
 class SignalSessionSyncApi {
     constructor(options) {
         this.logger = options.logger;
@@ -19,6 +24,10 @@ class SignalSessionSyncApi {
             options.defaultTimeoutMs ?? constants_1.WA_DEFAULTS.SIGNAL_FETCH_KEY_BUNDLES_TIMEOUT_MS;
         this.hostDomain = options.hostDomain ?? constants_1.WA_DEFAULTS.HOST_DOMAIN;
     }
+    /**
+     * Convenience wrapper for {@link fetchKeyBundles} that fetches a single
+     * bundle and throws on server error envelopes.
+     */
     async fetchKeyBundle(target, timeoutMs = this.defaultTimeoutMs) {
         const results = await this.fetchKeyBundles([target], timeoutMs);
         const first = results[0];
@@ -36,6 +45,10 @@ class SignalSessionSyncApi {
         });
         return parsed;
     }
+    /**
+     * Batched key-bundle fetch. Returns one entry per JID – either a bundle
+     * (success) or an error envelope. Duplicate JIDs are coalesced.
+     */
     async fetchKeyBundles(targets, timeoutMs = this.defaultTimeoutMs) {
         if (targets.length === 0) {
             return [];
@@ -136,57 +149,16 @@ class SignalSessionSyncApi {
         if (!registrationNode) {
             throw new Error('key bundle user missing registration node');
         }
-        const identityNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.IDENTITY);
-        if (!identityNode) {
-            throw new Error('key bundle user missing identity node');
-        }
-        const signedPreKeyNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.SKEY);
-        if (!signedPreKeyNode) {
-            throw new Error('key bundle user missing signed pre-key node');
-        }
-        const registrationBytes = (0, codec_1.decodeExactLength)(registrationNode.content, 'key bundle registration', constants_2.SIGNAL_REGISTRATION_ID_LENGTH);
-        const registrationId = (0, codec_1.parseUint)(registrationBytes, 'key bundle registration');
-        const identity = (0, codec_1.decodeExactLength)(identityNode.content, 'key bundle identity', constants_2.SIGNAL_KEY_DATA_LENGTH);
-        const signedIdNode = (0, helpers_1.findNodeChild)(signedPreKeyNode, constants_1.WA_NODE_TAGS.ID);
-        const signedValueNode = (0, helpers_1.findNodeChild)(signedPreKeyNode, constants_1.WA_NODE_TAGS.VALUE);
-        const signedSignatureNode = (0, helpers_1.findNodeChild)(signedPreKeyNode, constants_1.WA_NODE_TAGS.SIGNATURE);
-        if (!signedIdNode || !signedValueNode || !signedSignatureNode) {
-            throw new Error('key bundle signed pre-key is incomplete');
-        }
-        const signedIdBytes = (0, codec_1.decodeExactLength)(signedIdNode.content, 'key bundle skey.id', constants_2.SIGNAL_KEY_ID_LENGTH);
-        const signedValue = (0, codec_1.decodeExactLength)(signedValueNode.content, 'key bundle skey.value', constants_2.SIGNAL_KEY_DATA_LENGTH);
-        const signedSignature = (0, codec_1.decodeExactLength)(signedSignatureNode.content, 'key bundle skey.signature', constants_2.SIGNAL_SIGNATURE_LENGTH);
-        const preKeyNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.KEY);
-        let oneTimeKey;
-        if (preKeyNode) {
-            const preKeyIdNode = (0, helpers_1.findNodeChild)(preKeyNode, constants_1.WA_NODE_TAGS.ID);
-            const preKeyValueNode = (0, helpers_1.findNodeChild)(preKeyNode, constants_1.WA_NODE_TAGS.VALUE);
-            if (!preKeyIdNode || !preKeyValueNode) {
-                throw new Error('key bundle one-time pre-key is incomplete');
-            }
-            const preKeyIdBytes = (0, codec_1.decodeExactLength)(preKeyIdNode.content, 'key bundle key.id', constants_2.SIGNAL_KEY_ID_LENGTH);
-            const preKeyValue = (0, codec_1.decodeExactLength)(preKeyValueNode.content, 'key bundle key.value', constants_2.SIGNAL_KEY_DATA_LENGTH);
-            oneTimeKey = {
-                id: (0, codec_1.parseUint)(preKeyIdBytes, 'key bundle key.id'),
-                publicKey: preKeyValue
-            };
-        }
-        const deviceIdentityNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.DEVICE_IDENTITY);
-        const deviceIdentity = deviceIdentityNode
-            ? (0, helpers_1.decodeNodeContentBase64OrBytes)(deviceIdentityNode.content, 'key bundle device-identity')
-            : undefined;
+        const regId = (0, codec_1.parseUint)((0, codec_1.decodeExactLength)(registrationNode.content, 'key bundle registration', constants_2.SIGNAL_REGISTRATION_ID_LENGTH), 'key bundle registration');
+        const parsed = (0, codec_1.parseSignalKeyBundleFromNode)(node, 'key bundle');
         return {
             bundle: {
-                regId: registrationId,
-                identity,
-                signedKey: {
-                    id: (0, codec_1.parseUint)(signedIdBytes, 'key bundle skey.id'),
-                    publicKey: signedValue,
-                    signature: signedSignature
-                },
-                ...(oneTimeKey ? { oneTimeKey } : {})
+                regId,
+                identity: parsed.identity,
+                signedKey: parsed.signedKey,
+                ...(parsed.oneTimeKey ? { oneTimeKey: parsed.oneTimeKey } : {})
             },
-            ...(deviceIdentity ? { deviceIdentity } : {})
+            ...(parsed.deviceIdentity ? { deviceIdentity: parsed.deviceIdentity } : {})
         };
     }
 }

package/dist/signal/api/codec.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decodeExactLength = decodeExactLength;
 exports.parseUint = parseUint;
+exports.parseSignalKeyBundleFromNode = parseSignalKeyBundleFromNode;
+const constants_1 = require("../../protocol/constants");
+const constants_2 = require("../api/constants");
 const helpers_1 = require("../../transport/node/helpers");
 function decodeExactLength(value, field, expectedLength) {
     const bytes = (0, helpers_1.decodeNodeContentBase64OrBytes)(value, field);
@@ -25,3 +28,52 @@ function parseUint(bytes, field) {
     }
     throw new Error(`${field} has invalid byte length`);
 }
+/**
+ * Parses the shared `<identity><skey id|value|signature><key id|value><device-identity>`
+ * shape used by session pre-key bundles, missing pre-key device bundles, and retry
+ * receipt key bundles. Caller is responsible for parsing the `<registration>` node
+ * separately when it lives at the same level (it's omitted from retry bundles).
+ */
+function parseSignalKeyBundleFromNode(node, fieldPrefix) {
+    const [identityNode, signedKeyNode, oneTimeKeyNode, deviceIdentityNode] = (0, helpers_1.findNodeChildrenByTags)(node, [
+        constants_1.WA_NODE_TAGS.IDENTITY,
+        constants_1.WA_NODE_TAGS.SKEY,
+        constants_1.WA_NODE_TAGS.KEY,
+        constants_1.WA_NODE_TAGS.DEVICE_IDENTITY
+    ]);
+    if (!identityNode) {
+        throw new Error(`${fieldPrefix} missing identity node`);
+    }
+    if (!signedKeyNode) {
+        throw new Error(`${fieldPrefix} missing signed pre-key node`);
+    }
+    const identity = decodeExactLength(identityNode.content, `${fieldPrefix}.identity`, constants_2.SIGNAL_KEY_DATA_LENGTH);
+    const [signedKeyIdNode, signedKeyValueNode, signedKeySignatureNode] = (0, helpers_1.findNodeChildrenByTags)(signedKeyNode, [constants_1.WA_NODE_TAGS.ID, constants_1.WA_NODE_TAGS.VALUE, constants_1.WA_NODE_TAGS.SIGNATURE]);
+    if (!signedKeyIdNode || !signedKeyValueNode || !signedKeySignatureNode) {
+        throw new Error(`${fieldPrefix} signed pre-key is incomplete`);
+    }
+    const signedKey = {
+        id: parseUint(decodeExactLength(signedKeyIdNode.content, `${fieldPrefix}.skey.id`, constants_2.SIGNAL_KEY_ID_LENGTH), `${fieldPrefix}.skey.id`),
+        publicKey: decodeExactLength(signedKeyValueNode.content, `${fieldPrefix}.skey.value`, constants_2.SIGNAL_KEY_DATA_LENGTH),
+        signature: decodeExactLength(signedKeySignatureNode.content, `${fieldPrefix}.skey.signature`, constants_2.SIGNAL_SIGNATURE_LENGTH)
+    };
+    let oneTimeKey;
+    if (oneTimeKeyNode) {
+        const [oneTimeKeyIdNode, oneTimeKeyValueNode] = (0, helpers_1.findNodeChildrenByTags)(oneTimeKeyNode, [
+            constants_1.WA_NODE_TAGS.ID,
+            constants_1.WA_NODE_TAGS.VALUE
+        ]);
+        if (!oneTimeKeyIdNode || !oneTimeKeyValueNode) {
+            throw new Error(`${fieldPrefix} one-time pre-key is incomplete`);
+        }
+        oneTimeKey = {
+            id: parseUint(decodeExactLength(oneTimeKeyIdNode.content, `${fieldPrefix}.key.id`, constants_2.SIGNAL_KEY_ID_LENGTH), `${fieldPrefix}.key.id`),
+            publicKey: decodeExactLength(oneTimeKeyValueNode.content, `${fieldPrefix}.key.value`, constants_2.SIGNAL_KEY_DATA_LENGTH)
+        };
+    }
+    let deviceIdentity;
+    if (deviceIdentityNode) {
+        deviceIdentity = (0, helpers_1.decodeNodeContentBase64OrBytes)(deviceIdentityNode.content, `${fieldPrefix}.device-identity`);
+    }
+    return { identity, signedKey, oneTimeKey, deviceIdentity };
+}

package/dist/signal/api/prekeys.js

@@ -7,6 +7,10 @@ var prekeys_1 = require("../../transport/node/builders/prekeys");
 Object.defineProperty(exports, "buildMissingPreKeysFetchIq", { enumerable: true, get: function () { return prekeys_1.buildMissingPreKeysFetchIq; } });
 Object.defineProperty(exports, "buildPreKeyUploadIq", { enumerable: true, get: function () { return prekeys_1.buildPreKeyUploadIq; } });
 Object.defineProperty(exports, "buildSignedPreKeyRotateIq", { enumerable: true, get: function () { return prekeys_1.buildSignedPreKeyRotateIq; } });
+/**
+ * Extracts the numeric error code and text from a failed `prekey` upload IQ
+ * response. Use after a non-success status to decide whether to retry.
+ */
 function parsePreKeyUploadFailure(node) {
     const error = (0, query_1.parseIqError)(node);
     return {

package/dist/signal/{crypto → attestation}/WaAdvSignature.js

@@ -1,17 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ADV_PREFIX_HOSTED_DEVICE_SIGNATURE = exports.ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE = exports.ADV_PREFIX_DEVICE_SIGNATURE = exports.ADV_PREFIX_ACCOUNT_SIGNATURE = void 0;
+exports.ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE = exports.ADV_PREFIX_DEVICE_SIGNATURE = exports.ADV_PREFIX_ACCOUNT_SIGNATURE = void 0;
 exports.verifyDeviceIdentityAccountSignature = verifyDeviceIdentityAccountSignature;
 exports.generateDeviceSignature = generateDeviceSignature;
 exports.computeAdvIdentityHmac = computeAdvIdentityHmac;
 const _crypto_1 = require("../../crypto/index.js");
-const constants_1 = require("../crypto/constants");
+const constants_1 = require("../attestation/constants");
 const bytes_1 = require("../../util/bytes");
-var constants_2 = require("../crypto/constants");
+var constants_2 = require("../attestation/constants");
 Object.defineProperty(exports, "ADV_PREFIX_ACCOUNT_SIGNATURE", { enumerable: true, get: function () { return constants_2.ADV_PREFIX_ACCOUNT_SIGNATURE; } });
 Object.defineProperty(exports, "ADV_PREFIX_DEVICE_SIGNATURE", { enumerable: true, get: function () { return constants_2.ADV_PREFIX_DEVICE_SIGNATURE; } });
 Object.defineProperty(exports, "ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE", { enumerable: true, get: function () { return constants_2.ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE; } });
-Object.defineProperty(exports, "ADV_PREFIX_HOSTED_DEVICE_SIGNATURE", { enumerable: true, get: function () { return constants_2.ADV_PREFIX_HOSTED_DEVICE_SIGNATURE; } });
 async function verifyDeviceIdentityAccountSignature(details, accountSignature, identityPublicKey, accountSignatureKey, isHosted = false) {
     const prefix = isHosted ? constants_1.ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE : constants_1.ADV_PREFIX_ACCOUNT_SIGNATURE;
     const message = (0, bytes_1.concatBytes)([prefix, details, identityPublicKey]);
@@ -22,7 +21,6 @@ async function generateDeviceSignature(details, identityKeyPair, accountSignatur
     const message = (0, bytes_1.concatBytes)([prefix, details, identityKeyPair.pubKey, accountSignatureKey]);
     return (0, _crypto_1.xeddsaSign)(identityKeyPair.privKey, message);
 }
-async function computeAdvIdentityHmac(secretKey, details) {
-    const key = await (0, _crypto_1.importHmacKey)(secretKey);
-    return (0, _crypto_1.hmacSign)(key, details);
+function computeAdvIdentityHmac(secretKey, details) {
+    return (0, _crypto_1.hmacSha256Sign)(secretKey, details);
 }

package/dist/signal/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SIGNAL_PREFIX = exports.WHISPER_GROUP_INFO = exports.CHAIN_KEY_LABEL = exports.MESSAGE_KEY_LABEL = exports.SENDER_KEY_FUTURE_MESSAGES_MAX = exports.FUTURE_MESSAGES_MAX = exports.MAX_UNUSED_KEYS = exports.MAX_PREV_SESSIONS = exports.SIGNAL_MAC_SIZE = exports.SIGNAL_GROUP_VERSION = exports.SIGNAL_VERSION = void 0;
+exports.SIGNAL_PREFIX = exports.WHISPER_RATCHET_INFO = exports.WHISPER_TEXT_INFO = exports.WHISPER_MESSAGE_KEYS_INFO = exports.WHISPER_GROUP_INFO = exports.CHAIN_KEY_LABEL = exports.MESSAGE_KEY_LABEL = exports.SENDER_KEY_FUTURE_MESSAGES_MAX = exports.FUTURE_MESSAGES_MAX = exports.MAX_UNUSED_KEYS = exports.MAX_PREV_SESSIONS = exports.SIGNAL_MAC_SIZE = exports.SIGNAL_GROUP_VERSION = exports.SIGNAL_VERSION = void 0;
 const bytes_1 = require("../util/bytes");
 exports.SIGNAL_VERSION = 3;
 exports.SIGNAL_GROUP_VERSION = 3;
@@ -12,4 +12,7 @@ exports.SENDER_KEY_FUTURE_MESSAGES_MAX = 20000;
 exports.MESSAGE_KEY_LABEL = new Uint8Array([1]);
 exports.CHAIN_KEY_LABEL = new Uint8Array([2]);
 exports.WHISPER_GROUP_INFO = bytes_1.TEXT_ENCODER.encode('WhisperGroup');
+exports.WHISPER_MESSAGE_KEYS_INFO = bytes_1.TEXT_ENCODER.encode('WhisperMessageKeys');
+exports.WHISPER_TEXT_INFO = bytes_1.TEXT_ENCODER.encode('WhisperText');
+exports.WHISPER_RATCHET_INFO = bytes_1.TEXT_ENCODER.encode('WhisperRatchet');
 exports.SIGNAL_PREFIX = new Uint8Array(32).fill(0xff);

package/dist/signal/encoding.js

@@ -1,26 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toSignalAddressParts = toSignalAddressParts;
-exports.decodeSignalAddressFromRow = decodeSignalAddressFromRow;
-exports.decodeSignalRegistrationRow = decodeSignalRegistrationRow;
-exports.decodeSignalPreKeyRow = decodeSignalPreKeyRow;
-exports.decodeSignalSignedPreKeyRow = decodeSignalSignedPreKeyRow;
-exports.encodeSignalSessionSnapshot = encodeSignalSessionSnapshot;
-exports.encodeSignalRecvChain = encodeSignalRecvChain;
-exports.decodeSignalMessageKey = decodeSignalMessageKey;
-exports.decodeSignalRecvChain = decodeSignalRecvChain;
-exports.decodeSignalSessionSnapshot = decodeSignalSessionSnapshot;
-exports.encodeSignalSessionRecord = encodeSignalSessionRecord;
-exports.decodeSignalSessionRecord = decodeSignalSessionRecord;
-exports.encodeSenderKeyRecord = encodeSenderKeyRecord;
-exports.decodeSenderKeyRecord = decodeSenderKeyRecord;
-exports.decodeSenderKeyDistributionRow = decodeSenderKeyDistributionRow;
 exports.decodeStoreCount = decodeStoreCount;
-exports.decodeSignalRemoteIdentity = decodeSignalRemoteIdentity;
-const _proto_1 = require("../proto.js");
 const constants_1 = require("../protocol/constants");
-const bytes_1 = require("../util/bytes");
 const coercion_1 = require("../util/coercion");
+/** Flattens a {@link SignalAddress} into plain fields, defaulting `server` to the host domain. */
 function toSignalAddressParts(address) {
     return {
         user: address.user,
@@ -28,292 +12,10 @@ function toSignalAddressParts(address) {
         device: address.device
     };
 }
-function decodeSignalAddressFromRow(row) {
-    return {
-        user: (0, coercion_1.asString)(row.sender_user, 'signal.sender_user'),
-        server: (0, coercion_1.asString)(row.sender_server, 'signal.sender_server'),
-        device: (0, coercion_1.asNumber)(row.sender_device, 'signal.sender_device')
-    };
-}
-function decodeSignalRegistrationRow(row) {
-    return {
-        registrationId: (0, coercion_1.asNumber)(row.registration_id, 'signal_registration.registration_id'),
-        identityKeyPair: {
-            pubKey: (0, coercion_1.asBytes)(row.identity_pub_key, 'signal_registration.identity_pub_key'),
-            privKey: (0, coercion_1.asBytes)(row.identity_priv_key, 'signal_registration.identity_priv_key')
-        }
-    };
-}
-function decodeSignalPreKeyRow(row) {
-    return {
-        keyId: (0, coercion_1.asNumber)(row.key_id, 'signal_prekey.key_id'),
-        keyPair: {
-            pubKey: (0, coercion_1.asBytes)(row.pub_key, 'signal_prekey.pub_key'),
-            privKey: (0, coercion_1.asBytes)(row.priv_key, 'signal_prekey.priv_key')
-        },
-        uploaded: (0, coercion_1.toBoolOrUndef)(row.uploaded)
-    };
-}
-function decodeSignalSignedPreKeyRow(row) {
-    return {
-        keyId: (0, coercion_1.asNumber)(row.key_id, 'signal_signed_prekey.key_id'),
-        keyPair: {
-            pubKey: (0, coercion_1.asBytes)(row.pub_key, 'signal_signed_prekey.pub_key'),
-            privKey: (0, coercion_1.asBytes)(row.priv_key, 'signal_signed_prekey.priv_key')
-        },
-        signature: (0, coercion_1.asBytes)(row.signature, 'signal_signed_prekey.signature'),
-        uploaded: (0, coercion_1.toBoolOrUndef)(row.uploaded)
-    };
-}
-function encodeSignalSessionSnapshot(session) {
-    return {
-        sessionVersion: 3,
-        localRegistrationId: session.local.regId,
-        localIdentityPublic: session.local.pubKey,
-        remoteRegistrationId: session.remote.regId,
-        remoteIdentityPublic: session.remote.pubKey,
-        rootKey: session.rootKey,
-        previousCounter: session.prevSendChainHighestIndex,
-        senderChain: encodeSignalSendChain(session.sendChain),
-        receiverChains: session.recvChains,
-        pendingPreKey: session.initialExchangeInfo
-            ? {
-                preKeyId: session.initialExchangeInfo.remoteOneTimeId ?? undefined,
-                signedPreKeyId: session.initialExchangeInfo.remoteSignedId,
-                baseKey: session.initialExchangeInfo.localOneTimePubKey
-            }
-            : undefined,
-        aliceBaseKey: session.aliceBaseKey ?? undefined
-    };
-}
-function encodeSignalSendChain(chain) {
-    return {
-        senderRatchetKey: chain.ratchetKey.pubKey,
-        senderRatchetKeyPrivate: chain.ratchetKey.privKey,
-        chainKey: {
-            index: chain.nextMsgIndex,
-            key: chain.chainKey
-        },
-        messageKeys: []
-    };
-}
-function encodeSignalRecvChain(chain) {
-    return {
-        senderRatchetKey: chain.ratchetPubKey,
-        chainKey: {
-            index: chain.nextMsgIndex,
-            key: chain.chainKey
-        },
-        messageKeys: chain.unusedMsgKeys
-    };
-}
-function decodeSignalMessageKey(messageKey, field) {
-    const cipherKey = (0, coercion_1.asBytes)(messageKey.cipherKey, `${field}.cipherKey`);
-    (0, bytes_1.assertByteLength)(cipherKey, 32, `invalid ${field}.cipherKey length ${cipherKey.byteLength}`);
-    const macKey = (0, coercion_1.asBytes)(messageKey.macKey, `${field}.macKey`);
-    (0, bytes_1.assertByteLength)(macKey, 32, `invalid ${field}.macKey length ${macKey.byteLength}`);
-    const iv = (0, coercion_1.asBytes)(messageKey.iv, `${field}.iv`);
-    (0, bytes_1.assertByteLength)(iv, 16, `invalid ${field}.iv length ${iv.byteLength}`);
-    return {
-        index: (0, coercion_1.asNumber)(messageKey.index, `${field}.index`),
-        cipherKey,
-        macKey,
-        iv
-    };
-}
-function decodeSignalRecvChain(chain, field) {
-    const chainKey = chain.chainKey;
-    if (!chainKey) {
-        throw new Error(`missing ${field}.chainKey`);
-    }
-    const ratchetPubKey = (0, coercion_1.asBytes)(chain.senderRatchetKey, `${field}.senderRatchetKey`);
-    (0, bytes_1.assertByteLength)(ratchetPubKey, 33, `invalid ${field}.senderRatchetKey length ${ratchetPubKey.byteLength}`);
-    const chainKeyBytes = (0, coercion_1.asBytes)(chainKey.key, `${field}.chainKey.key`);
-    (0, bytes_1.assertByteLength)(chainKeyBytes, 32, `invalid ${field}.chainKey.key length ${chainKeyBytes.byteLength}`);
-    return {
-        ratchetPubKey,
-        nextMsgIndex: (0, coercion_1.asNumber)(chainKey.index, `${field}.chainKey.index`),
-        chainKey: chainKeyBytes,
-        unusedMsgKeys: chain.messageKeys ?? []
-    };
-}
-function decodeSignalSendChain(chain, field) {
-    const chainKey = chain.chainKey;
-    if (!chainKey) {
-        throw new Error(`missing ${field}.chainKey`);
-    }
-    const privateKey = (0, coercion_1.asOptionalBytes)(chain.senderRatchetKeyPrivate, `${field}.senderRatchetKeyPrivate`);
-    if (!privateKey) {
-        throw new Error(`missing ${field}.senderRatchetKeyPrivate`);
-    }
-    (0, bytes_1.assertByteLength)(privateKey, 32, `invalid ${field}.senderRatchetKeyPrivate length ${privateKey.byteLength}`);
-    const ratchetPubKey = (0, coercion_1.asBytes)(chain.senderRatchetKey, `${field}.senderRatchetKey`);
-    (0, bytes_1.assertByteLength)(ratchetPubKey, 33, `invalid ${field}.senderRatchetKey length ${ratchetPubKey.byteLength}`);
-    const chainKeyBytes = (0, coercion_1.asBytes)(chainKey.key, `${field}.chainKey.key`);
-    (0, bytes_1.assertByteLength)(chainKeyBytes, 32, `invalid ${field}.chainKey.key length ${chainKeyBytes.byteLength}`);
-    return {
-        ratchetKey: {
-            pubKey: ratchetPubKey,
-            privKey: privateKey
-        },
-        nextMsgIndex: (0, coercion_1.asNumber)(chainKey.index, `${field}.chainKey.index`),
-        chainKey: chainKeyBytes
-    };
-}
-function decodeSignalSessionSnapshot(session, field) {
-    const senderChain = session.senderChain;
-    if (!senderChain) {
-        throw new Error(`missing ${field}.senderChain`);
-    }
-    const pendingPreKey = session.pendingPreKey;
-    const localPubKey = (0, coercion_1.asBytes)(session.localIdentityPublic, `${field}.localIdentityPublic`);
-    (0, bytes_1.assertByteLength)(localPubKey, 33, `invalid ${field}.localIdentityPublic length ${localPubKey.byteLength}`);
-    const remotePubKey = (0, coercion_1.asBytes)(session.remoteIdentityPublic, `${field}.remoteIdentityPublic`);
-    (0, bytes_1.assertByteLength)(remotePubKey, 33, `invalid ${field}.remoteIdentityPublic length ${remotePubKey.byteLength}`);
-    const rootKey = (0, coercion_1.asBytes)(session.rootKey, `${field}.rootKey`);
-    (0, bytes_1.assertByteLength)(rootKey, 32, `invalid ${field}.rootKey length ${rootKey.byteLength}`);
-    const localOneTimePubKey = pendingPreKey
-        ? (0, coercion_1.asBytes)(pendingPreKey.baseKey, `${field}.pendingPreKey.baseKey`)
-        : null;
-    if (localOneTimePubKey) {
-        (0, bytes_1.assertByteLength)(localOneTimePubKey, 33, `invalid ${field}.pendingPreKey.baseKey length ${localOneTimePubKey.byteLength}`);
-    }
-    const aliceBaseKey = (0, coercion_1.asOptionalBytes)(session.aliceBaseKey, `${field}.aliceBaseKey`) ?? null;
-    if (aliceBaseKey) {
-        (0, bytes_1.assertByteLength)(aliceBaseKey, 33, `invalid ${field}.aliceBaseKey length ${aliceBaseKey.byteLength}`);
-    }
-    return {
-        local: {
-            regId: (0, coercion_1.asNumber)(session.localRegistrationId, `${field}.localRegistrationId`),
-            pubKey: localPubKey
-        },
-        remote: {
-            regId: (0, coercion_1.asNumber)(session.remoteRegistrationId, `${field}.remoteRegistrationId`),
-            pubKey: remotePubKey
-        },
-        rootKey,
-        sendChain: decodeSignalSendChain(senderChain, `${field}.senderChain`),
-        recvChains: session.receiverChains ?? [],
-        initialExchangeInfo: pendingPreKey
-            ? {
-                remoteOneTimeId: (0, coercion_1.asOptionalNumber)(pendingPreKey.preKeyId, `${field}.pendingPreKey.preKeyId`) ??
-                    null,
-                remoteSignedId: (0, coercion_1.asNumber)(pendingPreKey.signedPreKeyId, `${field}.pendingPreKey.signedPreKeyId`),
-                localOneTimePubKey: localOneTimePubKey
-            }
-            : null,
-        prevSendChainHighestIndex: (0, coercion_1.asOptionalNumber)(session.previousCounter, `${field}.previousCounter`) ?? 0,
-        aliceBaseKey
-    };
-}
-function encodeSignalSessionRecord(record) {
-    return _proto_1.proto.RecordStructure.encode({
-        currentSession: encodeSignalSessionSnapshot(record),
-        previousSessions: record.prevSessions
-    }).finish();
-}
-function decodeSignalSessionRecord(raw) {
-    const decoded = _proto_1.proto.RecordStructure.decode((0, coercion_1.asBytes)(raw, 'signal_sessions.record'));
-    if (!decoded.currentSession) {
-        throw new Error('missing signal_sessions.record.currentSession');
-    }
-    const current = decodeSignalSessionSnapshot(decoded.currentSession, 'signal_sessions.currentSession');
-    return {
-        ...current,
-        prevSessions: decoded.previousSessions ?? []
-    };
-}
-function encodeSenderKeyRecord(record) {
-    return _proto_1.proto.SenderKeyRecordStructure.encode({
-        senderKeyStates: [
-            {
-                senderKeyId: record.keyId,
-                senderChainKey: {
-                    iteration: record.iteration,
-                    seed: record.chainKey
-                },
-                senderSigningKey: {
-                    public: record.signingPublicKey,
-                    private: record.signingPrivateKey
-                },
-                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();
-}
-function decodeSenderKeyState(state, field) {
-    if (!state.senderChainKey) {
-        throw new Error(`missing ${field}.senderChainKey`);
-    }
-    if (!state.senderSigningKey) {
-        throw new Error(`missing ${field}.senderSigningKey`);
-    }
-    return {
-        keyId: (0, coercion_1.asNumber)(state.senderKeyId, `${field}.senderKeyId`),
-        iteration: (0, coercion_1.asNumber)(state.senderChainKey.iteration, `${field}.senderChainKey.iteration`),
-        chainKey: (0, coercion_1.asBytes)(state.senderChainKey.seed, `${field}.senderChainKey.seed`),
-        signingPublicKey: (0, coercion_1.asBytes)(state.senderSigningKey.public, `${field}.senderSigningKey.public`),
-        signingPrivateKey: state.senderSigningKey.private !== null && state.senderSigningKey.private !== undefined
-            ? (0, coercion_1.asBytes)(state.senderSigningKey.private, `${field}.senderSigningKey.private`)
-            : undefined,
-        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: (0, coercion_1.asNumber)(messageKey.iteration, `${field}.senderMessageKeys[${i}].iteration`),
-                    seed: (0, coercion_1.asBytes)(messageKey.seed, `${field}.senderMessageKeys[${i}].seed`)
-                };
-            }
-            return arr;
-        })()
-    };
-}
-function decodeSenderKeyRecord(raw, groupId, sender) {
-    const decoded = _proto_1.proto.SenderKeyRecordStructure.decode((0, coercion_1.asBytes)(raw, 'sender_keys.record'));
-    const state = decoded.senderKeyStates?.[0];
-    if (!state) {
-        throw new Error('missing sender_keys.record.senderKeyStates[0]');
-    }
-    const parsed = decodeSenderKeyState(state, 'sender_keys.record.senderKeyStates[0]');
-    return {
-        groupId,
-        sender,
-        keyId: parsed.keyId,
-        iteration: parsed.iteration,
-        chainKey: parsed.chainKey,
-        signingPublicKey: parsed.signingPublicKey,
-        signingPrivateKey: parsed.signingPrivateKey,
-        unusedMessageKeys: parsed.unusedMessageKeys
-    };
-}
-function decodeSenderKeyDistributionRow(row) {
-    return {
-        groupId: (0, coercion_1.asString)(row.group_id, 'sender_key_distribution.group_id'),
-        sender: {
-            user: (0, coercion_1.asString)(row.sender_user, 'sender_key_distribution.sender_user'),
-            server: (0, coercion_1.asString)(row.sender_server, 'sender_key_distribution.sender_server'),
-            device: (0, coercion_1.asNumber)(row.sender_device, 'sender_key_distribution.sender_device')
-        },
-        keyId: (0, coercion_1.asNumber)(row.key_id, 'sender_key_distribution.key_id'),
-        timestampMs: (0, coercion_1.asNumber)(row.timestamp_ms, 'sender_key_distribution.timestamp_ms')
-    };
-}
+/**
+ * Reads the `count` field of a single-row SQL `COUNT(*)` result, returning
+ * `0` when the row is missing.
+ */
 function decodeStoreCount(row, field) {
     return row ? (0, coercion_1.asNumber)(row.count, field) : 0;
 }
-function decodeSignalRemoteIdentity(raw) {
-    return (0, coercion_1.asBytes)(raw, 'signal_identity.identity_key');
-}

package/dist/signal/group/SenderKeyChain.js

@@ -5,6 +5,7 @@ exports.deriveSenderKeyMsgKey = deriveSenderKeyMsgKey;
 const _crypto_1 = require("../../crypto/index.js");
 const constants_1 = require("../constants");
 const bytes_1 = require("../../util/bytes");
+// eslint-disable-next-line @typescript-eslint/require-await
 async function selectMessageKey(senderKey, targetIteration, futureMessagesMax) {
     const delta = targetIteration - senderKey.iteration;
     if (delta > (futureMessagesMax ?? constants_1.SENDER_KEY_FUTURE_MESSAGES_MAX)) {
@@ -26,9 +27,9 @@ async function selectMessageKey(senderKey, targetIteration, futureMessagesMax) {
             }
         };
     }
-    let chainState = await createSenderChainState(senderKey.chainKey);
-    const firstDerived = await deriveSenderKeyMsgKeyFromState(senderKey.iteration, chainState);
-    chainState = firstDerived.nextState;
+    let chainKey = ensureChainKey(senderKey.chainKey);
+    const firstDerived = deriveSenderKeyMsgKeyFromChainKey(senderKey.iteration, chainKey);
+    chainKey = firstDerived.nextChainKey;
     let messageKey = firstDerived.messageKey;
     if (delta === 0) {
         return {
@@ -36,7 +37,7 @@ async function selectMessageKey(senderKey, targetIteration, futureMessagesMax) {
             updatedRecord: {
                 ...senderKey,
                 iteration: targetIteration + 1,
-                chainKey: chainState.chainKey,
+                chainKey,
                 unusedMessageKeys: currentUnused
             }
         };
@@ -54,8 +55,8 @@ async function selectMessageKey(senderKey, targetIteration, futureMessagesMax) {
         else {
             nextUnused.push(messageKey);
         }
-        const derived = await deriveSenderKeyMsgKeyFromState(iteration, chainState);
-        chainState = derived.nextState;
+        const derived = deriveSenderKeyMsgKeyFromChainKey(iteration, chainKey);
+        chainKey = derived.nextChainKey;
         messageKey = derived.messageKey;
     }
     return {
@@ -63,41 +64,25 @@ async function selectMessageKey(senderKey, targetIteration, futureMessagesMax) {
         updatedRecord: {
             ...senderKey,
             iteration: targetIteration + 1,
-            chainKey: chainState.chainKey,
+            chainKey,
             unusedMessageKeys: nextUnused
         }
     };
 }
-async function deriveSenderKeyMsgKey(iteration, chainKey) {
-    const state = await createSenderChainState(chainKey);
-    const derived = await deriveSenderKeyMsgKeyFromState(iteration, state);
-    return {
-        nextChainKey: derived.nextState.chainKey,
-        messageKey: derived.messageKey
-    };
+function deriveSenderKeyMsgKey(iteration, chainKey) {
+    return deriveSenderKeyMsgKeyFromChainKey(iteration, ensureChainKey(chainKey));
 }
-async function createSenderChainState(chainKey) {
+function ensureChainKey(chainKey) {
     (0, bytes_1.assertByteLength)(chainKey, 32, 'sender key chainKey must be 32 bytes');
-    return {
-        chainKey,
-        hmacKey: await (0, _crypto_1.importHmacKey)(chainKey)
-    };
+    return chainKey;
 }
-async function deriveSenderKeyMsgKeyFromState(iteration, state) {
-    const [nextChainRaw, messageInputKey] = await Promise.all([
-        (0, _crypto_1.hmacSign)(state.hmacKey, constants_1.CHAIN_KEY_LABEL),
-        (0, _crypto_1.hmacSign)(state.hmacKey, constants_1.MESSAGE_KEY_LABEL)
-    ]);
+function deriveSenderKeyMsgKeyFromChainKey(iteration, chainKey) {
+    const nextChainRaw = (0, _crypto_1.hmacSha256Sign)(chainKey, constants_1.CHAIN_KEY_LABEL);
+    const messageInputKey = (0, _crypto_1.hmacSha256Sign)(chainKey, constants_1.MESSAGE_KEY_LABEL);
     const nextChainKey = nextChainRaw.subarray(0, 32);
-    const [nextHmacKey, messageSeed] = await Promise.all([
-        (0, _crypto_1.importHmacKey)(nextChainKey),
-        (0, _crypto_1.hkdf)(messageInputKey, null, constants_1.WHISPER_GROUP_INFO, 50)
-    ]);
+    const messageSeed = (0, _crypto_1.hkdf)(messageInputKey, null, constants_1.WHISPER_GROUP_INFO, 50);
     return {
-        nextState: {
-            chainKey: nextChainKey,
-            hmacKey: nextHmacKey
-        },
+        nextChainKey,
         messageKey: {
             iteration,
             seed: messageSeed