@zentrix/baileys 4.1.5

package/lib/Signal/Group/sender-key-state.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderKeyState = void 0;
+const sender_chain_key_1 = require("./sender-chain-key");
+const sender_message_key_1 = require("./sender-message-key");
+class SenderKeyState {
+    constructor(id, iteration, chainKey, signatureKeyPair, signatureKeyPublic, signatureKeyPrivate, senderKeyStateStructure) {
+        this.MAX_MESSAGE_KEYS = 2000;
+        if (senderKeyStateStructure) {
+            this.senderKeyStateStructure = senderKeyStateStructure;
+        }
+        else {
+            if (signatureKeyPair) {
+                signatureKeyPublic = signatureKeyPair.public;
+                signatureKeyPrivate = signatureKeyPair.private;
+            }
+            chainKey = typeof chainKey === 'string' ? Buffer.from(chainKey, 'base64') : chainKey;
+            const senderChainKeyStructure = {
+                iteration: iteration || 0,
+                seed: chainKey || Buffer.alloc(0)
+            };
+            const signingKeyStructure = {
+                public: typeof signatureKeyPublic === 'string'
+                    ? Buffer.from(signatureKeyPublic, 'base64')
+                    : signatureKeyPublic || Buffer.alloc(0)
+            };
+            if (signatureKeyPrivate) {
+                signingKeyStructure.private =
+                    typeof signatureKeyPrivate === 'string' ? Buffer.from(signatureKeyPrivate, 'base64') : signatureKeyPrivate;
+            }
+            this.senderKeyStateStructure = {
+                senderKeyId: id || 0,
+                senderChainKey: senderChainKeyStructure,
+                senderSigningKey: signingKeyStructure,
+                senderMessageKeys: []
+            };
+        }
+    }
+    getKeyId() {
+        return this.senderKeyStateStructure.senderKeyId;
+    }
+    getSenderChainKey() {
+        return new sender_chain_key_1.SenderChainKey(this.senderKeyStateStructure.senderChainKey.iteration, this.senderKeyStateStructure.senderChainKey.seed);
+    }
+    setSenderChainKey(chainKey) {
+        this.senderKeyStateStructure.senderChainKey = {
+            iteration: chainKey.getIteration(),
+            seed: chainKey.getSeed()
+        };
+    }
+    getSigningKeyPublic() {
+        const publicKey = this.senderKeyStateStructure.senderSigningKey.public;
+        if (publicKey instanceof Buffer) {
+            return publicKey;
+        }
+        else if (typeof publicKey === 'string') {
+            return Buffer.from(publicKey, 'base64');
+        }
+        return Buffer.from(publicKey || []);
+    }
+    getSigningKeyPrivate() {
+        const privateKey = this.senderKeyStateStructure.senderSigningKey.private;
+        if (!privateKey) {
+            return undefined;
+        }
+        if (privateKey instanceof Buffer) {
+            return privateKey;
+        }
+        else if (typeof privateKey === 'string') {
+            return Buffer.from(privateKey, 'base64');
+        }
+        return Buffer.from(privateKey || []);
+    }
+    hasSenderMessageKey(iteration) {
+        return this.senderKeyStateStructure.senderMessageKeys.some(key => key.iteration === iteration);
+    }
+    addSenderMessageKey(senderMessageKey) {
+        this.senderKeyStateStructure.senderMessageKeys.push({
+            iteration: senderMessageKey.getIteration(),
+            seed: senderMessageKey.getSeed()
+        });
+        if (this.senderKeyStateStructure.senderMessageKeys.length > this.MAX_MESSAGE_KEYS) {
+            this.senderKeyStateStructure.senderMessageKeys.shift();
+        }
+    }
+    removeSenderMessageKey(iteration) {
+        const index = this.senderKeyStateStructure.senderMessageKeys.findIndex(key => key.iteration === iteration);
+        if (index !== -1) {
+            const messageKey = this.senderKeyStateStructure.senderMessageKeys[index];
+            this.senderKeyStateStructure.senderMessageKeys.splice(index, 1);
+            return new sender_message_key_1.SenderMessageKey(messageKey.iteration, messageKey.seed);
+        }
+        return null;
+    }
+    getStructure() {
+        return this.senderKeyStateStructure;
+    }
+}
+exports.SenderKeyState = SenderKeyState;

package/lib/Signal/Group/sender-message-key.d.ts

@@ -0,0 +1,11 @@
+export declare class SenderMessageKey {
+    private readonly iteration;
+    private readonly iv;
+    private readonly cipherKey;
+    private readonly seed;
+    constructor(iteration: number, seed: Uint8Array);
+    getIteration(): number;
+    getIv(): Uint8Array;
+    getCipherKey(): Uint8Array;
+    getSeed(): Uint8Array;
+}

package/lib/Signal/Group/sender-message-key.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderMessageKey = void 0;
+const crypto_1 = require("libsignal/src/crypto");
+class SenderMessageKey {
+    constructor(iteration, seed) {
+        const derivative = (0, crypto_1.deriveSecrets)(seed, Buffer.alloc(32), Buffer.from('WhisperGroup'));
+        const keys = new Uint8Array(32);
+        keys.set(new Uint8Array(derivative[0].slice(16)));
+        keys.set(new Uint8Array(derivative[1].slice(0, 16)), 16);
+        this.iv = Buffer.from(derivative[0].slice(0, 16));
+        this.cipherKey = Buffer.from(keys.buffer);
+        this.iteration = iteration;
+        this.seed = seed;
+    }
+    getIteration() {
+        return this.iteration;
+    }
+    getIv() {
+        return this.iv;
+    }
+    getCipherKey() {
+        return this.cipherKey;
+    }
+    getSeed() {
+        return this.seed;
+    }
+}
+exports.SenderMessageKey = SenderMessageKey;

package/lib/Signal/libsignal.d.ts

@@ -0,0 +1,3 @@
+import { SignalAuthState } from '../Types';
+import { SignalRepository } from '../Types/Signal';
+export declare function makeLibSignalRepository(auth: SignalAuthState): SignalRepository;

package/lib/Signal/libsignal.js

@@ -0,0 +1,336 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLibSignalRepository = makeLibSignalRepository;
+const libsignal = __importStar(require("libsignal"));
+const Utils_1 = require("../Utils");
+const WABinary_1 = require("../WABinary");
+const sender_key_name_1 = require("./Group/sender-key-name");
+const sender_key_record_1 = require("./Group/sender-key-record");
+const Group_1 = require("./Group");
+
+/**
+ * FIX 1: Identity key extraction from PreKeyWhisperMessage.
+ * Allows detecting identity changes BEFORE decryption, preventing Bad MAC errors
+ * caused by stale sessions with a contact who has re-registered or changed devices.
+ */
+function extractIdentityFromPkmsg(ciphertext) {
+    try {
+        if (!ciphertext || ciphertext.length < 2) return undefined;
+        // Version byte check (must be version 3)
+        const version = ciphertext[0];
+        if ((version & 0xf) !== 3) return undefined;
+        // Minimal protobuf parse to extract identityKey field (tag 4, wire type 2)
+        const data = ciphertext.slice(1);
+        let i = 0;
+        while (i < data.length) {
+            const tag = data[i] >> 3;
+            const wireType = data[i] & 0x7;
+            i++;
+            if (wireType === 2) {
+                // length-delimited
+                let len = 0, shift = 0;
+                while (i < data.length) {
+                    const b = data[i++];
+                    len |= (b & 0x7f) << shift;
+                    if (!(b & 0x80)) break;
+                    shift += 7;
+                }
+                if (tag === 4 && len === 33) {
+                    // identityKey field
+                    return new Uint8Array(data.slice(i, i + len));
+                }
+                i += len;
+            } else if (wireType === 0) {
+                // varint - skip
+                while (i < data.length && (data[i++] & 0x80));
+            } else if (wireType === 5) {
+                i += 4;
+            } else if (wireType === 1) {
+                i += 8;
+            } else {
+                break;
+            }
+        }
+        return undefined;
+    } catch {
+        return undefined;
+    }
+}
+
+function makeLibSignalRepository(auth, logger) {
+    const storage = signalStorage(auth, logger);
+
+    return {
+        decryptGroupMessage({ group, authorJid, msg }) {
+            const senderName = jidToSignalSenderKeyName(group, authorJid);
+            const cipher = new Group_1.GroupCipher(storage, senderName);
+            return cipher.decrypt(msg);
+        },
+
+        async processSenderKeyDistributionMessage({ item, authorJid }) {
+            const builder = new Group_1.GroupSessionBuilder(storage);
+            if (!item.groupId) {
+                throw new Error('Group ID is required for sender key distribution message');
+            }
+            const senderName = jidToSignalSenderKeyName(item.groupId, authorJid);
+            const senderMsg = new Group_1.SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage);
+            const senderNameStr = senderName.toString();
+            const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
+            if (!senderKey) {
+                await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
+            }
+            await builder.process(senderName, senderMsg);
+        },
+
+        async decryptMessage({ jid, type, ciphertext }) {
+            const addr = jidToSignalProtocolAddress(jid);
+            const session = new libsignal.SessionCipher(storage, addr);
+
+            /**
+             * FIX 2: Identity key change detection before decryption.
+             * When we receive a pkmsg (PreKey message = new session establishment),
+             * extract and save the sender's identity key FIRST.
+             * If the identity changed (re-registered number), clear old session.
+             * This prevents Bad MAC errors from trying to decrypt with stale keys.
+             */
+            if (type === 'pkmsg') {
+                const identityKey = extractIdentityFromPkmsg(ciphertext);
+                if (identityKey) {
+                    const addrStr = addr.toString();
+                    const identityChanged = await storage.saveIdentity(addrStr, identityKey);
+                    if (identityChanged && logger) {
+                        logger.info({ jid, addr: addrStr }, 'identity key changed, session will be re-established');
+                    }
+                }
+            }
+
+            let result;
+            switch (type) {
+                case 'pkmsg':
+                    result = await session.decryptPreKeyWhisperMessage(ciphertext);
+                    break;
+                case 'msg':
+                    result = await session.decryptWhisperMessage(ciphertext);
+                    break;
+                default:
+                    throw new Error(`Unknown message type: ${type}`);
+            }
+            return result;
+        },
+
+        async encryptMessage({ jid, data }) {
+            const addr = jidToSignalProtocolAddress(jid);
+            const cipher = new libsignal.SessionCipher(storage, addr);
+            const { type: sigType, body } = await cipher.encrypt(data);
+            const type = sigType === 3 ? 'pkmsg' : 'msg';
+            return { type, ciphertext: Buffer.from(body, 'binary') };
+        },
+
+        async encryptGroupMessage({ group, meId, data }) {
+            const senderName = jidToSignalSenderKeyName(group, meId);
+            const builder = new Group_1.GroupSessionBuilder(storage);
+            const senderNameStr = senderName.toString();
+            const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
+            if (!senderKey) {
+                await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
+            }
+            const senderKeyDistributionMessage = await builder.create(senderName);
+            const session = new Group_1.GroupCipher(storage, senderName);
+            const ciphertext = await session.encrypt(data);
+            return {
+                ciphertext,
+                senderKeyDistributionMessage: senderKeyDistributionMessage.serialize()
+            };
+        },
+
+        async injectE2ESession({ jid, session }) {
+            const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid));
+            await cipher.initOutgoing(session);
+        },
+
+        jidToSignalProtocolAddress(jid) {
+            return jidToSignalProtocolAddress(jid).toString();
+        },
+
+        /**
+         * FIX 3: validateSession - check if a valid open session exists for a JID.
+         * Used by the retry system to decide whether to force re-key before retrying.
+         */
+        async validateSession(jid) {
+            try {
+                const addr = jidToSignalProtocolAddress(jid);
+                const sess = await storage.loadSession(addr.toString());
+                if (!sess) return { exists: false, reason: 'no session' };
+                if (!sess.haveOpenSession()) return { exists: false, reason: 'no open session' };
+                return { exists: true };
+            } catch (error) {
+                return { exists: false, reason: 'validation error' };
+            }
+        },
+
+        /**
+         * FIX 4: deleteSession - bulk-delete sessions by JID list.
+         * Used to force re-establishment of broken/corrupt sessions
+         * rather than letting Bad MAC errors loop indefinitely.
+         */
+        async deleteSession(jids) {
+            if (!jids || !jids.length) return;
+            const sessionUpdates = {};
+            jids.forEach(jid => {
+                const addr = jidToSignalProtocolAddress(jid);
+                sessionUpdates[addr.toString()] = null;
+            });
+            await auth.keys.set({ session: sessionUpdates });
+        }
+    };
+}
+
+const jidToSignalProtocolAddress = (jid) => {
+    const { user, device } = (0, WABinary_1.jidDecode)(jid);
+    return new libsignal.ProtocolAddress(user, device || 0);
+};
+
+const jidToSignalSenderKeyName = (group, user) => {
+    return new sender_key_name_1.SenderKeyName(group, jidToSignalProtocolAddress(user));
+};
+
+function signalStorage({ creds, keys }, logger) {
+    return {
+        loadSession: async (id) => {
+            try {
+                const { [id]: sess } = await keys.get('session', [id]);
+                if (sess) {
+                    return libsignal.SessionRecord.deserialize(sess);
+                }
+            } catch (e) {
+                if (logger) logger.warn({ id, err: e }, 'failed to load session, returning null');
+                return null;
+            }
+            return null;
+        },
+
+        storeSession: async (id, session) => {
+            await keys.set({ session: { [id]: session.serialize() } });
+        },
+
+        isTrustedIdentity: () => {
+            return true; // TOFU - Trust on First Use
+        },
+
+        /**
+         * FIX 5: loadIdentityKey - expose identity key loading.
+         * Required for identity change detection in saveIdentity.
+         */
+        loadIdentityKey: async (id) => {
+            const { [id]: key } = await keys.get('identity-key', [id]);
+            return key || undefined;
+        },
+
+        /**
+         * FIX 6: saveIdentity - detect identity key changes.
+         * When a contact re-registers their number, their identity key changes.
+         * Old sessions using the previous key will produce Bad MAC on every message.
+         * This clears the stale session and saves the new key so re-keying happens.
+         */
+        saveIdentity: async (id, identityKey) => {
+            const { [id]: existingKey } = await keys.get('identity-key', [id]);
+            const keysMatch = existingKey &&
+                existingKey.length === identityKey.length &&
+                existingKey.every((byte, i) => byte === identityKey[i]);
+            if (existingKey && !keysMatch) {
+                // Identity changed — clear stale session, save new key
+                if (logger) logger.info({ id }, 'identity key changed, clearing stale session');
+                await keys.set({
+                    session: { [id]: null },
+                    'identity-key': { [id]: identityKey }
+                });
+                return true;
+            }
+            if (!existingKey) {
+                // New contact — TOFU
+                await keys.set({ 'identity-key': { [id]: identityKey } });
+                return true;
+            }
+            return false;
+        },
+
+        loadPreKey: async (id) => {
+            const keyId = id.toString();
+            const { [keyId]: key } = await keys.get('pre-key', [keyId]);
+            if (key) {
+                return {
+                    privKey: Buffer.from(key.private),
+                    pubKey: Buffer.from(key.public)
+                };
+            }
+        },
+
+        removePreKey: (id) => keys.set({ 'pre-key': { [id]: null } }),
+
+        loadSignedPreKey: () => {
+            const key = creds.signedPreKey;
+            return {
+                privKey: Buffer.from(key.keyPair.private),
+                pubKey: Buffer.from(key.keyPair.public)
+            };
+        },
+
+        loadSenderKey: async (senderKeyName) => {
+            const keyId = senderKeyName.toString();
+            const { [keyId]: key } = await keys.get('sender-key', [keyId]);
+            if (key) {
+                return sender_key_record_1.SenderKeyRecord.deserialize(key);
+            }
+            return new sender_key_record_1.SenderKeyRecord();
+        },
+
+        storeSenderKey: async (senderKeyName, key) => {
+            const keyId = senderKeyName.toString();
+            const serialized = JSON.stringify(key.serialize());
+            await keys.set({ 'sender-key': { [keyId]: Buffer.from(serialized, 'utf-8') } });
+        },
+
+        getOurRegistrationId: () => creds.registrationId,
+
+        getOurIdentity: () => {
+            const { signedIdentityKey } = creds;
+            return {
+                privKey: Buffer.from(signedIdentityKey.private),
+                pubKey: (0, Utils_1.generateSignalPubKey)(signedIdentityKey.public)
+            };
+        }
+    };
+}