zapo-js 0.1.2 → 0.3.0

package/dist/signal/crypto/WaAdvSignature.js

@@ -1,16 +1,10 @@
 "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");
@@ -18,51 +12,15 @@ Object.defineProperty(exports, "ADV_PREFIX_ACCOUNT_SIGNATURE", { enumerable: tru
 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 (!(0, bytes_1.assertByteLength)(signature, 64, 'invalid signal signature length', false)) {
-        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) {
-    (0, bytes_1.assertByteLength)(privateKey, 32, `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);
+    return (0, _crypto_1.xeddsaVerify)((0, _crypto_1.toRawPubKey)(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);
+    return (0, _crypto_1.xeddsaSign)(identityKeyPair.privKey, message);
 }
 async function computeAdvIdentityHmac(secretKey, details) {
     const key = await (0, _crypto_1.importHmacKey)(secretKey);

package/dist/signal/crypto/constants.js

@@ -1,10 +1,6 @@
 "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_HOSTED_DEVICE_SIGNATURE = exports.ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE = exports.ADV_PREFIX_DEVICE_SIGNATURE = exports.ADV_PREFIX_ACCOUNT_SIGNATURE = void 0;
 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]);

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

@@ -5,17 +5,22 @@ 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.decodeSqliteCount = decodeSqliteCount;
+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");
+const _proto_1 = require("../proto.js");
+const constants_1 = require("../protocol/constants");
+const bytes_1 = require("../util/bytes");
+const coercion_1 = require("../util/coercion");
 function toSignalAddressParts(address) {
     return {
         user: address.user,
@@ -70,7 +75,7 @@ function encodeSignalSessionSnapshot(session) {
         rootKey: session.rootKey,
         previousCounter: session.prevSendChainHighestIndex,
         senderChain: encodeSignalSendChain(session.sendChain),
-        receiverChains: session.recvChains.map((chain) => encodeSignalRecvChain(chain)),
+        receiverChains: session.recvChains,
         pendingPreKey: session.initialExchangeInfo
             ? {
                 preKeyId: session.initialExchangeInfo.remoteOneTimeId ?? undefined,
@@ -99,12 +104,7 @@ 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: chain.unusedMsgKeys
     };
 }
 function decodeSignalMessageKey(messageKey, field) {
@@ -134,7 +134,7 @@ function decodeSignalRecvChain(chain, field) {
         ratchetPubKey,
         nextMsgIndex: (0, coercion_1.asNumber)(chainKey.index, `${field}.chainKey.index`),
         chainKey: chainKeyBytes,
-        unusedMsgKeys: (chain.messageKeys ?? []).map((messageKey, index) => decodeSignalMessageKey(messageKey, `${field}.messageKeys[${index}]`))
+        unusedMsgKeys: chain.messageKeys ?? []
     };
 }
 function decodeSignalSendChain(chain, field) {
@@ -193,7 +193,7 @@ function decodeSignalSessionSnapshot(session, field) {
         },
         rootKey,
         sendChain: decodeSignalSendChain(senderChain, `${field}.senderChain`),
-        recvChains: (session.receiverChains ?? []).map((chain, index) => decodeSignalRecvChain(chain, `${field}.receiverChains[${index}]`)),
+        recvChains: session.receiverChains ?? [],
         initialExchangeInfo: pendingPreKey
             ? {
                 remoteOneTimeId: (0, coercion_1.asOptionalNumber)(pendingPreKey.preKeyId, `${field}.pendingPreKey.preKeyId`) ??
@@ -209,7 +209,7 @@ function decodeSignalSessionSnapshot(session, field) {
 function encodeSignalSessionRecord(record) {
     return _proto_1.proto.RecordStructure.encode({
         currentSession: encodeSignalSessionSnapshot(record),
-        previousSessions: record.prevSessions.map((session) => encodeSignalSessionSnapshot(session))
+        previousSessions: record.prevSessions
     }).finish();
 }
 function decodeSignalSessionRecord(raw) {
@@ -220,7 +220,7 @@ 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: decoded.previousSessions ?? []
     };
 }
 function encodeSenderKeyRecord(record) {
@@ -236,10 +236,18 @@ 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();
@@ -259,10 +267,18 @@ function decodeSenderKeyState(state, field) {
         signingPrivateKey: state.senderSigningKey.private !== null && state.senderSigningKey.private !== undefined
             ? (0, coercion_1.asBytes)(state.senderSigningKey.private, `${field}.senderSigningKey.private`)
             : undefined,
-        unusedMessageKeys: (state.senderMessageKeys ?? []).map((messageKey, index) => ({
-            iteration: (0, coercion_1.asNumber)(messageKey.iteration, `${field}.senderMessageKeys[${index}].iteration`),
-            seed: (0, coercion_1.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: (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) {
@@ -295,7 +311,7 @@ function decodeSenderKeyDistributionRow(row) {
         timestampMs: (0, coercion_1.asNumber)(row.timestamp_ms, 'sender_key_distribution.timestamp_ms')
     };
 }
-function decodeSqliteCount(row, field) {
+function decodeStoreCount(row, field) {
     return row ? (0, coercion_1.asNumber)(row.count, field) : 0;
 }
 function decodeSignalRemoteIdentity(raw) {

package/dist/signal/group/SenderKeyChain.js

@@ -5,9 +5,9 @@ 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) {
+async function selectMessageKey(senderKey, targetIteration, futureMessagesMax) {
     const delta = targetIteration - senderKey.iteration;
-    if (delta > constants_1.SENDER_KEY_FUTURE_MESSAGES_MAX) {
+    if (delta > (futureMessagesMax ?? constants_1.SENDER_KEY_FUTURE_MESSAGES_MAX)) {
         throw new Error('sender key message is too far in future');
     }
     const currentUnused = senderKey.unusedMessageKeys ?? [];

package/dist/signal/group/SenderKeyCodec.js

@@ -4,10 +4,11 @@ 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 constants_1 = require("../api/constants");
+const constants_2 = 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 body = (0, _crypto_1.readVersionedContent)(payload, constants_2.SIGNAL_GROUP_VERSION, 0);
     const decoded = _proto_1.proto.SenderKeyDistributionMessage.decode(body);
     if (decoded.id === null ||
         decoded.id === undefined ||
@@ -19,17 +20,16 @@ function parseDistributionPayload(payload) {
         decoded.signingKey === undefined) {
         throw new Error('invalid sender key distribution message');
     }
-    const chainKey = (0, bytes_1.toBytesView)(decoded.chainKey);
-    (0, bytes_1.assertByteLength)(chainKey, 32, 'sender key distribution chainKey must be 32 bytes');
+    (0, bytes_1.assertByteLength)(decoded.chainKey, 32, '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))
+        chainKey: decoded.chainKey,
+        signingPublicKey: (0, _crypto_1.toSerializedPubKey)(decoded.signingKey)
     };
 }
 function parseSenderKeyMessage(versionContentMac) {
-    const body = (0, _crypto_1.readVersionedContent)(versionContentMac, constants_1.SIGNAL_GROUP_VERSION, constants_1.SIGNATURE_SIZE);
+    const body = (0, _crypto_1.readVersionedContent)(versionContentMac, constants_2.SIGNAL_GROUP_VERSION, constants_1.SIGNAL_SIGNATURE_LENGTH);
     const decoded = _proto_1.proto.SenderKeyMessage.decode(body);
     if (decoded.id === null ||
         decoded.id === undefined ||
@@ -42,7 +42,7 @@ function parseSenderKeyMessage(versionContentMac) {
     return {
         keyId: decoded.id,
         iteration: decoded.iteration,
-        ciphertext: (0, bytes_1.toBytesView)(decoded.ciphertext),
+        ciphertext: decoded.ciphertext,
         versionContentMac
     };
 }

package/dist/signal/group/SenderKeyManager.js

@@ -2,9 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SenderKeyManager = void 0;
 const _crypto_1 = require("../../crypto/index.js");
+const StoreLock_1 = require("../../infra/perf/StoreLock");
 const _proto_1 = require("../../proto.js");
-const constants_1 = require("../constants");
-const WaAdvSignature_1 = require("../crypto/WaAdvSignature");
+const jid_1 = require("../../protocol/jid");
+const constants_1 = require("../api/constants");
+const constants_2 = require("../constants");
 const SenderKeyChain_1 = require("../group/SenderKeyChain");
 const SenderKeyCodec_1 = require("../group/SenderKeyCodec");
 const bytes_1 = require("../../util/bytes");
@@ -26,144 +28,161 @@ async function aesCbcDecryptFromSeed(seed, ciphertext) {
     return (0, _crypto_1.aesCbcDecrypt)(await (0, _crypto_1.importAesCbcKey)(keyBytes), iv, ciphertext);
 }
 class SenderKeyManager {
-    constructor(store) {
+    constructor(store, options) {
+        this.senderLock = new StoreLock_1.StoreLock();
         this.store = store;
+        this.getFutureMessagesMax = options?.getFutureMessagesMax;
+        this.skipSignatureVerification = options?.skipSignatureVerification === true;
     }
-    async createSenderKeyDistributionMessage(groupId, sender) {
-        const senderKey = await this.ensureSenderKey(groupId, sender);
-        const distributionProto = _proto_1.proto.SenderKeyDistributionMessage.encode({
-            id: senderKey.keyId,
-            iteration: senderKey.iteration,
-            chainKey: senderKey.chainKey,
-            signingKey: senderKey.signingPublicKey
-        }).finish();
-        const payload = (0, _crypto_1.prependVersion)(distributionProto, constants_1.SIGNAL_GROUP_VERSION);
-        await this.store.upsertSenderKeyDistribution({
-            groupId,
-            sender,
-            keyId: senderKey.keyId,
-            timestampMs: Date.now()
+    async prepareGroupEncryption(groupId, sender, plaintext) {
+        return this.runWithSenderLock(groupId, sender, async () => {
+            const senderKey = await this.ensureSenderKeyInternal(groupId, sender);
+            if (!senderKey.signingPrivateKey) {
+                throw new Error('sender private signing key is missing');
+            }
+            const derived = await (0, SenderKeyChain_1.deriveSenderKeyMsgKey)(senderKey.iteration, senderKey.chainKey);
+            await this.store.upsertSenderKey({
+                ...senderKey,
+                chainKey: derived.nextChainKey,
+                iteration: derived.messageKey.iteration + 1
+            });
+            const distributionProto = _proto_1.proto.SenderKeyDistributionMessage.encode({
+                id: senderKey.keyId,
+                iteration: senderKey.iteration,
+                chainKey: senderKey.chainKey,
+                signingKey: senderKey.signingPublicKey
+            }).finish();
+            const distributionMessage = {
+                groupId,
+                axolotlSenderKeyDistributionMessage: (0, _crypto_1.prependVersion)(distributionProto, constants_2.SIGNAL_GROUP_VERSION)
+            };
+            const messagePayload = await aesCbcEncryptFromSeed(derived.messageKey.seed, plaintext);
+            const senderKeyMessage = _proto_1.proto.SenderKeyMessage.encode({
+                id: senderKey.keyId,
+                iteration: derived.messageKey.iteration,
+                ciphertext: messagePayload
+            }).finish();
+            const versionedContent = (0, _crypto_1.prependVersion)(senderKeyMessage, constants_2.SIGNAL_GROUP_VERSION);
+            const signature = await (0, _crypto_1.xeddsaSign)(senderKey.signingPrivateKey, versionedContent);
+            if (signature.length !== constants_1.SIGNAL_SIGNATURE_LENGTH) {
+                throw new Error(`invalid sender key signature length ${signature.length}`);
+            }
+            const ciphertext = {
+                groupId,
+                sender,
+                keyId: senderKey.keyId,
+                iteration: derived.messageKey.iteration,
+                ciphertext: (0, bytes_1.concatBytes)([versionedContent, signature])
+            };
+            await this.store.upsertSenderKeyDistribution({
+                groupId,
+                sender,
+                keyId: senderKey.keyId,
+                timestampMs: Date.now()
+            });
+            return {
+                distributionMessage,
+                ciphertext,
+                keyId: senderKey.keyId
+            };
         });
-        return {
-            groupId,
-            axolotlSenderKeyDistributionMessage: payload
-        };
     }
-    async filterParticipantsNeedingDistribution(groupId, sender, participants) {
+    async filterParticipantsNeedingDistribution(groupId, senderKeyId, participants) {
         if (participants.length === 0) {
             return [];
         }
-        const senderKey = await this.ensureSenderKey(groupId, sender);
         const distributed = await this.store.getDeviceSenderKeyDistributions(groupId, participants);
-        return participants.filter((_, index) => {
+        const pendingParticipants = new Array(participants.length);
+        let pendingCount = 0;
+        for (let index = 0; index < participants.length; index += 1) {
             const record = distributed[index];
-            return !record || record.keyId !== senderKey.keyId;
-        });
+            if (!record || record.keyId !== senderKeyId) {
+                pendingParticipants[pendingCount] = participants[index];
+                pendingCount += 1;
+            }
+        }
+        pendingParticipants.length = pendingCount;
+        return pendingParticipants;
     }
-    async markSenderKeyDistributed(groupId, sender, participants) {
+    async markSenderKeyDistributed(groupId, senderKeyId, participants) {
         if (participants.length === 0) {
             return;
         }
-        const senderKey = await this.ensureSenderKey(groupId, sender);
         const timestampMs = Date.now();
         const distributions = new Array(participants.length);
         for (let index = 0; index < participants.length; index += 1) {
             distributions[index] = {
                 groupId,
                 sender: participants[index],
-                keyId: senderKey.keyId,
+                keyId: senderKeyId,
                 timestampMs
             };
         }
         await this.store.upsertSenderKeyDistributions(distributions);
     }
     async processSenderKeyDistributionPayload(groupId, sender, payload) {
-        if (groupId.length === 0) {
-            throw new Error('sender key distribution missing groupId');
-        }
-        const parsed = (0, SenderKeyCodec_1.parseDistributionPayload)(payload);
-        const record = {
-            groupId,
-            sender,
-            keyId: parsed.keyId,
-            iteration: parsed.iteration,
-            chainKey: parsed.chainKey,
-            signingPublicKey: parsed.signingPublicKey,
-            unusedMessageKeys: []
-        };
-        await Promise.all([
-            this.store.upsertSenderKey(record),
-            this.store.upsertSenderKeyDistribution({
+        return this.runWithSenderLock(groupId, sender, async () => {
+            if (groupId.length === 0) {
+                throw new Error('sender key distribution missing groupId');
+            }
+            const parsed = (0, SenderKeyCodec_1.parseDistributionPayload)(payload);
+            const record = {
                 groupId,
                 sender,
                 keyId: parsed.keyId,
-                timestampMs: Date.now()
-            })
-        ]);
-        return record;
-    }
-    async encryptGroupMessage(groupId, sender, plaintext) {
-        const senderKey = await this.ensureSenderKey(groupId, sender);
-        if (!senderKey.signingPrivateKey) {
-            throw new Error('sender private signing key is missing');
-        }
-        const derived = await (0, SenderKeyChain_1.deriveSenderKeyMsgKey)(senderKey.iteration, senderKey.chainKey);
-        const messagePayload = await aesCbcEncryptFromSeed(derived.messageKey.seed, plaintext);
-        const senderKeyMessage = _proto_1.proto.SenderKeyMessage.encode({
-            id: senderKey.keyId,
-            iteration: derived.messageKey.iteration,
-            ciphertext: messagePayload
-        }).finish();
-        const versionedContent = (0, _crypto_1.prependVersion)(senderKeyMessage, constants_1.SIGNAL_GROUP_VERSION);
-        const signature = await (0, WaAdvSignature_1.signSignalMessage)(senderKey.signingPrivateKey, versionedContent);
-        if (signature.length !== constants_1.SIGNATURE_SIZE) {
-            throw new Error(`invalid sender key signature length ${signature.length}`);
-        }
-        const ciphertext = (0, bytes_1.concatBytes)([versionedContent, signature]);
-        await this.store.upsertSenderKey({
-            ...senderKey,
-            chainKey: derived.nextChainKey,
-            iteration: derived.messageKey.iteration + 1
+                iteration: parsed.iteration,
+                chainKey: parsed.chainKey,
+                signingPublicKey: parsed.signingPublicKey,
+                unusedMessageKeys: []
+            };
+            await Promise.all([
+                this.store.upsertSenderKey(record),
+                this.store.upsertSenderKeyDistribution({
+                    groupId,
+                    sender,
+                    keyId: parsed.keyId,
+                    timestampMs: Date.now()
+                })
+            ]);
+            return record;
         });
-        return {
-            groupId,
-            sender,
-            keyId: senderKey.keyId,
-            iteration: derived.messageKey.iteration,
-            ciphertext
-        };
     }
     async decryptGroupMessage(payload) {
-        const parsed = (0, SenderKeyCodec_1.parseSenderKeyMessage)(payload.ciphertext);
-        const senderKey = await this.store.getDeviceSenderKey(payload.groupId, payload.sender);
-        if (!senderKey) {
-            throw new Error('missing sender key');
-        }
-        if (senderKey.keyId !== parsed.keyId) {
-            throw new Error('sender key id mismatch');
-        }
-        if (payload.keyId !== undefined &&
-            payload.keyId !== null &&
-            parsed.keyId !== payload.keyId) {
-            throw new Error('sender key id mismatch');
-        }
-        if (payload.iteration !== undefined &&
-            payload.iteration !== null &&
-            parsed.iteration !== payload.iteration) {
-            throw new Error('sender key iteration mismatch');
-        }
-        const signedContent = parsed.versionContentMac.subarray(0, parsed.versionContentMac.length - constants_1.SIGNATURE_SIZE);
-        const signature = parsed.versionContentMac.subarray(parsed.versionContentMac.length - constants_1.SIGNATURE_SIZE);
-        const validSignature = await (0, WaAdvSignature_1.verifySignalSignature)(senderKey.signingPublicKey, signedContent, signature);
-        if (!validSignature) {
-            throw new Error('invalid sender key signature');
-        }
-        const selected = await (0, SenderKeyChain_1.selectMessageKey)(senderKey, parsed.iteration);
-        const plaintext = await aesCbcDecryptFromSeed(selected.messageKey.seed, parsed.ciphertext);
-        await this.store.upsertSenderKey(selected.updatedRecord);
-        return plaintext;
+        return this.runWithSenderLock(payload.groupId, payload.sender, async () => {
+            const parsed = (0, SenderKeyCodec_1.parseSenderKeyMessage)(payload.ciphertext);
+            const senderKey = await this.store.getDeviceSenderKey(payload.groupId, payload.sender);
+            if (!senderKey) {
+                throw new Error('missing sender key');
+            }
+            if (senderKey.keyId !== parsed.keyId) {
+                throw new Error('sender key id mismatch');
+            }
+            if (payload.keyId !== undefined &&
+                payload.keyId !== null &&
+                parsed.keyId !== payload.keyId) {
+                throw new Error('sender key id mismatch');
+            }
+            if (payload.iteration !== undefined &&
+                payload.iteration !== null &&
+                parsed.iteration !== payload.iteration) {
+                throw new Error('sender key iteration mismatch');
+            }
+            if (!this.skipSignatureVerification) {
+                const signedContent = parsed.versionContentMac.subarray(0, parsed.versionContentMac.length - constants_1.SIGNAL_SIGNATURE_LENGTH);
+                const signature = parsed.versionContentMac.subarray(parsed.versionContentMac.length - constants_1.SIGNAL_SIGNATURE_LENGTH);
+                const validSignature = await (0, _crypto_1.xeddsaVerify)((0, _crypto_1.toRawPubKey)(senderKey.signingPublicKey), signedContent, signature);
+                if (!validSignature) {
+                    throw new Error('invalid sender key signature');
+                }
+            }
+            const selected = await (0, SenderKeyChain_1.selectMessageKey)(senderKey, parsed.iteration, this.getFutureMessagesMax?.());
+            // Keep decrypt + persist ordered: failed decrypt must not advance sender-key state.
+            const plaintext = await aesCbcDecryptFromSeed(selected.messageKey.seed, parsed.ciphertext);
+            await this.store.upsertSenderKey(selected.updatedRecord);
+            return plaintext;
+        });
     }
-    async ensureSenderKey(groupId, sender) {
+    async ensureSenderKeyInternal(groupId, sender) {
         const existing = await this.store.getDeviceSenderKey(groupId, sender);
         if (existing) {
             return existing;
@@ -186,5 +205,8 @@ class SenderKeyManager {
         await this.store.upsertSenderKey(created);
         return created;
     }
+    runWithSenderLock(groupId, sender, task) {
+        return this.senderLock.run(`senderKey:${groupId}:${(0, jid_1.signalAddressKey)(sender)}`, task);
+    }
 }
 exports.SenderKeyManager = SenderKeyManager;

package/dist/signal/index.js

@@ -1,6 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSignalSessionResolver = exports.SignalProtocol = exports.createAndStoreInitialKeys = exports.SenderKeyManager = exports.SignalSessionSyncApi = exports.SignalRotateKeyApi = exports.SignalMissingPreKeysSyncApi = exports.SignalIdentitySyncApi = exports.SignalDeviceSyncApi = exports.SignalDigestSyncApi = exports.parsePreKeyUploadFailure = exports.buildPreKeyUploadIq = exports.generateSignedPreKey = exports.generateRegistrationInfo = exports.generateRegistrationId = exports.generatePreKeyPair = void 0;
+exports.createSignalSessionResolver = exports.SignalProtocol = exports.createAndStoreInitialKeys = exports.SenderKeyManager = exports.SignalSessionSyncApi = exports.SignalRotateKeyApi = exports.SignalMissingPreKeysSyncApi = exports.SignalIdentitySyncApi = exports.SignalDeviceSyncApi = exports.SignalDigestSyncApi = exports.parsePreKeyUploadFailure = exports.buildPreKeyUploadIq = exports.generateSignedPreKey = exports.generateRegistrationInfo = exports.generateRegistrationId = exports.generatePreKeyPair = exports.toSignalAddressParts = exports.encodeSignalSessionRecord = exports.encodeSenderKeyRecord = exports.decodeStoreCount = exports.decodeSenderKeyRecord = exports.decodeSenderKeyDistributionRow = exports.decodeSignalSignedPreKeyRow = exports.decodeSignalSessionRecord = exports.decodeSignalRemoteIdentity = exports.decodeSignalRegistrationRow = exports.decodeSignalPreKeyRow = void 0;
+var encoding_1 = require("./encoding");
+Object.defineProperty(exports, "decodeSignalPreKeyRow", { enumerable: true, get: function () { return encoding_1.decodeSignalPreKeyRow; } });
+Object.defineProperty(exports, "decodeSignalRegistrationRow", { enumerable: true, get: function () { return encoding_1.decodeSignalRegistrationRow; } });
+Object.defineProperty(exports, "decodeSignalRemoteIdentity", { enumerable: true, get: function () { return encoding_1.decodeSignalRemoteIdentity; } });
+Object.defineProperty(exports, "decodeSignalSessionRecord", { enumerable: true, get: function () { return encoding_1.decodeSignalSessionRecord; } });
+Object.defineProperty(exports, "decodeSignalSignedPreKeyRow", { enumerable: true, get: function () { return encoding_1.decodeSignalSignedPreKeyRow; } });
+Object.defineProperty(exports, "decodeSenderKeyDistributionRow", { enumerable: true, get: function () { return encoding_1.decodeSenderKeyDistributionRow; } });
+Object.defineProperty(exports, "decodeSenderKeyRecord", { enumerable: true, get: function () { return encoding_1.decodeSenderKeyRecord; } });
+Object.defineProperty(exports, "decodeStoreCount", { enumerable: true, get: function () { return encoding_1.decodeStoreCount; } });
+Object.defineProperty(exports, "encodeSenderKeyRecord", { enumerable: true, get: function () { return encoding_1.encodeSenderKeyRecord; } });
+Object.defineProperty(exports, "encodeSignalSessionRecord", { enumerable: true, get: function () { return encoding_1.encodeSignalSessionRecord; } });
+Object.defineProperty(exports, "toSignalAddressParts", { enumerable: true, get: function () { return encoding_1.toSignalAddressParts; } });
 var keygen_1 = require("./registration/keygen");
 Object.defineProperty(exports, "generatePreKeyPair", { enumerable: true, get: function () { return keygen_1.generatePreKeyPair; } });
 Object.defineProperty(exports, "generateRegistrationId", { enumerable: true, get: function () { return keygen_1.generateRegistrationId; } });

package/dist/signal/registration/keygen.js

@@ -7,11 +7,14 @@ exports.generateRegistrationId = generateRegistrationId;
 const _crypto_1 = require("../../crypto/index.js");
 const keys_1 = require("../../crypto/core/keys");
 const X25519_1 = require("../../crypto/curves/X25519");
-const WaAdvSignature_1 = require("../crypto/WaAdvSignature");
 async function generateRegistrationInfo() {
+    const [registrationId, identityKeyPair] = await Promise.all([
+        generateRegistrationId(),
+        X25519_1.X25519.generateKeyPair()
+    ]);
     return {
-        registrationId: await generateRegistrationId(),
-        identityKeyPair: await X25519_1.X25519.generateKeyPair()
+        registrationId,
+        identityKeyPair
     };
 }
 async function generatePreKeyPair(keyId) {
@@ -24,7 +27,7 @@ async function generatePreKeyPair(keyId) {
 async function generateSignedPreKey(keyId, signingPrivateKey) {
     const keyPair = await X25519_1.X25519.generateKeyPair();
     const serializedPubKey = (0, keys_1.toSerializedPubKey)(keyPair.pubKey);
-    const signature = await (0, WaAdvSignature_1.signSignalMessage)(signingPrivateKey, serializedPubKey);
+    const signature = await (0, _crypto_1.xeddsaSign)(signingPrivateKey, serializedPubKey);
     return {
         keyId,
         keyPair,

package/dist/signal/registration/utils.js

@@ -2,15 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAndStoreInitialKeys = createAndStoreInitialKeys;
 const keygen_1 = require("../registration/keygen");
-async function createAndStoreInitialKeys(store) {
+async function createAndStoreInitialKeys(store, preKeyStore) {
     const [registrationInfo, firstPreKey] = await Promise.all([
         (0, keygen_1.generateRegistrationInfo)(),
         (0, keygen_1.generatePreKeyPair)(1)
     ]);
     const signedPreKey = await (0, keygen_1.generateSignedPreKey)(1, registrationInfo.identityKeyPair.privKey);
+    // Keep writes ordered so partial commit failures don't leave split registration bootstrap state.
     await store.setRegistrationInfo(registrationInfo);
     await store.setSignedPreKey(signedPreKey);
-    await store.getOrGenSinglePreKey(async () => firstPreKey);
+    await preKeyStore.getOrGenSinglePreKey(async () => firstPreKey);
     return {
         registrationInfo,
         signedPreKey,