gifted-baileys 1.5.0 → 1.5.5

package/{lib → src}/Utils/use-multi-file-auth-state.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useMultiFileAuthState = void 0;
 const promises_1 = require("fs/promises");
@@ -13,53 +22,53 @@ const generics_1 = require("./generics");
  * 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
  * */
-const useMultiFileAuthState = async (folder) => {
+const useMultiFileAuthState = (folder) => __awaiter(void 0, void 0, void 0, function* () {
     const writeData = (data, file) => {
         return (0, promises_1.writeFile)((0, path_1.join)(folder, fixFileName(file)), JSON.stringify(data, generics_1.BufferJSON.replacer));
     };
-    const readData = async (file) => {
+    const readData = (file) => __awaiter(void 0, void 0, void 0, function* () {
         try {
-            const data = await (0, promises_1.readFile)((0, path_1.join)(folder, fixFileName(file)), { encoding: 'utf-8' });
+            const data = yield (0, promises_1.readFile)((0, path_1.join)(folder, fixFileName(file)), { encoding: 'utf-8' });
             return JSON.parse(data, generics_1.BufferJSON.reviver);
         }
         catch (error) {
             return null;
         }
-    };
-    const removeData = async (file) => {
+    });
+    const removeData = (file) => __awaiter(void 0, void 0, void 0, function* () {
         try {
-            await (0, promises_1.unlink)((0, path_1.join)(folder, fixFileName(file)));
+            yield (0, promises_1.unlink)((0, path_1.join)(folder, fixFileName(file)));
         }
         catch (_a) {
         }
-    };
-    const folderInfo = await (0, promises_1.stat)(folder).catch(() => { });
+    });
+    const folderInfo = yield (0, promises_1.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 (0, promises_1.mkdir)(folder, { recursive: true });
+        yield (0, promises_1.mkdir)(folder, { recursive: true });
     }
     const fixFileName = (file) => { var _a; return (_a = file === null || file === void 0 ? void 0 : file.replace(/\//g, '__')) === null || _a === void 0 ? void 0 : _a.replace(/:/g, '-'); };
-    const creds = await readData('creds.json') || (0, auth_utils_1.initAuthCreds)();
+    const creds = (yield readData('creds.json')) || (0, auth_utils_1.initAuthCreds)();
     return {
         state: {
             creds,
             keys: {
-                get: async (type, ids) => {
+                get: (type, ids) => __awaiter(void 0, void 0, void 0, function* () {
                     const data = {};
-                    await Promise.all(ids.map(async (id) => {
-                        let value = await readData(`${type}-${id}.json`);
+                    yield Promise.all(ids.map((id) => __awaiter(void 0, void 0, void 0, function* () {
+                        let value = yield readData(`${type}-${id}.json`);
                         if (type === 'app-state-sync-key' && value) {
                             value = WAProto_1.proto.Message.AppStateSyncKeyData.fromObject(value);
                         }
                         data[id] = value;
-                    }));
+                    })));
                     return data;
-                },
-                set: async (data) => {
+                }),
+                set: (data) => __awaiter(void 0, void 0, void 0, function* () {
                     const tasks = [];
                     for (const category in data) {
                         for (const id in data[category]) {
@@ -68,13 +77,13 @@ const useMultiFileAuthState = async (folder) => {
                             tasks.push(value ? writeData(value, file) : removeData(file));
                         }
                     }
-                    await Promise.all(tasks);
-                }
+                    yield Promise.all(tasks);
+                })
             }
         },
         saveCreds: () => {
             return writeData(creds, 'creds.json');
         }
     };
-};
+});
 exports.useMultiFileAuthState = useMultiFileAuthState;

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

@@ -0,0 +1,90 @@
+import { mkdir, readFile, stat, unlink, writeFile } from 'fs/promises'
+import { join } from 'path'
+import { proto } from '../../WAProto'
+import { AuthenticationCreds, AuthenticationState, SignalDataTypeMap } from '../Types'
+import { initAuthCreds } from './auth-utils'
+import { BufferJSON } from './generics'
+
+/**
+ * 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> }> => {
+
+	const writeData = (data: any, file: string) => {
+		return writeFile(join(folder, fixFileName(file)!), JSON.stringify(data, BufferJSON.replacer))
+	}
+
+	const readData = async(file: string) => {
+		try {
+			const data = await readFile(join(folder, fixFileName(file)!), { encoding: 'utf-8' })
+			return JSON.parse(data, BufferJSON.reviver)
+		} catch(error) {
+			return null
+		}
+	}
+
+	const removeData = async(file: string) => {
+		try {
+			await unlink(join(folder, fixFileName(file)!))
+		} 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]) {
+							const value = data[category][id]
+							const file = `${category}-${id}.json`
+							tasks.push(value ? writeData(value, file) : removeData(file))
+						}
+					}
+
+					await Promise.all(tasks)
+				}
+			}
+		},
+		saveCreds: () => {
+			return writeData(creds, 'creds.json')
+		}
+	}
+}

package/{lib → src}/Utils/validate-connection.js

@@ -12,29 +12,28 @@ const signal_1 = require("./signal");
 const getUserAgent = (config) => {
     var _a, _b;
     const osVersion = config.mobile ? '15.3.1' : '0.1';
-    const version = config.mobile ? [2, 22, 24] : config.version;
+    const version = config.mobile ? [2, 24, 6] : config.version;
     const device = config.mobile ? 'iPhone_7' : 'Desktop';
     const manufacturer = config.mobile ? 'Apple' : '';
-    const platform = config.mobile ? WAProto_1.proto.ClientPayload.UserAgent.Platform.IOS : WAProto_1.proto.ClientPayload.UserAgent.Platform.MACOS;
+    const platform = config.mobile ? WAProto_1.proto.ClientPayload.UserAgent.Platform.IOS : WAProto_1.proto.ClientPayload.UserAgent.Platform.WEB;
     const phoneId = config.mobile ? { phoneId: config.auth.creds.phoneId } : {};
-    return {
-        appVersion: {
+    return Object.assign({ appVersion: {
             primary: version[0],
             secondary: version[1],
             tertiary: version[2],
-        },
-        platform,
-        releaseChannel: WAProto_1.proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
-        mcc: ((_a = config.auth.creds.registration) === null || _a === void 0 ? void 0 : _a.phoneNumberMobileCountryCode) || '000',
-        mnc: ((_b = config.auth.creds.registration) === null || _b === void 0 ? void 0 : _b.phoneNumberMobileNetworkCode) || '000',
-        osVersion: osVersion,
-        manufacturer,
-        device,
-        osBuildNumber: osVersion,
-        localeLanguageIso6391: 'en',
-        localeCountryIso31661Alpha2: 'US',
-        ...phoneId
-    };
+        }, platform, releaseChannel: WAProto_1.proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE, mcc: ((_a = config.auth.creds.registration) === null || _a === void 0 ? void 0 : _a.phoneNumberMobileCountryCode) || '000', mnc: ((_b = config.auth.creds.registration) === null || _b === void 0 ? void 0 : _b.phoneNumberMobileNetworkCode) || '000', osVersion: osVersion, manufacturer,
+        device, osBuildNumber: osVersion, localeLanguageIso6391: 'en', localeCountryIso31661Alpha2: 'US' }, phoneId);
+};
+const PLATFORM_MAP = {
+    'Mac OS': WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
+    'Windows': WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.WIN32
+};
+const getWebInfo = (config) => {
+    let webSubPlatform = WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER;
+    if (config.syncFullHistory && PLATFORM_MAP[config.browser[0]]) {
+        webSubPlatform = PLATFORM_MAP[config.browser[0]];
+    }
+    return { webSubPlatform };
 };
 const getClientPayload = (config) => {
     const payload = {
@@ -42,37 +41,25 @@ const getClientPayload = (config) => {
         connectReason: WAProto_1.proto.ClientPayload.ConnectReason.USER_ACTIVATED,
         userAgent: getUserAgent(config),
     };
+    if (!config.mobile) {
+        payload.webInfo = getWebInfo(config);
+    }
     return payload;
 };
 const generateMobileNode = (config) => {
     if (!config.auth.creds) {
         throw new boom_1.Boom('No registration data found', { data: config });
     }
-    const payload = {
-        ...getClientPayload(config),
-        sessionId: Math.floor(Math.random() * 999999999 + 1),
-        shortConnect: true,
-        connectAttemptCount: 0,
-        device: 0,
-        dnsSource: {
+    const payload = Object.assign(Object.assign({}, getClientPayload(config)), { sessionId: Math.floor(Math.random() * 999999999 + 1), shortConnect: true, connectAttemptCount: 0, device: 0, dnsSource: {
             appCached: false,
             dnsMethod: WAProto_1.proto.ClientPayload.DNSSource.DNSResolutionMethod.SYSTEM,
-        },
-        passive: false,
-        pushName: 'test',
-        username: Number(`${config.auth.creds.registration.phoneNumberCountryCode}${config.auth.creds.registration.phoneNumberNationalNumber}`),
-    };
+        }, passive: false, pushName: 'test', username: Number(`${config.auth.creds.registration.phoneNumberCountryCode}${config.auth.creds.registration.phoneNumberNationalNumber}`) });
     return WAProto_1.proto.ClientPayload.fromObject(payload);
 };
 exports.generateMobileNode = generateMobileNode;
 const generateLoginNode = (userJid, config) => {
     const { user, device } = (0, WABinary_1.jidDecode)(userJid);
-    const payload = {
-        ...getClientPayload(config),
-        passive: true,
-        username: +user,
-        device: device,
-    };
+    const payload = Object.assign(Object.assign({}, getClientPayload(config)), { passive: true, username: +user, device: device });
     return WAProto_1.proto.ClientPayload.fromObject(payload);
 };
 exports.generateLoginNode = generateLoginNode;
@@ -92,10 +79,7 @@ const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentity
         requireFullSync: config.syncFullHistory,
     };
     const companionProto = WAProto_1.proto.DeviceProps.encode(companion).finish();
-    const registerPayload = {
-        ...getClientPayload(config),
-        passive: false,
-        devicePairingData: {
+    const registerPayload = Object.assign(Object.assign({}, getClientPayload(config)), { passive: false, devicePairingData: {
             buildHash: appVersionBuf,
             deviceProps: companionProto,
             eRegid: (0, generics_1.encodeBigEndian)(registrationId),
@@ -104,8 +88,7 @@ const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentity
             eSkeyId: (0, generics_1.encodeBigEndian)(signedPreKey.keyId, 3),
             eSkeyVal: signedPreKey.keyPair.public,
             eSkeySig: signedPreKey.signature,
-        },
-    };
+        } });
     return WAProto_1.proto.ClientPayload.fromObject(registerPayload);
 };
 exports.generateRegistrationNode = generateRegistrationNode;
@@ -178,7 +161,7 @@ const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, s
 exports.configureSuccessfulPairing = configureSuccessfulPairing;
 const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
     var _a;
-    account = { ...account };
+    account = Object.assign({}, 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 || !((_a = account.accountSignatureKey) === null || _a === void 0 ? void 0 : _a.length)) {

package/src/Utils/validate-connection.ts

@@ -0,0 +1,238 @@
+import { Boom } from '@hapi/boom'
+import { createHash } from 'crypto'
+import { proto } from '../../WAProto'
+import { KEY_BUNDLE_TYPE } from '../Defaults'
+import type { AuthenticationCreds, SignalCreds, SocketConfig } from '../Types'
+import { 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 => {
+	const osVersion = config.mobile ? '15.3.1' : '0.1'
+	const version = config.mobile ? [2, 24, 6] : config.version
+	const device = config.mobile ? 'iPhone_7' : 'Desktop'
+	const manufacturer = config.mobile ? 'Apple' : ''
+	const platform = config.mobile ? proto.ClientPayload.UserAgent.Platform.IOS : proto.ClientPayload.UserAgent.Platform.WEB
+	const phoneId = config.mobile ? { phoneId: config.auth.creds.phoneId } : {}
+
+	return {
+		appVersion: {
+			primary: version[0],
+			secondary: version[1],
+			tertiary: version[2],
+		},
+		platform,
+		releaseChannel: proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
+		mcc: config.auth.creds.registration?.phoneNumberMobileCountryCode || '000',
+		mnc: config.auth.creds.registration?.phoneNumberMobileNetworkCode || '000',
+		osVersion: osVersion,
+		manufacturer,
+		device,
+		osBuildNumber: osVersion,
+		localeLanguageIso6391: 'en',
+		localeCountryIso31661Alpha2: 'US',
+		...phoneId
+	}
+}
+
+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]]) {
+		webSubPlatform = PLATFORM_MAP[config.browser[0]]
+	}
+
+	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),
+	}
+
+	if(!config.mobile) {
+		payload.webInfo = getWebInfo(config)
+	}
+
+	return payload
+}
+
+export const generateMobileNode = (config: SocketConfig): proto.IClientPayload => {
+	if(!config.auth.creds) {
+		throw new Boom('No registration data found', { data: config })
+	}
+
+	const payload: proto.IClientPayload = {
+		...getClientPayload(config),
+		sessionId: Math.floor(Math.random() * 999999999 + 1),
+		shortConnect: true,
+		connectAttemptCount: 0,
+		device: 0,
+		dnsSource: {
+			appCached: false,
+			dnsMethod: proto.ClientPayload.DNSSource.DNSResolutionMethod.SYSTEM,
+		},
+		passive: false, // XMPP heartbeat setting (false: server actively pings) (true: client actively pings)
+		pushName: 'test',
+		username: Number(`${config.auth.creds.registration.phoneNumberCountryCode}${config.auth.creds.registration.phoneNumberNationalNumber}`),
+	}
+	return proto.ClientPayload.fromObject(payload)
+}
+
+export const generateLoginNode = (userJid: string, config: SocketConfig): proto.IClientPayload => {
+	const { user, device } = jidDecode(userJid)!
+	const payload: proto.IClientPayload = {
+		...getClientPayload(config),
+		passive: true,
+		username: +user,
+		device: device,
+	}
+	return proto.ClientPayload.fromObject(payload)
+}
+
+const getPlatformType = (platform: string): proto.DeviceProps.PlatformType => {
+	const platformType = platform.toUpperCase()
+	return proto.DeviceProps.PlatformType[platformType] || proto.DeviceProps.PlatformType.DESKTOP
+}
+
+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,
+	}
+
+	const companionProto = proto.DeviceProps.encode(companion).finish()
+
+	const registerPayload: proto.IClientPayload = {
+		...getClientPayload(config),
+		passive: 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 { details, hmac } = proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content as Buffer)
+	// check HMAC matches
+	const advSign = hmacSign(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
+	// verify the device signature matches
+	const accountMsg = Buffer.concat([ Buffer.from([6, 0]), deviceDetails, signedIdentityKey.public ])
+	if(!Curve.verify(accountSignatureKey, accountMsg, accountSignature)) {
+		throw new Boom('Failed to verify account signature')
+	}
+
+	// sign the details with our identity key
+	const deviceMsg = Buffer.concat([ Buffer.from([6, 1]), deviceDetails, signedIdentityKey.public, accountSignatureKey ])
+	account.deviceSignature = Curve.sign(signedIdentityKey.private, deviceMsg)
+
+	const identity = createSignalIdentity(jid, accountSignatureKey)
+	const accountEnc = encodeSignedDeviceIdentity(account, false)
+
+	const deviceIdentity = proto.ADVDeviceIdentity.decode(account.details)
+
+	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 },
+		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()
+}