@badzz88/baileys 8.5.3 → 8.5.4

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

@@ -1,262 +1,122 @@
 'use strict'
 
-const Crypto_1 = require('./crypto')
+const rb = require('whatsapp-rust-bridge')
 const { proto } = require('../../WAProto')
 
 const BOT_MESSAGE_INFO = 'Bot Message'
 const KEY_LENGTH = 32
-const AUTH_TAG_LENGTH = 16
-
-const MSG_ID_HEX_RE = /^[0-9A-Fa-f]{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)
-	}
-
+	if (Buffer.isBuffer(value)) return value
+	if (value instanceof Uint8Array) return Buffer.from(value.buffer, value.byteOffset, value.byteLength)
 	return Buffer.from(value)
 }
 
-const normalizeLidJid = jid => {
-	if (!jid || !jid.endsWith('@lid') || !jid.includes(':')) {
-		return jid
-	}
-
-	return `${jid.split(':')[0]}@lid`
-}
-
-const buildMessageIdRepresentations = messageId => {
-	const ascii = Buffer.from(messageId)
-	const binary = MSG_ID_HEX_RE.test(messageId) ? Buffer.from(messageId, 'hex') : ascii
-	return [
-		{ label: 'msgIdAscii', value: ascii },
-		...(binary.equals(ascii) ? [] : [{ label: 'msgIdBinary', value: binary }])
-	]
-}
 
-const pushUnique = (items, seen, item) => {
-	const key = JSON.stringify([
-		item.messageId,
-		item.idSource,
-		item.idSources,
-		item.infoSource,
-		item.aadSource,
-		item.info.toString('hex'),
-		item.aad.toString('hex')
-	])
 
-	if (!seen.has(key)) {
-		seen.add(key)
-		items.push(item)
-	}
+const normalizeLidJid = jid => {
+	if (!jid || !jid.endsWith('@lid') || !jid.includes(':')) return jid
+	return `${jid.split(':')[0]}@lid`
 }
 
-const getCandidateIds = messageKey => {
-	const orderedCandidates = [
-		messageKey?.botType === 'full'
-			? { source: 'stanzaId', messageId: messageKey?.stanzaId }
-			: { source: 'botEditTargetId', messageId: messageKey?.botEditTargetId },
-		{ source: 'targetId', messageId: messageKey?.targetId },
-		{ source: 'metaTargetId', messageId: messageKey?.metaTargetId },
-		{ source: 'stanzaId', messageId: messageKey?.stanzaId }
-	]
 
-	const targetIdCandidates = Array.isArray(messageKey?.targetIdCandidates) ? messageKey.targetIdCandidates : []
-	for (let index = 0; index < targetIdCandidates.length; index += 1) {
-		orderedCandidates.push({
-			source: `targetIdCandidates[${index}]`,
-			messageId: targetIdCandidates[index]
-		})
-	}
-
-	const grouped = new Map()
-	for (const candidate of orderedCandidates) {
-		if (!candidate.messageId) {
-			continue
-		}
-
-		const messageId = String(candidate.messageId)
-		const existing = grouped.get(messageId)
-		if (existing) {
-			if (!existing.idSources.includes(candidate.source)) {
-				existing.idSources.push(candidate.source)
-			}
-		} else {
-			grouped.set(messageId, {
-				messageId,
-				idSource: candidate.source,
-				idSources: [candidate.source]
-			})
-		}
-	}
-
-	return Array.from(grouped.values())
-}
-
-const getJidCandidates = messageKey => {
-	const ordered = [
-		{ source: 'meId', jid: messageKey?.meId },
-		{ source: 'conversationJid', jid: messageKey?.conversationJid },
-		{ source: 'senderJid', jid: messageKey?.senderJid },
-		{ source: 'meLidNormalized', jid: normalizeLidJid(messageKey?.meLid) }
-	]
 
+const selectMsgIdCandidates = messageKey => {
 	const seen = new Set()
-	const candidates = []
-	for (const candidate of ordered) {
-		if (!candidate.jid) {
-			continue
-		}
-
-		const jid = String(candidate.jid)
-		if (!seen.has(jid)) {
-			seen.add(jid)
-			candidates.push({ source: candidate.source, jid, value: Buffer.from(jid) })
+	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 candidates
+	return result
 }
 
-const buildMsmsgDecryptionStrategies = messageKey => {
-	const botJid = String(messageKey?.participant || '')
-	const botJidBuffer = Buffer.from(botJid)
-	const targetIds = getCandidateIds(messageKey)
-	const jidCandidates = getJidCandidates(messageKey)
-	const primaryJid = jidCandidates[0]
-	const alternateJid = jidCandidates.find(
-		candidate => candidate.source !== primaryJid?.source && candidate.jid !== botJid
-	)
-	const strategies = []
-	const seen = new Set()
 
-	for (const idCandidate of targetIds) {
-		const idForms = buildMessageIdRepresentations(idCandidate.messageId)
-		for (const idForm of idForms) {
-			pushUnique(strategies, seen, {
-				mode: '2step',
-				idSource: idCandidate.idSource,
-				idSources: idCandidate.idSources,
-				infoSource: `${idForm.label}+meId+botJid`,
-				aadSource: `${idForm.label}+0+botJid`,
-				authTagLayout: 'trailing',
-				messageId: idCandidate.messageId,
-				info: Buffer.concat([idForm.value, primaryJid.value, botJidBuffer, Buffer.alloc(0)]),
-				aad: Buffer.concat([idForm.value, Buffer.from([0]), botJidBuffer]),
-				attemptLabel: `${idCandidate.idSource}:${idForm.label}:primary`
-			})
 
-			if (alternateJid) {
-				pushUnique(strategies, seen, {
-					mode: '2step',
-					idSource: idCandidate.idSource,
-					idSources: idCandidate.idSources,
-					infoSource: `${idForm.label}+${alternateJid.source}+botJid`,
-					aadSource: `${idForm.label}+0+${alternateJid.source}`,
-					authTagLayout: 'trailing',
-					messageId: idCandidate.messageId,
-					info: Buffer.concat([idForm.value, alternateJid.value, botJidBuffer, Buffer.alloc(0)]),
-					aad: Buffer.concat([idForm.value, Buffer.from([0]), alternateJid.value]),
-					attemptLabel: `${idCandidate.idSource}:${idForm.label}:${alternateJid.source}`
-				})
-			}
+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 strategies.slice(0, 12)
-}
-
-const assertRequired = (value, label) => {
-	if (
-		!value ||
-		(Buffer.isBuffer(value) && value.length === 0) ||
-		(value instanceof Uint8Array && value.byteLength === 0)
-	) {
-		throw new Error(`Missing required ${label} for msmsg decryption`)
-	}
-}
-
-const decryptWithStrategy = (messageSecret, msMsg, strategy) => {
-	const baseSecret = Buffer.from(Crypto_1.hkdf(toBuffer(messageSecret), KEY_LENGTH, { info: BOT_MESSAGE_INFO }))
-	const key = Buffer.from(Crypto_1.hkdf(baseSecret, KEY_LENGTH, { info: strategy.info }))
-	const payload = toBuffer(msMsg.encPayload)
-	// ciphertext = payload without last 16 bytes (auth tag) + auth tag appended → standard GCM layout
-	const ciphertextWithTag = Buffer.concat([payload.slice(0, -AUTH_TAG_LENGTH), payload.slice(-AUTH_TAG_LENGTH)])
-	return Buffer.from(Crypto_1.aesDecryptGCM(ciphertextWithTag, key, toBuffer(msMsg.encIv), strategy.aad))
+	return result
 }
 
 const decodeDecryptedMsmsgMessage = decrypted => {
-	const messageBuffer = toBuffer(decrypted)
-
+	const buf = toBuffer(decrypted)
 	try {
-		const unpadded = Buffer.from(unpadRandomMax16(messageBuffer))
+		const unpadded = Buffer.from(unpadRandomMax16(buf))
 		const decoded = proto.Message.decode(unpadded)
-		const hasContent = Object.keys(decoded).some(key => key !== 'messageContextInfo' && decoded[key] != null)
-		if (hasContent) {
-			return decoded
-		}
+		const hasContent = Object.keys(decoded).some(k => k !== 'messageContextInfo' && decoded[k] != null)
+		if (hasContent) return decoded
 	} catch {}
-
-	return proto.Message.decode(messageBuffer)
+	return proto.Message.decode(buf)
 }
 
+
 const decryptMsmsgBotMessage = async (messageSecret, messageKey, msMsg) => {
-	assertRequired(messageSecret, 'messageSecret')
-	assertRequired(messageKey?.participant, 'participant')
-	assertRequired(messageKey?.meId, 'meId')
-	assertRequired(msMsg?.encIv, 'encIv')
-	assertRequired(msMsg?.encPayload, 'encPayload')
-	if (getCandidateIds(messageKey).length === 0) {
-		throw new Error('Missing required target message id for msmsg decryption')
+	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 strategies = buildMsmsgDecryptionStrategies(messageKey)
-	const attemptedStrategies = []
-	let lastError
+	const msgIdCandidates = selectMsgIdCandidates(messageKey)
+	if (!msgIdCandidates.length) throw new Error('Missing required target message id for msmsg decryption')
 
-	for (const strategy of strategies) {
-		const attempt = {
-			idSource: strategy.idSource,
-			idSources: strategy.idSources,
-			infoSource: strategy.infoSource,
-			aadSource: strategy.aadSource,
-			messageId: strategy.messageId
-		}
+	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)
 
-		try {
-			return await decryptWithStrategy(messageSecret, msMsg, strategy)
-		} catch (error) {
-			attemptedStrategies.push(attempt)
-			lastError = error
+	
+	const baseKey = Buffer.from(rb.hkdf(toBuffer(messageSecret), KEY_LENGTH, { info: BOT_MESSAGE_INFO }))
+
+	let lastError
+	for (const msgId of msgIdCandidates) {
+		
+		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 error = new Error('Failed to decrypt msmsg with bounded deterministic strategies')
-	error.attemptedStrategies = attemptedStrategies
-	error.cause = lastError
-	throw error
+	const err = new Error('msmsg decryption failed: all key derivation candidates exhausted')
+	err.cause = lastError
+	throw err
 }
 
 module.exports = {
-	buildMsmsgDecryptionStrategies,
 	decodeDecryptedMsmsgMessage,
 	decryptMsmsgBotMessage
 }

package/lib/Utils/noise-handler.js

@@ -4,15 +4,15 @@ 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('./native-bridge').loadRustBridge()
+const rb = require('whatsapp-rust-bridge')
+
 
-// 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') {
@@ -33,14 +33,6 @@ const makeNoiseHandler = ({
 }) => {
 	logger = logger.child({ class: 'ns' })
 
-	if (!rb) {
-		throw new Error(
-			'Establishing a WhatsApp connection requires the "whatsapp-rust-bridge" native module ' +
-				'(Noise protocol handshake + session), which failed to load. Make sure it is installed: ' +
-				'npm install whatsapp-rust-bridge@0.5.4'
-		)
-	}
-
 	const session = new rb.NoiseSession(
 		publicKey instanceof Uint8Array ? publicKey : new Uint8Array(publicKey),
 		NOISE_HEADER instanceof Uint8Array ? NOISE_HEADER : new Uint8Array(NOISE_HEADER),
@@ -52,7 +44,7 @@ const makeNoiseHandler = ({
 	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]
@@ -93,7 +85,7 @@ const makeNoiseHandler = ({
 				} else {
 					try {
 						frame = rustNodeToJs(item.toJSON())
-					} catch (e) {
+					} catch {
 						continue
 					}
 				}
@@ -119,7 +111,7 @@ const makeNoiseHandler = ({
 		},
 		finishInit,
 		processHandshake: ({ serverHello }, noiseKey) => {
-			// Rust handles the crypto: authenticate ephemeral, ECDH, decrypt static+payload
+			
 			const certPayload = session.processHandshakeInit(
 				serverHello.ephemeral,
 				serverHello.static,
@@ -127,7 +119,7 @@ const makeNoiseHandler = ({
 				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 })
@@ -148,13 +140,20 @@ const makeNoiseHandler = ({
 				throw new boom_1.Boom('certification match failed', { statusCode: 400 })
 			}
 
-			// Encrypt our static key and do final ECDH
+			
+			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 {}
+
+			
 			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 Buffer.from(keyEnc)
+			return { keyEnc: Buffer.from(keyEnc), serverStaticPub }
 		},
 		encodeFrame: data => {
 			const u8 = data instanceof Uint8Array ? data : new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
@@ -162,14 +161,13 @@ const makeNoiseHandler = ({
 		},
 		decodeFrame: async (newData, onFrame) => {
 			if (isWaitingForTransport) {
-				pendingBytes = pendingBytes
-					? Buffer.concat([pendingBytes, Buffer.from(newData)])
-					: Buffer.from(newData)
+				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 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++) {

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

@@ -1,12 +1,7 @@
 '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
@@ -27,8 +22,8 @@ function makeOfflineNodeProcessor(nodeProcessorMap, deps, batchSize = 10) {
 				}
 				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()

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

@@ -7,35 +7,29 @@ var __importDefault =
 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) {
@@ -45,23 +39,21 @@ class PreKeyManager {
 					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
@@ -71,7 +63,7 @@ class PreKeyManager {
 				}
 			}
 		} else {
-			// Outside transaction, validate against store
+			
 			const existingKeys = await this.store.get(keyType, ids)
 			for (const keyId of ids) {
 				if (existingKeys[keyId]) {
@@ -83,17 +75,15 @@ class PreKeyManager {
 			}
 		}
 	}
-	/**
-	 * 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]) {