@badzz88/baileys 8.4.6 → 8.4.9

package/src/Utils/meta-ai-msmsg.js

@@ -0,0 +1,133 @@
+'use strict'
+
+const rb = require('whatsapp-rust-bridge-baron')
+const { proto } = require('../../WAProto')
+
+const BOT_MESSAGE_INFO = 'Bot Message'
+const KEY_LENGTH = 32
+
+const unpadRandomMax16 = value => {
+	const bytes = new Uint8Array(value)
+	if (!bytes.length) {
+		throw new Error('unpadPkcs7 given empty bytes')
+	}
+	const padLength = bytes[bytes.length - 1]
+	if (padLength > bytes.length) {
+		throw new Error(`unpad given ${bytes.length} bytes, but pad is ${padLength}`)
+	}
+	return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.length - padLength)
+}
+
+const toBuffer = value => {
+	if (Buffer.isBuffer(value)) return value
+	if (value instanceof Uint8Array) return Buffer.from(value.buffer, value.byteOffset, value.byteLength)
+	return Buffer.from(value)
+}
+
+// Strips device suffix from LID JIDs: "user:device@lid" → "user@lid".
+// jidEncode includes ":0" even for device=0 (user/non-AD form), so normalize both meId and meLid.
+const normalizeLidJid = jid => {
+	if (!jid || !jid.endsWith('@lid') || !jid.includes(':')) return jid
+	return `${jid.split(':')[0]}@lid`
+}
+
+// Ordered msgId candidates per the Rust BotMessageContext:
+//   botEditTargetId when editing, stanzaId for the normal full response, metaTargetId as fallback.
+const selectMsgIdCandidates = messageKey => {
+	const seen = new Set()
+	const result = []
+	for (const id of [messageKey?.botEditTargetId, messageKey?.stanzaId, messageKey?.metaTargetId]) {
+		const s = id ? String(id) : ''
+		if (s && !seen.has(s)) {
+			seen.add(s)
+			result.push(s)
+		}
+	}
+	return result
+}
+
+// Ordered target_sender_user_jid candidates per Rust spec (non-AD user JID = no device suffix).
+// jidEncode produces "user:0@lid" for device=0 LID JIDs, so normalize both meId and meLid.
+const selectTargetJidCandidates = messageKey => {
+	const seen = new Set()
+	const result = []
+	for (const jid of [normalizeLidJid(messageKey?.meId), normalizeLidJid(messageKey?.meLid)]) {
+		const s = jid ? String(jid) : ''
+		if (s && !seen.has(s)) {
+			seen.add(s)
+			result.push(s)
+		}
+	}
+	return result
+}
+
+const decodeDecryptedMsmsgMessage = decrypted => {
+	const buf = toBuffer(decrypted)
+	try {
+		const unpadded = Buffer.from(unpadRandomMax16(buf))
+		const decoded = proto.Message.decode(unpadded)
+		const hasContent = Object.keys(decoded).some(k => k !== 'messageContextInfo' && decoded[k] != null)
+		if (hasContent) return decoded
+	} catch {}
+	return proto.Message.decode(buf)
+}
+
+/**
+ * Decrypts <enc type="msmsg"> bot messages.
+ *
+ * Two-pass HKDF — algorithm from bot_message.rs (BotMessageContext):
+ *   k1    = HKDF(messageSecret, salt=∅, info="Bot Message",                     32)
+ *   k2    = HKDF(k1,            salt=∅, info=msgID||target_sender_jid||bot_jid, 32)
+ *   AAD   = msgID || 0x00 || bot_user_jid
+ *   plain = AES-256-GCM.Decrypt(k2, encIv, encPayload, AAD)
+ *
+ * k1 is shared across all candidates and derived once.
+ * AAD always uses bot_user_jid, never target_sender_jid.
+ */
+const decryptMsmsgBotMessage = async (messageSecret, messageKey, msMsg) => {
+	if (!messageSecret || (messageSecret instanceof Uint8Array && !messageSecret.byteLength)) {
+		throw new Error('Missing required messageSecret for msmsg decryption')
+	}
+	if (!messageKey?.participant) throw new Error('Missing required participant for msmsg decryption')
+	if (!messageKey?.meId) throw new Error('Missing required meId for msmsg decryption')
+	if (!msMsg?.encIv) throw new Error('Missing required encIv for msmsg decryption')
+	if (!msMsg?.encPayload) throw new Error('Missing required encPayload for msmsg decryption')
+
+	const msgIdCandidates = selectMsgIdCandidates(messageKey)
+	if (!msgIdCandidates.length) throw new Error('Missing required target message id for msmsg decryption')
+
+	const targetJidCandidates = selectTargetJidCandidates(messageKey)
+	if (!targetJidCandidates.length) throw new Error('Missing required target JID for msmsg decryption')
+
+	const botJidBuf = Buffer.from(String(messageKey.participant))
+	const payload = toBuffer(msMsg.encPayload)
+	const iv = toBuffer(msMsg.encIv)
+
+	// k1 depends only on messageSecret — derive once and reuse across all candidates
+	const baseKey = Buffer.from(rb.hkdf(toBuffer(messageSecret), KEY_LENGTH, { info: BOT_MESSAGE_INFO }))
+
+	let lastError
+	for (const msgId of msgIdCandidates) {
+		// msg_id is always passed as ASCII bytes per Rust spec (msg_id.as_bytes())
+		const idBuf = Buffer.from(msgId)
+		for (const targetJid of targetJidCandidates) {
+			const info = Buffer.concat([idBuf, Buffer.from(targetJid), botJidBuf])
+			const key = Buffer.from(rb.hkdf(baseKey, KEY_LENGTH, { info }))
+			const aad = Buffer.concat([idBuf, Buffer.from([0x00]), botJidBuf])
+			try {
+				return Buffer.from(rb.aesDecryptGCM(payload, key, iv, aad))
+			} catch (e) {
+				lastError = e
+			}
+		}
+	}
+
+	const err = new Error('msmsg decryption failed: all key derivation candidates exhausted')
+	err.cause = lastError
+	throw err
+}
+
+module.exports = {
+	decodeDecryptedMsmsgMessage,
+	decryptMsmsgBotMessage
+}

package/src/Utils/noise-handler.js

@@ -0,0 +1,194 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.makeNoiseHandler = void 0
+const boom_1 = require('@hapi/boom')
+const index_js_1 = require('../../WAProto/index.js')
+const Defaults_1 = require('../Defaults')
+const rb = require('whatsapp-rust-bridge-baron')
+
+// rustNodeToJs mirrors the one in decode.js — converts InternalBinaryNode to plain JS object
+const rustNodeToJs = node => {
+	if (!node || typeof node !== 'object') return node
+	const result = { tag: node.tag, attrs: node.attrs || {} }
+	const content = node.content
+	if (content === undefined || content === null) {
+		// no content
+	} else if (content instanceof Uint8Array) {
+		result.content = Buffer.from(content)
+	} else if (typeof content === 'string') {
+		result.content = content
+	} else if (Array.isArray(content)) {
+		result.content = content.map(rustNodeToJs)
+	} else {
+		result.content = content
+	}
+	return result
+}
+
+const makeNoiseHandler = ({
+	keyPair: { private: privateKey, public: publicKey },
+	NOISE_HEADER,
+	logger,
+	routingInfo
+}) => {
+	logger = logger.child({ class: 'ns' })
+
+	const session = new rb.NoiseSession(
+		publicKey instanceof Uint8Array ? publicKey : new Uint8Array(publicKey),
+		NOISE_HEADER instanceof Uint8Array ? NOISE_HEADER : new Uint8Array(NOISE_HEADER),
+		routingInfo ? (routingInfo instanceof Uint8Array ? routingInfo : new Uint8Array(routingInfo)) : undefined
+	)
+
+	let isWaitingForTransport = false
+	let pendingOnFrame = null
+	let pendingBytes = null
+
+	const processFrames = async onFrame => {
+		// decodeFrame returns an Array of InternalBinaryNode (post-handshake) or Uint8Array (handshake)
+		const frames = session.decodeFrame(new Uint8Array(0))
+		for (let i = 0; i < frames.length; i++) {
+			const item = frames[i]
+			let frame
+			if (item instanceof Uint8Array) {
+				frame = Buffer.from(item)
+			} else {
+				try {
+					frame = rustNodeToJs(item.toJSON())
+				} catch (decodeErr) {
+					logger.debug({ err: decodeErr?.message }, '[noise] decode error')
+					continue
+				}
+			}
+			if (logger.level === 'trace') {
+				logger.trace({ msg: frame?.attrs?.id }, 'recv frame')
+			}
+			onFrame(frame)
+		}
+	}
+
+	const finishInit = async () => {
+		isWaitingForTransport = true
+		session.finishInit()
+		isWaitingForTransport = false
+		logger.trace('Noise handler transitioned to Transport state (Rust)')
+		if (pendingOnFrame && pendingBytes) {
+			logger.trace({ length: pendingBytes.length }, 'Flushing buffered frames after transport ready')
+			const frames = session.decodeFrame(pendingBytes)
+			pendingBytes = null
+			const cb = pendingOnFrame
+			pendingOnFrame = null
+			for (let i = 0; i < frames.length; i++) {
+				const item = frames[i]
+				let frame
+				if (item instanceof Uint8Array) {
+					frame = Buffer.from(item)
+				} else {
+					try {
+						frame = rustNodeToJs(item.toJSON())
+					} catch {
+						continue
+					}
+				}
+				cb(frame)
+			}
+		}
+	}
+
+	return {
+		encrypt: plaintext => {
+			const u8 = plaintext instanceof Uint8Array ? plaintext : new Uint8Array(plaintext)
+			return Buffer.from(session.encrypt(u8))
+		},
+		decrypt: ciphertext => {
+			const u8 = ciphertext instanceof Uint8Array ? ciphertext : new Uint8Array(ciphertext)
+			return Buffer.from(session.decrypt(u8))
+		},
+		authenticate: data => {
+			session.authenticate(data instanceof Uint8Array ? data : new Uint8Array(data))
+		},
+		mixIntoKey: data => {
+			session.mixIntoKey(data instanceof Uint8Array ? data : new Uint8Array(data))
+		},
+		finishInit,
+		processHandshake: ({ serverHello }, noiseKey) => {
+			// Rust handles the crypto: authenticate ephemeral, ECDH, decrypt static+payload
+			const certPayload = session.processHandshakeInit(
+				serverHello.ephemeral,
+				serverHello.static,
+				serverHello.payload,
+				privateKey instanceof Uint8Array ? privateKey : new Uint8Array(privateKey)
+			)
+
+			// Certificate validation stays in JS (uses protobuf + WA-specific constants)
+			const { intermediate: certIntermediate, leaf } = index_js_1.proto.CertChain.decode(certPayload)
+			if (!leaf?.details || !leaf?.signature) {
+				throw new boom_1.Boom('invalid noise leaf certificate', { statusCode: 400 })
+			}
+			if (!certIntermediate?.details || !certIntermediate?.signature) {
+				throw new boom_1.Boom('invalid noise intermediate certificate', { statusCode: 400 })
+			}
+			const details = index_js_1.proto.CertChain.NoiseCertificate.Details.decode(certIntermediate.details)
+			const { issuerSerial } = details
+			const { Curve } = require('./crypto')
+			if (!Curve.verify(details.key, leaf.details, leaf.signature)) {
+				throw new boom_1.Boom('noise certificate signature invalid', { statusCode: 400 })
+			}
+			if (!Curve.verify(Defaults_1.WA_CERT_DETAILS.PUBLIC_KEY, certIntermediate.details, certIntermediate.signature)) {
+				throw new boom_1.Boom('noise intermediate certificate signature invalid', { statusCode: 400 })
+			}
+			if (issuerSerial !== Defaults_1.WA_CERT_DETAILS.SERIAL) {
+				throw new boom_1.Boom('certification match failed', { statusCode: 400 })
+			}
+
+			// Extract server static key from leaf cert — used to cache for NoiseIkSession (fast reconnect)
+			let serverStaticPub
+			try {
+				const leafDetails = index_js_1.proto.CertChain.NoiseCertificate.Details.decode(leaf.details)
+				if (leafDetails.key?.length === 32) serverStaticPub = Buffer.from(leafDetails.key)
+			} catch {}
+
+			// Encrypt our static key and do final ECDH
+			const keyEnc = session.processHandshakeFinish(
+				noiseKey.public instanceof Uint8Array ? noiseKey.public : new Uint8Array(noiseKey.public),
+				noiseKey.private instanceof Uint8Array ? noiseKey.private : new Uint8Array(noiseKey.private),
+				serverHello.ephemeral
+			)
+			return { keyEnc: Buffer.from(keyEnc), serverStaticPub }
+		},
+		encodeFrame: data => {
+			const u8 = data instanceof Uint8Array ? data : new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
+			return Buffer.from(session.encodeFrameRaw(u8))
+		},
+		decodeFrame: async (newData, onFrame) => {
+			if (isWaitingForTransport) {
+				pendingBytes = pendingBytes ? Buffer.concat([pendingBytes, Buffer.from(newData)]) : Buffer.from(newData)
+				pendingOnFrame = onFrame
+				return
+			}
+
+			const u8 =
+				newData instanceof Uint8Array ? newData : new Uint8Array(newData.buffer, newData.byteOffset, newData.byteLength)
+			const frames = session.decodeFrame(u8)
+
+			for (let i = 0; i < frames.length; i++) {
+				const item = frames[i]
+				let frame
+				if (item instanceof Uint8Array) {
+					frame = Buffer.from(item)
+				} else {
+					try {
+						frame = rustNodeToJs(item.toJSON())
+					} catch (decodeErr) {
+						logger.debug({ err: decodeErr?.message }, '[noise] decode error')
+						continue
+					}
+				}
+				if (logger.level === 'trace') {
+					logger.trace({ msg: frame?.attrs?.id }, 'recv frame')
+				}
+				onFrame(frame)
+			}
+		}
+	}
+}
+exports.makeNoiseHandler = makeNoiseHandler

package/src/Utils/offline-node-processor.js

@@ -0,0 +1,42 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.makeOfflineNodeProcessor = makeOfflineNodeProcessor
+/**
+ * Creates a processor for offline stanza nodes that:
+ * - Queues nodes for sequential processing
+ * - Yields to the event loop periodically to avoid blocking
+ * - Catches handler errors to prevent the processing loop from crashing
+ */
+function makeOfflineNodeProcessor(nodeProcessorMap, deps, batchSize = 10) {
+	const nodes = []
+	let isProcessing = false
+	const enqueue = (type, node) => {
+		nodes.push({ type, node })
+		if (isProcessing) {
+			return
+		}
+		isProcessing = true
+		const promise = async () => {
+			let processedInBatch = 0
+			while (nodes.length && deps.isWsOpen()) {
+				const { type, node } = nodes.shift()
+				const nodeProcessor = nodeProcessorMap.get(type)
+				if (!nodeProcessor) {
+					deps.onUnexpectedError(new Error(`unknown offline node type: ${type}`), 'processing offline node')
+					continue
+				}
+				await nodeProcessor(node).catch(err => deps.onUnexpectedError(err, `processing offline ${type}`))
+				processedInBatch++
+				// Yield to event loop after processing a batch
+				// This prevents blocking the event loop for too long when there are many offline nodes
+				if (processedInBatch >= batchSize) {
+					processedInBatch = 0
+					await deps.yieldToEventLoop()
+				}
+			}
+			isProcessing = false
+		}
+		promise().catch(error => deps.onUnexpectedError(error, 'processing offline nodes'))
+	}
+	return { enqueue }
+}

package/src/Utils/pre-key-manager.js

@@ -0,0 +1,107 @@
+'use strict'
+var __importDefault =
+	(this && this.__importDefault) ||
+	function (mod) {
+		return mod && mod.__esModule ? mod : { default: mod }
+	}
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.PreKeyManager = void 0
+const p_queue_1 = __importDefault(require('p-queue'))
+/**
+ * Manages pre-key operations with proper concurrency control
+ */
+class PreKeyManager {
+	constructor(store, logger) {
+		this.store = store
+		this.logger = logger
+		this.queues = new Map()
+	}
+	/**
+	 * Get or create a queue for a specific key type
+	 */
+	getQueue(keyType) {
+		if (!this.queues.has(keyType)) {
+			this.queues.set(keyType, new p_queue_1.default({ concurrency: 1 }))
+		}
+		return this.queues.get(keyType)
+	}
+	/**
+	 * Process pre-key operations (updates and deletions)
+	 */
+	async processOperations(data, keyType, transactionCache, mutations, isInTransaction) {
+		const keyData = data[keyType]
+		if (!keyData) return
+		return this.getQueue(keyType).add(async () => {
+			// Ensure structures exist
+			transactionCache[keyType] = transactionCache[keyType] || {}
+			mutations[keyType] = mutations[keyType] || {}
+			// Separate deletions from updates
+			const deletions = []
+			const updates = {}
+			for (const keyId in keyData) {
+				if (keyData[keyId] === null) {
+					deletions.push(keyId)
+				} else {
+					updates[keyId] = keyData[keyId]
+				}
+			}
+			// Process updates (no validation needed)
+			if (Object.keys(updates).length > 0) {
+				Object.assign(transactionCache[keyType], updates)
+				Object.assign(mutations[keyType], updates)
+			}
+			// Process deletions with validation
+			if (deletions.length > 0) {
+				await this.processDeletions(keyType, deletions, transactionCache, mutations, isInTransaction)
+			}
+		})
+	}
+	/**
+	 * Process deletions with validation
+	 */
+	async processDeletions(keyType, ids, transactionCache, mutations, isInTransaction) {
+		if (isInTransaction) {
+			// In transaction, only allow deletion if key exists in cache
+			for (const keyId of ids) {
+				if (transactionCache[keyType]?.[keyId]) {
+					transactionCache[keyType][keyId] = null
+					mutations[keyType][keyId] = null
+				} else {
+					this.logger.warn(`Skipping deletion of non-existent ${keyType} in transaction: ${keyId}`)
+				}
+			}
+		} else {
+			// Outside transaction, validate against store
+			const existingKeys = await this.store.get(keyType, ids)
+			for (const keyId of ids) {
+				if (existingKeys[keyId]) {
+					transactionCache[keyType][keyId] = null
+					mutations[keyType][keyId] = null
+				} else {
+					this.logger.warn(`Skipping deletion of non-existent ${keyType}: ${keyId}`)
+				}
+			}
+		}
+	}
+	/**
+	 * Validate and process pre-key deletions outside transactions
+	 */
+	async validateDeletions(data, keyType) {
+		const keyData = data[keyType]
+		if (!keyData) return
+		return this.getQueue(keyType).add(async () => {
+			// Find all deletion requests
+			const deletionIds = Object.keys(keyData).filter(id => keyData[id] === null)
+			if (deletionIds.length === 0) return
+			// Validate deletions
+			const existingKeys = await this.store.get(keyType, deletionIds)
+			for (const keyId of deletionIds) {
+				if (!existingKeys[keyId]) {
+					this.logger.warn(`Skipping deletion of non-existent ${keyType}: ${keyId}`)
+					delete data[keyType][keyId]
+				}
+			}
+		})
+	}
+}
+exports.PreKeyManager = PreKeyManager