@pontalabs/baileys 1.0.10 → 1.1.0

package/lib/Utils/validate-connection.js

@@ -1,88 +1,111 @@
-"use strict"
-
-Object.defineProperty(exports, "__esModule", { value: true })
-
-const boom_1 = require("@hapi/boom")
-const crypto_1 = require("crypto")
-const WAProto_1 = require("../../WAProto")
-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: WAProto_1.proto.ClientPayload.UserAgent.Platform.WEB,
-        releaseChannel: WAProto_1.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 });
+const { Boom: Boom } = require("@hapi/boom");
+const { createHash: createHash } = require("crypto");
+const { proto: proto } = require("../../WAProto");
+const {
+    KEY_BUNDLE_TYPE: KEY_BUNDLE_TYPE,
+    WA_ADV_ACCOUNT_SIG_PREFIX: WA_ADV_ACCOUNT_SIG_PREFIX,
+    WA_ADV_DEVICE_SIG_PREFIX: WA_ADV_DEVICE_SIG_PREFIX,
+    WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX: WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX,
+} = require("../Defaults/constants");
+const {
+    jidDecode: jidDecode,
+    getBinaryNodeChild: getBinaryNodeChild,
+    S_WHATSAPP_NET: S_WHATSAPP_NET,
+} = require("../WABinary");
+const { Curve: Curve, hmacSign: hmacSign } = require("./crypto");
+const { encodeBigEndian: encodeBigEndian } = require("./generics");
+const { createSignalIdentity: createSignalIdentity } = require("./signal");
+const getUserAgent = (config) => ({
+    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': WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
-    'Windows': WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.WIN32, 
-    'Android': WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.WIN_HYBRID
-}
-
+    "Mac OS": proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
+    Windows: 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]]
+    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 }
-}
-
+    return { webSubPlatform: webSubPlatform };
+};
 const getClientPayload = (config) => {
     const payload = {
-        connectType: WAProto_1.proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
-        connectReason: WAProto_1.proto.ClientPayload.ConnectReason.USER_ACTIVATED,
+        connectType: proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
+        connectReason: proto.ClientPayload.ConnectReason.USER_ACTIVATED,
         userAgent: getUserAgent(config),
-    }
-    payload.webInfo = getWebInfo(config)
-    return payload
-}
-
+    };
+    payload.webInfo = getWebInfo(config);
+    return payload;
+};
 const generateLoginNode = (userJid, config) => {
-    const { user, device } = WABinary_1.jidDecode(userJid)
+    const { user: user, device: device } = jidDecode(userJid);
     const payload = {
         ...getClientPayload(config),
         passive: true,
         pull: true,
         username: +user,
         device: device,
-    }
-    return WAProto_1.proto.ClientPayload.fromObject(payload)
-}
-
+        lidDbMigrated: false,
+    };
+    return proto.ClientPayload.fromObject(payload);
+};
 const getPlatformType = (platform) => {
-    const platformType = platform.toUpperCase()
-    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 = crypto_1.createHash('md5')
-        .update(config.version.join('.')) // join as string
-        .digest()
+    const platformType = platform.toUpperCase();
+    return proto.DeviceProps.PlatformType[platformType] || proto.DeviceProps.PlatformType.CHROME;
+};
+const generateRegistrationNode = (
+    {
+        registrationId: registrationId,
+        signedPreKey: signedPreKey,
+        signedIdentityKey: signedIdentityKey,
+    },
+    config
+) => {
+    const appVersionBuf = createHash("md5").update(config.version.join(".")).digest();
     const companion = {
         os: config.browser[0],
         platformType: getPlatformType(config.browser[1]),
         requireFullSync: config.syncFullHistory,
-    }
-    const companionProto = WAProto_1.proto.DeviceProps.encode(companion).finish()
+        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,
@@ -90,99 +113,117 @@ const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentity
         devicePairingData: {
             buildHash: appVersionBuf,
             deviceProps: companionProto,
-            eRegid: generics_1.encodeBigEndian(registrationId),
-            eKeytype: Defaults_1.KEY_BUNDLE_TYPE,
+            eRegid: encodeBigEndian(registrationId),
+            eKeytype: KEY_BUNDLE_TYPE,
             eIdent: signedIdentityKey.public,
-            eSkeyId: generics_1.encodeBigEndian(signedPreKey.keyId, 3),
+            eSkeyId: encodeBigEndian(signedPreKey.keyId, 3),
             eSkeyVal: signedPreKey.keyPair.public,
             eSkeySig: signedPreKey.signature,
         },
+    };
+    return proto.ClientPayload.fromObject(registerPayload);
+};
+const configureSuccessfulPairing = (
+    stanza,
+    {
+        advSecretKey: advSecretKey,
+        signedIdentityKey: signedIdentityKey,
+        signalIdentities: signalIdentities,
     }
-    return WAProto_1.proto.ClientPayload.fromObject(registerPayload)
-}
-
-const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, signalIdentities }) => {
-    const msgId = stanza.attrs.id
-    const pairSuccessNode = WABinary_1.getBinaryNodeChild(stanza, 'pair-success')
-    const deviceIdentityNode = WABinary_1.getBinaryNodeChild(pairSuccessNode, 'device-identity')
-    const platformNode = WABinary_1.getBinaryNodeChild(pairSuccessNode, 'platform')
-    const deviceNode = WABinary_1.getBinaryNodeChild(pairSuccessNode, 'device')
-    const businessNode = WABinary_1.getBinaryNodeChild(pairSuccessNode, 'biz')
+) => {
+    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_1.Boom('Missing device-identity or device in pair success node', { data: stanza })
+        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: details,
+        hmac: hmac,
+        accountType: 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 bizName = businessNode?.attrs?.name
-    const jid = deviceNode.attrs.jid
-    const lid = deviceNode.attrs.lid
-    const { details, hmac, accountType } = WAProto_1.proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content)
-    const isHostedAccount = accountType !== undefined && accountType === WAProto_1.proto.ADVEncryptionType.HOSTED
-    const hmacPrefix = isHostedAccount ? Buffer.from([6, 5]) : Buffer.alloc(0) 
-    const advSign = crypto_2.hmacSign(Buffer.concat([hmacPrefix, details]), Buffer.from(advSecretKey, 'base64'))
+    const advSign = hmacSign(
+        Buffer.concat([hmacPrefix, details]),
+        Buffer.from(advSecretKey, "base64")
+    );
     if (Buffer.compare(hmac, advSign) !== 0) {
-        throw new boom_1.Boom('Invalid account signature')
+        throw new Boom("Invalid account signature");
     }
-    const account = WAProto_1.proto.ADVSignedDeviceIdentity.decode(details)
-    const { accountSignatureKey, accountSignature, details: deviceDetails } = account
-    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 account = proto.ADVSignedDeviceIdentity.decode(details);
+    const {
+        accountSignatureKey: accountSignatureKey,
+        accountSignature: 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 devicePrefix = isHostedAccount ? Buffer.from([6, 6]) : Buffer.from([6, 1]) 
-    const deviceMsg = Buffer.concat([devicePrefix, deviceDetails, signedIdentityKey.public, accountSignatureKey])
-    account.deviceSignature = crypto_2.Curve.sign(signedIdentityKey.private, deviceMsg)
-    const identity = signal_1.createSignalIdentity(lid, accountSignatureKey)
-    const accountEnc = encodeSignedDeviceIdentity(account, false)
-    const deviceIdentity = WAProto_1.proto.ADVDeviceIdentity.decode(account.details)
+    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: WABinary_1.S_WHATSAPP_NET,
-            type: 'result',
-            id: msgId,
-        },
+        tag: "iq",
+        attrs: { to: S_WHATSAPP_NET, type: "result", id: msgId },
         content: [
             {
-                tag: 'pair-device-sign',
+                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
+                        tag: "device-identity",
+                        attrs: { "key-index": deviceIdentity.keyIndex.toString() },
+                        content: accountEnc,
+                    },
+                ],
+            },
         ],
-        platform: platformNode?.attrs?.name
-    }
-    return {
-        creds: authUpdate,
-        reply
-    }
-}
-
+    };
+    const authUpdate = {
+        account: account,
+        me: { id: jid, name: bizName, lid: lid },
+        signalIdentities: [...(signalIdentities || []), identity],
+        platform: platformNode?.attrs.name,
+    };
+    return { creds: authUpdate, reply: reply };
+};
 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
+    account = { ...account };
     if (!includeSignatureKey || !account.accountSignatureKey?.length) {
-        account.accountSignatureKey = null
+        account.accountSignatureKey = null;
     }
-    return WAProto_1.proto.ADVSignedDeviceIdentity.encode(account).finish()
-}
-
+    return proto.ADVSignedDeviceIdentity.encode(account).finish();
+};
 module.exports = {
-  generateLoginNode, 
-  generateRegistrationNode, 
-  configureSuccessfulPairing, 
-  encodeSignedDeviceIdentity
-}
+    generateLoginNode: generateLoginNode,
+    generateRegistrationNode: generateRegistrationNode,
+    configureSuccessfulPairing: configureSuccessfulPairing,
+    encodeSignedDeviceIdentity: encodeSignedDeviceIdentity,
+};

package/lib/Utils/vialeys-event-stream.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Events = require("events");
+const { promises: promises, createReadStream: createReadStream } = require("fs");
+const { writeFile: writeFile } = require("fs/promises");
+const { createInterface: createInterface } = require("readline");
+const { delay: delay } = require("./generics");
+const { makeMutex: makeMutex } = require("./make-mutex");
+const captureEventStream = (ev, filename) => {
+    const oldEmit = ev.emit;
+    const writeMutex = makeMutex();
+    ev.emit = function (...args) {
+        const content =
+            JSON.stringify({ timestamp: Date.now(), event: args[0], data: args[1] }) + "\n";
+        const result = oldEmit.apply(ev, args);
+        writeMutex.mutex(async () => {
+            await promises.writeFile(filename, content, { flag: "a" });
+        });
+        return result;
+    };
+};
+const readAndEmitEventStream = (filename, delayIntervalMs = 0) => {
+    const ev = new Events();
+    const fireEvents = async () => {
+        const fileStream = createReadStream(filename);
+        const rl = createInterface({ input: fileStream, crlfDelay: Infinity });
+        for await (const line of rl) {
+            if (line) {
+                const { event: event, data: data } = JSON.parse(line);
+                ev.emit(event, data);
+                delayIntervalMs && (await delay(delayIntervalMs));
+            }
+        }
+        fileStream.close();
+    };
+    return { ev: ev, task: fireEvents() };
+};
+module.exports = {
+    captureEventStream: captureEventStream,
+    readAndEmitEventStream: readAndEmitEventStream,
+};