Skip to content

Computer use for the Pi coding agent — Windows apps, browsers and desktops through native UI trees, screenshots and real input.

test: cover isolated relay authentication and cleanup (LPT-1025)

alexshpunt-clanker[bot]9f51563d656c
diff --git a/test/isolated-session.test.ts b/test/isolated-session.test.ts
index 747c2e1..8603b1a 100644
--- a/test/isolated-session.test.ts
+++ b/test/isolated-session.test.ts
@@ -1,14 +1,23 @@
import { mkdir, mkdtemp, readFile, writeFile, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import path from "node:path";
-import { expect, test } from "vitest";
+import { afterEach, expect, test } from "vitest";
+import type { SessionRelayKeys } from "../src/session-relay.ts";
+
import { IsolatedSession } from "../src/isolated-session.ts";
import type { SandboxHost } from "../src/sandbox.ts";
+const roots: string[] = [];
+afterEach(async () => { await Promise.all(roots.splice(0).map(root => rm(root, { recursive: true, force: true }))); });
+
/** A host where wxc-exec answers each lifecycle phase; `failAt` makes one phase fail. Every script is recorded. */
-async function fakeHost(options: { installed?: boolean; failAt?: "provision" | "start" } = {}) {
+async function fakeHost(options: { installed?: boolean; failAt?: "provision" | "start"; failForward?: number } = {}) {
const root = await mkdtemp(path.join(tmpdir(), "pi-session-test-"));
+ roots.push(root);
const scripts: string[] = [];
+ const relayKeys: SessionRelayKeys[] = [];
+ let relayClosed = false;
+ const forwarded: number[] = [], closedForwards: number[] = [];
const phases: string[] = [];
const host: SandboxHost = {
async path(value, to) {
@@ -29,10 +38,6 @@ async function fakeHost(options: { installed?: boolean; failAt?: "provision" | "
}
return `{"result":{}}`;
}
- if (script.includes("host-reverse.ps1")) {
- await writeFile(path.join(root, "Local/PiComputerUse/sessions", /sessions\\(is-\w+)/.exec(script)![1], "ports.txt"), "1001 1002 1003 1004 4242\n");
- return "";
- }
if (script.includes("--operation exec")) { phases.push("exec"); return "5151\n"; }
return "";
},
@@ -40,9 +45,17 @@ async function fakeHost(options: { installed?: boolean; failAt?: "provision" | "
writeFile: (file, content) => writeFile(file, content),
readFile: file => readFile(file, "utf8").catch(() => ""),
remove: dir => rm(dir, { recursive: true, force: true }),
- forward: async port => ({ port: port + 10_000, close: () => {} }),
+ async reverseRelay(_workdir, keys) {
+ relayKeys.push(keys);
+ return { ports: [1001, 1002, 1003, 1004], close: async () => { relayClosed = true; } };
+ },
+ async forward(port) {
+ forwarded.push(port);
+ if (forwarded.length === options.failForward) throw new Error("Forwarding refused");
+ return { port: port + 10_000, close: () => { closedForwards.push(port); } };
+ },
};
- return { host, scripts, phases, root };
+ return { host, scripts, phases, root, relayKeys, closedForwards, relayClosed: () => relayClosed };
}
test("a session provisions, starts its driver through the reverse relay, and close removes the agent user", async () => {
@@ -52,11 +65,25 @@ test("a session provisions, starts its driver through the reverse relay, and clo
expect(session.endpoint).toMatchObject({ url: "http://127.0.0.1:11001/mcp", identityPort: 11003, domain: "windows-session" });
// The driver config inside the session points its relay at the host's session-side ports.
const config = JSON.parse(await readFile(path.join(f.root, "Users/A1/Shared/session.json"), "utf8"));
- expect(config).toMatchObject({ hostDriverPort: 1002, hostIdentityPort: 1004 });
+ expect(config).toMatchObject({ hostDriverPort: 1002, hostIdentityPort: 1004,
+ relay: { session: session.ref, key: f.relayKeys[0].sessionKey } });
+ expect(config.relay.key).not.toBe(session.endpoint?.relay?.key);
+ expect(session.endpoint?.relay).toEqual({ session: session.ref, key: f.relayKeys[0].clientKey });
+ expect(JSON.stringify(config)).not.toContain(f.relayKeys[0].clientKey);
expect(await readFile(path.join(f.root, "Users/A1/Shared/session-start.ps1"), "utf8")).toContain("--no-overlay");
await session.close();
expect(f.phases).toEqual(["provision", "start", "exec", "stop", "deprovision"]);
- expect(f.scripts.at(-1)).toContain("Stop-Process -Id 4242,5151");
+ expect(f.scripts.at(-1)).toContain("Stop-Process -Id 5151");
+ expect(f.relayClosed()).toBe(true);
+ expect(f.closedForwards).toEqual([1001, 1003]);
+});
+
+test("a failed second forward closes the first tunnel and relay before removing the session", async () => {
+ const f = await fakeHost({ failForward: 2 });
+ await expect(IsolatedSession.open(f.host, "/mnt/c/runtime/cua-driver.exe")).rejects.toBeInstanceOf(Error);
+ expect(f.closedForwards).toEqual([1001]);
+ expect(f.relayClosed()).toBe(true);
+ expect(f.phases).toEqual(["provision", "start", "exec", "stop", "deprovision"]);
});
test("a machine without MXC refuses before provisioning anything", async () => {
diff --git a/test/relay-http.test.ts b/test/relay-http.test.ts
new file mode 100644
index 0000000..d104dd0
--- /dev/null
+++ b/test/relay-http.test.ts
@@ -0,0 +1,55 @@
+import { createServer, type AddressInfo, type Socket } from "node:net";
+import { once } from "node:events";
+import { expect, test } from "vitest";
+import { SingleConnectionHttpTransport } from "../src/http-transport.ts";
+
+test("closing during authentication cancels the pending HTTP request and releases its socket", async () => {
+ let accepted: (socket: Socket) => void;
+ const incoming = new Promise<Socket>(resolve => { accepted = resolve; });
+ const server = createServer(socket => { socket.on("error", () => {}); accepted(socket); });
+ await new Promise<void>(resolve => server.listen(0, "127.0.0.1", resolve));
+ const transport = new SingleConnectionHttpTransport(new URL(`http://127.0.0.1:${(server.address() as AddressInfo).port}/mcp`), "private-bearer",
+ { session: "cancellation-test", key: "cd".repeat(32) });
+ const result = transport.send({ jsonrpc: "2.0", id: 1, method: "initialize" }).then(() => false, () => true);
+ const socket = await incoming;
+ const closed = once(socket, "close"); socket.resume();
+ try {
+ await transport.close();
+ expect(await result).toBe(true);
+ await closed;
+ expect(socket.destroyed).toBe(true);
+ } finally {
+ socket.destroy(); await transport.close();
+ await new Promise<void>(resolve => server.close(() => resolve()));
+ }
+});
+
+test("a false relay cannot receive the driver bearer before proving its identity", async () => {
+ const sockets = new Set<Socket>();
+ const received: Buffer[] = [];
+ const server = createServer(socket => {
+ sockets.add(socket);
+ socket.on("close", () => sockets.delete(socket));
+ socket.on("error", () => {});
+ socket.write(JSON.stringify({ version: 1, nonce: "ab".repeat(32) }) + "\n");
+ socket.on("data", chunk => {
+ received.push(chunk);
+ // An unauthenticated OK or made-up server proof must never unlock HTTP.
+ socket.end(JSON.stringify({ proof: "00".repeat(32) }) + "\n");
+ });
+ });
+ await new Promise<void>(resolve => server.listen(0, "127.0.0.1", resolve));
+ const port = (server.address() as AddressInfo).port;
+ const bearer = "private-driver-token-must-not-reach-the-false-peer";
+ const transport = new SingleConnectionHttpTransport(new URL(`http://127.0.0.1:${port}/mcp`), bearer,
+ { session: "test-session", key: "cd".repeat(32) });
+ try {
+ await expect(transport.send({ jsonrpc: "2.0", id: 1, method: "initialize", params: {} })).rejects.toBeInstanceOf(Error);
+ expect(Buffer.concat(received).toString()).not.toContain(bearer);
+ expect(Buffer.concat(received).toString()).not.toContain("Authorization:");
+ } finally {
+ await transport.close();
+ for (const socket of sockets) socket.destroy();
+ await new Promise<void>(resolve => server.close(() => resolve()));
+ }
+});
diff --git a/test/session-relay-host.test.ts b/test/session-relay-host.test.ts
new file mode 100644
index 0000000..da258dd
--- /dev/null
+++ b/test/session-relay-host.test.ts
@@ -0,0 +1,191 @@
+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { once } from "node:events";
+import { mkdtemp, readFile, readdir, rm } from "node:fs/promises";
+import { connect, type Socket } from "node:net";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { expect, test } from "vitest";
+import { connectRelay } from "../src/relay-auth.ts";
+import { localRunner, type CommandRunner } from "../src/runner.ts";
+import { startSessionRelay } from "../src/session-relay-host.ts";
+
+const keys = () => ({ session: "worker-test", clientKey: randomBytes(32).toString("hex"), sessionKey: randomBytes(32).toString("hex") });
+const unreachable = (port: number) => new Promise<boolean>(resolve => {
+ const socket = connect({ port, host: "127.0.0.1" });
+ socket.once("connect", () => { socket.destroy(); resolve(false); });
+ socket.once("error", () => { socket.destroy(); resolve(true); });
+});
+
+async function fixture(script?: string) {
+ const root = await mkdtemp(path.join(tmpdir(), "pi-relay-worker-"));
+ const children: ChildProcessWithoutNullStreams[] = [];
+ const invocations: { file: string; args: readonly string[]; env?: Record<string, string> }[] = [];
+ const local = localRunner();
+ const runner: CommandRunner = {
+ ...local, ssh: "fixture",
+ spawn(file, args, env) {
+ invocations.push({ file, args, env });
+ const child = script === undefined ? local.spawn(file, args, env) : spawn(process.execPath, ["-e", script], { stdio: "pipe" });
+ children.push(child); return child;
+ },
+ };
+ const cleanup = async () => {
+ for (const child of children) if (child.exitCode === null && child.signalCode === null) {
+ const closed = once(child, "close").catch(() => {}); child.kill(); await closed;
+ }
+ await rm(root, { recursive: true, force: true });
+ };
+ return { root, runner, children, invocations, cleanup };
+}
+
+test("local relay uses owned in-process listeners and close releases all ports", async () => {
+ const k = keys(); const relay = await startSessionRelay(localRunner(), "unused", k);
+ const sockets: Socket[] = [];
+ try {
+ const client = await connectRelay(relay.ports[0], { session: k.session, key: k.clientKey }, { channel: "driver", role: "client" }); sockets.push(client);
+ const session = await connectRelay(relay.ports[1], { session: k.session, key: k.sessionKey }, { channel: "driver", role: "session" }); sockets.push(session);
+ const reply = once(client, "data"); client.resume(); session.write("owned-response");
+ expect(String((await reply)[0])).toBe("owned-response");
+ await relay.close();
+ expect(await Promise.all(relay.ports.map(unreachable))).toEqual([true, true, true, true]);
+ } finally { sockets.forEach(s => s.destroy()); await relay.close(); }
+});
+
+test("remote worker receives credentials only on stdin and EOF closes listeners and process", async () => {
+ const f = await fixture(); const k = keys();
+ try {
+ const relay = await startSessionRelay(f.runner, f.root, k);
+ const session = await connectRelay(relay.ports[3], { session: k.session, key: k.sessionKey }, { channel: "identity", role: "session" });
+ try {
+ expect(f.invocations).toHaveLength(1);
+ expect(JSON.stringify(f.invocations)).not.toContain(k.clientKey);
+ expect(JSON.stringify(f.invocations)).not.toContain(k.sessionKey);
+ for (const name of await readdir(f.root)) {
+ const source = await readFile(path.join(f.root, name), "utf8");
+ expect(source).not.toContain(k.clientKey); expect(source).not.toContain(k.sessionKey);
+ }
+ await relay.close();
+ expect(f.children[0].exitCode).toBe(0);
+ expect(await Promise.all(relay.ports.map(unreachable))).toEqual([true, true, true, true]);
+ } finally { session.destroy(); await relay.close(); }
+ } finally { await f.cleanup(); }
+});
+
+test("failed startup waits for every started worker transfer before cleanup can proceed", async () => {
+ const f = await fixture();
+ const transfers: { resolve(value: string): void; reject(error: Error): void }[] = [];
+ let allStarted: () => void;
+ const started = new Promise<void>(resolve => { allStarted = resolve; });
+ const original = f.runner.run;
+ f.runner.run = (file, args, options) => file !== "dd" ? original(file, args, options) : new Promise<string>((resolve, reject) => {
+ transfers.push({ resolve, reject });
+ if (transfers.length === 3) allStarted();
+ });
+ const outcome = startSessionRelay(f.runner, f.root, keys()).then(() => "ready", () => "rejected");
+ try {
+ await started;
+ transfers[0].reject(new Error("Transfer fixture failure"));
+ const state = await Promise.race([outcome, new Promise<string>(resolve => setTimeout(() => resolve("waiting"), 20))]);
+ expect(state).toBe("waiting");
+ transfers[1].resolve(""); transfers[2].resolve("");
+ expect(await outcome).toBe("rejected");
+ expect(f.children).toHaveLength(0);
+ } finally {
+ transfers.forEach(transfer => transfer.resolve(""));
+ await outcome; await f.cleanup();
+ }
+});
+
+test("an already cancelled startup launches no child or listeners", async () => {
+ const f = await fixture(); const abort = new AbortController(); abort.abort();
+ try {
+ await expect(startSessionRelay(f.runner, f.root, keys(), abort.signal)).rejects.toBeInstanceOf(Error);
+ expect(f.children).toHaveLength(0);
+ expect(await readdir(f.root)).toEqual([]);
+ } finally { await f.cleanup(); }
+});
+
+test("cancellation while the worker starts closes stdin and awaits process exit", async () => {
+ const f = await fixture("process.stdin.resume(); process.stdin.on('end',()=>process.exit(0)); process.stdin.on('data',()=>{});");
+ const abort = new AbortController();
+ try {
+ const opening = startSessionRelay(f.runner, f.root, keys(), abort.signal);
+ // The runner is the real spawn boundary, so cancellation always occurs after the child exists.
+ const waitSpawn = f.runner.spawn;
+ f.runner.spawn = (...args) => { const child = waitSpawn(...args); queueMicrotask(() => abort.abort()); return child; };
+ await expect(opening).rejects.toBeInstanceOf(Error);
+ expect(f.children).toHaveLength(1);
+ expect(f.children[0].exitCode).toBe(0);
+ } finally { await f.cleanup(); }
+});
+
+test("EOF during asynchronous worker startup closes listeners that finish opening afterward", async () => {
+ const f = await fixture(); const k = keys();
+ let child: ChildProcessWithoutNullStreams | undefined;
+ try {
+ // Copy the real worker through the production launcher first, then close that owned instance.
+ const prepared = await startSessionRelay(f.runner, f.root, k); await prepared.close();
+ const preload = `import net from 'node:net'; const listen = net.Server.prototype.listen; net.Server.prototype.listen = function(...args) { setTimeout(() => listen.apply(this, args), 25); return this; };`;
+ child = spawn(process.execPath, ["--experimental-strip-types", `--import=data:text/javascript,${encodeURIComponent(preload)}`, path.join(f.root, "session-relay-worker.ts")], { stdio: "pipe" });
+ let output = ""; child.stdout.on("data", chunk => { output += chunk.toString(); }); child.stderr.resume();
+ const closed = once(child, "close");
+ child.stdin.end(JSON.stringify(k) + "\n");
+ const [code, signal] = await closed;
+ expect(code).toBe(0); expect(signal).toBeNull();
+ expect(output).toBe("");
+ } finally {
+ if (child && child.exitCode === null && child.signalCode === null) { const closed = once(child, "close"); child.kill(); await closed; }
+ await f.cleanup();
+ }
+});
+
+test("malformed credentials never produce readiness and the real worker exits", async () => {
+ const f = await fixture();
+ try {
+ await expect(startSessionRelay(f.runner, f.root, { ...keys(), clientKey: "not-a-key" })).rejects.toBeInstanceOf(Error);
+ expect(f.children).toHaveLength(1);
+ expect(f.children[0].exitCode).toBe(1);
+ } finally { await f.cleanup(); }
+});
+
+test("a missing worker executable is rejected without leaving a live child", async () => {
+ const f = await fixture();
+ f.runner.spawn = () => {
+ const child = spawn(path.join(f.root, "missing-node"), [], { stdio: "pipe" });
+ f.children.push(child); return child;
+ };
+ try {
+ await expect(startSessionRelay(f.runner, f.root, keys())).rejects.toBeInstanceOf(Error);
+ expect(f.children).toHaveLength(1);
+ expect(f.children[0].exitCode).not.toBeNull();
+ } finally { await f.cleanup(); }
+});
+
+test("a broken worker input pipe rejects startup and still waits for EOF cleanup", async () => {
+ const f = await fixture();
+ const original = f.runner.spawn;
+ f.runner.spawn = (...args) => {
+ const child = original(...args);
+ queueMicrotask(() => child.stdin.destroy(new Error("fixture pipe error")));
+ return child;
+ };
+ try {
+ await expect(startSessionRelay(f.runner, f.root, keys())).rejects.toBeInstanceOf(Error);
+ expect(f.children).toHaveLength(1);
+ expect(f.children[0].exitCode).toBe(0);
+ } finally { await f.cleanup(); }
+});
+
+test.each([
+ "process.stdout.write('not-json\\n'); process.stdin.resume();",
+ "process.stdout.write('x'.repeat(2048)); process.stdin.resume();",
+ "process.stdout.write(JSON.stringify({ports:[1,2]})+'\\n'); process.stdin.resume();",
+ "process.stdin.resume(); process.stdin.once('data',()=>process.exit(7));",
+])("invalid startup output or early worker failure is rejected and reaped (%#)", async script => {
+ const f = await fixture(script);
+ try {
+ await expect(startSessionRelay(f.runner, f.root, keys())).rejects.toBeInstanceOf(Error);
+ expect(f.children[0].exitCode).not.toBeNull();
+ } finally { await f.cleanup(); }
+});
diff --git a/test/session-relay.test.ts b/test/session-relay.test.ts
new file mode 100644
index 0000000..66a16b7
--- /dev/null
+++ b/test/session-relay.test.ts
@@ -0,0 +1,162 @@
+import { createHmac, randomBytes } from "node:crypto";
+import { createServer as httpServer } from "node:http";
+import { once } from "node:events";
+import { connect, createServer, type AddressInfo, type Socket } from "node:net";
+import { setTimeout as delay } from "node:timers/promises";
+import { expect, test } from "vitest";
+import { connectRelay } from "../src/relay-auth.ts";
+import { createSessionRelay } from "../src/session-relay.ts";
+import { SingleConnectionHttpTransport } from "../src/http-transport.ts";
+
+const keys = () => ({ session: "test-session", clientKey: randomBytes(32).toString("hex"), sessionKey: randomBytes(32).toString("hex") });
+const proofContext = (auth: { session: string; key: string }, side: string, channel: string, role: string, serverNonce: unknown, nonce: unknown) =>
+ createHmac("sha256", Buffer.from(auth.key, "hex")).update(JSON.stringify(["pi-relay", 1, side, auth.session, channel, role, serverNonce, nonce])).digest("hex");
+const line = (socket: Socket): Promise<Record<string, unknown>> => new Promise((resolve, reject) => {
+ let text = "";
+ const data = (chunk: Buffer) => { text += chunk.toString(); if (text.includes("\n")) { socket.pause(); socket.off("data", data); resolve(JSON.parse(text.split("\n")[0])); } };
+ socket.once("error", reject); socket.on("data", data); socket.resume();
+});
+
+test("a foreign reverse endpoint cannot enter pairing or receive driver credentials", async () => {
+ const k = keys();
+ const relay = await createSessionRelay(k, { authenticationTimeoutMs: 100 });
+ const attacker = connect(relay.ports[1], "127.0.0.1");
+ const stolen: Buffer[] = [];
+ attacker.on("data", c => stolen.push(c)); attacker.on("error", () => {});
+ const dropped = once(attacker, "close");
+ const transport = new SingleConnectionHttpTransport(new URL(`http://127.0.0.1:${relay.ports[0]}/mcp`), "secret-bearer",
+ { session: k.session, key: k.clientKey });
+ let legitimate: Socket | undefined;
+ try {
+ const response = transport.send({ jsonrpc: "2.0", id: 1, method: "initialize" });
+ await dropped;
+ legitimate = await connectRelay(relay.ports[1], { session: k.session, key: k.sessionKey }, { channel: "driver", role: "session" });
+ let request = "";
+ legitimate.on("data", chunk => {
+ request += chunk.toString();
+ if (!request.includes("secret-bearer")) return;
+ const body = JSON.stringify({ jsonrpc: "2.0", id: 1, result: {} });
+ legitimate!.write(`HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`);
+ });
+ legitimate.resume();
+ await response;
+ expect(request).toContain("Authorization: Bearer secret-bearer");
+ expect(Buffer.concat(stolen).toString()).not.toContain("secret-bearer");
+ expect(Buffer.concat(stolen).toString()).not.toContain("POST /mcp");
+ } finally { attacker.destroy(); legitimate?.destroy(); await transport.close(); await relay.close(); }
+});
+
+test("successive driver requests keep the same authenticated native TCP connection", async () => {
+ let accepted = 0;
+ const native = httpServer((request, response) => {
+ let body = "";
+ request.on("data", chunk => { body += String(chunk); });
+ request.on("end", () => {
+ const message = JSON.parse(body);
+ response.writeHead(200, { "Content-Type": "application/json" });
+ response.end(JSON.stringify({ jsonrpc: "2.0", id: message.id, result: {} }));
+ });
+ });
+ native.on("connection", () => { accepted++; });
+ await new Promise<void>(resolve => native.listen(0, "127.0.0.1", resolve));
+ const k = keys(), relay = await createSessionRelay(k);
+ const remote = await connectRelay(relay.ports[1], { session: k.session, key: k.sessionKey }, { channel: "driver", role: "session" });
+ const local = connect((native.address() as AddressInfo).port, "127.0.0.1");
+ remote.pipe(local); local.pipe(remote);
+ const transport = new SingleConnectionHttpTransport(new URL(`http://127.0.0.1:${relay.ports[0]}/mcp`), "driver-token",
+ { session: k.session, key: k.clientKey });
+ const replies: unknown[] = []; transport.onmessage = message => { replies.push(message); };
+ try {
+ for (const id of [1, 2]) await transport.send({ jsonrpc: "2.0", id, method: "test" });
+ expect(replies).toEqual([{ jsonrpc: "2.0", id: 1, result: {} }, { jsonrpc: "2.0", id: 2, result: {} }]);
+ expect(accepted).toBe(1);
+ } finally {
+ await transport.close(); remote.destroy(); local.destroy(); await relay.close();
+ native.closeAllConnections(); await new Promise<void>(resolve => native.close(() => resolve()));
+ }
+});
+
+test("a valid key cannot substitute a different session, role or channel", async () => {
+ const k = keys(); const relay = await createSessionRelay(k);
+ try {
+ for (const [auth, context] of [
+ [{ session: k.session, key: k.sessionKey }, { channel: "driver", role: "client" }],
+ [{ session: "other-session", key: k.clientKey }, { channel: "driver", role: "client" }],
+ [{ session: k.session, key: k.clientKey }, { channel: "identity", role: "client" }],
+ [{ session: k.session, key: k.clientKey }, { channel: "driver", role: "session" }],
+ ] as const) {
+ await expect(connectRelay(relay.ports[0], auth, context)).rejects.toBeInstanceOf(Error);
+ }
+ } finally { await relay.close(); }
+});
+
+test("a server proof coalesced with application bytes preserves every payload byte", async () => {
+ const auth = { session: "coalesced-test", key: "ef".repeat(32) };
+ const sockets: Socket[] = [];
+ const server = createServer(socket => {
+ sockets.push(socket); socket.on("error", () => {});
+ const nonce = "ab".repeat(32);
+ socket.write(JSON.stringify({ version: 1, nonce }) + "\n");
+ void line(socket).then(frame => {
+ const mac = proofContext(auth, "server", "identity", "client", nonce, frame.nonce);
+ socket.write(JSON.stringify({ proof: mac }) + "\n" + "identity-payload\n");
+ });
+ });
+ await new Promise<void>(resolve => server.listen(0, "127.0.0.1", resolve));
+ try {
+ const peer = await connectRelay((server.address() as AddressInfo).port, auth, { channel: "identity", role: "client" });
+ sockets.push(peer);
+ const data = once(peer, "data"); peer.resume();
+ expect(String((await data)[0])).toBe("identity-payload\n");
+ } finally { sockets.forEach(s => s.destroy()); await new Promise<void>(resolve => server.close(() => resolve())); }
+});
+
+test("oversized unauthenticated frames are dropped without entering a pairing queue", async () => {
+ const k = keys(); const relay = await createSessionRelay(k);
+ const attacker = connect(relay.ports[1], "127.0.0.1"); attacker.on("error", () => {});
+ try {
+ await line(attacker);
+ const closed = once(attacker, "close");
+ attacker.write("x".repeat(513)); attacker.resume();
+ await closed;
+ expect(attacker.destroyed).toBe(true);
+ } finally { attacker.destroy(); await relay.close(); }
+});
+
+test("proofs cannot be replayed on another connection, channel or role", async () => {
+ const k = keys(); const relay = await createSessionRelay(k);
+ const sockets: Socket[] = [];
+ try {
+ const first = connect(relay.ports[0], "127.0.0.1"); sockets.push(first);
+ const challenge = await line(first);
+ const nonce = randomBytes(32).toString("hex");
+ const proof = createHmac("sha256", Buffer.from(k.clientKey, "hex"))
+ .update(JSON.stringify(["pi-relay", 1, "client", k.session, "driver", "client", challenge.nonce, nonce])).digest("hex");
+ const frame = { version: 1, session: k.session, channel: "driver", role: "client", nonce, proof };
+ const serverProof = line(first); first.write(JSON.stringify(frame) + "\n");
+ expect(await serverProof).toHaveProperty("proof");
+ for (const port of [relay.ports[0], relay.ports[1], relay.ports[2]]) {
+ const replay = connect(port, "127.0.0.1"); replay.on("error", () => {}); sockets.push(replay);
+ await line(replay);
+ const closed = once(replay, "close"); replay.write(JSON.stringify(frame) + "\n"); replay.resume();
+ await closed;
+ expect(replay.destroyed).toBe(true);
+ }
+ } finally { sockets.forEach(s => s.destroy()); await relay.close(); }
+});
+
+test("an idle driver handshake does not block identity and authenticated peers survive idle time", async () => {
+ const k = keys(); const relay = await createSessionRelay(k, { authenticationTimeoutMs: 80 });
+ const idle = connect(relay.ports[1], "127.0.0.1"); idle.on("error", () => {});
+ const sockets: Socket[] = [idle];
+ try {
+ const session = await connectRelay(relay.ports[3], { session: k.session, key: k.sessionKey }, { channel: "identity", role: "session" }); sockets.push(session);
+ const client = await connectRelay(relay.ports[2], { session: k.session, key: k.clientKey }, { channel: "identity", role: "client" }); sockets.push(client);
+ await delay(180);
+ const reply = once(client, "data"); client.resume();
+ session.write("persistent-identity-response\n"); session.resume();
+ expect(String((await reply)[0])).toBe("persistent-identity-response\n");
+ await relay.close();
+ await expect(connectRelay(relay.ports[0], { session: k.session, key: k.clientKey }, { channel: "driver", role: "client" })).rejects.toBeInstanceOf(Error);
+ } finally { sockets.forEach(s => s.destroy()); await relay.close(); }
+});