@peers-app/peers-sdk 0.27.3 → 0.27.4

package/dist/device/connection.test.js

@@ -1,613 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const nacl = require("tweetnacl");
-const keys_1 = require("../keys");
-const utils_1 = require("../utils");
-const binary_peer_connection_v2_1 = require("./binary-peer-connection-v2");
-const connection_1 = require("./connection");
-const device_1 = require("./device");
-const frame_cipher_1 = require("./frame-cipher");
-const socket_type_1 = require("./socket.type");
-function createTestSocket(localHandlers, remoteHandlers) {
-    const socket = {
-        id: (0, utils_1.newid)(),
-        emit(eventName, args, callback) {
-            const matching = remoteHandlers.filter(({ eventName: _eventName }) => eventName === _eventName);
-            if (matching.length === 0) {
-                // Same answer the real transports give for an event nobody handles.
-                callback?.(`No handler registered for event: ${eventName}`);
-                return;
-            }
-            matching.forEach(async ({ handler }) => {
-                handler(args, callback);
-            });
-        },
-        on(eventName, handler) {
-            localHandlers.push({
-                eventName,
-                handler: async (...args) => handler(...args),
-            });
-        },
-        removeAllListeners(eventName) {
-            while (localHandlers.find(({ eventName: _eventName }) => eventName === _eventName)) {
-                const index = localHandlers.findIndex(({ eventName: _eventName }) => eventName === _eventName);
-                localHandlers.splice(index, 1);
-            }
-        },
-        disconnect() {
-            // Simulate disconnection logic if needed
-        },
-    };
-    return socket;
-}
-function createTestSocketPair() {
-    const clientHandlers = [];
-    const serverHandlers = [];
-    const clientSocket = createTestSocket(clientHandlers, serverHandlers);
-    const serverSocket = createTestSocket(serverHandlers, clientHandlers);
-    const connectionId = (0, utils_1.newid)();
-    clientSocket.id = connectionId;
-    serverSocket.id = connectionId;
-    return {
-        clientSocket,
-        serverSocket,
-    };
-}
-describe(connection_1.Connection, () => {
-    it("should allow simulating a client and server connection handshake", async () => {
-        const { clientSocket, serverSocket } = createTestSocketPair();
-        const clientDevice = new device_1.Device(undefined, undefined, undefined, {
-            userName: "Client user",
-            deviceName: "Client laptop",
-        });
-        const serverDevice = new device_1.Device(undefined, undefined, undefined, {
-            userName: "Server user",
-            deviceName: "Server desktop",
-        });
-        const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
-        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ["localhost"]);
-        expect(clientConnection.connectionId).toBe(serverConnection.connectionId);
-        const response = await clientConnection.doHandshake("localhost");
-        expect(response.userId).toBe(serverDevice.userId);
-        expect(response.deviceId).toBe(serverDevice.deviceId);
-        expect(response.publicKey).toBe(serverDevice.publicKey);
-        expect(response.publicBoxKey).toBe(serverDevice.publicBoxKey);
-        expect(response.serverAddress).toBe("localhost");
-        expect(response.connectionId).toBe(serverConnection.connectionId);
-        expect(response.userName).toBe("Server user");
-        expect(response.deviceName).toBe("Server desktop");
-        expect(clientConnection.remoteDeviceInfo).toMatchObject({
-            userName: "Server user",
-            deviceName: "Server desktop",
-        });
-        expect(serverConnection.remoteDeviceInfo).toMatchObject({
-            userName: "Client user",
-            deviceName: "Client laptop",
-        });
-        serverConnection.removeAllListeners("ping");
-        serverConnection.exposeRPC("ping", async (n, s) => `pong - ${n}, ${s}`);
-        const pong = await clientConnection.emit("ping", 1, "hello");
-        expect(pong).toBe("pong - 1, hello");
-    });
-    it("should create a new id if socket doesn't have one", async () => {
-        const socket = {
-            id: (0, utils_1.newid)(),
-            emit(_eventName, _args, _callback) {
-                // do nothing
-            },
-            on(_eventName, _handler) {
-                // do nothing
-            },
-            removeAllListeners(_eventName) {
-                // do nothing
-            },
-            disconnect() {
-                // do nothing
-            },
-        };
-        const connection = new connection_1.Connection(socket, new device_1.Device());
-        expect(connection.connectionId).toBeTruthy();
-    });
-    it("client should requestSecure if both are using https", async () => {
-        const { clientSocket, serverSocket } = createTestSocketPair();
-        const clientDevice = new device_1.Device();
-        const serverDevice = new device_1.Device();
-        const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
-        const _serverConnection = new connection_1.Connection(serverSocket, serverDevice, ["https://localhost"]);
-        await clientConnection.doHandshake("https://localhost");
-        expect(clientConnection.encryptTraffic).toBe(false);
-        // and allow forcing insecure
-        clientConnection.overrideEncryption = "encrypt-traffic-regardless-of-protocol";
-        expect(clientConnection.encryptTraffic).toBe(true);
-        // and only return a copy of the remoteDeviceInfo
-        expect(clientConnection.remoteDeviceInfo).not.toBe(clientConnection.remoteDeviceInfo);
-    });
-    it("should gracefully handle remote errors for secure connections", async () => {
-        const { clientSocket, serverSocket } = createTestSocketPair();
-        const clientDevice = new device_1.Device();
-        const serverDevice = new device_1.Device();
-        const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
-        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ["https://localhost"]);
-        await clientConnection.doHandshake("https://localhost");
-        expect(clientConnection.encryptTraffic).toBe(false);
-        expect(serverConnection.encryptTraffic).toBe(false);
-        serverConnection.removeAllListeners("ping");
-        serverConnection.exposeRPC("ping", async () => {
-            throw new Error("fake error");
-        });
-        const response = await clientConnection.emit("ping").catch((err) => err);
-        expect(response).toEqual({
-            errorType: "RPC_ERROR",
-            error: "fake error",
-        });
-    });
-    it("should gracefully handle remote errors for unsecure connections", async () => {
-        const { clientSocket, serverSocket } = createTestSocketPair();
-        const clientDevice = new device_1.Device();
-        const serverDevice = new device_1.Device();
-        const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
-        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ["http://localhost"]);
-        await clientConnection.doHandshake("http://localhost");
-        expect(clientConnection.encryptTraffic).toBe(true);
-        expect(serverConnection.encryptTraffic).toBe(true);
-        serverConnection.removeAllListeners("ping");
-        serverConnection.exposeRPC("ping", async () => {
-            throw new Error("fake error");
-        });
-        const response = await clientConnection.emit("ping").catch((err) => err);
-        expect(response).toEqual({
-            errorType: "RPC_ERROR",
-            error: "fake error",
-        });
-    });
-    it("should ignore other events before the handshake is finished", async () => {
-        const { clientSocket, serverSocket } = createTestSocketPair();
-        const clientDevice = new device_1.Device();
-        const serverDevice = new device_1.Device();
-        const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
-        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ["https://localhost"]);
-        serverConnection.exposeRPC("ping", async () => "pong");
-        expect(serverConnection.verified).toBe(false);
-        expect(clientConnection.verified).toBe(false);
-        const response = await clientConnection.emit("ping").catch((err) => err);
-        expect(response).toMatch(/Connection not verified/);
-    });
-    it("client should detect different connection ids during handshake", async () => {
-        const serverAddress = "http://localhost";
-        const { clientSocket, serverSocket } = createTestSocketPair();
-        const clientDevice = new device_1.Device();
-        const serverDevice = new device_1.Device();
-        const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
-        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, [serverAddress]);
-        serverConnection.exposeRPC("ping", async () => "pong");
-        serverConnection.socket.removeAllListeners("completeHandshake");
-        serverConnection.exposeRPC("completeHandshake", async (handshakeBox) => {
-            const handshake = await serverConnection.completeHandshake(handshakeBox);
-            handshake.connectionId = "fake";
-            return handshake;
-        });
-        const result = await clientConnection.doHandshake(serverAddress).catch((err) => String(err));
-        expect(result).toMatch(/Invalid connectionId/);
-    });
-    it("client should detect different device ids during handshake", async () => {
-        const serverAddress = "http://localhost";
-        const { clientSocket, serverSocket } = createTestSocketPair();
-        const clientDevice = new device_1.Device();
-        const serverDevice = new device_1.Device();
-        const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
-        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, [serverAddress]);
-        serverConnection.exposeRPC("ping", async () => "pong");
-        serverConnection.socket.removeAllListeners("completeHandshake");
-        serverConnection.exposeRPC("completeHandshake", async (handshakeBox) => {
-            const handshake = await serverConnection.completeHandshake(handshakeBox);
-            handshake.deviceId = (0, utils_1.newid)();
-            return handshake;
-        });
-        const result = await clientConnection.doHandshake(serverAddress).catch((err) => String(err));
-        expect(result).toMatch(/Inconsistent device info/);
-    });
-    it("client should detect different device ids during handshake", async () => {
-        const serverAddress = "http://localhost";
-        const { clientSocket, serverSocket } = createTestSocketPair();
-        const clientDevice = new device_1.Device();
-        const serverDevice = new device_1.Device();
-        const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
-        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, [serverAddress]);
-        serverConnection.exposeRPC("ping", async () => "pong");
-        serverConnection.socket.removeAllListeners("completeHandshake");
-        serverConnection.exposeRPC("completeHandshake", async (handshakeBox) => {
-            const handshake = await serverConnection.completeHandshake(handshakeBox);
-            handshake.userId = (0, utils_1.newid)();
-            return handshake;
-        });
-        const result = await clientConnection.doHandshake(serverAddress).catch((err) => String(err));
-        expect(result).toMatch(/Inconsistent device info/);
-    });
-    it("client should detect different box key during handshake", async () => {
-        const serverAddress = "http://localhost";
-        const { clientSocket, serverSocket } = createTestSocketPair();
-        const clientDevice = new device_1.Device();
-        const serverDevice = new device_1.Device();
-        const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
-        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, [serverAddress]);
-        serverConnection.exposeRPC("ping", async () => "pong");
-        serverConnection.socket.removeAllListeners("completeHandshake");
-        serverConnection.exposeRPC("completeHandshake", async (handshakeBox) => {
-            const handshake = await serverConnection.completeHandshake(handshakeBox);
-            const _keys = (0, keys_1.newKeys)();
-            handshake.publicBoxKey = _keys.publicBoxKey;
-            return handshake;
-        });
-        const result = await clientConnection.doHandshake(serverAddress).catch((err) => String(err));
-        expect(result).toMatch(/Inconsistent public keys/);
-    });
-    it("client should detect different public key during handshake", async () => {
-        const serverAddress = "http://localhost";
-        const { clientSocket, serverSocket } = createTestSocketPair();
-        const clientDevice = new device_1.Device();
-        const serverDevice = new device_1.Device();
-        const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
-        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, [serverAddress]);
-        serverConnection.exposeRPC("ping", async () => "pong");
-        serverConnection.socket.removeAllListeners("completeHandshake");
-        serverConnection.exposeRPC("completeHandshake", async (handshakeBox) => {
-            const handshake = await serverConnection.completeHandshake(handshakeBox);
-            const _keys = (0, keys_1.newKeys)();
-            handshake.publicKey = _keys.publicKey;
-            return handshake;
-        });
-        const result = await clientConnection.doHandshake(serverAddress).catch((err) => String(err));
-        expect(result).toMatch(/Inconsistent public keys/);
-    });
-    it("refuses an untrusted client without leaving an unhandled rejection behind", async () => {
-        // The server tells the client to reset as a courtesy. A client that is not itself a
-        // server has no `reset` handler, so that call fails; the failure must not escape as an
-        // unhandled rejection, which would take down a host with no process-level handler
-        // (peers-services) every time a device presents a retired key.
-        const serverAddress = "http://localhost";
-        const { clientSocket, serverSocket } = createTestSocketPair();
-        const clientConnection = new connection_1.Connection(clientSocket, new device_1.Device());
-        const serverConnection = new connection_1.Connection(serverSocket, new device_1.Device(), [serverAddress], () => Promise.resolve(socket_type_1.TrustLevel.Untrusted));
-        const unhandled = jest.fn();
-        process.on("unhandledRejection", unhandled);
-        try {
-            const result = await clientConnection
-                .doHandshake(serverAddress)
-                .catch((err) => err?.error ?? String(err));
-            expect(result).toMatch(/Untrusted connection/);
-            await (0, utils_1.sleep)(20);
-            expect(unhandled).not.toHaveBeenCalled();
-            expect(serverConnection.verified).toBe(false);
-        }
-        finally {
-            process.off("unhandledRejection", unhandled);
-        }
-    });
-    it("should handle RPC calls with large arguments and responses", async () => {
-        const { clientSocket, serverSocket } = createTestSocketPair();
-        const clientDevice = new device_1.Device();
-        const serverDevice = new device_1.Device();
-        const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
-        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ["localhost"]);
-        await clientConnection.doHandshake("localhost");
-        // Create large data
-        const largeData = {
-            message: "A".repeat(500),
-            metadata: "B".repeat(300),
-            payload: "C".repeat(400),
-        };
-        serverConnection.exposeRPC("processLargeData", async (data) => {
-            return {
-                received: data,
-                processedSize: JSON.stringify(data).length,
-            };
-        });
-        const result = await clientConnection.emit("processLargeData", largeData);
-        expect(result.received.message).toBe("A".repeat(500));
-        expect(result.received.metadata).toBe("B".repeat(300));
-        expect(result.received.payload).toBe("C".repeat(400));
-        expect(result.processedSize).toBe(JSON.stringify(largeData).length);
-    });
-    it("should reject handshake if device timestamps are too far apart", async () => {
-        const { clientSocket, serverSocket } = createTestSocketPair();
-        const clientDevice = new device_1.Device();
-        const serverDevice = new device_1.Device();
-        const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
-        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ["localhost"]);
-        // Set a very strict timestamp tolerance (1 second) to make test reliable
-        serverConnection.handshakeTimestampToleranceMs = 1000;
-        // Mock the client device to send an old timestamp
-        const originalGetHandshake = clientDevice.getHandshake.bind(clientDevice);
-        clientDevice.getHandshake = (connectionId, serverAddress) => {
-            const handshake = originalGetHandshake(connectionId, serverAddress);
-            return clientDevice.signObjectWithSecretKey({
-                ...handshake.contents,
-                // Make timestamp 2 seconds in the past (beyond tolerance)
-                timestamp: Date.now() - 2000,
-            });
-        };
-        const result = await clientConnection
-            .doHandshake("localhost")
-            .catch((err) => err.message || err.error || String(err));
-        expect(result).toMatch(/Remote device's system clock is too far out of sync/);
-    });
-    it.todo("should handle RPC calls that return undefined");
-    // ─── Security: key confusion attack ────────────────────────────────────────
-    //
-    // openSignedObject verifies the signature using signedObj.publicKey (the
-    // envelope key — the ACTUAL signer). Identity is then recorded from
-    // contents.publicKey (the CLAIMED key). There is no check that these match.
-    //
-    // A malicious peer can sign a handshake with their real key KA while
-    // claiming victim's publicKey KV in the payload contents. The signature
-    // check passes, but the server registers KV as the connected identity.
-    //
-    // Fix: after openSignedObject succeeds, assert
-    //   signedHandshake.publicKey === signedHandshake.contents.publicKey
-    //
-    describe("Security: key confusion — signing key vs claimed identity key", () => {
-        it("rejects handshake where signing key (KA) differs from claimed identity key in contents (KV)", async () => {
-            const serverAddress = "http://localhost";
-            const { clientSocket, serverSocket } = createTestSocketPair();
-            const attackerDevice = new device_1.Device();
-            const victimDevice = new device_1.Device(); // identity the attacker wants to impersonate
-            const serverDevice = new device_1.Device();
-            const attackerConnection = new connection_1.Connection(clientSocket, attackerDevice);
-            const serverConnection = new connection_1.Connection(serverSocket, serverDevice, [serverAddress]);
-            // Craft a malicious handshake:
-            //   signedObj.publicKey  = KA  (attacker's real signing key — used for verification)
-            //   contents.publicKey   = KV  (victim's signing key   — recorded as identity)
-            //   contents.userId      = victim's userId
-            //   contents.publicBoxKey = KA_box  (attacker's box key, kept so the server
-            //                                    boxes its response for the attacker and
-            //                                    the attacker can decrypt it to finish the
-            //                                    handshake — making the whole flow succeed)
-            const originalGetHandshake = attackerDevice.getHandshake.bind(attackerDevice);
-            attackerDevice.getHandshake = (connectionId, addr) => {
-                const real = originalGetHandshake(connectionId, addr);
-                const maliciousContents = {
-                    ...real.contents, // keep connectionId, timestamp, serverAddress
-                    userId: victimDevice.userId, // claim victim's userId
-                    publicKey: victimDevice.publicKey, // claim victim's Ed25519 key (KV)
-                    // publicBoxKey stays as attacker's own box key (KA_box) so the server
-                    // encrypts its handshake response for a key the attacker can open
-                };
-                // Sign with attacker's secret key:
-                //   signedObj.publicKey = KA   (actual signer)
-                //   contents.publicKey  = KV   (claimed identity) — DIFFERENT
-                return attackerDevice.signObjectWithSecretKey(maliciousContents);
-            };
-            // The server must reject this — the signing key (KA) does not match the
-            // claimed identity key in the payload contents (KV).
-            // Server-side errors travel back through the RPC layer as plain objects
-            // { error: '...', errorType: 'RPC_ERROR' } rather than Error instances.
-            const result = await attackerConnection.doHandshake(serverAddress).catch((err) => err);
-            const errorMessage = result instanceof Error ? result.message : (result?.error ?? String(result));
-            expect(errorMessage).toMatch(/signing key does not match claimed identity key/i);
-            // Neither side should be left in a verified state
-            expect(attackerConnection.verified).toBe(false);
-            expect(serverConnection.verified).toBe(false);
-        });
-    });
-    // ─── Frame cipher ──────────────────────────────────────────────────────────
-    //
-    // These run over real binary peer sockets (the production framing) so the
-    // handshake actually arms the cipher and the wire can be inspected.
-    describe("frame cipher", () => {
-        class TapPeer {
-            other;
-            sent = [];
-            destroyed = false;
-            dataHandlers = [];
-            closeHandlers = [];
-            on(event, handler) {
-                if (event === "data")
-                    this.dataHandlers.push(handler);
-                if (event === "close")
-                    this.closeHandlers.push(handler);
-            }
-            send(data) {
-                const bytes = Buffer.from(data);
-                this.sent.push(bytes);
-                const target = this.other;
-                if (target) {
-                    setImmediate(() => {
-                        for (const h of target.dataHandlers)
-                            h(bytes);
-                    });
-                }
-            }
-            destroy() {
-                this.destroyed = true;
-                for (const h of this.closeHandlers)
-                    h();
-            }
-        }
-        function pair(protocol, opts = {}) {
-            const clientPeer = new TapPeer();
-            const serverPeer = new TapPeer();
-            clientPeer.other = serverPeer;
-            serverPeer.other = clientPeer;
-            const connectionId = (0, utils_1.newid)();
-            const userId = (0, utils_1.newid)();
-            const clientDevice = new device_1.Device(userId, (0, utils_1.newid)(), (0, keys_1.newKeys)());
-            const serverDevice = new device_1.Device(userId, (0, utils_1.newid)(), (0, keys_1.newKeys)());
-            const client = (0, binary_peer_connection_v2_1.wrapBinaryPeer)(connectionId, clientPeer, clientDevice, true, { protocol });
-            const server = (0, binary_peer_connection_v2_1.wrapBinaryPeer)(connectionId, serverPeer, serverDevice, false, { protocol });
-            // A "legacy" peer is one whose socket cannot arm a cipher, so it never advertises frameCrypto.
-            if (opts.legacyClient)
-                delete client.socket.armFrameCipher;
-            if (opts.legacyServer)
-                delete server.socket.armFrameCipher;
-            return {
-                clientPeer,
-                serverPeer,
-                client,
-                server,
-                clientDevice,
-                serverDevice,
-                address: `${protocol}://${connectionId}`,
-            };
-        }
-        function wire(...peers) {
-            return peers.flatMap((p) => p.sent);
-        }
-        for (const protocol of ["ws", "wrtc"]) {
-            it(`arms both sides after the handshake on ${protocol} and stops boxing RPC`, async () => {
-                const { client, server, clientDevice, serverDevice, clientPeer, serverPeer, address } = pair(protocol);
-                const clientBox = jest.spyOn(clientDevice, "signAndBoxDataForDevice");
-                const serverBox = jest.spyOn(serverDevice, "signAndBoxDataForDevice");
-                const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
-                try {
-                    await client.doHandshake(address);
-                    expect(client.frameCipherArmed).toBe(true);
-                    expect(server.frameCipherArmed).toBe(true);
-                    expect(client.verified).toBe(true);
-                    expect(server.verified).toBe(true);
-                    expect(client.encryptTraffic).toBe(false);
-                    expect(server.encryptTraffic).toBe(false);
-                    expect(warn).not.toHaveBeenCalledWith(expect.stringContaining("does not support frame encryption"), expect.anything());
-                    // The only box+sign so far is the server's handshake response.
-                    expect(serverBox).toHaveBeenCalledTimes(1);
-                    expect(clientBox).toHaveBeenCalledTimes(0);
-                    // Application RPC: no envelope, but sealed on the wire.
-                    const marker = `marker-${(0, utils_1.newid)()}`;
-                    server.exposeRPC("echo", async (s) => `${s}!`);
-                    const clientBefore = clientPeer.sent.length;
-                    const serverBefore = serverPeer.sent.length;
-                    expect(await client.emit("echo", marker)).toBe(`${marker}!`);
-                    expect(clientBox).toHaveBeenCalledTimes(0);
-                    expect(serverBox).toHaveBeenCalledTimes(1);
-                    const rpcFrames = [
-                        ...clientPeer.sent.slice(clientBefore),
-                        ...serverPeer.sent.slice(serverBefore),
-                    ];
-                    expect(rpcFrames.length).toBe(2);
-                    for (const frame of rpcFrames) {
-                        expect(frame[0]).toBe(frame_cipher_1.FRAME_ENC);
-                        expect(frame.indexOf(Buffer.from(marker))).toBe(-1);
-                    }
-                    // Streams: delivered and sealed.
-                    const payload = nacl.randomBytes(48);
-                    const received = new Promise((resolve) => server.socket.onRawBytes?.("s", (d) => resolve(d)));
-                    await client.socket.sendRawBytes?.("s", payload);
-                    expect(Buffer.from(await received)).toEqual(Buffer.from(payload));
-                    const last = clientPeer.sent[clientPeer.sent.length - 1];
-                    expect(last[0]).toBe(frame_cipher_1.FRAME_ENC);
-                    expect(last.indexOf(Buffer.from(payload))).toBe(-1);
-                }
-                finally {
-                    warn.mockRestore();
-                    clientPeer.destroy();
-                    serverPeer.destroy();
-                }
-            });
-        }
-        it("no longer double-encrypts over wrtc (finding 2)", async () => {
-            const { client, server, clientPeer, serverPeer, address } = pair("wrtc");
-            const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
-            try {
-                await client.doHandshake(address);
-                // Before: client {secureLocal: true, secureRemote: false}, server the
-                // reverse, encryptTraffic true on both. Now the cipher decides.
-                expect(client.encryptTraffic).toBe(false);
-                expect(server.encryptTraffic).toBe(false);
-                expect(client.frameCipherArmed).toBe(true);
-                // requestSecure is never sent when the cipher is armed.
-                const plaintextFrames = wire(clientPeer, serverPeer).filter((f) => f[0] !== frame_cipher_1.FRAME_ENC);
-                for (const frame of plaintextFrames) {
-                    expect(frame.indexOf(Buffer.from("requestSecure"))).toBe(-1);
-                }
-            }
-            finally {
-                warn.mockRestore();
-                clientPeer.destroy();
-                serverPeer.destroy();
-            }
-        });
-        it("only the handshake frames are plaintext, and the ephemeral keys are never in the clear", async () => {
-            const { client, clientPeer, serverPeer, address } = pair("ws");
-            await client.doHandshake(address);
-            const frames = wire(clientPeer, serverPeer);
-            // reset, requestDeviceInfo, completeHandshake: 3 requests + 3 replies in the clear.
-            const plaintext = frames.filter((f) => f[0] !== frame_cipher_1.FRAME_ENC);
-            expect(plaintext.length).toBe(6);
-            for (const frame of plaintext) {
-                expect(frame.indexOf(Buffer.from("ephemeralBoxKey"))).toBe(-1);
-            }
-            clientPeer.destroy();
-            serverPeer.destroy();
-        });
-        it("drops plaintext stream frames before the handshake completes", async () => {
-            const { client, server, clientPeer, serverPeer, address } = pair("ws");
-            let delivered = 0;
-            server.socket.onRawBytes?.("early", () => delivered++);
-            await client.socket.sendRawBytes?.("early", new Uint8Array([1, 2, 3]));
-            await (0, utils_1.sleep)(20);
-            expect(delivered).toBe(0);
-            expect(serverPeer.destroyed).toBe(false);
-            await client.doHandshake(address);
-            await client.socket.sendRawBytes?.("early", new Uint8Array([4]));
-            await (0, utils_1.sleep)(20);
-            expect(delivered).toBe(1);
-            clientPeer.destroy();
-            serverPeer.destroy();
-        });
-        for (const [label, opts] of [
-            ["legacy client", { legacyClient: true }],
-            ["legacy server", { legacyServer: true }],
-        ]) {
-            it(`falls back to the legacy envelope and warns against a ${label}`, async () => {
-                const { client, server, clientDevice, clientPeer, serverPeer, address } = pair("ws", opts);
-                const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
-                const clientBox = jest.spyOn(clientDevice, "signAndBoxDataForDevice");
-                try {
-                    await client.doHandshake(address);
-                    expect(client.verified).toBe(true);
-                    expect(server.verified).toBe(true);
-                    expect(client.frameCipherArmed).toBe(false);
-                    expect(server.frameCipherArmed).toBe(false);
-                    // ws://: legacy classification says encrypt per message.
-                    expect(client.encryptTraffic).toBe(true);
-                    expect(server.encryptTraffic).toBe(true);
-                    expect(warn).toHaveBeenCalledWith(expect.stringContaining("does not support frame encryption"), expect.objectContaining({ transport: "ws" }));
-                    server.exposeRPC("echo", async (s) => `${s}!`);
-                    expect(await client.emit("echo", "hi")).toBe("hi!");
-                    expect(clientBox).toHaveBeenCalled();
-                    for (const frame of wire(clientPeer, serverPeer)) {
-                        expect(frame[0]).not.toBe(frame_cipher_1.FRAME_ENC);
-                    }
-                    // Plaintext streams are delivered once the legacy handshake verified the peer.
-                    let delivered = 0;
-                    server.socket.onRawBytes?.("legacy", () => delivered++);
-                    await client.socket.sendRawBytes?.("legacy", new Uint8Array([1]));
-                    await (0, utils_1.sleep)(20);
-                    expect(delivered).toBe(1);
-                }
-                finally {
-                    warn.mockRestore();
-                    clientPeer.destroy();
-                    serverPeer.destroy();
-                }
-            });
-        }
-        it("ignores dont-encrypt-traffic-after-handshake outside NODE_ENV=test", async () => {
-            const { client, clientPeer, serverPeer, address } = pair("ws", { legacyServer: true });
-            const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
-            const previous = process.env.NODE_ENV;
-            try {
-                await client.doHandshake(address);
-                client.overrideEncryption = "dont-encrypt-traffic-after-handshake";
-                expect(client.encryptTraffic).toBe(false);
-                process.env.NODE_ENV = "production";
-                expect(client.encryptTraffic).toBe(true);
-            }
-            finally {
-                process.env.NODE_ENV = previous;
-                warn.mockRestore();
-                clientPeer.destroy();
-                serverPeer.destroy();
-            }
-        });
-    });
-});

package/dist/device/device-election.test.d.ts

@@ -1 +0,0 @@
-export {};