@cdteam/cdwa 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,1224 @@
+import { x25519 } from '@noble/curves/ed25519';
+import { hkdf } from '@noble/hashes/hkdf';
+import { sha256 } from '@noble/hashes/sha256';
+import { gcm } from '@noble/ciphers/aes';
+import { randomBytes, createCipheriv, createHmac } from 'crypto';
+import { promises } from 'fs';
+import path from 'path';
+import WebSocket from 'ws';
+import { EventEmitter } from 'events';
+
+// src/crypto/index.ts
+var NOISE_PROTOCOL_NAME = "Noise_XX_25519_AESGCM_SHA256";
+var WA_NOISE_HEADER = new Uint8Array([87, 65, 6, 2]);
+var NoiseCipherState = class {
+  key = null;
+  nonce = 0;
+  constructor(key) {
+    if (key) {
+      this.key = key;
+    }
+  }
+  hasKey() {
+    return this.key !== null;
+  }
+  setKey(key) {
+    this.key = key;
+    this.nonce = 0;
+  }
+  encryptWithAd(ad, plaintext) {
+    if (!this.key) {
+      return plaintext;
+    }
+    const iv = this.generateNonceBuffer(this.nonce);
+    this.nonce += 1;
+    return CryptoEngine.aesGcmEncrypt(this.key, plaintext, iv, ad);
+  }
+  decryptWithAd(ad, ciphertext) {
+    if (!this.key) {
+      return ciphertext;
+    }
+    const iv = this.generateNonceBuffer(this.nonce);
+    this.nonce += 1;
+    return CryptoEngine.aesGcmDecrypt(this.key, ciphertext, iv, ad);
+  }
+  generateNonceBuffer(nonce) {
+    const buffer = new Uint8Array(12);
+    const view = new DataView(buffer.buffer);
+    view.setUint32(8, nonce, false);
+    return buffer;
+  }
+};
+var NoiseHandshake = class {
+  symmetricState;
+  localEphemeral;
+  localStatic;
+  remoteEphemeral = null;
+  remoteStatic = null;
+  constructor(localStaticKey) {
+    this.localStatic = localStaticKey;
+    this.localEphemeral = CryptoEngine.generateKeyPair();
+    const protocolHash = sha256(new TextEncoder().encode(NOISE_PROTOCOL_NAME));
+    this.symmetricState = {
+      h: new Uint8Array(protocolHash),
+      ck: new Uint8Array(protocolHash),
+      cipher: new NoiseCipherState()
+    };
+    this.mixHash(WA_NOISE_HEADER);
+  }
+  mixHash(data) {
+    const merged = new Uint8Array(this.symmetricState.h.length + data.length);
+    merged.set(this.symmetricState.h, 0);
+    merged.set(data, this.symmetricState.h.length);
+    this.symmetricState.h = sha256(merged);
+  }
+  mixKey(data) {
+    const derived = CryptoEngine.deriveKey(data, "", this.symmetricState.ck, 64);
+    this.symmetricState.ck = derived.slice(0, 32);
+    const tempK = derived.slice(32, 64);
+    this.symmetricState.cipher.setKey(tempK);
+  }
+  /**
+   * Passo 1: Início do Handshake -> Envia chave efêmera local (e)
+   */
+  startHandshake() {
+    this.mixHash(this.localEphemeral.public);
+    const message = new Uint8Array(WA_NOISE_HEADER.length + this.localEphemeral.public.length);
+    message.set(WA_NOISE_HEADER, 0);
+    message.set(this.localEphemeral.public, WA_NOISE_HEADER.length);
+    return message;
+  }
+  /**
+   * Passo 2: Recebe resposta do servidor WhatsApp <- (e, ee, s, es)
+   */
+  processServerHello(serverBuffer) {
+    this.remoteEphemeral = serverBuffer.slice(0, 32);
+    this.mixHash(this.remoteEphemeral);
+    const ee = CryptoEngine.sharedKey(this.localEphemeral.private, this.remoteEphemeral);
+    this.mixKey(ee);
+    const encryptedStatic = serverBuffer.slice(32, 80);
+    this.remoteStatic = this.symmetricState.cipher.decryptWithAd(this.symmetricState.h, encryptedStatic);
+    this.mixHash(encryptedStatic);
+    const es = CryptoEngine.sharedKey(this.localEphemeral.private, this.remoteStatic);
+    this.mixKey(es);
+    const encryptedPayload = serverBuffer.slice(80);
+    const decryptedPayload = this.symmetricState.cipher.decryptWithAd(this.symmetricState.h, encryptedPayload);
+    this.mixHash(encryptedPayload);
+    return decryptedPayload;
+  }
+  /**
+   * Passo 3: Envia resposta final de autenticação do cliente -> (s, se) + payload
+   * Retorna os CipherStates de leitura e escrita para uso no WebSocket
+   */
+  finishHandshake(payload) {
+    const encryptedStatic = this.symmetricState.cipher.encryptWithAd(this.symmetricState.h, this.localStatic.public);
+    this.mixHash(encryptedStatic);
+    if (!this.remoteEphemeral) {
+      throw new Error("Remote ephemeral key is missing in Noise Handshake");
+    }
+    const se = CryptoEngine.sharedKey(this.localStatic.private, this.remoteEphemeral);
+    this.mixKey(se);
+    const encryptedPayload = this.symmetricState.cipher.encryptWithAd(this.symmetricState.h, payload);
+    this.mixHash(encryptedPayload);
+    const handshakeMessage = new Uint8Array(encryptedStatic.length + encryptedPayload.length);
+    handshakeMessage.set(encryptedStatic, 0);
+    handshakeMessage.set(encryptedPayload, encryptedStatic.length);
+    const transportKeys = CryptoEngine.deriveKey(new Uint8Array(0), "", this.symmetricState.ck, 64);
+    const writeKey = transportKeys.slice(0, 32);
+    const readKey = transportKeys.slice(32, 64);
+    return {
+      handshakeMessage,
+      writeCipher: new NoiseCipherState(writeKey),
+      readCipher: new NoiseCipherState(readKey)
+    };
+  }
+};
+
+// src/crypto/index.ts
+var CryptoEngine = class {
+  /**
+   * Gera um novo par de chaves Curve25519 (Diffie-Hellman)
+   */
+  static generateKeyPair() {
+    const priv = randomBytes(32);
+    const pub = 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 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(sha256, secret, salt, infoBytes, length);
+  }
+  /**
+   * Encriptação autenticada com AES-256-GCM
+   */
+  static aesGcmEncrypt(key, plaintext, iv, additionalData) {
+    const cipher = gcm(key, iv, additionalData);
+    return cipher.encrypt(plaintext);
+  }
+  /**
+   * Decriptação autenticada com AES-256-GCM
+   */
+  static aesGcmDecrypt(key, ciphertext, iv, additionalData) {
+    const cipher = 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 = randomBytes(16);
+    const iv = randomBytes(12);
+    const key = hkdf(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(sha256, new TextEncoder().encode(masterPassphrase), salt, new TextEncoder().encode("cdwa-at-rest"), 32);
+    return this.aesGcmDecrypt(key, data, iv);
+  }
+};
+function initAuthCreds() {
+  const identityKeyPair = CryptoEngine.generateKeyPair();
+  const noiseKey = CryptoEngine.generateKeyPair();
+  const pairingEphemeral = CryptoEngine.generateKeyPair();
+  const signedPreKey = CryptoEngine.generateKeyPair();
+  const signedSignature = CryptoEngine.sharedKey(identityKeyPair.private, signedPreKey.public);
+  return {
+    noiseKey,
+    pairingEphemeralKeyPair: pairingEphemeral,
+    signedIdentityKey: identityKeyPair,
+    signedPreKey: {
+      ...signedPreKey,
+      keyId: 1,
+      signature: signedSignature
+    },
+    registrationId: Math.floor(Math.random() * 16384),
+    advSecretKey: Buffer.from(randomBytes(32)).toString("base64"),
+    firstUnuploadedPreKeyId: 1,
+    nextPreKeyId: 1
+  };
+}
+var EncryptedFileAuthState = class {
+  folderPath;
+  passphrase;
+  constructor(folderPath, passphrase) {
+    this.folderPath = folderPath;
+    this.passphrase = passphrase;
+  }
+  async ensureDir() {
+    await promises.mkdir(this.folderPath, { recursive: true });
+  }
+  getFilePath(filename) {
+    return path.join(this.folderPath, `${filename}.json`);
+  }
+  async save(key, data) {
+    await this.ensureDir();
+    const filePath = this.getFilePath(key);
+    const jsonString = JSON.stringify(data, (_, value) => {
+      if (value instanceof Uint8Array) {
+        return { __type: "Buffer", data: Buffer.from(value).toString("base64") };
+      }
+      return value;
+    });
+    if (this.passphrase) {
+      const encrypted = CryptoEngine.encryptAtRest(new TextEncoder().encode(jsonString), this.passphrase);
+      await promises.writeFile(filePath, JSON.stringify(encrypted), "utf-8");
+    } else {
+      await promises.writeFile(filePath, jsonString, "utf-8");
+    }
+  }
+  async load(key) {
+    const filePath = this.getFilePath(key);
+    try {
+      const content = await promises.readFile(filePath, "utf-8");
+      let jsonString = content;
+      if (this.passphrase) {
+        const bundle = JSON.parse(content);
+        const decryptedBytes = CryptoEngine.decryptAtRest(bundle, this.passphrase);
+        jsonString = new TextDecoder().decode(decryptedBytes);
+      }
+      return JSON.parse(jsonString, (_, value) => {
+        if (value && value.__type === "Buffer") {
+          return new Uint8Array(Buffer.from(value.data, "base64"));
+        }
+        return value;
+      });
+    } catch {
+      return null;
+    }
+  }
+  createKeyStore() {
+    return {
+      get: async (type, ids) => {
+        const result = {};
+        for (const id of ids) {
+          const item = await this.load(`${type}-${id}`);
+          if (item) {
+            result[id] = item;
+          }
+        }
+        return result;
+      },
+      set: async (data) => {
+        for (const [type, entries] of Object.entries(data)) {
+          for (const [id, value] of Object.entries(entries)) {
+            await this.save(`${type}-${id}`, value);
+          }
+        }
+      }
+    };
+  }
+};
+async function useSecureAuthState(folderPath, passphrase) {
+  const storage = new EncryptedFileAuthState(folderPath, passphrase);
+  let creds = await storage.load("creds");
+  if (!creds) {
+    creds = initAuthCreds();
+    await storage.save("creds", creds);
+  }
+  return {
+    creds,
+    keys: storage.createKeyStore()
+  };
+}
+
+// src/signal/index.ts
+var SignalEngine = class {
+  keyStore;
+  constructor(keyStore) {
+    this.keyStore = keyStore;
+  }
+  /**
+   * Inicializa ou recupera uma sessão de Double Ratchet com um contato/dispositivo
+   */
+  async getSession(address) {
+    const sessions = await this.keyStore.get("session", [address]);
+    return sessions[address] || null;
+  }
+  /**
+   * Salva uma sessão atualizada após troca de chaves
+   */
+  async saveSession(address, sessionData) {
+    await this.keyStore.set({
+      session: {
+        [address]: sessionData
+      }
+    });
+  }
+  /**
+   * Gerenciamento de chaves de remetente (Sender Keys) para envio otimizado em grupos
+   */
+  async getGroupSenderKey(groupId, senderId) {
+    const keyKey = `${groupId}::${senderId}`;
+    const keys = await this.keyStore.get("sender-key", [keyKey]);
+    return keys[keyKey] || null;
+  }
+};
+
+// src/binary/constants.ts
+var WABinaryConstants = {
+  LIST_EMPTY: 0,
+  STREAM_END: 2,
+  DICTIONARY_0: 236,
+  DICTIONARY_1: 237,
+  DICTIONARY_2: 238,
+  DICTIONARY_3: 239,
+  LIST_8: 248,
+  LIST_16: 249,
+  JID_PAIR: 250,
+  HEX_8: 251,
+  BINARY_8: 252,
+  BINARY_20: 253,
+  BINARY_32: 254,
+  NIBBLE_8: 255,
+  SINGLE_BYTE_MAX: 256
+};
+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}>`;
+  }
+};
+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 = 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(mediaBuffer);
+    const cipher = createCipheriv("aes-256-cbc", Buffer.from(cipherKey), Buffer.from(iv));
+    const encryptedBody = Buffer.concat([cipher.update(Buffer.from(mediaBuffer)), cipher.final()]);
+    const hmac = 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(finalCiphertext);
+    return {
+      mediaKey: new Uint8Array(mediaKey),
+      ciphertext: finalCiphertext,
+      fileSha256: new Uint8Array(fileSha256),
+      fileEncSha256: new Uint8Array(fileEncSha256),
+      mac: new Uint8Array(mac)
+    };
+  }
+};
+
+// 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");
+  }
+};
+var DEFAULT_WA_WS_URL = "wss://web.whatsapp.com/ws/chat";
+var WhatsAppSocket = class extends EventEmitter {
+  ws = null;
+  config;
+  pingInterval = null;
+  state = "close";
+  // Noise Handshake & Ciphers
+  noise = null;
+  writeCipher = null;
+  readCipher = null;
+  isHandshakeComplete = false;
+  constructor(config = {}) {
+    super();
+    this.config = {
+      waWebSocketUrl: DEFAULT_WA_WS_URL,
+      connectTimeoutMs: 2e4,
+      keepAliveIntervalMs: 3e4,
+      ...config
+    };
+  }
+  get connectionState() {
+    return this.state;
+  }
+  updateConnection(update) {
+    if (update.connection) {
+      this.state = update.connection;
+    }
+    this.emit("connection.update", update);
+  }
+  async connect(staticKey) {
+    if (this.ws && (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING)) {
+      return;
+    }
+    this.isHandshakeComplete = false;
+    this.writeCipher = null;
+    this.readCipher = null;
+    this.noise = new NoiseHandshake(staticKey);
+    this.updateConnection({ connection: "connecting" });
+    const wsUrl = this.config.waWebSocketUrl || DEFAULT_WA_WS_URL;
+    this.ws = new WebSocket(wsUrl, {
+      origin: "https://web.whatsapp.com",
+      headers: {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+      }
+    });
+    this.ws.on("open", () => {
+      this.startKeepAlive();
+      this.emit("open");
+      this.initiateNoiseHandshake();
+    });
+    this.ws.on("message", (data) => {
+      const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+      this.handleIncomingFrame(new Uint8Array(buffer));
+    });
+    this.ws.on("close", (code, reason) => {
+      this.cleanup();
+      this.updateConnection({
+        connection: "close",
+        lastDisconnect: {
+          error: new Error(`WebSocket closed with code ${code}: ${reason.toString()}`),
+          date: /* @__PURE__ */ new Date()
+        }
+      });
+    });
+    this.ws.on("error", (err) => {
+      this.emit("error", err);
+    });
+  }
+  /**
+   * Envia a mensagem inicial do Noise Handshake
+   */
+  initiateNoiseHandshake() {
+    if (!this.noise) return;
+    const initialPayload = this.noise.startHandshake();
+    this.sendRaw(initialPayload);
+  }
+  /**
+   * Trata frames recebidos pelo WebSocket
+   */
+  handleIncomingFrame(frame) {
+    if (!this.isHandshakeComplete) {
+      this.handleHandshakeFrame(frame);
+      return;
+    }
+    if (this.readCipher && frame.length > 3) {
+      const ciphertext = frame.slice(3);
+      const decrypted = this.readCipher.decryptWithAd(new Uint8Array(0), ciphertext);
+      try {
+        const node = BinaryProtocol.decode(decrypted);
+        this.emit("node", node);
+      } catch (err) {
+        this.emit("error", new Error(`Failed to decode WABinary stanza: ${err.message}`));
+      }
+    }
+  }
+  /**
+   * Conclui as etapas do Noise Handshake
+   */
+  handleHandshakeFrame(frame) {
+    if (!this.noise) return;
+    try {
+      this.noise.processServerHello(frame);
+      const clientPayload = new Uint8Array([0]);
+      const finish = this.noise.finishHandshake(clientPayload);
+      this.writeCipher = finish.writeCipher;
+      this.readCipher = finish.readCipher;
+      this.isHandshakeComplete = true;
+      this.sendRaw(finish.handshakeMessage);
+      this.updateConnection({ connection: "open" });
+      this.emit("handshake.complete");
+    } catch (err) {
+      this.emit("error", new Error(`Noise Handshake failed: ${err.message}`));
+      this.disconnect();
+    }
+  }
+  /**
+   * Envia uma stanza estruturada, codificando em WABinary e criptografando com o Noise Write Cipher
+   */
+  sendNode(node) {
+    if (!this.isHandshakeComplete || !this.writeCipher) {
+      throw new Error("Cannot send stanza: Noise Handshake is not complete");
+    }
+    const encodedNode = BinaryProtocol.encode(node);
+    const encrypted = this.writeCipher.encryptWithAd(new Uint8Array(0), encodedNode);
+    const length = encrypted.length;
+    const frame = new Uint8Array(3 + length);
+    frame[0] = length >> 16 & 255;
+    frame[1] = length >> 8 & 255;
+    frame[2] = length & 255;
+    frame.set(encrypted, 3);
+    this.sendRaw(frame);
+  }
+  sendRaw(data) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("Cannot send raw data: WebSocket is not open");
+    }
+    this.ws.send(data);
+  }
+  startKeepAlive() {
+    this.stopKeepAlive();
+    this.pingInterval = setInterval(() => {
+      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+        this.ws.ping();
+      }
+    }, this.config.keepAliveIntervalMs);
+  }
+  stopKeepAlive() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+  }
+  cleanup() {
+    this.stopKeepAlive();
+    this.isHandshakeComplete = false;
+    this.writeCipher = null;
+    this.readCipher = null;
+    this.noise = null;
+    if (this.ws) {
+      this.ws.removeAllListeners();
+      this.ws = null;
+    }
+  }
+  disconnect() {
+    this.cleanup();
+    this.updateConnection({ connection: "close" });
+  }
+};
+var WhatsAppClient = class extends EventEmitter {
+  socket;
+  auth = null;
+  signal = null;
+  config;
+  constructor(config = {}) {
+    super();
+    this.config = config;
+    this.socket = new WhatsAppSocket(config);
+    if (config.auth) {
+      this.setAuthState(config.auth);
+    }
+    this.setupListeners();
+  }
+  setAuthState(auth) {
+    this.auth = auth;
+    this.signal = new SignalEngine(auth.keys);
+  }
+  setupListeners() {
+    this.socket.on("connection.update", (update) => {
+      this.emit("connection.update", update);
+    });
+    this.socket.on("handshake.complete", () => {
+      this.onHandshakeComplete();
+    });
+    this.socket.on("node", (node) => {
+      this.handleIncomingNode(node);
+    });
+    this.socket.on("error", (err) => {
+      this.emit("error", err);
+    });
+  }
+  /**
+   * Disparado após a conexão criptografada (Noise) estar pronta
+   */
+  async onHandshakeComplete() {
+    if (!this.auth) {
+      return;
+    }
+    if (!this.auth.creds.me) {
+      await this.requestPairingCode();
+    } else {
+      this.emit("connection.update", { connection: "open", isNewLogin: false });
+    }
+  }
+  /**
+   * Envia stanza solicitando o QR Code de pareamento
+   */
+  async requestPairingCode() {
+    if (!this.auth) return;
+    const pairNode = BinaryProtocol.createNode(
+      "iq",
+      {
+        to: "s.whatsapp.net",
+        type: "set",
+        xmlns: "pair-device",
+        id: `pair-${Date.now()}`
+      },
+      [
+        BinaryProtocol.createNode("pair-device", {}, [
+          BinaryProtocol.createNode("ref", {}, void 0)
+        ])
+      ]
+    );
+    this.socket.sendNode(pairNode);
+  }
+  /**
+   * Processa stanzas recebidas do WhatsApp
+   */
+  handleIncomingNode(node) {
+    this.emit("raw.node", node);
+    if (node.tag === "iq" && node.attrs.type === "result") {
+      const pairDevice = BinaryProtocol.getChildNode(node, "pair-device");
+      if (pairDevice) {
+        const refNode = BinaryProtocol.getChildNode(pairDevice, "ref");
+        if (refNode && typeof refNode.content === "string" && this.auth) {
+          const ref = refNode.content;
+          const pubKey = Buffer.from(this.auth.creds.signedIdentityKey.public).toString("base64");
+          const noisePub = Buffer.from(this.auth.creds.noiseKey.public).toString("base64");
+          const qrString = `${ref},${noisePub},${pubKey},${this.auth.creds.advSecretKey}`;
+          this.emit("connection.update", { qr: qrString });
+        }
+      }
+    }
+    if (node.tag === "iq" && node.attrs.xmlns === "pair-success") {
+      this.emit("connection.update", { connection: "open", isNewLogin: true });
+    }
+    if (node.tag === "message") {
+      this.emit("messages.upsert", { node });
+    }
+  }
+  /**
+   * Inicia o fluxo de conexão com o WhatsApp Web
+   */
+  async connect() {
+    if (!this.auth) {
+      throw new Error("AuthenticationState must be provided before calling connect()");
+    }
+    await this.socket.connect(this.auth.creds.noiseKey);
+  }
+  /**
+   * Envia qualquer tipo de mensagem (Texto, Imagem, Vídeo, Áudio, Localização, Contato, Reação)
+   */
+  async sendMessage(jid, content, options = {}) {
+    const normalizedContent = typeof content === "string" ? { text: content } : content;
+    const { node, messageId } = await MessageBuilder.buildMessageNode(
+      jid,
+      normalizedContent,
+      options
+    );
+    this.socket.sendNode(node);
+    return { messageId };
+  }
+  /**
+   * Encerra a conexão
+   */
+  disconnect() {
+    this.socket.disconnect();
+  }
+};
+function makeWASocket(config = {}) {
+  return new WhatsAppClient(config);
+}
+
+export { BinaryDecoder, BinaryEncoder, BinaryProtocol, CryptoEngine, DEFAULT_WA_WS_URL, EncryptedFileAuthState, MediaCrypto, MessageBuilder, NOISE_PROTOCOL_NAME, NoiseCipherState, NoiseHandshake, SINGLE_BYTE_TOKENS, SignalEngine, TOKEN_MAP, WABinaryConstants, WA_NOISE_HEADER, WhatsAppClient, WhatsAppSocket, makeWASocket as default, initAuthCreds, makeWASocket, useSecureAuthState };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map