@sixcore/baileys 1.0.0 → 1.0.2

package/src/Utils/signal.ts

@@ -1,214 +0,0 @@
-import { KEY_BUNDLE_TYPE } from '../Defaults'
-import type { SignalRepositoryWithLIDStore } from '../Types'
-import type {
-	AuthenticationCreds,
-	AuthenticationState,
-	KeyPair,
-	SignalIdentity,
-	SignalKeyStore,
-	SignedKeyPair
-} from '../Types/Auth'
-import {
-	assertNodeErrorFree,
-	type BinaryNode,
-	type FullJid,
-	getBinaryNodeChild,
-	getBinaryNodeChildBuffer,
-	getBinaryNodeChildren,
-	getBinaryNodeChildUInt,
-	getServerFromDomainType,
-	jidDecode,
-	S_WHATSAPP_NET,
-	WAJIDDomains
-} from '../WABinary'
-import type { DeviceListData, ParsedDeviceInfo, USyncQueryResultList } from '../WAUSync'
-import { Curve, generateSignalPubKey } from './crypto'
-import { encodeBigEndian } from './generics'
-
-function chunk<T>(array: T[], size: number): T[][] {
-	const chunks: T[][] = []
-	for (let i = 0; i < array.length; i += size) {
-		chunks.push(array.slice(i, i + size))
-	}
-
-	return chunks
-}
-
-export const createSignalIdentity = (wid: string, accountSignatureKey: Uint8Array): SignalIdentity => {
-	return {
-		identifier: { name: wid, deviceId: 0 },
-		identifierKey: generateSignalPubKey(accountSignatureKey)
-	}
-}
-
-export const getPreKeys = async ({ get }: SignalKeyStore, min: number, limit: number) => {
-	const idList: string[] = []
-	for (let id = min; id < limit; id++) {
-		idList.push(id.toString())
-	}
-
-	return get('pre-key', idList)
-}
-
-export const generateOrGetPreKeys = (creds: AuthenticationCreds, range: number) => {
-	const avaliable = creds.nextPreKeyId - creds.firstUnuploadedPreKeyId
-	const remaining = range - avaliable
-	const lastPreKeyId = creds.nextPreKeyId + remaining - 1
-	const newPreKeys: { [id: number]: KeyPair } = {}
-	if (remaining > 0) {
-		for (let i = creds.nextPreKeyId; i <= lastPreKeyId; i++) {
-			newPreKeys[i] = Curve.generateKeyPair()
-		}
-	}
-
-	return {
-		newPreKeys,
-		lastPreKeyId,
-		preKeysRange: [creds.firstUnuploadedPreKeyId, range] as const
-	}
-}
-
-export const xmppSignedPreKey = (key: SignedKeyPair): BinaryNode => ({
-	tag: 'skey',
-	attrs: {},
-	content: [
-		{ tag: 'id', attrs: {}, content: encodeBigEndian(key.keyId, 3) },
-		{ tag: 'value', attrs: {}, content: key.keyPair.public },
-		{ tag: 'signature', attrs: {}, content: key.signature }
-	]
-})
-
-export const xmppPreKey = (pair: KeyPair, id: number): BinaryNode => ({
-	tag: 'key',
-	attrs: {},
-	content: [
-		{ tag: 'id', attrs: {}, content: encodeBigEndian(id, 3) },
-		{ tag: 'value', attrs: {}, content: pair.public }
-	]
-})
-
-export const parseAndInjectE2ESessions = async (node: BinaryNode, repository: SignalRepositoryWithLIDStore) => {
-	const extractKey = (key: BinaryNode) =>
-		key
-			? {
-					keyId: getBinaryNodeChildUInt(key, 'id', 3)!,
-					publicKey: generateSignalPubKey(getBinaryNodeChildBuffer(key, 'value')!),
-					signature: getBinaryNodeChildBuffer(key, 'signature')!
-				}
-			: undefined
-	const nodes = getBinaryNodeChildren(getBinaryNodeChild(node, 'list'), 'user')
-	for (const node of nodes) {
-		assertNodeErrorFree(node)
-	}
-
-	// Most of the work in repository.injectE2ESession is CPU intensive, not IO
-	// So Promise.all doesn't really help here,
-	// but blocks even loop if we're using it inside keys.transaction, and it makes it "sync" actually
-	// This way we chunk it in smaller parts and between those parts we can yield to the event loop
-	// It's rare case when you need to E2E sessions for so many users, but it's possible
-	const chunkSize = 100
-	const chunks = chunk(nodes, chunkSize)
-
-	for (const nodesChunk of chunks) {
-		for (const node of nodesChunk) {
-			const signedKey = getBinaryNodeChild(node, 'skey')!
-			const key = getBinaryNodeChild(node, 'key')!
-			const identity = getBinaryNodeChildBuffer(node, 'identity')!
-			const jid = node.attrs.jid!
-
-			const registrationId = getBinaryNodeChildUInt(node, 'registration', 4)
-
-			await repository.injectE2ESession({
-				jid,
-				session: {
-					registrationId: registrationId!,
-					identityKey: generateSignalPubKey(identity),
-					signedPreKey: extractKey(signedKey)!,
-					preKey: extractKey(key)!
-				}
-			})
-		}
-	}
-}
-
-export const extractDeviceJids = (
-	result: USyncQueryResultList[],
-	myJid: string,
-	myLid: string,
-	excludeZeroDevices: boolean
-) => {
-	const { user: myUser, device: myDevice } = jidDecode(myJid)!
-
-	const extracted: FullJid[] = []
-
-	for (const userResult of result) {
-		const { devices, id } = userResult as { devices: ParsedDeviceInfo; id: string }
-		const decoded = jidDecode(id)!,
-			{ user, server } = decoded
-		let { domainType } = decoded
-		const deviceList = devices?.deviceList as DeviceListData[]
-		if (!Array.isArray(deviceList)) continue
-		for (const { id: device, keyIndex, isHosted } of deviceList) {
-			if (
-				(!excludeZeroDevices || device !== 0) && // if zero devices are not-excluded, or device is non zero
-				((myUser !== user && myLid !== user) || myDevice !== device) && // either different user or if me user, not this device
-				(device === 0 || !!keyIndex) // ensure that "key-index" is specified for "non-zero" devices, produces a bad req otherwise
-			) {
-				if (isHosted) {
-					domainType = domainType === WAJIDDomains.LID ? WAJIDDomains.HOSTED_LID : WAJIDDomains.HOSTED
-				}
-
-				extracted.push({
-					user,
-					device,
-					domainType,
-					server: getServerFromDomainType(server, domainType)
-				})
-			}
-		}
-	}
-
-	return extracted
-}
-
-/**
- * get the next N keys for upload or processing
- * @param count number of pre-keys to get or generate
- */
-export const getNextPreKeys = async ({ creds, keys }: AuthenticationState, count: number) => {
-	const { newPreKeys, lastPreKeyId, preKeysRange } = generateOrGetPreKeys(creds, count)
-
-	const update: Partial<AuthenticationCreds> = {
-		nextPreKeyId: Math.max(lastPreKeyId + 1, creds.nextPreKeyId),
-		firstUnuploadedPreKeyId: Math.max(creds.firstUnuploadedPreKeyId, lastPreKeyId + 1)
-	}
-
-	await keys.set({ 'pre-key': newPreKeys })
-
-	const preKeys = await getPreKeys(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1])
-
-	return { update, preKeys }
-}
-
-export const getNextPreKeysNode = async (state: AuthenticationState, count: number) => {
-	const { creds } = state
-	const { update, preKeys } = await getNextPreKeys(state, count)
-
-	const node: BinaryNode = {
-		tag: 'iq',
-		attrs: {
-			xmlns: 'encrypt',
-			type: 'set',
-			to: S_WHATSAPP_NET
-		},
-		content: [
-			{ tag: 'registration', attrs: {}, content: encodeBigEndian(creds.registrationId) },
-			{ tag: 'type', attrs: {}, content: KEY_BUNDLE_TYPE },
-			{ tag: 'identity', attrs: {}, content: creds.signedIdentityKey.public },
-			{ tag: 'list', attrs: {}, content: Object.keys(preKeys).map(k => xmppPreKey(preKeys[+k]!, +k)) },
-			xmppSignedPreKey(creds.signedPreKey)
-		]
-	}
-
-	return { update, node }
-}

package/src/Utils/use-multi-file-auth-state.ts

@@ -1,136 +0,0 @@
-import { Mutex } from 'async-mutex'
-import { mkdir, readFile, stat, unlink, writeFile } from 'fs/promises'
-import { join } from 'path'
-import { proto } from '../../WAProto/index.js'
-import type { AuthenticationCreds, AuthenticationState, SignalDataTypeMap } from '../Types'
-import { initAuthCreds } from './auth-utils'
-import { BufferJSON } from './generics'
-
-// We need to lock files due to the fact that we are using async functions to read and write files
-// https://github.com/WhiskeySockets/Baileys/issues/794
-// https://github.com/nodejs/node/issues/26338
-// Use a Map to store mutexes for each file path
-const fileLocks = new Map<string, Mutex>()
-
-// Get or create a mutex for a specific file path
-const getFileLock = (path: string): Mutex => {
-	let mutex = fileLocks.get(path)
-	if (!mutex) {
-		mutex = new Mutex()
-		fileLocks.set(path, mutex)
-	}
-
-	return mutex
-}
-
-/**
- * stores the full authentication state in a single folder.
- * Far more efficient than singlefileauthstate
- *
- * Again, I wouldn't endorse this for any production level use other than perhaps a bot.
- * Would recommend writing an auth state for use with a proper SQL or No-SQL DB
- * */
-export const useMultiFileAuthState = async (
-	folder: string
-): Promise<{ state: AuthenticationState; saveCreds: () => Promise<void> }> => {
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	const writeData = async (data: any, file: string) => {
-		const filePath = join(folder, fixFileName(file)!)
-		const mutex = getFileLock(filePath)
-
-		return mutex.acquire().then(async release => {
-			try {
-				await writeFile(filePath, JSON.stringify(data, BufferJSON.replacer))
-			} finally {
-				release()
-			}
-		})
-	}
-
-	const readData = async (file: string) => {
-		try {
-			const filePath = join(folder, fixFileName(file)!)
-			const mutex = getFileLock(filePath)
-
-			return await mutex.acquire().then(async release => {
-				try {
-					const data = await readFile(filePath, { encoding: 'utf-8' })
-					return JSON.parse(data, BufferJSON.reviver)
-				} finally {
-					release()
-				}
-			})
-		} catch (error) {
-			return null
-		}
-	}
-
-	const removeData = async (file: string) => {
-		try {
-			const filePath = join(folder, fixFileName(file)!)
-			const mutex = getFileLock(filePath)
-
-			return mutex.acquire().then(async release => {
-				try {
-					await unlink(filePath)
-				} catch {
-				} finally {
-					release()
-				}
-			})
-		} catch {}
-	}
-
-	const folderInfo = await stat(folder).catch(() => {})
-	if (folderInfo) {
-		if (!folderInfo.isDirectory()) {
-			throw new Error(
-				`found something that is not a directory at ${folder}, either delete it or specify a different location`
-			)
-		}
-	} else {
-		await mkdir(folder, { recursive: true })
-	}
-
-	const fixFileName = (file?: string) => file?.replace(/\//g, '__')?.replace(/:/g, '-')
-
-	const creds: AuthenticationCreds = (await readData('creds.json')) || initAuthCreds()
-
-	return {
-		state: {
-			creds,
-			keys: {
-				get: async (type, ids) => {
-					const data: { [_: string]: SignalDataTypeMap[typeof type] } = {}
-					await Promise.all(
-						ids.map(async id => {
-							let value = await readData(`${type}-${id}.json`)
-							if (type === 'app-state-sync-key' && value) {
-								value = proto.Message.AppStateSyncKeyData.fromObject(value)
-							}
-
-							data[id] = value
-						})
-					)
-
-					return data
-				},
-				set: async data => {
-					const tasks: Promise<void>[] = []
-					for (const category in data) {
-						for (const id in data[category as keyof SignalDataTypeMap]) {
-							const value = data[category as keyof SignalDataTypeMap]![id]
-							const file = `${category}-${id}.json`
-							tasks.push(value ? writeData(value, file) : removeData(file))
-						}
-					}
-
-					await Promise.all(tasks)
-				}
-			}
-		},
-		saveCreds: async () => {
-			return writeData(creds, 'creds.json')
-		}
-	}
-}

package/src/Utils/validate-connection.ts

@@ -1,253 +0,0 @@
-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'
-import type { AuthenticationCreds, SignalCreds, SocketConfig } from '../Types'
-import { type BinaryNode, getBinaryNodeChild, jidDecode, S_WHATSAPP_NET } from '../WABinary'
-import { Curve, hmacSign } from './crypto'
-import { encodeBigEndian } from './generics'
-import { createSignalIdentity } from './signal'
-
-const getUserAgent = (config: SocketConfig): proto.ClientPayload.IUserAgent => {
-	return {
-		appVersion: {
-			primary: config.version[0],
-			secondary: config.version[1],
-			tertiary: config.version[2]
-		},
-		platform: proto.ClientPayload.UserAgent.Platform.WEB,
-		releaseChannel: 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: SocketConfig): proto.ClientPayload.IWebInfo => {
-	let webSubPlatform = proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER
-	if (
-		config.syncFullHistory &&
-		PLATFORM_MAP[config.browser[0] as keyof typeof PLATFORM_MAP] &&
-		config.browser[1] === 'Desktop'
-	) {
-		webSubPlatform = PLATFORM_MAP[config.browser[0] as keyof typeof PLATFORM_MAP]
-	}
-
-	return { webSubPlatform }
-}
-
-const getClientPayload = (config: SocketConfig) => {
-	const payload: proto.IClientPayload = {
-		connectType: proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
-		connectReason: proto.ClientPayload.ConnectReason.USER_ACTIVATED,
-		userAgent: getUserAgent(config)
-	}
-
-	payload.webInfo = getWebInfo(config)
-
-	return payload
-}
-
-export const generateLoginNode = (userJid: string, config: SocketConfig): proto.IClientPayload => {
-	const { user, device } = jidDecode(userJid)!
-	const payload: proto.IClientPayload = {
-		...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: string): proto.DeviceProps.PlatformType => {
-	const platformType = platform.toUpperCase()
-	return (
-		proto.DeviceProps.PlatformType[platformType as keyof typeof proto.DeviceProps.PlatformType] ||
-		proto.DeviceProps.PlatformType.CHROME
-	)
-}
-
-export const generateRegistrationNode = (
-	{ registrationId, signedPreKey, signedIdentityKey }: SignalCreds,
-	config: SocketConfig
-) => {
-	// 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: proto.IDeviceProps = {
-		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: proto.IClientPayload = {
-		...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: BinaryNode,
-	{
-		advSecretKey,
-		signedIdentityKey,
-		signalIdentities
-	}: Pick<AuthenticationCreds, '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 as Buffer)
-
-	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: BinaryNode = {
-		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: Partial<AuthenticationCreds> = {
-		account,
-		me: { id: jid!, name: bizName, lid },
-		signalIdentities: [...(signalIdentities || []), identity],
-		platform: platformNode?.attrs.name
-	}
-
-	return {
-		creds: authUpdate,
-		reply
-	}
-}
-
-export const encodeSignedDeviceIdentity = (account: proto.IADVSignedDeviceIdentity, includeSignatureKey: boolean) => {
-	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()
-}