@cdteam/cdwa 0.0.0-stage → 0.1.0

package/dist/messages/index.cjs

@@ -0,0 +1,662 @@
+'use strict';
+
+var crypto = require('crypto');
+var sha256 = require('@noble/hashes/sha256');
+var ed25519 = require('@noble/curves/ed25519');
+var hkdf = require('@noble/hashes/hkdf');
+var aes = require('@noble/ciphers/aes');
+
+// src/messages/media.ts
+
+// src/crypto/index.ts
+var CryptoEngine = class {
+  /**
+   * Gera um novo par de chaves Curve25519 (Diffie-Hellman)
+   */
+  static generateKeyPair() {
+    const priv = crypto.randomBytes(32);
+    const pub = ed25519.x25519.getPublicKey(priv);
+    return {
+      private: new Uint8Array(priv),
+      public: new Uint8Array(pub)
+    };
+  }
+  /**
+   * Executa Diffie-Hellman compartilhado (Shared Secret) usando Curve25519
+   */
+  static sharedKey(privateKey, publicKey) {
+    return ed25519.x25519.getSharedSecret(privateKey, publicKey);
+  }
+  /**
+   * HKDF baseado em SHA-256 para derivação segura de chaves (RFC 5869)
+   */
+  static deriveKey(secret, info, salt, length = 32) {
+    const infoBytes = typeof info === "string" ? new TextEncoder().encode(info) : info;
+    return hkdf.hkdf(sha256.sha256, secret, salt, infoBytes, length);
+  }
+  /**
+   * Encriptação autenticada com AES-256-GCM
+   */
+  static aesGcmEncrypt(key, plaintext, iv, additionalData) {
+    const cipher = aes.gcm(key, iv, additionalData);
+    return cipher.encrypt(plaintext);
+  }
+  /**
+   * Decriptação autenticada com AES-256-GCM
+   */
+  static aesGcmDecrypt(key, ciphertext, iv, additionalData) {
+    const cipher = aes.gcm(key, iv, additionalData);
+    return cipher.decrypt(ciphertext);
+  }
+  /**
+   * Encripta um payload com uma senha mestra (para proteger credenciais at-rest)
+   */
+  static encryptAtRest(payload, masterPassphrase) {
+    const salt = crypto.randomBytes(16);
+    const iv = crypto.randomBytes(12);
+    const key = hkdf.hkdf(sha256.sha256, new TextEncoder().encode(masterPassphrase), salt, new TextEncoder().encode("cdwa-at-rest"), 32);
+    const encrypted = this.aesGcmEncrypt(key, payload, iv);
+    return {
+      salt: Buffer.from(salt).toString("hex"),
+      iv: Buffer.from(iv).toString("hex"),
+      data: Buffer.from(encrypted).toString("base64")
+    };
+  }
+  /**
+   * Decripta um payload protegido com a senha mestra
+   */
+  static decryptAtRest(encryptedBundle, masterPassphrase) {
+    const salt = Buffer.from(encryptedBundle.salt, "hex");
+    const iv = Buffer.from(encryptedBundle.iv, "hex");
+    const data = Buffer.from(encryptedBundle.data, "base64");
+    const key = hkdf.hkdf(sha256.sha256, new TextEncoder().encode(masterPassphrase), salt, new TextEncoder().encode("cdwa-at-rest"), 32);
+    return this.aesGcmDecrypt(key, data, iv);
+  }
+};
+
+// src/messages/media.ts
+var MEDIA_HKDF_INFO = {
+  image: "WhatsApp Image Keys",
+  video: "WhatsApp Video Keys",
+  audio: "WhatsApp Audio Keys",
+  document: "WhatsApp Document Keys"
+};
+var MediaCrypto = class {
+  /**
+   * Criptografa o arquivo de mídia de acordo com o padrão RFC do WhatsApp
+   */
+  static encryptMedia(mediaBuffer, type) {
+    const mediaKey = crypto.randomBytes(32);
+    const info = MEDIA_HKDF_INFO[type];
+    const expandedKeys = CryptoEngine.deriveKey(new Uint8Array(mediaKey), info, void 0, 112);
+    const iv = expandedKeys.slice(0, 16);
+    const cipherKey = expandedKeys.slice(16, 48);
+    const macKey = expandedKeys.slice(48, 80);
+    const fileSha256 = sha256.sha256(mediaBuffer);
+    const cipher = crypto.createCipheriv("aes-256-cbc", Buffer.from(cipherKey), Buffer.from(iv));
+    const encryptedBody = Buffer.concat([cipher.update(Buffer.from(mediaBuffer)), cipher.final()]);
+    const hmac = crypto.createHmac("sha256", Buffer.from(macKey));
+    hmac.update(Buffer.from(iv));
+    hmac.update(encryptedBody);
+    const fullMac = hmac.digest();
+    const mac = fullMac.subarray(0, 10);
+    const finalCiphertext = new Uint8Array(encryptedBody.length + mac.length);
+    finalCiphertext.set(encryptedBody, 0);
+    finalCiphertext.set(mac, encryptedBody.length);
+    const fileEncSha256 = sha256.sha256(finalCiphertext);
+    return {
+      mediaKey: new Uint8Array(mediaKey),
+      ciphertext: finalCiphertext,
+      fileSha256: new Uint8Array(fileSha256),
+      fileEncSha256: new Uint8Array(fileEncSha256),
+      mac: new Uint8Array(mac)
+    };
+  }
+};
+
+// src/binary/constants.ts
+var WABinaryConstants = {
+  LIST_EMPTY: 0,
+  LIST_8: 248,
+  LIST_16: 249,
+  BINARY_8: 252,
+  BINARY_32: 254};
+var SINGLE_BYTE_TOKENS = [
+  "",
+  "",
+  "",
+  "200",
+  "400",
+  "404",
+  "500",
+  "501",
+  "502",
+  "action",
+  "add",
+  "after",
+  "archive",
+  "author",
+  "available",
+  "battery",
+  "before",
+  "body",
+  "broadcast",
+  "chat",
+  "clear",
+  "code",
+  "composing",
+  "config",
+  "contacts",
+  "count",
+  "create",
+  "debug",
+  "delete",
+  "demote",
+  "duplicate",
+  "encoding",
+  "error",
+  "false",
+  "filehash",
+  "from",
+  "g.us",
+  "group",
+  "groups_v2",
+  "height",
+  "ib",
+  "id",
+  "image",
+  "in",
+  "index",
+  "invis",
+  "item",
+  "jid",
+  "kind",
+  "last",
+  "leave",
+  "live",
+  "log",
+  "media",
+  "message",
+  "mimetype",
+  "missing",
+  "modify",
+  "name",
+  "notification",
+  "notify",
+  "out",
+  "owner",
+  "participant",
+  "paused",
+  "picture",
+  "played",
+  "presence",
+  "preview",
+  "promote",
+  "query",
+  "raw",
+  "read",
+  "receipt",
+  "received",
+  "recipient",
+  "recording",
+  "relay",
+  "remove",
+  "response",
+  "resume",
+  "retry",
+  "s.whatsapp.net",
+  "seconds",
+  "set",
+  "size",
+  "status",
+  "subject",
+  "subscribe",
+  "t",
+  "text",
+  "to",
+  "true",
+  "type",
+  "unarchive",
+  "unavailable",
+  "url",
+  "user",
+  "value",
+  "web",
+  "width",
+  "mute",
+  "read_only",
+  "admin",
+  "creator",
+  "short",
+  "update",
+  "powersave",
+  "rich",
+  "modify_tag",
+  "message_info",
+  "opaque",
+  "contact",
+  "unlink",
+  "iq",
+  "ping",
+  "version",
+  "client",
+  "pair-device",
+  "pair-success",
+  "success",
+  "failure"
+];
+var TOKEN_MAP = /* @__PURE__ */ new Map();
+SINGLE_BYTE_TOKENS.forEach((token, index) => {
+  if (token) {
+    TOKEN_MAP.set(token, index);
+  }
+});
+
+// src/binary/encoder.ts
+var BinaryEncoder = class {
+  buffer = [];
+  encode(node) {
+    this.buffer = [];
+    this.writeNode(node);
+    return new Uint8Array(this.buffer);
+  }
+  writeByte(byte) {
+    this.buffer.push(byte & 255);
+  }
+  writeBytes(bytes) {
+    for (let i = 0; i < bytes.length; i++) {
+      this.writeByte(bytes[i]);
+    }
+  }
+  writeInt16(value) {
+    this.writeByte(value >> 8 & 255);
+    this.writeByte(value & 255);
+  }
+  writeInt32(value) {
+    this.writeByte(value >> 24 & 255);
+    this.writeByte(value >> 16 & 255);
+    this.writeByte(value >> 8 & 255);
+    this.writeByte(value & 255);
+  }
+  writeListStart(size) {
+    if (size === 0) {
+      this.writeByte(WABinaryConstants.LIST_EMPTY);
+    } else if (size < 256) {
+      this.writeByte(WABinaryConstants.LIST_8);
+      this.writeByte(size);
+    } else {
+      this.writeByte(WABinaryConstants.LIST_16);
+      this.writeInt16(size);
+    }
+  }
+  writeString(str) {
+    const tokenIndex = TOKEN_MAP.get(str);
+    if (tokenIndex !== void 0) {
+      this.writeByte(tokenIndex);
+      return;
+    }
+    const encoded = new TextEncoder().encode(str);
+    if (encoded.length < 256) {
+      this.writeByte(WABinaryConstants.BINARY_8);
+      this.writeByte(encoded.length);
+    } else {
+      this.writeByte(WABinaryConstants.BINARY_32);
+      this.writeInt32(encoded.length);
+    }
+    this.writeBytes(encoded);
+  }
+  writeNode(node) {
+    const numAttrs = Object.keys(node.attrs).length;
+    const hasContent = node.content !== void 0;
+    const listSize = 1 + numAttrs * 2 + (hasContent ? 1 : 0);
+    this.writeListStart(listSize);
+    this.writeString(node.tag);
+    for (const [key, value] of Object.entries(node.attrs)) {
+      if (value !== void 0) {
+        this.writeString(key);
+        this.writeString(String(value));
+      }
+    }
+    if (hasContent) {
+      if (Array.isArray(node.content)) {
+        this.writeListStart(node.content.length);
+        for (const child of node.content) {
+          this.writeNode(child);
+        }
+      } else if (typeof node.content === "string") {
+        this.writeString(node.content);
+      } else if (node.content instanceof Uint8Array) {
+        if (node.content.length < 256) {
+          this.writeByte(WABinaryConstants.BINARY_8);
+          this.writeByte(node.content.length);
+        } else {
+          this.writeByte(WABinaryConstants.BINARY_32);
+          this.writeInt32(node.content.length);
+        }
+        this.writeBytes(node.content);
+      }
+    }
+  }
+};
+
+// src/binary/decoder.ts
+var BinaryDecoder = class {
+  buffer = new Uint8Array(0);
+  offset = 0;
+  decode(buffer) {
+    this.buffer = buffer;
+    this.offset = 0;
+    return this.readNode();
+  }
+  readByte() {
+    if (this.offset >= this.buffer.length) {
+      throw new Error(`Unexpected EOF in WABinary stream at offset ${this.offset}`);
+    }
+    const b = this.buffer[this.offset];
+    this.offset += 1;
+    return b;
+  }
+  readBytes(length) {
+    if (this.offset + length > this.buffer.length) {
+      throw new Error(`Buffer underrun: requested ${length} bytes, have ${this.buffer.length - this.offset}`);
+    }
+    const slice = this.buffer.slice(this.offset, this.offset + length);
+    this.offset += length;
+    return slice;
+  }
+  readInt16() {
+    const b0 = this.readByte();
+    const b1 = this.readByte();
+    return b0 << 8 | b1;
+  }
+  readInt32() {
+    const b0 = this.readByte();
+    const b1 = this.readByte();
+    const b2 = this.readByte();
+    const b3 = this.readByte();
+    return b0 << 24 | b1 << 16 | b2 << 8 | b3;
+  }
+  readListSize() {
+    const tag = this.readByte();
+    if (tag === WABinaryConstants.LIST_EMPTY) {
+      return 0;
+    }
+    if (tag === WABinaryConstants.LIST_8) {
+      return this.readByte();
+    }
+    if (tag === WABinaryConstants.LIST_16) {
+      return this.readInt16();
+    }
+    throw new Error(`Invalid list tag byte: ${tag}`);
+  }
+  readString() {
+    const tag = this.readByte();
+    if (tag < SINGLE_BYTE_TOKENS.length && SINGLE_BYTE_TOKENS[tag]) {
+      return SINGLE_BYTE_TOKENS[tag];
+    }
+    if (tag === WABinaryConstants.BINARY_8) {
+      const length = this.readByte();
+      const bytes = this.readBytes(length);
+      return new TextDecoder().decode(bytes);
+    }
+    if (tag === WABinaryConstants.BINARY_32) {
+      const length = this.readInt32();
+      const bytes = this.readBytes(length);
+      return new TextDecoder().decode(bytes);
+    }
+    throw new Error(`Unsupported string tag: ${tag} at offset ${this.offset - 1}`);
+  }
+  readNode() {
+    const listSize = this.readListSize();
+    if (listSize === 0) {
+      throw new Error("Invalid empty node");
+    }
+    const tag = this.readString();
+    const attrs = {};
+    let remaining = listSize - 1;
+    while (remaining > 1) {
+      const key = this.readString();
+      const val = this.readString();
+      attrs[key] = val;
+      remaining -= 2;
+    }
+    let content;
+    if (remaining === 1) {
+      const peekByte = this.buffer[this.offset];
+      if (peekByte === WABinaryConstants.LIST_EMPTY || peekByte === WABinaryConstants.LIST_8 || peekByte === WABinaryConstants.LIST_16) {
+        const childCount = this.readListSize();
+        const children = [];
+        for (let i = 0; i < childCount; i++) {
+          children.push(this.readNode());
+        }
+        content = children;
+      } else if (peekByte === WABinaryConstants.BINARY_8 || peekByte === WABinaryConstants.BINARY_32) {
+        const nextTag = this.readByte();
+        const length = nextTag === WABinaryConstants.BINARY_8 ? this.readByte() : this.readInt32();
+        content = this.readBytes(length);
+      } else {
+        content = this.readString();
+      }
+    }
+    return { tag, attrs, content };
+  }
+};
+
+// src/binary/index.ts
+var BinaryProtocol = class {
+  static encoder = new BinaryEncoder();
+  static decoder = new BinaryDecoder();
+  /**
+   * Converte um BinaryNode para bytes WABinary
+   */
+  static encode(node) {
+    return this.encoder.encode(node);
+  }
+  /**
+   * Converte bytes WABinary de volta para um BinaryNode estruturado
+   */
+  static decode(buffer) {
+    return this.decoder.decode(buffer);
+  }
+  /**
+   * Constrói um nó binário com validação de formato
+   */
+  static createNode(tag, attrs = {}, content) {
+    return {
+      tag,
+      attrs,
+      content
+    };
+  }
+  /**
+   * Localiza o primeiro filho correspondente à tag fornecida
+   */
+  static getChildNode(node, childTag) {
+    if (Array.isArray(node.content)) {
+      return node.content.find((child) => child.tag === childTag);
+    }
+    return void 0;
+  }
+  /**
+   * Extrai todos os nós filhos que batem com uma determinada tag
+   */
+  static getChildrenNodes(node, childTag) {
+    if (Array.isArray(node.content)) {
+      return node.content.filter((child) => child.tag === childTag);
+    }
+    return [];
+  }
+  /**
+   * Converte o nó para representação em string legível para debug
+   */
+  static stringify(node, indent = 0) {
+    const spaces = "  ".repeat(indent);
+    const attrsStr = Object.entries(node.attrs).map(([k, v]) => `${k}="${v}"`).join(" ");
+    const openTag = attrsStr ? `<${node.tag} ${attrsStr}>` : `<${node.tag}>`;
+    if (!node.content) {
+      return `${spaces}<${node.tag} ${attrsStr} />`;
+    }
+    if (Array.isArray(node.content)) {
+      const children = node.content.map((c) => this.stringify(c, indent + 1)).join("\n");
+      return `${spaces}${openTag}
+${children}
+${spaces}</${node.tag}>`;
+    }
+    const contentStr = node.content instanceof Uint8Array ? `[Buffer ${node.content.length}b]` : String(node.content);
+    return `${spaces}${openTag}${contentStr}</${node.tag}>`;
+  }
+};
+
+// src/messages/builder.ts
+var MessageBuilder = class {
+  /**
+   * Converte qualquer conteúdo de mensagem em uma stanza <message> pronta para transmissão
+   */
+  static async buildMessageNode(jid, content, options = {}) {
+    const messageId = `3EB0${Date.now().toString(16).toUpperCase()}${Math.floor(Math.random() * 1e4)}`;
+    const timestamp = options.timestamp || Math.floor(Date.now() / 1e3);
+    const messageAttrs = {
+      id: messageId,
+      to: jid,
+      type: "text",
+      t: timestamp
+    };
+    let payloadContent = new Uint8Array(0);
+    if ("text" in content) {
+      payloadContent = new TextEncoder().encode(content.text);
+    } else if ("image" in content) {
+      messageAttrs.type = "media";
+      messageAttrs.mediatype = "image";
+      const buffer = await this.resolveMediaBuffer(content.image);
+      const encrypted = MediaCrypto.encryptMedia(buffer, "image");
+      payloadContent = [
+        BinaryProtocol.createNode("image", {
+          mimetype: content.mimetype || "image/jpeg",
+          caption: content.caption,
+          fileLength: buffer.length,
+          fileSha256: Buffer.from(encrypted.fileSha256).toString("base64"),
+          fileEncSha256: Buffer.from(encrypted.fileEncSha256).toString("base64"),
+          mediaKey: Buffer.from(encrypted.mediaKey).toString("base64")
+        })
+      ];
+    } else if ("video" in content) {
+      messageAttrs.type = "media";
+      messageAttrs.mediatype = "video";
+      const buffer = await this.resolveMediaBuffer(content.video);
+      const encrypted = MediaCrypto.encryptMedia(buffer, "video");
+      payloadContent = [
+        BinaryProtocol.createNode("video", {
+          mimetype: content.mimetype || "video/mp4",
+          caption: content.caption,
+          gifPlayback: content.gifPlayback ? "true" : void 0,
+          ptv: content.ptv ? "true" : void 0,
+          fileLength: buffer.length,
+          fileSha256: Buffer.from(encrypted.fileSha256).toString("base64"),
+          fileEncSha256: Buffer.from(encrypted.fileEncSha256).toString("base64"),
+          mediaKey: Buffer.from(encrypted.mediaKey).toString("base64")
+        })
+      ];
+    } else if ("audio" in content) {
+      messageAttrs.type = "media";
+      messageAttrs.mediatype = "audio";
+      const buffer = await this.resolveMediaBuffer(content.audio);
+      const encrypted = MediaCrypto.encryptMedia(buffer, "audio");
+      payloadContent = [
+        BinaryProtocol.createNode("audio", {
+          mimetype: content.mimetype || (content.ptt ? "audio/ogg; codecs=opus" : "audio/mp4"),
+          ptt: content.ptt ? "true" : "false",
+          fileLength: buffer.length,
+          fileSha256: Buffer.from(encrypted.fileSha256).toString("base64"),
+          fileEncSha256: Buffer.from(encrypted.fileEncSha256).toString("base64"),
+          mediaKey: Buffer.from(encrypted.mediaKey).toString("base64")
+        })
+      ];
+    } else if ("document" in content) {
+      messageAttrs.type = "media";
+      messageAttrs.mediatype = "document";
+      const buffer = await this.resolveMediaBuffer(content.document);
+      const encrypted = MediaCrypto.encryptMedia(buffer, "document");
+      payloadContent = [
+        BinaryProtocol.createNode("document", {
+          mimetype: content.mimetype,
+          fileName: content.fileName || "file",
+          caption: content.caption,
+          fileLength: buffer.length,
+          fileSha256: Buffer.from(encrypted.fileSha256).toString("base64"),
+          fileEncSha256: Buffer.from(encrypted.fileEncSha256).toString("base64"),
+          mediaKey: Buffer.from(encrypted.mediaKey).toString("base64")
+        })
+      ];
+    } else if ("location" in content) {
+      messageAttrs.type = "location";
+      payloadContent = [
+        BinaryProtocol.createNode("location", {
+          degreesLatitude: content.location.degreesLatitude,
+          degreesLongitude: content.location.degreesLongitude,
+          name: content.location.name,
+          address: content.location.address,
+          url: content.location.url
+        })
+      ];
+    } else if ("contact" in content) {
+      messageAttrs.type = "contact";
+      payloadContent = [
+        BinaryProtocol.createNode("contact", {
+          displayName: content.contact.displayName,
+          vcard: content.contact.vcard
+        })
+      ];
+    } else if ("contacts" in content) {
+      messageAttrs.type = "contacts";
+      const contactNodes = content.contacts.contacts.map(
+        (c) => BinaryProtocol.createNode("contact", {
+          displayName: c.displayName,
+          vcard: c.vcard
+        })
+      );
+      payloadContent = [
+        BinaryProtocol.createNode(
+          "contacts",
+          { displayName: content.contacts.displayName },
+          contactNodes
+        )
+      ];
+    } else if ("react" in content) {
+      messageAttrs.type = "reaction";
+      payloadContent = [
+        BinaryProtocol.createNode("reaction", {
+          text: content.react.text,
+          targetId: content.react.key.id,
+          targetJid: content.react.key.remoteJid
+        })
+      ];
+    }
+    const node = BinaryProtocol.createNode("message", messageAttrs, payloadContent);
+    return {
+      node,
+      messageId
+    };
+  }
+  /**
+   * Resolve diferentes fontes de mídia (Buffer, Uint8Array ou URL) para um Uint8Array em memória
+   */
+  static async resolveMediaBuffer(source) {
+    if (source instanceof Uint8Array) {
+      return source;
+    }
+    if (Buffer.isBuffer(source)) {
+      return new Uint8Array(source);
+    }
+    if (typeof source === "object" && source !== null && "url" in source) {
+      const res = await fetch(source.url);
+      const arrayBuf = await res.arrayBuffer();
+      return new Uint8Array(arrayBuf);
+    }
+    throw new Error("Unsupported media source format");
+  }
+};
+
+exports.MediaCrypto = MediaCrypto;
+exports.MessageBuilder = MessageBuilder;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map