mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-16 12:01:13 +00:00
Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
c1795a2202 |
No files matched your search
@@ -959,6 +959,9 @@ async function buildLocalSessionEnv(
|
||||
) {
|
||||
const { buildTerminalProcessEnv } = require("./httpNetworkProxyBridge.cjs");
|
||||
const env = { ...buildTerminalProcessEnv(baseEnv), ...(payload?.env || {}) };
|
||||
// AppImage's ARGV0 makes zsh rename external commands, including ssh. Xorg
|
||||
// then mistakes ssh's X11 connection for a local client and sends unusable fds.
|
||||
delete env.ARGV0;
|
||||
if (platform !== "win32") return env;
|
||||
|
||||
const { getPathEnvKey, resolveWindowsLivePath } = require("./ai/shellUtils.cjs");
|
||||
|
||||
@@ -37,6 +37,15 @@ const STALE_PATH =
|
||||
const LIVE_PATH =
|
||||
"C:\\Users\\me\\.herdr\\packages\\standalone\\releases\\0.9.1-x86_64-pc-windows-msvc;C:\\Windows\\System32";
|
||||
|
||||
test("buildLocalSessionEnv strips AppImage ARGV0 without changing the base env", async () => {
|
||||
const baseEnv = { PATH: "/usr/bin:/bin", ARGV0: "/opt/Netcatty.AppImage" };
|
||||
const env = await bridge.buildLocalSessionEnv({}, { baseEnv, platform: "linux" });
|
||||
|
||||
assert.equal(Object.hasOwn(env, "ARGV0"), false);
|
||||
assert.equal(env.PATH, baseEnv.PATH);
|
||||
assert.equal(baseEnv.ARGV0, "/opt/Netcatty.AppImage");
|
||||
});
|
||||
|
||||
test("buildLocalSessionEnv keeps the captured PATH untouched off Windows", async () => {
|
||||
const env = await bridge.buildLocalSessionEnv(
|
||||
{ env: { NETCATTY_MARKER: "1" } },
|
||||
|
||||
@@ -0,0 +1,190 @@
|
||||
const { Transform } = require("node:stream");
|
||||
|
||||
const DEFAULT_HIDDEN_EXTENSIONS = Object.freeze(["DRI3", "MIT-SHM"]);
|
||||
const EMPTY = Buffer.alloc(0);
|
||||
|
||||
function readUInt16(buffer, offset, littleEndian) {
|
||||
return littleEndian ? buffer.readUInt16LE(offset) : buffer.readUInt16BE(offset);
|
||||
}
|
||||
|
||||
function readUInt32(buffer, offset, littleEndian) {
|
||||
return littleEndian ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset);
|
||||
}
|
||||
|
||||
function pad4(length) {
|
||||
return Math.ceil(length / 4) * 4;
|
||||
}
|
||||
|
||||
// Retain only the header we need; large request/reply bodies stream through.
|
||||
function collectHeader(state, length, chunk, offset) {
|
||||
const count = Math.min(Math.max(0, length - state.header.length), chunk.length - offset);
|
||||
if (count > 0) {
|
||||
state.header = Buffer.concat([state.header, chunk.subarray(offset, offset + count)]);
|
||||
}
|
||||
return offset + count;
|
||||
}
|
||||
|
||||
class RequestTracker extends Transform {
|
||||
constructor(shared) {
|
||||
super();
|
||||
this.shared = shared;
|
||||
this.setup = true;
|
||||
this.header = EMPTY;
|
||||
this.remaining = 0;
|
||||
this.sequence = 0;
|
||||
}
|
||||
|
||||
_transform(chunk, _encoding, callback) {
|
||||
const shared = this.shared;
|
||||
let offset = 0;
|
||||
while (offset < chunk.length && shared.enabled) {
|
||||
if (this.remaining > 0) {
|
||||
const count = Math.min(this.remaining, chunk.length - offset);
|
||||
offset += count;
|
||||
this.remaining -= count;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (this.setup) {
|
||||
offset = collectHeader(this, 1, chunk, offset);
|
||||
if (this.header[0] !== 0x6c && this.header[0] !== 0x42) {
|
||||
shared.enabled = false;
|
||||
break;
|
||||
}
|
||||
shared.littleEndian = this.header[0] === 0x6c;
|
||||
offset = collectHeader(this, 12, chunk, offset);
|
||||
if (this.header.length < 12) break;
|
||||
this.remaining = pad4(readUInt16(this.header, 6, shared.littleEndian))
|
||||
+ pad4(readUInt16(this.header, 8, shared.littleEndian));
|
||||
this.header = EMPTY;
|
||||
this.setup = false;
|
||||
continue;
|
||||
}
|
||||
|
||||
offset = collectHeader(this, 4, chunk, offset);
|
||||
if (this.header.length < 4) break;
|
||||
let words = readUInt16(this.header, 2, shared.littleEndian);
|
||||
const headerLength = words === 0 ? 8 : 4;
|
||||
if (headerLength === 8) {
|
||||
offset = collectHeader(this, 8, chunk, offset);
|
||||
if (this.header.length < 8) break;
|
||||
words = readUInt32(this.header, 4, shared.littleEndian);
|
||||
}
|
||||
const total = words * 4;
|
||||
if (total < headerLength) {
|
||||
shared.enabled = false;
|
||||
break;
|
||||
}
|
||||
|
||||
let name;
|
||||
const nameOffset = headerLength + 4;
|
||||
if (this.header[0] === 98 && total >= nameOffset) { // QueryExtension
|
||||
offset = collectHeader(this, nameOffset, chunk, offset);
|
||||
if (this.header.length < nameOffset) break;
|
||||
const nameLength = readUInt16(this.header, headerLength, shared.littleEndian);
|
||||
if (nameLength <= shared.maxNameLength && nameOffset + pad4(nameLength) <= total) {
|
||||
offset = collectHeader(this, nameOffset + nameLength, chunk, offset);
|
||||
if (this.header.length < nameOffset + nameLength) break;
|
||||
name = this.header.toString("latin1", nameOffset, nameOffset + nameLength);
|
||||
}
|
||||
}
|
||||
|
||||
this.sequence = (this.sequence + 1) & 0xffff;
|
||||
// Do not let an unanswered query affect an unrelated request after wrap.
|
||||
shared.pending.delete(this.sequence);
|
||||
if (shared.hidden.has(name)) shared.pending.set(this.sequence, name);
|
||||
this.remaining = total - this.header.length;
|
||||
this.header = EMPTY;
|
||||
}
|
||||
callback(null, chunk);
|
||||
}
|
||||
}
|
||||
|
||||
class ReplyFilter extends Transform {
|
||||
constructor(shared) {
|
||||
super();
|
||||
this.shared = shared;
|
||||
this.setup = true;
|
||||
this.header = EMPTY;
|
||||
this.remaining = 0;
|
||||
}
|
||||
|
||||
_transform(chunk, _encoding, callback) {
|
||||
const shared = this.shared;
|
||||
let offset = 0;
|
||||
while (offset < chunk.length) {
|
||||
if (!shared.enabled) {
|
||||
this.push(this.header);
|
||||
this.header = EMPTY;
|
||||
this.push(chunk.subarray(offset));
|
||||
break;
|
||||
}
|
||||
if (this.remaining > 0) {
|
||||
const count = Math.min(this.remaining, chunk.length - offset);
|
||||
this.push(chunk.subarray(offset, offset + count));
|
||||
offset += count;
|
||||
this.remaining -= count;
|
||||
continue;
|
||||
}
|
||||
|
||||
offset = collectHeader(this, this.setup ? 8 : 4, chunk, offset);
|
||||
if (this.header.length < (this.setup ? 8 : 4)) break;
|
||||
if (this.setup) {
|
||||
this.remaining = readUInt16(this.header, 6, shared.littleEndian) * 4;
|
||||
this.setup = false;
|
||||
} else {
|
||||
const type = this.header[0];
|
||||
let total = 32; // Errors and ordinary events are fixed size.
|
||||
if (type === 1 || (type & 0x7f) === 35) { // Reply or GenericEvent
|
||||
offset = collectHeader(this, 8, chunk, offset);
|
||||
if (this.header.length < 8) break;
|
||||
total += readUInt32(this.header, 4, shared.littleEndian) * 4;
|
||||
}
|
||||
if (type === 0 || type === 1) {
|
||||
const sequence = readUInt16(this.header, 2, shared.littleEndian);
|
||||
const name = shared.pending.get(sequence);
|
||||
if (name !== undefined) {
|
||||
if (type === 1) {
|
||||
offset = collectHeader(this, 9, chunk, offset);
|
||||
if (this.header.length < 9) break;
|
||||
if (this.header[8] !== 0) {
|
||||
this.header[8] = 0; // QueryExtension.present = False
|
||||
if (!shared.warned) {
|
||||
shared.warned = true;
|
||||
shared.logger.warn?.(`[X11] hiding ${name}: forwarding cannot carry file descriptors`);
|
||||
}
|
||||
}
|
||||
}
|
||||
shared.pending.delete(sequence);
|
||||
}
|
||||
}
|
||||
this.remaining = total - this.header.length;
|
||||
}
|
||||
this.push(this.header);
|
||||
this.header = EMPTY;
|
||||
}
|
||||
callback();
|
||||
}
|
||||
|
||||
_flush(callback) {
|
||||
callback(null, this.header);
|
||||
}
|
||||
}
|
||||
|
||||
// SCM_RIGHTS descriptors cannot travel over an SSH byte stream. Hide extensions
|
||||
// that require them so clients select a supported rendering path instead.
|
||||
function createX11FdGuard(options = {}) {
|
||||
const hidden = new Set(options.hiddenExtensions ?? DEFAULT_HIDDEN_EXTENSIONS);
|
||||
const shared = {
|
||||
enabled: hidden.size > 0,
|
||||
hidden,
|
||||
maxNameLength: Math.max(0, ...Array.from(hidden, (name) => name.length)),
|
||||
littleEndian: true,
|
||||
pending: new Map(),
|
||||
warned: false,
|
||||
logger: options.logger || console,
|
||||
};
|
||||
return { toServer: new RequestTracker(shared), toClient: new ReplyFilter(shared) };
|
||||
}
|
||||
|
||||
module.exports = { createX11FdGuard, DEFAULT_HIDDEN_EXTENSIONS };
|
||||
@@ -0,0 +1,204 @@
|
||||
const test = require("node:test");
|
||||
const assert = require("node:assert/strict");
|
||||
const { once } = require("node:events");
|
||||
const { createX11FdGuard, DEFAULT_HIDDEN_EXTENSIONS } = require("./x11FdGuard.cjs");
|
||||
|
||||
function writeUInt16(buffer, value, offset, endian) {
|
||||
buffer[endian === "l" ? "writeUInt16LE" : "writeUInt16BE"](value, offset);
|
||||
}
|
||||
|
||||
function writeUInt32(buffer, value, offset, endian) {
|
||||
buffer[endian === "l" ? "writeUInt32LE" : "writeUInt32BE"](value, offset);
|
||||
}
|
||||
|
||||
function setupRequest(endian = "l") {
|
||||
const packet = Buffer.alloc(24, 0xab);
|
||||
packet[0] = endian.charCodeAt(0);
|
||||
writeUInt16(packet, 11, 2, endian);
|
||||
writeUInt16(packet, 3, 6, endian);
|
||||
writeUInt16(packet, 5, 8, endian);
|
||||
return packet;
|
||||
}
|
||||
|
||||
function setupReply(endian = "l", status = 1) {
|
||||
const packet = Buffer.alloc(20, 0xcd);
|
||||
packet[0] = status;
|
||||
writeUInt16(packet, 11, 2, endian);
|
||||
writeUInt16(packet, 3, 6, endian);
|
||||
return packet;
|
||||
}
|
||||
|
||||
function request(name, { endian = "l", big = false, opcode = 98 } = {}) {
|
||||
const nameBytes = Buffer.from(name, "latin1");
|
||||
const prefix = big ? 12 : 8;
|
||||
const packet = Buffer.alloc(prefix + Math.ceil(nameBytes.length / 4) * 4);
|
||||
packet[0] = opcode;
|
||||
writeUInt16(packet, big ? 0 : packet.length / 4, 2, endian);
|
||||
if (big) writeUInt32(packet, packet.length / 4, 4, endian);
|
||||
writeUInt16(packet, nameBytes.length, big ? 8 : 4, endian);
|
||||
nameBytes.copy(packet, prefix);
|
||||
return packet;
|
||||
}
|
||||
|
||||
function reply(sequence, { endian = "l", type = 1, present = 1, extra = 0 } = {}) {
|
||||
const packet = Buffer.alloc(32 + extra, 0xef);
|
||||
packet[0] = type;
|
||||
writeUInt16(packet, sequence, 2, endian);
|
||||
writeUInt32(packet, extra / 4, 4, endian);
|
||||
packet[8] = present;
|
||||
return packet;
|
||||
}
|
||||
|
||||
function withoutPresent(packet) {
|
||||
const copy = Buffer.from(packet);
|
||||
copy[8] = 0;
|
||||
return copy;
|
||||
}
|
||||
|
||||
function chunks(buffer, size) {
|
||||
if (!size) return [buffer];
|
||||
const result = [];
|
||||
for (let offset = 0; offset < buffer.length; offset += size) {
|
||||
result.push(buffer.subarray(offset, offset + size));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
async function exchange(uplink, downlink, { chunkSize, ...options } = {}) {
|
||||
const warnings = [];
|
||||
const guard = createX11FdGuard({ logger: { warn: (message) => warnings.push(message) }, ...options });
|
||||
const sent = [];
|
||||
const received = [];
|
||||
guard.toServer.on("data", (chunk) => sent.push(chunk));
|
||||
guard.toClient.on("data", (chunk) => received.push(chunk));
|
||||
const ended = Promise.all([once(guard.toServer, "end"), once(guard.toClient, "end")]);
|
||||
for (const chunk of chunks(uplink, chunkSize)) guard.toServer.write(chunk);
|
||||
for (const chunk of chunks(downlink, chunkSize)) guard.toClient.write(chunk);
|
||||
guard.toServer.end();
|
||||
guard.toClient.end();
|
||||
await ended;
|
||||
assert.deepEqual(Buffer.concat(sent), uplink, "uplink must stay byte-identical");
|
||||
return { received: Buffer.concat(received), warnings };
|
||||
}
|
||||
|
||||
for (const endian of ["l", "B"]) {
|
||||
for (const chunkSize of [undefined, 1]) {
|
||||
test(`default guard hides only DRI3 and MIT-SHM (${endian}, chunks ${chunkSize || "coalesced"})`, async () => {
|
||||
assert.deepEqual(DEFAULT_HIDDEN_EXTENSIONS, ["DRI3", "MIT-SHM"]);
|
||||
const names = ["DRI3", "GLX", "MIT-SHM", "RENDER", "dri3", "DRI3-extra", ""];
|
||||
const replies = names.map((_, index) => reply(index + 1, { endian }));
|
||||
const uplink = Buffer.concat([setupRequest(endian), ...names.map((name) => request(name, { endian }))]);
|
||||
const downlink = Buffer.concat([setupReply(endian), ...replies]);
|
||||
const expected = Buffer.concat([setupReply(endian), ...replies.map((packet, index) => (
|
||||
index === 0 || index === 2 ? withoutPresent(packet) : packet
|
||||
))]);
|
||||
const result = await exchange(uplink, downlink, { chunkSize });
|
||||
assert.deepEqual(result.received, expected);
|
||||
assert.equal(result.warnings.length, 1);
|
||||
assert.match(result.warnings[0], /^\[X11\] hiding DRI3/);
|
||||
assert.deepEqual(downlink, Buffer.concat([setupReply(endian), ...replies]), "input buffers must stay unchanged");
|
||||
});
|
||||
}
|
||||
|
||||
test(`BIG-REQUESTS use the extended header offsets (${endian})`, async () => {
|
||||
const queries = [
|
||||
request("DRI3", { endian, big: true }),
|
||||
request("MIT-SHM", { endian, big: true }),
|
||||
request("GLX", { endian, big: true }),
|
||||
request("DRI3", { endian }),
|
||||
];
|
||||
const replies = queries.map((_, index) => reply(index + 1, { endian }));
|
||||
const result = await exchange(
|
||||
Buffer.concat([setupRequest(endian), ...queries]),
|
||||
Buffer.concat([setupReply(endian), ...replies]),
|
||||
{ chunkSize: 1 },
|
||||
);
|
||||
assert.deepEqual(result.received, Buffer.concat([
|
||||
setupReply(endian), withoutPresent(replies[0]), withoutPresent(replies[1]), replies[2], withoutPresent(replies[3]),
|
||||
]));
|
||||
});
|
||||
}
|
||||
|
||||
test("an empty hide list is byte-identical and a custom list replaces the defaults", async () => {
|
||||
const uplink = Buffer.concat([setupRequest(), request("DRI3"), request("MIT-SHM"), request("GLX")]);
|
||||
const replies = [reply(1), reply(2), reply(3)];
|
||||
const downlink = Buffer.concat([setupReply(), ...replies]);
|
||||
const disabled = await exchange(uplink, downlink, { hiddenExtensions: [], chunkSize: 1 });
|
||||
assert.deepEqual(disabled.received, downlink);
|
||||
assert.deepEqual(disabled.warnings, []);
|
||||
const custom = await exchange(uplink, downlink, { hiddenExtensions: ["GLX"], chunkSize: 1 });
|
||||
assert.deepEqual(custom.received, Buffer.concat([setupReply(), replies[0], replies[1], withoutPresent(replies[2])]));
|
||||
assert.equal(custom.warnings.length, 1);
|
||||
assert.match(custom.warnings[0], /hiding GLX/);
|
||||
});
|
||||
|
||||
test("errors, unrelated replies, ordinary events and variable GenericEvents preserve sequence isolation", async () => {
|
||||
const uplink = Buffer.concat([setupRequest(), request("DRI3"), request("GLX"), request("MIT-SHM")]);
|
||||
const error = reply(1, { type: 0 });
|
||||
const afterError = reply(1);
|
||||
const unrelated = reply(2, { extra: 64 });
|
||||
const event = reply(3, { type: 12 });
|
||||
const generic = reply(3, { type: 35, extra: 48 });
|
||||
const sentGeneric = reply(3, { type: 0x80 | 35, extra: 12 });
|
||||
const hidden = reply(3);
|
||||
const repeated = reply(3);
|
||||
const prefix = [setupReply(), error, afterError, unrelated, event, generic, sentGeneric];
|
||||
const result = await exchange(uplink, Buffer.concat([...prefix, hidden, repeated]), { chunkSize: 1 });
|
||||
assert.deepEqual(result.received, Buffer.concat([...prefix, withoutPresent(hidden), repeated]));
|
||||
assert.equal(result.warnings.length, 1);
|
||||
assert.match(result.warnings[0], /hiding MIT-SHM/);
|
||||
});
|
||||
|
||||
test("absent extensions and failed queries do not log", async () => {
|
||||
const uplink = Buffer.concat([setupRequest(), request("DRI3"), request("MIT-SHM")]);
|
||||
const downlink = Buffer.concat([setupReply(), reply(1, { present: 0 }), reply(2, { type: 0 })]);
|
||||
const result = await exchange(uplink, downlink, { chunkSize: 1 });
|
||||
assert.deepEqual(result.received, downlink);
|
||||
assert.deepEqual(result.warnings, []);
|
||||
});
|
||||
|
||||
test("request bodies are skipped without mistaking embedded queries for requests", async () => {
|
||||
const body = Buffer.alloc(128 * 1024);
|
||||
request("DRI3").copy(body, 0);
|
||||
const large = Buffer.alloc(8 + body.length);
|
||||
large[0] = 18; // ChangeProperty, using BIG-REQUESTS framing
|
||||
large.writeUInt32LE(large.length / 4, 4);
|
||||
body.copy(large, 8);
|
||||
const uplink = Buffer.concat([setupRequest(), large, request("MIT-SHM")]);
|
||||
const visible = reply(1, { extra: 128 * 1024 });
|
||||
const hidden = reply(2);
|
||||
const result = await exchange(uplink, Buffer.concat([setupReply(), visible, hidden]), { chunkSize: 17 });
|
||||
assert.deepEqual(result.received, Buffer.concat([setupReply(), visible, withoutPresent(hidden)]));
|
||||
});
|
||||
|
||||
test("sequence wrap hides new queries and clears stale entries on reused sequences", async () => {
|
||||
const noOp = Buffer.from([127, 0, 1, 0]);
|
||||
const queries = [request("DRI3"), Buffer.concat(Array(65534).fill(noOp)), request("MIT-SHM"), noOp, request("DRI3")];
|
||||
const stale = reply(1);
|
||||
const wrapped = reply(0);
|
||||
const hidden = reply(2);
|
||||
const result = await exchange(
|
||||
Buffer.concat([setupRequest(), ...queries]),
|
||||
Buffer.concat([setupReply(), wrapped, stale, hidden]),
|
||||
{ chunkSize: 13 },
|
||||
);
|
||||
assert.deepEqual(result.received, Buffer.concat([setupReply(), withoutPresent(wrapped), stale, withoutPresent(hidden)]));
|
||||
});
|
||||
|
||||
test("setup failures and truncated headers flush unchanged", async () => {
|
||||
for (const status of [0, 2]) {
|
||||
const downlink = setupReply("B", status);
|
||||
const result = await exchange(setupRequest("B"), downlink, { chunkSize: 1 });
|
||||
assert.deepEqual(result.received, downlink);
|
||||
}
|
||||
const shortSetup = await exchange(setupRequest(), setupReply().subarray(0, 5), { chunkSize: 1 });
|
||||
assert.deepEqual(shortSetup.received, setupReply().subarray(0, 5));
|
||||
const partial = Buffer.concat([setupReply(), reply(1).subarray(0, 7)]);
|
||||
const result = await exchange(Buffer.concat([setupRequest(), request("DRI3")]), partial, { chunkSize: 1 });
|
||||
assert.deepEqual(result.received, partial);
|
||||
});
|
||||
|
||||
test("non-X11 payloads pass through unchanged", async () => {
|
||||
const result = await exchange(Buffer.from("remote"), Buffer.from("local"), { chunkSize: 1 });
|
||||
assert.equal(result.received.toString(), "local");
|
||||
});
|
||||
@@ -2,6 +2,7 @@ const net = require("node:net");
|
||||
const fs = require("node:fs");
|
||||
const { Transform } = require("node:stream");
|
||||
const { execFileSync } = require("node:child_process");
|
||||
const { createX11FdGuard } = require("./x11FdGuard.cjs");
|
||||
|
||||
const X11_PORT_BASE = 6000;
|
||||
const MIT_MAGIC_COOKIE_PROTOCOL = "MIT-MAGIC-COOKIE-1";
|
||||
@@ -253,11 +254,16 @@ function attachX11Forwarding(conn, options = {}) {
|
||||
const target = resolveX11DisplaySpec(display, { platform });
|
||||
const localSocket = createSocket();
|
||||
let acceptedChannel = null;
|
||||
let guard = null;
|
||||
let settled = false;
|
||||
|
||||
const cleanup = () => {
|
||||
if (acceptedChannel) destroyStream(acceptedChannel);
|
||||
destroyStream(localSocket);
|
||||
if (guard) {
|
||||
destroyStream(guard.toServer);
|
||||
destroyStream(guard.toClient);
|
||||
}
|
||||
};
|
||||
|
||||
localSocket.once("connect", () => {
|
||||
@@ -275,15 +281,19 @@ function attachX11Forwarding(conn, options = {}) {
|
||||
localSocket.on("error", () => cleanup());
|
||||
acceptedChannel.on("close", () => destroyStream(localSocket));
|
||||
localSocket.on("close", () => destroyStream(acceptedChannel));
|
||||
guard = createX11FdGuard({ hiddenExtensions: options.hiddenExtensions, logger });
|
||||
guard.toServer.on("error", cleanup);
|
||||
guard.toClient.on("error", cleanup);
|
||||
const realCookie = resolveLocalAuthCookie();
|
||||
if (realCookie && fakeCookie) {
|
||||
acceptedChannel
|
||||
.pipe(createX11AuthTransform({ fakeCookie, realCookie }))
|
||||
.pipe(localSocket)
|
||||
.pipe(acceptedChannel);
|
||||
.pipe(guard.toServer)
|
||||
.pipe(localSocket);
|
||||
} else {
|
||||
acceptedChannel.pipe(localSocket).pipe(acceptedChannel);
|
||||
acceptedChannel.pipe(guard.toServer).pipe(localSocket);
|
||||
}
|
||||
localSocket.pipe(guard.toClient).pipe(acceptedChannel);
|
||||
});
|
||||
|
||||
localSocket.once("error", (err) => {
|
||||
|
||||
@@ -181,6 +181,7 @@ test("attachX11Forwarding pipes accepted X11 channels to the local display socke
|
||||
attachX11Forwarding(conn, {
|
||||
display: ":0",
|
||||
createSocket: () => localSocket,
|
||||
readLocalAuthCookie: () => null,
|
||||
sendMessage: (message) => messages.push(message),
|
||||
platform: "linux",
|
||||
});
|
||||
@@ -203,6 +204,79 @@ test("attachX11Forwarding pipes accepted X11 channels to the local display socke
|
||||
assert.deepEqual(messages, []);
|
||||
});
|
||||
|
||||
for (const rewriteCookie of [false, true]) {
|
||||
test(`attachX11Forwarding hides fd extensions with cookie rewriting ${rewriteCookie ? "enabled" : "disabled"}`, async (t) => {
|
||||
const conn = new EventEmitter();
|
||||
const capturedLocal = [];
|
||||
const capturedRemote = [];
|
||||
const warnings = [];
|
||||
const makeDuplex = (captured) => new Duplex({
|
||||
read() {},
|
||||
write(chunk, _encoding, callback) {
|
||||
captured.push(Buffer.from(chunk));
|
||||
callback();
|
||||
},
|
||||
});
|
||||
const localSocket = makeDuplex(capturedLocal);
|
||||
const acceptedChannel = makeDuplex(capturedRemote);
|
||||
t.after(() => {
|
||||
localSocket.destroy();
|
||||
acceptedChannel.destroy();
|
||||
});
|
||||
localSocket.connect = () => {
|
||||
queueMicrotask(() => localSocket.emit("connect"));
|
||||
return localSocket;
|
||||
};
|
||||
const fakeCookie = "11111111111111111111111111111111";
|
||||
const realCookie = "22222222222222222222222222222222";
|
||||
attachX11Forwarding(conn, {
|
||||
display: ":0",
|
||||
platform: "linux",
|
||||
createSocket: () => localSocket,
|
||||
fakeCookie: rewriteCookie ? fakeCookie : undefined,
|
||||
readLocalAuthCookie: () => rewriteCookie ? Buffer.from(realCookie, "hex") : null,
|
||||
logger: { warn: (message) => warnings.push(message) },
|
||||
});
|
||||
conn.emit("x11", {}, () => acceptedChannel, () => assert.fail("unexpected reject"));
|
||||
await new Promise((resolve) => setImmediate(resolve));
|
||||
|
||||
const setup = buildX11SetupPacket({ cookie: fakeCookie });
|
||||
const queries = ["DRI3", "MIT-SHM", "GLX"].map((name) => {
|
||||
const packet = Buffer.alloc(8 + Math.ceil(name.length / 4) * 4);
|
||||
packet[0] = 98;
|
||||
packet.writeUInt16LE(packet.length / 4, 2);
|
||||
packet.writeUInt16LE(name.length, 4);
|
||||
packet.write(name, 8, "ascii");
|
||||
return packet;
|
||||
});
|
||||
// Fragment the auth packet, coalescing its tail with the first requests.
|
||||
acceptedChannel.push(setup.subarray(0, 7));
|
||||
acceptedChannel.push(Buffer.concat([setup.subarray(7), ...queries]));
|
||||
await new Promise((resolve) => setImmediate(resolve));
|
||||
assert.deepEqual(Buffer.concat(capturedLocal), Buffer.concat([
|
||||
buildX11SetupPacket({ cookie: rewriteCookie ? realCookie : fakeCookie }), ...queries,
|
||||
]));
|
||||
|
||||
const setupReply = Buffer.from([1, 0, 11, 0, 0, 0, 0, 0]);
|
||||
const replies = queries.map((_, index) => {
|
||||
const packet = Buffer.alloc(32);
|
||||
packet[0] = 1;
|
||||
packet.writeUInt16LE(index + 1, 2);
|
||||
packet[8] = 1;
|
||||
return packet;
|
||||
});
|
||||
const response = Buffer.concat([setupReply, ...replies]);
|
||||
for (const byte of response) localSocket.push(Buffer.from([byte]));
|
||||
await new Promise((resolve) => setImmediate(resolve));
|
||||
const expected = Buffer.from(response);
|
||||
expected[8 + 8] = 0;
|
||||
expected[8 + 32 + 8] = 0;
|
||||
assert.deepEqual(Buffer.concat(capturedRemote), expected);
|
||||
assert.equal(warnings.length, 1);
|
||||
assert.match(warnings[0], /^\[X11\] hiding DRI3/);
|
||||
});
|
||||
}
|
||||
|
||||
test("attachX11Forwarding rejects the remote channel and explains local display failures", async () => {
|
||||
const conn = new EventEmitter();
|
||||
const localSocket = new EventEmitter();
|
||||
|
||||
Reference in new issue
Block a user