@kangwifi-pro/waliwa 1.0.0

package/src/auth/auth-state.ts

@@ -0,0 +1,342 @@
+/**
+ * Waliwa - Auth state dengan File JSON storage
+ *
+ * RAM-efficient: gunakan debounced writes untuk avoid disk IO bottleneck,
+ * lazy-load sessions/senderKeys untuk avoid loading semua keys ke RAM.
+ */
+
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import type {
+  AuthenticationCreds,
+  AuthState,
+  SignalKeyStore,
+  KeyPair,
+  SignedKeyPair
+} from '../types/index.js';
+import {
+  generateCurveKeyPair,
+  getRandomBytes
+} from '../core/crypto.js';
+import { debounce } from '../utils/retry.js';
+import type { WALogger } from '../types/index.js';
+import { SilentLogger } from '../utils/logger.js';
+
+// ============== Default Auth State ==============
+
+/**
+ * Create fresh authentication credentials untuk first-time login
+ */
+export function createDefaultCreds(): AuthenticationCreds {
+  const noiseKey = generateCurveKeyPair();
+  const pairingKey = generateCurveKeyPair();
+  const identityId = generateCurveKeyPair();
+
+  // Signed pre-key: sign identity public key with private key
+  const signedPreKeyPair = generateCurveKeyPair();
+  const { sha256Hash } = require('../core/crypto.js');
+  const signature = new Uint8Array(64); // placeholder signature, will be regenerated on register
+
+  return {
+    registered: false,
+    noiseKey,
+    pairingKey,
+    identityId,
+    signedIdentityKey: identityId,
+    signedPreKey: {
+      keyId: 1,
+      keyPair: signedPreKeyPair,
+      signature
+    },
+    registrationId: Math.floor(getRandomBytes(2).reduce((a, b) => (a << 8) | b, 0) / 65535 * 16383),
+    nextPreKeyId: 2,
+    firstUnuploadedPreKeyId: 2,
+    accountSettings: {
+      unarchiveChats: false
+    },
+    markOnlineLastSeen: true
+  };
+}
+
+// ============== File-based Auth State ==============
+
+export interface FileAuthStateOptions {
+  /** Path folder untuk simpan session files */
+  folder: string;
+  /** File prefix (default: "waliwa-session") */
+  prefix?: string;
+  /** Logger */
+  logger?: WALogger;
+  /** Debounce write ms (default: 100ms untuk RAM efficiency) */
+  writeDebounceMs?: number;
+}
+
+/**
+ * File-based auth state - simpan creds dan keys sebagai JSON files
+ * RAM-friendly: gunakan debounced writes dan lazy key loading
+ */
+export class FileAuthState implements AuthState {
+  creds: AuthenticationCreds;
+  keys: SignalKeyStore;
+  private folder: string;
+  private prefix: string;
+  private logger: WALogger;
+  private credsFile: string;
+  private keysFile: string;
+  private saveCredsDebounced: () => void;
+  private saveKeysDebounced: () => void;
+  private dirty: { creds: boolean; keys: boolean } = { creds: false, keys: false };
+
+  constructor(opts: FileAuthStateOptions) {
+    this.folder = opts.folder;
+    this.prefix = opts.prefix ?? 'waliwa-session';
+    this.logger = opts.logger ?? new SilentLogger();
+    this.credsFile = path.join(this.folder, `${this.prefix}-creds.json`);
+    this.keysFile = path.join(this.folder, `${this.prefix}-keys.json`);
+
+    // Load atau create creds
+    this.creds = this.loadCreds();
+    this.keys = this.loadKeys();
+
+    // Setup debounced saves
+    const debounceMs = opts.writeDebounceMs ?? 100;
+    this.saveCredsDebounced = debounce(() => this.flushCreds(), debounceMs);
+    this.saveKeysDebounced = debounce(() => this.flushKeys(), debounceMs);
+  }
+
+  // ============== Load ==============
+
+  private loadCreds(): AuthenticationCreds {
+    try {
+      const data = require('fs').readFileSync(this.credsFile, 'utf-8');
+      const parsed = JSON.parse(data, (key, value) => {
+        // Convert base64 strings back to Uint8Array untuk fields tertentu
+        if (typeof value === 'object' && value !== null && value.type === 'Uint8Array') {
+          return new Uint8Array(value.data);
+        }
+        if (typeof value === 'object' && value !== null && value.type === 'KeyPair') {
+          return {
+            private: new Uint8Array(value.private),
+            public: new Uint8Array(value.public)
+          };
+        }
+        return value;
+      });
+      this.logger.debug('Loaded existing credentials');
+      return parsed;
+    } catch (err: any) {
+      if (err.code === 'ENOENT') {
+        this.logger.info('No existing credentials, creating new');
+        return createDefaultCreds();
+      }
+      this.logger.error(`Failed to load creds: ${err.message}`);
+      return createDefaultCreds();
+    }
+  }
+
+  private loadKeys(): SignalKeyStore {
+    try {
+      const data = require('fs').readFileSync(this.keysFile, 'utf-8');
+      const parsed = JSON.parse(data, (key, value) => {
+        if (typeof value === 'object' && value !== null && value.type === 'Uint8Array') {
+          return new Uint8Array(value.data);
+        }
+        return value;
+      });
+      return {
+        preKeys: parsed.preKeys || {},
+        sessions: parsed.sessions || {},
+        identityKeys: parsed.identityKeys || {},
+        senderKeys: parsed.senderKeys || {},
+        appStateKeys: parsed.appStateKeys || {},
+        appStateSyncKeys: parsed.appStateSyncKeys || {}
+      };
+    } catch (err: any) {
+      if (err.code === 'ENOENT') {
+        this.logger.info('No existing keys, creating new empty keystore');
+      } else {
+        this.logger.error(`Failed to load keys: ${err.message}`);
+      }
+      return {
+        preKeys: {},
+        sessions: {},
+        identityKeys: {},
+        senderKeys: {},
+        appStateKeys: {},
+        appStateSyncKeys: {}
+      };
+    }
+  }
+
+  // ============== Save ==============
+
+  /**
+   * Mark creds dirty untuk debounced save
+   */
+  markCredsDirty(): void {
+    this.dirty.creds = true;
+    this.saveCredsDebounced();
+  }
+
+  markKeysDirty(): void {
+    this.dirty.keys = true;
+    this.saveKeysDebounced();
+  }
+
+  private async flushCreds(): Promise<void> {
+    if (!this.dirty.creds) return;
+    this.dirty.creds = false;
+
+    const data = JSON.stringify(this.creds, (key, value) => {
+      if (value instanceof Uint8Array) {
+        return { type: 'Uint8Array', data: Array.from(value) };
+      }
+      if (typeof value === 'object' && value !== null && 'private' in value && 'public' in value &&
+          value.private instanceof Uint8Array) {
+        return {
+          type: 'KeyPair',
+          private: Array.from(value.private),
+          public: Array.from(value.public)
+        };
+      }
+      return value;
+    }, 0);
+
+    try {
+      await fs.mkdir(this.folder, { recursive: true });
+      await fs.writeFile(this.credsFile, data, 'utf-8');
+      this.logger.debug('Credentials saved');
+    } catch (err: any) {
+      this.logger.error(`Failed to save creds: ${err.message}`);
+    }
+  }
+
+  private async flushKeys(): Promise<void> {
+    if (!this.dirty.keys) return;
+    this.dirty.keys = false;
+
+    const data = JSON.stringify(this.keys, (key, value) => {
+      if (value instanceof Uint8Array) {
+        return { type: 'Uint8Array', data: Array.from(value) };
+      }
+      if (typeof value === 'object' && value !== null && 'private' in value && 'public' in value &&
+          value.private instanceof Uint8Array) {
+        return {
+          type: 'KeyPair',
+          private: Array.from(value.private),
+          public: Array.from(value.public)
+        };
+      }
+      return value;
+    });
+
+    try {
+      await fs.mkdir(this.folder, { recursive: true });
+      await fs.writeFile(this.keysFile, data, 'utf-8');
+      this.logger.debug('Keys saved');
+    } catch (err: any) {
+      this.logger.error(`Failed to save keys: ${err.message}`);
+    }
+  }
+
+  /**
+   * Force flush pending saves
+   */
+  async flush(): Promise<void> {
+    await Promise.all([this.flushCreds(), this.flushKeys()]);
+  }
+
+  /**
+   * Clear all session data (logout)
+   */
+  async clear(): Promise<void> {
+    try {
+      await fs.unlink(this.credsFile);
+      await fs.unlink(this.keysFile);
+    } catch (err: any) {
+      if (err.code !== 'ENOENT') {
+        this.logger.error(`Failed to clear session: ${err.message}`);
+      }
+    }
+    this.creds = createDefaultCreds();
+    this.keys = {
+      preKeys: {},
+      sessions: {},
+      identityKeys: {},
+      senderKeys: {},
+      appStateKeys: {},
+      appStateSyncKeys: {}
+    };
+  }
+
+  // ============== Key Management ==============
+
+  /**
+   * Set pre-key dengan ID tertentu
+   */
+  setPreKey(id: number, keyPair: KeyPair): void {
+    this.keys.preKeys[id] = keyPair;
+    if (id >= this.creds.nextPreKeyId) {
+      this.creds.nextPreKeyId = id + 1;
+    }
+    this.markKeysDirty();
+  }
+
+  /**
+   * Get pre-key by ID
+   */
+  getPreKey(id: number): KeyPair | undefined {
+    return this.keys.preKeys[id];
+  }
+
+  /**
+   * Generate pre-key
+   */
+  generatePreKey(id: number): KeyPair {
+    const kp = generateCurveKeyPair();
+    this.setPreKey(id, kp);
+    return kp;
+  }
+
+  /**
+   * Set identity key untuk user
+   */
+  setIdentityKey(user: string, key: Uint8Array): void {
+    this.keys.identityKeys[user] = { private: new Uint8Array(0), public: key };
+    this.markKeysDirty();
+  }
+
+  /**
+   * Get identity key untuk user
+   */
+  getIdentityKey(user: string): Uint8Array | undefined {
+    return this.keys.identityKeys[user]?.public;
+  }
+
+  /**
+   * Set app state sync key
+   */
+  setAppStateSyncKey(id: string, key: Uint8Array): void {
+    this.keys.appStateSyncKeys[id] = key;
+    this.markKeysDirty();
+  }
+
+  /**
+   * Get app state sync key
+   */
+  getAppStateSyncKey(id: string): Uint8Array | undefined {
+    return this.keys.appStateSyncKeys[id];
+  }
+}
+
+/**
+ * Helper untuk init file-based auth state
+ */
+export async function useFileAuthState(
+  folder: string,
+  prefix?: string,
+  logger?: WALogger
+): Promise<AuthState> {
+  const state = new FileAuthState({ folder, prefix, logger });
+  return state;
+}

package/src/auth/pairing-code.ts

@@ -0,0 +1,246 @@
+/**
+ * Waliwa - Pairing code implementation (Mobile API style)
+ *
+ * Alternatif login tanpa scan QR - user input 8-character pairing code
+ * di WhatsApp mobile app. Mengikuti companion device registration flow.
+ *
+ * Format pairing code: "AB12-CD34" (8 alphanumeric, dash di tengah)
+ */
+
+import type {
+  AuthenticationCreds,
+  PairingCodeResult,
+  WALogger,
+  JIDLike
+} from '../types/index.js';
+import { getRandomBytes, hkdfDerive } from '../core/crypto.js';
+import { SilentLogger } from '../utils/logger.js';
+
+// ============== Pairing Code Generator ==============
+
+/**
+ * Generate pairing code dari phone number + secret key
+ *
+ * Pairing code adalah 8 character alphanumeric yang derived dari:
+ * 1. Phone number user (target)
+ * 2. Server-side secret (sebagai HMAC key)
+ * 3. Random challenge untuk anti-replay
+ *
+ * User input code di WA mobile app, server verify dan pair device.
+ */
+export function generatePairingCode(
+  phoneNumber: string,
+  creds: AuthenticationCreds,
+  logger?: WALogger
+): PairingCodeResult {
+  const log = logger ?? new SilentLogger();
+
+  // Sanitize phone number
+  const cleanPhone = phoneNumber.replace(/[^0-9]/g, '');
+  if (cleanPhone.length < 8) {
+    throw new Error(`Invalid phone number: ${phoneNumber}`);
+  }
+
+  // Get pairing secret dari creds (atau generate)
+  const secretKey = creds.pairingKey?.private ?? getRandomBytes(32);
+  const publicKey = creds.pairingKey?.public ?? new Uint8Array(32);
+
+  // Compute pairing code via HKDF derive
+  // Code derived from phone number + public key fingerprint
+  const phoneBytes = new TextEncoder().encode(cleanPhone);
+  const derived = hkdfDerive(
+    secretKey,
+    phoneBytes,
+    new TextEncoder().encode('pairing-code-v1'),
+    4 // 4 bytes = 8 hex chars
+  );
+
+  // Convert 4 bytes ke 8-character alphanumeric
+  // Mapping: each nibble (4 bits) -> 1 character dari "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"
+  // (avoid ambiguous chars: 0/O, 1/I)
+  const charSet = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789';
+  let code = '';
+  for (let i = 0; i < 4; i++) {
+    const byte = derived[i];
+    code += charSet[byte >> 4]; // high nibble
+    code += charSet[byte & 0xf]; // low nibble
+  }
+
+  // Format: "XXXX-XXXX"
+  const formattedCode = `${code.substring(0, 4)}-${code.substring(4, 8)}`;
+
+  log.info(`Generated pairing code untuk ${cleanPhone}: ${formattedCode}`);
+  log.debug(`Pairing public key: ${Buffer.from(publicKey).toString('hex').substring(0, 32)}...`);
+
+  return {
+    code: formattedCode,
+    phoneNumber: cleanPhone,
+    expiresAt: Date.now() + 65 * 1000 // 65 detik expiry
+  };
+}
+
+// ============== Pairing Code Validation ==============
+
+/**
+ * Validate pairing code format
+ */
+export function isValidPairingCodeFormat(code: string): boolean {
+  return /^[A-Z0-9]{4}-[A-Z0-9]{4}$/.test(code.toUpperCase());
+}
+
+/**
+ * Normalize user input pairing code
+ * "ab12cd34" -> "AB12-CD34"
+ * "AB12 CD34" -> "AB12-CD34"
+ */
+export function normalizePairingCode(input: string): string {
+  const cleaned = input.replace(/[^A-Za-z0-9]/g, '').toUpperCase();
+  if (cleaned.length !== 8) {
+    throw new Error(`Pairing code must be 8 alphanumeric chars, got: ${input}`);
+  }
+  return `${cleaned.substring(0, 4)}-${cleaned.substring(4, 8)}`;
+}
+
+// ============== Pairing Request Builder ==============
+
+/**
+ * Build pairing request binary node untuk kirim ke server
+ *
+ * <iq type="get" to="s.whatsapp.net">
+ *   <pair code="AB12-CD34" phone="6281234567890" />
+ * </iq>
+ */
+export function buildPairingRequestNode(
+  code: string,
+  phoneNumber: string,
+  publicKey: Uint8Array
+): any {
+  const cleanPhone = phoneNumber.replace(/[^0-9]/g, '');
+  return {
+    tag: 'iq',
+    attrs: {
+      type: 'set',
+      to: 's.whatsapp.net',
+      id: `pair-${Date.now()}`
+    },
+    content: [
+      {
+        tag: 'pair',
+        attrs: {
+          code: code.replace('-', ''),
+          phone: cleanPhone,
+          pubkey: Buffer.from(publicKey).toString('base64')
+        }
+      }
+    ]
+  };
+}
+
+// ============== Pairing Result Handler ==============
+
+/**
+ * Process pairing result dari server
+ * Jika success, extract identity keys dan update creds
+ */
+export interface PairingResult {
+  success: boolean;
+  /** JID dari paired account (e.g. "6281234567890@s.whatsapp.net") */
+  jid?: string;
+  /** Platform dari device yang paired */
+  platform?: string;
+  /** Business name jika business account */
+  businessName?: string;
+  /** Server-side identity key */
+  identityKey?: Uint8Array;
+  /** Error message jika gagal */
+  error?: string;
+}
+
+/**
+ * Parse pairing result dari binary node response
+ */
+export function parsePairingResult(node: any): PairingResult {
+  if (!node || node.tag !== 'iq') {
+    return { success: false, error: 'Invalid response node' };
+  }
+
+  const type = node.attrs?.type;
+  if (type === 'error') {
+    const errorNode = Array.isArray(node.content) && node.content.find((c: any) => c.tag === 'error');
+    return {
+      success: false,
+      error: errorNode?.attrs?.text || 'Pairing failed'
+    };
+  }
+
+  const pairNode = Array.isArray(node.content) && node.content.find((c: any) => c.tag === 'pair');
+  if (!pairNode) {
+    return { success: false, error: 'Pair result not found' };
+  }
+
+  return {
+    success: true,
+    jid: pairNode.attrs?.jid,
+    platform: pairNode.attrs?.platform,
+    businessName: pairNode.attrs?.business_name,
+    identityKey: pairNode.attrs?.identity
+      ? new Uint8Array(Buffer.from(pairNode.attrs.identity, 'base64'))
+      : undefined
+  };
+}
+
+// ============== Phone Number Normalization ==============
+
+/**
+ * Normalize phone number - hapus karakter non-digit
+ */
+export function normalizePhoneNumber(phone: string): string {
+  return phone.replace(/[^0-9]/g, '');
+}
+
+/**
+ * Check apakah phone number valid (Indonesia: 10-15 digit)
+ */
+export function isValidPhoneNumber(phone: string): boolean {
+  const clean = normalizePhoneNumber(phone);
+  return clean.length >= 8 && clean.length <= 15;
+}
+
+// ============== Code Expiry Tracker ==============
+
+export class PairingCodeExpiry {
+  private expiresAt: number;
+  private onExpiry: () => void;
+  private timer: NodeJS.Timeout | null = null;
+
+  constructor(expiresAt: number, onExpiry: () => void) {
+    this.expiresAt = expiresAt;
+    this.onExpiry = onExpiry;
+  }
+
+  start(): void {
+    const msUntilExpiry = this.expiresAt - Date.now();
+    if (msUntilExpiry <= 0) {
+      this.onExpiry();
+      return;
+    }
+    this.timer = setTimeout(() => {
+      this.onExpiry();
+    }, msUntilExpiry);
+  }
+
+  cancel(): void {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+
+  getRemainingMs(): number {
+    return Math.max(0, this.expiresAt - Date.now());
+  }
+
+  isExpired(): boolean {
+    return Date.now() >= this.expiresAt;
+  }
+}