@leonoremods/baileys 0.0.0-stage → 1.2.9

package/src/Signal/Group/group_cipher.js

@@ -0,0 +1,82 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.GroupCipher = void 0;
+const Crypto_1 = require('../../Utils/crypto');
+const sender_key_message_1 = require('./sender-key-message');
+class GroupCipher {
+    constructor(senderKeyStore, senderKeyName) {
+        this.senderKeyStore = senderKeyStore;
+        this.senderKeyName = senderKeyName;
+    }
+    async encrypt(paddedPlaintext) {
+        const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
+        if (!record) {
+            throw new Error('No SenderKeyRecord found for encryption');
+        }
+        const senderKeyState = record.getSenderKeyState();
+        if (!senderKeyState) {
+            throw new Error('No session to encrypt message');
+        }
+        const iteration = senderKeyState.getSenderChainKey().getIteration();
+        const senderKey = this.getSenderKey(senderKeyState, iteration === 0 ? 0 : iteration + 1);
+        const ciphertext = await this.getCipherText(senderKey.getIv(), senderKey.getCipherKey(), paddedPlaintext);
+        const senderKeyMessage = new sender_key_message_1.SenderKeyMessage(senderKeyState.getKeyId(), senderKey.getIteration(), ciphertext, senderKeyState.getSigningKeyPrivate());
+        await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
+        return senderKeyMessage.serialize();
+    }
+    async decrypt(senderKeyMessageBytes) {
+        const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
+        if (!record) {
+            throw new Error('No SenderKeyRecord found for decryption');
+        }
+        const senderKeyMessage = new sender_key_message_1.SenderKeyMessage(null, null, null, null, senderKeyMessageBytes);
+        const senderKeyState = record.getSenderKeyState(senderKeyMessage.getKeyId());
+        if (!senderKeyState) {
+            throw new Error('No session found to decrypt message');
+        }
+        senderKeyMessage.verifySignature(senderKeyState.getSigningKeyPublic());
+        const senderKey = this.getSenderKey(senderKeyState, senderKeyMessage.getIteration());
+        const plaintext = await this.getPlainText(senderKey.getIv(), senderKey.getCipherKey(), senderKeyMessage.getCipherText());
+        await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
+        return plaintext;
+    }
+    getSenderKey(senderKeyState, iteration) {
+        let senderChainKey = senderKeyState.getSenderChainKey();
+        if (senderChainKey.getIteration() > iteration) {
+            if (senderKeyState.hasSenderMessageKey(iteration)) {
+                const messageKey = senderKeyState.removeSenderMessageKey(iteration);
+                if (!messageKey) {
+                    throw new Error('No sender message key found for iteration');
+                }
+                return messageKey;
+            }
+            throw new Error(`Received message with old counter: ${senderChainKey.getIteration()}, ${iteration}`);
+        }
+        if (iteration - senderChainKey.getIteration() > 2000) {
+            throw new Error('Over 2000 messages into the future!');
+        }
+        while (senderChainKey.getIteration() < iteration) {
+            senderKeyState.addSenderMessageKey(senderChainKey.getSenderMessageKey());
+            senderChainKey = senderChainKey.getNext();
+        }
+        senderKeyState.setSenderChainKey(senderChainKey.getNext());
+        return senderChainKey.getSenderMessageKey();
+    }
+    async getPlainText(iv, key, ciphertext) {
+        try {
+            return Buffer.from(Crypto_1.aesDecryptWithIV(ciphertext, key, iv));
+        }
+        catch (e) {
+            throw new Error('InvalidMessageException');
+        }
+    }
+    async getCipherText(iv, key, plaintext) {
+        try {
+            return Buffer.from(Crypto_1.aesEncrypWithIV(plaintext, key, iv));
+        }
+        catch (e) {
+            throw new Error('InvalidMessageException');
+        }
+    }
+}
+exports.GroupCipher = GroupCipher;

package/src/Signal/Group/index.js

@@ -0,0 +1,140 @@
+'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.keyhelper =
+    exports.CiphertextMessage =
+        exports.SenderChainKey =
+            exports.SenderMessageKey =
+                exports.SenderKeyMessage =
+                    exports.SenderKeyState =
+                        exports.GroupCipher =
+                            exports.SenderKeyName =
+                                exports.SenderKeyRecord =
+                                    exports.SenderKeyDistributionMessage =
+                                        exports.GroupSessionBuilder =
+                                            void 0;
+var group_session_builder_1 = require('./group-session-builder');
+Object.defineProperty(exports, 'GroupSessionBuilder', {
+    enumerable: true,
+    get: function () {
+        return group_session_builder_1.GroupSessionBuilder;
+    }
+});
+var sender_key_distribution_message_1 = require('./sender-key-distribution-message');
+Object.defineProperty(exports, 'SenderKeyDistributionMessage', {
+    enumerable: true,
+    get: function () {
+        return sender_key_distribution_message_1.SenderKeyDistributionMessage;
+    }
+});
+var sender_key_record_1 = require('./sender-key-record');
+Object.defineProperty(exports, 'SenderKeyRecord', {
+    enumerable: true,
+    get: function () {
+        return sender_key_record_1.SenderKeyRecord;
+    }
+});
+var sender_key_name_1 = require('./sender-key-name');
+Object.defineProperty(exports, 'SenderKeyName', {
+    enumerable: true,
+    get: function () {
+        return sender_key_name_1.SenderKeyName;
+    }
+});
+var group_cipher_1 = require('./group_cipher');
+Object.defineProperty(exports, 'GroupCipher', {
+    enumerable: true,
+    get: function () {
+        return group_cipher_1.GroupCipher;
+    }
+});
+var sender_key_state_1 = require('./sender-key-state');
+Object.defineProperty(exports, 'SenderKeyState', {
+    enumerable: true,
+    get: function () {
+        return sender_key_state_1.SenderKeyState;
+    }
+});
+var sender_key_message_1 = require('./sender-key-message');
+Object.defineProperty(exports, 'SenderKeyMessage', {
+    enumerable: true,
+    get: function () {
+        return sender_key_message_1.SenderKeyMessage;
+    }
+});
+var sender_message_key_1 = require('./sender-message-key');
+Object.defineProperty(exports, 'SenderMessageKey', {
+    enumerable: true,
+    get: function () {
+        return sender_message_key_1.SenderMessageKey;
+    }
+});
+var sender_chain_key_1 = require('./sender-chain-key');
+Object.defineProperty(exports, 'SenderChainKey', {
+    enumerable: true,
+    get: function () {
+        return sender_chain_key_1.SenderChainKey;
+    }
+});
+var ciphertext_message_1 = require('./ciphertext-message');
+Object.defineProperty(exports, 'CiphertextMessage', {
+    enumerable: true,
+    get: function () {
+        return ciphertext_message_1.CiphertextMessage;
+    }
+});
+exports.keyhelper = __importStar(require('./keyhelper'));

package/src/Signal/Group/keyhelper.js

@@ -0,0 +1,77 @@
+'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.generateSenderKey = generateSenderKey;
+exports.generateSenderKeyId = generateSenderKeyId;
+exports.generateSenderSigningKey = generateSenderSigningKey;
+const nodeCrypto = __importStar(require('crypto'));
+const Crypto_1 = require('../../Utils/crypto');
+function generateSenderKey() {
+    return nodeCrypto.randomBytes(32);
+}
+function generateSenderKeyId() {
+    return nodeCrypto.randomInt(2147483647);
+}
+function generateSenderSigningKey(key) {
+    if (!key) {
+        key = Crypto_1.Curve.generateKeyPair();
+    }
+    return {
+        public: Crypto_1.generateSignalPubKey(key.public),
+        private: Buffer.from(key.private)
+    };
+}

package/src/Signal/Group/sender-chain-key.js

@@ -0,0 +1,29 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.SenderChainKey = void 0;
+const Crypto_1 = require('../../Utils/crypto');
+const sender_message_key_1 = require('./sender-message-key');
+class SenderChainKey {
+    constructor(iteration, chainKey) {
+        this.MESSAGE_KEY_SEED = Buffer.from([0x01]);
+        this.CHAIN_KEY_SEED = Buffer.from([0x02]);
+        this.iteration = iteration;
+        this.chainKey = Buffer.from(chainKey);
+    }
+    getIteration() {
+        return this.iteration;
+    }
+    getSenderMessageKey() {
+        return new sender_message_key_1.SenderMessageKey(this.iteration, this.getDerivative(this.MESSAGE_KEY_SEED, this.chainKey));
+    }
+    getNext() {
+        return new SenderChainKey(this.iteration + 1, this.getDerivative(this.CHAIN_KEY_SEED, this.chainKey));
+    }
+    getSeed() {
+        return this.chainKey;
+    }
+    getDerivative(seed, key) {
+        return Buffer.from(Crypto_1.hmacSign(seed, key));
+    }
+}
+exports.SenderChainKey = SenderChainKey;

package/src/Signal/Group/sender-key-distribution-message.js

@@ -0,0 +1,66 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.SenderKeyDistributionMessage = void 0;
+const index_js_1 = require('../../../WAProto/index.js');
+const ciphertext_message_1 = require('./ciphertext-message');
+class SenderKeyDistributionMessage extends ciphertext_message_1.CiphertextMessage {
+    constructor(id, iteration, chainKey, signatureKey, serialized) {
+        super();
+        if (serialized) {
+            try {
+                const message = serialized.slice(1);
+                const distributionMessage = index_js_1.proto.SenderKeyDistributionMessage.decode(message).toJSON();
+                this.serialized = serialized;
+                this.id = distributionMessage.id;
+                this.iteration = distributionMessage.iteration;
+                this.chainKey =
+                    typeof distributionMessage.chainKey === 'string'
+                        ? Buffer.from(distributionMessage.chainKey, 'base64')
+                        : distributionMessage.chainKey;
+                this.signatureKey =
+                    typeof distributionMessage.signingKey === 'string'
+                        ? Buffer.from(distributionMessage.signingKey, 'base64')
+                        : distributionMessage.signingKey;
+            }
+            catch (e) {
+                throw new Error(String(e));
+            }
+        }
+        else {
+            const version = this.intsToByteHighAndLow(this.CURRENT_VERSION, this.CURRENT_VERSION);
+            this.id = id;
+            this.iteration = iteration;
+            this.chainKey = chainKey;
+            this.signatureKey = signatureKey;
+            const message = index_js_1.proto.SenderKeyDistributionMessage.encode(index_js_1.proto.SenderKeyDistributionMessage.create({
+                id,
+                iteration,
+                chainKey,
+                signingKey: this.signatureKey
+            })).finish();
+            this.serialized = Buffer.concat([Buffer.from([version]), message]);
+        }
+    }
+    intsToByteHighAndLow(highValue, lowValue) {
+        return (((highValue << 4) | lowValue) & 0xff) % 256;
+    }
+    serialize() {
+        return this.serialized;
+    }
+    getType() {
+        return this.SENDERKEY_DISTRIBUTION_TYPE;
+    }
+    getIteration() {
+        return this.iteration;
+    }
+    getChainKey() {
+        return this.chainKey;
+    }
+    getSignatureKey() {
+        return this.signatureKey;
+    }
+    getId() {
+        return this.id;
+    }
+}
+exports.SenderKeyDistributionMessage = SenderKeyDistributionMessage;

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

@@ -0,0 +1,69 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.SenderKeyMessage = void 0;
+const Crypto_1 = require('../../Utils/crypto');
+const index_js_1 = require('../../../WAProto/index.js');
+const ciphertext_message_1 = require('./ciphertext-message');
+class SenderKeyMessage extends ciphertext_message_1.CiphertextMessage {
+    constructor(keyId, iteration, ciphertext, signatureKey, serialized) {
+        super();
+        this.SIGNATURE_LENGTH = 64;
+        if (serialized) {
+            const version = serialized[0];
+            const message = serialized.slice(1, serialized.length - this.SIGNATURE_LENGTH);
+            const signature = serialized.slice(-1 * this.SIGNATURE_LENGTH);
+            const senderKeyMessage = index_js_1.proto.SenderKeyMessage.decode(message).toJSON();
+            this.serialized = serialized;
+            this.messageVersion = (version & 0xff) >> 4;
+            this.keyId = senderKeyMessage.id;
+            this.iteration = senderKeyMessage.iteration;
+            this.ciphertext =
+                typeof senderKeyMessage.ciphertext === 'string'
+                    ? Buffer.from(senderKeyMessage.ciphertext, 'base64')
+                    : senderKeyMessage.ciphertext;
+            this.signature = signature;
+        }
+        else {
+            const version = (((this.CURRENT_VERSION << 4) | this.CURRENT_VERSION) & 0xff) % 256;
+            const ciphertextBuffer = Buffer.from(ciphertext);
+            const message = index_js_1.proto.SenderKeyMessage.encode(index_js_1.proto.SenderKeyMessage.create({
+                id: keyId,
+                iteration: iteration,
+                ciphertext: ciphertextBuffer
+            })).finish();
+            const signature = this.getSignature(signatureKey, Buffer.concat([Buffer.from([version]), message]));
+            this.serialized = Buffer.concat([Buffer.from([version]), message, Buffer.from(signature)]);
+            this.messageVersion = this.CURRENT_VERSION;
+            this.keyId = keyId;
+            this.iteration = iteration;
+            this.ciphertext = ciphertextBuffer;
+            this.signature = signature;
+        }
+    }
+    getKeyId() {
+        return this.keyId;
+    }
+    getIteration() {
+        return this.iteration;
+    }
+    getCipherText() {
+        return this.ciphertext;
+    }
+    verifySignature(signatureKey) {
+        const part1 = this.serialized.slice(0, this.serialized.length - this.SIGNATURE_LENGTH);
+        const part2 = this.serialized.slice(-1 * this.SIGNATURE_LENGTH);
+        const res = Crypto_1.Curve.verify(signatureKey, part1, part2);
+        if (!res)
+            throw new Error('Invalid signature!');
+    }
+    getSignature(signatureKey, serialized) {
+        return Buffer.from(Crypto_1.Curve.sign(signatureKey, serialized));
+    }
+    serialize() {
+        return this.serialized;
+    }
+    getType() {
+        return 4;
+    }
+}
+exports.SenderKeyMessage = SenderKeyMessage;

package/src/Signal/Group/sender-key-name.js

@@ -0,0 +1,51 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.SenderKeyName = void 0;
+function isNull(str) {
+    return str === null || str === '';
+}
+function intValue(num) {
+    const MAX_VALUE = 0x7fffffff;
+    const MIN_VALUE = -0x80000000;
+    if (num > MAX_VALUE || num < MIN_VALUE) {
+        return num & 0xffffffff;
+    }
+    return num;
+}
+function hashCode(strKey) {
+    let hash = 0;
+    if (!isNull(strKey)) {
+        for (let i = 0; i < strKey.length; i++) {
+            hash = hash * 31 + strKey.charCodeAt(i);
+            hash = intValue(hash);
+        }
+    }
+    return hash;
+}
+class SenderKeyName {
+    constructor(groupId, sender) {
+        this.groupId = groupId;
+        this.sender = sender;
+    }
+    getGroupId() {
+        return this.groupId;
+    }
+    getSender() {
+        return this.sender;
+    }
+    serialize() {
+        return `${this.groupId}::${this.sender.id}::${this.sender.deviceId}`;
+    }
+    toString() {
+        return this.serialize();
+    }
+    equals(other) {
+        if (other === null)
+            return false;
+        return this.groupId === other.groupId && this.sender.toString() === other.sender.toString();
+    }
+    hashCode() {
+        return hashCode(this.groupId) ^ hashCode(this.sender.toString());
+    }
+}
+exports.SenderKeyName = SenderKeyName;

package/src/Signal/Group/sender-key-record.js

@@ -0,0 +1,44 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.SenderKeyRecord = void 0;
+const generics_1 = require('../../Utils/generics');
+const sender_key_state_1 = require('./sender-key-state');
+class SenderKeyRecord {
+    constructor(serialized) {
+        this.MAX_STATES = 5;
+        this.senderKeyStates = [];
+        if (serialized) {
+            for (const structure of serialized) {
+                this.senderKeyStates.push(new sender_key_state_1.SenderKeyState(null, null, null, null, null, null, structure));
+            }
+        }
+    }
+    isEmpty() {
+        return this.senderKeyStates.length === 0;
+    }
+    getSenderKeyState(keyId) {
+        if (keyId === undefined && this.senderKeyStates.length) {
+            return this.senderKeyStates[this.senderKeyStates.length - 1];
+        }
+        return this.senderKeyStates.find(state => state.getKeyId() === keyId);
+    }
+    addSenderKeyState(id, iteration, chainKey, signatureKey) {
+        this.senderKeyStates.push(new sender_key_state_1.SenderKeyState(id, iteration, chainKey, null, signatureKey));
+        if (this.senderKeyStates.length > this.MAX_STATES) {
+            this.senderKeyStates.shift();
+        }
+    }
+    setSenderKeyState(id, iteration, chainKey, keyPair) {
+        this.senderKeyStates.length = 0;
+        this.senderKeyStates.push(new sender_key_state_1.SenderKeyState(id, iteration, chainKey, keyPair));
+    }
+    serialize() {
+        return this.senderKeyStates.map(state => state.getStructure());
+    }
+    static deserialize(data) {
+        const str = Buffer.from(data).toString('utf-8');
+        const parsed = JSON.parse(str, generics_1.BufferJSON.reviver);
+        return new SenderKeyRecord(parsed);
+    }
+}
+exports.SenderKeyRecord = SenderKeyRecord;

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

@@ -0,0 +1,87 @@
+'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,
+                senderMessageKeys: Array.isArray(senderKeyStateStructure.senderMessageKeys)
+                    ? senderKeyStateStructure.senderMessageKeys
+                    : []
+            };
+        }
+        else {
+            if (signatureKeyPair) {
+                signatureKeyPublic = signatureKeyPair.public;
+                signatureKeyPrivate = signatureKeyPair.private;
+            }
+            this.senderKeyStateStructure = {
+                senderKeyId: id || 0,
+                senderChainKey: {
+                    iteration: iteration || 0,
+                    seed: Buffer.from(chainKey || [])
+                },
+                senderSigningKey: {
+                    public: Buffer.from(signatureKeyPublic || []),
+                    private: Buffer.from(signatureKeyPrivate || [])
+                },
+                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 = Buffer.from(this.senderKeyStateStructure.senderSigningKey.public);
+        if (publicKey.length === 32) {
+            const fixed = Buffer.alloc(33);
+            fixed[0] = 0x05;
+            publicKey.copy(fixed, 1);
+            return fixed;
+        }
+        return publicKey;
+    }
+    getSigningKeyPrivate() {
+        const privateKey = this.senderKeyStateStructure.senderSigningKey.private;
+        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/src/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('../../Utils/crypto');
+class SenderMessageKey {
+    constructor(iteration, seed) {
+        const derived = Buffer.from(Crypto_1.hkdf(seed, 96, { salt: Buffer.alloc(32), info: 'WhisperGroup' }));
+        const keys = new Uint8Array(32);
+        keys.set(new Uint8Array(derived.slice(16, 32)));
+        keys.set(new Uint8Array(derived.slice(32, 48)), 16);
+        this.iv = Buffer.from(derived.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;