gifted-baileys 1.5.6 → 1.5.7

package/src/Utils/noise-handler.ts

@@ -1,197 +0,0 @@
-import { Boom } from '@hapi/boom'
-import { Logger } from 'pino'
-import { proto } from '../../WAProto'
-import { NOISE_MODE, WA_CERT_DETAILS } from '../Defaults'
-import { KeyPair } from '../Types'
-import { BinaryNode, decodeBinaryNode } from '../WABinary'
-import { aesDecryptGCM, aesEncryptGCM, Curve, hkdf, sha256 } from './crypto'
-
-const generateIV = (counter: number) => {
-	const iv = new ArrayBuffer(12)
-	new DataView(iv).setUint32(8, counter)
-
-	return new Uint8Array(iv)
-}
-
-export const makeNoiseHandler = ({
-	keyPair: { private: privateKey, public: publicKey },
-	NOISE_HEADER,
-	mobile,
-	logger,
-	routingInfo
-}: {
-	keyPair: KeyPair
-	NOISE_HEADER: Uint8Array
-	mobile: boolean
-	logger: Logger
-	routingInfo?: Buffer | undefined
-}) => {
-	logger = logger.child({ class: 'ns' })
-
-	const authenticate = (data: Uint8Array) => {
-		if(!isFinished) {
-			hash = sha256(Buffer.concat([hash, data]))
-		}
-	}
-
-	const encrypt = (plaintext: Uint8Array) => {
-		const result = aesEncryptGCM(plaintext, encKey, generateIV(writeCounter), hash)
-
-		writeCounter += 1
-
-		authenticate(result)
-		return result
-	}
-
-	const decrypt = (ciphertext: Uint8Array) => {
-		// before the handshake is finished, we use the same counter
-		// after handshake, the counters are different
-		const iv = generateIV(isFinished ? readCounter : writeCounter)
-		const result = aesDecryptGCM(ciphertext, decKey, iv, hash)
-
-		if(isFinished) {
-			readCounter += 1
-		} else {
-			writeCounter += 1
-		}
-
-		authenticate(ciphertext)
-		return result
-	}
-
-	const localHKDF = (data: Uint8Array) => {
-		const key = hkdf(Buffer.from(data), 64, { salt, info: '' })
-		return [key.slice(0, 32), key.slice(32)]
-	}
-
-	const mixIntoKey = (data: Uint8Array) => {
-		const [write, read] = localHKDF(data)
-		salt = write
-		encKey = read
-		decKey = read
-		readCounter = 0
-		writeCounter = 0
-	}
-
-	const finishInit = () => {
-		const [write, read] = localHKDF(new Uint8Array(0))
-		encKey = write
-		decKey = read
-		hash = Buffer.from([])
-		readCounter = 0
-		writeCounter = 0
-		isFinished = true
-	}
-
-	const data = Buffer.from(NOISE_MODE)
-	let hash = Buffer.from(data.byteLength === 32 ? data : sha256(data))
-	let salt = hash
-	let encKey = hash
-	let decKey = hash
-	let readCounter = 0
-	let writeCounter = 0
-	let isFinished = false
-	let sentIntro = false
-
-	let inBytes = Buffer.alloc(0)
-
-	authenticate(NOISE_HEADER)
-	authenticate(publicKey)
-
-	return {
-		encrypt,
-		decrypt,
-		authenticate,
-		mixIntoKey,
-		finishInit,
-		processHandshake: ({ serverHello }: proto.HandshakeMessage, noiseKey: KeyPair) => {
-			authenticate(serverHello!.ephemeral!)
-			mixIntoKey(Curve.sharedKey(privateKey, serverHello!.ephemeral!))
-
-			const decStaticContent = decrypt(serverHello!.static!)
-			mixIntoKey(Curve.sharedKey(privateKey, decStaticContent))
-
-			const certDecoded = decrypt(serverHello!.payload!)
-
-			if(mobile) {
-				proto.CertChain.NoiseCertificate.decode(certDecoded)
-			} else {
-				const { intermediate: certIntermediate } = proto.CertChain.decode(certDecoded)
-
-				const { issuerSerial } = proto.CertChain.NoiseCertificate.Details.decode(certIntermediate!.details!)
-
-				if(issuerSerial !== WA_CERT_DETAILS.SERIAL) {
-					throw new Boom('certification match failed', { statusCode: 400 })
-				}
-			}
-
-			const keyEnc = encrypt(noiseKey.public)
-			mixIntoKey(Curve.sharedKey(noiseKey.private, serverHello!.ephemeral!))
-
-			return keyEnc
-		},
-		encodeFrame: (data: Buffer | Uint8Array) => {
-			if(isFinished) {
-				data = encrypt(data)
-			}
-
-			let header: Buffer
-
-			if(routingInfo) {
-				header = Buffer.alloc(7)
-				header.write('ED', 0, 'utf8')
-				header.writeUint8(0, 2)
-				header.writeUint8(1, 3)
-				header.writeUint8(routingInfo.byteLength >> 16, 4)
-				header.writeUint16BE(routingInfo.byteLength & 65535, 5)
-				header = Buffer.concat([header, routingInfo, NOISE_HEADER])
-			} else {
-				header = Buffer.from(NOISE_HEADER)
-			}
-
-			const introSize = sentIntro ? 0 : header.length
-			const frame = Buffer.alloc(introSize + 3 + data.byteLength)
-
-			if(!sentIntro) {
-				frame.set(header)
-				sentIntro = true
-			}
-
-			frame.writeUInt8(data.byteLength >> 16, introSize)
-			frame.writeUInt16BE(65535 & data.byteLength, introSize + 1)
-			frame.set(data, introSize + 3)
-
-			return frame
-		},
-		decodeFrame: (newData: Buffer | Uint8Array, onFrame: (buff: Uint8Array | BinaryNode) => void) => {
-			// the binary protocol uses its own framing mechanism
-			// on top of the WS frames
-			// so we get this data and separate out the frames
-			const getBytesSize = () => {
-				if(inBytes.length >= 3) {
-					return (inBytes.readUInt8() << 16) | inBytes.readUInt16BE(1)
-				}
-			}
-
-			inBytes = Buffer.concat([ inBytes, newData ])
-
-			logger.trace(`recv ${newData.length} bytes, total recv ${inBytes.length} bytes`)
-
-			let size = getBytesSize()
-			while(size && inBytes.length >= size + 3) {
-				let frame: Uint8Array | BinaryNode = inBytes.slice(3, size + 3)
-				inBytes = inBytes.slice(size + 3)
-
-				if(isFinished) {
-					const result = decrypt(frame as Uint8Array)
-					frame = decodeBinaryNode(result)
-				}
-
-				logger.trace({ msg: (frame as any)?.attrs?.id }, 'recv frame')
-
-				onFrame(frame)
-				size = getBytesSize()
-			}
-		}
-	}
-}

package/src/Utils/process-message.ts

@@ -1,414 +0,0 @@
-import { AxiosRequestConfig } from 'axios'
-import type { Logger } from 'pino'
-import { proto } from '../../WAProto'
-import { AuthenticationCreds, BaileysEventEmitter, Chat, GroupMetadata, ParticipantAction, SignalKeyStoreWithTransaction, SocketConfig, WAMessageStubType } from '../Types'
-import { getContentType, normalizeMessageContent } from '../Utils/messages'
-import { areJidsSameUser, isJidBroadcast, isJidStatusBroadcast, jidNormalizedUser } from '../WABinary'
-import { aesDecryptGCM, hmacSign } from './crypto'
-import { getKeyAuthor, toNumber } from './generics'
-import { downloadAndProcessHistorySyncNotification } from './history'
-
-type ProcessMessageContext = {
-	shouldProcessHistoryMsg: boolean
-	creds: AuthenticationCreds
-	keyStore: SignalKeyStoreWithTransaction
-	ev: BaileysEventEmitter
-	getMessage: SocketConfig['getMessage']
-	logger?: Logger
-	options: AxiosRequestConfig<{}>
-}
-
-const REAL_MSG_STUB_TYPES = new Set([
-	WAMessageStubType.CALL_MISSED_GROUP_VIDEO,
-	WAMessageStubType.CALL_MISSED_GROUP_VOICE,
-	WAMessageStubType.CALL_MISSED_VIDEO,
-	WAMessageStubType.CALL_MISSED_VOICE
-])
-
-const REAL_MSG_REQ_ME_STUB_TYPES = new Set([
-	WAMessageStubType.GROUP_PARTICIPANT_ADD
-])
-
-/** Cleans a received message to further processing */
-export const cleanMessage = (message: proto.IWebMessageInfo, meId: string) => {
-	// ensure remoteJid and participant doesn't have device or agent in it
-	message.key.remoteJid = jidNormalizedUser(message.key.remoteJid!)
-	message.key.participant = message.key.participant ? jidNormalizedUser(message.key.participant!) : undefined
-	const content = normalizeMessageContent(message.message)
-	// if the message has a reaction, ensure fromMe & remoteJid are from our perspective
-	if(content?.reactionMessage) {
-		normaliseKey(content.reactionMessage.key!)
-	}
-
-	if(content?.pollUpdateMessage) {
-		normaliseKey(content.pollUpdateMessage.pollCreationMessageKey!)
-	}
-
-	function normaliseKey(msgKey: proto.IMessageKey) {
-		// if the reaction is from another user
-		// we've to correctly map the key to this user's perspective
-		if(!message.key.fromMe) {
-			// if the sender believed the message being reacted to is not from them
-			// we've to correct the key to be from them, or some other participant
-			msgKey.fromMe = !msgKey.fromMe
-				? areJidsSameUser(msgKey.participant || msgKey.remoteJid!, meId)
-				// if the message being reacted to, was from them
-				// fromMe automatically becomes false
-				: false
-			// set the remoteJid to being the same as the chat the message came from
-			msgKey.remoteJid = message.key.remoteJid
-			// set participant of the message
-			msgKey.participant = msgKey.participant || message.key.participant
-		}
-	}
-}
-
-export const isRealMessage = (message: proto.IWebMessageInfo, meId: string) => {
-	const normalizedContent = normalizeMessageContent(message.message)
-	const hasSomeContent = !!getContentType(normalizedContent)
-	return (
-		!!normalizedContent
-		|| REAL_MSG_STUB_TYPES.has(message.messageStubType!)
-		|| (
-			REAL_MSG_REQ_ME_STUB_TYPES.has(message.messageStubType!)
-			&& message.messageStubParameters?.some(p => areJidsSameUser(meId, p))
-		)
-	)
-	&& hasSomeContent
-	&& !normalizedContent?.protocolMessage
-	&& !normalizedContent?.reactionMessage
-	&& !normalizedContent?.pollUpdateMessage
-}
-
-export const shouldIncrementChatUnread = (message: proto.IWebMessageInfo) => (
-	!message.key.fromMe && !message.messageStubType
-)
-
-/**
- * Get the ID of the chat from the given key.
- * Typically -- that'll be the remoteJid, but for broadcasts, it'll be the participant
- */
-export const getChatId = ({ remoteJid, participant, fromMe }: proto.IMessageKey) => {
-	if(
-		isJidBroadcast(remoteJid!)
-		&& !isJidStatusBroadcast(remoteJid!)
-		&& !fromMe
-	) {
-		return participant!
-	}
-
-	return remoteJid!
-}
-
-type PollContext = {
-	/** normalised jid of the person that created the poll */
-	pollCreatorJid: string
-	/** ID of the poll creation message */
-	pollMsgId: string
-	/** poll creation message enc key */
-	pollEncKey: Uint8Array
-	/** jid of the person that voted */
-	voterJid: string
-}
-
-/**
- * Decrypt a poll vote
- * @param vote encrypted vote
- * @param ctx additional info about the poll required for decryption
- * @returns list of SHA256 options
- */
-export function decryptPollVote(
-	{ encPayload, encIv }: proto.Message.IPollEncValue,
-	{
-		pollCreatorJid,
-		pollMsgId,
-		pollEncKey,
-		voterJid,
-	}: PollContext
-) {
-	const sign = Buffer.concat(
-		[
-			toBinary(pollMsgId),
-			toBinary(pollCreatorJid),
-			toBinary(voterJid),
-			toBinary('Poll Vote'),
-			new Uint8Array([1])
-		]
-	)
-
-	const key0 = hmacSign(pollEncKey, new Uint8Array(32), 'sha256')
-	const decKey = hmacSign(sign, key0, 'sha256')
-	const aad = toBinary(`${pollMsgId}\u0000${voterJid}`)
-
-	const decrypted = aesDecryptGCM(encPayload!, decKey, encIv!, aad)
-	return proto.Message.PollVoteMessage.decode(decrypted)
-
-	function toBinary(txt: string) {
-		return Buffer.from(txt)
-	}
-}
-
-const processMessage = async(
-	message: proto.IWebMessageInfo,
-	{
-		shouldProcessHistoryMsg,
-		ev,
-		creds,
-		keyStore,
-		logger,
-		options,
-		getMessage
-	}: ProcessMessageContext
-) => {
-	const meId = creds.me!.id
-	const { accountSettings } = creds
-
-	const chat: Partial<Chat> = { id: jidNormalizedUser(getChatId(message.key)) }
-	const isRealMsg = isRealMessage(message, meId)
-
-	if(isRealMsg) {
-		chat.conversationTimestamp = toNumber(message.messageTimestamp)
-		// only increment unread count if not CIPHERTEXT and from another person
-		if(shouldIncrementChatUnread(message)) {
-			chat.unreadCount = (chat.unreadCount || 0) + 1
-		}
-	}
-
-	const content = normalizeMessageContent(message.message)
-
-	// unarchive chat if it's a real message, or someone reacted to our message
-	// and we've the unarchive chats setting on
-	if(
-		(isRealMsg || content?.reactionMessage?.key?.fromMe)
-		&& accountSettings?.unarchiveChats
-	) {
-		chat.archived = false
-		chat.readOnly = false
-	}
-
-	const protocolMsg = content?.protocolMessage
-	if(protocolMsg) {
-		switch (protocolMsg.type) {
-		case proto.Message.ProtocolMessage.Type.HISTORY_SYNC_NOTIFICATION:
-			const histNotification = protocolMsg!.historySyncNotification!
-			const process = shouldProcessHistoryMsg
-			const isLatest = !creds.processedHistoryMessages?.length
-
-			logger?.info({
-				histNotification,
-				process,
-				id: message.key.id,
-				isLatest,
-			}, 'got history notification')
-
-			if(process) {
-				ev.emit('creds.update', {
-					processedHistoryMessages: [
-						...(creds.processedHistoryMessages || []),
-						{ key: message.key, messageTimestamp: message.messageTimestamp }
-					]
-				})
-
-				const data = await downloadAndProcessHistorySyncNotification(
-					histNotification,
-					options
-				)
-
-				ev.emit('messaging-history.set', { ...data, isLatest })
-			}
-
-			break
-		case proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_SHARE:
-			const keys = protocolMsg.appStateSyncKeyShare!.keys
-			if(keys?.length) {
-				let newAppStateSyncKeyId = ''
-				await keyStore.transaction(
-					async() => {
-						const newKeys: string[] = []
-						for(const { keyData, keyId } of keys) {
-							const strKeyId = Buffer.from(keyId!.keyId!).toString('base64')
-							newKeys.push(strKeyId)
-
-							await keyStore.set({ 'app-state-sync-key': { [strKeyId]: keyData! } })
-
-							newAppStateSyncKeyId = strKeyId
-						}
-
-						logger?.info(
-							{ newAppStateSyncKeyId, newKeys },
-							'injecting new app state sync keys'
-						)
-					}
-				)
-
-				ev.emit('creds.update', { myAppStateKeyId: newAppStateSyncKeyId })
-			} else {
-				logger?.info({ protocolMsg }, 'recv app state sync with 0 keys')
-			}
-
-			break
-		case proto.Message.ProtocolMessage.Type.REVOKE:
-			ev.emit('messages.update', [
-				{
-					key: {
-						...message.key,
-						id: protocolMsg.key!.id
-					},
-					update: { message: null, messageStubType: WAMessageStubType.REVOKE, key: message.key }
-				}
-			])
-			break
-		case proto.Message.ProtocolMessage.Type.EPHEMERAL_SETTING:
-			Object.assign(chat, {
-				ephemeralSettingTimestamp: toNumber(message.messageTimestamp),
-				ephemeralExpiration: protocolMsg.ephemeralExpiration || null
-			})
-			break
-		case proto.Message.ProtocolMessage.Type.PEER_DATA_OPERATION_REQUEST_RESPONSE_MESSAGE:
-			const response = protocolMsg.peerDataOperationRequestResponseMessage!
-			if(response) {
-				const { peerDataOperationResult } = response
-				for(const result of peerDataOperationResult!) {
-					const { placeholderMessageResendResponse: retryResponse } = result
-					if(retryResponse) {
-						const webMessageInfo = proto.WebMessageInfo.decode(retryResponse.webMessageInfoBytes!)
-						ev.emit('messages.update', [
-							{ key: webMessageInfo.key, update: { message: webMessageInfo.message } }
-						])
-					}
-				}
-			}
-
-			break
-		}
-	} else if(content?.reactionMessage) {
-		const reaction: proto.IReaction = {
-			...content.reactionMessage,
-			key: message.key,
-		}
-		ev.emit('messages.reaction', [{
-			reaction,
-			key: content.reactionMessage!.key!,
-		}])
-	} else if(message.messageStubType) {
-		const jid = message.key!.remoteJid!
-		//let actor = whatsappID (message.participant)
-		let participants: string[]
-		const emitParticipantsUpdate = (action: ParticipantAction) => (
-			ev.emit('group-participants.update', { id: jid, author: message.participant!, participants, action })
-		)
-		const emitGroupUpdate = (update: Partial<GroupMetadata>) => {
-			ev.emit('groups.update', [{ id: jid, ...update, author: message.participant ?? undefined }])
-		}
-
-		const participantsIncludesMe = () => participants.find(jid => areJidsSameUser(meId, jid))
-
-		switch (message.messageStubType) {
-		case WAMessageStubType.GROUP_PARTICIPANT_LEAVE:
-		case WAMessageStubType.GROUP_PARTICIPANT_REMOVE:
-			participants = message.messageStubParameters || []
-			emitParticipantsUpdate('remove')
-			// mark the chat read only if you left the group
-			if(participantsIncludesMe()) {
-				chat.readOnly = true
-			}
-
-			break
-		case WAMessageStubType.GROUP_PARTICIPANT_ADD:
-		case WAMessageStubType.GROUP_PARTICIPANT_INVITE:
-		case WAMessageStubType.GROUP_PARTICIPANT_ADD_REQUEST_JOIN:
-			participants = message.messageStubParameters || []
-			if(participantsIncludesMe()) {
-				chat.readOnly = false
-			}
-
-			emitParticipantsUpdate('add')
-			break
-		case WAMessageStubType.GROUP_PARTICIPANT_DEMOTE:
-			participants = message.messageStubParameters || []
-			emitParticipantsUpdate('demote')
-			break
-		case WAMessageStubType.GROUP_PARTICIPANT_PROMOTE:
-			participants = message.messageStubParameters || []
-			emitParticipantsUpdate('promote')
-			break
-		case WAMessageStubType.GROUP_CHANGE_ANNOUNCE:
-			const announceValue = message.messageStubParameters?.[0]
-			emitGroupUpdate({ announce: announceValue === 'true' || announceValue === 'on' })
-			break
-		case WAMessageStubType.GROUP_CHANGE_RESTRICT:
-			const restrictValue = message.messageStubParameters?.[0]
-			emitGroupUpdate({ restrict: restrictValue === 'true' || restrictValue === 'on' })
-			break
-		case WAMessageStubType.GROUP_CHANGE_SUBJECT:
-			const name = message.messageStubParameters?.[0]
-			chat.name = name
-			emitGroupUpdate({ subject: name })
-			break
-		case WAMessageStubType.GROUP_CHANGE_INVITE_LINK:
-			const code = message.messageStubParameters?.[0]
-			emitGroupUpdate({ inviteCode: code })
-			break
-		case WAMessageStubType.GROUP_MEMBER_ADD_MODE:
-			const memberAddValue = message.messageStubParameters?.[0]
-			emitGroupUpdate({ memberAddMode: memberAddValue === 'all_member_add' })
-			break
-		case WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE:
-			const approvalMode = message.messageStubParameters?.[0]
-			emitGroupUpdate({ joinApprovalMode: approvalMode === 'on' })
-			break
-		}
-	} else if(content?.pollUpdateMessage) {
-		const creationMsgKey = content.pollUpdateMessage.pollCreationMessageKey!
-		// we need to fetch the poll creation message to get the poll enc key
-		const pollMsg = await getMessage(creationMsgKey)
-		if(pollMsg) {
-			const meIdNormalised = jidNormalizedUser(meId)
-			const pollCreatorJid = getKeyAuthor(creationMsgKey, meIdNormalised)
-			const voterJid = getKeyAuthor(message.key!, meIdNormalised)
-			const pollEncKey = pollMsg.messageContextInfo?.messageSecret!
-
-			try {
-				const voteMsg = decryptPollVote(
-					content.pollUpdateMessage.vote!,
-					{
-						pollEncKey,
-						pollCreatorJid,
-						pollMsgId: creationMsgKey.id!,
-						voterJid,
-					}
-				)
-				ev.emit('messages.update', [
-					{
-						key: creationMsgKey,
-						update: {
-							pollUpdates: [
-								{
-									pollUpdateMessageKey: message.key,
-									vote: voteMsg,
-									senderTimestampMs: (content.pollUpdateMessage.senderTimestampMs! as Long).toNumber(),
-								}
-							]
-						}
-					}
-				])
-			} catch(err) {
-				logger?.warn(
-					{ err, creationMsgKey },
-					'failed to decrypt poll vote'
-				)
-			}
-		} else {
-			logger?.warn(
-				{ creationMsgKey },
-				'poll creation message not found, cannot decrypt update'
-			)
-		}
-	}
-
-	if(Object.keys(chat).length > 1) {
-		ev.emit('chats.update', [chat])
-	}
-}
-
-export default processMessage