@kangwifi-pro/waliwa 1.0.0

package/src/skdm/index.ts

@@ -0,0 +1,693 @@
+/**
+ * Waliwa - SKDM (Store Key Data Manager)
+ *
+ * Subsystem cerdas untuk manage Signal protocol keys:
+ * - Auto-regenerate pre-keys saat hampir habis (prevents Baileys pre-key exhaustion)
+ * - LRU cache untuk sessions (RAM efficient)
+ * - Atomic writes untuk prevent corruption saat disconnect (Baileys issue)
+ * - Pre-key rotation policy dengan background jobs
+ * - Session cleanup untuk orphaned sessions
+ * - Key prefetching untuk known conversations (fix decryption failures)
+ *
+ * Fixes yang addressed:
+ * - Baileys issue: pre-key exhaustion → pre-keys habis gak auto-regenerate
+ * - Baileys issue: session corruption on disconnect → atomic write
+ * - Baileys issue: decryption failure for old messages → key prefetch
+ * - Baileys issue: memory leak dari sessions lama → LRU eviction
+ */
+
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { rename } from 'fs/promises';
+import {
+  generateCurveKeyPair
+} from '../core/crypto.js';
+import { debounce } from '../utils/retry.js';
+import { SilentLogger } from '../utils/logger.js';
+import type {
+  AuthenticationCreds,
+  SignalKeyStore,
+  KeyPair,
+  WALogger
+} from '../types/index.js';
+
+// ============== SKDM Config ==============
+
+export interface SKDMConfig {
+  /** Min pre-keys sebelum regenerate (default: 5) */
+  minPreKeys?: number;
+  /** Max pre-keys yang di-generate sekaligus (default: 50) */
+  maxPreKeysBatch?: number;
+  /** Total pre-keys yang di-keep (default: 100) */
+  targetPreKeyCount?: number;
+  /** Max sessions di RAM cache (default: 500, RAM optimization) */
+  maxSessionCacheSize?: number;
+  /** Auto-save interval ms (default: 5000) */
+  autoSaveIntervalMs?: number;
+  /** Enable background key rotation (default: true) */
+  enableKeyRotation?: boolean;
+  /** Logger */
+  logger?: WALogger;
+  /** Folder untuk atomic writes */
+  storageFolder: string;
+  /** File prefix */
+  prefix?: string;
+  /** Enable session prefetching (default: true, fix decryption failure) */
+  enableSessionPrefetch?: boolean;
+  /** Session expiry (ms, default: 30 days) */
+  sessionExpiryMs?: number;
+}
+
+// ============== LRU Cache (RAM efficient) ==============
+
+/**
+ * LRU cache dengan O(1) operations, manual implementation untuk RAM efficiency.
+ * Used untuk caching sessions dan senderKeys.
+ */
+export class LRUCache<K, V> {
+  private cache: Map<K, V>;
+  private maxSize: number;
+  private hits: number = 0;
+  private misses: number = 0;
+
+  constructor(maxSize: number = 500) {
+    this.cache = new Map();
+    this.maxSize = maxSize;
+  }
+
+  get(key: K): V | undefined {
+    const value = this.cache.get(key);
+    if (value !== undefined) {
+      // Move to end (most recent)
+      this.cache.delete(key);
+      this.cache.set(key, value);
+      this.hits++;
+      return value;
+    }
+    this.misses++;
+    return undefined;
+  }
+
+  set(key: K, value: V): void {
+    if (this.cache.has(key)) {
+      // Update existing - move to end
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.maxSize) {
+      // Evict oldest
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== undefined) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, value);
+  }
+
+  has(key: K): boolean {
+    return this.cache.has(key);
+  }
+
+  delete(key: K): boolean {
+    return this.cache.delete(key);
+  }
+
+  clear(): void {
+    this.cache.clear();
+    this.hits = 0;
+    this.misses = 0;
+  }
+
+  size(): number {
+    return this.cache.size;
+  }
+
+  getStats(): { size: number; hits: number; misses: number; hitRate: number } {
+    const total = this.hits + this.misses;
+    return {
+      size: this.cache.size,
+      hits: this.hits,
+      misses: this.misses,
+      hitRate: total === 0 ? 0 : this.hits / total
+    };
+  }
+}
+
+// ============== Atomic File Writer ==============
+
+/**
+ * Atomic file writer - prevents corruption saat disconnect/power failure.
+ * Baileys issue: session files corrupt jika process kill saat write.
+ *
+ * Strategy: write to .tmp file, then rename (atomic on POSIX systems).
+ */
+export class AtomicFileWriter {
+  private static writeLocks: Map<string, Promise<void>> = new Map();
+
+  static async writeFile(
+    filePath: string,
+    data: string | Buffer,
+    encoding: 'utf-8' | 'binary' = 'utf-8'
+  ): Promise<void> {
+    // Serialize writes per file (prevent concurrent writes)
+    const existingLock = AtomicFileWriter.writeLocks.get(filePath);
+    const newPromise = (existingLock ?? Promise.resolve())
+      .then(() => AtomicFileWriter.performWrite(filePath, data, encoding));
+
+    AtomicFileWriter.writeLocks.set(filePath, newPromise);
+
+    try {
+      await newPromise;
+    } finally {
+      if (AtomicFileWriter.writeLocks.get(filePath) === newPromise) {
+        AtomicFileWriter.writeLocks.delete(filePath);
+      }
+    }
+  }
+
+  private static async performWrite(
+    filePath: string,
+    data: string | Buffer,
+    encoding: 'utf-8' | 'binary'
+  ): Promise<void> {
+    const tmpPath = `${filePath}.tmp.${process.pid}.${Date.now()}`;
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    if (encoding === 'utf-8') {
+      await fs.writeFile(tmpPath, data as string, 'utf-8');
+    } else {
+      await fs.writeFile(tmpPath, data as Buffer);
+    }
+    // Atomic rename (POSIX)
+    await rename(tmpPath, filePath);
+  }
+}
+
+// ============== Pre-Key Manager ==============
+
+/**
+ * Pre-key manager - auto-regenerate saat low, prevents exhaustion.
+ * Fix Baileys issue: pre-keys habis tanpa warning.
+ */
+export class PreKeyManager {
+  private creds: AuthenticationCreds;
+  private keys: SignalKeyStore;
+  private minPreKeys: number;
+  private maxBatch: number;
+  private targetCount: number;
+  private logger: WALogger;
+  private isRegenerating: boolean = false;
+  private lastRegenTime: number = 0;
+  private regenDebounce: NodeJS.Timeout | null = null;
+
+  constructor(
+    creds: AuthenticationCreds,
+    keys: SignalKeyStore,
+    config: Pick<SKDMConfig, 'minPreKeys' | 'maxPreKeysBatch' | 'targetPreKeyCount' | 'logger'>
+  ) {
+    this.creds = creds;
+    this.keys = keys;
+    this.minPreKeys = config.minPreKeys ?? 5;
+    this.maxBatch = config.maxPreKeysBatch ?? 50;
+    this.targetCount = config.targetPreKeyCount ?? 100;
+    this.logger = config.logger ?? new SilentLogger();
+  }
+
+  needsRegeneration(): boolean {
+    return this.getPreKeyCount() < this.minPreKeys;
+  }
+
+  getPreKeyCount(): number {
+    return Object.keys(this.keys.preKeys).length;
+  }
+
+  getNextPreKeyId(): number {
+    return this.creds.nextPreKeyId ?? 1;
+  }
+
+  getPreKey(id: number): KeyPair | undefined {
+    return this.keys.preKeys[id];
+  }
+
+  /**
+   * Consume a pre-key (mark as used)
+   * Returns true jika key consumed, false jika tidak ada
+   */
+  consumePreKey(id: number): boolean {
+    const key = this.keys.preKeys[id];
+    if (!key) return false;
+    delete this.keys.preKeys[id];
+    this.logger.debug(`Consumed pre-key ${id}, ${this.getPreKeyCount()} remaining`);
+
+    if (this.needsRegeneration()) {
+      this.scheduleRegeneration();
+    }
+    return true;
+  }
+
+  scheduleRegeneration(): void {
+    if (this.regenDebounce) clearTimeout(this.regenDebounce);
+    this.regenDebounce = setTimeout(() => {
+      this.regeneratePreKeys().catch(err => {
+        this.logger.error(`Pre-key regeneration failed: ${err.message}`);
+      });
+    }, 2000);
+  }
+
+  async regeneratePreKeys(): Promise<void> {
+    if (this.isRegenerating) {
+      this.logger.debug('Pre-key regeneration already in progress');
+      return;
+    }
+
+    this.isRegenerating = true;
+    const currentCount = this.getPreKeyCount();
+    const needed = this.targetCount - currentCount;
+    const toGenerate = Math.min(needed, this.maxBatch);
+
+    if (toGenerate <= 0) {
+      this.isRegenerating = false;
+      return;
+    }
+
+    this.logger.info(`Regenerating ${toGenerate} pre-keys (current: ${currentCount})`);
+
+    let nextId = this.getNextPreKeyId();
+    for (let i = 0; i < toGenerate; i++) {
+      const keyPair = generateCurveKeyPair();
+      this.keys.preKeys[nextId] = keyPair;
+      nextId++;
+    }
+    this.creds.nextPreKeyId = nextId;
+    this.lastRegenTime = Date.now();
+
+    this.logger.info(`Pre-keys regenerated. Total: ${this.getPreKeyCount()}`);
+    this.isRegenerating = false;
+  }
+
+  startBackgroundRotation(intervalMs: number = 60 * 60 * 1000): NodeJS.Timeout {
+    return setInterval(() => {
+      if (this.needsRegeneration()) {
+        this.regeneratePreKeys().catch(err => {
+          this.logger.error(`Background pre-key regen failed: ${err.message}`);
+        });
+      }
+    }, intervalMs);
+  }
+
+  getStats(): {
+    total: number;
+    nextId: number;
+    lastRegenTime: number;
+    needsRegen: boolean;
+  } {
+    return {
+      total: this.getPreKeyCount(),
+      nextId: this.creds.nextPreKeyId ?? 1,
+      lastRegenTime: this.lastRegenTime,
+      needsRegen: this.needsRegeneration()
+    };
+  }
+}
+
+// ============== Session Manager ==============
+
+/**
+ * Session manager dengan LRU cache untuk RAM efficiency.
+ * Fix Baileys issue: memory leak dari sessions lama.
+ */
+export class SessionManager {
+  private keys: SignalKeyStore;
+  private cache: LRUCache<string, any>;
+  private maxCacheSize: number;
+  private logger: WALogger;
+  private sessionExpiryMs: number;
+  private lastAccess: Map<string, number> = new Map();
+
+  constructor(
+    keys: SignalKeyStore,
+    config: Pick<SKDMConfig, 'maxSessionCacheSize' | 'logger' | 'sessionExpiryMs'>
+  ) {
+    this.keys = keys;
+    this.maxCacheSize = config.maxSessionCacheSize ?? 500;
+    this.cache = new LRUCache<string, any>(this.maxCacheSize);
+    this.logger = config.logger ?? new SilentLogger();
+    this.sessionExpiryMs = config.sessionExpiryMs ?? 30 * 24 * 60 * 60 * 1000;
+  }
+
+  getSession(jid: string): any | undefined {
+    const cached = this.cache.get(jid);
+    if (cached !== undefined) return cached;
+
+    const session = this.keys.sessions[jid];
+    if (session) {
+      this.cache.set(jid, session);
+      this.lastAccess.set(jid, Date.now());
+    }
+    return session;
+  }
+
+  setSession(jid: string, session: any): void {
+    this.cache.set(jid, session);
+    this.keys.sessions[jid] = session;
+    this.lastAccess.set(jid, Date.now());
+  }
+
+  deleteSession(jid: string): void {
+    this.cache.delete(jid);
+    delete this.keys.sessions[jid];
+    this.lastAccess.delete(jid);
+  }
+
+  /**
+   * Cleanup expired sessions (untuk free RAM)
+   * Returns count of cleaned sessions
+   */
+  cleanupExpiredSessions(): number {
+    const now = Date.now();
+    let cleaned = 0;
+    const toDelete: string[] = [];
+
+    for (const [jid, lastTime] of this.lastAccess.entries()) {
+      if (now - lastTime > this.sessionExpiryMs) {
+        toDelete.push(jid);
+      }
+    }
+
+    for (const jid of toDelete) {
+      this.deleteSession(jid);
+      cleaned++;
+    }
+
+    if (cleaned > 0) {
+      this.logger.info(`Cleaned ${cleaned} expired sessions`);
+    }
+    return cleaned;
+  }
+
+  /**
+   * Prefetch sessions untuk multiple JIDs (fix decryption failure)
+   * Bulk load sessions sebelum decrypt group messages
+   */
+  prefetchSessions(jids: string[]): void {
+    for (const jid of jids) {
+      if (!this.cache.has(jid) && this.keys.sessions[jid]) {
+        this.cache.set(jid, this.keys.sessions[jid]);
+        this.lastAccess.set(jid, Date.now());
+      }
+    }
+  }
+
+  getStats() {
+    return {
+      ...this.cache.getStats(),
+      totalSessions: Object.keys(this.keys.sessions).length,
+      expiredSessions: Array.from(this.lastAccess.values())
+        .filter(t => Date.now() - t > this.sessionExpiryMs).length
+    };
+  }
+}
+
+// ============== AppState Key Manager ==============
+
+/**
+ * AppState key manager - manage app state sync keys dengan deduplication.
+ * Fix Baileys issue: app state sync keys bertumpuk tanpa cleanup.
+ */
+export class AppStateKeyManager {
+  private keys: SignalKeyStore;
+  private logger: WALogger;
+  private cache: LRUCache<string, Uint8Array>;
+
+  constructor(keys: SignalKeyStore, logger?: WALogger) {
+    this.keys = keys;
+    this.logger = logger ?? new SilentLogger();
+    this.cache = new LRUCache<string, Uint8Array>(100);
+  }
+
+  get(keyId: string): Uint8Array | undefined {
+    const cached = this.cache.get(keyId);
+    if (cached) return cached;
+    const stored = this.keys.appStateSyncKeys[keyId];
+    if (stored) {
+      this.cache.set(keyId, stored);
+      return stored;
+    }
+    return undefined;
+  }
+
+  set(keyId: string, key: Uint8Array): void {
+    this.cache.set(keyId, key);
+    this.keys.appStateSyncKeys[keyId] = key;
+  }
+
+  cleanup(maxKeep: number = 50): number {
+    const allKeys = Object.keys(this.keys.appStateSyncKeys);
+    if (allKeys.length <= maxKeep) return 0;
+
+    const toDelete = allKeys.slice(0, allKeys.length - maxKeep);
+    for (const keyId of toDelete) {
+      delete this.keys.appStateSyncKeys[keyId];
+      this.cache.delete(keyId);
+    }
+    this.logger.debug(`Cleaned ${toDelete.length} old app state keys`);
+    return toDelete.length;
+  }
+}
+
+// ============== Identity Key Manager ==============
+
+/**
+ * Identity key manager dengan verification.
+ * Fix Baileys issue: identity changes gak tracked properly.
+ */
+export class IdentityKeyManager {
+  private keys: SignalKeyStore;
+  private logger: WALogger;
+  private trustedIdentities: Map<string, Uint8Array> = new Map();
+  private changedIdentities: Set<string> = new Set();
+
+  constructor(keys: SignalKeyStore, logger?: WALogger) {
+    this.keys = keys;
+    this.logger = logger ?? new SilentLogger();
+    for (const [jid, keyPair] of Object.entries(keys.identityKeys)) {
+      if (keyPair?.public) {
+        this.trustedIdentities.set(jid, keyPair.public);
+      }
+    }
+  }
+
+  get(jid: string): Uint8Array | undefined {
+    return this.trustedIdentities.get(jid) ?? this.keys.identityKeys[jid]?.public;
+  }
+
+  /**
+   * Save identity key, detect changes
+   * Returns true jika identity CHANGED (security concern)
+   */
+  save(jid: string, identity: Uint8Array): boolean {
+    const existing = this.trustedIdentities.get(jid);
+    const changed = existing !== undefined && !this.bytesEqual(existing, identity);
+
+    this.trustedIdentities.set(jid, identity);
+    this.keys.identityKeys[jid] = { private: new Uint8Array(0), public: identity };
+
+    if (changed) {
+      this.changedIdentities.add(jid);
+      this.logger.warn(`Identity changed for ${jid} - possible security issue!`);
+    }
+    return changed;
+  }
+
+  getChangedIdentities(): string[] {
+    return Array.from(this.changedIdentities);
+  }
+
+  acknowledge(jid: string): void {
+    this.changedIdentities.delete(jid);
+  }
+
+  trust(jid: string): void {
+    this.changedIdentities.delete(jid);
+  }
+
+  private bytesEqual(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;
+  }
+}
+
+// ============== Main SKDM Class ==============
+
+/**
+ * SKDM - Store Key Data Manager
+ * Single entry point untuk semua key management operations.
+ */
+export class SKDM {
+  private config: SKDMConfig;
+  private logger: WALogger;
+  private creds: AuthenticationCreds;
+  private keys: SignalKeyStore;
+
+  public preKeyManager: PreKeyManager;
+  public sessionManager: SessionManager;
+  public identityManager: IdentityKeyManager;
+  public appStateManager: AppStateKeyManager;
+
+  private dirty: { creds: boolean; keys: boolean } = { creds: false, keys: false };
+  private saveCredsDebounced: () => void;
+  private saveKeysDebounced: () => void;
+  private backgroundJobs: NodeJS.Timeout[] = [];
+  private isInitialized: boolean = false;
+
+  constructor(creds: AuthenticationCreds, keys: SignalKeyStore, config: SKDMConfig) {
+    this.creds = creds;
+    this.keys = keys;
+    this.config = config;
+    this.logger = config.logger ?? new SilentLogger();
+
+    this.preKeyManager = new PreKeyManager(creds, keys, config);
+    this.sessionManager = new SessionManager(keys, config);
+    this.identityManager = new IdentityKeyManager(keys, this.logger);
+    this.appStateManager = new AppStateKeyManager(keys, this.logger);
+
+    const debounceMs = 100;
+    this.saveCredsDebounced = debounce(() => this.flushCreds(), debounceMs);
+    this.saveKeysDebounced = debounce(() => this.flushKeys(), debounceMs);
+  }
+
+  /**
+   * Initialize SKDM - load state, start background jobs
+   */
+  async initialize(): Promise<void> {
+    if (this.isInitialized) return;
+
+    this.logger.info('Initializing SKDM...');
+
+    if (this.preKeyManager.needsRegeneration()) {
+      await this.preKeyManager.regeneratePreKeys();
+    }
+
+    if (this.config.enableKeyRotation !== false) {
+      const preKeyJob = this.preKeyManager.startBackgroundRotation(60 * 60 * 1000);
+      this.backgroundJobs.push(preKeyJob);
+    }
+
+    const sessionCleanupJob = setInterval(() => {
+      const cleaned = this.sessionManager.cleanupExpiredSessions();
+      if (cleaned > 0) this.markKeysDirty();
+    }, 6 * 60 * 60 * 1000);
+    this.backgroundJobs.push(sessionCleanupJob);
+
+    const appStateCleanupJob = setInterval(() => {
+      const cleaned = this.appStateManager.cleanup(50);
+      if (cleaned > 0) this.markKeysDirty();
+    }, 24 * 60 * 60 * 1000);
+    this.backgroundJobs.push(appStateCleanupJob);
+
+    this.isInitialized = true;
+    this.logger.info('SKDM initialized successfully');
+  }
+
+  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;
+    });
+
+    const filePath = path.join(this.config.storageFolder, `${this.config.prefix ?? 'waliwa'}-creds.json`);
+    try {
+      await AtomicFileWriter.writeFile(filePath, data, 'utf-8');
+      this.logger.debug('Credentials saved (atomic)');
+    } catch (err: any) {
+      this.logger.error(`Failed to save creds: ${err.message}`);
+      this.dirty.creds = true;
+    }
+  }
+
+  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;
+    });
+
+    const filePath = path.join(this.config.storageFolder, `${this.config.prefix ?? 'waliwa'}-keys.json`);
+    try {
+      await AtomicFileWriter.writeFile(filePath, data, 'utf-8');
+      this.logger.debug('Keys saved (atomic)');
+    } catch (err: any) {
+      this.logger.error(`Failed to save keys: ${err.message}`);
+      this.dirty.keys = true;
+    }
+  }
+
+  async flush(): Promise<void> {
+    await Promise.all([this.flushCreds(), this.flushKeys()]);
+  }
+
+  getStats(): SKDMStats {
+    return {
+      preKeys: this.preKeyManager.getStats(),
+      sessions: this.sessionManager.getStats(),
+      identities: {
+        total: this.identityManager['trustedIdentities'].size,
+        changed: this.identityManager.getChangedIdentities().length
+      },
+      appStateKeys: Object.keys(this.keys.appStateSyncKeys).length,
+      pendingSaves: (this.dirty.creds ? 1 : 0) + (this.dirty.keys ? 1 : 0)
+    };
+  }
+
+  async destroy(): Promise<void> {
+    for (const job of this.backgroundJobs) {
+      clearInterval(job);
+    }
+    this.backgroundJobs = [];
+    await this.flush();
+    this.isInitialized = false;
+    this.logger.info('SKDM destroyed');
+  }
+}
+
+export interface SKDMStats {
+  preKeys: ReturnType<PreKeyManager['getStats']>;
+  sessions: ReturnType<SessionManager['getStats']>;
+  identities: { total: number; changed: number };
+  appStateKeys: number;
+  pendingSaves: number;
+}