zapo-js 0.1.0

package/dist/signal/api/SignalSessionSyncApi.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignalSessionSyncApi = void 0;
+const constants_1 = require("../../protocol/constants");
+const codec_1 = require("../api/codec");
+const constants_2 = require("../api/constants");
+const helpers_1 = require("../../transport/node/helpers");
+class SignalSessionSyncApi {
+    constructor(options) {
+        this.logger = options.logger;
+        this.query = options.query;
+        this.defaultTimeoutMs =
+            options.defaultTimeoutMs ?? constants_1.WA_DEFAULTS.SIGNAL_FETCH_KEY_BUNDLES_TIMEOUT_MS;
+        this.hostDomain = options.hostDomain ?? constants_1.WA_DEFAULTS.HOST_DOMAIN;
+    }
+    async fetchKeyBundle(target, timeoutMs = this.defaultTimeoutMs) {
+        const results = await this.fetchKeyBundles([target], timeoutMs);
+        const first = results[0];
+        if (!first || !('bundle' in first)) {
+            const errorCode = first && 'errorCode' in first ? (first.errorCode ?? 'unknown') : 'unknown';
+            const errorText = first && 'errorText' in first ? first.errorText : 'unknown';
+            throw new Error(`key bundle user error (${target.jid}): ${errorCode} ${errorText}`);
+        }
+        const parsed = first;
+        this.logger.debug('signal fetch key bundle success', {
+            requestJid: target.jid,
+            responseJid: parsed.jid,
+            hasOneTimeKey: parsed.bundle.oneTimeKey !== undefined,
+            hasDeviceIdentity: parsed.deviceIdentity !== undefined
+        });
+        return parsed;
+    }
+    async fetchKeyBundles(targets, timeoutMs = this.defaultTimeoutMs) {
+        if (targets.length === 0) {
+            return [];
+        }
+        const targetByJid = new Map();
+        for (let index = 0; index < targets.length; index += 1) {
+            const target = targets[index];
+            const previous = targetByJid.get(target.jid);
+            targetByJid.set(target.jid, {
+                jid: target.jid,
+                reasonIdentity: (previous?.reasonIdentity ?? false) || target.reasonIdentity === true
+            });
+        }
+        const mergedTargets = [...targetByJid.values()];
+        this.logger.debug('signal fetch key bundles request', {
+            targets: mergedTargets.length,
+            timeoutMs
+        });
+        const responseNode = await this.query({
+            tag: constants_1.WA_NODE_TAGS.IQ,
+            attrs: {
+                type: constants_1.WA_IQ_TYPES.GET,
+                xmlns: constants_1.WA_XMLNS.SIGNAL,
+                to: this.hostDomain
+            },
+            content: [
+                {
+                    tag: constants_1.WA_NODE_TAGS.KEY,
+                    attrs: {},
+                    content: mergedTargets.map((target) => ({
+                        tag: constants_1.WA_NODE_TAGS.USER,
+                        attrs: {
+                            jid: target.jid,
+                            ...(target.reasonIdentity === true ? { reason: 'identity' } : {})
+                        }
+                    }))
+                }
+            ]
+        }, timeoutMs);
+        return this.parseFetchKeyBundleResponse(responseNode, mergedTargets);
+    }
+    parseFetchKeyBundleResponse(node, requestedTargets) {
+        if (node.tag !== constants_1.WA_NODE_TAGS.IQ) {
+            throw new Error(`invalid key bundle response tag: ${node.tag}`);
+        }
+        if (node.attrs.type === constants_1.WA_IQ_TYPES.ERROR) {
+            const errorNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.ERROR);
+            if (!errorNode) {
+                throw new Error(`key bundle iq error for ${node.attrs.id ?? 'unknown id'}`);
+            }
+            const code = errorNode.attrs.code ?? 'unknown';
+            const text = errorNode.attrs.text ?? errorNode.attrs.type ?? 'unknown';
+            throw new Error(`key bundle iq error (${code} ${text})`);
+        }
+        if (node.attrs.type !== constants_1.WA_IQ_TYPES.RESULT) {
+            throw new Error(`invalid key bundle response type: ${node.attrs.type ?? 'unknown'}`);
+        }
+        const listNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.LIST);
+        if (!listNode) {
+            throw new Error('key bundle response missing list node');
+        }
+        const userNodes = (0, helpers_1.getNodeChildrenByTag)(listNode, constants_1.WA_NODE_TAGS.USER);
+        if (userNodes.length === 0) {
+            throw new Error('key bundle response list is empty');
+        }
+        const parsedByJid = new Map();
+        for (let index = 0; index < userNodes.length; index += 1) {
+            const userNode = userNodes[index];
+            const jid = userNode.attrs.jid;
+            if (!jid) {
+                continue;
+            }
+            const userErrorNode = (0, helpers_1.findNodeChild)(userNode, constants_1.WA_NODE_TAGS.ERROR);
+            if (userErrorNode) {
+                parsedByJid.set(jid, {
+                    jid,
+                    errorCode: userErrorNode.attrs.code,
+                    errorText: userErrorNode.attrs.text ?? 'unknown'
+                });
+                continue;
+            }
+            const parsed = this.parseUserKeyBundle(userNode);
+            parsedByJid.set(jid, {
+                jid,
+                bundle: parsed.bundle,
+                ...(parsed.deviceIdentity ? { deviceIdentity: parsed.deviceIdentity } : {})
+            });
+        }
+        return requestedTargets.map((target) => {
+            const parsed = parsedByJid.get(target.jid);
+            if (parsed) {
+                return parsed;
+            }
+            return {
+                jid: target.jid,
+                errorText: 'missing key bundle user in response'
+            };
+        });
+    }
+    parseUserKeyBundle(node) {
+        const registrationNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.REGISTRATION);
+        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;
+        return {
+            bundle: {
+                regId: registrationId,
+                identity,
+                signedKey: {
+                    id: (0, codec_1.parseUint)(signedIdBytes, 'key bundle skey.id'),
+                    publicKey: signedValue,
+                    signature: signedSignature
+                },
+                ...(oneTimeKey ? { oneTimeKey } : {})
+            },
+            ...(deviceIdentity ? { deviceIdentity } : {})
+        };
+    }
+}
+exports.SignalSessionSyncApi = SignalSessionSyncApi;

package/dist/signal/api/codec.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeExactLength = decodeExactLength;
+exports.parseUint = parseUint;
+const helpers_1 = require("../../transport/node/helpers");
+function decodeExactLength(value, field, expectedLength) {
+    const bytes = (0, helpers_1.decodeNodeContentBase64OrBytes)(value, field);
+    if (bytes.byteLength !== expectedLength) {
+        throw new Error(`${field} must be ${expectedLength} bytes`);
+    }
+    return bytes;
+}
+function parseUint(bytes, field) {
+    if (bytes.byteLength === 1) {
+        return bytes[0];
+    }
+    if (bytes.byteLength === 2) {
+        return (bytes[0] << 8) | bytes[1];
+    }
+    if (bytes.byteLength === 3) {
+        return (bytes[0] << 16) | (bytes[1] << 8) | bytes[2];
+    }
+    if (bytes.byteLength === 4) {
+        return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(0, false);
+    }
+    throw new Error(`${field} has invalid byte length`);
+}

package/dist/signal/api/constants.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SIGNAL_SIGNATURE_LENGTH = exports.SIGNAL_KEY_DATA_LENGTH = exports.SIGNAL_KEY_ID_LENGTH = exports.SIGNAL_REGISTRATION_ID_LENGTH = exports.SIGNAL_KEY_BUNDLE_TYPE_LENGTH = exports.SIGNAL_KEY_BUNDLE_TYPE_BYTES = exports.SIGNAL_SIGNED_PREKEY_SERVER_ERROR_BACKOFF_MS = exports.SIGNAL_SIGNED_PREKEY_ROTATION_INTERVAL_MS = exports.SIGNAL_UPLOAD_PREKEYS_COUNT = void 0;
+exports.SIGNAL_UPLOAD_PREKEYS_COUNT = 812;
+exports.SIGNAL_SIGNED_PREKEY_ROTATION_INTERVAL_MS = 27 * 24 * 60 * 60 * 1000;
+exports.SIGNAL_SIGNED_PREKEY_SERVER_ERROR_BACKOFF_MS = 24 * 60 * 60 * 1000;
+exports.SIGNAL_KEY_BUNDLE_TYPE_BYTES = new Uint8Array([5]);
+exports.SIGNAL_KEY_BUNDLE_TYPE_LENGTH = 1;
+exports.SIGNAL_REGISTRATION_ID_LENGTH = 4;
+exports.SIGNAL_KEY_ID_LENGTH = 3;
+exports.SIGNAL_KEY_DATA_LENGTH = 32;
+exports.SIGNAL_SIGNATURE_LENGTH = 64;

package/dist/signal/api/prekeys.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSignedPreKeyRotateIq = exports.buildPreKeyUploadIq = exports.buildMissingPreKeysFetchIq = void 0;
+exports.parsePreKeyUploadFailure = parsePreKeyUploadFailure;
+const query_1 = require("../../transport/node/query");
+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; } });
+function parsePreKeyUploadFailure(node) {
+    const error = (0, query_1.parseIqError)(node);
+    return {
+        ...(error.numericCode !== undefined ? { errorCode: error.numericCode } : {}),
+        errorText: error.text
+    };
+}

package/dist/signal/constants.js

@@ -0,0 +1,19 @@
+"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.SIGNATURE_SIZE = exports.SIGNAL_MAC_SIZE = exports.KEY_TYPE_CURVE25519 = exports.SERIALIZED_PUB_KEY_PREFIX = exports.SIGNAL_GROUP_VERSION = exports.SIGNAL_VERSION = void 0;
+const constants_1 = require("../crypto/core/constants");
+const bytes_1 = require("../util/bytes");
+exports.SIGNAL_VERSION = 3;
+exports.SIGNAL_GROUP_VERSION = 3;
+exports.SERIALIZED_PUB_KEY_PREFIX = constants_1.SERIALIZED_PUB_KEY_PREFIX;
+exports.KEY_TYPE_CURVE25519 = 5;
+exports.SIGNAL_MAC_SIZE = 8;
+exports.SIGNATURE_SIZE = 64;
+exports.MAX_PREV_SESSIONS = 40;
+exports.MAX_UNUSED_KEYS = 2000;
+exports.FUTURE_MESSAGES_MAX = 2000;
+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.SIGNAL_PREFIX = new Uint8Array(32).fill(0xff);

package/dist/signal/crypto/WaAdvSignature.js

@@ -0,0 +1,72 @@
+"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.verifySignalSignature = verifySignalSignature;
+exports.signSignalMessage = signSignalMessage;
+exports.verifyDeviceIdentityAccountSignature = verifyDeviceIdentityAccountSignature;
+exports.generateDeviceSignature = generateDeviceSignature;
+exports.computeAdvIdentityHmac = computeAdvIdentityHmac;
+const _crypto_1 = require("../../crypto/index.js");
+const X25519_1 = require("../../crypto/curves/X25519");
+const edwards_1 = require("../../crypto/math/edwards");
+const le_1 = require("../../crypto/math/le");
+const mod_1 = require("../../crypto/math/mod");
+const constants_1 = require("../crypto/constants");
+const bytes_1 = require("../../util/bytes");
+var constants_2 = require("../crypto/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 verifySignalSignature(publicKey, message, signature) {
+    if (signature.length !== 64) {
+        return false;
+    }
+    if ((signature[63] & 0x60) !== 0) {
+        return false;
+    }
+    const signalSignature = new Uint8Array(signature);
+    const signBit = signalSignature[63] & 0x80;
+    signalSignature[63] &= 0x7f;
+    const curvePublic = (0, _crypto_1.toRawPubKey)(publicKey);
+    const edPublic = (0, X25519_1.montgomeryToEdwardsPublic)(curvePublic, signBit);
+    return (0, _crypto_1.ed25519VerifyRaw)(edPublic, signalSignature, message);
+}
+async function signSignalMessage(privateKey, message) {
+    if (privateKey.length !== 32) {
+        throw new Error(`invalid curve25519 private key length ${privateKey.length}`);
+    }
+    const clampedPrivateKey = (0, X25519_1.clampCurvePrivateKeyInPlace)(privateKey);
+    const privateScalar = (0, le_1.bytesToBigIntLE)(clampedPrivateKey);
+    const encodedPublic = (0, edwards_1.encodeExtendedPoint)((0, edwards_1.scalarMultBase)(privateScalar));
+    const pubKeySignBit = encodedPublic[31] & 0x80;
+    const randomSuffix = await (0, _crypto_1.randomBytesAsync)(64);
+    const hashInput = (0, bytes_1.concatBytes)([
+        constants_1.SIGNAL_PREFIX_SIGNATURE_RANDOM,
+        clampedPrivateKey,
+        message,
+        randomSuffix
+    ]);
+    const r = (0, mod_1.modGroup)((0, le_1.bytesToBigIntLE)(await (0, _crypto_1.sha512)(hashInput)));
+    const encodedR = (0, edwards_1.encodeExtendedPoint)((0, edwards_1.scalarMultBase)(r));
+    const hInput = (0, bytes_1.concatBytes)([encodedR, encodedPublic, message]);
+    const h = (0, mod_1.modGroup)((0, le_1.bytesToBigIntLE)(await (0, _crypto_1.sha512)(hInput)));
+    const s = (0, mod_1.modGroup)(r + h * privateScalar);
+    const encodedS = (0, le_1.bigIntToBytesLE)(s, 32);
+    encodedS[31] = (encodedS[31] & 0x7f) | pubKeySignBit;
+    return (0, bytes_1.concatBytes)([encodedR, encodedS]);
+}
+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]);
+    return verifySignalSignature(accountSignatureKey, message, accountSignature);
+}
+async function generateDeviceSignature(details, identityKeyPair, accountSignatureKey, isHosted = false) {
+    const prefix = isHosted ? constants_1.ADV_PREFIX_HOSTED_DEVICE_SIGNATURE : constants_1.ADV_PREFIX_DEVICE_SIGNATURE;
+    const message = (0, bytes_1.concatBytes)([prefix, details, identityKeyPair.pubKey, accountSignatureKey]);
+    return signSignalMessage(identityKeyPair.privKey, message);
+}
+async function computeAdvIdentityHmac(secretKey, details) {
+    const key = await (0, _crypto_1.importHmacKey)(secretKey);
+    return (0, _crypto_1.hmacSign)(key, details);
+}

package/dist/signal/crypto/constants.js

@@ -0,0 +1,11 @@
+"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 = exports.SIGNAL_PREFIX_SIGNATURE_RANDOM = void 0;
+exports.SIGNAL_PREFIX_SIGNATURE_RANDOM = new Uint8Array([
+    0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
+]);
+exports.ADV_PREFIX_ACCOUNT_SIGNATURE = new Uint8Array([6, 0]);
+exports.ADV_PREFIX_DEVICE_SIGNATURE = new Uint8Array([6, 1]);
+exports.ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE = new Uint8Array([6, 5]);
+exports.ADV_PREFIX_HOSTED_DEVICE_SIGNATURE = new Uint8Array([6, 6]);

package/dist/signal/group/SenderKeyChain.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectMessageKey = selectMessageKey;
+exports.deriveSenderKeyMsgKey = deriveSenderKeyMsgKey;
+const _crypto_1 = require("../../crypto/index.js");
+const constants_1 = require("../constants");
+const bytes_1 = require("../../util/bytes");
+async function selectMessageKey(senderKey, targetIteration) {
+    const delta = targetIteration - senderKey.iteration;
+    if (delta > constants_1.SENDER_KEY_FUTURE_MESSAGES_MAX) {
+        throw new Error('sender key message is too far in future');
+    }
+    const currentUnused = senderKey.unusedMessageKeys ?? [];
+    if (delta < 0) {
+        const foundIndex = currentUnused.findIndex((entry) => entry.iteration === targetIteration);
+        if (foundIndex === -1) {
+            throw new Error('sender key message iteration is stale');
+        }
+        const messageKey = currentUnused[foundIndex];
+        const nextUnused = (0, bytes_1.removeAt)(currentUnused, foundIndex);
+        return {
+            messageKey,
+            updatedRecord: {
+                ...senderKey,
+                unusedMessageKeys: nextUnused
+            }
+        };
+    }
+    let chainState = await createSenderChainState(senderKey.chainKey);
+    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 - constants_1.MAX_UNUSED_KEYS;
+        if (overflow > 0) {
+            nextUnused = nextUnused.slice(overflow);
+            overflow -= currentUnused.length;
+        }
+        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;
+        }
+    }
+    return {
+        messageKey,
+        updatedRecord: {
+            ...senderKey,
+            iteration: targetIteration + 1,
+            chainKey: chainState.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
+    };
+}
+async function createSenderChainState(chainKey) {
+    if (chainKey.length !== 32) {
+        throw new Error('sender key chainKey must be 32 bytes');
+    }
+    return {
+        chainKey,
+        hmacKey: await (0, _crypto_1.importHmacKey)(chainKey)
+    };
+}
+async function deriveSenderKeyMsgKeyFromState(iteration, state) {
+    const nextChainRawPromise = (0, _crypto_1.hmacSign)(state.hmacKey, constants_1.CHAIN_KEY_LABEL);
+    const messageInputKeyPromise = (0, _crypto_1.hmacSign)(state.hmacKey, constants_1.MESSAGE_KEY_LABEL);
+    const [nextChainRaw, messageInputKey] = await Promise.all([
+        nextChainRawPromise,
+        messageInputKeyPromise
+    ]);
+    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)
+    ]);
+    return {
+        nextState: {
+            chainKey: nextChainKey,
+            hmacKey: nextHmacKey
+        },
+        messageKey: {
+            iteration,
+            seed: messageSeed
+        }
+    };
+}

package/dist/signal/group/SenderKeyCodec.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDistributionPayload = parseDistributionPayload;
+exports.parseSenderKeyMessage = parseSenderKeyMessage;
+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 parseDistributionPayload(payload) {
+    const body = (0, _crypto_1.readVersionedContent)(payload, constants_1.SIGNAL_GROUP_VERSION, 0);
+    const decoded = _proto_1.proto.SenderKeyDistributionMessage.decode(body);
+    if (decoded.id === null ||
+        decoded.id === undefined ||
+        decoded.iteration === null ||
+        decoded.iteration === undefined ||
+        decoded.chainKey === null ||
+        decoded.chainKey === undefined ||
+        decoded.signingKey === null ||
+        decoded.signingKey === undefined) {
+        throw new Error('invalid sender key distribution message');
+    }
+    const chainKey = (0, bytes_1.toBytesView)(decoded.chainKey);
+    if (chainKey.length !== 32) {
+        throw new Error('sender key distribution chainKey must be 32 bytes');
+    }
+    return {
+        keyId: decoded.id,
+        iteration: decoded.iteration,
+        chainKey,
+        signingPublicKey: (0, _crypto_1.toSerializedPubKey)((0, bytes_1.toBytesView)(decoded.signingKey))
+    };
+}
+function parseSenderKeyMessage(versionContentMac) {
+    const body = (0, _crypto_1.readVersionedContent)(versionContentMac, constants_1.SIGNAL_GROUP_VERSION, constants_1.SIGNATURE_SIZE);
+    const decoded = _proto_1.proto.SenderKeyMessage.decode(body);
+    if (decoded.id === null ||
+        decoded.id === undefined ||
+        decoded.iteration === null ||
+        decoded.iteration === undefined ||
+        decoded.ciphertext === null ||
+        decoded.ciphertext === undefined) {
+        throw new Error('invalid sender key message');
+    }
+    return {
+        keyId: decoded.id,
+        iteration: decoded.iteration,
+        ciphertext: (0, bytes_1.toBytesView)(decoded.ciphertext),
+        versionContentMac
+    };
+}