@wangyaoshen/remux 0.3.8-dev.29e114b

package/tests/e2ee.test.js

@@ -0,0 +1,325 @@
+/**
+ * E2EE tests for Remux.
+ * Tests X25519 key exchange + AES-256-GCM encryption layer.
+ *
+ * Design reference: Signal Protocol / Mosh E2EE (X25519 ECDH + HKDF + AES-GCM)
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  generateKeyPair,
+  deriveSharedSecret,
+  encrypt,
+  decrypt,
+  E2EESession,
+} from "../src/e2ee.js";
+
+describe("e2ee", () => {
+  // ── Key pair generation ──
+
+  describe("generateKeyPair", () => {
+    it("should return publicKey and privateKey buffers", () => {
+      const kp = generateKeyPair();
+      expect(kp).toHaveProperty("publicKey");
+      expect(kp).toHaveProperty("privateKey");
+      expect(Buffer.isBuffer(kp.publicKey)).toBe(true);
+      expect(Buffer.isBuffer(kp.privateKey)).toBe(true);
+    });
+
+    it("should generate 32-byte X25519 keys", () => {
+      const kp = generateKeyPair();
+      expect(kp.publicKey.length).toBe(32);
+      expect(kp.privateKey.length).toBe(32);
+    });
+
+    it("should generate unique key pairs each time", () => {
+      const kp1 = generateKeyPair();
+      const kp2 = generateKeyPair();
+      expect(kp1.publicKey.equals(kp2.publicKey)).toBe(false);
+      expect(kp1.privateKey.equals(kp2.privateKey)).toBe(false);
+    });
+  });
+
+  // ── Shared secret derivation ──
+
+  describe("deriveSharedSecret", () => {
+    it("should derive the same shared secret on both sides", () => {
+      const alice = generateKeyPair();
+      const bob = generateKeyPair();
+
+      const secretA = deriveSharedSecret(alice.privateKey, bob.publicKey);
+      const secretB = deriveSharedSecret(bob.privateKey, alice.publicKey);
+
+      expect(secretA.equals(secretB)).toBe(true);
+    });
+
+    it("should return a 32-byte key (256-bit AES key)", () => {
+      const alice = generateKeyPair();
+      const bob = generateKeyPair();
+      const secret = deriveSharedSecret(alice.privateKey, bob.publicKey);
+      expect(secret.length).toBe(32);
+    });
+
+    it("should produce different secrets with different peers", () => {
+      const alice = generateKeyPair();
+      const bob = generateKeyPair();
+      const carol = generateKeyPair();
+
+      const secretAB = deriveSharedSecret(alice.privateKey, bob.publicKey);
+      const secretAC = deriveSharedSecret(alice.privateKey, carol.publicKey);
+
+      expect(secretAB.equals(secretAC)).toBe(false);
+    });
+  });
+
+  // ── Encrypt / Decrypt round-trip ──
+
+  describe("encrypt / decrypt", () => {
+    it("should round-trip encrypt and decrypt", () => {
+      const alice = generateKeyPair();
+      const bob = generateKeyPair();
+      const key = deriveSharedSecret(alice.privateKey, bob.publicKey);
+
+      const plaintext = Buffer.from("hello, encrypted world!");
+      const { ciphertext, tag, iv } = encrypt(key, plaintext, 0n);
+
+      const decrypted = decrypt(key, ciphertext, tag, iv);
+      expect(decrypted.toString("utf8")).toBe("hello, encrypted world!");
+    });
+
+    it("should produce different ciphertext with different counters", () => {
+      const alice = generateKeyPair();
+      const bob = generateKeyPair();
+      const key = deriveSharedSecret(alice.privateKey, bob.publicKey);
+
+      const plaintext = Buffer.from("same message");
+      const enc1 = encrypt(key, plaintext, 0n);
+      const enc2 = encrypt(key, plaintext, 1n);
+
+      expect(enc1.ciphertext.equals(enc2.ciphertext)).toBe(false);
+      expect(enc1.iv.equals(enc2.iv)).toBe(false);
+    });
+
+    it("should produce 12-byte IV", () => {
+      const key = deriveSharedSecret(
+        generateKeyPair().privateKey,
+        generateKeyPair().publicKey,
+      );
+      const { iv } = encrypt(key, Buffer.from("test"), 0n);
+      expect(iv.length).toBe(12);
+    });
+
+    it("should produce 16-byte auth tag", () => {
+      const key = deriveSharedSecret(
+        generateKeyPair().privateKey,
+        generateKeyPair().publicKey,
+      );
+      const { tag } = encrypt(key, Buffer.from("test"), 0n);
+      expect(tag.length).toBe(16);
+    });
+
+    it("should fail to decrypt with wrong key", () => {
+      const alice = generateKeyPair();
+      const bob = generateKeyPair();
+      const carol = generateKeyPair();
+
+      const rightKey = deriveSharedSecret(alice.privateKey, bob.publicKey);
+      const wrongKey = deriveSharedSecret(alice.privateKey, carol.publicKey);
+
+      const plaintext = Buffer.from("secret data");
+      const { ciphertext, tag, iv } = encrypt(rightKey, plaintext, 0n);
+
+      expect(() => decrypt(wrongKey, ciphertext, tag, iv)).toThrow();
+    });
+
+    it("should fail to decrypt with tampered ciphertext", () => {
+      const key = deriveSharedSecret(
+        generateKeyPair().privateKey,
+        generateKeyPair().publicKey,
+      );
+
+      const plaintext = Buffer.from("untampered message");
+      const { ciphertext, tag, iv } = encrypt(key, plaintext, 0n);
+
+      // Flip a bit in the ciphertext
+      const tampered = Buffer.from(ciphertext);
+      tampered[0] ^= 0xff;
+
+      expect(() => decrypt(key, tampered, tag, iv)).toThrow();
+    });
+
+    it("should fail to decrypt with tampered auth tag", () => {
+      const key = deriveSharedSecret(
+        generateKeyPair().privateKey,
+        generateKeyPair().publicKey,
+      );
+
+      const plaintext = Buffer.from("tagged message");
+      const { ciphertext, tag, iv } = encrypt(key, plaintext, 0n);
+
+      const tamperedTag = Buffer.from(tag);
+      tamperedTag[0] ^= 0xff;
+
+      expect(() => decrypt(key, ciphertext, tamperedTag, iv)).toThrow();
+    });
+
+    it("should handle empty plaintext", () => {
+      const key = deriveSharedSecret(
+        generateKeyPair().privateKey,
+        generateKeyPair().publicKey,
+      );
+
+      const plaintext = Buffer.from("");
+      const { ciphertext, tag, iv } = encrypt(key, plaintext, 0n);
+      const decrypted = decrypt(key, ciphertext, tag, iv);
+      expect(decrypted.toString("utf8")).toBe("");
+    });
+
+    it("should handle large messages (64KB)", () => {
+      const key = deriveSharedSecret(
+        generateKeyPair().privateKey,
+        generateKeyPair().publicKey,
+      );
+
+      const plaintext = Buffer.alloc(65536, 0x42); // 64KB of 'B'
+      const { ciphertext, tag, iv } = encrypt(key, plaintext, 0n);
+      const decrypted = decrypt(key, ciphertext, tag, iv);
+      expect(decrypted.equals(plaintext)).toBe(true);
+    });
+  });
+
+  // ── E2EESession ──
+
+  describe("E2EESession", () => {
+    it("should expose a base64-encoded public key", () => {
+      const session = new E2EESession();
+      const pubKey = session.getPublicKey();
+      expect(typeof pubKey).toBe("string");
+      // Should be valid base64
+      const decoded = Buffer.from(pubKey, "base64");
+      expect(decoded.length).toBe(32);
+    });
+
+    it("should not be established before handshake", () => {
+      const session = new E2EESession();
+      expect(session.isEstablished()).toBe(false);
+    });
+
+    it("should complete handshake between two sessions", () => {
+      const client = new E2EESession();
+      const server = new E2EESession();
+
+      // Exchange public keys
+      server.completeHandshake(client.getPublicKey());
+      client.completeHandshake(server.getPublicKey());
+
+      expect(client.isEstablished()).toBe(true);
+      expect(server.isEstablished()).toBe(true);
+    });
+
+    it("should encrypt/decrypt messages after handshake", () => {
+      const client = new E2EESession();
+      const server = new E2EESession();
+
+      server.completeHandshake(client.getPublicKey());
+      client.completeHandshake(server.getPublicKey());
+
+      // Client sends to server
+      const encrypted = client.encryptMessage("hello server");
+      const decrypted = server.decryptMessage(encrypted);
+      expect(decrypted).toBe("hello server");
+
+      // Server sends to client
+      const encrypted2 = server.encryptMessage("hello client");
+      const decrypted2 = client.decryptMessage(encrypted2);
+      expect(decrypted2).toBe("hello client");
+    });
+
+    it("should handle multiple messages with incrementing counters", () => {
+      const client = new E2EESession();
+      const server = new E2EESession();
+
+      server.completeHandshake(client.getPublicKey());
+      client.completeHandshake(server.getPublicKey());
+
+      const messages = [
+        "first message",
+        "second message",
+        "third message",
+        "unicode: \u4f60\u597d\u4e16\u754c\ud83d\ude00",
+      ];
+
+      for (const msg of messages) {
+        const enc = client.encryptMessage(msg);
+        const dec = server.decryptMessage(enc);
+        expect(dec).toBe(msg);
+      }
+    });
+
+    it("should reject replayed messages (anti-replay)", () => {
+      const client = new E2EESession();
+      const server = new E2EESession();
+
+      server.completeHandshake(client.getPublicKey());
+      client.completeHandshake(server.getPublicKey());
+
+      const encrypted = client.encryptMessage("original message");
+      // First decrypt succeeds
+      server.decryptMessage(encrypted);
+      // Replay: same encrypted message should fail
+      expect(() => server.decryptMessage(encrypted)).toThrow();
+    });
+
+    it("should throw when encrypting before handshake", () => {
+      const session = new E2EESession();
+      expect(() => session.encryptMessage("test")).toThrow();
+    });
+
+    it("should throw when decrypting before handshake", () => {
+      const session = new E2EESession();
+      expect(() => session.decryptMessage("dGVzdA==")).toThrow();
+    });
+
+    it("should handle concurrent independent sessions", () => {
+      // Two separate E2EE channels that don't interfere
+      const clientA = new E2EESession();
+      const serverA = new E2EESession();
+      const clientB = new E2EESession();
+      const serverB = new E2EESession();
+
+      serverA.completeHandshake(clientA.getPublicKey());
+      clientA.completeHandshake(serverA.getPublicKey());
+
+      serverB.completeHandshake(clientB.getPublicKey());
+      clientB.completeHandshake(serverB.getPublicKey());
+
+      // Channel A messages
+      const encA = clientA.encryptMessage("channel A");
+      const decA = serverA.decryptMessage(encA);
+      expect(decA).toBe("channel A");
+
+      // Channel B messages
+      const encB = clientB.encryptMessage("channel B");
+      const decB = serverB.decryptMessage(encB);
+      expect(decB).toBe("channel B");
+
+      // Cross-channel: A's ciphertext should NOT decrypt on B
+      const encCross = clientA.encryptMessage("cross-channel test");
+      expect(() => serverB.decryptMessage(encCross)).toThrow();
+    });
+
+    it("should handle binary-like content (terminal output with control chars)", () => {
+      const client = new E2EESession();
+      const server = new E2EESession();
+
+      server.completeHandshake(client.getPublicKey());
+      client.completeHandshake(server.getPublicKey());
+
+      // Simulate terminal output with ANSI escapes
+      const terminalData = "\x1b[32mgreen text\x1b[0m\r\n$ ls -la\r\n";
+      const enc = client.encryptMessage(terminalData);
+      const dec = server.decryptMessage(enc);
+      expect(dec).toBe(terminalData);
+    });
+  });
+});

package/tests/message-buffer.test.js

@@ -0,0 +1,245 @@
+/**
+ * Tests for server-side message buffering and session recovery.
+ * Covers MessageBuffer (per-device ring buffer) and BufferRegistry (global manager).
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+
+// Will import from the source module once implemented
+import { MessageBuffer, BufferRegistry } from "../src/message-buffer.js";
+
+// ── MessageBuffer ───────────────────────────────────────────────
+
+describe("MessageBuffer", () => {
+  let buf;
+
+  beforeEach(() => {
+    buf = new MessageBuffer(5, 10_000); // 5 msgs, 10s TTL
+  });
+
+  it("push/drain round trip returns all messages", () => {
+    buf.push('{"type":"data","payload":"hello"}');
+    buf.push('{"type":"data","payload":"world"}');
+
+    const msgs = buf.drain();
+    expect(msgs).toHaveLength(2);
+    expect(msgs[0].data).toBe('{"type":"data","payload":"hello"}');
+    expect(msgs[1].data).toBe('{"type":"data","payload":"world"}');
+    // Each message has a timestamp
+    expect(typeof msgs[0].timestamp).toBe("number");
+    expect(msgs[0].timestamp).toBeGreaterThan(0);
+  });
+
+  it("drain clears the buffer", () => {
+    buf.push("a");
+    buf.push("b");
+    const first = buf.drain();
+    expect(first).toHaveLength(2);
+
+    const second = buf.drain();
+    expect(second).toHaveLength(0);
+  });
+
+  it("maxSize eviction drops oldest messages", () => {
+    // maxSize = 5
+    for (let i = 0; i < 8; i++) {
+      buf.push(`msg-${i}`);
+    }
+    const msgs = buf.drain();
+    expect(msgs).toHaveLength(5);
+    // Oldest 3 (msg-0, msg-1, msg-2) should have been evicted
+    expect(msgs[0].data).toBe("msg-3");
+    expect(msgs[4].data).toBe("msg-7");
+  });
+
+  it("maxAgeMs expiration filters old messages on drain", () => {
+    // Use fake timers to control time
+    vi.useFakeTimers();
+
+    const now = Date.now();
+    buf.push("old-msg");
+
+    // Advance time past TTL
+    vi.advanceTimersByTime(11_000); // 11s > 10s TTL
+    buf.push("new-msg");
+
+    const msgs = buf.drain();
+    expect(msgs).toHaveLength(1);
+    expect(msgs[0].data).toBe("new-msg");
+
+    vi.useRealTimers();
+  });
+
+  it("drain with since timestamp filter returns only newer messages", () => {
+    vi.useFakeTimers();
+
+    buf.push("msg-1");
+    const t1 = Date.now();
+
+    vi.advanceTimersByTime(1000);
+    buf.push("msg-2");
+
+    vi.advanceTimersByTime(1000);
+    buf.push("msg-3");
+
+    // Drain messages since t1 (should exclude msg-1 which was pushed at t1)
+    const msgs = buf.drain(t1);
+    expect(msgs).toHaveLength(2);
+    expect(msgs[0].data).toBe("msg-2");
+    expect(msgs[1].data).toBe("msg-3");
+
+    vi.useRealTimers();
+  });
+
+  it("clear empties the buffer", () => {
+    buf.push("a");
+    buf.push("b");
+    buf.push("c");
+    buf.clear();
+    expect(buf.size).toBe(0);
+    expect(buf.drain()).toHaveLength(0);
+  });
+
+  it("size is accurate", () => {
+    expect(buf.size).toBe(0);
+    buf.push("a");
+    expect(buf.size).toBe(1);
+    buf.push("b");
+    expect(buf.size).toBe(2);
+    buf.drain();
+    expect(buf.size).toBe(0);
+  });
+
+  it("size respects maxSize cap", () => {
+    // maxSize = 5
+    for (let i = 0; i < 10; i++) {
+      buf.push(`msg-${i}`);
+    }
+    expect(buf.size).toBe(5);
+  });
+
+  it("pruneExpired removes old messages", () => {
+    vi.useFakeTimers();
+
+    buf.push("old-1");
+    buf.push("old-2");
+
+    vi.advanceTimersByTime(11_000); // past TTL
+    buf.push("new-1");
+
+    buf.pruneExpired();
+    expect(buf.size).toBe(1);
+    const msgs = buf.drain();
+    expect(msgs[0].data).toBe("new-1");
+
+    vi.useRealTimers();
+  });
+
+  it("uses default maxSize and maxAgeMs when not specified", () => {
+    const defaultBuf = new MessageBuffer();
+    // Default: 1000 messages, 10 minutes
+    // Push a message and verify it works
+    defaultBuf.push("test");
+    expect(defaultBuf.size).toBe(1);
+    expect(defaultBuf.drain()).toHaveLength(1);
+  });
+});
+
+// ── BufferRegistry ──────────────────────────────────────────────
+
+describe("BufferRegistry", () => {
+  let registry;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    registry = new BufferRegistry();
+  });
+
+  afterEach(() => {
+    registry.destroy();
+    vi.useRealTimers();
+  });
+
+  it("getOrCreate creates a new buffer for unknown deviceId", () => {
+    const buf = registry.getOrCreate("device-1");
+    expect(buf).toBeInstanceOf(MessageBuffer);
+    expect(buf.size).toBe(0);
+  });
+
+  it("getOrCreate returns the same buffer for the same deviceId", () => {
+    const buf1 = registry.getOrCreate("device-1");
+    buf1.push("hello");
+    const buf2 = registry.getOrCreate("device-1");
+    expect(buf2).toBe(buf1);
+    expect(buf2.size).toBe(1);
+  });
+
+  it("getOrCreate returns different buffers for different deviceIds", () => {
+    const buf1 = registry.getOrCreate("device-1");
+    const buf2 = registry.getOrCreate("device-2");
+    expect(buf1).not.toBe(buf2);
+  });
+
+  it("remove deletes a buffer", () => {
+    const buf = registry.getOrCreate("device-1");
+    buf.push("hello");
+
+    registry.remove("device-1");
+
+    // Getting again should be a fresh buffer
+    const newBuf = registry.getOrCreate("device-1");
+    expect(newBuf.size).toBe(0);
+    expect(newBuf).not.toBe(buf);
+  });
+
+  it("remove is safe for non-existent deviceId", () => {
+    // Should not throw
+    registry.remove("nonexistent");
+  });
+
+  it("cleanup removes empty buffers with no recent activity", () => {
+    const buf = registry.getOrCreate("device-1");
+    // Buffer is empty and was created a while ago
+
+    // Advance time so the buffer looks stale
+    vi.advanceTimersByTime(120_000); // 2 minutes
+
+    // Trigger cleanup via the interval (60s interval)
+    vi.advanceTimersByTime(60_000);
+
+    // Getting again should create a new buffer
+    const newBuf = registry.getOrCreate("device-1");
+    // If cleanup removed it, this would be a fresh buffer
+    // (but if the buffer was still there, the reference would be different
+    // only if it was removed and recreated)
+    expect(newBuf.size).toBe(0);
+  });
+
+  it("cleanup preserves buffers with messages", () => {
+    const buf = registry.getOrCreate("device-1");
+    buf.push("important-message");
+
+    // Advance time and trigger cleanup
+    vi.advanceTimersByTime(120_000);
+    vi.advanceTimersByTime(60_000);
+
+    // Buffer should still exist with its message
+    const sameBuf = registry.getOrCreate("device-1");
+    expect(sameBuf).toBe(buf);
+    expect(sameBuf.size).toBe(1);
+  });
+
+  it("destroy clears all buffers and stops interval", () => {
+    registry.getOrCreate("device-1").push("msg");
+    registry.getOrCreate("device-2").push("msg");
+
+    registry.destroy();
+
+    // After destroy, getting buffers again should return fresh ones
+    // (destroy should have cleared the map)
+    const freshRegistry = new BufferRegistry();
+    const buf = freshRegistry.getOrCreate("device-1");
+    expect(buf.size).toBe(0);
+    freshRegistry.destroy();
+  });
+});