@hansaka02/baileys 7.3.4 → 7.3.6

package/lib/Utils/signal.js

@@ -2,7 +2,6 @@
 
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const { chunk } = require("lodash")
 const { KEY_BUNDLE_TYPE } = require("../Defaults/constants")
 const {
   S_WHATSAPP_NET, 
@@ -11,7 +10,9 @@ const {
   getBinaryNodeChildUInt, 
   getBinaryNodeChildBuffer,
   assertNodeErrorFree, 
-  jidDecode
+  jidDecode, 
+  getServerFromDomainType, 
+  WAJIDDomains, 
 } = require("../WABinary")
 const { 
   Curve,
@@ -19,6 +20,14 @@ const {
 } = require("./crypto")
 const { encodeBigEndian } = require("./generics")
 
+function chunk(array, size) {
+    const chunks = []
+    for (let i = 0; i < array.length; i += size) {
+        chunks.push(array.slice(i, i + size))
+    }
+    return chunks
+}
+
 const createSignalIdentity = (wid, accountSignatureKey) => {
     return {
         identifier: { name: wid, deviceId: 0 },
@@ -71,15 +80,19 @@ const xmppPreKey = (pair, id) => ({
 })
 
 const parseAndInjectE2ESessions = async (node, repository) => {
-    const extractKey = (key) => (key ? ({
-        keyId: getBinaryNodeChildUInt(key, 'id', 3),
-        publicKey: generateSignalPubKey(getBinaryNodeChildBuffer(key, 'value')),
-        signature: getBinaryNodeChildBuffer(key, 'signature')
-    }) : undefined)
+    const extractKey = (key) => 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
@@ -87,8 +100,9 @@ const parseAndInjectE2ESessions = async (node, repository) => {
     // 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) {
-        await Promise.all(nodesChunk.map(async (node) => {
+        for (const node of nodesChunk) {
             const signedKey = getBinaryNodeChild(node, 'skey')
             const key = getBinaryNodeChild(node, 'key')
             const identity = getBinaryNodeChildBuffer(node, 'identity')
@@ -103,25 +117,38 @@ const parseAndInjectE2ESessions = async (node, repository) => {
                     preKey: extractKey(key)
                 }
             })
-        }))
+        }
     }
 }
 
-const extractDeviceJids = (result, myJid, excludeZeroDevices) => {
+const extractDeviceJids = (result, myJid, myLid, excludeZeroDevices) => {
     const { user: myUser, device: myDevice } = jidDecode(myJid)
     const extracted = []
+    
     for (const userResult of result) {
         const { devices, id } = userResult
-        const { user } = jidDecode(id)
+        const decoded = jidDecode(id), { user, server } = decoded
+        
+        let { domainType } = decoded
+        
         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 })
+        
+        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)
+                })
             }
         }
     }

package/lib/Utils/validate-connection.js

@@ -5,7 +5,12 @@ Object.defineProperty(exports, "__esModule", { value: true })
 const { Boom } = require("@hapi/boom")
 const { createHash } = require("crypto")
 const { proto } = require("../../WAProto")
-const { KEY_BUNDLE_TYPE } = require("../Defaults/constants")
+const {
+  KEY_BUNDLE_TYPE, 
+  WA_ADV_ACCOUNT_SIG_PREFIX, 
+  WA_ADV_DEVICE_SIG_PREFIX, 
+  WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX
+} = require("../Defaults/constants")
 const {
   jidDecode, 
   getBinaryNodeChild,
@@ -25,7 +30,9 @@ const getUserAgent = (config) => {
             secondary: config.version[1],
             tertiary: config.version[2],
         },
-        platform: proto.ClientPayload.UserAgent.Platform.WEB,
+        platform: /*config.browser[1].toLocaleLowerCase().includes('android') 
+                         ? proto.ClientPayload.UserAgent.Platform.ANDROID 
+                         :*/ proto.ClientPayload.UserAgent.Platform.WEB,
         releaseChannel: proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
         osVersion: '0.1',
         device: 'Desktop',
@@ -39,13 +46,14 @@ const getUserAgent = (config) => {
 
 const PLATFORM_MAP = {
     'Mac OS': proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
-    'Windows': proto.ClientPayload.WebInfo.WebSubPlatform.WIN32, 
-    'Android': proto.ClientPayload.WebInfo.WebSubPlatform.WIN_HYBRID
+    'Windows': proto.ClientPayload.WebInfo.WebSubPlatform.WIN32
 }
 
 const getWebInfo = (config) => {
     let webSubPlatform = proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER
-    if (config.syncFullHistory && PLATFORM_MAP[config.browser[0]]) {
+    if (config.syncFullHistory &&
+        PLATFORM_MAP[config.browser[0]] &&
+        config.browser[1] === 'Desktop') {
         webSubPlatform = PLATFORM_MAP[config.browser[0]]
     }
     return { webSubPlatform }
@@ -57,7 +65,12 @@ const getClientPayload = (config) => {
         connectReason: proto.ClientPayload.ConnectReason.USER_ACTIVATED,
         userAgent: getUserAgent(config),
     }
-    payload.webInfo = getWebInfo(config)
+    
+    /*if (!config.browser[1].toLocaleLowerCase().includes('android')) { 
+   	 payload.webInfo = getWebInfo(config) 
+    }*/
+    payload.webInfo = getWebInfo(config) 
+    
     return payload
 }
 
@@ -65,17 +78,25 @@ const generateLoginNode = (userJid, config) => {
     const { user, device } = jidDecode(userJid)
     const payload = {
         ...getClientPayload(config),
-        passive: false,
+        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) => {
     const platformType = platform.toUpperCase()
-    return proto.DeviceProps.PlatformType[platformType] || proto.DeviceProps.PlatformType.DESKTOP
+    
+     /*if (platformType === 'ANDROID') { 
+     	return proto.DeviceProps.PlatformType.ANDROID_PHONE
+     }*/
+     
+    return (proto.DeviceProps.PlatformType[platformType] ||
+        proto.DeviceProps.PlatformType.CHROME)
 }
 
 const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentityKey }, config) => {
@@ -141,54 +162,57 @@ const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, s
     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 bizName = businessNode?.attrs.name
     const jid = deviceNode.attrs.jid
     const lid = deviceNode.attrs.lid
     const { details, hmac, accountType } = proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content)
     
     let hmacPrefix = Buffer.from([])
+    
     if (accountType !== undefined && accountType === proto.ADVEncryptionType.HOSTED) {
-        hmacPrefix = Buffer.from([6, 5])
+        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 decodedDeviceIdentity = proto.ADVDeviceIdentity.decode(deviceDetails)
-
-    const accountSignaturePrefix =
-        decodedDeviceIdentity.deviceType === proto.ADVEncryptionType.HOSTED
-            ? Buffer.from([6, 5])
-            : Buffer.from([6, 0])
+    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([
-        Buffer.from([6, 1]),
+        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 deviceIdentityData = proto.ADVDeviceIdentity.decode(account.details)
     const reply = {
         tag: 'iq',
         attrs: {
             to: S_WHATSAPP_NET,
             type: 'result',
-            id: msgId,
+            id: msgId
         },
         content: [
             {
@@ -197,22 +221,21 @@ const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, s
                 content: [
                     {
                         tag: 'device-identity',
-                        attrs: { 'key-index': deviceIdentityData.keyIndex.toString() },
+                        attrs: { 'key-index': deviceIdentity.keyIndex.toString() },
                         content: accountEnc
                     }
                 ]
             }
         ]
     }
+    
     const authUpdate = {
         account,
         me: { id: jid, name: bizName, lid },
-        signalIdentities: [
-            ...(signalIdentities || []),
-            identity
-        ],
-        platform: platformNode?.attrs?.name
+        signalIdentities: [...(signalIdentities || []), identity],
+        platform: platformNode?.attrs.name
     }
+    
     return {
         creds: authUpdate,
         reply