a2a-exposed 0.7.11 → 0.7.13

package/worker/test/wake-target.test.ts

@@ -2,13 +2,17 @@
 // Unset keeps today's fetch. Run: npm test
 import { test } from "node:test";
 import assert from "node:assert/strict";
+import net from "node:net";
+import { Duplex } from "node:stream";
 import worker from "../src/index.ts";
 import { d1 } from "./d1.ts";
 import * as M from "../src/mcp.ts";
-import { fetchCheckedWake, publicWakeProblem, type AddressLookup, type WakeDeps } from "../src/wake-target.ts";
+import { dialChecked, fetchCheckedWake, publicWakeProblem, wakeNet, type AddressLookup, type CheckedDeliver, type WakeConnect } from "../src/wake-target.ts";
 
 const publicLookup: AddressLookup = async (host) => {
 	if (host === "hook.example" || host === "also.example") return ["1.2.3.4"];
+	if (host === "round.example") return ["1.2.3.4", "1.2.3.5"];
+	if (host === "v6.example") return ["2606:4700:4700::1111"];
 	if (host === "split.example") return ["1.2.3.4", "10.0.0.1"];
 	if (host === "meta.example") return ["169.254.169.254"];
 	if (host === "missing.example") return [];
@@ -46,65 +50,155 @@ test("public-https refuses private, metadata, and non-https URLs before any requ
 	assert.equal(await publicWakeProblem("https://unknown.example/wake", publicLookup), "its address could not be checked");
 });
 
-function pinned(answer: (request: string) => { status: number; location?: string }) {
-	const calls: { ip: string; sni: string; request: string }[] = [];
-	const connect: NonNullable<WakeDeps["connect"]> = (addr) => ({
-		startTls: ({ expectedServerHostname: sni }) => {
-			let req = "";
-			let respond!: (bytes: Uint8Array) => void;
-			const ready = new Promise<Uint8Array>((resolve) => { respond = resolve; });
-			const writable = new WritableStream<Uint8Array>({
-				write(chunk) {
-					req += new TextDecoder().decode(chunk);
-					if (!req.includes("\r\n\r\n")) return;
-					calls.push({ ip: addr.hostname, sni, request: req });
-					const made = answer(req);
-					const headers = [`HTTP/1.1 ${made.status} X`, "content-length: 0"];
-					if (made.location) headers.push(`location: ${made.location}`);
-					headers.push("connection: close", "", "");
-					respond(new TextEncoder().encode(headers.join("\r\n")));
-				},
-			});
-			const readable = new ReadableStream<Uint8Array>({
-				async start(controller) {
-					controller.enqueue(await ready);
-					controller.close();
-				},
-			});
-			return { readable, writable, close: async () => {} };
-		},
-	});
-	return { connect, calls };
+function recorded(answer: (call: { url: string }) => { status: number; location?: string }) {
+	const calls: { url: string; ip: string; hostname: string; authorization: string; body: string; redirect: string }[] = [];
+	const deliver: CheckedDeliver = async (url, init, target) => {
+		const headers = new Headers(init.headers);
+		const call = {
+			url,
+			ip: target.ip,
+			hostname: target.hostname,
+			authorization: headers.get("authorization") ?? "",
+			body: typeof init.body === "string" ? init.body : init.body instanceof Uint8Array ? new TextDecoder().decode(init.body) : "",
+			redirect: init.redirect ?? "",
+		};
+		calls.push(call);
+		const made = answer(call);
+		return new Response(null, { status: made.status, headers: made.location ? { location: made.location } : {} });
+	};
+	return { deliver, calls };
+}
+
+test("the dial uses the checked address and leaves TLS to name the host", () => {
+	const seen: { hostname: string; secure?: string }[] = [];
+	const base: WakeConnect = (addr, options) => {
+		seen.push({ hostname: addr.hostname, secure: options?.secureTransport });
+		return { readable: new ReadableStream(), writable: new WritableStream(), async close() {} };
+	};
+	dialChecked("1.2.3.4", base)({ hostname: "hook.example", port: 443 }, { secureTransport: "on" });
+	assert.deepEqual(seen, [{ hostname: "1.2.3.4", secure: "off" }]);
+});
+
+/** Server names from a TLS ClientHello. Empty when the bytes are not one. */
+function clientHelloNames(buf: Buffer): string[] {
+	if (buf.length < 5 || buf[0] !== 0x16) return [];
+	const recordLen = buf.readUInt16BE(3);
+	if (buf.length < 5 + recordLen) return [];
+	const hs = buf.subarray(5, 5 + recordLen);
+	if (hs.length < 4 || hs[0] !== 1) return [];
+	let i = 4 + 2 + 32;
+	if (i >= hs.length) return [];
+	const sidLen = hs[i]!;
+	i += 1 + sidLen;
+	if (i + 2 > hs.length) return [];
+	const csLen = hs.readUInt16BE(i);
+	i += 2 + csLen;
+	if (i >= hs.length) return [];
+	const compLen = hs[i]!;
+	i += 1 + compLen;
+	if (i + 2 > hs.length) return [];
+	const extEnd = i + 2 + hs.readUInt16BE(i);
+	i += 2;
+	const names: string[] = [];
+	while (i + 4 <= extEnd && i + 4 <= hs.length) {
+		const type = hs.readUInt16BE(i);
+		const len = hs.readUInt16BE(i + 2);
+		i += 4;
+		if (i + len > hs.length) break;
+		if (type === 0 && len >= 2) {
+			const list = hs.subarray(i, i + len);
+			let j = 2;
+			while (j + 3 <= list.length) {
+				const nameType = list[j]!;
+				const nlen = list.readUInt16BE(j + 1);
+				j += 3;
+				if (j + nlen > list.length) break;
+				if (nameType === 0) names.push(list.subarray(j, j + nlen).toString());
+				j += nlen;
+			}
+		}
+		i += len;
+	}
+	return names;
 }
 
-test("a redirect to a private address is not connected, and the first hop uses the checked IP", async () => {
-	const socket = pinned(() => ({ status: 302, location: "http://169.254.169.254/latest/meta-data" }));
-	const result = await fetchCheckedWake("https://hook.example/wake", { method: "POST", headers: { authorization: "Bearer secret" }, body: "{}" }, { lookup: publicLookup, connect: socket.connect });
-	assert.equal(socket.calls.length, 1);
-	assert.equal(socket.calls[0].ip, "1.2.3.4");
-	assert.equal(socket.calls[0].sni, "hook.example");
-	assert.match(socket.calls[0].request, /^POST \/wake HTTP\/1\.1/);
-	assert.match(socket.calls[0].request, /authorization: Bearer secret/i);
+test("delivery sends the hostname in the ClientHello on a socket to the checked address", async () => {
+	const chunks: Buffer[] = [];
+	const server = net.createServer((socket) => {
+		socket.on("data", (data) => {
+			chunks.push(data);
+			const hello = Buffer.concat(chunks);
+			if (hello.length >= 5 && hello[0] === 0x16 && hello.length >= 5 + hello.readUInt16BE(3)) socket.destroy();
+		});
+	});
+	await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+	const address = server.address();
+	if (!address || typeof address === "string") throw new Error("no port");
+	const dialed: { hostname: string; secure?: string }[] = [];
+	const connect: WakeConnect = (addr, options) => {
+		dialed.push({ hostname: addr.hostname, secure: options?.secureTransport });
+		const socket = net.connect({ host: "127.0.0.1", port: address.port });
+		const web = Duplex.toWeb(socket);
+		return {
+			readable: web.readable,
+			writable: web.writable,
+			opened: new Promise((resolve, reject) => {
+				socket.once("connect", () => resolve({ remoteAddress: "127.0.0.1" }));
+				socket.once("error", reject);
+			}),
+			async close() { socket.destroy(); },
+		};
+	};
+	try {
+		await assert.rejects(
+			() => fetchCheckedWake("https://hook.example/wake", {
+				method: "POST",
+				headers: { authorization: "Bearer secret" },
+				body: "{}",
+			}, { lookup: publicLookup, connect }),
+			(err: unknown) => err instanceof Error && err.message === "TLS Handshake Failed.",
+		);
+	} finally {
+		server.close();
+	}
+	const wire = Buffer.concat(chunks);
+	assert.deepEqual(dialed, [{ hostname: "1.2.3.4", secure: "off" }]);
+	assert.deepEqual(clientHelloNames(wire), ["hook.example"]);
+	assert.equal(wire.includes(Buffer.from("POST /wake")), false);
+	assert.equal(wire.includes(Buffer.from("secret")), false);
+});
+
+test("a redirect to a private address is not requested, and the first hop is pinned to the checked address", async () => {
+	const hop = recorded(() => ({ status: 302, location: "http://169.254.169.254/latest/meta-data" }));
+	const result = await fetchCheckedWake("https://hook.example/wake", { method: "POST", headers: { authorization: "Bearer secret" }, body: "{}" }, { lookup: publicLookup, deliver: hop.deliver });
+	assert.equal(hop.calls.length, 1);
+	assert.equal(hop.calls[0].url, "https://hook.example/wake");
+	assert.equal(hop.calls[0].ip, "1.2.3.4");
+	assert.equal(hop.calls[0].hostname, "hook.example");
+	assert.equal(hop.calls[0].redirect, "manual");
+	assert.equal(hop.calls[0].authorization, "Bearer secret");
 	assert.equal("refused" in result && result.refused, "must be https");
 });
 
 test("a cross-origin redirect is not followed, so credentials stay on the first host", async () => {
-	const socket = pinned(() => ({ status: 307, location: "https://also.example/wake" }));
-	const result = await fetchCheckedWake("https://hook.example/wake", { method: "POST", headers: { authorization: "Bearer secret" }, body: "{}" }, { lookup: publicLookup, connect: socket.connect });
-	assert.equal(socket.calls.length, 1);
-	assert.equal(socket.calls[0].ip, "1.2.3.4");
+	const hop = recorded(() => ({ status: 307, location: "https://also.example/wake" }));
+	const result = await fetchCheckedWake("https://hook.example/wake", { method: "POST", headers: { authorization: "Bearer secret" }, body: "{}" }, { lookup: publicLookup, deliver: hop.deliver });
+	assert.equal(hop.calls.length, 1);
+	assert.equal(hop.calls[0].ip, "1.2.3.4");
 	assert.equal("refused" in result && result.refused, "cross-origin redirect");
 });
 
-test("a same-origin redirect is pinned again and keeps the wake headers", async () => {
-	const socket = pinned((request) => request.startsWith("POST /wake ")
+test("a same-origin redirect is checked again and keeps the wake headers", async () => {
+	const hop = recorded((call) => call.url.endsWith("/wake")
 		? { status: 307, location: "https://hook.example/next" }
 		: { status: 200 });
-	const result = await fetchCheckedWake("https://hook.example/wake", { method: "POST", headers: { authorization: "Bearer secret" }, body: "{}" }, { lookup: publicLookup, connect: socket.connect });
-	assert.equal(socket.calls.length, 2);
-	assert.deepEqual(socket.calls.map((call) => call.ip), ["1.2.3.4", "1.2.3.4"]);
-	assert.match(socket.calls[1].request, /^POST \/next HTTP\/1\.1/);
-	assert.match(socket.calls[1].request, /authorization: Bearer secret/i);
+	const result = await fetchCheckedWake("https://hook.example/wake", { method: "POST", headers: { authorization: "Bearer secret" }, body: "{}" }, { lookup: publicLookup, deliver: hop.deliver });
+	assert.deepEqual(hop.calls.map((call) => [call.url, call.ip]), [
+		["https://hook.example/wake", "1.2.3.4"],
+		["https://hook.example/next", "1.2.3.4"],
+	]);
+	assert.equal(hop.calls[1].authorization, "Bearer secret");
+	assert.equal(hop.calls[1].body, "{}");
 	assert.equal("response" in result && result.response.status, 200);
 });
 
@@ -168,20 +262,33 @@ test("public-https does not request a metadata address, and does post to a check
 	assert.equal(requested.some((url) => url.includes("169.254.169.254")), false);
 
 	requested.length = 0;
-	const socket = pinned(() => ({ status: 200 }));
-	M.net.connect = socket.connect;
+	const hop = recorded(() => ({ status: 200 }));
+	// The runtime startTls pin sends no SNI. Delivery must dial the checked IP and name the host itself.
+	M.net.connect = () => { throw new Error("wake delivery must not use startTls on the resolved IP"); };
+	wakeNet.deliver = hop.deliver;
 	try {
 		const allowed = await wakeTest({
 			DB: db(), PUBLIC_URL: BASE, OWNER_TOKEN: "owner-secret", WAKE_PRESET: "generic",
 			WAKE_WEBHOOK_URL: "https://hook.example/wake", WAKE_WEBHOOK_KEY: "hook-key", WAKE_TARGET_POLICY: "public-https",
 		}, fetchImpl);
 		assert.equal(allowed.status, 200);
-		assert.equal(requested.every((url) => url.startsWith("https://cloudflare-dns.com/")), true);
-		assert.equal(socket.calls.length, 1);
-		assert.equal(socket.calls[0].ip, "1.2.3.4");
-		assert.equal(socket.calls[0].sni, "hook.example");
-		assert.match(socket.calls[0].request, /authorization: Bearer hook-key/i);
+		assert.equal(hop.calls.length, 1);
+		assert.equal(hop.calls[0].ip, "1.2.3.4");
+		assert.equal(hop.calls[0].hostname, "hook.example");
+		assert.equal(hop.calls[0].authorization, "Bearer hook-key");
+		assert.equal(requested.some((url) => new URL(url).hostname === "hook.example"), false);
+		assert.equal(requested.some((url) => url.startsWith("https://cloudflare-dns.com/dns-query")), true);
 	} finally {
 		M.net.connect = null;
+		wakeNet.deliver = null;
 	}
+
+	wakeNet.deliver = async () => { throw new Error("TLS Handshake Failed."); };
+	const tls = await wakeTest({
+		DB: db(), PUBLIC_URL: BASE, OWNER_TOKEN: "owner-secret", WAKE_PRESET: "generic",
+		WAKE_WEBHOOK_URL: "https://hook.example/wake", WAKE_WEBHOOK_KEY: "hook-key", WAKE_TARGET_POLICY: "public-https",
+	}, fetchImpl);
+	wakeNet.deliver = null;
+	assert.equal(tls.status, null);
+	assert.equal(tls.info, "Error: TLS Handshake Failed.");
 });

package/worker/test/wake.test.ts

@@ -116,6 +116,23 @@ test("generic custom key header is rendered with prefix and redacted in previews
 	assert.ok(!JSON.stringify(red).includes("supersecretvalue"));
 });
 
+test("a key header the preview shows in full is not used for the key", async () => {
+	const req = (await renderWake({ preset: "generic", url: "https://hooks.example.com/abc", key: "supersecretvalue", keyHeader: "Content-Type", keyPrefix: "" }, ev))!;
+	assert.equal(req.headers["authorization"], "supersecretvalue");
+	assert.equal(req.headers["content-type"], "application/json");
+	assert.equal(redact(req).headers["authorization"], "••••");
+	assert.equal(JSON.stringify(redact(req)).includes("supe"), false);
+});
+
+test("generic key header is redacted even when its name is not a secret word", async () => {
+	const req = (await renderWake({ preset: "generic", url: "https://hooks.example.com/abc", key: "supersecretvalue", keyHeader: "X-Credential", keyPrefix: "" }, ev))!;
+	assert.equal(req.headers["x-credential"], "supersecretvalue");
+	const red = redact(req);
+	assert.equal(red.headers["x-credential"], "••••");
+	assert.equal(red.headers["content-type"], "application/json");
+	assert.ok(!JSON.stringify(red).includes("supersecretvalue"));
+});
+
 // ---------------------------------------------------------------- Cloudflare Access service token (tunnel wakes)
 const ACCESS = { accessClientId: "abc123.access", accessClientSecret: "s3cr3t-value-0123456789" };
 
@@ -144,8 +161,9 @@ test("hermes HMAC is computed over the body only, unaffected by Access headers",
 
 test("redact masks both Access headers", async () => {
 	const r = redact((await renderWake({ preset: "openclaw-wake", url: "https://wake-x.example.com/hooks/wake", key: "hooks-token", ...ACCESS }, ev))!);
-	assert.equal(r.headers["CF-Access-Client-Id"], "abc1…");
-	assert.equal(r.headers["CF-Access-Client-Secret"], "s3cr…");
+	assert.equal(r.headers["CF-Access-Client-Id"], "••••");
+	assert.equal(r.headers["CF-Access-Client-Secret"], "••••");
+	assert.equal(r.headers["authorization"], "Bearer ••••");
 	assert.ok(!JSON.stringify(r).includes("s3cr3t-value"));
 });