This commit is contained in:
oss-sync
Executable
+399
@@ -0,0 +1,399 @@
|
||||
#!/usr/bin/env node
|
||||
/**
|
||||
* Offline regression check for the server egress boundary artifacts.
|
||||
*
|
||||
* This check never applies host firewall/systemd policy and never contacts the
|
||||
* public network. It validates the shipped templates, exercises an in-process
|
||||
* exact-host+port proxy policy, and demonstrates the transports that still
|
||||
* require the OS boundary because HTTP proxy environment variables do not
|
||||
* contain them.
|
||||
*/
|
||||
import assert from 'node:assert/strict';
|
||||
import { readFile } from 'node:fs/promises';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import http from 'node:http';
|
||||
import net from 'node:net';
|
||||
import dgram from 'node:dgram';
|
||||
import { Resolver } from 'node:dns/promises';
|
||||
import { execFile } from 'node:child_process';
|
||||
|
||||
const SYSTEMD_FILE = new URL('../../deploy/egress/systemd/maestro-egress.service.example', import.meta.url);
|
||||
const SQUID_FILE = new URL('../../deploy/egress/squid.conf', import.meta.url);
|
||||
const ALLOWED_HOST = 'allowed.egress.invalid';
|
||||
const DENIED_HOST = 'denied.egress.invalid';
|
||||
const ALLOWED_PORT = 443;
|
||||
const SECRET = 'EGRESS_SECRET_CANARY_7d7fc02c';
|
||||
|
||||
function listen(server, host) {
|
||||
return new Promise((resolve, reject) => {
|
||||
server.once('error', reject);
|
||||
const onReady = () => {
|
||||
server.off('error', reject);
|
||||
resolve(server.address());
|
||||
};
|
||||
if (typeof server.listen === 'function') server.listen(0, host, onReady);
|
||||
else server.bind(0, host, onReady);
|
||||
});
|
||||
}
|
||||
|
||||
function close(server) {
|
||||
server.closeAllConnections?.();
|
||||
server.close();
|
||||
}
|
||||
|
||||
function runNode(code, env = {}) {
|
||||
return new Promise((resolve, reject) => {
|
||||
execFile(
|
||||
process.execPath,
|
||||
['--use-env-proxy', '-e', code],
|
||||
{
|
||||
env: { PATH: process.env.PATH || '/usr/bin:/bin', HOME: '/tmp', LANG: 'C.UTF-8', ...env },
|
||||
encoding: 'utf8',
|
||||
timeout: 8_000,
|
||||
maxBuffer: 64 * 1024,
|
||||
},
|
||||
(error, stdout, stderr) => {
|
||||
if (error) {
|
||||
reject(new Error(`local child probe failed: ${stderr.trim() || error.message}`));
|
||||
return;
|
||||
}
|
||||
resolve(stdout.trim());
|
||||
},
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
function rawExchange(host, port, request) {
|
||||
return new Promise((resolve, reject) => {
|
||||
const socket = net.createConnection({ host, port });
|
||||
let response = '';
|
||||
const timer = setTimeout(() => socket.destroy(new Error('raw probe timed out')), 3_000);
|
||||
socket.setEncoding('utf8');
|
||||
socket.on('connect', () => socket.end(request));
|
||||
socket.on('data', (chunk) => { response += chunk; });
|
||||
socket.on('error', reject);
|
||||
socket.on('close', () => {
|
||||
clearTimeout(timer);
|
||||
resolve(response);
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
function parseTarget(value, fallbackScheme = 'http:') {
|
||||
try {
|
||||
const url = value.includes('://') ? new URL(value) : new URL(`${fallbackScheme}//${value}`);
|
||||
return {
|
||||
hostname: url.hostname,
|
||||
port: Number(url.port || (url.protocol === 'https:' ? 443 : 80)),
|
||||
};
|
||||
} catch {
|
||||
return { hostname: '', port: 0 };
|
||||
}
|
||||
}
|
||||
|
||||
function allowedTarget(target) {
|
||||
return target.hostname === ALLOWED_HOST && target.port === ALLOWED_PORT;
|
||||
}
|
||||
|
||||
async function validateTemplates() {
|
||||
const [unit, squid] = await Promise.all([
|
||||
readFile(SYSTEMD_FILE, 'utf8'),
|
||||
readFile(SQUID_FILE, 'utf8'),
|
||||
]);
|
||||
|
||||
assert.match(unit, /^IPAddressDeny=any$/m);
|
||||
assert.match(unit, /^IPAddressAllow=127\.0\.0\.2\/32$/m);
|
||||
assert.match(unit, /^IPAddressAllow=127\.0\.0\.3\/32$/m);
|
||||
assert.doesNotMatch(unit, /^IPAddressAllow=(?:localhost|127\.0\.0\.0\/8|::1(?:\/128)?)$/m);
|
||||
assert.match(unit, /ExecStart=\/usr\/bin\/env .*HTTP_PROXY=http:\/\/127\.0\.0\.2:3128 .*HTTPS_PROXY=http:\/\/127\.0\.0\.2:3128 .*NO_PROXY= .*\/usr\/bin\/node --use-env-proxy/m);
|
||||
assert.doesNotMatch(unit, /NODE_OPTIONS=/);
|
||||
|
||||
assert.match(squid, /^http_port 127\.0\.0\.2:3128$/m);
|
||||
assert.match(squid, /^acl maestro_llm_host dstdomain -n allowed\.egress\.invalid$/m);
|
||||
assert.match(squid, /^acl maestro_llm_port port 443$/m);
|
||||
assert.match(squid, /^http_access allow maestro_llm_host maestro_llm_port$/m);
|
||||
assert.match(squid, /^access_log none$/m);
|
||||
assert.match(squid, /^cache_store_log none$/m);
|
||||
const accessRules = squid.split(/\r?\n/).filter((line) => /^http_access\s+/.test(line.trim()));
|
||||
assert.equal(accessRules.at(-1)?.trim(), 'http_access deny all');
|
||||
return { systemd: true, squid: true };
|
||||
}
|
||||
|
||||
async function runProxyChecks() {
|
||||
const events = [];
|
||||
const proxy = http.createServer((req, res) => {
|
||||
const selectedTarget = Array.isArray(req.headers['x-egress-target'])
|
||||
? req.headers['x-egress-target'][0]
|
||||
: req.headers['x-egress-target'];
|
||||
const target = parseTarget(selectedTarget || req.url || '');
|
||||
const allowed = allowedTarget(target);
|
||||
events.push({ protocol: 'http', decision: allowed ? 'allow' : 'deny', port: target.port });
|
||||
res.writeHead(allowed ? 200 : 403, { 'content-type': 'text/plain' });
|
||||
res.end(allowed ? 'allowed' : 'denied');
|
||||
});
|
||||
proxy.on('connect', (req, socket) => {
|
||||
const target = parseTarget(req.url || '', 'http:');
|
||||
const allowed = allowedTarget(target);
|
||||
events.push({ protocol: 'connect', decision: allowed ? 'allow' : 'deny', port: target.port });
|
||||
socket.end(`HTTP/1.1 ${allowed ? '200 Connection Established' : '403 Forbidden'}\r\nConnection: close\r\n\r\n`);
|
||||
});
|
||||
proxy.on('upgrade', (req, socket) => {
|
||||
const target = parseTarget(req.url || '');
|
||||
const allowed = allowedTarget(target);
|
||||
events.push({ protocol: 'websocket', decision: allowed ? 'allow' : 'deny', port: target.port });
|
||||
socket.end(`HTTP/1.1 ${allowed ? '101 Switching Protocols' : '403 Forbidden'}\r\nConnection: close\r\n\r\n`);
|
||||
});
|
||||
|
||||
const address = await listen(proxy, '127.0.0.1');
|
||||
const proxyUrl = `http://127.0.0.1:${address.port}`;
|
||||
try {
|
||||
const fetchAllowed = await fetch(`${proxyUrl}/private?token=${SECRET}`, {
|
||||
headers: { Authorization: `Bearer ${SECRET}`, 'x-egress-target': `${ALLOWED_HOST}:${ALLOWED_PORT}` },
|
||||
signal: AbortSignal.timeout(3_000),
|
||||
});
|
||||
const fetchDenied = await fetch(`${proxyUrl}/private?token=${SECRET}`, {
|
||||
headers: { Authorization: `Bearer ${SECRET}`, 'x-egress-target': `${DENIED_HOST}:${ALLOWED_PORT}` },
|
||||
signal: AbortSignal.timeout(3_000),
|
||||
});
|
||||
assert.equal(fetchAllowed.status, 200);
|
||||
assert.equal(fetchDenied.status, 403);
|
||||
await Promise.all([fetchAllowed.text(), fetchDenied.text()]);
|
||||
|
||||
const connectAllowed = await rawExchange('127.0.0.1', address.port,
|
||||
`CONNECT ${ALLOWED_HOST}:${ALLOWED_PORT} HTTP/1.1\r\nHost: ${ALLOWED_HOST}:${ALLOWED_PORT}\r\nAuthorization: Bearer ${SECRET}\r\n\r\n`);
|
||||
const connectDenied = await rawExchange('127.0.0.1', address.port,
|
||||
`CONNECT ${DENIED_HOST}:${ALLOWED_PORT} HTTP/1.1\r\nHost: ${DENIED_HOST}:${ALLOWED_PORT}\r\n\r\n`);
|
||||
assert.match(connectAllowed, /^HTTP\/1\.1 200/);
|
||||
assert.match(connectDenied, /^HTTP\/1\.1 403/);
|
||||
|
||||
const wsAllowed = await rawExchange('127.0.0.1', address.port,
|
||||
`GET ws://${ALLOWED_HOST}:${ALLOWED_PORT}/socket?token=${SECRET} HTTP/1.1\r\nHost: ${ALLOWED_HOST}:${ALLOWED_PORT}\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n\r\n`);
|
||||
const wsDenied = await rawExchange('127.0.0.1', address.port,
|
||||
`GET ws://${DENIED_HOST}:${ALLOWED_PORT}/socket HTTP/1.1\r\nHost: ${DENIED_HOST}:${ALLOWED_PORT}\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n\r\n`);
|
||||
assert.match(wsAllowed, /^HTTP\/1\.1 101/);
|
||||
assert.match(wsDenied, /^HTTP\/1\.1 403/);
|
||||
|
||||
const serializedEvents = JSON.stringify(events);
|
||||
assert.ok(!serializedEvents.includes(SECRET), 'metadata events must not retain request secrets');
|
||||
assert.equal(events.filter((event) => event.decision === 'allow').length, 3);
|
||||
assert.equal(events.filter((event) => event.decision === 'deny').length, 3);
|
||||
return { allowed: 3, denied: 3, secretRetained: false };
|
||||
} finally {
|
||||
close(proxy);
|
||||
}
|
||||
}
|
||||
|
||||
async function reserveTcpPort() {
|
||||
const server = net.createServer();
|
||||
const address = await listen(server, '127.0.0.1');
|
||||
await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
|
||||
return address.port;
|
||||
}
|
||||
|
||||
async function runActualEnvProxyChild(port) {
|
||||
const events = [];
|
||||
const proxy = http.createServer((req, res) => {
|
||||
const target = parseTarget(req.url || '');
|
||||
const allowed = allowedTarget(target);
|
||||
events.push({
|
||||
transport: 'absolute-form',
|
||||
decision: allowed ? 'allow' : 'deny',
|
||||
target: `${target.hostname}:${target.port}`,
|
||||
absoluteUrl: /^http:\/\//.test(req.url || ''),
|
||||
});
|
||||
res.writeHead(allowed ? 200 : 403, { 'content-type': 'text/plain', connection: 'close' });
|
||||
res.end(allowed ? 'allowed' : 'denied');
|
||||
});
|
||||
proxy.on('connect', (req, socket) => {
|
||||
const target = parseTarget(req.url || '', 'http:');
|
||||
const allowed = allowedTarget(target);
|
||||
events.push({
|
||||
transport: 'connect',
|
||||
decision: allowed ? 'allow' : 'deny',
|
||||
target: `${target.hostname}:${target.port}`,
|
||||
absoluteUrl: false,
|
||||
});
|
||||
if (!allowed) {
|
||||
socket.end('HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n');
|
||||
return;
|
||||
}
|
||||
socket.write('HTTP/1.1 200 Connection Established\r\n\r\n');
|
||||
socket.once('data', () => {
|
||||
socket.end('HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 7\r\nConnection: close\r\n\r\nallowed');
|
||||
});
|
||||
});
|
||||
await new Promise((resolve, reject) => {
|
||||
proxy.once('error', reject);
|
||||
proxy.listen(port, '127.0.0.1', () => {
|
||||
proxy.off('error', reject);
|
||||
resolve();
|
||||
});
|
||||
});
|
||||
try {
|
||||
const init = {
|
||||
headers: { Authorization: `Bearer ${SECRET}` },
|
||||
signal: AbortSignal.timeout(3_000),
|
||||
};
|
||||
const allowedResponse = await fetch(`http://${ALLOWED_HOST}:${ALLOWED_PORT}/private?token=${SECRET}`, init);
|
||||
const allowedStatus = allowedResponse.status;
|
||||
await allowedResponse.text();
|
||||
let deniedStatus = 'error';
|
||||
try {
|
||||
const deniedResponse = await fetch(`http://${DENIED_HOST}:${ALLOWED_PORT}/private?token=${SECRET}`, init);
|
||||
deniedStatus = deniedResponse.status;
|
||||
await deniedResponse.text();
|
||||
} catch {}
|
||||
return { allowedStatus, deniedStatus, events };
|
||||
} finally {
|
||||
close(proxy);
|
||||
}
|
||||
}
|
||||
|
||||
async function runActualEnvProxyCheck() {
|
||||
const port = await reserveTcpPort();
|
||||
const proxyUrl = `http://127.0.0.1:${port}`;
|
||||
const childEnv = {
|
||||
PATH: process.env.PATH || '/usr/bin:/bin',
|
||||
HOME: '/tmp',
|
||||
LANG: 'C.UTF-8',
|
||||
MAESTRO_EGRESS_PROXY_CHILD: '1',
|
||||
MAESTRO_EGRESS_PROXY_PORT: String(port),
|
||||
HTTP_PROXY: proxyUrl,
|
||||
HTTPS_PROXY: proxyUrl,
|
||||
NO_PROXY: '',
|
||||
};
|
||||
const output = await new Promise((resolve, reject) => {
|
||||
execFile(
|
||||
process.execPath,
|
||||
['--use-env-proxy', fileURLToPath(import.meta.url)],
|
||||
{ env: childEnv, encoding: 'utf8', timeout: 8_000, maxBuffer: 64 * 1024 },
|
||||
(error, stdout, stderr) => {
|
||||
if (error) {
|
||||
reject(new Error(`env proxy child failed: ${stderr.trim() || error.message}`));
|
||||
return;
|
||||
}
|
||||
resolve(stdout.trim());
|
||||
},
|
||||
);
|
||||
});
|
||||
assert.ok(!output.includes(SECRET));
|
||||
const result = JSON.parse(output);
|
||||
assert.equal(result.allowedStatus, 200);
|
||||
assert.ok(result.deniedStatus === 403 || result.deniedStatus === 'error');
|
||||
const allowed = result.events.find((event) => event.decision === 'allow');
|
||||
const denied = result.events.find((event) => event.decision === 'deny');
|
||||
assert.equal(allowed?.target, `${ALLOWED_HOST}:${ALLOWED_PORT}`);
|
||||
assert.equal(denied?.target, `${DENIED_HOST}:${ALLOWED_PORT}`);
|
||||
if (allowed.transport === 'absolute-form') assert.equal(allowed.absoluteUrl, true);
|
||||
return {
|
||||
nodeFlag: '--use-env-proxy',
|
||||
allowedTransport: allowed.transport,
|
||||
allowedTarget: allowed.target,
|
||||
deniedTarget: denied.target,
|
||||
cleanChildEnvironment: true,
|
||||
secretRetained: false,
|
||||
};
|
||||
}
|
||||
|
||||
async function runDirectBypassChecks() {
|
||||
const hits = { http: 0, raw: 0, childRaw: 0, ipv6: 0, dns: 0 };
|
||||
const httpServer = http.createServer((req, res) => {
|
||||
hits.http += 1;
|
||||
res.end('direct-http');
|
||||
});
|
||||
const rawServer = net.createServer((socket) => {
|
||||
socket.once('data', (data) => {
|
||||
const kind = data.toString() === 'child' ? 'childRaw' : 'raw';
|
||||
hits[kind] += 1;
|
||||
socket.end('ok');
|
||||
});
|
||||
});
|
||||
const ipv6Server = net.createServer((socket) => {
|
||||
hits.ipv6 += 1;
|
||||
socket.end('ok');
|
||||
});
|
||||
const dnsServer = dgram.createSocket('udp4');
|
||||
dnsServer.on('message', (message, remote) => {
|
||||
hits.dns += 1;
|
||||
const response = Buffer.from(message);
|
||||
response[2] = 0x81;
|
||||
response[3] = 0x83;
|
||||
response.writeUInt16BE(0, 6);
|
||||
response.writeUInt16BE(0, 8);
|
||||
response.writeUInt16BE(0, 10);
|
||||
dnsServer.send(response, remote.port, remote.address);
|
||||
});
|
||||
|
||||
const servers = [httpServer, rawServer, ipv6Server, dnsServer];
|
||||
try {
|
||||
const httpAddress = await listen(httpServer, '127.0.0.1');
|
||||
const rawAddress = await listen(rawServer, '127.0.0.1');
|
||||
const ipv6Address = await listen(ipv6Server, '::1');
|
||||
const dnsAddress = await listen(dnsServer, '127.0.0.1');
|
||||
|
||||
const directHttp = await new Promise((resolve, reject) => {
|
||||
const request = http.get(`http://127.0.0.1:${httpAddress.port}/direct`, (response) => {
|
||||
response.resume();
|
||||
response.on('end', () => resolve(response.statusCode));
|
||||
});
|
||||
request.on('error', reject);
|
||||
});
|
||||
assert.equal(directHttp, 200);
|
||||
assert.equal(await rawExchange('127.0.0.1', rawAddress.port, 'parent'), 'ok');
|
||||
assert.equal(await rawExchange('::1', ipv6Address.port, 'ipv6'), 'ok');
|
||||
|
||||
const childResult = await runNode(`
|
||||
const net = require('node:net');
|
||||
const socket = net.createConnection({ host: '127.0.0.1', port: ${rawAddress.port} });
|
||||
socket.on('connect', () => socket.end('child'));
|
||||
socket.on('close', () => process.exit(0));
|
||||
socket.on('error', (error) => { console.error(error); process.exit(1); });
|
||||
`, {
|
||||
HTTP_PROXY: 'http://127.0.0.1:9',
|
||||
HTTPS_PROXY: 'http://127.0.0.1:9',
|
||||
NO_PROXY: '',
|
||||
});
|
||||
assert.equal(childResult, '');
|
||||
|
||||
const resolver = new Resolver();
|
||||
resolver.setServers([`127.0.0.1:${dnsAddress.port}`]);
|
||||
await resolver.resolve4(`dns-${SECRET.toLowerCase()}.invalid`).catch(() => {});
|
||||
|
||||
assert.deepEqual(hits, { http: 1, raw: 1, childRaw: 1, ipv6: 1, dns: 1 });
|
||||
return {
|
||||
demonstrated: ['node:http', 'raw-tcp-ipv4', 'spawned-child-raw-tcp', 'raw-tcp-ipv6', 'direct-dns'],
|
||||
meaning: 'these transports bypass HTTP_PROXY and must be stopped by the OS boundary',
|
||||
};
|
||||
} finally {
|
||||
for (const server of servers) {
|
||||
try { close(server); } catch {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (process.env.MAESTRO_EGRESS_PROXY_CHILD === '1') {
|
||||
const port = Number(process.env.MAESTRO_EGRESS_PROXY_PORT);
|
||||
assert.ok(Number.isInteger(port) && port > 0);
|
||||
const childResult = await runActualEnvProxyChild(port);
|
||||
const childOutput = JSON.stringify(childResult);
|
||||
assert.ok(!childOutput.includes(SECRET));
|
||||
console.log(childOutput);
|
||||
process.exit(0);
|
||||
}
|
||||
|
||||
const templates = await validateTemplates();
|
||||
const envProxyRuntime = await runActualEnvProxyCheck();
|
||||
const proxyPolicy = await runProxyChecks();
|
||||
const proxyScope = await runDirectBypassChecks();
|
||||
const result = {
|
||||
ok: true,
|
||||
externalNetworkUsed: false,
|
||||
hostIsolationApplied: false,
|
||||
templates,
|
||||
envProxyRuntime,
|
||||
proxyPolicy,
|
||||
proxyScope,
|
||||
};
|
||||
const output = JSON.stringify(result, null, 2);
|
||||
assert.ok(!output.includes(SECRET));
|
||||
console.log(output);
|
||||
Reference in New Issue
Block a user