kersiosocket 0.0.0-stage → 0.6.0-dev

package/src/socket/noise.js

@@ -0,0 +1,146 @@
+'use strict'
+/**
+ * Noise Protocol (pola XX, X25519, AES-GCM, SHA-256) untuk transport WhatsApp Web.
+ * Ditulis dari spesifikasi Noise (noiseprotocol.org), bukan salinan library lain.
+ *
+ * NoiseState      : state mesin Noise (hash, chaining key, kunci, counter)
+ * ClientHandshake : alur sisi klien (initiator)
+ */
+const {
+  EMPTY, generateKeyPair, sharedKey, sha256, hkdf, aesGcmEncrypt, aesGcmDecrypt
+} = require('../utils/crypto')
+const { encodeClientHello, encodeClientFinish, decodeServerHello } = require('../proto/handshake')
+
+// Nama protokol, dipad nol sampai 32 byte (panjang hash SHA-256)
+const NOISE_MODE = Buffer.from('Noise_XX_25519_AESGCM_SHA256\0\0\0\0')
+// 'W','A', versi magic, versi dictionary. PERLU diverifikasi ke versi WA Web terbaru.
+const WA_HEADER = Buffer.from([0x57, 0x41, 6, 3])
+// IV AES-GCM memakai counter 32 bit; lewat ini nonce akan berulang (fatal), jadi berhenti.
+const MAX_COUNTER = 0xffffffff
+
+class NoiseState {
+  constructor(header) {
+    this.hash = NOISE_MODE.length === 32 ? NOISE_MODE : sha256(NOISE_MODE)
+    this.salt = this.hash // chaining key
+    this.encKey = this.hash
+    this.decKey = this.hash
+    this.readCounter = 0
+    this.writeCounter = 0
+    this.finished = false
+    this.authenticate(header)
+  }
+
+  /** hash = SHA256(hash || data). Tidak dilakukan setelah handshake selesai. */
+  authenticate(data) {
+    if (!this.finished) this.hash = sha256(Buffer.concat([this.hash, data]))
+  }
+
+  _iv(counter) {
+    const iv = Buffer.alloc(12)
+    iv.writeUInt32BE(counter, 8)
+    return iv
+  }
+
+  encrypt(plaintext) {
+    if (this.writeCounter >= MAX_COUNTER) throw new Error('noise: counter tulis habis, koneksi harus dibuat ulang')
+    const aad = this.finished ? EMPTY : this.hash
+    const out = aesGcmEncrypt(this.encKey, this._iv(this.writeCounter++), plaintext, aad)
+    this.authenticate(out)
+    return out
+  }
+
+  decrypt(ciphertext) {
+    if (this.readCounter >= MAX_COUNTER) throw new Error('noise: counter baca habis, koneksi harus dibuat ulang')
+    const aad = this.finished ? EMPTY : this.hash
+    const out = aesGcmDecrypt(this.decKey, this._iv(this.readCounter++), ciphertext, aad)
+    this.authenticate(ciphertext)
+    return out
+  }
+
+  /** MixKey: (ck, k) = HKDF(ck, input). Counter di-reset. */
+  mixIntoKey(data) {
+    const out = hkdf(data, 64, this.salt)
+    this.salt = out.subarray(0, 32)
+    this.encKey = this.decKey = out.subarray(32)
+    this.readCounter = this.writeCounter = 0
+  }
+
+  /** Split: turunkan kunci transport akhir. */
+  finish(isInitiator) {
+    const out = hkdf(EMPTY, 64, this.salt)
+    const a = out.subarray(0, 32), b = out.subarray(32)
+    this.encKey = isInitiator ? a : b
+    this.decKey = isInitiator ? b : a
+    this.hash = EMPTY
+    this.readCounter = this.writeCounter = 0
+    this.finished = true
+  }
+}
+
+class ClientHandshake {
+  /**
+   * @param {{ staticKey: {public:Buffer, private:Buffer}, ephemeralKey?: object, header?: Buffer }} opts
+   */
+  constructor({ staticKey, ephemeralKey = generateKeyPair(), header = WA_HEADER, verifyServerCertificate, requireServerCertificateVerification = false }) {
+    this.staticKey = staticKey
+    this.verifyServerCertificate = verifyServerCertificate
+    this.requireServerCertificateVerification = requireServerCertificateVerification
+    this.serverCertificateVerified = false
+    this.ephemeralKey = ephemeralKey
+    this.noise = new NoiseState(header)
+    this.noise.authenticate(ephemeralKey.public)
+    this.serverStatic = null
+    this.serverCertificate = null
+  }
+
+  /** Pesan pertama (ClientHello), sudah di-encode protobuf. */
+  hello() {
+    return encodeClientHello(this.ephemeralKey.public)
+  }
+
+  /**
+   * Proses ServerHello, kembalikan ClientFinish (protobuf).
+   * Verifikasi sertifikat dipasok oleh verifier yang menggunakan root/intermediate key
+   * resmi yang dipin dan test vector independen. Tidak ada verifier bawaan yang diklaim.
+   * @param {Buffer} data  isi frame ServerHello
+   * @param {Buffer} clientPayload  ClientPayload (login/registrasi), sudah di-encode protobuf
+   */
+  processServerHello(data, clientPayload) {
+    const n = this.noise
+    const sh = decodeServerHello(data)
+
+    n.authenticate(sh.ephemeral)
+    n.mixIntoKey(sharedKey(this.ephemeralKey.private, sh.ephemeral))
+
+    this.serverStatic = n.decrypt(sh.static)
+    n.mixIntoKey(sharedKey(this.ephemeralKey.private, this.serverStatic))
+
+    this.serverCertificate = n.decrypt(sh.payload)
+    if (typeof this.verifyServerCertificate === 'function') {
+      const verified = this.verifyServerCertificate(this.serverCertificate, {
+        serverStatic: Buffer.from(this.serverStatic),
+        header: Buffer.from(WA_HEADER)
+      })
+      if (verified !== true) {
+        const error = new Error('Noise: sertifikat server ditolak oleh verifier')
+        error.code = 'ERR_NOISE_CERTIFICATE_REJECTED'
+        throw error
+      }
+      this.serverCertificateVerified = true
+    } else if (this.requireServerCertificateVerification) {
+      const error = new Error('Noise: koneksi ditolak karena verifier sertifikat server belum dikonfigurasi')
+      error.code = 'ERR_NOISE_CERTIFICATE_VERIFIER_MISSING'
+      throw error
+    }
+
+    const encStatic = n.encrypt(this.staticKey.public)
+    n.mixIntoKey(sharedKey(this.staticKey.private, sh.ephemeral))
+
+    const encPayload = n.encrypt(clientPayload)
+    n.finish(true)
+
+    return encodeClientFinish({ static: encStatic, payload: encPayload })
+  }
+}
+
+module.exports = { NoiseState, ClientHandshake, WA_HEADER, NOISE_MODE, MAX_COUNTER }

package/src/socket/transport.js

@@ -0,0 +1,39 @@
+'use strict'
+/**
+ * Adapter WebSocket. Memakai paket `ws` bila terpasang (bisa set header Origin,
+ * disarankan untuk WhatsApp), jika tidak jatuh ke WebSocket bawaan Node.
+ * Event yang dipancarkan: open, message(Buffer), close(code, reason), transport.error(err)
+ */
+const { EventEmitter } = require('node:events')
+
+function createTransport(url, { origin, headers } = {}) {
+  const t = new EventEmitter()
+  let WS = null
+  try { WS = require('ws') } catch { /* opsional */ }
+
+  if (WS) {
+    const ws = new WS(url, { origin, headers, handshakeTimeout: 20000 })
+    ws.on('open', () => t.emit('open'))
+    ws.on('message', (d) => t.emit('message', Buffer.isBuffer(d) ? d : Buffer.from(d)))
+    ws.on('close', (code, reason) => t.emit('close', code, String(reason || '')))
+    ws.on('error', (err) => t.emit('transport.error', err))
+    t.send = (buf) => ws.send(buf)
+    t.close = () => ws.close()
+    return t
+  }
+
+  if (typeof WebSocket === 'undefined') {
+    throw new Error('WebSocket tidak tersedia. Pakai Node >= 22 atau jalankan: npm i ws')
+  }
+  const ws = new WebSocket(url)
+  ws.binaryType = 'arraybuffer'
+  ws.onopen = () => t.emit('open')
+  ws.onmessage = (e) => t.emit('message', Buffer.from(e.data))
+  ws.onclose = (e) => t.emit('close', e.code, e.reason)
+  ws.onerror = (e) => t.emit('transport.error', e.error || new Error('WebSocket error'))
+  t.send = (buf) => ws.send(buf)
+  t.close = () => ws.close()
+  return t
+}
+
+module.exports = { createTransport }

package/src/utils/crypto.js

@@ -0,0 +1,52 @@
+'use strict'
+/**
+ * Helper kripto kersiosocket. Hanya memakai node:crypto (tanpa dependensi).
+ * Semua fungsi bekerja langsung di atas Buffer agar hemat memori.
+ */
+const crypto = require('node:crypto')
+
+const EMPTY = Buffer.alloc(0)
+// Prefix DER untuk membungkus kunci mentah X25519 (32 byte)
+const X25519_SPKI = Buffer.from('302a300506032b656e032100', 'hex')
+const X25519_PKCS8 = Buffer.from('302e020100300506032b656e04220420', 'hex')
+
+/** Buat pasangan kunci Curve25519 mentah (32 byte masing-masing). */
+function generateKeyPair() {
+  const { publicKey, privateKey } = crypto.generateKeyPairSync('x25519')
+  return {
+    public: publicKey.export({ type: 'spki', format: 'der' }).subarray(X25519_SPKI.length),
+    private: privateKey.export({ type: 'pkcs8', format: 'der' }).subarray(X25519_PKCS8.length)
+  }
+}
+
+/** Diffie-Hellman X25519: rahasia bersama dari kunci privat sendiri + publik lawan. */
+function sharedKey(privateKey, publicKey) {
+  const priv = crypto.createPrivateKey({ key: Buffer.concat([X25519_PKCS8, privateKey]), format: 'der', type: 'pkcs8' })
+  const pub = crypto.createPublicKey({ key: Buffer.concat([X25519_SPKI, publicKey]), format: 'der', type: 'spki' })
+  return crypto.diffieHellman({ privateKey: priv, publicKey: pub })
+}
+
+function sha256(data) {
+  return crypto.createHash('sha256').update(data).digest()
+}
+
+function hkdf(ikm, length, salt, info = EMPTY) {
+  return Buffer.from(crypto.hkdfSync('sha256', ikm, salt, info, length))
+}
+
+/** AES-256-GCM. Hasil = ciphertext || tag(16). */
+function aesGcmEncrypt(key, iv, plaintext, aad = EMPTY) {
+  const c = crypto.createCipheriv('aes-256-gcm', key, iv)
+  c.setAAD(aad)
+  return Buffer.concat([c.update(plaintext), c.final(), c.getAuthTag()])
+}
+
+function aesGcmDecrypt(key, iv, data, aad = EMPTY) {
+  if (data.length < 16) throw new Error('ciphertext terlalu pendek')
+  const d = crypto.createDecipheriv('aes-256-gcm', key, iv)
+  d.setAAD(aad)
+  d.setAuthTag(data.subarray(data.length - 16))
+  return Buffer.concat([d.update(data.subarray(0, data.length - 16)), d.final()])
+}
+
+module.exports = { EMPTY, generateKeyPair, sharedKey, sha256, hkdf, aesGcmEncrypt, aesGcmDecrypt }

package/src/utils/latency.js

@@ -0,0 +1,32 @@
+'use strict'
+/** Pelacak latensi ringan: ring buffer Float64Array tetap (tanpa alokasi per sampel). */
+class LatencyTracker {
+  constructor(size = 256) {
+    this.buf = new Float64Array(size)
+    this.n = 0
+    this.i = 0
+    this.max = 0
+  }
+
+  /** Mulai ukur; kembalikan fungsi yang mencatat selisih (ms) saat dipanggil. */
+  start() {
+    const t0 = process.hrtime.bigint()
+    return () => this.add(Number(process.hrtime.bigint() - t0) / 1e6)
+  }
+
+  add(ms) {
+    this.buf[this.i] = ms
+    this.i = (this.i + 1) % this.buf.length
+    if (this.n < this.buf.length) this.n++
+    if (ms > this.max) this.max = ms
+  }
+
+  summary() {
+    if (!this.n) return { count: 0, p50: 0, p95: 0, max: 0 }
+    const a = Array.from(this.buf.subarray(0, this.n)).sort((x, y) => x - y)
+    const q = (p) => +a[Math.min(a.length - 1, Math.floor(p * a.length))].toFixed(3)
+    return { count: this.n, p50: q(0.5), p95: q(0.95), max: +this.max.toFixed(3) }
+  }
+}
+
+module.exports = { LatencyTracker }

package/src/utils/lru.js

@@ -0,0 +1,76 @@
+'use strict'
+/**
+ * Cache LRU dengan batas jumlah entri, batas ukuran (byte) opsional, dan TTL opsional.
+ * Memakai urutan sisip Map, jadi get/set O(1) tanpa struktur tambahan.
+ *
+ * new LRUCache({ max: 1000, maxBytes: 8 * 1024 * 1024, sizeOf: (v) => v.length, ttl: 60000 })
+ */
+class LRUCache {
+  constructor({ max = 500, maxBytes = Infinity, sizeOf = null, ttl = 0, onEvict = null } = {}) {
+    if (!(max > 0)) throw new Error('LRUCache: max harus > 0')
+    this.max = max
+    this.maxBytes = maxBytes
+    this.sizeOf = sizeOf
+    this.ttl = ttl
+    this.onEvict = onEvict
+    this.map = new Map() // key -> { v, size, exp }
+    this.bytes = 0
+    this.hits = 0
+    this.misses = 0
+  }
+
+  get size() { return this.map.size }
+
+  get(key) {
+    const e = this.map.get(key)
+    if (!e) { this.misses++; return undefined }
+    if (e.exp && e.exp <= Date.now()) { this._drop(key, e, 'expired'); this.misses++; return undefined }
+    this.map.delete(key)
+    this.map.set(key, e) // pindah ke ujung = paling baru dipakai
+    this.hits++
+    return e.v
+  }
+
+  has(key) {
+    const e = this.map.get(key)
+    if (!e) return false
+    if (e.exp && e.exp <= Date.now()) { this._drop(key, e, 'expired'); return false }
+    return true
+  }
+
+  set(key, v) {
+    const old = this.map.get(key)
+    if (old) { this.bytes -= old.size; this.map.delete(key) }
+    const size = this.sizeOf ? this.sizeOf(v) : 0
+    this.map.set(key, { v, size, exp: this.ttl ? Date.now() + this.ttl : 0 })
+    this.bytes += size
+    while (this.map.size > this.max || this.bytes > this.maxBytes) {
+      const [k, e] = this.map.entries().next().value
+      if (k === key && this.map.size === 1) break // satu entri raksasa tetap disimpan
+      this._drop(k, e, 'evicted')
+    }
+    return this
+  }
+
+  delete(key) {
+    const e = this.map.get(key)
+    if (!e) return false
+    this.bytes -= e.size
+    return this.map.delete(key)
+  }
+
+  clear() { this.map.clear(); this.bytes = 0 }
+
+  _drop(key, e, reason) {
+    this.map.delete(key)
+    this.bytes -= e.size
+    if (this.onEvict) this.onEvict(key, e.v, reason)
+  }
+
+  stats() {
+    const n = this.hits + this.misses
+    return { size: this.map.size, bytes: this.bytes, hits: this.hits, misses: this.misses, hitRate: n ? +(this.hits / n).toFixed(3) : 0 }
+  }
+}
+
+module.exports = { LRUCache }