dcodeindra-baileyspro 2.3.9

package/lib/Utils/crypto.d.ts

@@ -0,0 +1,40 @@
+import { KeyPair } from '../Types'
+/** prefix version byte to the pub keys, required for some curve crypto functions */
+export declare const generateSignalPubKey: (pubKey: Uint8Array | Buffer) => Uint8Array | Buffer
+export declare const Curve: {
+generateKeyPair: () => KeyPair
+sharedKey: (privateKey: Uint8Array, publicKey: Uint8Array) => Buffer
+sign: (privateKey: Uint8Array, buf: Uint8Array) => any
+verify: (pubKey: Uint8Array, message: Uint8Array, signature: Uint8Array) => boolean
+}
+export declare const signedKeyPair: (identityKeyPair: KeyPair, keyId: number) => {
+keyPair: KeyPair
+signature: any
+keyId: number
+}
+/**
+* encrypt AES 256 GCM
+* where the tag tag is suffixed to the ciphertext
+* */
+export declare function aesEncryptGCM(plaintext: Uint8Array, key: Uint8Array, iv: Uint8Array, additionalData: Uint8Array): Buffer
+/**
+* decrypt AES 256 GCM
+* where the auth tag is suffixed to the ciphertext
+* */
+export declare function aesDecryptGCM(ciphertext: Uint8Array, key: Uint8Array, iv: Uint8Array, additionalData: Uint8Array): Buffer
+export declare function aesEncryptCTR(plaintext: Uint8Array, key: Uint8Array, iv: Uint8Array): Buffer
+export declare function aesDecryptCTR(ciphertext: Uint8Array, key: Uint8Array, iv: Uint8Array): Buffer
+/** decrypt AES 256 CBC where the IV is prefixed to the buffer */
+export declare function aesDecrypt(buffer: Buffer, key: Buffer): Buffer
+/** decrypt AES 256 CBC */
+export declare function aesDecryptWithIV(buffer: Buffer, key: Buffer, IV: Buffer): Buffer
+export declare function aesEncrypt(buffer: Buffer | Uint8Array, key: Buffer): Buffer
+export declare function aesEncrypWithIV(buffer: Buffer, key: Buffer, IV: Buffer): Buffer
+export declare function hmacSign(buffer: Buffer | Uint8Array, key: Buffer | Uint8Array, variant?: 'sha256' | 'sha512'): Buffer
+export declare function sha256(buffer: Buffer): Buffer
+export declare function md5(buffer: Buffer): Buffer
+export declare function hkdf(buffer: Uint8Array | Buffer, expandedLength: number, info: {
+salt?: Buffer
+info?: string
+}): Promise<Buffer>
+export declare function derivePairingCodeKey(pairingCode: string, salt: Buffer): Promise<Buffer>

package/lib/Utils/crypto.js

@@ -0,0 +1,150 @@
+"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
+}
+Object.defineProperty(exports, "__esModule", { value: true })
+const crypto_1 = require("crypto")
+const libsignal = __importStar(require("libsignal"))
+const Defaults_1 = require("../Defaults")
+const generateSignalPubKey = (pubKey) => (
+pubKey.length === 33 ? pubKey : Buffer.concat([Defaults_1.KEY_BUNDLE_TYPE, pubKey])
+)
+const Curve = {
+generateKeyPair: () => {
+const { pubKey, privKey } = libsignal.curve.generateKeyPair()
+return {
+private: Buffer.from(privKey),
+public: Buffer.from(pubKey.slice(1))
+}
+},
+sharedKey: (privateKey, publicKey) => {
+const shared = libsignal.curve.calculateAgreement(generateSignalPubKey(publicKey), privateKey)
+return Buffer.from(shared)
+},
+sign: (privateKey, buf) => libsignal.curve.calculateSignature(privateKey, buf),
+verify: (pubKey, message, signature) => {
+try {
+libsignal.curve.verifySignature(generateSignalPubKey(pubKey), message, signature)
+return true
+} catch {
+return false
+}
+}
+}
+const signedKeyPair = (identityKeyPair, keyId) => {
+const preKey = Curve.generateKeyPair()
+const pubKey = generateSignalPubKey(preKey.public)
+const signature = Curve.sign(identityKeyPair.private, pubKey)
+return { keyPair: preKey, signature, keyId }
+}
+const GCM_TAG_LENGTH = 128 >> 3
+function aesEncryptGCM(plaintext, key, iv, additionalData) {
+const cipher = crypto_1.createCipheriv('aes-256-gcm', key, iv)
+cipher.setAAD(additionalData)
+return Buffer.concat([cipher.update(plaintext), cipher.final(), cipher.getAuthTag()])
+}
+function aesDecryptGCM(ciphertext, key, iv, additionalData) {
+const decipher = crypto_1.createDecipheriv('aes-256-gcm', key, iv)
+const enc = ciphertext.slice(0, ciphertext.length - GCM_TAG_LENGTH)
+const tag = ciphertext.slice(ciphertext.length - GCM_TAG_LENGTH)
+decipher.setAAD(additionalData)
+decipher.setAuthTag(tag)
+return Buffer.concat([decipher.update(enc), decipher.final()])
+}
+function aesEncryptCTR(plaintext, key, iv) {
+const cipher = crypto_1.createCipheriv('aes-256-ctr', key, iv)
+return Buffer.concat([cipher.update(plaintext), cipher.final()])
+}
+function aesDecryptCTR(ciphertext, key, iv) {
+const decipher = crypto_1.createDecipheriv('aes-256-ctr', key, iv)
+return Buffer.concat([decipher.update(ciphertext), decipher.final()])
+}
+function aesDecrypt(buffer, key) {
+return aesDecryptWithIV(buffer.slice(16), key, buffer.slice(0, 16))
+}
+function aesDecryptWithIV(buffer, key, IV) {
+const aes = crypto_1.createDecipheriv('aes-256-cbc', key, IV)
+return Buffer.concat([aes.update(buffer), aes.final()])
+}
+function aesEncrypt(buffer, key) {
+const IV = crypto_1.randomBytes(16)
+const aes = crypto_1.createCipheriv('aes-256-cbc', key, IV)
+return Buffer.concat([IV, aes.update(buffer), aes.final()])
+}
+function aesEncrypWithIV(buffer, key, IV) {
+const aes = crypto_1.createCipheriv('aes-256-cbc', key, IV)
+return Buffer.concat([aes.update(buffer), aes.final()])
+}
+function hmacSign(buffer, key, variant = 'sha256') {
+return crypto_1.createHmac(variant, key).update(buffer).digest()
+}
+function sha256(buffer) {
+return crypto_1.createHash('sha256').update(buffer).digest()
+}
+function md5(buffer) {
+return crypto_1.createHash('md5').update(buffer).digest()
+}
+async function hkdf(buffer, expandedLength, info) {
+const inputKeyMaterial = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer)
+const salt = info.salt ? new Uint8Array(info.salt) : new Uint8Array(0)
+const infoBytes = info.info ? new TextEncoder().encode(info.info) : new Uint8Array(0)
+const importedKey = await crypto.subtle.importKey('raw', inputKeyMaterial, { name: 'HKDF' }, false, ['deriveBits'])
+const derivedBits = await crypto.subtle.deriveBits({
+name: 'HKDF',
+hash: 'SHA-256',
+salt,
+info: infoBytes
+}, importedKey, expandedLength * 8)
+return Buffer.from(derivedBits)
+}
+async function derivePairingCodeKey(pairingCode, salt) {
+const encoder = new TextEncoder()
+const pairingCodeBuffer = encoder.encode(pairingCode)
+const saltBuffer = salt instanceof Uint8Array ? salt : new Uint8Array(salt)
+const keyMaterial = await crypto.subtle.importKey('raw', pairingCodeBuffer, { name: 'PBKDF2' }, false, ['deriveBits'])
+const derivedBits = await crypto.subtle.deriveBits({
+name: 'PBKDF2',
+salt: saltBuffer,
+iterations: 2 << 16,
+hash: 'SHA-256'
+}, keyMaterial, 32 * 8)
+return Buffer.from(derivedBits)
+}
+module.exports = {
+generateSignalPubKey,
+Curve,
+signedKeyPair,
+aesEncryptGCM,
+aesDecryptGCM,
+aesEncryptCTR,
+aesDecryptCTR,
+aesDecrypt,
+aesDecryptWithIV,
+aesEncrypt,
+aesEncrypWithIV,
+hmacSign,
+sha256,
+md5,
+hkdf,
+derivePairingCodeKey
+}

package/lib/Utils/decode-wa-message.d.ts

@@ -0,0 +1,252 @@
+"use strict";
+
+const { Boom } = require('@hapi/boom');
+const { proto } = require('../../WAProto');
+const { areJidsSameUser, isJidBroadcast, isJidGroup, isJidMetaIa, isJidNewsletter, isJidStatusBroadcast, isJidUser, isLidUser, jidNormalizedUser } = require('../WABinary');
+const { unpadRandomMax16 } = require('./generics');
+const { getDevice } = require('./messages');
+
+const NO_MESSAGE_FOUND_ERROR_TEXT = 'Message absent from node';
+const MISSING_KEYS_ERROR_TEXT = 'Key used already or never filled';
+
+const NACK_REASONS = {
+    ParsingError: 487,
+    UnrecognizedStanza: 488,
+    UnrecognizedStanzaClass: 489,
+    UnrecognizedStanzaType: 490,
+    InvalidProtobuf: 491,
+    InvalidHostedCompanionStanza: 493,
+    MissingMessageSecret: 495,
+    SignalErrorOldCounter: 496,
+    MessageDeletedOnPeer: 499,
+    UnhandledError: 500,
+    UnsupportedAdminRevoke: 550,
+    UnsupportedLIDGroup: 551,
+    DBOperationFailed: 552
+};
+
+/**
+ * Decode the received node as a message.
+ * @note this will only parse the message, not decrypt it
+ */
+function decodeMessageNode(stanza, meId, meLid) {
+    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) => areJidsSameUser(jid, meId);
+    const isMeLid = (jid) => areJidsSameUser(jid, meLid);
+
+    if (isJidUser(from) || isLidUser(from)) {
+        if (recipient && !isJidMetaIa(recipient)) {
+            if (!isMe(from) && !isMeLid(from)) {
+                throw new Boom('receipient present, but msg not from me', { data: stanza });
+            }
+
+            chatId = recipient;
+        } else {
+            chatId = from;
+        }
+
+        msgType = 'chat';
+        author = from;
+    } else if (isJidGroup(from)) {
+        if (!participant) {
+            throw new Boom('No participant in group message');
+        }
+
+        msgType = 'group';
+        author = participant;
+        chatId = from;
+    } else if (isJidBroadcast(from)) {
+        if (!participant) {
+            throw new Boom('No participant in group message');
+        }
+
+        const isParticipantMe = isMe(participant);
+        if (isJidStatusBroadcast(from)) {
+            msgType = isParticipantMe ? 'direct_peer_status' : 'other_status';
+        } else {
+            msgType = isParticipantMe ? 'peer_broadcast' : 'other_broadcast';
+        }
+
+        chatId = from;
+        author = participant;
+    } else if (isJidNewsletter(from)) {
+        msgType = 'newsletter';
+        chatId = from;
+        author = from;
+    } else {
+        throw new Boom('Unknown message type', { data: stanza });
+    }
+
+    const fromMe = isJidNewsletter(from) 
+        ? !!stanza.attrs?.is_sender 
+        : isLidUser(from) 
+            ? isMeLid(stanza.attrs.participant || stanza.attrs.from) 
+            : isMe(stanza.attrs.participant || stanza.attrs.from);
+
+    const pushname = stanza?.attrs?.notify;
+
+    const key = {
+        remoteJid: chatId,
+        fromMe,
+        id: msgId,
+        participant,
+        senderLid: stanza?.attrs?.sender_lid,
+        senderPn: stanza?.attrs?.sender_pn,
+        participantLid: stanza?.attrs?.participant_lid,
+        newsletter_server_id: msgType === 'newsletter' ? +stanza.attrs?.server_id : undefined
+    };
+
+    const fullMessage = {
+        key,
+        messageTimestamp: +stanza.attrs.t,
+        pushName: pushname,
+        broadcast: isJidBroadcast(from),
+        newsletter: isJidNewsletter(from)
+    };
+
+    if (msgType === 'newsletter') {
+        fullMessage.newsletter_server_id = +stanza.attrs?.server_id;
+    }
+
+    if (key.fromMe) {
+        fullMessage.status = proto.WebMessageInfo.Status.SERVER_ACK;
+    }
+
+    if (!key.fromMe) {
+        fullMessage.platform = getDevice(key.id);
+    }
+
+    return {
+        fullMessage,
+        author,
+        sender: msgType === 'chat' ? author : chatId
+    };
+}
+
+function decryptMessageNode(stanza, meId, meLid, repository, logger) {
+    const { fullMessage, author, sender } = decodeMessageNode(stanza, meId, meLid);
+    return {
+        fullMessage,
+        category: stanza.attrs.category,
+        author,
+        async decrypt() {
+            let decryptables = 0;
+            if (Array.isArray(stanza.content)) {
+                for (const { tag, attrs, content } of stanza.content) {
+                    if (tag === 'verified_name' && content instanceof Uint8Array) {
+                        const cert = proto.VerifiedNameCertificate.decode(content);
+                        const details = proto.VerifiedNameCertificate.Details.decode(cert.details);
+                        fullMessage.verifiedBizName = details.verifiedName;
+                    }
+
+                    if (tag === 'multicast' && content instanceof Uint8Array) {
+                        fullMessage.multicast = true;
+                    }
+
+                    if (tag === 'meta' && content instanceof Uint8Array) {
+                        fullMessage.metaInfo = {
+                            targetID: attrs.target_id
+                        };
+                        if (attrs.target_sender_jid) {
+                            fullMessage.metaInfo.targetSender = jidNormalizedUser(attrs.target_sender_jid);
+                        }
+                    }
+
+                    if (tag === 'bot' && content instanceof Uint8Array) {
+                        if (attrs.edit) {
+                            fullMessage.botInfo = {
+                                editType: attrs.edit,
+                                editTargetID: attrs.edit_target_id,
+                                editSenderTimestampMS: attrs.sender_timestamp_ms
+                            };
+                        }
+                    }
+
+                    if (tag !== 'enc' && tag !== 'plaintext') {
+                        continue;
+                    }
+
+                    if (!(content instanceof Uint8Array)) {
+                        continue;
+                    }
+
+                    decryptables += 1;
+
+                    let msgBuffer;
+                    try {
+                        const e2eType = tag === 'plaintext' ? 'plaintext' : attrs.type;
+                        switch (e2eType) {
+                            case 'skmsg':
+                                msgBuffer = await repository.decryptGroupMessage({
+                                    group: sender,
+                                    authorJid: author,
+                                    msg: content
+                                });
+                                break;
+                            case 'pkmsg':
+                            case 'msg':
+                                const user = isJidUser(sender) ? sender : author;
+                                msgBuffer = await repository.decryptMessage({
+                                    jid: user,
+                                    type: e2eType,
+                                    ciphertext: content
+                                });
+                                break;
+                            case 'plaintext':
+                                msgBuffer = content;
+                                break;
+                            default:
+                                throw new Error(`Unknown e2e type: ${e2eType}`);
+                        }
+
+                        let msg = proto.Message.decode(
+                            e2eType !== 'plaintext' ? unpadRandomMax16(msgBuffer) : msgBuffer
+                        );
+                        msg = msg.deviceSentMessage?.message || msg;
+                        if (msg.senderKeyDistributionMessage) {
+                            try {
+                                await repository.processSenderKeyDistributionMessage({
+                                    authorJid: author,
+                                    item: msg.senderKeyDistributionMessage
+                                });
+                            } catch (err) {
+                                logger.error({ key: fullMessage.key, err }, 'failed to decrypt message');
+                            }
+                        }
+
+                        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 = proto.WebMessageInfo.StubType.CIPHERTEXT;
+                        fullMessage.messageStubParameters = [err.message];
+                    }
+                }
+            }
+
+            if (!decryptables) {
+                fullMessage.messageStubType = proto.WebMessageInfo.StubType.CIPHERTEXT;
+                fullMessage.messageStubParameters = [NO_MESSAGE_FOUND_ERROR_TEXT];
+            }
+        }
+    };
+}
+
+module.exports = {
+    decodeMessageNode,
+    decryptMessageNode,
+    NO_MESSAGE_FOUND_ERROR_TEXT,
+    MISSING_KEYS_ERROR_TEXT,
+    NACK_REASONS
+};

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

@@ -0,0 +1,232 @@
+"use strict"
+Object.defineProperty(exports, "__esModule", { value: true })
+const boom_1 = require("@hapi/boom")
+const WAProto_1 = require("../../WAProto")
+const WABinary_1 = require("../WABinary")
+const generics_1 = require("./generics")
+const messages_1 = require("./messages") 
+const NO_MESSAGE_FOUND_ERROR_TEXT = 'Message absent from node'
+const MISSING_KEYS_ERROR_TEXT = 'Key used already or never filled'
+const NACK_REASONS = {
+ParsingError: 487,
+UnrecognizedStanza: 488,
+UnrecognizedStanzaClass: 489,
+UnrecognizedStanzaType: 490,
+InvalidProtobuf: 491,
+InvalidHostedCompanionStanza: 493,
+MissingMessageSecret: 495,
+SignalErrorOldCounter: 496,
+MessageDeletedOnPeer: 499,
+UnhandledError: 500,
+UnsupportedAdminRevoke: 550,
+UnsupportedLIDGroup: 551,
+DBOperationFailed: 552
+}
+/**
+* Decode the received node as a message.
+* @note this will only parse the message, not decrypt it
+*/
+function decodeMessageNode(stanza, meId, meLid) {
+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) => WABinary_1.areJidsSameUser(jid, meId)
+const isMeLid = (jid) => WABinary_1.areJidsSameUser(jid, meLid)
+if (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 (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 (WABinary_1.isJidGroup(from)) {
+if (!participant) {
+throw new boom_1.Boom('No participant in group message')
+}
+msgType = 'group'
+author = participant
+chatId = from
+}
+else if (WABinary_1.isJidBroadcast(from)) {
+if (!participant) {
+throw new boom_1.Boom('No participant in group message')
+}
+const isParticipantMe = isMe(participant)
+if (WABinary_1.isJidStatusBroadcast(from)) {
+msgType = isParticipantMe ? 'direct_peer_status' : 'other_status'
+}
+else {
+msgType = isParticipantMe ? 'peer_broadcast' : 'other_broadcast'
+}
+chatId = from
+author = participant
+}
+else if (WABinary_1.isJidNewsletter(from)) {
+msgType = 'newsletter'
+chatId = from
+author = from
+}
+else {
+throw new boom_1.Boom('Unknown message type', { data: stanza })
+}
+const fromMe = WABinary_1.isJidNewsletter(from) ? !!stanza.attrs?.is_sender : WABinary_1.isLidUser(from) ? isMeLid(stanza.attrs.participant || stanza.attrs.from) : 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: WABinary_1.isJidBroadcast(from), 
+newsletter: WABinary_1.isJidNewsletter(from) 
+}
+if (msgType === 'newsletter') {
+fullMessage.newsletter_server_id  = +stanza.attrs?.server_id
+}
+if (key.fromMe) {
+fullMessage.status = WAProto_1.proto.WebMessageInfo.Status.SERVER_ACK
+}
+if (!key.fromMe) {
+fullMessage.platform = messages_1.getDevice(key.id) 
+}
+return {
+fullMessage,
+author,
+sender: msgType === 'chat' ? author : chatId
+}
+}
+const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
+const { fullMessage, author, sender } = decodeMessageNode(stanza, meId, meLid)
+return {
+fullMessage,
+category: stanza.attrs.category,
+author,
+async decrypt() {
+let decryptables = 0
+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 === 'multicast' && content instanceof Uint8Array) {
+fullMessage.multicast = true
+}
+if (tag === 'meta' && content instanceof Uint8Array) {
+fullMessage.metaInfo = {
+targetID: attrs.target_id
+}
+if (attrs.target_sender_jid) {
+fullMessage.metaInfo.targetSender = WABinary_1.jidNormalizedUser(attrs.target_sender_jid)
+}
+}
+if (tag === 'bot' && content instanceof Uint8Array) {
+if (attrs.edit) {
+fullMessage.botInfo = {
+editType: attrs.edit, 
+editTargetID: attrs.edit_target_id, 
+editSenderTimestampMS: attrs.sender_timestamp_ms
+}
+}
+}
+if (tag !== 'enc' && tag !== 'plaintext') {
+continue
+}
+if (!(content instanceof Uint8Array)) {
+continue
+}
+decryptables += 1
+let msgBuffer
+try {
+const e2eType = tag === 'plaintext' ? 'plaintext' : attrs.type
+switch (e2eType) {
+case 'skmsg':
+msgBuffer = await repository.decryptGroupMessage({
+group: sender,
+authorJid: author,
+msg: content
+})
+break
+case 'pkmsg':
+case 'msg':
+const user = WABinary_1.isJidUser(sender) ? sender : author
+msgBuffer = await repository.decryptMessage({
+jid: user,
+type: e2eType,
+ciphertext: content
+})
+break
+case 'plaintext':
+msgBuffer = content
+break
+default:
+throw new Error(`Unknown e2e type: ${e2eType}`)
+}
+let msg = WAProto_1.proto.Message.decode(e2eType !== 'plaintext' ? generics_1.unpadRandomMax16(msgBuffer) : msgBuffer)
+msg = msg.deviceSentMessage?.message || msg
+if (msg.senderKeyDistributionMessage) {
+//eslint-disable-next-line max-depth
+try {
+await repository.processSenderKeyDistributionMessage({
+authorJid: author,
+item: msg.senderKeyDistributionMessage
+})
+}
+catch (err) {
+logger.error({ key: fullMessage.key, err }, 'failed to decrypt message')
+}
+}
+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]
+}
+}
+}
+}
+module.exports = {
+decodeMessageNode, 
+decryptMessageNode
+}