@prototypevip/baileys 0.0.1

package/lib/Utils/companion-reg-client-utils.js

@@ -0,0 +1,54 @@
+export var CompanionWebClientType;
+(function (CompanionWebClientType) {
+  CompanionWebClientType[(CompanionWebClientType["UNKNOWN"] = 0)] = "UNKNOWN";
+  CompanionWebClientType[(CompanionWebClientType["CHROME"] = 1)] = "CHROME";
+  CompanionWebClientType[(CompanionWebClientType["EDGE"] = 2)] = "EDGE";
+  CompanionWebClientType[(CompanionWebClientType["FIREFOX"] = 3)] = "FIREFOX";
+  CompanionWebClientType[(CompanionWebClientType["IE"] = 4)] = "IE";
+  CompanionWebClientType[(CompanionWebClientType["OPERA"] = 5)] = "OPERA";
+  CompanionWebClientType[(CompanionWebClientType["SAFARI"] = 6)] = "SAFARI";
+  CompanionWebClientType[(CompanionWebClientType["ELECTRON"] = 7)] = "ELECTRON";
+  CompanionWebClientType[(CompanionWebClientType["UWP"] = 8)] = "UWP";
+  CompanionWebClientType[(CompanionWebClientType["OTHER_WEB_CLIENT"] = 9)] =
+    "OTHER_WEB_CLIENT";
+})(CompanionWebClientType || (CompanionWebClientType = {}));
+const BROWSER_TO_COMPANION_WEB_CLIENT = {
+  Chrome: CompanionWebClientType.CHROME,
+  Edge: CompanionWebClientType.EDGE,
+  Firefox: CompanionWebClientType.FIREFOX,
+  IE: CompanionWebClientType.IE,
+  Opera: CompanionWebClientType.OPERA,
+  Safari: CompanionWebClientType.SAFARI,
+};
+export const getCompanionWebClientType = ([os, browserName]) => {
+  if (browserName === "Desktop") {
+    return os === "Windows"
+      ? CompanionWebClientType.UWP
+      : CompanionWebClientType.ELECTRON;
+  }
+  return (
+    BROWSER_TO_COMPANION_WEB_CLIENT[browserName] ||
+    CompanionWebClientType.OTHER_WEB_CLIENT
+  );
+};
+export const getCompanionPlatformId = (browser) => {
+  return getCompanionWebClientType(browser).toString();
+};
+export const buildPairingQRData = (
+  ref,
+  noiseKeyB64,
+  identityKeyB64,
+  advB64,
+  browser,
+) => {
+  return (
+    "https://wa.me/settings/linked_devices#" +
+    [
+      ref,
+      noiseKeyB64,
+      identityKeyB64,
+      advB64,
+      getCompanionPlatformId(browser),
+    ].join(",")
+  );
+};

package/lib/Utils/constants.js

@@ -0,0 +1,24 @@
+export const NO_MESSAGE_FOUND_ERROR_TEXT = "Message absent from node";
+export const MISSING_KEYS_ERROR_TEXT = "Key used already or never filled";
+
+export const NACK_REASONS = {
+  ParsingError: 487,
+  UnrecognizedStanza: 488,
+  UnrecognizedStanzaClass: 489,
+  UnrecognizedStanzaType: 490,
+  InvalidProtobuf: 491,
+  InvalidHostedCompanionStanza: 493,
+  MissingMessageSecret: 495,
+  SignalErrorOldCounter: 496,
+  MessageDeletedOnPeer: 499,
+  UnhandledError: 500,
+  UnsupportedAdminRevoke: 550,
+  UnsupportedLIDGroup: 551,
+  DBOperationFailed: 552,
+};
+export const ACCOUNT_RESTRICTED_TEXT = "Your account has been restricted";
+export const SERVER_ERROR_CODES = {
+  MessageAccountRestriction: "463",
+  SmaxInvalid: "479",
+};
+export const BOT_PHONE_REGEX = /^1313555\d{4}$|^131655500\d{2}$/;

package/lib/Utils/crypto.js

@@ -0,0 +1,133 @@
+import {
+  createCipheriv,
+  createDecipheriv,
+  createHash,
+  createHmac,
+  randomBytes,
+} from "crypto";
+import * as curve from "libsignal/src/curve.js";
+import { KEY_BUNDLE_TYPE } from "../Defaults/index.js";
+export { md5, hkdf } from "whatsapp-rust-bridge";
+// insure browser & node compatibility
+const { subtle } = globalThis.crypto;
+/** prefix version byte to the pub keys, required for some curve crypto functions */ export const generateSignalPubKey =
+  (pubKey) =>
+    pubKey.length === 33 ? pubKey : Buffer.concat([KEY_BUNDLE_TYPE, pubKey]);
+export const Curve = {
+  generateKeyPair: () => {
+    const { pubKey, privKey } = curve.generateKeyPair();
+    return {
+      private: Buffer.from(privKey),
+      // remove version byte
+      public: Buffer.from(pubKey.slice(1)),
+    };
+  },
+  sharedKey: (privateKey, publicKey) => {
+    const shared = curve.calculateAgreement(
+      generateSignalPubKey(publicKey),
+      privateKey,
+    );
+    return Buffer.from(shared);
+  },
+  sign: (privateKey, buf) => curve.calculateSignature(privateKey, buf),
+  verify: (pubKey, message, signature) => {
+    try {
+      curve.verifySignature(generateSignalPubKey(pubKey), message, signature);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  },
+};
+export const signedKeyPair = (identityKeyPair, keyId) => {
+  const preKey = Curve.generateKeyPair();
+  const pubKey = generateSignalPubKey(preKey.public);
+  const signature = Curve.sign(identityKeyPair.private, pubKey);
+  return { keyPair: preKey, signature: signature, keyId: keyId };
+};
+const GCM_TAG_LENGTH = 128 >> 3;
+/**
+ * encrypt AES 256 GCM;
+ * where the tag tag is suffixed to the ciphertext
+ * */ export function aesEncryptGCM(plaintext, key, iv, additionalData) {
+  const cipher = createCipheriv("aes-256-gcm", key, iv);
+  cipher.setAAD(additionalData);
+  return Buffer.concat([
+    cipher.update(plaintext),
+    cipher.final(),
+    cipher.getAuthTag(),
+  ]);
+}
+/**
+ * decrypt AES 256 GCM;
+ * where the auth tag is suffixed to the ciphertext
+ * */ export function aesDecryptGCM(ciphertext, key, iv, additionalData) {
+  const decipher = createDecipheriv("aes-256-gcm", key, iv);
+  // decrypt additional adata
+  const enc = ciphertext.slice(0, ciphertext.length - GCM_TAG_LENGTH);
+  const tag = ciphertext.slice(ciphertext.length - GCM_TAG_LENGTH);
+  // set additional data
+  decipher.setAAD(additionalData);
+  decipher.setAuthTag(tag);
+  return Buffer.concat([decipher.update(enc), decipher.final()]);
+}
+export function aesEncryptCTR(plaintext, key, iv) {
+  const cipher = createCipheriv("aes-256-ctr", key, iv);
+  return Buffer.concat([cipher.update(plaintext), cipher.final()]);
+}
+export function aesDecryptCTR(ciphertext, key, iv) {
+  const decipher = createDecipheriv("aes-256-ctr", key, iv);
+  return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+}
+/** decrypt AES 256 CBC; where the IV is prefixed to the buffer */ export function aesDecrypt(
+  buffer,
+  key,
+) {
+  return aesDecryptWithIV(buffer.subarray(16), key, buffer.subarray(0, 16));
+}
+/** decrypt AES 256 CBC */ export function aesDecryptWithIV(buffer, key, IV) {
+  const aes = createDecipheriv("aes-256-cbc", key, IV);
+  return Buffer.concat([aes.update(buffer), aes.final()]);
+}
+// encrypt AES 256 CBC; where a random IV is prefixed to the buffer
+export function aesEncrypt(buffer, key) {
+  const IV = randomBytes(16);
+  const aes = createCipheriv("aes-256-cbc", key, IV);
+  return Buffer.concat([IV, aes.update(buffer), aes.final()]); // prefix IV to the buffer
+}
+// encrypt AES 256 CBC with a given IV
+export function aesEncrypWithIV(buffer, key, IV) {
+  const aes = createCipheriv("aes-256-cbc", key, IV);
+  return Buffer.concat([aes.update(buffer), aes.final()]); // prefix IV to the buffer
+}
+// sign HMAC using SHA 256
+export function hmacSign(buffer, key, variant = "sha256") {
+  return createHmac(variant, key).update(buffer).digest();
+}
+export function sha256(buffer) {
+  return createHash("sha256").update(buffer).digest();
+}
+export async function derivePairingCodeKey(pairingCode, salt) {
+  // Convert inputs to formats Web Crypto API can work with
+  const encoder = new TextEncoder();
+  const pairingCodeBuffer = encoder.encode(pairingCode);
+  const saltBuffer = new Uint8Array(
+    salt instanceof Uint8Array ? salt : new Uint8Array(salt),
+  );
+  // Import the pairing code as key material
+  const keyMaterial = await subtle.importKey(
+    "raw",
+    pairingCodeBuffer,
+    { name: "PBKDF2" },
+    false,
+    ["deriveBits"],
+  );
+  // Derive bits using PBKDF2 with the same parameters
+  // 2 << 16 = 131,072 iterations
+  const derivedBits = await subtle.deriveBits(
+    { name: "PBKDF2", salt: saltBuffer, iterations: 2 << 16, hash: "SHA-256" },
+    keyMaterial,
+    32 * 8,
+  );
+  return Buffer.from(derivedBits);
+}

package/lib/Utils/cstoken-utils.js

@@ -0,0 +1,41 @@
+import { createHmac } from "crypto";
+import {
+  isJidBot,
+  isLidUser,
+  isPnUser,
+  jidDecode,
+  S_WHATSAPP_NET,
+} from "../WABinary/index.js";
+
+const PSA_USER = "0";
+
+export const shouldSendCsToken = (jid) => {
+  const decoded = jidDecode(jid);
+  if (!decoded) return false;
+
+  const { user, server } = decoded;
+  return (
+    (server === "s.whatsapp.net" || server === "c.us" || server === "lid") &&
+    user !== PSA_USER &&
+    !isJidBot(jid)
+  );
+};
+
+export const generateCsToken = (jid, salt) => {
+  if (!salt) return null;
+  if (!shouldSendCsToken(jid)) return null;
+
+  const decoded = jidDecode(jid);
+  if (
+    !decoded ||
+    (decoded.server !== "lid" &&
+      decoded.server !== "s.whatsapp.net" &&
+      decoded.server !== "c.us")
+  ) {
+    return null;
+  }
+
+  const hmac = createHmac("sha256", salt);
+  hmac.update(jid);
+  return hmac.digest();
+};

package/lib/Utils/decode-wa-message.js

@@ -0,0 +1,406 @@
+import { Boom } from "@hapi/boom";
+import { proto } from "../../WAProto/index.js";
+import {
+  areJidsSameUser,
+  isHostedLidUser,
+  isHostedPnUser,
+  isJidBroadcast,
+  isJidGroup,
+  isJidMetaAI,
+  isJidNewsletter,
+  isJidStatusBroadcast,
+  isLidUser,
+  isPnUser,
+  jidNormalizedUser,
+} from "../WABinary/index.js";
+import { NO_MESSAGE_FOUND_ERROR_TEXT } from "./constants.js";
+import { unpadRandomMax16 } from "./generics.js";
+
+// === مضافة من الرسمية: إعدادات إعادة محاولة فك التشفير عند أخطاء الـ session ===
+export const DECRYPTION_RETRY_CONFIG = {
+  maxRetries: 3,
+  baseDelayMs: 100,
+  sessionRecordErrors: [
+    "No session record",
+    "SessionError: No session record",
+  ],
+};
+/**
+ * تتحقق هل الخطأ سببه فقدان سجل جلسة (session record) عشان نقدر نميّزه
+ * عن أي فشل فك تشفير تاني في اللوج.
+ */
+function isSessionRecordError(error) {
+  const errorMessage = error?.message || error?.toString() || "";
+  return DECRYPTION_RETRY_CONFIG.sessionRecordErrors.some((errorPattern) =>
+    errorMessage.includes(errorPattern),
+  );
+}
+
+export const getDecryptionJid = async (sender, repository) => {
+  if (isLidUser(sender) || isHostedLidUser(sender)) return sender;
+  return (await repository.lidMapping.getLIDForPN(sender)) || sender;
+};
+
+const storeMappingFromEnvelope = async (
+  stanza,
+  sender,
+  repository,
+  decryptionJid,
+  logger,
+) => {
+  const senderPn =
+    stanza.attrs.participant_pn ||
+    stanza.attrs.sender_pn ||
+    stanza.attrs.peer_recipient_pn;
+
+  const senderLid =
+    stanza.attrs.participant_lid ||
+    stanza.attrs.sender_lid ||
+    stanza.attrs.peer_recipient_lid;
+
+  if (senderLid && isPnUser(sender) && decryptionJid === sender) {
+    try {
+      await repository.lidMapping.storeLIDPNMappings([
+        { lid: senderLid, pn: sender },
+      ]);
+
+      logger.debug({ sender, senderLid }, "Stored LID mapping from envelope");
+    } catch (error) {
+      logger.warn({ sender, senderLid, error }, "Failed to store LID mapping");
+    }
+  }
+};
+
+export const extractAddressingContext = (stanza) => {
+  let senderAlt;
+  let recipientAlt;
+  const sender = stanza.attrs.participant || stanza.attrs.from;
+  const addressingMode =
+    stanza.attrs.addressing_mode || (sender?.endsWith("lid") ? "lid" : "pn");
+  if (addressingMode === "lid") {
+    senderAlt =
+      stanza.attrs.participant_pn ||
+      stanza.attrs.sender_pn ||
+      stanza.attrs.peer_recipient_pn;
+    recipientAlt = stanza.attrs.recipient_pn;
+  } else {
+    senderAlt =
+      stanza.attrs.participant_lid ||
+      stanza.attrs.sender_lid ||
+      stanza.attrs.peer_recipient_lid;
+    recipientAlt = stanza.attrs.recipient_lid;
+  }
+  return {
+    addressingMode,
+    senderAlt,
+    recipientAlt,
+  };
+};
+export function decodeMessageNode(stanza, meId, meLid) {
+  let msgType;
+  let chatId;
+  let author;
+  let fromMe = false;
+
+  const msgId = stanza.attrs.id;
+  const from = stanza.attrs.from;
+  if (!msgId) {
+    throw new Boom("Invalid message stanza: missing id", {
+      data: stanza,
+    });
+  }
+  if (!from) {
+    throw new Boom("Invalid message stanza: missing from", {
+      data: stanza,
+    });
+  }
+  const participant = stanza.attrs.participant;
+  const recipient = stanza.attrs.recipient;
+
+  const addressingContext = extractAddressingContext(stanza);
+  const isMe = (jid) => areJidsSameUser(jid, meId);
+  const isMeLid = (jid) => areJidsSameUser(jid, meLid);
+  if (
+    isPnUser(from) ||
+    isLidUser(from) ||
+    isHostedLidUser(from) ||
+    isHostedPnUser(from)
+  ) {
+    if (recipient && !isJidMetaAI(recipient)) {
+      if (!isMe(from) && !isMeLid(from)) {
+        throw new Boom("receipient present, but msg not from me", {
+          data: stanza,
+        });
+      }
+      if (isMe(from) || isMeLid(from)) {
+        fromMe = true;
+      }
+      chatId = recipient;
+    } else {
+      if (isMe(from) || isMeLid(from)) {
+        fromMe = true;
+      }
+      chatId = from;
+    }
+    msgType = "chat";
+    author = from;
+  } else if (isJidGroup(from)) {
+    if (!participant) {
+      throw new Boom("No participant in group message");
+    }
+    if (isMe(participant) || isMeLid(participant)) {
+      fromMe = true;
+    }
+    msgType = "group";
+    author = participant;
+    chatId = from;
+  } else if (isJidBroadcast(from)) {
+    if (!participant) {
+      throw new Boom("No participant in group message");
+    }
+    const isParticipantMe = isMe(participant);
+    if (isJidStatusBroadcast(from)) {
+      msgType = isParticipantMe ? "direct_peer_status" : "other_status";
+    } else {
+      msgType = isParticipantMe ? "peer_broadcast" : "other_broadcast";
+    }
+    fromMe = isParticipantMe;
+    chatId = from;
+    author = participant;
+  } else if (isJidNewsletter(from)) {
+    msgType = "newsletter";
+    chatId = from;
+    author = from;
+    if (isMe(from) || isMeLid(from)) {
+      fromMe = true;
+    }
+  } else {
+    throw new Boom("Unknown message type", { data: stanza });
+  }
+
+  const pushname = stanza?.attrs?.notify;
+  const key = {
+    remoteJid: chatId,
+    remoteJidAlt: !isJidGroup(chatId) ? addressingContext.senderAlt : undefined,
+    remoteJidUsername: !isJidGroup(chatId)
+      ? stanza.attrs.peer_recipient_username || stanza.attrs.recipient_username
+      : undefined,
+    fromMe,
+    id: msgId,
+    participant: fromMe
+      ? isPnUser(participant)
+        ? jidNormalizedUser(meId)
+        : isLidUser(participant)
+          ? jidNormalizedUser(meLid)
+          : jidNormalizedUser(participant)
+      : jidNormalizedUser(participant),
+    participantAlt: fromMe
+      ? jidNormalizedUser(participant) === jidNormalizedUser(meLid)
+        ? jidNormalizedUser(meId)
+        : jidNormalizedUser(meLid)
+      : addressingContext.senderAlt,
+    participantUsername: stanza.attrs.participant
+      ? stanza.attrs.participant_username
+      : undefined,
+    addressingMode: addressingContext.addressingMode,
+    ...(msgType === "newsletter" && stanza.attrs.server_id
+      ? { server_id: stanza.attrs.server_id }
+      : {}),
+  };
+
+  const fullMessage = {
+    key,
+    category: stanza.attrs.category,
+    messageTimestamp: +stanza.attrs.t,
+    pushName: pushname,
+    broadcast: isJidBroadcast(from),
+  };
+
+  if (key.fromMe) {
+    fullMessage.status = proto.WebMessageInfo.Status.SERVER_ACK;
+  }
+
+  return {
+    fullMessage,
+    author,
+    sender: msgType === "chat" ? author : chatId,
+  };
+}
+
+export const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
+  const { fullMessage, author, sender } = decodeMessageNode(
+    stanza,
+    meId,
+    meLid,
+  );
+
+  return {
+    fullMessage,
+    category: stanza.attrs.category,
+    author,
+
+    async decrypt() {
+      let decryptables = 0;
+
+      if (Array.isArray(stanza.content)) {
+        for (const { tag, attrs, content } of stanza.content) {
+          if (tag !== "enc" && tag !== "plaintext") continue;
+          if (!(content instanceof Uint8Array)) continue;
+          if (tag === "unavailable" && attrs.type === "view_once") {
+            fullMessage.key.isViewOnce = true;
+          }
+          if (tag === "verified_name" && content instanceof Uint8Array) {
+            const cert = proto.VerifiedNameCertificate.decode(content);
+
+            const details = proto.VerifiedNameCertificate.Details.decode(
+              cert.details,
+            );
+
+            fullMessage.verifiedBizName = details.verifiedName;
+          }
+          if (attrs.count && tag === "enc") {
+            fullMessage.retryCount = Number(attrs.count);
+          }
+          decryptables++;
+
+          const decryptionJid = await getDecryptionJid(author, repository);
+
+          if (tag !== "plaintext") {
+            await storeMappingFromEnvelope(
+              stanza,
+              author,
+              repository,
+              decryptionJid,
+              logger,
+            );
+          }
+
+          try {
+            const e2eType = tag === "plaintext" ? "plaintext" : attrs.type;
+
+            let msgBuffer;
+
+            switch (e2eType) {
+              case "skmsg":
+                msgBuffer = await repository.decryptGroupMessage({
+                  group: sender,
+                  authorJid: author,
+                  msg: content,
+                });
+                break;
+
+              case "pkmsg":
+              case "msg":
+                msgBuffer = await repository.decryptMessage({
+                  jid: decryptionJid,
+                  type: e2eType,
+                  ciphertext: content,
+                });
+                break;
+
+              case "plaintext":
+                msgBuffer = content;
+                break;
+
+              default:
+                throw new Error(`Unknown e2e type: ${e2eType}`);
+            }
+
+            let msg = proto.Message.decode(
+              e2eType !== "plaintext" ? unpadRandomMax16(msgBuffer) : msgBuffer,
+            );
+
+            msg = msg.deviceSentMessage?.message || msg;
+            if (msg.senderKeyDistributionMessage) {
+              try {
+                await repository.processSenderKeyDistributionMessage({
+                  authorJid: author,
+                  item: msg.senderKeyDistributionMessage,
+                });
+              } catch (err) {
+                logger.error(
+                  {
+                    key: fullMessage.key,
+                    err,
+                    sender,
+                    author,
+                    stanzaType: attrs.type,
+                  },
+                  "failed to decrypt message",
+                );
+              }
+            }
+            await normalizeQuoted(msg, repository);
+
+            if (fullMessage.message) {
+              Object.assign(fullMessage.message, msg);
+            } else {
+              fullMessage.message = msg;
+            }
+          } catch (err) {
+            logger.error(
+              {
+                key: fullMessage.key,
+                err,
+                messageType: tag === "plaintext" ? "plaintext" : attrs.type,
+                sender,
+                author,
+                isSessionRecordError: isSessionRecordError(err),
+              },
+              "failed to decrypt message",
+            );
+
+            fullMessage.messageStubType =
+              proto.WebMessageInfo.StubType.CIPHERTEXT;
+
+            fullMessage.messageStubParameters = [err.message.toString()];
+          }
+        }
+      }
+
+      if (!decryptables && !fullMessage.key?.isViewOnce) {
+        fullMessage.messageStubType = proto.WebMessageInfo.StubType.CIPHERTEXT;
+
+        fullMessage.messageStubParameters = [NO_MESSAGE_FOUND_ERROR_TEXT];
+      }
+    },
+  };
+};
+
+async function normalizeQuoted(msg, repo) {
+  const CONTEXT_TYPES = [
+    "extendedTextMessage",
+    "imageMessage",
+    "videoMessage",
+    "documentMessage",
+    "audioMessage",
+    "stickerMessage",
+    "contactMessage",
+    "contactsArrayMessage",
+    "liveLocationMessage",
+    "buttonsMessage",
+    "buttonsResponseMessage",
+    "listMessage",
+    "listResponseMessage",
+    "templateMessage",
+    "templateButtonReplyMessage",
+    "interactiveMessage",
+    "interactiveResponseMessage",
+    "pollCreationMessage",
+    "pollCreationMessageV2",
+    "reactionMessage",
+  ];
+  let ctx = null;
+  for (const type of CONTEXT_TYPES) {
+    const contextInfo = msg?.[type]?.contextInfo;
+    if (contextInfo) {
+      ctx = contextInfo;
+      break;
+    }
+  }
+  if (!ctx?.participant) return;
+  if (typeof ctx.participant === "string" && ctx.participant.endsWith("@lid")) {
+    const pn = await repo.lidMapping.getPNForLID(ctx.participant);
+    if (pn) ctx.participant = pn;
+  }
+}