@baileys-md/baileys 10.1.0 → 11.0.0

package/lib/Utils/validate-connection.js

@@ -1,47 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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");
-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");
+import { Boom } from '@hapi/boom';
+import { createHash } from 'crypto';
+import { proto } from '../../WAProto/index.js';
+import { KEY_BUNDLE_TYPE } 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) => {
-    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: version[0],
-            secondary: version[1],
-            tertiary: version[2],
+            primary: config.version[0],
+            secondary: config.version[1],
+            tertiary: config.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,
+        platform: proto.ClientPayload.UserAgent.Platform.WEB,
+        releaseChannel: proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
+        osVersion: '0.1',
+        device: 'Desktop',
+        osBuildNumber: '0.1',
         localeLanguageIso6391: 'en',
-        localeCountryIso31661Alpha2: config.countryCode,
-        ...phoneId
+        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
+    '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;
+    let webSubPlatform = proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER;
     if (config.syncFullHistory && PLATFORM_MAP[config.browser[0]]) {
         webSubPlatform = PLATFORM_MAP[config.browser[0]];
     }
@@ -49,64 +37,41 @@ const getWebInfo = (config) => {
 };
 const getClientPayload = (config) => {
     const payload = {
-        connectType: WAProto_1.proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
-        connectReason: WAProto_1.proto.ClientPayload.ConnectReason.USER_ACTIVATED,
-        userAgent: getUserAgent(config),
+        connectType: proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
+        connectReason: proto.ClientPayload.ConnectReason.USER_ACTIVATED,
+        userAgent: getUserAgent(config)
     };
-    if (!config.mobile) {
-        payload.webInfo = getWebInfo(config);
-    }
+    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, // 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 WAProto_1.proto.ClientPayload.fromObject(payload);
-};
-exports.generateMobileNode = generateMobileNode;
-const generateLoginNode = (userJid, config) => {
-    const { user, device } = (0, WABinary_1.jidDecode)(userJid);
+export const generateLoginNode = (userJid, config) => {
+    const { user, device } = jidDecode(userJid);
     const payload = {
         ...getClientPayload(config),
         passive: false,
         pull: true,
         username: +user,
-        device: device,
+        device: device
     };
-    return WAProto_1.proto.ClientPayload.fromObject(payload);
+    return 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.DESKTOP;
+    return (proto.DeviceProps.PlatformType[platformType] ||
+        proto.DeviceProps.PlatformType.DESKTOP);
 };
-const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentityKey }, config) => {
+export const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentityKey }, config) => {
     // the app version needs to be md5 hashed
     // and passed in
-    const appVersionBuf = (0, crypto_1.createHash)('md5')
+    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,
+        requireFullSync: config.syncFullHistory
     };
-    const companionProto = WAProto_1.proto.DeviceProps.encode(companion).finish();
+    const companionProto = proto.DeviceProps.encode(companion).finish();
     const registerPayload = {
         ...getClientPayload(config),
         passive: false,
@@ -114,54 +79,53 @@ const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentity
         devicePairingData: {
             buildHash: appVersionBuf,
             deviceProps: companionProto,
-            eRegid: (0, generics_1.encodeBigEndian)(registrationId),
-            eKeytype: Defaults_1.KEY_BUNDLE_TYPE,
+            eRegid: encodeBigEndian(registrationId),
+            eKeytype: KEY_BUNDLE_TYPE,
             eIdent: signedIdentityKey.public,
-            eSkeyId: (0, generics_1.encodeBigEndian)(signedPreKey.keyId, 3),
+            eSkeyId: encodeBigEndian(signedPreKey.keyId, 3),
             eSkeyVal: signedPreKey.keyPair.public,
-            eSkeySig: signedPreKey.signature,
-        },
+            eSkeySig: signedPreKey.signature
+        }
     };
-    return WAProto_1.proto.ClientPayload.fromObject(registerPayload);
+    return proto.ClientPayload.fromObject(registerPayload);
 };
-exports.generateRegistrationNode = generateRegistrationNode;
-const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, signalIdentities }) => {
+export 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');
+    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 === null || businessNode === void 0 ? void 0 : businessNode.attrs.name;
+    const bizName = businessNode?.attrs.name;
     const jid = deviceNode.attrs.jid;
-    const { details, hmac } = WAProto_1.proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content);
-    // check HMAC matches
-    const advSign = (0, crypto_2.hmacSign)(details, Buffer.from(advSecretKey, 'base64'));
+    const { details, hmac, accountType } = proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content);
+    const isHostedAccount = accountType !== undefined && accountType === proto.ADVEncryptionType.HOSTED;
+    const hmacPrefix = isHostedAccount ? Buffer.from([6, 5]) : Buffer.alloc(0);
+    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 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 (!crypto_2.Curve.verify(accountSignatureKey, accountMsg, accountSignature)) {
-        throw new boom_1.Boom('Failed to verify account signature');
+    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 = 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 devicePrefix = isHostedAccount ? Buffer.from([6, 6]) : Buffer.from([6, 1]);
+    const deviceMsg = Buffer.concat([devicePrefix, 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 = {
         tag: 'iq',
         attrs: {
-            to: WABinary_1.S_WHATSAPP_NET,
+            to: S_WHATSAPP_NET,
             type: 'result',
-            id: msgId,
+            id: msgId
         },
         content: [
             {
@@ -180,28 +144,21 @@ const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, s
     const authUpdate = {
         account,
         me: { id: jid, name: bizName },
-        signalIdentities: [
-            ...(signalIdentities || []),
-            identity
-        ],
-        platform: platformNode === null || platformNode === void 0 ? void 0 : platformNode.attrs.name
+        signalIdentities: [...(signalIdentities || []), identity],
+        platform: platformNode?.attrs.name
     };
     return {
         creds: authUpdate,
         reply
     };
 };
-exports.configureSuccessfulPairing = configureSuccessfulPairing;
-const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
-    var _a;
+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 || !((_a = account.accountSignatureKey) === null || _a === void 0 ? void 0 : _a.length)) {
+    if (!includeSignatureKey || !account.accountSignatureKey?.length) {
         account.accountSignatureKey = null;
     }
-    return WAProto_1.proto.ADVSignedDeviceIdentity
-        .encode(account)
-        .finish();
+    return proto.ADVSignedDeviceIdentity.encode(account).finish();
 };
-exports.encodeSignedDeviceIdentity = encodeSignedDeviceIdentity;
+//# sourceMappingURL=validate-connection.js.map