@bellaxchuu/flowred 0.8.6

package/lib/Utils/validate-connection.js

@@ -0,0 +1,219 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.encodeSignedDeviceIdentity =
+	exports.configureSuccessfulPairing =
+	exports.generateRegistrationNode =
+	exports.generateLoginNode =
+		void 0
+const boom_1 = require('@hapi/boom')
+const crypto_1 = require('crypto')
+const Crypto_1 = require('./crypto')
+const index_js_1 = require('../../WAProto/index.js')
+const Defaults_1 = require('../Defaults')
+const WABinary_1 = require('../WABinary')
+const crypto_2 = require('./crypto')
+const generics_1 = require('./generics')
+const signal_1 = require('./signal')
+const getUserAgent = config => {
+	return {
+		appVersion: {
+			primary: config.version[0],
+			secondary: config.version[1],
+			tertiary: config.version[2]
+		},
+		platform: index_js_1.proto.ClientPayload.UserAgent.Platform.WEB,
+		releaseChannel: index_js_1.proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
+		osVersion: '0.1',
+		device: 'Desktop',
+		osBuildNumber: '0.1',
+		localeLanguageIso6391: 'en',
+		mnc: '000',
+		mcc: '000',
+		localeCountryIso31661Alpha2: config.countryCode
+	}
+}
+const PLATFORM_MAP = {
+	'Mac OS': index_js_1.proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
+	Windows: index_js_1.proto.ClientPayload.WebInfo.WebSubPlatform.WIN32
+}
+const getWebInfo = config => {
+	let webSubPlatform = index_js_1.proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER
+	if (config.syncFullHistory && PLATFORM_MAP[config.browser[0]] && config.browser[1] === 'Desktop') {
+		webSubPlatform = PLATFORM_MAP[config.browser[0]]
+	}
+	return { webSubPlatform }
+}
+const getClientPayload = config => {
+	const payload = {
+		connectType: index_js_1.proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
+		connectReason: index_js_1.proto.ClientPayload.ConnectReason.USER_ACTIVATED,
+		userAgent: getUserAgent(config)
+	}
+	payload.webInfo = getWebInfo(config)
+	return payload
+}
+const generateLoginNode = (userJid, config, creds) => {
+	const { user, device } = (0, WABinary_1.jidDecode)(userJid)
+	// masqueradeAsPrimary: connect as device 0 so the WA server (and interop bridges)
+	// route primary-device traffic — including interop messages — to this session.
+	// Trade-off: the real phone (device 0 on TCP) may be kicked or see a conflict.
+	const effectiveDevice = config.masqueradeAsPrimary ? 0 : device
+	const payload = {
+		...getClientPayload(config),
+		passive: !config.masqueradeAsPrimary,
+		pull: !config.masqueradeAsPrimary,
+		username: +user,
+		device: effectiveDevice,
+		lidDbMigrated: false
+	}
+	// InteropData is required for Meta/FB-linked accounts (AccountType = HOSTED).
+	// Populated from creds when present so the server routes interop traffic correctly.
+	if (creds?.interopData?.accountId) {
+		payload.interopData = {
+			accountId: creds.interopData.accountId,
+			token: creds.interopData.token,
+			enableReadReceipts: creds.interopData.enableReadReceipts ?? true
+		}
+	}
+	return index_js_1.proto.ClientPayload.fromObject(payload)
+}
+exports.generateLoginNode = generateLoginNode
+const getPlatformType = platform => {
+	const platformType = platform.toUpperCase()
+	return index_js_1.proto.DeviceProps.PlatformType[platformType] || index_js_1.proto.DeviceProps.PlatformType.CHROME
+}
+const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentityKey }, config) => {
+	// the app version needs to be md5 hashed
+	// and passed in
+	const appVersionBuf = Buffer.from(Crypto_1.md5(Buffer.from(config.version.join('.'))))
+	const companion = {
+		os: config.browser[0],
+		platformType: getPlatformType(config.browser[1]),
+		requireFullSync: config.syncFullHistory,
+		historySyncConfig: {
+			storageQuotaMb: 10240,
+			inlineInitialPayloadInE2EeMsg: true,
+			recentSyncDaysLimit: undefined,
+			supportCallLogHistory: false,
+			supportBotUserAgentChatHistory: true,
+			supportCagReactionsAndPolls: true,
+			supportBizHostedMsg: true,
+			supportRecentSyncChunkMessageCountTuning: true,
+			supportHostedGroupMsg: true,
+			supportFbidBotChatHistory: true,
+			supportAddOnHistorySyncMigration: undefined,
+			supportMessageAssociation: true,
+			supportGroupHistory: false,
+			onDemandReady: undefined,
+			supportGuestChat: undefined
+		},
+		version: {
+			primary: 10,
+			secondary: 15,
+			tertiary: 7
+		}
+	}
+	const companionProto = index_js_1.proto.DeviceProps.encode(companion).finish()
+	const registerPayload = {
+		...getClientPayload(config),
+		passive: false,
+		pull: false,
+		devicePairingData: {
+			buildHash: appVersionBuf,
+			deviceProps: companionProto,
+			eRegid: (0, generics_1.encodeBigEndian)(registrationId),
+			eKeytype: Defaults_1.KEY_BUNDLE_TYPE,
+			eIdent: signedIdentityKey.public,
+			eSkeyId: (0, generics_1.encodeBigEndian)(signedPreKey.keyId, 3),
+			eSkeyVal: signedPreKey.keyPair.public,
+			eSkeySig: signedPreKey.signature
+		}
+	}
+	return index_js_1.proto.ClientPayload.fromObject(registerPayload)
+}
+exports.generateRegistrationNode = generateRegistrationNode
+const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, signalIdentities }) => {
+	const msgId = stanza.attrs.id
+	const pairSuccessNode = (0, WABinary_1.getBinaryNodeChild)(stanza, 'pair-success')
+	const deviceIdentityNode = (0, WABinary_1.getBinaryNodeChild)(pairSuccessNode, 'device-identity')
+	const platformNode = (0, WABinary_1.getBinaryNodeChild)(pairSuccessNode, 'platform')
+	const deviceNode = (0, WABinary_1.getBinaryNodeChild)(pairSuccessNode, 'device')
+	const businessNode = (0, WABinary_1.getBinaryNodeChild)(pairSuccessNode, 'biz')
+	if (!deviceIdentityNode || !deviceNode) {
+		throw new boom_1.Boom('Missing device-identity or device in pair success node', { data: stanza })
+	}
+	const bizName = businessNode?.attrs.name
+	const jid = deviceNode.attrs.jid
+	const lid = deviceNode.attrs.lid
+	const { details, hmac, accountType } = index_js_1.proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content)
+	let hmacPrefix = Buffer.from([])
+	if (accountType !== undefined && accountType === index_js_1.proto.ADVEncryptionType.HOSTED) {
+		hmacPrefix = Defaults_1.WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX
+	}
+	const advSign = (0, crypto_2.hmacSign)(Buffer.concat([hmacPrefix, details]), Buffer.from(advSecretKey, 'base64'))
+	if (Buffer.compare(hmac, advSign) !== 0) {
+		throw new boom_1.Boom('Invalid account signature')
+	}
+	const account = index_js_1.proto.ADVSignedDeviceIdentity.decode(details)
+	const { accountSignatureKey, accountSignature, details: deviceDetails } = account
+	const deviceIdentity = index_js_1.proto.ADVDeviceIdentity.decode(deviceDetails)
+	const accountSignaturePrefix =
+		deviceIdentity.deviceType === index_js_1.proto.ADVEncryptionType.HOSTED
+			? Defaults_1.WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX
+			: Defaults_1.WA_ADV_ACCOUNT_SIG_PREFIX
+	const accountMsg = Buffer.concat([accountSignaturePrefix, deviceDetails, signedIdentityKey.public])
+	if (!crypto_2.Curve.verify(accountSignatureKey, accountMsg, accountSignature)) {
+		throw new boom_1.Boom('Failed to verify account signature')
+	}
+	const deviceMsg = Buffer.concat([
+		Defaults_1.WA_ADV_DEVICE_SIG_PREFIX,
+		deviceDetails,
+		signedIdentityKey.public,
+		accountSignatureKey
+	])
+	account.deviceSignature = crypto_2.Curve.sign(signedIdentityKey.private, deviceMsg)
+	const identity = (0, signal_1.createSignalIdentity)(lid, accountSignatureKey)
+	const accountEnc = (0, exports.encodeSignedDeviceIdentity)(account, false)
+	const reply = {
+		tag: 'iq',
+		attrs: {
+			to: WABinary_1.S_WHATSAPP_NET,
+			type: 'result',
+			id: msgId
+		},
+		content: [
+			{
+				tag: 'pair-device-sign',
+				attrs: {},
+				content: [
+					{
+						tag: 'device-identity',
+						attrs: { 'key-index': deviceIdentity.keyIndex.toString() },
+						content: accountEnc
+					}
+				]
+			}
+		]
+	}
+	const authUpdate = {
+		account,
+		me: { id: jid, name: bizName, lid },
+		signalIdentities: [...(signalIdentities || []), identity],
+		platform: platformNode?.attrs.name
+	}
+	return {
+		creds: authUpdate,
+		reply
+	}
+}
+exports.configureSuccessfulPairing = configureSuccessfulPairing
+const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
+	account = { ...account }
+	// set to null if we are not to include the signature key
+	// or if we are including the signature key but it is empty
+	if (!includeSignatureKey || !account.accountSignatureKey?.length) {
+		account.accountSignatureKey = null
+	}
+	return index_js_1.proto.ADVSignedDeviceIdentity.encode(account).finish()
+}
+exports.encodeSignedDeviceIdentity = encodeSignedDeviceIdentity

package/lib/Utils/view-once-cache.js

@@ -0,0 +1,79 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.autoCacheViewOnceMedia = void 0
+const path = require('path')
+const fs = require('fs')
+const Messages_1 = require('./messages')
+const MessagesMedia_1 = require('./messages-media')
+
+const VIEW_ONCE_WRAPPER_KEYS = ['viewOnceMessage', 'viewOnceMessageV2', 'viewOnceMessageV2Extension']
+const VIEW_ONCE_INNER_KEYS = ['imageMessage', 'videoMessage', 'audioMessage']
+
+/**
+ * Unwraps a message and returns the inner view-once media content if present, otherwise null.
+ * Handles both the wrapper style (viewOnceMessage[V2/V2Extension] -> message -> ...)
+ * and the inline style (imageMessage/videoMessage with viewOnce: true set directly).
+ */
+const getViewOnceContent = message => {
+	if (!message) return null
+	const content = (0, Messages_1.extractMessageContent)(message)
+	if (!content) return null
+	for (const wrapperKey of VIEW_ONCE_WRAPPER_KEYS) {
+		const wrapper = content[wrapperKey]
+		if (wrapper?.message) {
+			const inner = (0, Messages_1.extractMessageContent)(wrapper.message)
+			if (inner) return inner
+		}
+	}
+	for (const key of VIEW_ONCE_INNER_KEYS) {
+		if (content[key]?.viewOnce) {
+			return { [key]: content[key] }
+		}
+	}
+	return null
+}
+
+/**
+ * Registers a `messages.upsert` listener on the given socket that automatically
+ * downloads and saves view-once media (image/video/audio) to `cacheDir` as soon
+ * as it arrives, before the sender's app can mark it as opened/consumed.
+ *
+ * @param {ReturnType<typeof import('../Socket').default>} sock - an active Baileys socket
+ * @param {{ cacheDir?: string, logger?: any, onCached?: (info: { id: string, jid: string, filePath: string, type: string }) => void }} [options]
+ * @returns {() => void} a function that removes the listener
+ */
+const autoCacheViewOnceMedia = (sock, options = {}) => {
+	const cacheDir = options.cacheDir || './viewonce-cache'
+	const logger = options.logger || sock.logger
+	if (!fs.existsSync(cacheDir)) {
+		fs.mkdirSync(cacheDir, { recursive: true })
+	}
+	const handler = async ({ messages, type }) => {
+		if (type !== 'notify' && type !== 'append') return
+		for (const msg of messages) {
+			try {
+				const viewOnceContent = getViewOnceContent(msg.message)
+				if (!viewOnceContent) continue
+				const mediaType = Object.keys(viewOnceContent)[0]
+				const buffer = await (0, Messages_1.downloadMediaMessage)(
+					msg,
+					'buffer',
+					{},
+					{ logger, reuploadRequest: sock.updateMediaMessage }
+				)
+				const extension = (0, MessagesMedia_1.extensionForMediaMessage)(viewOnceContent) || 'bin'
+				const fileName = `${msg.key.id}.${extension}`
+				const filePath = path.join(cacheDir, fileName)
+				fs.writeFileSync(filePath, buffer)
+				logger?.debug?.({ id: msg.key.id, filePath, mediaType }, 'cached view-once media')
+				options.onCached?.({ id: msg.key.id, jid: msg.key.remoteJid, filePath, type: mediaType })
+			} catch (error) {
+				logger?.warn?.({ error, id: msg.key?.id }, 'failed to cache view-once media')
+			}
+		}
+	}
+	sock.ev.on('messages.upsert', handler)
+	return () => sock.ev.off('messages.upsert', handler)
+}
+exports.autoCacheViewOnceMedia = autoCacheViewOnceMedia
+exports.getViewOnceContent = getViewOnceContent

package/lib/Utils/voip-rekey.js

@@ -0,0 +1,22 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.decodeE2eRekeyPayload = void 0
+const index_js_1 = require('../../WAProto/index.js')
+const REKEY_TYPE_NAMES = {
+	[index_js_1.proto.RekeyKeyType.REKEY_KEY_AUDIO]: 'REKEY_KEY_AUDIO',
+	[index_js_1.proto.RekeyKeyType.REKEY_KEY_VIDEO]: 'REKEY_KEY_VIDEO',
+	[index_js_1.proto.RekeyKeyType.REKEY_KEY_APPDATA]: 'REKEY_KEY_APPDATA'
+}
+const decodeE2eRekeyPayload = buffer => {
+	if (!Buffer.isBuffer(buffer) && !(buffer instanceof Uint8Array)) {
+		throw new TypeError('decodeE2eRekeyPayload: buffer must be Buffer or Uint8Array')
+	}
+	const decoded = index_js_1.proto.E2eRekeyPayload.decode(buffer)
+	return {
+		keys: (decoded.keys || []).map(entry => ({
+			type: REKEY_TYPE_NAMES[entry.type] ?? entry.type,
+			key: entry.key ? Buffer.from(entry.key) : Buffer.alloc(0)
+		}))
+	}
+}
+exports.decodeE2eRekeyPayload = decodeE2eRekeyPayload