@celestial-community/baileys 0.0.1-security → 1.0.0

package/lib/Signal/Group/index.js

@@ -0,0 +1,138 @@
+'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/lib/Signal/Group/keyhelper.js

@@ -0,0 +1,75 @@
+'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 curve_1 = require('libsignal/src/curve')
+function generateSenderKey() {
+    return nodeCrypto.randomBytes(32)
+}
+function generateSenderKeyId() {
+    return nodeCrypto.randomInt(2147483647)
+}
+function generateSenderSigningKey(key) {
+    if (!key) {
+        key = (0, curve_1.generateKeyPair)()
+    }
+    return {
+        public: Buffer.from(key.pubKey),
+        private: Buffer.from(key.privKey)
+    }
+}

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

@@ -0,0 +1,54 @@
+'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,39 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.SenderChainKey = void 0
+const crypto_1 = require('libsignal/src/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
+        if (chainKey instanceof Buffer) {
+            this.chainKey = chainKey
+        } else {
+            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 (0, crypto_1.calculateMAC)(key, seed)
+    }
+}
+exports.SenderChainKey = SenderChainKey

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

@@ -0,0 +1,71 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.SenderKeyDistributionMessage = void 0
+const WAProto_1 = require('../../../WAProto')
+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 =
+                    WAProto_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 = WAProto_1.proto.SenderKeyDistributionMessage.encode(
+                WAProto_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 typeof this.chainKey === 'string'
+            ? Buffer.from(this.chainKey, 'base64')
+            : this.chainKey
+    }
+    getSignatureKey() {
+        return typeof this.signatureKey === 'string'
+            ? Buffer.from(this.signatureKey, 'base64')
+            : this.signatureKey
+    }
+    getId() {
+        return this.id
+    }
+}
+exports.SenderKeyDistributionMessage = SenderKeyDistributionMessage

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

@@ -0,0 +1,76 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.SenderKeyMessage = void 0
+const curve_1 = require('libsignal/src/curve')
+const WAProto_1 = require('../../../WAProto')
+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 = WAProto_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 = WAProto_1.proto.SenderKeyMessage.encode(
+                WAProto_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 = (0, curve_1.verifySignature)(signatureKey, part1, part2)
+        if (!res) throw new Error('Invalid signature!')
+    }
+    getSignature(signatureKey, serialized) {
+        return Buffer.from((0, curve_1.calculateSignature)(signatureKey, serialized))
+    }
+    serialize() {
+        return this.serialized
+    }
+    getType() {
+        return 4
+    }
+}
+exports.SenderKeyMessage = SenderKeyMessage

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

@@ -0,0 +1,50 @@
+'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/lib/Signal/Group/sender-key-record.js

@@ -0,0 +1,65 @@
+'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) {
+        let parsed
+        if (typeof data === 'string') {
+            parsed = JSON.parse(data, generics_1.BufferJSON.reviver)
+        } else if (data instanceof Uint8Array) {
+            const str = Buffer.from(data).toString('utf-8')
+            parsed = JSON.parse(str, generics_1.BufferJSON.reviver)
+        } else {
+            parsed = data
+        }
+        return new SenderKeyRecord(parsed)
+    }
+}
+exports.SenderKeyRecord = SenderKeyRecord

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

@@ -0,0 +1,114 @@
+'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