gifted-baileys 1.5.6 → 1.5.7

package/src/Utils/crypto.ts

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

@@ -1,211 +0,0 @@
-"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

@@ -1,228 +0,0 @@
-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)]
-			}
-		}
-	}
-}