@whanext/core 0.17.0 → 0.17.1

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.17.1
+
+### Fixed
+
+- Compatibilidade com o novo formato criptografado de edições do WhatsApp (`secretEncryptedMessage`).
+- O provider interpreta `targetMessageKey.fromMe` pela perspectiva do editor, deriva a chave com `messageSecret` e descriptografa edições com AES-256-GCM.
+- Edições em conversas privadas preservam a chave local da mensagem original após a descriptografia.
+- Edições consecutivas preservam o `messageSecret` no cache para que a versão anterior continue disponível.
+- `messageEdited` continua com a mesma API pública da 0.17.0.
+
 ## 0.17.0
 
 ### Adicionado

package/README.md

@@ -175,7 +175,7 @@ O evento também informa `deletedById` quando o WhatsApp fornece a identidade re
 
 ## Mensagens editadas
 
-Edições recebidas pelo WhatsApp são expostas pelo evento `messageEdited`. Quando a versão anterior ainda estiver no cache recente, o payload inclui `previous`; `message` contém a versão atual.
+Edições recebidas pelo WhatsApp são expostas pelo evento `messageEdited`. A partir da 0.17.1, o provider inclui suporte ao envelope criptografado `secretEncryptedMessage` usado atualmente pelo WhatsApp para edições. Quando a versão anterior ainda estiver no cache recente, o payload inclui `previous`; `message` contém a versão atual.
 
 ```ts
 app.on('messageEdited', async ({ previous, message, editedByMe }) => {

package/dist/index.js

@@ -2305,7 +2305,7 @@ import {
   generateWAMessageFromContent,
   isJidGroup,
   makeWASocket,
-  proto,
+  proto as proto2,
   useMultiFileAuthState
 } from "@whiskeysockets/baileys";
 
@@ -2587,6 +2587,179 @@ function toDate(value) {
   return new Date(seconds * 1e3);
 }
 
+// src/provider/baileys/secret-edit.ts
+import { createDecipheriv, hkdfSync } from "crypto";
+import {
+  jidNormalizedUser,
+  normalizeMessageContent as normalizeMessageContent2,
+  proto
+} from "@whiskeysockets/baileys";
+function isSecretEncryptedEdit(message) {
+  const content = normalizeMessageContent2(message.message);
+  return content?.secretEncryptedMessage?.secretEncType === proto.Message.SecretEncryptedMessage.SecretEncType.MESSAGE_EDIT;
+}
+function secretEditTargetKey(message) {
+  const content = normalizeMessageContent2(message.message);
+  const secret = content?.secretEncryptedMessage;
+  if (secret?.secretEncType !== proto.Message.SecretEncryptedMessage.SecretEncType.MESSAGE_EDIT || !secret.targetMessageKey?.id) {
+    return void 0;
+  }
+  return secret.targetMessageKey;
+}
+function decryptSecretEncryptedEdit(envelope, original, meId, meLid) {
+  const content = normalizeMessageContent2(envelope.message);
+  const secret = content?.secretEncryptedMessage;
+  const targetKey = secret?.targetMessageKey;
+  if (secret?.secretEncType !== proto.Message.SecretEncryptedMessage.SecretEncType.MESSAGE_EDIT || !targetKey?.id || !secret.encPayload?.length || secret.encIv?.length !== 12) {
+    return void 0;
+  }
+  const messageSecret = findMessageSecret(original.message);
+  if (messageSecret?.length !== 32) {
+    return void 0;
+  }
+  const editorCandidates = envelope.key.fromMe ? uniqueUserJids([meId, meLid]) : uniqueUserJids([
+    envelope.key.participant,
+    envelope.key.participantAlt,
+    envelope.key.remoteJid,
+    envelope.key.remoteJidAlt
+  ]);
+  const originalSenderCandidates = targetKey.fromMe ? editorCandidates : isUserJid(envelope.key.remoteJid) ? uniqueUserJids([
+    targetKey.remoteJid,
+    targetKey.remoteJidAlt,
+    original.key.remoteJid,
+    original.key.remoteJidAlt
+  ]) : uniqueUserJids([
+    targetKey.participant,
+    targetKey.participantAlt,
+    original.key.participant,
+    original.key.participantAlt
+  ]);
+  const fallbackOriginalCandidates = original.key.fromMe ? uniqueUserJids([meId, meLid]) : uniqueUserJids([
+    original.key.participant,
+    original.key.participantAlt,
+    original.key.remoteJid,
+    original.key.remoteJidAlt
+  ]);
+  const senders = uniqueUserJids([
+    ...originalSenderCandidates,
+    ...fallbackOriginalCandidates
+  ]);
+  if (!editorCandidates.length || !senders.length) {
+    return void 0;
+  }
+  let decoded;
+  for (const originalSender of senders) {
+    for (const editor of editorCandidates) {
+      try {
+        decoded = decryptPayload(
+          targetKey.id,
+          originalSender,
+          editor,
+          messageSecret,
+          secret.encIv,
+          secret.encPayload
+        );
+        break;
+      } catch {
+        continue;
+      }
+    }
+    if (decoded) {
+      break;
+    }
+  }
+  const protocol = decoded?.protocolMessage;
+  if (protocol?.type !== proto.Message.ProtocolMessage.Type.MESSAGE_EDIT || !protocol.editedMessage || protocol.key?.id && protocol.key.id !== targetKey.id) {
+    return void 0;
+  }
+  const edited = protocol.editedMessage;
+  if (!edited.messageContextInfo?.messageSecret?.length) {
+    edited.messageContextInfo = {
+      ...edited.messageContextInfo,
+      messageSecret
+    };
+  }
+  return {
+    message: edited,
+    ...protocol.timestampMs ? { timestamp: Math.floor(numberValue(protocol.timestampMs) / 1e3) } : {}
+  };
+}
+function decryptPayload(messageId, originalSender, editor, messageSecret, iv, payload) {
+  const info = Buffer.concat([
+    Buffer.from(messageId, "utf8"),
+    Buffer.from(originalSender, "utf8"),
+    Buffer.from(editor, "utf8"),
+    Buffer.from("Message Edit", "utf8")
+  ]);
+  const key = Buffer.from(hkdfSync(
+    "sha256",
+    Buffer.from(messageSecret),
+    Buffer.alloc(32),
+    info,
+    32
+  ));
+  const encrypted = Buffer.from(payload);
+  if (encrypted.length <= 16) {
+    throw new Error("INVALID_EDIT_PAYLOAD");
+  }
+  const decipher = createDecipheriv("aes-256-gcm", key, Buffer.from(iv));
+  decipher.setAAD(Buffer.alloc(0));
+  decipher.setAuthTag(encrypted.subarray(encrypted.length - 16));
+  return proto.Message.decode(Buffer.concat([
+    decipher.update(encrypted.subarray(0, encrypted.length - 16)),
+    decipher.final()
+  ]));
+}
+function findMessageSecret(message) {
+  if (!message) {
+    return void 0;
+  }
+  const direct = message.messageContextInfo?.messageSecret;
+  if (direct?.length) {
+    return direct;
+  }
+  const normalized = normalizeMessageContent2(message);
+  const normalizedSecret = normalized?.messageContextInfo?.messageSecret;
+  if (normalizedSecret?.length) {
+    return normalizedSecret;
+  }
+  const deviceSecret = message.deviceSentMessage?.message?.messageContextInfo?.messageSecret;
+  if (deviceSecret?.length) {
+    return deviceSecret;
+  }
+  return void 0;
+}
+function uniqueUserJids(values) {
+  return [...new Set(
+    values.map(normalizeUserJid).filter((value) => value !== void 0)
+  )];
+}
+function normalizeUserJid(value) {
+  if (!isUserJid(value)) {
+    return void 0;
+  }
+  return jidNormalizedUser(value);
+}
+function isUserJid(value) {
+  if (!value) {
+    return false;
+  }
+  const normalized = jidNormalizedUser(value);
+  return normalized.endsWith("@s.whatsapp.net") || normalized.endsWith("@lid") || normalized.endsWith("@hosted") || normalized.endsWith("@hosted.lid");
+}
+function numberValue(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return Number(value);
+  }
+  if (value && typeof value === "object" && "toString" in value) {
+    return Number(String(value));
+  }
+  return Number(value);
+}
+
 // src/provider/baileys/baileys-provider.ts
 var BaileysProvider = class {
   #options;
@@ -2827,7 +3000,7 @@ var BaileysProvider = class {
   async setMessagePin(groupId, key, pinned) {
     await this.#requireSocket().sendMessage(groupId, {
       pin: this.#toWaKey(key),
-      type: pinned ? proto.PinInChat.Type.PIN_FOR_ALL : proto.PinInChat.Type.UNPIN_FOR_ALL,
+      type: pinned ? proto2.PinInChat.Type.PIN_FOR_ALL : proto2.PinInChat.Type.UNPIN_FOR_ALL,
       ...pinned ? { time: 604800 } : {}
     });
   }
@@ -2859,6 +3032,7 @@ var BaileysProvider = class {
     socket.ev.on("messages.upsert", ({ messages, type }) => {
       if (type !== "notify") return;
       for (const raw of messages) {
+        if (this.#handleSecretEncryptedEdit(raw)) continue;
         if (raw.key.id && raw.message) this.#remember(raw);
         const quoted = extractQuotedBaileysMessage(raw);
         if (quoted?.key.id && quoted.message) this.#remember(quoted);
@@ -2871,13 +3045,13 @@ var BaileysProvider = class {
         if (!key.id || !key.remoteJid) continue;
         const stored = this.#messageStore.get(this.#messageStoreKey(key));
         if (update.message === null) {
-          const message2 = stored ? normalizeBaileysMessage(stored) : void 0;
+          const message = stored ? normalizeBaileysMessage(stored) : void 0;
           const deletionKey = update.key;
           const deletedByMe = deletionKey?.fromMe === true;
           const deletedById = deletionKey?.participant ?? deletionKey?.participantAlt ?? (deletedByMe ? this.#socket?.user?.id : deletionKey?.remoteJid ?? void 0);
           void this.#events.emit("messageDeleted", {
-            key: message2?.keys ?? normalizeKey(key),
-            ...message2 ? { message: message2 } : {},
+            key: message?.keys ?? normalizeKey(key),
+            ...message ? { message } : {},
             deletedByMe,
             ...deletedById ? { deletedById } : {},
             deletedAt: /* @__PURE__ */ new Date()
@@ -2894,20 +3068,7 @@ var BaileysProvider = class {
           message: update.message,
           messageTimestamp: update.messageTimestamp ?? stored?.messageTimestamp ?? Math.floor(Date.now() / 1e3)
         };
-        const previous = stored ? normalizeBaileysMessage(stored) : void 0;
-        const message = normalizeBaileysMessage(editedRaw);
-        if (!message) continue;
-        this.#remember(editedRaw);
-        const editedByMe = key.fromMe === true;
-        const editedById = key.participant ?? key.participantAlt ?? (editedByMe ? this.#socket?.user?.id : key.remoteJid ?? void 0);
-        void this.#events.emit("messageEdited", {
-          key: message.keys,
-          ...previous ? { previous } : {},
-          message,
-          editedByMe,
-          ...editedById ? { editedById } : {},
-          editedAt: message.timestamp
-        });
+        this.#emitMessageEdited(key, editedRaw, stored);
       }
     });
     socket.ev.on("groups.update", (groups) => {
@@ -3007,7 +3168,7 @@ var BaileysProvider = class {
         "WhatsApp did not expose the current account identity for the interactive message."
       );
     }
-    const interactiveMessage = proto.Message.InteractiveMessage.create({
+    const interactiveMessage = proto2.Message.InteractiveMessage.create({
       ...content.title !== void 0 ? {
         header: {
           title: content.title,
@@ -3199,6 +3360,68 @@ var BaileysProvider = class {
     ];
     return known.find((value) => value === status) ?? "timeout";
   }
+  #handleSecretEncryptedEdit(raw) {
+    if (!isSecretEncryptedEdit(raw)) return false;
+    const targetKey = secretEditTargetKey(raw);
+    if (!targetKey?.id) return true;
+    const stored = this.#findStoredMessage(targetKey);
+    if (!stored) return true;
+    try {
+      const decrypted = decryptSecretEncryptedEdit(
+        raw,
+        stored,
+        this.#socket?.user?.id,
+        this.#socket?.user?.lid
+      );
+      if (!decrypted) return true;
+      const key = {
+        ...stored.key,
+        id: targetKey.id
+      };
+      const editedRaw = {
+        ...stored,
+        key,
+        message: {
+          editedMessage: {
+            message: decrypted.message
+          }
+        },
+        messageTimestamp: decrypted.timestamp ?? raw.messageTimestamp ?? stored.messageTimestamp ?? Math.floor(Date.now() / 1e3)
+      };
+      this.#emitMessageEdited(key, editedRaw, stored);
+    } catch (error) {
+      this.#logger.warn("Could not decrypt the encrypted message edit.", {
+        messageId: targetKey.id,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+    return true;
+  }
+  #emitMessageEdited(key, editedRaw, stored) {
+    const previous = stored ? normalizeBaileysMessage(stored) : void 0;
+    const message = normalizeBaileysMessage(editedRaw);
+    if (!message) return;
+    this.#remember(editedRaw);
+    const editedByMe = key.fromMe === true;
+    const editedById = key.participant ?? key.participantAlt ?? (editedByMe ? this.#socket?.user?.id : key.remoteJid ?? void 0);
+    void this.#events.emit("messageEdited", {
+      key: message.keys,
+      ...previous ? { previous } : {},
+      message,
+      editedByMe,
+      ...editedById ? { editedById } : {},
+      editedAt: message.timestamp
+    });
+  }
+  #findStoredMessage(key) {
+    const direct = this.#messageStore.get(this.#messageStoreKey(key));
+    if (direct) return direct;
+    if (!key.id) return void 0;
+    for (const message of this.#messageStore.values()) {
+      if (message.key.id === key.id) return message;
+    }
+    return void 0;
+  }
   #remember(message) {
     const key = this.#messageStoreKey(message.key);
     this.#messageStore.delete(key);