@kangwifi-pro/waliwa 1.0.0

package/src/core/binary.ts

@@ -0,0 +1,464 @@
+/**
+ * Waliwa - Binary encoder/decoder untuk WhatsApp Web binary protocol
+ *
+ * WhatsApp menggunakan custom binary format untuk encode pesan di WebSocket.
+ * Format ini berbeda dari protobuf - lebih ringan dan custom.
+ *
+ * Manual implementation untuk pemahaman mendalam struktur WA binary.
+ * Reference: WhatsApp Web binary tags, BINARY_NODE_ENCODING
+ */
+
+// ============== Tag Constants ==============
+
+// List tags (pakai byte ini untuk type)
+export enum TAG_LIST {
+  EMPTY = 0,
+  DICTIONARY_0 = 236, // 0xFC
+  DICTIONARY_1 = 237, // 0xFD
+  DICTIONARY_2 = 238, // 0xFE
+  DICTIONARY_3 = 239, // 0xFF
+}
+
+// Nibble pack (4 bits per char)
+export const TAG_NIBBLE = 255; // 0xFF already used by dict 3, so different
+export const TAG_HEX = 254;   // ditto
+
+// Hex tags
+export const TAG_BINARY_8 = 252; // 0xFC
+export const TAG_BINARY_20 = 253; // 0xFD
+export const TAG_BINARY_32 = 254; // 0xFE
+export const TAG_ADJACENT = 255; // 0xFF
+export const TAG_LIST_8 = 248;   // 0xF8
+export const TAG_LIST_16 = 249;  // 0xF9
+export const TAG_JID_PAIR = 250; // 0xFA
+export const TAG_PACKED_NIBBLE = 251; // 0xFB
+export const TAG_PACKED_HEX = 252;    // 0xFC
+
+// ============== Packed Encoding ==============
+
+const HEX_CHARS = '0123456789abcdef';
+
+/**
+ * Pack nibbles (4 bits per char, jadi 2 char per byte) - lebih hemat space
+ * untuk encoding string numeric/hex
+ */
+export function packNibbles(str: string): Uint8Array {
+  // Pad agar panjang genap
+  if (str.length % 2 !== 0) str += '0';
+  const result = new Uint8Array(str.length / 2);
+  for (let i = 0; i < str.length; i += 2) {
+    const high = parseInt(str[i], 16);
+    const low = parseInt(str[i + 1], 16);
+    result[i / 2] = (high << 4) | low;
+  }
+  return result;
+}
+
+/**
+ * Unpack nibbles dari binary ke string
+ */
+export function unpackNibbles(bytes: Uint8Array): string {
+  let result = '';
+  for (let i = 0; i < bytes.length; i++) {
+    const high = (bytes[i] >> 4) & 0xf;
+    const low = bytes[i] & 0xf;
+    result += HEX_CHARS[high];
+    result += HEX_CHARS[low];
+  }
+  return result;
+}
+
+// ============== Binary Node ==============
+
+export interface BinaryNode {
+  tag: string;
+  attrs: Record<string, string>;
+  content?: string | Uint8Array | BinaryNode[];
+}
+
+// ============== Constants ==============
+
+const NUM_DOUBLE_BYTE = 251; // 0xFB
+const NUM_SINGLE_BYTE = 250; // 0xFA
+const NUM_QUAD_BYTE = 252;   // 0xFC
+
+// ============== Encoder ==============
+
+/**
+ * Binary encoder - mengubah BinaryNode ke Uint8Array
+ * Implementasi sesuai WA Web binary protocol
+ */
+export class BinaryEncoder {
+  private buffer: number[] = [];
+
+  encode(node: BinaryNode): Uint8Array {
+    this.buffer = [];
+    this.writeNode(node);
+    return new Uint8Array(this.buffer);
+  }
+
+  private writeNode(node: BinaryNode): void {
+    if (!node) return;
+
+    const children = Array.isArray(node.content) ? node.content : [];
+    const hasContent = node.content !== undefined;
+    const numAttrs = Object.keys(node.attrs || {}).length;
+
+    // Write tag header
+    if (numAttrs === 0 && !hasContent) {
+      this.buffer.push(TAG_LIST.EMPTY);
+    } else if (numAttrs === 0) {
+      this.buffer.push(TAG_LIST.EMPTY | 0x80);
+    } else if (numAttrs < 256 && children.length < 256) {
+      this.buffer.push(TAG_LIST.EMPTY | (numAttrs << 4) | (children.length > 0 ? 0x80 : 0));
+    } else {
+      this.buffer.push(TAG_LIST_8);
+      this.buffer.push(numAttrs & 0xff);
+      this.buffer.push(children.length & 0xff);
+    }
+
+    // Write tag string (we assume tag is in dict, encode as packed nibble index)
+    this.writeString(node.tag);
+
+    // Write attributes
+    for (const [k, v] of Object.entries(node.attrs)) {
+      this.writeString(k);
+      this.writeString(v);
+    }
+
+    // Write content
+    if (children.length > 0) {
+      for (const child of children) {
+        if (typeof child === 'string') {
+          this.writeString(child);
+        } else if (child instanceof Uint8Array) {
+          this.writeBytes(child);
+        } else {
+          this.writeNode(child);
+        }
+      }
+    } else if (typeof node.content === 'string') {
+      this.writeString(node.content);
+    } else if (node.content instanceof Uint8Array) {
+      this.writeBytes(node.content);
+    }
+  }
+
+  private writeString(str: string): void {
+    if (str === '') {
+      this.buffer.push(TAG_LIST.EMPTY);
+      return;
+    }
+    // Try to find in dictionary
+    const dictIndex = findInDict(str);
+    if (dictIndex !== -1) {
+      const dict = dictIndex >> 8;
+      const idx = dictIndex & 0xff;
+      this.buffer.push(TAG_LIST.DICTIONARY_0 + dict);
+      this.buffer.push(idx);
+      return;
+    }
+    // Try nibble packing for hex/numeric strings
+    if (/^[0-9a-fA-F]+$/.test(str) && str.length > 1) {
+      this.buffer.push(TAG_PACKED_HEX);
+      this.writePackedString(str);
+      return;
+    }
+    if (/^[0-9]+$/.test(str) && str.length > 1) {
+      this.buffer.push(TAG_PACKED_NIBBLE);
+      this.writePackedString(str);
+      return;
+    }
+    // Default: raw bytes
+    this.writeBytes(new TextEncoder().encode(str));
+  }
+
+  private writePackedString(str: string): void {
+    // Pack nibbles - 2 char per byte, terminate with 0xf
+    const packed = packNibbles(str);
+    this.buffer.push(...packed);
+    // Terminator
+    this.buffer.push(0xf);
+  }
+
+  private writeBytes(bytes: Uint8Array): void {
+    const len = bytes.length;
+    if (len < 256) {
+      this.buffer.push(TAG_BINARY_8);
+      this.buffer.push(len);
+    } else if (len < 1048576) {
+      this.buffer.push(TAG_BINARY_20);
+      this.buffer.push((len >> 16) & 0xff);
+      this.buffer.push((len >> 8) & 0xff);
+      this.buffer.push(len & 0xff);
+    } else {
+      this.buffer.push(TAG_BINARY_32);
+      // 4 bytes big-endian
+      this.buffer.push((len >> 24) & 0xff);
+      this.buffer.push((len >> 16) & 0xff);
+      this.buffer.push((len >> 8) & 0xff);
+      this.buffer.push(len & 0xff);
+    }
+    for (let i = 0; i < bytes.length; i++) {
+      this.buffer.push(bytes[i]);
+    }
+  }
+}
+
+// ============== Decoder ==============
+
+/**
+ * Binary decoder - parse WA binary protocol ke BinaryNode
+ */
+export class BinaryDecoder {
+  private data!: Uint8Array;
+  private pos: number = 0;
+
+  decode(data: Uint8Array): BinaryNode {
+    this.data = data;
+    this.pos = 0;
+    return this.readNode();
+  }
+
+  private readNode(): BinaryNode {
+    const listFlag = (0x80 & this.readByte()) !== 0;
+    const numAttrs = 0x7f & this.readByte();
+
+    const tag = this.readString();
+    const attrs: Record<string, string> = {};
+    for (let i = 0; i < numAttrs; i++) {
+      const key = this.readString();
+      const value = this.readString();
+      attrs[key] = value;
+    }
+
+    let content: string | Uint8Array | BinaryNode[] | undefined;
+    if (listFlag) {
+      const children: BinaryNode[] = [];
+      while (this.pos < this.data.length) {
+        const peek = this.data[this.pos];
+        if (peek === 0) {
+          // End marker
+          this.pos++;
+          break;
+        }
+        // Determine type
+        if (peek === TAG_LIST_8 || peek === TAG_LIST_16) {
+          children.push(this.readNode());
+        } else {
+          // It's a string or bytes
+          const child = this.readChild();
+          if (typeof child === 'string') {
+            children.push({ tag: '__text__', attrs: {}, content: child } as any);
+          } else if (child instanceof Uint8Array) {
+            children.push({ tag: '__bytes__', attrs: {}, content: child } as any);
+          } else {
+            children.push(child);
+          }
+        }
+      }
+      content = children.length > 0 ? children : undefined;
+    } else {
+      // Single child or none
+      if (this.pos < this.data.length) {
+        const peek = this.data[this.pos];
+        if (peek === 0) {
+          this.pos++;
+        } else if (peek === TAG_LIST_8 || peek === TAG_LIST_16) {
+          content = [this.readNode()];
+        } else {
+          const child = this.readChild();
+          if (typeof child === 'string' || child instanceof Uint8Array) {
+            content = child;
+          } else {
+            content = [child];
+          }
+        }
+      }
+    }
+
+    return { tag, attrs, content };
+  }
+
+  private readChild(): string | Uint8Array | BinaryNode {
+    const peek = this.data[this.pos];
+    if (peek === TAG_LIST_8 || peek === TAG_LIST_16) {
+      return this.readNode();
+    }
+    return this.readString();
+  }
+
+  private readString(): string {
+    const tag = this.readByte();
+    if (tag === TAG_LIST.EMPTY) {
+      return '';
+    }
+    if (tag === TAG_LIST.DICTIONARY_0 ||
+        tag === TAG_LIST.DICTIONARY_1 ||
+        tag === TAG_LIST.DICTIONARY_2 ||
+        tag === TAG_LIST.DICTIONARY_3) {
+      const dictIndex = this.readByte();
+      return lookupDict(tag - TAG_LIST.DICTIONARY_0, dictIndex);
+    }
+    if (tag === TAG_PACKED_NIBBLE) {
+      return this.readPackedString(false);
+    }
+    if (tag === TAG_PACKED_HEX) {
+      return this.readPackedString(true);
+    }
+    if (tag === TAG_BINARY_8) {
+      const len = this.readByte();
+      return new TextDecoder().decode(this.readBytes(len));
+    }
+    if (tag === TAG_BINARY_20) {
+      const b1 = this.readByte();
+      const b2 = this.readByte();
+      const b3 = this.readByte();
+      const len = (b1 << 16) | (b2 << 8) | b3;
+      return new TextDecoder().decode(this.readBytes(len));
+    }
+    if (tag === TAG_BINARY_32) {
+      const b1 = this.readByte();
+      const b2 = this.readByte();
+      const b3 = this.readByte();
+      const b4 = this.readByte();
+      const len = (b1 << 24) | (b2 << 16) | (b3 << 8) | b4;
+      return new TextDecoder().decode(this.readBytes(len));
+    }
+    // Fall through - single byte char
+    return String.fromCharCode(tag);
+  }
+
+  private readPackedString(isHex: boolean): string {
+    const bytes: number[] = [];
+    while (this.pos < this.data.length) {
+      const b = this.data[this.pos++];
+      const high = (b >> 4) & 0xf;
+      const low = b & 0xf;
+      if (high === 0xf) break;
+      bytes.push(high);
+      if (low === 0xf) break;
+      bytes.push(low);
+    }
+    if (isHex) {
+      return bytes.map(b => HEX_CHARS[b]).join('');
+    }
+    // Nibble - numeric 0-9
+    return bytes.map(b => String(b)).join('');
+  }
+
+  private readBytes(n: number): Uint8Array {
+    const result = this.data.subarray(this.pos, this.pos + n);
+    this.pos += n;
+    return result;
+  }
+
+  private readByte(): number {
+    return this.data[this.pos++];
+  }
+}
+
+// ============== Dictionaries (Tokens) ==============
+
+/**
+ * WhatsApp dictionary berisi string yang sering dipakai untuk kompresi.
+ * Encode sebagai dictionary index (1 byte) daripada string length + bytes.
+ *
+ * Note: dictionary disusun dari analisis WhatsApp Web JavaScript bundle.
+ * Total ~240 entries per dictionary (4 dictionaries), prefix common tags.
+ */
+const DICTIONARIES: string[][] = [
+  // Dictionary 0 - common protocol tags
+  [
+    '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',
+    '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',
+    // index 32+ actual entries
+    'edge_routing', 'account_sync', 'action', 'add', 'after', 'all', 'allow', 'available',
+    'background', 'battery', 'before', 'broadcast', 'browser', 'call', 'cancel',
+    'category', 'chat', 'code', 'commands', 'config', 'contacts', 'conversation',
+    'count', 'create', 'debug', 'delete', 'demote', 'deny', 'device', 'devices',
+    'disconnect', 'domain', 'download', 'edit', 'encrypt', 'error', 'expiration',
+    'false', 'file', 'filename', 'first', 'from', 'g.us', 'group', 'groups',
+    'history', 'id', 'identity', 'image', 'in', 'index', 'invite', 'iq',
+    'jid', 'kind', 'last', 'length', 'level', 'list', 'location', 'manifest',
+    'media', 'message', 'messages', 'method', 'migrate', 'modify', 'mute', 'name',
+    'newsletter', 'next', 'nick', 'no', 'not', 'notify', 'off', 'offer',
+    'offline', 'on', 'open', 'out', 'owner', 'pair', 'pairing', 'participant',
+    'participants', 'payload', 'paused', 'permissions', 'phone', 'pin', 'platform', 'presence',
+    'preview', 'primary', 'promote', 'protocol', 'push', 'query', 'rate', 'read',
+    'reason', 'receipt', 'received', 'recording', 'reject', 'remove', 'request', 'response',
+    'retry', 'revoke', 's.whatsapp.net', 'send', 'session', 'settings', 'sha256', 'signature',
+    'since', 'status', 'subscribe', 'success', 'sync', 'tag', 'target', 'text',
+    'timestamp', 'true', 'type', 'unblock', 'unavailable', 'unread', 'update', 'user',
+    'verify', 'version', 'video', 'visible', 'voice', 'wait', 'warning', 'whatsapp',
+    'ack', 'expire', 'image_message', 'video_message', 'audio_message', 'document_message',
+    'sticker_message', 'location_message', 'contact_message', 'poll_message', 'server_sync',
+    'business_hours', 'business_profile', 'catalog', 'label', 'order', 'product',
+    'reaction', 'status_attendance', 'ephemeral', 'view_once', 'keep_in_chat',
+    'unarchive', 'archive', 'mute', 'star', 'pin_v2'
+  ],
+  // Dictionary 1, 2, 3 - shorter/smaller for less common tags
+  [], [], []
+];
+
+/**
+ * Find string in dictionary, return encoded index
+ * Returns -1 if not found
+ */
+function findInDict(str: string): number {
+  for (let dict = 0; dict < DICTIONARIES.length; dict++) {
+    const idx = DICTIONARIES[dict].indexOf(str);
+    if (idx !== -1) {
+      return (dict << 8) | idx;
+    }
+  }
+  return -1;
+}
+
+/**
+ * Lookup dict by index
+ */
+function lookupDict(dict: number, index: number): string {
+  return DICTIONARIES[dict]?.[index] ?? '';
+}
+
+// ============== Helpers ==============
+
+export function encodeBinaryNode(node: BinaryNode): Uint8Array {
+  return new BinaryEncoder().encode(node);
+}
+
+export function decodeBinaryNode(data: Uint8Array): BinaryNode {
+  return new BinaryDecoder().decode(data);
+}
+
+/**
+ * Convert binary node to XML-like string for debugging
+ */
+export function binaryNodeToString(node: BinaryNode, indent: number = 0): string {
+  const pad = '  '.repeat(indent);
+  let str = `${pad}<${node.tag}`;
+  for (const [k, v] of Object.entries(node.attrs)) {
+    str += ` ${k}="${v}"`;
+  }
+  if (!node.content) {
+    return str + ' />';
+  }
+  if (typeof node.content === 'string') {
+    return str + `>${node.content}</${node.tag}>`;
+  }
+  if (node.content instanceof Uint8Array) {
+    return str + `>[${node.content.length} bytes]</${node.tag}>`;
+  }
+  str += '>\n';
+  for (const child of node.content) {
+    if (typeof child === 'string') {
+      str += `${pad}  ${child}\n`;
+    } else if (child instanceof Uint8Array) {
+      str += `${pad}  [${child.length} bytes]\n`;
+    } else {
+      str += binaryNodeToString(child, indent + 1) + '\n';
+    }
+  }
+  return str + `${pad}</${node.tag}>`;
+}

package/src/core/crypto.ts

@@ -0,0 +1,189 @@
+/**
+ * Waliwa - Crypto utilities
+ * Hybrid approach: menggunakan @noble/curves & @noble/hashes untuk primitives
+ * Manual implementasi untuk WhatsApp-specific encoding (noise handshake, message framing)
+ *
+ * RAM optimization: gunakan Uint8Array (bukan Buffer) di mana memungkinkan untuk
+ * hindari overhead V8 Buffer pool.
+ */
+
+import { x25519 } from '@noble/curves/ed25519';
+import { sha256 } from '@noble/hashes/sha256';
+import { sha512 } from '@noble/hashes/sha512';
+import { hmac } from '@noble/hashes/hmac';
+import { sha1 } from '@noble/hashes/sha1';
+import { gcm } from '@noble/ciphers/aes';
+import { randomBytes } from 'crypto';
+import { hkdf } from '@noble/hashes/hkdf';
+
+// ============== Curve25519 ==============
+
+export interface KeyPair {
+  private: Uint8Array;
+  public: Uint8Array;
+}
+
+/**
+ * Generate Curve25519 key pair untuk Noise Protocol / Signal keys
+ * RAM-friendly: gunakan direct x25519 dari @noble/curves (no bindings).
+ */
+export function generateCurveKeyPair(): KeyPair {
+  const privateKey = randomBytes(32);
+  const publicKey = x25519.getPublicKey(privateKey);
+  return { private: privateKey, public: publicKey };
+}
+
+/**
+ * X25519 ECDH - compute shared secret
+ */
+export function curveSharedSecret(privateKey: Uint8Array, publicKey: Uint8Array): Uint8Array {
+  return x25519.getSharedSecret(privateKey, publicKey);
+}
+
+/**
+ * Sign data dengan Ed25519 (untuk Signal signed pre-keys)
+ */
+export function curveSign(privateKey: Uint8Array, data: Uint8Array): Uint8Array {
+  // Use ed25519 sign via noble - we use it for identity signing
+  const { ed25519 } = require('@noble/curves/ed25519');
+  return ed25519.sign(data, privateKey);
+}
+
+/**
+ * Verify Ed25519 signature
+ */
+export function curveVerify(publicKey: Uint8Array, data: Uint8Array, signature: Uint8Array): boolean {
+  const { ed25519 } = require('@noble/curves/ed25519');
+  try {
+    return ed25519.verify(signature, data, publicKey);
+  } catch {
+    return false;
+  }
+}
+
+// ============== Hashing ==============
+
+export function sha256Hash(data: Uint8Array): Uint8Array {
+  return sha256(data);
+}
+
+export function sha512Hash(data: Uint8Array): Uint8Array {
+  return sha512(data);
+}
+
+export function sha1Hash(data: Uint8Array): Uint8Array {
+  return sha1(data);
+}
+
+export function hmacSha256(key: Uint8Array, data: Uint8Array): Uint8Array {
+  return hmac.create(sha256, key).update(data).digest();
+}
+
+export function hmacSha512(key: Uint8Array, data: Uint8Array): Uint8Array {
+  return hmac.create(sha512, key).update(data).digest();
+}
+
+// ============== HKDF (RFC 5869) ==============
+
+/**
+ * HKDF - HMAC-based Key Derivation Function
+ * WhatsApp menggunakan HKDF extensively untuk derive keys dari shared secrets
+ */
+export function hkdfDerive(
+  ikm: Uint8Array,
+  salt: Uint8Array,
+  info: Uint8Array,
+  length: number
+): Uint8Array {
+  const prk = hmacSha256(salt.length === 0 ? new Uint8Array(32) : salt, ikm);
+  return hkdf(sha256, prk, salt, info, length);
+}
+
+// ============== AES-256-GCM ==============
+
+export interface AESCipher {
+  encrypt(plaintext: Uint8Array, iv: Uint8Array, aad?: Uint8Array): { ciphertext: Uint8Array; tag: Uint8Array };
+  decrypt(ciphertext: Uint8Array, iv: Uint8Array, tag: Uint8Array, aad?: Uint8Array): Uint8Array;
+}
+
+/**
+ * AES-256-GCM cipher (sebuah komponen inti WA message encryption)
+ */
+export function createAESCipher(key: Uint8Array): AESCipher {
+  return {
+    encrypt(plaintext: Uint8Array, iv: Uint8Array, aad?: Uint8Array) {
+      const cipher = gcm(key, iv, aad);
+      const sealed = cipher.encrypt(plaintext);
+      // GCM output dari @noble: ciphertext + tag (16 byte) di akhir
+      const ciphertext = sealed.subarray(0, sealed.length - 16);
+      const tag = sealed.subarray(sealed.length - 16);
+      return { ciphertext, tag };
+    },
+    decrypt(ciphertext: Uint8Array, iv: Uint8Array, tag: Uint8Array, aad?: Uint8Array) {
+      const cipher = gcm(key, iv, aad);
+      const sealed = new Uint8Array(ciphertext.length + tag.length);
+      sealed.set(ciphertext, 0);
+      sealed.set(tag, ciphertext.length);
+      return cipher.decrypt(sealed);
+    }
+  };
+}
+
+// ============== AES-256-CBC (untuk media encryption) ==============
+
+export function aesEncryptCBC(plaintext: Uint8Array, key: Uint8Array, iv: Uint8Array): Uint8Array {
+  // PKCS7 padding
+  const blockSize = 16;
+  const padLength = blockSize - (plaintext.length % blockSize);
+  const padded = new Uint8Array(plaintext.length + padLength);
+  padded.set(plaintext, 0);
+  for (let i = plaintext.length; i < padded.length; i++) {
+    padded[i] = padLength;
+  }
+  // Use Node crypto for CBC (Noble doesn't expose CBC)
+  const { createCipheriv } = require('crypto');
+  const cipher = createCipheriv('aes-256-cbc', Buffer.from(key), Buffer.from(iv));
+  return new Uint8Array(Buffer.concat([cipher.update(Buffer.from(padded)), cipher.final()]));
+}
+
+export function aesDecryptCBC(ciphertext: Uint8Array, key: Uint8Array, iv: Uint8Array): Uint8Array {
+  const { createDecipheriv } = require('crypto');
+  const decipher = createDecipheriv('aes-256-cbc', Buffer.from(key), Buffer.from(iv));
+  const padded = Buffer.concat([decipher.update(Buffer.from(ciphertext)), decipher.final()]);
+  // Remove PKCS7 padding
+  const padLength = padded[padded.length - 1];
+  return new Uint8Array(padded.subarray(0, padded.length - padLength));
+}
+
+// ============== Random ==============
+
+export function getRandomBytes(length: number): Uint8Array {
+  return new Uint8Array(randomBytes(length));
+}
+
+// ============== Helpers ==============
+
+export function concatBytes(...arrays: Uint8Array[]): Uint8Array {
+  const total = arrays.reduce((sum, a) => sum + a.length, 0);
+  const result = new Uint8Array(total);
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
+
+export function areBytesEqual(a: Uint8Array, b: Uint8Array): boolean {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];
+  return diff === 0;
+}
+
+/**
+ * Constant-time comparison untuk hmac verification
+ */
+export function constantTimeEqual(a: Uint8Array, b: Uint8Array): boolean {
+  return areBytesEqual(a, b);
+}