@kangwifi-pro/waliwa 1.0.0

package/src/core/noise.ts

@@ -0,0 +1,406 @@
+/**
+ * Waliwa - Noise Protocol XX handshake implementation
+ *
+ * WhatsApp Web Multi-Device menggunakan Noise Protocol Framework (XX pattern)
+ * untuk establish secure channel antara client dan WhatsApp server.
+ *
+ * Pattern XX (lihat noiseprotocol.com):
+ *   <- e
+ *   -> e, ee, s, es
+ *   <- s, se
+ *
+ * Handshake ini menghasilkan encryption key untuk semua komunikasi WebSocket selanjutnya.
+ *
+ * Original implementation - tidak copy dari Baileys/ZapoJS.
+ */
+
+import {
+  generateCurveKeyPair,
+  curveSharedSecret,
+  hkdfDerive,
+  hmacSha256,
+  sha256Hash,
+  createAESCipher,
+  getRandomBytes,
+  concatBytes,
+  areBytesEqual,
+  KeyPair,
+  AESCipher
+} from './crypto.js';
+
+// ============== Noise Constants ==============
+
+/** Noise protocol name - WhatsApp menggunakan "Noise_XX_25519_AESGCM_SHA256" */
+const NOISE_PROTOCOL_NAME = 'Noise_XX_25519_AESGCM_SHA256';
+const NOISE_HANDSHAKE_DONE = 'Noise_XX_25519_AESGCM_SHA256_handshake_done';
+const HKDF_INFO = new TextEncoder().encode(NOISE_PROTOCOL_NAME);
+
+// WhatsApp specific constants
+const WA_NOISE_HEADER = new Uint8Array([0x57, 0x41]); // "WA" - 2 bytes prefix
+const WA_VERSION = new Uint8Array([0x05, 0x2d]); // Version 2.45 encoded
+
+// Max ciphertext size untuk WA frames
+const MAX_FRAME_SIZE = 1024 * 1024; // 1 MB
+
+// ============== Cipher State ==============
+
+interface CipherState {
+  key: Uint8Array | null;
+  nonce: number; // Counter-based nonce, increments per message
+}
+
+interface SymmetricState {
+  ck: Uint8Array; // Chaining key
+  h: Uint8Array;  // Handshake hash
+  cipher: CipherState;
+}
+
+interface HandshakeState {
+  ss: SymmetricState;
+  s: KeyPair;  // Static key pair
+  e: KeyPair;  // Ephemeral key pair
+  rs: Uint8Array | null; // Remote static public key
+  re: Uint8Array | null; // Remote ephemeral public key
+  initiator: boolean;
+  messagePattern: ('e' | 's' | 'ee' | 'es' | 'se' | 'ss')[];
+}
+
+// ============== Noise Handshake ==============
+
+export class NoiseHandshake {
+  private state: HandshakeState;
+  private cipher: AESCipher;
+  private readonly cipherKeyLen = 32;
+  private readonly nonceLen = 12;
+
+  constructor(staticKey?: KeyPair, initiator: boolean = true) {
+    this.state = {
+      ss: this.initializeSymmetric(),
+      s: staticKey ?? generateCurveKeyPair(),
+      e: generateCurveKeyPair(),
+      rs: null,
+      re: null,
+      initiator,
+      messagePattern: ['e', 'e', 'ee', 's', 'es', 's', 'se']
+    };
+    this.cipher = createAESCipher(new Uint8Array(32));
+    // Mix protocol name into hash
+    this.state.ss.h = sha256Hash(new TextEncoder().encode(NOISE_PROTOCOL_NAME));
+  }
+
+  private initializeSymmetric(): SymmetricState {
+    const protocolHash = sha256Hash(new TextEncoder().encode(NOISE_PROTOCOL_NAME));
+    return {
+      ck: protocolHash,
+      h: protocolHash,
+      cipher: { key: null, nonce: 0 }
+    };
+  }
+
+  /**
+   * Mix key into chaining key + derive new cipher key
+   */
+  private mixKey(inputKey: Uint8Array): void {
+    const derived = hkdfDerive(
+      inputKey,
+      this.state.ss.ck,
+      new Uint8Array(0),
+      64
+    );
+    // Split into 32-byte ck and 32-byte key
+    this.state.ss.ck = derived.subarray(0, 32);
+    this.state.ss.cipher.key = derived.subarray(32, 64);
+    this.state.ss.cipher.nonce = 0;
+  }
+
+  /**
+   * Mix hash data into handshake hash
+   */
+  private mixHash(data: Uint8Array): void {
+    this.state.ss.h = sha256Hash(concatBytes(this.state.ss.h, data));
+  }
+
+  /**
+   * Encrypt dengan handshake key
+   */
+  private encryptWithHash(plaintext: Uint8Array): Uint8Array {
+    if (!this.state.ss.cipher.key) {
+      return plaintext;
+    }
+    const iv = this.generateNonce(this.state.ss.cipher.nonce);
+    const { ciphertext, tag } = this.cipher.encrypt(
+      plaintext,
+      iv,
+      this.state.ss.h
+    );
+    this.state.ss.cipher.nonce++;
+    return concatBytes(ciphertext, tag);
+  }
+
+  /**
+   * Decrypt dengan handshake key
+   */
+  private decryptWithHash(ciphertext: Uint8Array): Uint8Array {
+    if (!this.state.ss.cipher.key) {
+      return ciphertext;
+    }
+    if (ciphertext.length < 16) {
+      throw new Error('Ciphertext too short');
+    }
+    const iv = this.generateNonce(this.state.ss.cipher.nonce);
+    const ct = ciphertext.subarray(0, ciphertext.length - 16);
+    const tag = ciphertext.subarray(ciphertext.length - 16);
+    const plaintext = this.cipher.decrypt(ct, iv, tag, this.state.ss.h);
+    this.state.ss.cipher.nonce++;
+    return plaintext;
+  }
+
+  /**
+   * Generate GCM nonce dari counter (big-endian, 4-byte prefix zero)
+   */
+  private generateNonce(counter: number): Uint8Array {
+    const nonce = new Uint8Array(12);
+    // Last 8 bytes = counter (big-endian)
+    const view = new DataView(nonce.buffer);
+    view.setUint32(4, Math.floor(counter / 0x100000000));
+    view.setUint32(8, counter & 0xffffffff);
+    return nonce;
+  }
+
+  // ============== Public Handshake Methods ==============
+
+  /**
+   * Step 1: Send ephemeral key (initiator -> responder)
+   * Output: bytes untuk dikirim ke server
+   */
+  public writeEphemeral(): Uint8Array {
+    const e = generateCurveKeyPair();
+    this.state.e = e;
+    this.mixHash(e.public);
+    this.mixKey(e.public);
+    return e.public;
+  }
+
+  /**
+   * Step 2: Receive ephemeral + static + EE + ES from responder
+   */
+  public readResponderHandshake(payload: Uint8Array): { plaintext: Uint8Array } {
+    // First 32 bytes = ephemeral key
+    if (payload.length < 32) throw new Error('Handshake too short');
+    const re = payload.subarray(0, 32);
+    this.state.re = re;
+    this.mixHash(re);
+    this.mixKey(re);
+
+    // Ephemeral-ephemeral DH
+    const ee = curveSharedSecret(this.state.e.private, re);
+    this.mixKey(ee);
+
+    // Next: encrypted static key + payload
+    const encryptedStatic = payload.subarray(32);
+    const remoteStatic = this.decryptWithHash(encryptedStatic);
+    this.state.rs = remoteStatic.subarray(0, 32);
+    this.mixHash(remoteStatic);
+
+    // Ephemeral-static DH
+    const es = curveSharedSecret(this.state.e.private, remoteStatic);
+    this.mixKey(es);
+
+    // Remaining: encrypted payload
+    const encryptedPayload = remoteStatic.subarray(32);
+    const payload2 = this.decryptWithHash(encryptedPayload);
+
+    return { plaintext: payload2 };
+  }
+
+  /**
+   * Step 3: Send our static + ES + payload (initiator -> responder)
+   */
+  public writeInitiatorHandshake(payload: Uint8Array): Uint8Array {
+    // Send ephemeral already done in step 1
+    // Now send static + ES + payload, all encrypted with current handshake key
+
+    // Encrypt our static key
+    const encryptedStatic = this.encryptWithHash(this.state.s.public);
+    this.mixHash(this.state.s.public);
+
+    // Static-ephemeral DH (us.remote ephemeral)
+    if (!this.state.re) throw new Error('No remote ephemeral');
+    const se = curveSharedSecret(this.state.s.private, this.state.re);
+    this.mixKey(se);
+
+    // Encrypt payload
+    const encryptedPayload = this.encryptWithHash(payload);
+
+    return concatBytes(encryptedStatic, encryptedPayload);
+  }
+
+  /**
+   * Finalize handshake - split prk into send/recv keys
+   */
+  public finalize(): { sendKey: Uint8Array; recvKey: Uint8Array } {
+    const derived = hkdfDerive(
+      new Uint8Array(0),
+      this.state.ss.ck,
+      new TextEncoder().encode(NOISE_HANDSHAKE_DONE),
+      64
+    );
+    return {
+      sendKey: derived.subarray(0, 32),
+      recvKey: derived.subarray(32, 64)
+    };
+  }
+
+  // ============== Post-handshake AEAD ==============
+
+  /**
+   * Encrypt a frame post-handshake menggunakan traffic keys
+   */
+  public static encryptFrame(
+    key: Uint8Array,
+    counter: number,
+    plaintext: Uint8Array
+  ): Uint8Array {
+    const cipher = createAESCipher(key);
+    const iv = new Uint8Array(12);
+    const view = new DataView(iv.buffer);
+    view.setUint32(4, Math.floor(counter / 0x100000000));
+    view.setUint32(8, counter & 0xffffffff);
+    const { ciphertext, tag } = cipher.encrypt(plaintext, iv);
+    return concatBytes(ciphertext, tag);
+  }
+
+  /**
+   * Decrypt a frame post-handshake
+   */
+  public static decryptFrame(
+    key: Uint8Array,
+    counter: number,
+    ciphertext: Uint8Array
+  ): Uint8Array {
+    if (ciphertext.length < 16) throw new Error('Frame too short');
+    const cipher = createAESCipher(key);
+    const iv = new Uint8Array(12);
+    const view = new DataView(iv.buffer);
+    view.setUint32(4, Math.floor(counter / 0x100000000));
+    view.setUint32(8, counter & 0xffffffff);
+    const ct = ciphertext.subarray(0, ciphertext.length - 16);
+    const tag = ciphertext.subarray(ciphertext.length - 16);
+    return cipher.decrypt(ct, iv, tag);
+  }
+
+  // ============== Frame helpers ==============
+
+  /**
+   * Encode WA noise frame: [WA_HEADER] [VERSION] [LENGTH:3] [PAYLOAD]
+   */
+  public static encodeFrame(payload: Uint8Array): Uint8Array {
+    const len = payload.length;
+    const header = new Uint8Array(3 + 2 + 2); // WA + version + 16-bit length placeholder (3 byte for >64KB)
+
+    // WA header
+    header[0] = 0x57; // 'W'
+    header[1] = 0x41; // 'A'
+    // Version
+    header[2] = 0x05;
+    header[3] = 0x2d;
+    // Length (3 bytes big-endian for up to 16MB)
+    header[4] = (len >> 16) & 0xff;
+    header[5] = (len >> 8) & 0xff;
+    header[6] = len & 0xff;
+
+    return concatBytes(header.subarray(0, 7), payload);
+  }
+
+  /**
+   * Encode WA client payload (untuk handshake init message)
+   * Format: [ephemeral_pubkey:32] [static_encrypted] [payload_encrypted]
+   */
+  public static encodeClientHello(
+    ephemeralPub: Uint8Array,
+    encryptedStatic: Uint8Array,
+    encryptedPayload: Uint8Array
+  ): Uint8Array {
+    return concatBytes(ephemeralPub, encryptedStatic, encryptedPayload);
+  }
+
+  /**
+   * Build client hello untuk initial connection
+   */
+  public buildClientHello(clientPayload: Uint8Array): Uint8Array {
+    // Step 1 + 3 combined for client hello
+    const ephemeral = this.writeEphemeral();
+    const encrypted = this.writeInitiatorHandshake(clientPayload);
+    return concatBytes(ephemeral, encrypted);
+  }
+}
+
+// ============== Traffic Cipher (post-handshake) ==============
+
+/**
+ * Traffic cipher untuk encrypt/decrypt frames setelah handshake done
+ */
+export class TrafficCipher {
+  private sendKey: Uint8Array;
+  private recvKey: Uint8Array;
+  private sendCounter: number = 0;
+  private recvCounter: number = 0;
+
+  constructor(sendKey: Uint8Array, recvKey: Uint8Array) {
+    this.sendKey = sendKey;
+    this.recvKey = recvKey;
+  }
+
+  encrypt(plaintext: Uint8Array): Uint8Array {
+    const result = NoiseHandshake.encryptFrame(this.sendKey, this.sendCounter, plaintext);
+    this.sendCounter++;
+    return result;
+  }
+
+  decrypt(ciphertext: Uint8Array): Uint8Array {
+    const plaintext = NoiseHandshake.decryptFrame(this.recvKey, this.recvCounter, ciphertext);
+    this.recvCounter++;
+    return plaintext;
+  }
+
+  reset() {
+    this.sendCounter = 0;
+    this.recvCounter = 0;
+  }
+}
+
+// ============== Client Payload Builder ==============
+
+/**
+ * Build initial client payload untuk WA Web multi-device connect
+ * Berisi info browser, version, dan props
+ */
+export function buildClientPayload(browser: [string, string, string]): Uint8Array {
+  // Encoded sebagai WA binary node
+  const enc = new TextEncoder();
+  const parts: Uint8Array[] = [];
+
+  // Browser info: [name, short_name, version]
+  parts.push(enc.encode(browser[0]));
+  parts.push(enc.encode(browser[1]));
+  parts.push(enc.encode(browser[2]));
+
+  // Pairing static key (32 bytes) - atau empty jika belum ada
+  // This is generated at first connection and stored in creds
+  // For first-time: generate new
+  const pairingKey = generateCurveKeyPair();
+  parts.push(pairingKey.public);
+
+  // Compute total length
+  let totalLen = 0;
+  for (const p of parts) totalLen += p.length;
+
+  // Prepend each part with length byte (assuming < 256)
+  const result: number[] = [];
+  for (const p of parts) {
+    result.push(p.length);
+    for (let i = 0; i < p.length; i++) result.push(p[i]);
+  }
+
+  return new Uint8Array(result);
+}

package/src/events/emitter.ts

@@ -0,0 +1,88 @@
+/**
+ * Waliwa - Event emitter untuk WebSocket events
+ * Typed event emitter untuk WhatsApp events (messages, presence, calls, dll)
+ *
+ * RAM optimization: gunakan Map untuk handlers, weakly referenced jika possible
+ */
+
+import { EventEmitter } from 'events';
+import type { WAEventMap } from '../types/index.js';
+
+export class WAEventEmitter extends EventEmitter {
+  /**
+   * Listen untuk specific event
+   */
+  on<K extends keyof WAEventMap>(event: K, listener: (payload: WAEventMap[K]) => void): this {
+    return super.on(event, listener as any);
+  }
+
+  /**
+   * Listen once
+   */
+  once<K extends keyof WAEventMap>(event: K, listener: (payload: WAEventMap[K]) => void): this {
+    return super.once(event, listener as any);
+  }
+
+  /**
+   * Listen dengan off support
+   */
+  addListener<K extends keyof WAEventMap>(event: K, listener: (payload: WAEventMap[K]) => void): this {
+    return super.addListener(event, listener as any);
+  }
+
+  /**
+   * Emit event ke all listeners
+   */
+  emit<K extends keyof WAEventMap>(event: K, payload: WAEventMap[K]): boolean {
+    return super.emit(event, payload);
+  }
+
+  /**
+   * Remove listener
+   */
+  off<K extends keyof WAEventMap>(event: K, listener: (payload: WAEventMap[K]) => void): this {
+    return super.off(event, listener as any);
+  }
+
+  /**
+   * Wait for event dengan timeout
+   */
+  async waitFor<K extends keyof WAEventMap>(
+    event: K,
+    timeoutMs: number = 30000
+  ): Promise<WAEventMap[K]> {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.off(event, handler);
+        reject(new Error(`Timeout waiting for ${String(event)}`));
+      }, timeoutMs);
+
+      const handler = (payload: WAEventMap[K]) => {
+        clearTimeout(timeout);
+        this.off(event, handler);
+        resolve(payload);
+      };
+      this.on(event, handler);
+    });
+  }
+}
+
+/**
+ * Strict event emitter - hanya registered events yang di-allow
+ * Berguna untuk catching typos dalam event names
+ */
+export class StrictEventEmitter extends WAEventEmitter {
+  private knownEvents: Set<string>;
+
+  constructor(events: (keyof WAEventMap)[]) {
+    super();
+    this.knownEvents = new Set(events as string[]);
+  }
+
+  emit<K extends keyof WAEventMap>(event: K, payload: WAEventMap[K]): boolean {
+    if (!this.knownEvents.has(event as string)) {
+      throw new Error(`Unknown event: ${String(event)}`);
+    }
+    return super.emit(event, payload);
+  }
+}