@prototypevip/baileys 0.1.0 → 0.1.2

package/lib/Utils/index.js

@@ -29,3 +29,5 @@ export * from "./rich-message-utils.js";
 export * from "./message-builder.js";
 export * from "./ai-rich-formatter.js";
 export * from "./constants.js";
+export * from "./socket-guard.js";
+export * from "./integrity-guard.js";

package/lib/Utils/integrity-guard.js

@@ -0,0 +1,281 @@
+'use strict';
+
+/**
+ * integrity-guard.js
+ * توسيع لنفس فلسفة socket-guard.js: أي عنصر حرج في البوت (موديول المالك،
+ * أرقام المالكين، بصمة الاسم "prototype") لو اتشال/اتغيّر/اتفك تشفيره غلط
+ * → نفس الكيل سويتش (كتابة ملف .proto_kill + رساله + process.exit).
+ *
+ * القيم الحساسة هنا مشتقة من bytes مش نصوص صريحة، عشان أي أداة rename
+ * بتدور على كلمة "prototype" كنص (زي سوكت.js نفسه) متلمّهاش وتغيّرها بالغلط،
+ * وفي نفس الوقت لو حد غيّرها يدوي قصدًا يبقى فرق البصمة واضح.
+ */
+
+import fs from "fs";
+import crypto from "crypto";
+import path from "path";
+import { fileURLToPath } from "url";
+import { PROTO_MARK_VALUE, isKilled, writeKill } from "./socket-guard.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// "prototypevip" + "baileys" كـ bytes مش كنص صريح
+const SCOPE_BYTES = [
+  0x70, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x76, 0x69, 0x70,
+]; // prototypevip
+const PKG_BYTES = [0x62, 0x61, 0x69, 0x6c, 0x65, 0x79, 0x73]; // baileys
+const WORD_BYTES = [
+  0x50, 0x52, 0x4f, 0x54, 0x4f, 0x54, 0x59, 0x50, 0x45,
+]; // PROTOTYPE
+
+function expectedScopedName() {
+  return `@${Buffer.from(SCOPE_BYTES).toString()}/${Buffer.from(PKG_BYTES).toString()}`;
+}
+
+function brandFingerprintSource() {
+  return `${Buffer.from(WORD_BYTES).toString()}:${PROTO_MARK_VALUE}:${expectedScopedName()}`;
+}
+
+// بصمة ثابتة محسوبة مرة واحدة على نفس القيم أعلاه — أي تعديل يدوي في أي
+// جزء من الثلاثة (WORD_BYTES / PROTO_MARK_VALUE / اسم السكوب) يكسر التطابق.
+const EXPECTED_BRAND_HASH = crypto
+  .createHash("sha256")
+  .update(brandFingerprintSource())
+  .digest("hex");
+
+/**
+ * تشتقاق مفتاح تشفير من نفس بصمة الماركة — بيربط حماية الأرقام المشفرة
+ * بحماية الختم والبراند في ملف واحد؛ لو حد لعب في أي منهم يبوظ التاني.
+ */
+function deriveKey(config = {}) {
+  const seed = (config && config.keySeed) || brandFingerprintSource();
+  return crypto.createHash("sha256").update(String(seed)).digest();
+}
+
+/* ---------------- بصمة اسم المكتبه (package.json) ---------------- */
+
+function readOwnPackageJson() {
+  // lib/Utils/integrity-guard.js -> ../../package.json
+  const pkgPath = path.join(__dirname, "..", "..", "package.json");
+  const raw = fs.readFileSync(pkgPath, "utf8");
+  return JSON.parse(raw);
+}
+
+function verifyPackageIdentity() {
+  try {
+    const pkg = readOwnPackageJson();
+    return pkg && pkg.name === expectedScopedName();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * التحقق النهائي من "بصمة الاسم": تطابق الهاش + تطابق اسم الباكدج.
+ */
+function verifyBrandIntegrity() {
+  try {
+    const h = crypto.createHash("sha256").update(brandFingerprintSource()).digest("hex");
+    if (h !== EXPECTED_BRAND_HASH) return false;
+    return verifyPackageIdentity();
+  } catch {
+    return false;
+  }
+}
+
+/* ---------------- موديول isOwner ---------------- */
+
+/**
+ * البوت هو اللي بيعمل require لملف isOwner بتاعه ويبعت الـ module هنا
+ * (المكتبه مش عارفه مسار البوت أصلًا). بنتأكد إن الشكل سليم فعلًا.
+ */
+function verifyOwnerModule(mod) {
+  try {
+    if (!mod || typeof mod !== "object") return false;
+    if (typeof mod.isOwner !== "function") return false;
+    if (typeof mod.isMainOwner !== "function") return false;
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/* ---------------- تخزين الأرقام مشفرة (AES-256-GCM) ---------------- */
+
+function signEncryptedStore(payload, config = {}) {
+  const key = deriveKey(config);
+  const iv = crypto.randomBytes(12);
+  const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
+  const enc = Buffer.concat([
+    cipher.update(JSON.stringify(payload), "utf8"),
+    cipher.final(),
+  ]);
+  const tag = cipher.getAuthTag();
+  return {
+    v: 1,
+    iv: iv.toString("base64"),
+    enc: enc.toString("base64"),
+    tag: tag.toString("base64"),
+  };
+}
+
+function writeEncryptedStore(filePath, payload, config = {}) {
+  const data = signEncryptedStore(payload, config);
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data), "utf8");
+}
+
+function readEncryptedStore(filePath, config = {}) {
+  const raw = JSON.parse(fs.readFileSync(filePath, "utf8"));
+  const key = deriveKey(config);
+  const decipher = crypto.createDecipheriv(
+    "aes-256-gcm",
+    key,
+    Buffer.from(raw.iv, "base64")
+  );
+  decipher.setAuthTag(Buffer.from(raw.tag, "base64"));
+  const dec = Buffer.concat([
+    decipher.update(Buffer.from(raw.enc, "base64")),
+    decipher.final(),
+  ]);
+  return JSON.parse(dec.toString("utf8"));
+}
+
+/**
+ * أي تعديل يدوي في الملف (نص أو byte واحد) بيكسر GCM auth tag ويرجع false،
+ * زي ما الملف الناقص خالص بيرجع false.
+ */
+function verifyEncryptedNumbers(filePath, config = {}) {
+  try {
+    if (!filePath || !fs.existsSync(filePath)) return false;
+    const data = readEncryptedStore(filePath, config);
+    return (
+      Array.isArray(data) &&
+      data.length > 0 &&
+      data.every((n) => /^\d{6,}$/.test(String(n)))
+    );
+  } catch {
+    return false;
+  }
+}
+
+/* ---------------- كيل سويتش عام لأي عنصر حرج ---------------- */
+
+/**
+ * enforceOrDie: نفس آلية enforceSocketOrDie بالظبط لكن عامّه لأي فحص
+ * (اسم العنصر + نتيجة boolean بدل ما تبقى مربوطة بالسوكت بس).
+ */
+async function enforceOrDie(name, ok, sock, chatId, config = {}) {
+  if (ok) return true;
+
+  writeKill(config, `critical_missing:${name}`);
+
+  const msg = config.killMessage || "لا يمكنك استخدام هذا بوت";
+  try {
+    if (sock && typeof sock.sendMessage === "function" && chatId) {
+      await sock.sendMessage(chatId, { text: msg });
+    }
+  } catch {}
+
+  try {
+    console.error(`[INTEGRITY-GUARD] "${name}" check failed — bot disabled permanently.`);
+  } catch {}
+
+  setTimeout(() => {
+    try {
+      process.exit(1);
+    } catch {}
+  }, 1500);
+
+  return false;
+}
+
+/**
+ * فحص دوري (بعد الإقلاع) بيعيد التأكد من نفس العناصر كل فترة، عشان لو حد
+ * مسح/عدّل الملفات وهو البوت شغال (مش بس وقت الإقلاع) يتوقف برضه.
+ */
+function startPeriodicIntegrityWatch(checks, sock, getChatId, config = {}, intervalMs = 10 * 60 * 1000) {
+  const timer = setInterval(async () => {
+    if (isKilled(config)) return; // هيتقفل من مكان تاني أصلًا
+    for (const [name, fn] of Object.entries(checks)) {
+      let ok = false;
+      try {
+        ok = !!(await fn());
+      } catch {
+        ok = false;
+      }
+      if (!ok) {
+        const chatId = typeof getChatId === "function" ? getChatId() : getChatId;
+        await enforceOrDie(name, false, sock, chatId, config);
+        clearInterval(timer);
+        return;
+      }
+    }
+  }, intervalMs);
+  if (timer.unref) timer.unref();
+  return timer;
+}
+
+/* ---------------- بصمة ملفات حرجه (manifest موقّع) ---------------- */
+
+/**
+ * بديل عام لأي محاولة تعديل "منطق" ملف حرج (مش بس حذفه) — زي حد يفتح
+ * isOwner.js ويحط `return true` ثابت، أو يفتح protoGuard.js ويعطل فحص.
+ * بنسجّل بصمة SHA-256 لكل ملف مهم وقت الإعداد، ونوقّع القايمه كلها بمفتاح
+ * مشتق من نفس بصمة الماركة، فبعد كده أي حرف يتغيّر في أي ملف من الليست
+ * يكسر التطابق. المانفست نفسه لو اتلمس (بدون التوقيع الصح) بيفشل فك التشفير.
+ */
+function hashFile(absPath) {
+  const buf = fs.readFileSync(absPath);
+  return crypto.createHash("sha256").update(buf).digest("hex");
+}
+
+/**
+ * files: { "relative/or/absolute/path.js": absolutePathOnDisk }
+ * بيرجع نفس شكل signEncryptedStore (iv/enc/tag) عشان يتحفظ في ملف زي أي
+ * ملف حساس تاني في المشروع.
+ */
+function writeFileManifest(files, manifestPath, config = {}) {
+  const entries = {};
+  for (const [label, absPath] of Object.entries(files)) {
+    entries[label] = hashFile(absPath);
+  }
+  writeEncryptedStore(manifestPath, entries, config);
+  return entries;
+}
+
+/**
+ * files: نفس الشكل المستخدم وقت الكتابة. بيرجع false لو المانفست ناقص/
+ * مش قابل لفك التشفير (تلاعب في التوقيع)، أو لو أي ملف من الليست ناقص،
+ * أو لو الهاش بتاعه اتغيّر عن اللي كان متسجل وقت seed-manifest.
+ */
+function verifyFileManifest(files, manifestPath, config = {}) {
+  try {
+    if (!fs.existsSync(manifestPath)) return false;
+    const recorded = readEncryptedStore(manifestPath, config);
+    for (const [label, absPath] of Object.entries(files)) {
+      if (!fs.existsSync(absPath)) return false;
+      if (recorded[label] !== hashFile(absPath)) return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export {
+  verifyBrandIntegrity,
+  verifyPackageIdentity,
+  verifyOwnerModule,
+  signEncryptedStore,
+  writeEncryptedStore,
+  readEncryptedStore,
+  verifyEncryptedNumbers,
+  enforceOrDie,
+  startPeriodicIntegrityWatch,
+  deriveKey,
+  writeFileManifest,
+  verifyFileManifest,
+};

package/lib/Utils/interactive-message-handler.js

@@ -3,10 +3,11 @@ import crypto from 'crypto';
 import * as Utils_1 from '../Utils/index.js';
 
 export default class InteractiveMessageHandler {
-    constructor(utils, waUploadToServer, relayMessageFn) {
+    constructor(utils, waUploadToServer, relayMessageFn, emitUpsert) {
         this.utils = utils;
         this.relayMessage = relayMessageFn;
         this.waUploadToServer = waUploadToServer;
+        this.emitUpsert = typeof emitUpsert === "function" ? emitUpsert : () => {};
         
         this.bail = {
             generateWAMessageContent: this.utils.generateWAMessageContent || Utils_1.generateWAMessageContent,
@@ -289,8 +290,10 @@ export default class InteractiveMessageHandler {
         
         await this.relayMessage(jid, album.message, {
             messageId: album.key.id,
+            skipStoreEmit: true,
         });
-        
+        this.emitUpsert(album);
+
         for (let content of array) {
             const img = await this.utils.generateWAMessage(jid, content, {
                 upload: this.waUploadToServer,
@@ -347,6 +350,7 @@ export default class InteractiveMessageHandler {
 
             await this.relayMessage(jid, img.message, {
                 messageId: img.key.id,
+                skipStoreEmit: true,
                 quoted: {
                     key: {
                         remoteJid: album.key.remoteJid,
@@ -357,6 +361,7 @@ export default class InteractiveMessageHandler {
                     message: album.message,
                 },
             });
+            this.emitUpsert(img);
         }
         return album;
     }   
@@ -407,8 +412,10 @@ export default class InteractiveMessageHandler {
         }, { quoted });
         
         await this.relayMessage(jid, msg.message, {
-            messageId: msg.key.id
+            messageId: msg.key.id,
+            skipStoreEmit: true,
         });
+        this.emitUpsert(msg);
         return msg;
     }
     
@@ -431,8 +438,10 @@ export default class InteractiveMessageHandler {
         });
     
         await this.relayMessage(jid, msg.message, {
-            messageId: msg.key.id
+            messageId: msg.key.id,
+            skipStoreEmit: true,
         });
+        this.emitUpsert(msg);
 
         return msg;
     }
@@ -463,16 +472,27 @@ export default class InteractiveMessageHandler {
             }
         }
 
+        const messageId = this.bail.generateMessageID();
         let msg = {
+            key: {
+                remoteJid: jid,
+                fromMe: true,
+                id: messageId,
+            },
             message: {
                 groupStatusMessageV2: {
                     message: waMsgContent.message || waMsgContent
                 }
-            }
+            },
+            messageTimestamp: Math.floor(Date.now() / 1000),
         };
 
-        return await this.relayMessage(jid, msg.message, {
-            messageId: this.bail.generateMessageID()
+        await this.relayMessage(jid, msg.message, {
+            messageId,
+            skipStoreEmit: true,
         });
+        this.emitUpsert(msg);
+
+        return msg;
     }
-}
+}