@badzz88/baileys 8.5.4 → 8.5.6

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

@@ -1,122 +0,0 @@
-'use strict'
-
-const rb = require('whatsapp-rust-bridge')
-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)
-}
-
-
-
-const normalizeLidJid = jid => {
-	if (!jid || !jid.endsWith('@lid') || !jid.includes(':')) return jid
-	return `${jid.split(':')[0]}@lid`
-}
-
-
-
-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
-}
-
-
-
-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)
-}
-
-
-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)
-
-	
-	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 err = new Error('msmsg decryption failed: all key derivation candidates exhausted')
-	err.cause = lastError
-	throw err
-}
-
-module.exports = {
-	decodeDecryptedMsmsgMessage,
-	decryptMsmsgBotMessage
-}

package/lib/Utils/noise-handler.js

@@ -1,194 +0,0 @@
-'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')
-
-
-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) {
-		
-	} 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 => {
-		
-		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) => {
-			
-			const certPayload = session.processHandshakeInit(
-				serverHello.ephemeral,
-				serverHello.static,
-				serverHello.payload,
-				privateKey instanceof Uint8Array ? privateKey : new Uint8Array(privateKey)
-			)
-
-			
-			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 })
-			}
-
-			
-			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 { 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/lib/Utils/offline-node-processor.js

@@ -1,37 +0,0 @@
-'use strict'
-Object.defineProperty(exports, '__esModule', { value: true })
-exports.makeOfflineNodeProcessor = makeOfflineNodeProcessor
-
-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++
-				
-				
-				if (processedInBatch >= batchSize) {
-					processedInBatch = 0
-					await deps.yieldToEventLoop()
-				}
-			}
-			isProcessing = false
-		}
-		promise().catch(error => deps.onUnexpectedError(error, 'processing offline nodes'))
-	}
-	return { enqueue }
-}

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

@@ -1,97 +0,0 @@
-'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'))
-
-class PreKeyManager {
-	constructor(store, logger) {
-		this.store = store
-		this.logger = logger
-		this.queues = new Map()
-	}
-	
-	getQueue(keyType) {
-		if (!this.queues.has(keyType)) {
-			this.queues.set(keyType, new p_queue_1.default({ concurrency: 1 }))
-		}
-		return this.queues.get(keyType)
-	}
-	
-	async processOperations(data, keyType, transactionCache, mutations, isInTransaction) {
-		const keyData = data[keyType]
-		if (!keyData) return
-		return this.getQueue(keyType).add(async () => {
-			
-			transactionCache[keyType] = transactionCache[keyType] || {}
-			mutations[keyType] = mutations[keyType] || {}
-			
-			const deletions = []
-			const updates = {}
-			for (const keyId in keyData) {
-				if (keyData[keyId] === null) {
-					deletions.push(keyId)
-				} else {
-					updates[keyId] = keyData[keyId]
-				}
-			}
-			
-			if (Object.keys(updates).length > 0) {
-				Object.assign(transactionCache[keyType], updates)
-				Object.assign(mutations[keyType], updates)
-			}
-			
-			if (deletions.length > 0) {
-				await this.processDeletions(keyType, deletions, transactionCache, mutations, isInTransaction)
-			}
-		})
-	}
-	
-	async processDeletions(keyType, ids, transactionCache, mutations, isInTransaction) {
-		if (isInTransaction) {
-			
-			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 {
-			
-			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}`)
-				}
-			}
-		}
-	}
-	
-	async validateDeletions(data, keyType) {
-		const keyData = data[keyType]
-		if (!keyData) return
-		return this.getQueue(keyType).add(async () => {
-			
-			const deletionIds = Object.keys(keyData).filter(id => keyData[id] === null)
-			if (deletionIds.length === 0) return
-			
-			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