alwaysaqioo 1.1.1 → 1.1.3

package/lib/Utils/signal.js

@@ -4,7 +4,6 @@ exports.getNextPreKeysNode = exports.getNextPreKeys = exports.extractDeviceJids
 const Defaults_1 = require("../Defaults");
 const WABinary_1 = require("../WABinary");
 const crypto_1 = require("./crypto");
-const lodash_1 = require("lodash")
 const generics_1 = require("./generics");
 const createSignalIdentity = (wid, accountSignatureKey) => {
     return {
@@ -59,61 +58,60 @@ const xmppPreKey = (pair, id) => ({
 exports.xmppPreKey = xmppPreKey;
 const parseAndInjectE2ESessions = async (node, repository) => {
     const extractKey = (key) => (key ? ({
-        keyId: WABinary_1.getBinaryNodeChildUInt(key, 'id', 3),
-        publicKey: crypto_1.generateSignalPubKey(WABinary_1.getBinaryNodeChildBuffer(key, 'value')),
-        signature: WABinary_1.getBinaryNodeChildBuffer(key, 'signature')
-    }) : undefined)
-    const nodes = WABinary_1.getBinaryNodeChildren(WABinary_1.getBinaryNodeChild(node, 'list'), 'user')
+        keyId: (0, WABinary_1.getBinaryNodeChildUInt)(key, 'id', 3),
+        publicKey: (0, crypto_1.generateSignalPubKey)((0, WABinary_1.getBinaryNodeChildBuffer)(key, 'value')),
+        signature: (0, WABinary_1.getBinaryNodeChildBuffer)(key, 'signature'),
+    }) : undefined);
+    const nodes = (0, WABinary_1.getBinaryNodeChildren)((0, WABinary_1.getBinaryNodeChild)(node, 'list'), 'user');
     for (const node of nodes) {
-        WABinary_1.assertNodeErrorFree(node)
+        (0, WABinary_1.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 = lodash_1.chunk(nodes, chunkSize)
-    for (const nodesChunk of chunks) {
-        await Promise.all(nodesChunk.map(async (node) => {
-            const signedKey = WABinary_1.getBinaryNodeChild(node, 'skey')
-            const key = WABinary_1.getBinaryNodeChild(node, 'key')
-            const identity = WABinary_1.getBinaryNodeChildBuffer(node, 'identity')
-            const jid = node.attrs.jid
-            const registrationId = WABinary_1.getBinaryNodeChildUInt(node, 'registration', 4)
-            await repository.injectE2ESession({
-                jid,
-                session: {
-                    registrationId: registrationId,
-                    identityKey: crypto_1.generateSignalPubKey(identity),
-                    signedPreKey: extractKey(signedKey),
-                    preKey: extractKey(key)
-                }
-            })
-        }))
-    }
-}
+    await Promise.all(nodes.map(async (node) => {
+        const signedKey = (0, WABinary_1.getBinaryNodeChild)(node, 'skey');
+        const key = (0, WABinary_1.getBinaryNodeChild)(node, 'key');
+        const identity = (0, WABinary_1.getBinaryNodeChildBuffer)(node, 'identity');
+        const jid = node.attrs.jid;
+        const registrationId = (0, WABinary_1.getBinaryNodeChildUInt)(node, 'registration', 4);
+        await repository.injectE2ESession({
+            jid,
+            session: {
+                registrationId: registrationId,
+                identityKey: (0, crypto_1.generateSignalPubKey)(identity),
+                signedPreKey: extractKey(signedKey),
+                preKey: extractKey(key)
+            }
+        });
+    }));
+};
 exports.parseAndInjectE2ESessions = parseAndInjectE2ESessions;
 const extractDeviceJids = (result, myJid, excludeZeroDevices) => {
-    const { user: myUser, device: myDevice } = WABinary_1.jidDecode(myJid)
-    const extracted = []
-    for (const userResult of result) {
-        const { devices, id } = userResult
-        const { user } = WABinary_1.jidDecode(id)
-        const deviceList = devices?.deviceList
-        if (Array.isArray(deviceList)) {
-            for (const { id: device, keyIndex } of deviceList) {
-                if ((!excludeZeroDevices || device !== 0) && // if zero devices are not-excluded, or device is non zero
-                    (myUser !== 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
-                ) {
-                    extracted.push({ user, device })
+    var _a;
+    const { user: myUser, device: myDevice } = (0, WABinary_1.jidDecode)(myJid);
+    const extracted = [];
+    for (const node of result.content) {
+        const list = (_a = (0, WABinary_1.getBinaryNodeChild)(node, 'list')) === null || _a === void 0 ? void 0 : _a.content;
+        if (list && Array.isArray(list)) {
+            for (const item of list) {
+                const { user } = (0, WABinary_1.jidDecode)(item.attrs.jid);
+                const devicesNode = (0, WABinary_1.getBinaryNodeChild)(item, 'devices');
+                const deviceListNode = (0, WABinary_1.getBinaryNodeChild)(devicesNode, 'device-list');
+                if (Array.isArray(deviceListNode === null || deviceListNode === void 0 ? void 0 : deviceListNode.content)) {
+                    for (const { tag, attrs } of deviceListNode.content) {
+                        const device = +attrs.id;
+                        if (tag === 'device' && // ensure the "device" tag
+                            (!excludeZeroDevices || device !== 0) && // if zero devices are not-excluded, or device is non zero
+                            (myUser !== user || myDevice !== device) && // either different user or if me user, not this device
+                            (device === 0 || !!attrs['key-index']) // ensure that "key-index" is specified for "non-zero" devices, produces a bad req otherwise
+                        ) {
+                            extracted.push({ user, device });
+                        }
+                    }
                 }
             }
         }
     }
-    return extracted
-}
+    return extracted;
+};
 exports.extractDeviceJids = extractDeviceJids;
 /**
  * get the next N keys for upload or processing

package/lib/Utils/use-multi-file-auth-state.js

@@ -1,21 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useMultiFileAuthState = void 0;
-const async_mutex_1 = require("async-mutex");
 const promises_1 = require("fs/promises");
 const path_1 = require("path");
 const WAProto_1 = require("../../WAProto");
 const auth_utils_1 = require("./auth-utils");
 const generics_1 = require("./generics");
-const fileLocks = new Map();
-const getFileLock = (path) => {
-    let mutex = fileLocks.get(path);
-    if (!mutex) {
-        mutex = new async_mutex_1.Mutex();
-        fileLocks.set(path, mutex);
-    }
-    return mutex;
-};
 /**
  * stores the full authentication state in a single folder.
  * Far more efficient than singlefileauthstate
@@ -24,31 +14,13 @@ const getFileLock = (path) => {
  * Would recommend writing an auth state for use with a proper SQL or No-SQL DB
  * */
 const useMultiFileAuthState = async (folder) => {
-    const writeData = async (data, file) => {
-        const filePath = (0, path_1.join)(folder, fixFileName(file));
-        const mutex = getFileLock(filePath);
-        return mutex.acquire().then(async (release) => {
-            try {
-                await (0, promises_1.writeFile)(filePath, JSON.stringify(data, generics_1.BufferJSON.replacer));
-            }
-            finally {
-                release();
-            }
-        });
+    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) => {
         try {
-            const filePath = (0, path_1.join)(folder, fixFileName(file));
-            const mutex = getFileLock(filePath);
-            return await mutex.acquire().then(async (release) => {
-                try {
-                    const data = await (0, promises_1.readFile)(filePath, { encoding: 'utf-8' });
-                    return JSON.parse(data, generics_1.BufferJSON.reviver);
-                }
-                finally {
-                    release();
-                }
-            });
+            const data = await (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;
@@ -56,18 +28,7 @@ const useMultiFileAuthState = async (folder) => {
     };
     const removeData = async (file) => {
         try {
-            const filePath = (0, path_1.join)(folder, fixFileName(file));
-            const mutex = getFileLock(filePath);
-            return mutex.acquire().then(async (release) => {
-                try {
-                    await (0, promises_1.unlink)(filePath);
-                }
-                catch (_a) {
-                }
-                finally {
-                    release();
-                }
-            });
+            await (0, promises_1.unlink)((0, path_1.join)(folder, fixFileName(file)));
         }
         catch (_a) {
         }
@@ -111,7 +72,7 @@ const useMultiFileAuthState = async (folder) => {
                 }
             }
         },
-        saveCreds: async () => {
+        saveCreds: () => {
             return writeData(creds, 'creds.json');
         }
     };

package/lib/Utils/validate-connection.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.encodeSignedDeviceIdentity = exports.configureSuccessfulPairing = exports.generateRegistrationNode = exports.generateLoginNode = void 0;
+exports.encodeSignedDeviceIdentity = exports.configureSuccessfulPairing = exports.generateRegistrationNode = exports.generateLoginNode = exports.generateMobileNode = void 0;
 const boom_1 = require("@hapi/boom");
 const crypto_1 = require("crypto");
 const WAProto_1 = require("../../WAProto");
@@ -8,108 +8,107 @@ 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 signal_1 = require("./signal"); 
 const getUserAgent = (config) => {
+    var _a, _b;
+    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 ? 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: {
-            primary: config.version[0],
-            secondary: config.version[1],
-            tertiary: config.version[2],
+            primary: version[0],
+            secondary: version[1],
+            tertiary: version[2],
         },
-        platform: WAProto_1.proto.ClientPayload.UserAgent.Platform.WEB,
+        platform,
         releaseChannel: WAProto_1.proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
-        osVersion: '0.1',
-        device: 'Desktop',
-        osBuildNumber: '0.1',
+        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',
-        mnc: '000',
-        mcc: '000',
-        localeCountryIso31661Alpha2: config.countryCode || 'US'
+        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]] && config.browser[1] === 'Desktop') {
+    if (config.syncFullHistory && PLATFORM_MAP[config.browser[0]]) {
         webSubPlatform = PLATFORM_MAP[config.browser[0]];
     }
     return { webSubPlatform };
 };
-
 const getClientPayload = (config) => {
     const payload = {
         connectType: WAProto_1.proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
         connectReason: WAProto_1.proto.ClientPayload.ConnectReason.USER_ACTIVATED,
         userAgent: getUserAgent(config),
     };
-    payload.webInfo = getWebInfo(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: {
+            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}`),
+    };
+    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,
-        pull: true,
         username: +user,
         device: device,
-        lidDbMigrated: false
     };
     return WAProto_1.proto.ClientPayload.fromObject(payload);
 };
 exports.generateLoginNode = generateLoginNode;
-
 const getPlatformType = (platform) => {
     const platformType = platform.toUpperCase();
-    return WAProto_1.proto.DeviceProps.PlatformType[platformType] || WAProto_1.proto.DeviceProps.PlatformType.CHROME;
+    return WAProto_1.proto.DeviceProps.PlatformType[platformType] || WAProto_1.proto.DeviceProps.PlatformType.DESKTOP;
 };
-
 const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentityKey }, config) => {
+    // the app version needs to be md5 hashed
+    // and passed in
     const appVersionBuf = (0, crypto_1.createHash)('md5')
-        .update(config.version.join('.'))
+        .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 = WAProto_1.proto.DeviceProps.encode(companion).finish();
-
     const registerPayload = {
         ...getClientPayload(config),
         passive: false,
-        pull: false,
         devicePairingData: {
             buildHash: appVersionBuf,
             deviceProps: companionProto,
@@ -124,7 +123,6 @@ const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentity
     return WAProto_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');
@@ -132,52 +130,30 @@ const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, s
     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 bizName = businessNode === null || businessNode === void 0 ? void 0 : businessNode.attrs.name;
     const jid = deviceNode.attrs.jid;
-    const lid = deviceNode.attrs.lid;
-
-    const { details, hmac, accountType } = WAProto_1.proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content);
-
-    let hmacPrefix = Buffer.from([]);
-    if (accountType !== undefined && accountType === WAProto_1.proto.ADVEncryptionType.HOSTED) {
-        hmacPrefix = Buffer.from([0x06, 0x05]);
-    }
-
-    const advSign = (0, crypto_2.hmacSign)(Buffer.concat([hmacPrefix, details]), Buffer.from(advSecretKey, 'base64'));
+    const { details, hmac } = WAProto_1.proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content);
+    // check HMAC matches
+    const advSign = (0, crypto_2.hmacSign)(details, Buffer.from(advSecretKey, 'base64'));
     if (Buffer.compare(hmac, advSign) !== 0) {
         throw new boom_1.Boom('Invalid account signature');
     }
-
     const account = WAProto_1.proto.ADVSignedDeviceIdentity.decode(details);
     const { accountSignatureKey, accountSignature, details: deviceDetails } = account;
-
-    const deviceIdentity = WAProto_1.proto.ADVDeviceIdentity.decode(deviceDetails);
-
-    const accountSignaturePrefix = deviceIdentity.deviceType === WAProto_1.proto.ADVEncryptionType.HOSTED 
-        ? Buffer.from([0x06, 0x05])
-        : Buffer.from([0x06, 0x00]);
-    const accountMsg = Buffer.concat([accountSignaturePrefix, deviceDetails, signedIdentityKey.public]);
-    
+    // verify the device signature matches
+    const accountMsg = Buffer.concat([Buffer.from([6, 0]), 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([
-        Buffer.from([0x06, 0x01]),
-        deviceDetails,
-        signedIdentityKey.public,
-        accountSignatureKey
-    ]);
+    // sign the details with our identity key
+    const deviceMsg = Buffer.concat([Buffer.from([6, 1]), deviceDetails, signedIdentityKey.public, accountSignatureKey]);
     account.deviceSignature = crypto_2.Curve.sign(signedIdentityKey.private, deviceMsg);
-
     const identity = (0, signal_1.createSignalIdentity)(jid, accountSignatureKey);
     const accountEnc = (0, exports.encodeSignedDeviceIdentity)(account, false);
-
+    const deviceIdentity = WAProto_1.proto.ADVDeviceIdentity.decode(account.details);
     const reply = {
         tag: 'iq',
         attrs: {
@@ -199,27 +175,27 @@ const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, s
             }
         ]
     };
-
     const authUpdate = {
         account,
-        me: { id: jid, name: bizName, lid },
+        me: { id: jid, name: bizName },
         signalIdentities: [
             ...(signalIdentities || []),
             identity
         ],
-        platform: platformNode?.attrs.name
+        platform: platformNode === null || platformNode === void 0 ? void 0 : platformNode.attrs.name
     };
-
     return {
         creds: authUpdate,
         reply
     };
 };
 exports.configureSuccessfulPairing = configureSuccessfulPairing;
-
 const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
+    var _a;
     account = { ...account };
-    if (!includeSignatureKey || !account.accountSignatureKey?.length) {
+    // 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)) {
         account.accountSignatureKey = null;
     }
     return WAProto_1.proto.ADVSignedDeviceIdentity

package/lib/WABinary/constants.d.ts

@@ -1,30 +1,27 @@
 export declare const TAGS: {
-    LIST_EMPTY: number
-    DICTIONARY_0: number
-    DICTIONARY_1: number
-    DICTIONARY_2: number
-    DICTIONARY_3: number
-    INTEROP_JID: number
-    FB_JID: number
-    AD_JID: number
-    LIST_8: number
-    LIST_16: number
-    JID_PAIR: number
-    HEX_8: number
-    BINARY_8: number
-    BINARY_20: number
-    BINARY_32: number
-    NIBBLE_8: number
-    PACKED_MAX: number
-}
-
-export declare const DOUBLE_BYTE_TOKENS: string[][]
-
-export declare const SINGLE_BYTE_TOKENS: (string | null)[]
-
+    LIST_EMPTY: number;
+    DICTIONARY_0: number;
+    DICTIONARY_1: number;
+    DICTIONARY_2: number;
+    DICTIONARY_3: number;
+    AD_JID: number;
+    LIST_8: number;
+    LIST_16: number;
+    JID_PAIR: number;
+    HEX_8: number;
+    BINARY_8: number;
+    BINARY_20: number;
+    BINARY_32: number;
+    NIBBLE_8: number;
+    PACKED_MAX: number;
+    SINGLE_BYTE_MAX: number;
+    STREAM_END: number;
+};
+export declare const DOUBLE_BYTE_TOKENS: string[][];
+export declare const SINGLE_BYTE_TOKENS: (string | null)[];
 export declare const TOKEN_MAP: {
     [token: string]: {
-        dict?: number
-        index: number
-    }
-}
+        dict?: number;
+        index: number;
+    };
+};