Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

fix: refuse browser traffic at the runner boundary

[._.]/ Adam Eivy31cbb421d75a
diff --git a/lib/portosAuthCore.js b/lib/portosAuthCore.js
index b797c3fe31..2b967e4863 100644
--- a/lib/portosAuthCore.js
+++ b/lib/portosAuthCore.js
@@ -288,7 +288,7 @@ export const isAllowedHost = (hostHeader, { env = process.env, machineHostname =
// Browsers stamp every request with `Sec-Fetch-Site` and every cross-origin or
// state-changing one with `Origin`; curl, agents, peers, and native companion
// apps send neither, so they never reach the checks below.
-const isBrowserRequest = (req) => Boolean(req.headers?.origin || req.headers?.['sec-fetch-site']);
+export const isBrowserRequest = (req) => Boolean(req.headers?.origin || req.headers?.['sec-fetch-site']);
// The browser-relay guard. Applies whether or not the optional password is
// set: without it, any page the user opens could drive loopback APIs (a
diff --git a/server/cos-runner/index.js b/server/cos-runner/index.js
index b1b06b0c61..2a8ef3ee94 100644
--- a/server/cos-runner/index.js
+++ b/server/cos-runner/index.js
@@ -15,6 +15,7 @@ import '../services/databaseBootFence.js';
*/
import express from 'express';
+import { runnerRequestGuard, runnerRequestRefusal } from './requestGuard.js';
import { assertDatabaseAdmission } from '../lib/databaseMaintenanceJournal.js';
import { spawn } from '../lib/childProcess.js';
import * as pty from 'node-pty';
@@ -104,13 +105,17 @@ const armForceKill = (agentId, agent, opts = {}) =>
// Express app setup
const app = express();
+app.use(runnerRequestGuard);
app.use(express.json({ limit: '10mb' }));
const server = http.createServer(app);
const io = new SocketServer(server, {
- cors: { origin: '*' }
+ allowRequest: (req, callback) => callback(null, runnerRequestRefusal(req) === null)
});
+// Check subsequent polling requests and upgrades too, even with an existing sid.
+io.engine.use(runnerRequestGuard);
+
const httpDrain = createHttpDrain([server]);
let transportClose;
const lifecycle = createRunnerShutdown({
diff --git a/server/cos-runner/index.test.js b/server/cos-runner/index.test.js
index d3ba58b01e..cfefa0cd63 100644
--- a/server/cos-runner/index.test.js
+++ b/server/cos-runner/index.test.js
@@ -205,3 +205,15 @@ describe('cos-runner output — ANSI decoloring parity with spawnDirectly', () =
expect(RUNNER_SRC).toMatch(/if \(!trimmedDecolored \|\| isKnownCliStderrNoise\(trimmedDecolored\)\) return;/);
});
});
+
+describe('runner browser boundary wiring', () => {
+ it('guards HTTP before parsing and every Socket.IO transport request', () => {
+ const guard = RUNNER_SRC.indexOf('app.use(runnerRequestGuard)');
+ expect(guard).toBeGreaterThan(-1);
+ expect(guard).toBeLessThan(RUNNER_SRC.indexOf('app.use(express.json'));
+ expect(guard).toBeLessThan(RUNNER_SRC.indexOf('app.post('));
+ expect(RUNNER_SRC).toContain('allowRequest: (req, callback) => callback(null, runnerRequestRefusal(req) === null)');
+ expect(RUNNER_SRC).toContain('io.engine.use(runnerRequestGuard)');
+ expect(RUNNER_SRC).not.toContain("origin: '*'");
+ });
+});
diff --git a/server/cos-runner/requestGuard.js b/server/cos-runner/requestGuard.js
new file mode 100644
index 0000000000..8a1077e86d
--- /dev/null
+++ b/server/cos-runner/requestGuard.js
@@ -0,0 +1,31 @@
+import { isBrowserRequest } from '../../lib/portosAuthCore.js';
+
+const LOOPBACK_HOSTS = new Set(['localhost', '127.0.0.1', '::1']);
+const WILDCARD_HOSTS = new Set(['0.0.0.0', '::', '*']);
+
+// Parse an authority, not a URL: userinfo, paths and malformed ports must not
+// turn an attacker-controlled Host into an allowed hostname.
+const hostname = (value) => {
+ if (typeof value !== 'string') return null;
+ if (value === '::1' || value === '::') return value;
+ const match = /^(?:\[([a-f\d:]+)\]|([a-z\d.-]+))(?::\d{1,5})?$/i.exec(value);
+ return match ? (match[1] || match[2]).toLowerCase() : null;
+};
+
+export const runnerRequestRefusal = (req, { host = process.env.HOST } = {}) => {
+ if (isBrowserRequest(req)) return 'BROWSER_REQUEST_REJECTED';
+ const requestedHost = hostname(req.headers?.host);
+ const configuredHost = hostname(host);
+ if (requestedHost && (LOOPBACK_HOSTS.has(requestedHost)
+ || (configuredHost && !WILDCARD_HOSTS.has(configuredHost) && requestedHost === configuredHost))) return null;
+ return 'HOST_NOT_ALLOWED';
+};
+
+// Express and Engine.IO share this boundary; neither browser pages nor DNS
+// rebinding names may borrow the runner's unauthenticated native-client access.
+export const runnerRequestGuard = (req, res, next) => {
+ const code = runnerRequestRefusal(req);
+ if (!code) return next();
+ res.writeHead(403, { 'Content-Type': 'application/json' });
+ res.end(JSON.stringify({ error: 'Runner accepts only trusted native clients', code }));
+};
diff --git a/server/cos-runner/requestGuard.test.js b/server/cos-runner/requestGuard.test.js
new file mode 100644
index 0000000000..26d2fec868
--- /dev/null
+++ b/server/cos-runner/requestGuard.test.js
@@ -0,0 +1,115 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import express from 'express';
+import { createServer, request } from 'node:http';
+import { Server } from 'socket.io';
+import { io as connect } from 'socket.io-client';
+import { runnerRequestGuard, runnerRequestRefusal } from './requestGuard.js';
+
+const headers = (extra = {}) => ({ host: 'localhost:5558', ...extra });
+
+describe('runner native-client boundary', () => {
+ it.each([
+ [{}, null],
+ [{ host: '127.0.0.1:5558' }, null],
+ [{ host: '[::1]:5558' }, null],
+ [{ host: '::1' }, null],
+ [{ 'sec-fetch-mode': 'cors' }, null],
+ [{ origin: 'https://attacker.example' }, 'BROWSER_REQUEST_REJECTED'],
+ [{ origin: 'http://localhost:5555' }, 'BROWSER_REQUEST_REJECTED'],
+ [{ origin: 'null' }, 'BROWSER_REQUEST_REJECTED'],
+ [{ 'sec-fetch-site': 'same-origin' }, 'BROWSER_REQUEST_REJECTED'],
+ [{ host: 'rebind.attacker.example:5558' }, 'HOST_NOT_ALLOWED'],
+ [{ host: 'localhost.attacker.example' }, 'HOST_NOT_ALLOWED'],
+ [{ host: 'attacker.example@localhost:5558' }, 'HOST_NOT_ALLOWED'],
+ [{ host: 'localhost:5558/path' }, 'HOST_NOT_ALLOWED'],
+ [{ host: '[::1]evil' }, 'HOST_NOT_ALLOWED'],
+ [{ host: undefined }, 'HOST_NOT_ALLOWED'],
+ ])('classifies %j', (extra, expected) => {
+ expect(runnerRequestRefusal({ headers: headers(extra) }, { host: undefined })).toBe(expected);
+ });
+
+ it('allows only the explicitly configured hostname, never a wildcard bind', () => {
+ expect(runnerRequestRefusal({ headers: headers({ host: 'runner.example:5558' }) }, { host: 'runner.example' })).toBeNull();
+ for (const host of ['0.0.0.0', '::', '[::]', '*']) {
+ expect(runnerRequestRefusal({ headers: headers({ host }) }, { host })).toBe('HOST_NOT_ALLOWED');
+ expect(runnerRequestRefusal({ headers: headers({ host: 'attacker.example' }) }, { host })).toBe('HOST_NOT_ALLOWED');
+ }
+ });
+});
+
+// Real transports with harmless echo handlers: never contact the installed
+// runner or spawn/control an agent to test admission.
+describe('runner HTTP and Socket.IO admission', () => {
+ let io;
+ const clients = [];
+ afterEach(async () => {
+ for (const client of clients.splice(0)) client.close();
+ if (io) await new Promise(resolve => io.close(resolve));
+ });
+
+ const fixture = async () => {
+ const app = express();
+ app.use(runnerRequestGuard);
+ app.use(express.json());
+ app.post('/terminate-all', (_req, res) => res.json({ reached: true }));
+ const server = createServer(app);
+ io = new Server(server, {
+ allowRequest: (req, callback) => callback(null, runnerRequestRefusal(req) === null)
+ });
+ io.engine.use(runnerRequestGuard);
+ io.on('connection', socket => socket.on('tui:input', (payload, acknowledge) => acknowledge(payload)));
+ await new Promise((resolve, reject) => {
+ server.once('error', reject);
+ server.listen(0, '127.0.0.1', resolve);
+ });
+ return `http://127.0.0.1:${server.address().port}`;
+ };
+
+ const httpRequest = (url, extra, path = '/terminate-all', method = 'POST') => new Promise((resolve, reject) => {
+ const req = request(`${url}${path}`, { method, headers: extra }, res => {
+ let body = '';
+ res.on('data', chunk => { body += chunk; });
+ res.on('end', () => resolve({ status: res.statusCode, body }));
+ });
+ req.on('error', reject);
+ req.end();
+ });
+
+ it('refuses no-preflight POSTs and rebind Hosts before routes or JSON parsing', async () => {
+ const url = await fixture();
+ for (const extra of [{ Origin: 'https://attacker.example' }, { 'Sec-Fetch-Site': 'same-origin' }, { Host: 'attacker.example:5558' }]) {
+ const response = await httpRequest(url, extra);
+ expect(response.status).toBe(403);
+ expect(JSON.parse(response.body).code).toMatch(/REJECTED|NOT_ALLOWED/);
+ }
+ const native = await fetch(`${url}/terminate-all`, { method: 'POST' });
+ expect(await native.json()).toEqual({ reached: true });
+ });
+
+ it.each(['polling', 'websocket'])('rejects browser and rebind %s handshakes; preserves native TUI relay', async transport => {
+ const url = await fixture();
+ const hostileHeaders = [{ Origin: 'https://attacker.example' }, { Origin: 'http://localhost:5555' }, { 'Sec-Fetch-Site': 'same-origin' }];
+ // The polling client's XMLHttpRequest implementation strips Host overrides.
+ // Use raw HTTP for that handshake so the hostile header reaches the server.
+ if (transport === 'polling') {
+ expect((await httpRequest(url, { Host: 'attacker.example:5558' }, '/socket.io/?EIO=4&transport=polling', 'GET')).status).toBe(403);
+ } else hostileHeaders.push({ Host: 'attacker.example:5558' });
+ for (const extraHeaders of hostileHeaders) {
+ const client = connect(url, { transports: [transport], extraHeaders, reconnection: false, timeout: 2000 });
+ clients.push(client);
+ const result = await new Promise(resolve => {
+ client.once('connect', () => resolve('connected'));
+ client.once('connect_error', () => resolve('refused'));
+ });
+ expect(result, JSON.stringify(extraHeaders)).toBe('refused');
+ }
+ const client = connect(url, { transports: [transport], reconnection: false, timeout: 2000 });
+ clients.push(client);
+ await new Promise((resolve, reject) => { client.once('connect', resolve); client.once('connect_error', reject); });
+ const payload = { sessionId: 'synthetic-session', data: 'synthetic-input' };
+ expect(await client.timeout(2000).emitWithAck('tui:input', payload)).toEqual(payload);
+ // An already-issued sid does not bypass the HTTP guard on later packets.
+ const response = await httpRequest(url, { Origin: 'https://attacker.example' }, `/socket.io/?EIO=4&transport=polling&sid=${client.io.engine.id}`);
+ expect(response.status).toBe(403);
+ });
+});
diff --git a/server/cos-runner/shutdown.test.js b/server/cos-runner/shutdown.test.js
index c6fe12080c..9acda1859c 100644
--- a/server/cos-runner/shutdown.test.js
+++ b/server/cos-runner/shutdown.test.js
@@ -1,3 +1,4 @@
+import { runnerRequestGuard, runnerRequestRefusal } from './requestGuard.js';
import { maintenance } from '../lib/maintenanceAdmission.js';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { EventEmitter } from 'node:events';
@@ -66,7 +67,7 @@ function runner(assertDatabaseAdmission = vi.fn()) {
listen: vi.fn(), close: vi.fn(cb => cb?.()), closeAllConnections: vi.fn(),
});
const io = Object.assign(new EventEmitter(), {
- use: vi.fn(), close: vi.fn(cb => cb?.()),
+ engine: { use: vi.fn() }, use: vi.fn(), close: vi.fn(cb => cb?.()),
});
const process = Object.assign(new EventEmitter(), { env: {}, exit: vi.fn() });
const state = { agents: {}, stats: { spawned: 0, completed: 0, failed: 0 } };
@@ -105,6 +106,7 @@ function runner(assertDatabaseAdmission = vi.fn()) {
watch: vi.fn(() => () => {}),
}));
runInNewContext(source, {
+ runnerRequestGuard, runnerRequestRefusal,
assertDatabaseAdmission, maintenance, withBackupAssetPublication, persistRunnerCompletion,
express, http: { createServer: () => server }, SocketServer: function () { return io; },
process, console, Buffer, Date, setTimeout, clearTimeout, join, basename,
diff --git a/server/cos-runner/tuiSentinel.test.js b/server/cos-runner/tuiSentinel.test.js
index 9b14c71209..c3c89ba3ac 100644
--- a/server/cos-runner/tuiSentinel.test.js
+++ b/server/cos-runner/tuiSentinel.test.js
@@ -1,3 +1,4 @@
+import { runnerRequestGuard, runnerRequestRefusal } from './requestGuard.js';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { EventEmitter } from 'node:events';
import { readFileSync } from 'node:fs';
@@ -31,7 +32,7 @@ async function spawnTui(sentinel = {}, { trackPromptSubmission = true } = {}) {
const server = Object.assign(new EventEmitter(), {
listen: vi.fn(), close: vi.fn(cb => cb?.()), closeAllConnections: vi.fn(),
});
- const io = Object.assign(new EventEmitter(), { use: vi.fn(), close: vi.fn(cb => cb?.()) });
+ const io = Object.assign(new EventEmitter(), { engine: { use: vi.fn() }, use: vi.fn(), close: vi.fn(cb => cb?.()) });
const child = Object.assign(new EventEmitter(), {
pid: 123, kill: vi.fn(), write: vi.fn(), resize: vi.fn(),
onData: fn => child.on('data', fn),
@@ -50,6 +51,7 @@ async function spawnTui(sentinel = {}, { trackPromptSubmission = true } = {}) {
const state = { agents: {}, stats: { spawned: 0, completed: 0, failed: 0 } };
const killProcessTree = vi.fn();
runInNewContext(source, {
+ runnerRequestGuard, runnerRequestRefusal,
assertDatabaseAdmission: vi.fn(), maintenance,
withBackupAssetPublication: vi.fn(), persistRunnerCompletion: vi.fn(),
express: Object.assign(() => app, { json: vi.fn() }),