gifted-baileys 1.5.0 → 1.5.5

package/{lib → src}/Utils/crypto.js

@@ -15,18 +15,41 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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 __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;
+    };
+})();
 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;
+exports.signedKeyPair = exports.Curve = exports.generateSignalPubKey = void 0;
+exports.aesEncryptGCM = aesEncryptGCM;
+exports.aesDecryptGCM = aesDecryptGCM;
+exports.aesEncryptCTR = aesEncryptCTR;
+exports.aesDecryptCTR = aesDecryptCTR;
+exports.aesDecrypt = aesDecrypt;
+exports.aesDecryptWithIV = aesDecryptWithIV;
+exports.aesEncrypt = aesEncrypt;
+exports.aesEncrypWithIV = aesEncrypWithIV;
+exports.hmacSign = hmacSign;
+exports.sha256 = sha256;
+exports.md5 = md5;
+exports.hkdf = hkdf;
+exports.derivePairingCodeKey = derivePairingCodeKey;
 const crypto_1 = require("crypto");
 const futoin_hkdf_1 = __importDefault(require("futoin-hkdf"));
 const libsignal = __importStar(require("libsignal"));
@@ -77,7 +100,6 @@ function aesEncryptGCM(plaintext, key, iv, additionalData) {
     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
@@ -92,60 +114,48 @@ function aesDecryptGCM(ciphertext, key, iv, 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/src/Utils/crypto.ts

@@ -0,0 +1,131 @@
+import { createCipheriv, createDecipheriv, createHash, createHmac, pbkdf2Sync, randomBytes } from 'crypto'
+import HKDF from 'futoin-hkdf'
+import * as libsignal from 'libsignal'
+import { KEY_BUNDLE_TYPE } from '../Defaults'
+import { KeyPair } from '../Types'
+
+/** prefix version byte to the pub keys, required for some curve crypto functions */
+export const generateSignalPubKey = (pubKey: Uint8Array | Buffer) => (
+	pubKey.length === 33
+		? pubKey
+		: Buffer.concat([ KEY_BUNDLE_TYPE, pubKey ])
+)
+
+export const Curve = {
+	generateKeyPair: (): KeyPair => {
+		const { pubKey, privKey } = libsignal.curve.generateKeyPair()
+		return {
+			private: Buffer.from(privKey),
+			// remove version byte
+			public: Buffer.from((pubKey as Uint8Array).slice(1))
+		}
+	},
+	sharedKey: (privateKey: Uint8Array, publicKey: Uint8Array) => {
+		const shared = libsignal.curve.calculateAgreement(generateSignalPubKey(publicKey), privateKey)
+		return Buffer.from(shared)
+	},
+	sign: (privateKey: Uint8Array, buf: Uint8Array) => (
+		libsignal.curve.calculateSignature(privateKey, buf)
+	),
+	verify: (pubKey: Uint8Array, message: Uint8Array, signature: Uint8Array) => {
+		try {
+			libsignal.curve.verifySignature(generateSignalPubKey(pubKey), message, signature)
+			return true
+		} catch(error) {
+			return false
+		}
+	}
+}
+
+export const signedKeyPair = (identityKeyPair: KeyPair, keyId: number) => {
+	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
+
+/**
+ * encrypt AES 256 GCM;
+ * where the tag tag is suffixed to the ciphertext
+ * */
+export function aesEncryptGCM(plaintext: Uint8Array, key: Uint8Array, iv: Uint8Array, additionalData: Uint8Array) {
+	const cipher = createCipheriv('aes-256-gcm', key, iv)
+	cipher.setAAD(additionalData)
+	return Buffer.concat([cipher.update(plaintext), cipher.final(), cipher.getAuthTag()])
+}
+
+/**
+ * decrypt AES 256 GCM;
+ * where the auth tag is suffixed to the ciphertext
+ * */
+export function aesDecryptGCM(ciphertext: Uint8Array, key: Uint8Array, iv: Uint8Array, additionalData: Uint8Array) {
+	const decipher = 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() ])
+}
+
+export function aesEncryptCTR(plaintext: Uint8Array, key: Uint8Array, iv: Uint8Array) {
+	const cipher = createCipheriv('aes-256-ctr', key, iv)
+	return Buffer.concat([cipher.update(plaintext), cipher.final()])
+}
+
+export function aesDecryptCTR(ciphertext: Uint8Array, key: Uint8Array, iv: Uint8Array) {
+	const decipher = createDecipheriv('aes-256-ctr', key, iv)
+	return Buffer.concat([decipher.update(ciphertext), decipher.final()])
+}
+
+/** decrypt AES 256 CBC; where the IV is prefixed to the buffer */
+export function aesDecrypt(buffer: Buffer, key: Buffer) {
+	return aesDecryptWithIV(buffer.slice(16, buffer.length), key, buffer.slice(0, 16))
+}
+
+/** decrypt AES 256 CBC */
+export function aesDecryptWithIV(buffer: Buffer, key: Buffer, IV: Buffer) {
+	const aes = createDecipheriv('aes-256-cbc', key, IV)
+	return Buffer.concat([aes.update(buffer), aes.final()])
+}
+
+// encrypt AES 256 CBC; where a random IV is prefixed to the buffer
+export function aesEncrypt(buffer: Buffer | Uint8Array, key: Buffer) {
+	const IV = randomBytes(16)
+	const aes = createCipheriv('aes-256-cbc', key, IV)
+	return Buffer.concat([IV, aes.update(buffer), aes.final()]) // prefix IV to the buffer
+}
+
+// encrypt AES 256 CBC with a given IV
+export function aesEncrypWithIV(buffer: Buffer, key: Buffer, IV: Buffer) {
+	const aes = createCipheriv('aes-256-cbc', key, IV)
+	return Buffer.concat([aes.update(buffer), aes.final()]) // prefix IV to the buffer
+}
+
+// sign HMAC using SHA 256
+export function hmacSign(buffer: Buffer | Uint8Array, key: Buffer | Uint8Array, variant: 'sha256' | 'sha512' = 'sha256') {
+	return createHmac(variant, key).update(buffer).digest()
+}
+
+export function sha256(buffer: Buffer) {
+	return createHash('sha256').update(buffer).digest()
+}
+
+export function md5(buffer: Buffer) {
+	return createHash('md5').update(buffer).digest()
+}
+
+// HKDF key expansion
+export function hkdf(buffer: Uint8Array | Buffer, expandedLength: number, info: { salt?: Buffer, info?: string }) {
+	return HKDF(!Buffer.isBuffer(buffer) ? Buffer.from(buffer) : buffer, expandedLength, info)
+}
+
+export function derivePairingCodeKey(pairingCode: string, salt: Buffer) {
+	return pbkdf2Sync(pairingCode, salt, 2 << 16, 32, 'sha256')
+}

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

@@ -0,0 +1,211 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decryptMessageNode = void 0;
+exports.decodeMessageNode = decodeMessageNode;
+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
+    };
+}
+const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
+    const { fullMessage, author, sender } = decodeMessageNode(stanza, meId, meLid);
+    return {
+        fullMessage,
+        category: stanza.attrs.category,
+        author,
+        decrypt() {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                let decryptables = 0;
+                function processSenderKeyDistribution(msg) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        if (msg.senderKeyDistributionMessage) {
+                            try {
+                                yield 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);
+                    yield 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 = yield repository.decryptGroupMessage({
+                                        group: sender,
+                                        authorJid: author,
+                                        msg: content
+                                    });
+                                    break;
+                                case 'pkmsg':
+                                case 'msg':
+                                    const user = (0, WABinary_1.isJidUser)(sender) ? sender : author;
+                                    msgBuffer = yield 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;
+                            yield 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;

package/src/Utils/decode-wa-message.ts

@@ -0,0 +1,228 @@
+import { Boom } from '@hapi/boom'
+import { Logger } from 'pino'
+import { proto } from '../../WAProto'
+import { SignalRepository, WAMessageKey } from '../Types'
+import { areJidsSameUser, BinaryNode, getBinaryNodeChild, isJidBroadcast, isJidGroup, isJidNewsLetter, isJidStatusBroadcast, isJidUser, isLidUser } from '../WABinary'
+import { BufferJSON, unpadRandomMax16 } from './generics'
+
+const NO_MESSAGE_FOUND_ERROR_TEXT = 'Message absent from node'
+
+type MessageType = 'chat' | 'peer_broadcast' | 'other_broadcast' | 'group' | 'direct_peer_status' | 'other_status' | 'newsletter'
+
+/**
+ * Decode the received node as a message.
+ * @note this will only parse the message, not decrypt it
+ */
+export function decodeMessageNode(
+	stanza: BinaryNode,
+	meId: string,
+	meLid: string
+) {
+	let msgType: MessageType
+	let chatId: string
+	let author: string
+
+	const msgId = stanza.attrs.id
+	const from = stanza.attrs.from
+	const participant: string | undefined = stanza.attrs.participant
+	const recipient: string | undefined = stanza.attrs.recipient
+
+	const isMe = (jid: string) => areJidsSameUser(jid, meId)
+	const isMeLid = (jid: string) => areJidsSameUser(jid, meLid)
+
+	if(isJidUser(from)) {
+		if(recipient) {
+			if(!isMe(from)) {
+				throw new Boom('receipient present, but msg not from me', { data: stanza })
+			}
+
+			chatId = recipient
+		} else {
+			chatId = from
+		}
+
+		msgType = 'chat'
+		author = from
+	} else if(isLidUser(from)) {
+		if(recipient) {
+			if(!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'
+		author = from
+		chatId = from
+	} else {
+		throw new Boom('Unknown message type', { data: stanza })
+	}
+
+	const fromMe = isJidNewsLetter(from) ? !!stanza.attrs?.is_sender : (isLidUser(from) ? isMeLid : isMe)(stanza.attrs.participant || stanza.attrs.from)
+	const pushname = stanza.attrs.notify
+
+	const key: WAMessageKey = {
+		remoteJid: chatId,
+		fromMe,
+		id: msgId,
+		participant
+	}
+
+	const fullMessage: proto.IWebMessageInfo = {
+		key,
+		messageTimestamp: +stanza.attrs.t,
+		pushName: pushname,
+		broadcast: isJidBroadcast(from)
+	}
+
+	if (msgType === 'newsletter') {
+		fullMessage.newsletterServerId = +stanza.attrs?.server_id
+	}
+
+	if(key.fromMe) {
+		fullMessage.status = proto.WebMessageInfo.Status.SERVER_ACK
+	}
+
+	return {
+		fullMessage,
+		author,
+		sender: msgType === 'chat' ? author : chatId
+	}
+}
+
+export const decryptMessageNode = (
+	stanza: BinaryNode,
+	meId: string,
+	meLid: string,
+	repository: SignalRepository,
+	logger: Logger
+) => {
+	const { fullMessage, author, sender } = decodeMessageNode(stanza, meId, meLid)
+	return {
+		fullMessage,
+		category: stanza.attrs.category,
+		author,
+		async decrypt() {
+			let decryptables = 0
+
+			async function processSenderKeyDistribution(msg: proto.IMessage) {
+				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 (isJidNewsLetter(fullMessage.key.remoteJid!)) {
+				const node = getBinaryNodeChild(stanza, 'plaintext')
+				const msg = proto.Message.decode(node?.content as Uint8Array)
+
+				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 = proto.VerifiedNameCertificate.decode(content)
+						const details = proto.VerifiedNameCertificate.Details.decode(cert.details)
+						fullMessage.verifiedBizName = details.verifiedName
+					}
+
+					if(tag !== 'enc') {
+						continue
+					}
+
+					if(!(content instanceof Uint8Array)) {
+						continue
+					}
+
+
+					decryptables += 1
+
+					let msgBuffer: Uint8Array
+
+					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 = 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: proto.IMessage = proto.Message.decode(unpadRandomMax16(msgBuffer))
+						msg = msg.deviceSentMessage?.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 = proto.WebMessageInfo.StubType.CIPHERTEXT
+						fullMessage.messageStubParameters = [err.message]
+					}
+				}
+			}
+
+			// if nothing was found to decrypt
+			if(!decryptables) {
+				fullMessage.messageStubType = proto.WebMessageInfo.StubType.CIPHERTEXT
+				fullMessage.messageStubParameters = [NO_MESSAGE_FOUND_ERROR_TEXT, JSON.stringify(stanza, BufferJSON.replacer)]
+			}
+		}
+	}
+}