@aseppxyzz12/baileys 1.1.8

package/lib/Signal/Group/queue-job.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = queueJob;
+const _queueAsyncBuckets = new Map();
+const _gcLimit = 10000;
+async function _asyncQueueExecutor(queue, cleanup) {
+    let offt = 0;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const limit = Math.min(queue.length, _gcLimit);
+        for (let i = offt; i < limit; i++) {
+            const job = queue[i];
+            try {
+                job.resolve(await job.awaitable());
+            }
+            catch (e) {
+                job.reject(e);
+            }
+        }
+        if (limit < queue.length) {
+            if (limit >= _gcLimit) {
+                queue.splice(0, limit);
+                offt = 0;
+            }
+            else {
+                offt = limit;
+            }
+        }
+        else {
+            break;
+        }
+    }
+    cleanup();
+}
+function queueJob(bucket, awaitable) {
+    // Skip name assignment since it's readonly in strict mode
+    if (typeof bucket !== 'string') {
+        console.warn('Unhandled bucket type (for naming):', typeof bucket, bucket);
+    }
+    let inactive = false;
+    if (!_queueAsyncBuckets.has(bucket)) {
+        _queueAsyncBuckets.set(bucket, []);
+        inactive = true;
+    }
+    const queue = _queueAsyncBuckets.get(bucket);
+    const job = new Promise((resolve, reject) => {
+        queue.push({
+            awaitable,
+            resolve: resolve,
+            reject
+        });
+    });
+    if (inactive) {
+        _asyncQueueExecutor(queue, () => _queueAsyncBuckets.delete(bucket));
+    }
+    return job;
+}

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { calculateMAC: calculateMAC } = require("libsignal/src/crypto");
+const { SenderMessageKey: SenderMessageKey } = require("./sender-message-key");
+class SenderChainKey {
+    constructor(iteration, chainKey) {
+        this.MESSAGE_KEY_SEED = Buffer.from([1]);
+        this.CHAIN_KEY_SEED = Buffer.from([2]);
+        this.iteration = iteration;
+        this.chainKey = Buffer.from(chainKey);
+    }
+    getIteration() {
+        return this.iteration;
+    }
+    getSenderMessageKey() {
+        return new 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 calculateMAC(key, seed);
+    }
+}
+module.exports = { SenderChainKey: SenderChainKey };

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { proto: proto } = require("../../../WAProto");
+const { CiphertextMessage: CiphertextMessage } = require("./ciphertext-message");
+class SenderKeyDistributionMessage extends CiphertextMessage {
+    constructor(id, iteration, chainKey, signatureKey, serialized) {
+        super();
+        if (serialized) {
+            try {
+                const message = serialized.slice(1);
+                const distributionMessage =
+                    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 = proto.SenderKeyDistributionMessage.encode(
+                proto.SenderKeyDistributionMessage.create({
+                    id: id,
+                    iteration: iteration,
+                    chainKey: chainKey,
+                    signingKey: this.signatureKey,
+                })
+            ).finish();
+            this.serialized = Buffer.concat([Buffer.from([version]), message]);
+        }
+    }
+    intsToByteHighAndLow(highValue, lowValue) {
+        return (((highValue << 4) | lowValue) & 255) % 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;
+    }
+}
+module.exports = { SenderKeyDistributionMessage: SenderKeyDistributionMessage };

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const {
+    verifySignature: verifySignature,
+    calculateSignature: calculateSignature,
+} = require("libsignal/src/curve");
+const { proto: proto } = require("../../../WAProto");
+const { CiphertextMessage: CiphertextMessage } = require("./ciphertext-message");
+class SenderKeyMessage extends 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 = proto.SenderKeyMessage.decode(message).toJSON();
+            this.serialized = serialized;
+            this.messageVersion = (version & 255) >> 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) & 255) % 256;
+            const ciphertextBuffer = Buffer.from(ciphertext);
+            const message = proto.SenderKeyMessage.encode(
+                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 = verifySignature(signatureKey, part1, part2);
+        if (!res) throw new Error("Invalid signature!");
+    }
+    getSignature(signatureKey, serialized) {
+        return Buffer.from(calculateSignature(signatureKey, serialized));
+    }
+    serialize() {
+        return this.serialized;
+    }
+    getType() {
+        return 4;
+    }
+}
+module.exports = { SenderKeyMessage: SenderKeyMessage };

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function isNull(str) {
+    return str === null || str === "";
+}
+function intValue(num) {
+    const MAX_VALUE = 2147483647;
+    const MIN_VALUE = -2147483648;
+    if (num > MAX_VALUE || num < MIN_VALUE) {
+        return num & 4294967295;
+    }
+    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());
+    }
+}
+module.exports = { SenderKeyName: SenderKeyName };

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { BufferJSON: BufferJSON } = require("../../Utils/generics");
+const { SenderKeyState: SenderKeyState } = 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 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 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 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, BufferJSON.reviver);
+        return new SenderKeyRecord(parsed);
+    }
+}
+module.exports = { SenderKeyRecord: SenderKeyRecord };

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

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { SenderChainKey: SenderChainKey } = require("./sender-chain-key");
+const { SenderMessageKey: SenderMessageKey } = require("./sender-message-key");
+class SenderKeyState {
+    constructor(
+        id,
+        iteration,
+        chainKey,
+        signatureKeyPair,
+        signatureKeyPublic,
+        signatureKeyPrivate,
+        senderKeyStateStructure
+    ) {
+        this.MAX_MESSAGE_KEYS = 2e3;
+        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 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] = 5;
+            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 SenderMessageKey(messageKey.iteration, messageKey.seed);
+        }
+        return null;
+    }
+    getStructure() {
+        return this.senderKeyStateStructure;
+    }
+}
+module.exports = { SenderKeyState: SenderKeyState };

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { deriveSecrets: deriveSecrets } = require("libsignal/src/crypto");
+class SenderMessageKey {
+    constructor(iteration, seed) {
+        const derivative = 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;
+    }
+}
+module.exports = { SenderMessageKey: SenderMessageKey };