torbaileys 8.0.0

package/lib/Utils/signal.js

@@ -0,0 +1,161 @@
+//=======================================================//
+import { assertNodeErrorFree, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildUInt, getServerFromDomainType, jidDecode, S_WHATSAPP_NET, WAJIDDomains } from "../WABinary/index.js";
+import { Curve, generateSignalPubKey } from "./crypto.js";
+import { KEY_BUNDLE_TYPE } from "../Defaults/index.js";
+import { encodeBigEndian } from "./generics.js";
+//=======================================================//
+function chunk(array, size) {
+  const chunks = [];
+  for (let i = 0; i < array.length; i += size) {
+    chunks.push(array.slice(i, i + size));
+  }
+  return chunks;
+}
+//=======================================================//
+export const createSignalIdentity = (wid, accountSignatureKey) => {
+  return {
+    identifier: { name: wid, deviceId: 0 },
+    identifierKey: generateSignalPubKey(accountSignatureKey)
+  };
+};
+//=======================================================//
+export const getPreKeys = async ({ get }, min, limit) => {
+  const idList = [];
+  for (let id = min; id < limit; id++) {
+    idList.push(id.toString());
+  }
+  return get("pre-key", idList);
+};
+//=======================================================//
+export const generateOrGetPreKeys = (creds, range) => {
+  const avaliable = creds.nextPreKeyId - creds.firstUnuploadedPreKeyId;
+  const remaining = range - avaliable;
+  const lastPreKeyId = creds.nextPreKeyId + remaining - 1;
+  const newPreKeys = {};
+  if (remaining > 0) {
+    for (let i = creds.nextPreKeyId; i <= lastPreKeyId; i++) {
+      newPreKeys[i] = Curve.generateKeyPair();
+    }
+  }
+  return {
+    newPreKeys,
+    lastPreKeyId,
+    preKeysRange: [creds.firstUnuploadedPreKeyId, range]
+  };
+};
+//=======================================================//
+export const xmppSignedPreKey = (key) => ({
+  tag: "skey",
+  attrs: {},
+  content: [
+    { tag: "id", attrs: {}, content: encodeBigEndian(key.keyId, 3) },
+    { tag: "value", attrs: {}, content: key.keyPair.public },
+    { tag: "signature", attrs: {}, content: key.signature }
+  ]
+});
+//=======================================================//
+export const xmppPreKey = (pair, id) => ({
+  tag: "key",
+  attrs: {},
+  content: [
+    { tag: "id", attrs: {}, content: encodeBigEndian(id, 3) },
+    { tag: "value", attrs: {}, content: pair.public }
+  ]
+});
+//=======================================================//
+export 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 nodes = getBinaryNodeChildren(getBinaryNodeChild(node, "list"), "user");
+  for (const node of nodes) {
+    assertNodeErrorFree(node);
+  }
+  const chunkSize = 100;
+  const chunks = chunk(nodes, chunkSize);
+  for (const nodesChunk of chunks) {
+    for (const node of nodesChunk) {
+      const signedKey = getBinaryNodeChild(node, "skey");
+      const key = getBinaryNodeChild(node, "key");
+      const identity = getBinaryNodeChildBuffer(node, "identity");
+      const jid = node.attrs.jid;
+      const registrationId = getBinaryNodeChildUInt(node, "registration", 4);
+      await repository.injectE2ESession({
+        jid,
+        session: {
+          registrationId: registrationId,
+          identityKey: generateSignalPubKey(identity),
+          signedPreKey: extractKey(signedKey),
+          preKey: extractKey(key)
+        }
+      });
+    }
+  }
+};
+//=======================================================//
+export 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 decoded = jidDecode(id), { user, server } = decoded;
+    let { domainType } = decoded;
+    const deviceList = devices?.deviceList;
+    if (!Array.isArray(deviceList))
+      continue;
+    for (const { id: device, keyIndex, isHosted } of deviceList) {
+      if ((!excludeZeroDevices || device !== 0) &&
+        ((myUser !== user && myLid !== user) || myDevice !== device) &&
+        (device === 0 || !!keyIndex)
+      ) {
+        if (isHosted) {
+          domainType = domainType === WAJIDDomains.LID ? WAJIDDomains.HOSTED_LID : WAJIDDomains.HOSTED;
+        }
+        extracted.push({
+          user,
+          device,
+          domainType,
+          server: getServerFromDomainType(server, domainType)
+        });
+      }
+    }
+  }
+  return extracted;
+};
+//=======================================================//
+export const getNextPreKeys = async ({ creds, keys }, count) => {
+  const { newPreKeys, lastPreKeyId, preKeysRange } = generateOrGetPreKeys(creds, count);
+  const update = {
+    nextPreKeyId: Math.max(lastPreKeyId + 1, creds.nextPreKeyId),
+    firstUnuploadedPreKeyId: Math.max(creds.firstUnuploadedPreKeyId, lastPreKeyId + 1)
+  };
+  await keys.set({ "pre-key": newPreKeys });
+  const preKeys = await getPreKeys(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1]);
+  return { update, preKeys };
+};
+//=======================================================//
+export const getNextPreKeysNode = async (state, count) => {
+  const { creds } = state;
+  const { update, preKeys } = await getNextPreKeys(state, count);
+  const node = {
+    tag: "iq",
+    attrs: {
+      xmlns: "encrypt",
+      type: "set",
+      to: S_WHATSAPP_NET
+    },
+    content: [
+      { tag: "registration", attrs: {}, content: encodeBigEndian(creds.registrationId) },
+      { tag: "type", attrs: {}, content: KEY_BUNDLE_TYPE },
+      { tag: "identity", attrs: {}, content: creds.signedIdentityKey.public },
+      { tag: "list", attrs: {}, content: Object.keys(preKeys).map(k => xmppPreKey(preKeys[+k], +k)) },
+      xmppSignedPreKey(creds.signedPreKey)
+    ]
+  };
+  return { update, node };
+};
+//=======================================================//

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

@@ -0,0 +1,111 @@
+//=======================================================//
+import { mkdir, readFile, stat, unlink, writeFile } from "fs/promises";
+import { initAuthCreds } from "./auth-utils.js";
+import { proto } from "../../WAProto/index.js";
+import { BufferJSON } from "./generics.js";
+import { Mutex } from "async-mutex";
+import { join } from "path";
+//=======================================================//
+const fileLocks = new Map();
+const getFileLock = (path) => {
+  let mutex = fileLocks.get(path);
+  if (!mutex) {
+    mutex = new Mutex();
+    fileLocks.set(path, mutex);
+  }
+  return mutex;
+};
+//=======================================================//
+export const useMultiFileAuthState = async (folder) => {
+  const writeData = async (data, file) => {
+    const filePath = join(folder, fixFileName(file));
+    const mutex = getFileLock(filePath);
+    return mutex.acquire().then(async (release) => {
+      try {
+        await writeFile(filePath, JSON.stringify(data, BufferJSON.replacer));
+      }
+      finally {
+        release();
+      }
+    });
+  };
+  const readData = async (file) => {
+    try {
+      const filePath = join(folder, fixFileName(file));
+      const mutex = getFileLock(filePath);
+      return await mutex.acquire().then(async (release) => {
+        try {
+          const data = await readFile(filePath, { encoding: "utf-8" });
+          return JSON.parse(data, BufferJSON.reviver);
+        }
+        finally {
+          release();
+        }
+      });
+    }
+    catch (error) {
+      return null;
+    }
+  };
+  const removeData = async (file) => {
+    try {
+      const filePath = join(folder, fixFileName(file));
+      const mutex = getFileLock(filePath);
+      return mutex.acquire().then(async (release) => {
+        try {
+          await unlink(filePath);
+        }
+        catch {
+        }
+        finally {
+          release();
+        }
+      });
+    }
+    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) => file?.replace(/\//g, "__")?.replace(/:/g, "-");
+  const creds = (await readData("creds.json")) || initAuthCreds();
+  return {
+    state: {
+      creds,
+      keys: {
+        get: async (type, ids) => {
+          const data = {};
+          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 = [];
+          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: async () => {
+      return writeData(creds, "creds.json");
+    }
+  };
+};
+//=======================================================//

package/lib/Utils/validate-connection.js

@@ -0,0 +1,200 @@
+//=======================================================//
+import { KEY_BUNDLE_TYPE, WA_ADV_ACCOUNT_SIG_PREFIX, WA_ADV_DEVICE_SIG_PREFIX, WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX } from "../Defaults/index.js";
+import { getBinaryNodeChild, jidDecode, S_WHATSAPP_NET } from "../WABinary/index.js";
+import { createSignalIdentity } from "./signal.js";
+import { encodeBigEndian } from "./generics.js";
+import { proto } from "../../WAProto/index.js";
+import { Curve, hmacSign } from "./crypto.js";
+import { createHash } from "crypto";
+import { Boom } from "@hapi/boom";
+//=======================================================//
+const getUserAgent = (config) => {
+  return {
+    "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": proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
+  "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]] &&
+    config.browser[1] === "Desktop") {
+    webSubPlatform = PLATFORM_MAP[config.browser[0]];
+  }
+  return { webSubPlatform };
+};
+//=======================================================//
+const getClientPayload = (config) => {
+  const payload = {
+    connectType: proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
+    connectReason: proto.ClientPayload.ConnectReason.USER_ACTIVATED,
+    userAgent: getUserAgent(config)
+  };
+  payload.webInfo = getWebInfo(config);
+  return payload;
+};
+//=======================================================//
+export const generateLoginNode = (userJid, config) => {
+  const { user, device } = jidDecode(userJid);
+  const payload = {
+    ...getClientPayload(config),
+    "passive": true,
+    "pull": true,
+    "username": +user,
+    "device": device,
+    "lidDbMigrated": false
+  };
+  return proto.ClientPayload.fromObject(payload);
+};
+//=======================================================//
+const getPlatformType = (platform) => {
+  const platformType = platform.toUpperCase();
+  return (proto.DeviceProps.PlatformType[platformType] ||
+    proto.DeviceProps.PlatformType.CHROME);
+};
+//=======================================================//
+export const generateRegistrationNode = ({ registrationId, signedPreKey, 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,
+    "historySyncConfig": {
+      "storageQuotaMb": 569150,
+      "inlineInitialPayloadInE2EeMsg": true,
+      "supportCallLogHistory": false,
+      "supportBotUserAgentChatHistory": true,
+      "supportCagReactionsAndPolls": true,
+      "supportBizHostedMsg": true,
+      "supportRecentSyncChunkMessageCountTuning": true,
+      "supportHostedGroupMsg": true,
+      "supportFbidBotChatHistory": true,
+      "supportMessageAssociation": true
+    },
+    "version": {
+      "primary": 10,
+      "secondary": 15,
+      "tertiary": 7
+    }
+  };
+  const companionProto = proto.DeviceProps.encode(companion).finish();
+  const registerPayload = {
+    ...getClientPayload(config),
+    passive: false,
+    pull: 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, { 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 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 = 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 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([
+    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: 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 = {
+    account,
+    me: { id: jid, name: bizName, lid },
+    signalIdentities: [...(signalIdentities || []), identity],
+    platform: platformNode?.attrs.name
+  };
+  return {
+    creds: authUpdate,
+    reply
+  };
+};
+//=======================================================//
+export const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
+  account = { ...account };
+  if (!includeSignatureKey || !account.accountSignatureKey?.length) {
+    account.accountSignatureKey = null;
+  }
+  return proto.ADVSignedDeviceIdentity.encode(account).finish();
+};
+//=======================================================//