@badzz88/baileys 8.4.7 → 8.5.0

package/lib/Utils/validate-connection.js

@@ -1,203 +1,219 @@
-import { Boom } from '@hapi/boom';
-import { createHash } from 'crypto';
-import { proto } from '../../WAProto/index.js';
-import { KEY_BUNDLE_TYPE, WA_ADV_ACCOUNT_SIG_PREFIX, WA_ADV_DEVICE_SIG_PREFIX, WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX } from '../Defaults/index.js';
-import { getBinaryNodeChild, jidDecode, S_WHATSAPP_NET } from '../WABinary/index.js';
-import { Curve, hmacSign } from './crypto.js';
-import { encodeBigEndian } from './generics.js';
-import { createSignalIdentity } from './signal.js';
-const getUserAgent = (config) => {
-    return {
-        appVersion: {
-            primary: config.version[0],
-            secondary: config.version[1],
-            tertiary: config.version[2]
-        },
-        platform: proto.ClientPayload.UserAgent.Platform.MACOS,
-        releaseChannel: proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
-        osVersion: '0.1',
-        device: 'Desktop',
-        osBuildNumber: '0.1',
-        localeLanguageIso6391: 'en',
-        mnc: '000',
-        mcc: '000',
-        localeCountryIso31661Alpha2: config.countryCode
-    };
-};
+'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': proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
-    Windows: proto.ClientPayload.WebInfo.WebSubPlatform.WIN32
-};
-const getWebInfo = (config) => {
-    let webSubPlatform = 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: proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
-        connectReason: proto.ClientPayload.ConnectReason.USER_ACTIVATED,
-        userAgent: getUserAgent(config)
-    };
-    payload.webInfo = getWebInfo(config);
-    if (config.pushName) {
-        payload.pushName = config.pushName;
-    }
-    return payload;
-};
-export const generateLoginNode = (userJid, config) => {
-    const { user, device } = jidDecode(userJid);
-    const payload = {
-        ...getClientPayload(config),
-        passive: true,
-        pull: true,
-        username: +user,
-        device: device,
-        // TODO: investigate (hard set as false atm)
-        lidDbMigrated: false
-    };
-    return proto.ClientPayload.fromObject(payload);
-};
-const getPlatformType = (platform) => {
-    const platformType = platform.toUpperCase();
-    return (proto.DeviceProps.PlatformType[platformType] ||
-        proto.DeviceProps.PlatformType.CHROME);
-};
-export const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentityKey }, config) => {
-    // the app version needs to be md5 hashed
-    // and passed in
-    const appVersionBuf = createHash('md5')
-        .update(config.version.join('.')) // join as string
-        .digest();
-    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 = proto.DeviceProps.encode(companion).finish();
-    const registerPayload = {
-        ...getClientPayload(config),
-        passive: false,
-        pull: false,
-        devicePairingData: {
-            buildHash: appVersionBuf,
-            deviceProps: companionProto,
-            eRegid: encodeBigEndian(registrationId),
-            eKeytype: KEY_BUNDLE_TYPE,
-            eIdent: signedIdentityKey.public,
-            eSkeyId: encodeBigEndian(signedPreKey.keyId, 3),
-            eSkeyVal: signedPreKey.keyPair.public,
-            eSkeySig: signedPreKey.signature
-        }
-    };
-    return proto.ClientPayload.fromObject(registerPayload);
-};
-export const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, signalIdentities }) => {
-    const msgId = stanza.attrs.id;
-    const pairSuccessNode = getBinaryNodeChild(stanza, 'pair-success');
-    const deviceIdentityNode = getBinaryNodeChild(pairSuccessNode, 'device-identity');
-    const platformNode = getBinaryNodeChild(pairSuccessNode, 'platform');
-    const deviceNode = getBinaryNodeChild(pairSuccessNode, 'device');
-    const businessNode = getBinaryNodeChild(pairSuccessNode, 'biz');
-    if (!deviceIdentityNode || !deviceNode) {
-        throw new 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 } = proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content);
-    let hmacPrefix = Buffer.from([]);
-    if (accountType !== undefined && accountType === proto.ADVEncryptionType.HOSTED) {
-        hmacPrefix = WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX;
-    }
-    const advSign = hmacSign(Buffer.concat([hmacPrefix, details]), Buffer.from(advSecretKey, 'base64'));
-    if (Buffer.compare(hmac, advSign) !== 0) {
-        throw new Boom('Invalid account signature');
-    }
-    const account = proto.ADVSignedDeviceIdentity.decode(details);
-    const { accountSignatureKey, accountSignature, details: deviceDetails } = account;
-    const deviceIdentity = proto.ADVDeviceIdentity.decode(deviceDetails);
-    const accountSignaturePrefix = deviceIdentity.deviceType === proto.ADVEncryptionType.HOSTED
-        ? WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX
-        : WA_ADV_ACCOUNT_SIG_PREFIX;
-    const accountMsg = Buffer.concat([accountSignaturePrefix, deviceDetails, signedIdentityKey.public]);
-    if (!Curve.verify(accountSignatureKey, accountMsg, accountSignature)) {
-        throw new Boom('Failed to verify account signature');
-    }
-    const deviceMsg = Buffer.concat([
-        WA_ADV_DEVICE_SIG_PREFIX,
-        deviceDetails,
-        signedIdentityKey.public,
-        accountSignatureKey
-    ]);
-    account.deviceSignature = Curve.sign(signedIdentityKey.private, deviceMsg);
-    const identity = createSignalIdentity(lid, accountSignatureKey);
-    const accountEnc = encodeSignedDeviceIdentity(account, false);
-    const reply = {
-        tag: 'iq',
-        attrs: {
-            to: 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
-    };
-};
-export 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 proto.ADVSignedDeviceIdentity.encode(account).finish();
-};
-//# sourceMappingURL=validate-connection.js.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.d.ts

@@ -0,0 +1,9 @@
+export interface AutoCacheViewOnceOptions {
+	cacheDir?: string
+	logger?: any
+	onCached?: (info: { id: string; jid: string; filePath: string; type: string }) => void
+}
+
+export function getViewOnceContent(message: any): Record<string, any> | null
+
+export function autoCacheViewOnceMedia(sock: any, options?: AutoCacheViewOnceOptions): () => void

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