Imports the previously untracked working tree as-is so that the review changes that follow (requirements -> design -> implementation) can be reviewed as diffs and reverted if needed. No content changes. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
264 lines
14 KiB
JavaScript
264 lines
14 KiB
JavaScript
'use strict';
|
|
|
|
const test = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const fs = require('node:fs');
|
|
const os = require('node:os');
|
|
const path = require('node:path');
|
|
const { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } = require('@theia/core/lib/common/message-rpc/uint8-array-message-buffer');
|
|
const { MsgPackMessageDecoder, MsgPackMessageEncoder } = require('@theia/core/lib/common/message-rpc/rpc-message-encoder');
|
|
const { BatchingChannel, RPCProtocolImpl, createProxyIdentifier } = require('@theia/plugin-ext/lib/common/rpc-protocol');
|
|
const { ConnectionImpl } = require('@theia/plugin-ext/lib/common/connection');
|
|
const { ForwardingDebugChannel } = require('@theia/debug/lib/common/debug-service');
|
|
const { Emitter } = require('@theia/core/lib/common/event');
|
|
const { filterPluginRpc, guardDebugChannel, MAX_BATCH_MESSAGES } = require('../plugin-dap-guard.cjs');
|
|
const { Coordinator, DEBUG_LEASE_MS } = require('../../coordination/index.cjs');
|
|
|
|
const encoder = new MsgPackMessageEncoder();
|
|
const decoder = new MsgPackMessageDecoder();
|
|
const deny = () => { throw new Error('DEBUG_FORBIDDEN'); };
|
|
function rpc(method, service, id = 1, type = 1, rest = []) {
|
|
const writer = new Uint8ArrayWriteBuffer();
|
|
if (type === 2) encoder.notification(writer, method, [service, ...rest], id);
|
|
else encoder.request(writer, id, method, [service, ...rest]);
|
|
return writer.getCurrentContents();
|
|
}
|
|
function batch(...messages) {
|
|
const writer = new Uint8ArrayWriteBuffer();
|
|
writer.writeLength(messages.length);
|
|
for (const message of messages) writer.writeBytes(message);
|
|
return writer.getCurrentContents();
|
|
}
|
|
function decode(payload) {
|
|
if (!payload) return [];
|
|
const reader = new Uint8ArrayReadBuffer(payload);
|
|
const count = reader.readLength();
|
|
return Array.from({ length: count }, () => decoder.parse(new Uint8ArrayReadBuffer(reader.readBytes())));
|
|
}
|
|
function memoryChannel() {
|
|
const messages = new Emitter();
|
|
const errors = new Emitter();
|
|
const closes = new Emitter();
|
|
const sent = [];
|
|
let closed = false;
|
|
return {
|
|
sent, get closed() { return closed; },
|
|
onMessage: messages.event, onError: errors.event, onClose: closes.event,
|
|
getWriteBuffer() { const writer = new Uint8ArrayWriteBuffer(); writer.onCommit(value => sent.push(value)); return writer; },
|
|
close() { closed = true; closes.fire({ code: 1000, reason: 'closed' }); },
|
|
receive(bytes) { messages.fire(() => new Uint8ArrayReadBuffer(bytes)); },
|
|
};
|
|
}
|
|
|
|
test('real Theia RPCProtocol emits the DebugExt wire shape gated by the filter', async () => {
|
|
const wire = memoryChannel();
|
|
const protocol = new RPCProtocolImpl(wire);
|
|
const pending = protocol.getProxy(createProxyIdentifier('DebugExt')).$createDebugSession({ type: 'pwa-node', name: 'test' }, 'file:///workspace');
|
|
const rejected = assert.rejects(pending, /DEBUG_CONTROL_REQUIRED/);
|
|
await new Promise(resolve => setImmediate(resolve));
|
|
assert.equal(wire.sent.length, 1);
|
|
const actual = decode(wire.sent[0]);
|
|
assert.equal(actual[0].method, '$createDebugSession');
|
|
assert.equal(actual[0].args[0], 'DebugExt');
|
|
const result = filterPluginRpc(wire.sent[0], deny);
|
|
assert.equal(result.forwarded, null);
|
|
assert.equal(result.denied, 1);
|
|
wire.receive(result.replies);
|
|
await rejected;
|
|
protocol.dispose();
|
|
});
|
|
|
|
test('unauthorized plugin create/terminate/send/delete requests never enter the forwarded host batch', () => {
|
|
const calls = [
|
|
rpc('$createDebugSession', 'DebugExt', 10), rpc('$terminateDebugSession', 'DebugExt', 11),
|
|
rpc('$sendMessage', 'ConnectionExt', 12, 1, ['session', '{"command":"continue"}']), rpc('$deleteConnection', 'ConnectionExt', 13),
|
|
];
|
|
const result = filterPluginRpc(batch(...calls), deny);
|
|
assert.equal(result.forwarded, null);
|
|
assert.equal(result.denied, 4);
|
|
assert.deepEqual(decode(result.replies).map(message => ({ type: message.type, id: message.id, error: message.err.message })), [10, 11, 12, 13].map(id => ({ type: 4, id, error: 'DEBUG_CONTROL_REQUIRED' })));
|
|
});
|
|
|
|
test('denied plugin DAP reaches real frontend RPCProtocol and ConnectionMain as a failed response', async () => {
|
|
const wire = memoryChannel();
|
|
const protocol = new RPCProtocolImpl(wire);
|
|
const proxy = protocol.getProxy(createProxyIdentifier('ConnectionExt'));
|
|
const connectionMain = protocol.set(createProxyIdentifier('ConnectionMain'), new ConnectionImpl(proxy));
|
|
const frontendChannel = await connectionMain.doEnsureConnection('session-real');
|
|
const received = [];
|
|
frontendChannel.onMessage(message => received.push(JSON.parse(message)));
|
|
let previousSequence = 0;
|
|
try {
|
|
for (const [seq, command] of [[31, 'next'], [32, 'continue']]) {
|
|
const pending = proxy.$sendMessage('session-real', JSON.stringify({ type: 'request', seq, command, arguments: { threadId: 1 } }));
|
|
const rejected = assert.rejects(pending, /DEBUG_CONTROL_REQUIRED/);
|
|
await new Promise(resolve => setImmediate(resolve));
|
|
const result = filterPluginRpc(wire.sent.at(-1), deny);
|
|
assert.equal(result.forwarded, null);
|
|
assert.equal(result.denied, 1);
|
|
const messages = decode(result.replies);
|
|
assert.equal(messages[0].type, 4);
|
|
assert.equal(messages[1].type, 2);
|
|
assert.equal(messages[1].method, '$sendMessage');
|
|
assert.deepEqual(messages[1].args.slice(0, 2), ['ConnectionMain', 'session-real']);
|
|
wire.receive(result.replies);
|
|
await rejected;
|
|
const response = received.at(-1);
|
|
assert.ok(Number.isSafeInteger(response.seq) && response.seq > previousSequence);
|
|
previousSequence = response.seq;
|
|
assert.deepEqual({ ...response, seq: undefined }, {
|
|
seq: undefined, type: 'response', request_seq: seq, command, success: false,
|
|
message: 'WishForge debug controller lease required',
|
|
});
|
|
}
|
|
assert.equal(received.length, 2);
|
|
} finally { protocol.dispose(); }
|
|
});
|
|
|
|
test('denied DAP carried as an RPC notification receives only a DAP failure notification', () => {
|
|
const request = JSON.stringify({ type: 'request', seq: 4, command: 'disconnect' });
|
|
const result = filterPluginRpc(batch(rpc('$sendMessage', 'ConnectionExt', 42, 2, ['session-one', request])), deny);
|
|
assert.equal(result.forwarded, null);
|
|
assert.equal(result.denied, 1);
|
|
const replies = decode(result.replies);
|
|
assert.equal(replies.length, 1);
|
|
assert.equal(replies[0].type, 2);
|
|
assert.deepEqual(replies[0].args.slice(0, 2), ['ConnectionMain', 'session-one']);
|
|
assert.equal(JSON.parse(replies[0].args[2]).request_seq, 4);
|
|
});
|
|
|
|
test('malformed or nonrequest denied plugin DAP never fabricates a DAP response', () => {
|
|
const cases = [
|
|
['session', 'bad-json'], ['session', 'null'], ['session', '[]'],
|
|
['session', '{"type":"event","seq":1,"command":"next"}'],
|
|
['session', '{"type":"request","seq":"1","command":"next"}'],
|
|
['session', '{"type":"request","seq":-1,"command":"next"}'],
|
|
['session', '{"type":"request","seq":1}'],
|
|
['session', '{"type":"request","seq":1,"command":""}'],
|
|
['session', { type: 'request', seq: 1, command: 'next' }],
|
|
['', '{"type":"request","seq":1,"command":"next"}'],
|
|
[5, '{"type":"request","seq":1,"command":"next"}'],
|
|
];
|
|
for (const args of cases) {
|
|
const result = filterPluginRpc(batch(rpc('$sendMessage', 'ConnectionExt', 42, 1, args)), deny);
|
|
assert.equal(result.forwarded, null);
|
|
assert.equal(result.denied, 1);
|
|
const replies = decode(result.replies);
|
|
assert.equal(replies.length, 1);
|
|
assert.equal(replies[0].type, 4);
|
|
assert.equal(replies[0].err.message, 'DEBUG_CONTROL_REQUIRED');
|
|
}
|
|
});
|
|
|
|
test('ordinary RPC forwards byte-for-byte while denied notifications do not fabricate replies', () => {
|
|
const ordinary = rpc('$acceptModelChanged', 'EditorsAndDocumentsExt', 1, 2);
|
|
const reply = new Uint8ArrayWriteBuffer();
|
|
encoder.replyOK(reply, 8, { success: true });
|
|
const result = filterPluginRpc(batch(ordinary, rpc('$sendMessage', 'ConnectionExt', 2, 2), reply.getCurrentContents()), deny);
|
|
assert.deepEqual(result.forwarded, batch(ordinary, reply.getCurrentContents()));
|
|
assert.equal(result.replies, null);
|
|
assert.equal(result.denied, 1);
|
|
});
|
|
|
|
test('controller forwarding preserves actual BatchingChannel bytes and rechecks authorization for every command', () => {
|
|
const wire = memoryChannel();
|
|
const batching = new BatchingChannel(wire);
|
|
const first = batching.getWriteBuffer(); encoder.request(first, 1, '$createDebugSession', ['DebugExt']); first.commit();
|
|
const second = batching.getWriteBuffer(); encoder.request(second, 2, '$sendMessage', ['ConnectionExt', 'session', '{}']); second.commit();
|
|
batching.sendAccumulated();
|
|
const payload = wire.sent[0];
|
|
let checks = 0;
|
|
const allowed = filterPluginRpc(payload, () => { checks++; });
|
|
assert.deepEqual(allowed.forwarded, payload);
|
|
assert.equal(allowed.replies, null);
|
|
assert.equal(checks, 2);
|
|
checks = 0;
|
|
const revokedMidBatch = filterPluginRpc(payload, () => { if (++checks === 2) deny(); });
|
|
assert.equal(decode(revokedMidBatch.forwarded).length, 1);
|
|
assert.equal(decode(revokedMidBatch.replies)[0].id, 2);
|
|
batching.close();
|
|
});
|
|
|
|
test('malformed, truncated, oversized or trailing frames fail atomically before any forwarding', () => {
|
|
const good = batch(rpc('$createDebugSession', 'DebugExt'));
|
|
const excessive = new Uint8ArrayWriteBuffer(); excessive.writeLength(MAX_BATCH_MESSAGES + 1);
|
|
const invalidInner = new Uint8ArrayWriteBuffer(); invalidInner.writeLength(100); invalidInner.writeRaw(new Uint8Array([1]));
|
|
const wrongShape = new Uint8ArrayWriteBuffer(); encoder.encode(wrongShape, { type: 1, id: 3, method: '$sendMessage', args: { 0: 'ConnectionExt' } });
|
|
for (const bytes of [new Uint8Array(), good.slice(0, -1), new Uint8Array([...good, 0]), excessive.getCurrentContents(), batch(invalidInner.getCurrentContents()), batch(wrongShape.getCurrentContents()), new Uint8Array([129, 129, 129, 129, 129, 0])]) {
|
|
let invoked = false;
|
|
assert.throws(() => filterPluginRpc(bytes, () => { invoked = true; }), /PLUGIN_RPC|RPC_BATCH_LIMIT/);
|
|
assert.equal(invoked, false);
|
|
}
|
|
// Prevent reading into extra bytes from a websocket buffer outside the actual view.
|
|
const backed = new Uint8Array([...good, ...good]);
|
|
assert.throws(() => filterPluginRpc(backed.subarray(0, good.length - 1), deny), /PLUGIN_RPC/);
|
|
assert.deepEqual(filterPluginRpc(batch(), deny), { forwarded: null, replies: null, denied: 0 });
|
|
});
|
|
|
|
test('guard cannot accidentally authorize on a false or asynchronous decision', () => {
|
|
const payload = batch(rpc('$sendMessage', 'ConnectionExt'));
|
|
for (const callback of [() => false, () => Promise.resolve(true)]) assert.equal(filterPluginRpc(payload, callback).forwarded, null);
|
|
assert.throws(() => filterPluginRpc(payload), /DEBUG_GUARD_REQUIRED/);
|
|
});
|
|
|
|
test('real coordinator lease owner, renewal, expiry and revocation govern plugin forwarding', t => {
|
|
const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'wishforge-debug-guard-'));
|
|
const workspaceRoot = path.join(directory, 'source'); fs.mkdirSync(workspaceRoot);
|
|
let now = 1000;
|
|
const coordinator = new Coordinator({ workspaceRoot, stateDirectory: path.join(directory, 'state'), now: () => now });
|
|
t.after(() => fs.rmSync(directory, { recursive: true, force: true }));
|
|
const alice = coordinator.debugAcquire('alice');
|
|
const payload = batch(rpc('$sendMessage', 'ConnectionExt'));
|
|
assert.equal(filterPluginRpc(payload, () => coordinator.assertDebugController('bob', alice.token)).forwarded, null);
|
|
assert.equal(filterPluginRpc(payload, () => coordinator.assertDebugController('alice', 'another-tab-token')).forwarded, null);
|
|
const permitted = () => coordinator.assertDebugController('alice', alice.token);
|
|
assert.deepEqual(filterPluginRpc(payload, permitted).forwarded, payload);
|
|
now += 10_000;
|
|
coordinator.debugAcquire('alice', alice.token);
|
|
now += DEBUG_LEASE_MS - 10_000;
|
|
assert.deepEqual(filterPluginRpc(payload, permitted).forwarded, payload);
|
|
now += 10_000;
|
|
assert.equal(filterPluginRpc(payload, permitted).forwarded, null);
|
|
const next = coordinator.debugAcquire('alice');
|
|
assert.deepEqual(filterPluginRpc(payload, () => coordinator.assertDebugController('alice', next.token)).forwarded, payload);
|
|
coordinator.revoke('alice');
|
|
assert.equal(filterPluginRpc(payload, () => coordinator.assertDebugController('alice', next.token)).forwarded, null);
|
|
});
|
|
|
|
test('native DAP wrapper checks the live lease before adapter callback and sends decodable denials', () => {
|
|
const wire = memoryChannel();
|
|
const raw = new ForwardingDebugChannel(wire);
|
|
let allowed = false;
|
|
const guarded = guardDebugChannel(raw, () => { if (!allowed) deny(); });
|
|
const received = [];
|
|
guarded.onMessage(message => received.push(JSON.parse(message)));
|
|
const incoming = (seq, command) => {
|
|
const writer = new Uint8ArrayWriteBuffer(); writer.writeString(JSON.stringify({ type: 'request', seq, command })); wire.receive(writer.getCurrentContents());
|
|
};
|
|
incoming(1, 'launch'); incoming(2, 'continue');
|
|
assert.deepEqual(received, []);
|
|
const errors = wire.sent.map(bytes => JSON.parse(new Uint8ArrayReadBuffer(bytes).readString()));
|
|
assert.deepEqual(errors.map(error => [error.seq, error.request_seq, error.command, error.success]), [[1, 1, 'launch', false], [2, 2, 'continue', false]]);
|
|
allowed = true; incoming(3, 'next');
|
|
assert.equal(received[0].command, 'next');
|
|
allowed = false; incoming(4, 'disconnect');
|
|
assert.equal(received.length, 1);
|
|
guarded.send(JSON.stringify({ type: 'event', event: 'stopped' }));
|
|
assert.equal(JSON.parse(new Uint8ArrayReadBuffer(wire.sent.at(-1)).readString()).event, 'stopped');
|
|
guarded.close();
|
|
assert.equal(wire.closed, true);
|
|
});
|
|
|
|
test('unauthorized malformed native DAP closes channel without reaching adapter', () => {
|
|
for (const message of ['bad-json', 'null', '{"type":"event","event":"stopped"}', '{"type":"request","seq":1}']) {
|
|
const wire = memoryChannel();
|
|
const guarded = guardDebugChannel(new ForwardingDebugChannel(wire), deny);
|
|
let reached = false;
|
|
guarded.onMessage(() => { reached = true; });
|
|
const writer = new Uint8ArrayWriteBuffer(); writer.writeString(message); wire.receive(writer.getCurrentContents());
|
|
assert.equal(reached, false);
|
|
assert.equal(wire.closed, true);
|
|
assert.equal(wire.sent.length, 0);
|
|
}
|
|
});
|