@celestial-community/baileys 0.0.1-security → 1.0.0

package/lib/Utils/companion-reg-client-utils.js

@@ -0,0 +1,37 @@
+export var CompanionWebClientType
+;(function (CompanionWebClientType) {
+    CompanionWebClientType[(CompanionWebClientType['UNKNOWN'] = 0)] = 'UNKNOWN'
+    CompanionWebClientType[(CompanionWebClientType['CHROME'] = 1)] = 'CHROME'
+    CompanionWebClientType[(CompanionWebClientType['EDGE'] = 2)] = 'EDGE'
+    CompanionWebClientType[(CompanionWebClientType['FIREFOX'] = 3)] = 'FIREFOX'
+    CompanionWebClientType[(CompanionWebClientType['IE'] = 4)] = 'IE'
+    CompanionWebClientType[(CompanionWebClientType['OPERA'] = 5)] = 'OPERA'
+    CompanionWebClientType[(CompanionWebClientType['SAFARI'] = 6)] = 'SAFARI'
+    CompanionWebClientType[(CompanionWebClientType['ELECTRON'] = 7)] = 'ELECTRON'
+    CompanionWebClientType[(CompanionWebClientType['UWP'] = 8)] = 'UWP'
+    CompanionWebClientType[(CompanionWebClientType['OTHER_WEB_CLIENT'] = 9)] = 'OTHER_WEB_CLIENT'
+})(CompanionWebClientType || (CompanionWebClientType = {}))
+const BROWSER_TO_COMPANION_WEB_CLIENT = {
+    Chrome: CompanionWebClientType.CHROME,
+    Edge: CompanionWebClientType.EDGE,
+    Firefox: CompanionWebClientType.FIREFOX,
+    IE: CompanionWebClientType.IE,
+    Opera: CompanionWebClientType.OPERA,
+    Safari: CompanionWebClientType.SAFARI
+}
+const getCompanionWebClientType = ([os, browserName]) => {
+    if (browserName === 'Desktop') {
+        return os === 'Windows' ? CompanionWebClientType.UWP : CompanionWebClientType.ELECTRON
+    }
+    return BROWSER_TO_COMPANION_WEB_CLIENT[browserName] || CompanionWebClientType.OTHER_WEB_CLIENT
+}
+const getCompanionPlatformId = (browser) => {
+    return getCompanionWebClientType(browser).toString()
+}
+const buildPairingQRData = (ref, noiseKeyB64, identityKeyB64, advB64, browser) => {
+    return (
+        'https://wa.me/settings/linked_devices#' +
+        [ref, noiseKeyB64, identityKeyB64, advB64, getCompanionPlatformId(browser)].join(',')
+    )
+}
+//# sourceMappingURL=companion-reg-client-utils.js.map

package/lib/Utils/contact-graph-warmer.js

@@ -0,0 +1,208 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.contact_graph_warmer = void 0
+
+/**
+ * @file contact-graph-warmer.js
+ * @description Enforces handshake progression before messaging strangers,
+ *   and a lurk period before sending in newly-joined groups — mimics how
+ *   a real human builds up a contact graph instead of blasting messages
+ *   to unknown recipients immediately. Off by default.
+ * @author Denzy ZeroDay
+ */
+
+const default_config = {
+    enabled: false,
+    require_handshake_before_group_send: true,
+    handshake_min_delay_ms: 3600000, // 1 hour
+    group_lurk_period_ms: 43200000, // 12 hours
+    max_stranger_messages_per_day: 5,
+    auto_register_on_incoming: true
+}
+
+class contact_graph_warmer {
+    constructor(config = {}) {
+        this.config = { ...default_config, ...config }
+        this.contacts = new Map()
+        this.groups = new Map()
+        this.stranger_messages_today = 0
+        this.last_stranger_reset_day = this.get_current_day()
+    }
+
+    /**
+     * Check if message can be sent to this contact/group.
+     * Returns { allowed: false, needs_handshake: true } if handshake required.
+     */
+    can_message(jid) {
+        if (!this.config.enabled) return { allowed: true }
+
+        const current_day = this.get_current_day()
+        if (current_day !== this.last_stranger_reset_day) {
+            this.stranger_messages_today = 0
+            this.last_stranger_reset_day = current_day
+        }
+
+        if (this.is_group(jid)) return this.check_group_message(jid)
+        return this.check_individual_message(jid)
+    }
+
+    /** Mark handshake as sent to this contact */
+    mark_handshake_sent(jid) {
+        if (!this.config.enabled) return
+        if (this.is_group(jid)) return
+        const record = this.contacts.get(jid) || { state: 'stranger' }
+        record.state = 'handshake_sent'
+        record.handshakeSentAt = Date.now()
+        this.contacts.set(jid, record)
+    }
+
+    /** Mark handshake as complete with this contact */
+    mark_handshake_complete(jid) {
+        if (!this.config.enabled) return
+        if (this.is_group(jid)) return
+        const record = this.contacts.get(jid) || { state: 'stranger' }
+        record.state = 'handshake_complete'
+        this.contacts.set(jid, record)
+    }
+
+    /** Register a contact as known (skip handshake requirement) */
+    register_known_contact(jid) {
+        if (!this.config.enabled) return
+        if (this.is_group(jid)) return
+        const record = this.contacts.get(jid) || { state: 'stranger' }
+        record.state = 'known'
+        this.contacts.set(jid, record)
+    }
+
+    /** Register a group join event */
+    register_group_join(group_jid) {
+        if (!this.config.enabled) return
+        if (!this.is_group(group_jid)) return
+        this.groups.set(group_jid, { joinedAt: Date.now() })
+    }
+
+    /** Get contact state */
+    get_contact_state(jid) {
+        if (this.is_group(jid)) return 'known'
+        return this.contacts.get(jid)?.state || 'stranger'
+    }
+
+    /** Handle incoming message — auto-register if enabled */
+    on_incoming_message(jid) {
+        if (!this.config.enabled) return
+        if (this.is_group(jid)) return
+        if (this.config.auto_register_on_incoming) this.register_known_contact(jid)
+    }
+
+    /** Get statistics */
+    get_stats() {
+        const known_contacts = Array.from(this.contacts.values()).filter(
+            (c) => c.state === 'known'
+        ).length
+        const pending_handshakes = Array.from(this.contacts.values()).filter(
+            (c) => c.state === 'handshake_sent'
+        ).length
+        const groups_joined = Array.from(this.groups.entries()).map(([group_jid, record]) => ({
+            groupJid: group_jid,
+            joinedAt: record.joinedAt,
+            firstSendUnlocksAt: record.joinedAt + this.config.group_lurk_period_ms
+        }))
+
+        return {
+            known_contacts,
+            pending_handshakes,
+            strangers_today: this.stranger_messages_today,
+            groups_joined
+        }
+    }
+
+    /** Reset all state */
+    reset() {
+        this.contacts.clear()
+        this.groups.clear()
+        this.stranger_messages_today = 0
+        this.last_stranger_reset_day = this.get_current_day()
+    }
+
+    /** Export state for persistence */
+    export_state() {
+        return {
+            contacts: Array.from(this.contacts.entries()),
+            groups: Array.from(this.groups.entries()),
+            strangerMessagesToday: this.stranger_messages_today,
+            lastStrangerResetDay: this.last_stranger_reset_day
+        }
+    }
+
+    /** Restore state from persistence */
+    restore_state(state) {
+        if (state?.contacts && Array.isArray(state.contacts))
+            this.contacts = new Map(state.contacts)
+        if (state?.groups && Array.isArray(state.groups)) this.groups = new Map(state.groups)
+        if (typeof state?.strangerMessagesToday === 'number')
+            this.stranger_messages_today = state.strangerMessagesToday
+        if (typeof state?.lastStrangerResetDay === 'number')
+            this.last_stranger_reset_day = state.lastStrangerResetDay
+    }
+
+    // Private helpers
+    is_group(jid) {
+        return jid.endsWith('@g.us')
+    }
+
+    get_current_day() {
+        return Math.floor(Date.now() / 86400000)
+    }
+
+    check_group_message(group_jid) {
+        const record = this.groups.get(group_jid)
+        if (!record) return { allowed: true }
+
+        const lurk_ends_at = record.joinedAt + this.config.group_lurk_period_ms
+        if (Date.now() < lurk_ends_at) {
+            const minutes_left = Math.ceil((lurk_ends_at - Date.now()) / 60000)
+            return {
+                allowed: false,
+                reason: `Group lurk period not elapsed — wait ${minutes_left} minutes`
+            }
+        }
+        return { allowed: true }
+    }
+
+    check_individual_message(jid) {
+        const record = this.contacts.get(jid)
+
+        if (!record || record.state === 'stranger') {
+            if (this.config.require_handshake_before_group_send) {
+                if (this.stranger_messages_today >= this.config.max_stranger_messages_per_day) {
+                    return {
+                        allowed: false,
+                        reason: `Daily new-contact limit reached (${this.config.max_stranger_messages_per_day})`,
+                        needs_handshake: true
+                    }
+                }
+                this.stranger_messages_today++
+            }
+            return { allowed: true, needs_handshake: true }
+        }
+
+        if (record.state === 'handshake_sent') {
+            if (!record.handshakeSentAt) return { allowed: true }
+            const elapsed = Date.now() - record.handshakeSentAt
+            if (elapsed < this.config.handshake_min_delay_ms) {
+                const minutes_left = Math.ceil(
+                    (this.config.handshake_min_delay_ms - elapsed) / 60000
+                )
+                return {
+                    allowed: false,
+                    reason: `Handshake too recent — wait ${minutes_left} minutes`
+                }
+            }
+        }
+
+        return { allowed: true }
+    }
+}
+
+exports.contact_graph_warmer = contact_graph_warmer
+module.exports = { contact_graph_warmer }

package/lib/Utils/crypto.js

@@ -0,0 +1,196 @@
+'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 (mod) {
+        if (mod && mod.__esModule) return mod
+        var result = {}
+        if (mod != null)
+            for (var k in mod)
+                if (k !== 'default' && Object.prototype.hasOwnProperty.call(mod, k))
+                    __createBinding(result, mod, k)
+        __setModuleDefault(result, mod)
+        return result
+    }
+var __importDefault =
+    (this && this.__importDefault) ||
+    function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod }
+    }
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.derivePairingCodeKey =
+    exports.hkdf =
+    exports.md5 =
+    exports.sha256 =
+    exports.hmacSign =
+    exports.aesEncrypWithIV =
+    exports.aesEncrypt =
+    exports.aesDecryptWithIV =
+    exports.aesDecrypt =
+    exports.aesDecryptCTR =
+    exports.aesEncryptCTR =
+    exports.aesDecryptGCM =
+    exports.aesEncryptGCM =
+    exports.signedKeyPair =
+    exports.Curve =
+    exports.generateSignalPubKey =
+        void 0
+const crypto_1 = require('crypto')
+const futoin_hkdf_1 = __importDefault(require('futoin-hkdf'))
+const libsignal = __importStar(require('libsignal'))
+const Defaults_1 = require('../Defaults')
+/** prefix version byte to the pub keys, required for some curve crypto functions */
+const generateSignalPubKey = (pubKey) =>
+    pubKey.length === 33 ? pubKey : Buffer.concat([Defaults_1.KEY_BUNDLE_TYPE, pubKey])
+exports.generateSignalPubKey = generateSignalPubKey
+exports.Curve = {
+    generateKeyPair: () => {
+        const { pubKey, privKey } = libsignal.curve.generateKeyPair()
+        return {
+            private: Buffer.from(privKey),
+            // remove version byte
+            public: Buffer.from(pubKey.slice(1))
+        }
+    },
+    sharedKey: (privateKey, publicKey) => {
+        const shared = libsignal.curve.calculateAgreement(
+            (0, exports.generateSignalPubKey)(publicKey),
+            privateKey
+        )
+        return Buffer.from(shared)
+    },
+    sign: (privateKey, buf) => libsignal.curve.calculateSignature(privateKey, buf),
+    verify: (pubKey, message, signature) => {
+        try {
+            libsignal.curve.verifySignature(
+                (0, exports.generateSignalPubKey)(pubKey),
+                message,
+                signature
+            )
+            return true
+        } catch (error) {
+            return false
+        }
+    }
+}
+const signedKeyPair = (identityKeyPair, keyId) => {
+    const preKey = exports.Curve.generateKeyPair()
+    const pubKey = (0, exports.generateSignalPubKey)(preKey.public)
+    const signature = exports.Curve.sign(identityKeyPair.private, pubKey)
+    return { keyPair: preKey, signature, keyId }
+}
+exports.signedKeyPair = signedKeyPair
+const GCM_TAG_LENGTH = 128 >> 3
+/**
+ * encrypt AES 256 GCM;
+ * where the tag tag is suffixed to the ciphertext
+ * */
+function aesEncryptGCM(plaintext, key, iv, additionalData) {
+    const cipher = (0, crypto_1.createCipheriv)('aes-256-gcm', key, iv)
+    cipher.setAAD(additionalData)
+    return Buffer.concat([cipher.update(plaintext), cipher.final(), cipher.getAuthTag()])
+}
+exports.aesEncryptGCM = aesEncryptGCM
+/**
+ * decrypt AES 256 GCM;
+ * where the auth tag is suffixed to the ciphertext
+ * */
+function aesDecryptGCM(ciphertext, key, iv, additionalData) {
+    const decipher = (0, crypto_1.createDecipheriv)('aes-256-gcm', key, iv)
+    // decrypt additional adata
+    const enc = ciphertext.slice(0, ciphertext.length - GCM_TAG_LENGTH)
+    const tag = ciphertext.slice(ciphertext.length - GCM_TAG_LENGTH)
+    // set additional data
+    decipher.setAAD(additionalData)
+    decipher.setAuthTag(tag)
+    return Buffer.concat([decipher.update(enc), decipher.final()])
+}
+exports.aesDecryptGCM = aesDecryptGCM
+function aesEncryptCTR(plaintext, key, iv) {
+    const cipher = (0, crypto_1.createCipheriv)('aes-256-ctr', key, iv)
+    return Buffer.concat([cipher.update(plaintext), cipher.final()])
+}
+exports.aesEncryptCTR = aesEncryptCTR
+function aesDecryptCTR(ciphertext, key, iv) {
+    const decipher = (0, crypto_1.createDecipheriv)('aes-256-ctr', key, iv)
+    return Buffer.concat([decipher.update(ciphertext), decipher.final()])
+}
+exports.aesDecryptCTR = aesDecryptCTR
+/** decrypt AES 256 CBC; where the IV is prefixed to the buffer */
+function aesDecrypt(buffer, key) {
+    return aesDecryptWithIV(buffer.slice(16, buffer.length), key, buffer.slice(0, 16))
+}
+exports.aesDecrypt = aesDecrypt
+/** decrypt AES 256 CBC */
+function aesDecryptWithIV(buffer, key, IV) {
+    const aes = (0, crypto_1.createDecipheriv)('aes-256-cbc', key, IV)
+    return Buffer.concat([aes.update(buffer), aes.final()])
+}
+exports.aesDecryptWithIV = aesDecryptWithIV
+// encrypt AES 256 CBC; where a random IV is prefixed to the buffer
+function aesEncrypt(buffer, key) {
+    const IV = (0, crypto_1.randomBytes)(16)
+    const aes = (0, crypto_1.createCipheriv)('aes-256-cbc', key, IV)
+    return Buffer.concat([IV, aes.update(buffer), aes.final()]) // prefix IV to the buffer
+}
+exports.aesEncrypt = aesEncrypt
+// encrypt AES 256 CBC with a given IV
+function aesEncrypWithIV(buffer, key, IV) {
+    const aes = (0, crypto_1.createCipheriv)('aes-256-cbc', key, IV)
+    return Buffer.concat([aes.update(buffer), aes.final()]) // prefix IV to the buffer
+}
+exports.aesEncrypWithIV = aesEncrypWithIV
+// sign HMAC using SHA 256
+function hmacSign(buffer, key, variant = 'sha256') {
+    return (0, crypto_1.createHmac)(variant, key).update(buffer).digest()
+}
+exports.hmacSign = hmacSign
+function sha256(buffer) {
+    return (0, crypto_1.createHash)('sha256').update(buffer).digest()
+}
+exports.sha256 = sha256
+function md5(buffer) {
+    return (0, crypto_1.createHash)('md5').update(buffer).digest()
+}
+exports.md5 = md5
+// HKDF key expansion
+function hkdf(buffer, expandedLength, info) {
+    return (0, futoin_hkdf_1.default)(
+        !Buffer.isBuffer(buffer) ? Buffer.from(buffer) : buffer,
+        expandedLength,
+        info
+    )
+}
+exports.hkdf = hkdf
+function derivePairingCodeKey(pairingCode, salt) {
+    return (0, crypto_1.pbkdf2Sync)(pairingCode, salt, 2 << 16, 32, 'sha256')
+}
+exports.derivePairingCodeKey = derivePairingCodeKey

package/lib/Utils/decode-wa-message.js

@@ -0,0 +1,208 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.decryptMessageNode = exports.decodeMessageNode = void 0
+const boom_1 = require('@hapi/boom')
+const WAProto_1 = require('../../WAProto')
+const WABinary_1 = require('../WABinary')
+const generics_1 = require('./generics')
+const NO_MESSAGE_FOUND_ERROR_TEXT = 'Message absent from node'
+/**
+ * Decode the received node as a message.
+ * @note this will only parse the message, not decrypt it
+ */
+function decodeMessageNode(stanza, meId, meLid) {
+    var _a, _b
+    let msgType
+    let chatId
+    let author
+    const msgId = stanza.attrs.id
+    const from = stanza.attrs.from
+    const participant = stanza.attrs.participant
+    const recipient = stanza.attrs.recipient
+    const isMe = (jid) => (0, WABinary_1.areJidsSameUser)(jid, meId)
+    const isMeLid = (jid) => (0, WABinary_1.areJidsSameUser)(jid, meLid)
+    if ((0, WABinary_1.isJidUser)(from)) {
+        if (recipient) {
+            if (!isMe(from)) {
+                throw new boom_1.Boom('receipient present, but msg not from me', { data: stanza })
+            }
+            chatId = recipient
+        } else {
+            chatId = from
+        }
+        msgType = 'chat'
+        author = from
+    } else if ((0, WABinary_1.isLidUser)(from)) {
+        if (recipient) {
+            if (!isMeLid(from)) {
+                throw new boom_1.Boom('receipient present, but msg not from me', { data: stanza })
+            }
+            chatId = recipient
+        } else {
+            chatId = from
+        }
+        msgType = 'chat'
+        author = from
+    } else if ((0, WABinary_1.isJidGroup)(from)) {
+        if (!participant) {
+            throw new boom_1.Boom('No participant in group message')
+        }
+        msgType = 'group'
+        author = participant
+        chatId = from
+    } else if ((0, WABinary_1.isJidBroadcast)(from)) {
+        if (!participant) {
+            throw new boom_1.Boom('No participant in group message')
+        }
+        const isParticipantMe = isMe(participant)
+        if ((0, WABinary_1.isJidStatusBroadcast)(from)) {
+            msgType = isParticipantMe ? 'direct_peer_status' : 'other_status'
+        } else {
+            msgType = isParticipantMe ? 'peer_broadcast' : 'other_broadcast'
+        }
+        chatId = from
+        author = participant
+    } else if ((0, WABinary_1.isJidNewsLetter)(from)) {
+        msgType = 'newsletter'
+        author = from
+        chatId = from
+    } else {
+        throw new boom_1.Boom('Unknown message type', { data: stanza })
+    }
+    const fromMe = (0, WABinary_1.isJidNewsLetter)(from)
+        ? !!((_a = stanza.attrs) === null || _a === void 0 ? void 0 : _a.is_sender)
+        : ((0, WABinary_1.isLidUser)(from) ? isMeLid : isMe)(
+              stanza.attrs.participant || stanza.attrs.from
+          )
+    const pushname = stanza.attrs.notify
+    const key = {
+        remoteJid: chatId,
+        fromMe,
+        id: msgId,
+        participant
+    }
+    const fullMessage = {
+        key,
+        messageTimestamp: +stanza.attrs.t,
+        pushName: pushname,
+        broadcast: (0, WABinary_1.isJidBroadcast)(from)
+    }
+    if (msgType === 'newsletter') {
+        fullMessage.newsletterServerId = +((_b = stanza.attrs) === null || _b === void 0
+            ? void 0
+            : _b.server_id)
+    }
+    if (key.fromMe) {
+        fullMessage.status = WAProto_1.proto.WebMessageInfo.Status.SERVER_ACK
+    }
+    return {
+        fullMessage,
+        author,
+        sender: msgType === 'chat' ? author : chatId
+    }
+}
+exports.decodeMessageNode = decodeMessageNode
+const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
+    const { fullMessage, author, sender } = decodeMessageNode(stanza, meId, meLid)
+    return {
+        fullMessage,
+        category: stanza.attrs.category,
+        author,
+        async decrypt() {
+            var _a
+            let decryptables = 0
+            async function processSenderKeyDistribution(msg) {
+                if (msg.senderKeyDistributionMessage) {
+                    try {
+                        await repository.processSenderKeyDistributionMessage({
+                            authorJid: author,
+                            item: msg.senderKeyDistributionMessage
+                        })
+                    } catch (err) {
+                        logger.error(
+                            { key: fullMessage.key, err },
+                            'failed to process senderKeyDistribution'
+                        )
+                    }
+                }
+            }
+            if ((0, WABinary_1.isJidNewsLetter)(fullMessage.key.remoteJid)) {
+                const node = (0, WABinary_1.getBinaryNodeChild)(stanza, 'plaintext')
+                const msg = WAProto_1.proto.Message.decode(
+                    node === null || node === void 0 ? void 0 : node.content
+                )
+                await processSenderKeyDistribution(msg)
+                fullMessage.message = msg
+                decryptables += 1
+            } else if (Array.isArray(stanza.content)) {
+                for (const { tag, attrs, content } of stanza.content) {
+                    if (tag === 'verified_name' && content instanceof Uint8Array) {
+                        const cert = WAProto_1.proto.VerifiedNameCertificate.decode(content)
+                        const details = WAProto_1.proto.VerifiedNameCertificate.Details.decode(
+                            cert.details
+                        )
+                        fullMessage.verifiedBizName = details.verifiedName
+                    }
+                    if (tag !== 'enc') {
+                        continue
+                    }
+                    if (!(content instanceof Uint8Array)) {
+                        continue
+                    }
+                    decryptables += 1
+                    let msgBuffer
+                    try {
+                        const e2eType = attrs.type
+                        switch (e2eType) {
+                            case 'skmsg':
+                                msgBuffer = await repository.decryptGroupMessage({
+                                    group: sender,
+                                    authorJid: author,
+                                    msg: content
+                                })
+                                break
+                            case 'pkmsg':
+                            case 'msg':
+                                const user = (0, WABinary_1.isJidUser)(sender) ? sender : author
+                                msgBuffer = await repository.decryptMessage({
+                                    jid: user,
+                                    type: e2eType,
+                                    ciphertext: content
+                                })
+                                break
+                            default:
+                                throw new Error(`Unknown e2e type: ${e2eType}`)
+                        }
+                        let msg = WAProto_1.proto.Message.decode(
+                            (0, generics_1.unpadRandomMax16)(msgBuffer)
+                        )
+                        msg =
+                            ((_a = msg.deviceSentMessage) === null || _a === void 0
+                                ? void 0
+                                : _a.message) || msg
+                        await processSenderKeyDistribution(msg)
+                        if (fullMessage.message) {
+                            Object.assign(fullMessage.message, msg)
+                        } else {
+                            fullMessage.message = msg
+                        }
+                    } catch (err) {
+                        logger.error({ key: fullMessage.key, err }, 'failed to decrypt message')
+                        fullMessage.messageStubType =
+                            WAProto_1.proto.WebMessageInfo.StubType.CIPHERTEXT
+                        fullMessage.messageStubParameters = [err.message]
+                    }
+                }
+            }
+            // if nothing was found to decrypt
+            if (!decryptables) {
+                fullMessage.messageStubType = WAProto_1.proto.WebMessageInfo.StubType.CIPHERTEXT
+                fullMessage.messageStubParameters = [
+                    NO_MESSAGE_FOUND_ERROR_TEXT,
+                    JSON.stringify(stanza, generics_1.BufferJSON.replacer)
+                ]
+            }
+        }
+    }
+}
+exports.decryptMessageNode = decryptMessageNode