161 lines
8.4 KiB
JavaScript
161 lines
8.4 KiB
JavaScript
import { test } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { mkdtemp, writeFile, symlink, rm } from 'node:fs/promises';
|
|
import { tmpdir } from 'node:os';
|
|
import { join } from 'node:path';
|
|
import { createServer } from 'node:http';
|
|
import { request as httpRequest } from 'node:http';
|
|
import { gzipSync } from 'node:zlib';
|
|
import net from 'node:net';
|
|
import { start } from '../../tool/preview/server.mjs';
|
|
|
|
async function fixture(t, { auth = true, hanging = false } = {}) {
|
|
const root = await mkdtemp(join(tmpdir(), 'preview-'));
|
|
await writeFile(join(root, 'index.html'), 'shell');
|
|
await writeFile(join(root, 'bundle.js'), 'bundle');
|
|
const seen = [];
|
|
const upstream = createServer((req, res) => {
|
|
seen.push({ url: req.url, headers: req.headers, method: req.method });
|
|
if (req.url === '/' && auth && req.headers.cookie !== 'sid=yes') {
|
|
res.writeHead(302, { location: '/login' }).end();
|
|
} else if (req.url === '/' && hanging) {
|
|
// Deliberately hold the auth check open to exercise its timeout.
|
|
} else if (req.url === '/login' || req.url === '/logout' || req.url.startsWith('/artifacts/')) {
|
|
res.writeHead(200, { 'content-type': 'application/octet-stream' }).end('proxied');
|
|
} else res.writeHead(200).end('authenticated');
|
|
});
|
|
upstream.on('upgrade', (req, socket, head) => {
|
|
seen.push({ url: req.url, headers: req.headers, upgraded: true });
|
|
socket.write('HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n\r\n');
|
|
if (head.length) socket.write(head);
|
|
socket.pipe(socket);
|
|
});
|
|
await new Promise((resolve) => upstream.listen(0, '127.0.0.1', resolve));
|
|
const preview = await start({ root, upstream: `http://127.0.0.1:${upstream.address().port}`, port: 0 });
|
|
t.after(async () => {
|
|
await preview.close();
|
|
await new Promise((resolve) => upstream.close(resolve));
|
|
await rm(root, { recursive: true, force: true });
|
|
});
|
|
return { root, upstream, preview, seen, base: `http://127.0.0.1:${preview.port}` };
|
|
}
|
|
|
|
function rawRequest(port, path, method, headers = {}) {
|
|
return new Promise((resolve, reject) => {
|
|
const request = httpRequest({ host: '127.0.0.1', port, path, method, headers }, (response) => {
|
|
const chunks = [];
|
|
response.on('data', (chunk) => chunks.push(chunk));
|
|
response.on('end', () => resolve({ status: response.statusCode, headers: response.headers, body: Buffer.concat(chunks) }));
|
|
});
|
|
request.on('error', reject);
|
|
request.end();
|
|
});
|
|
}
|
|
|
|
test('guards assets and redirects unauthenticated document requests to proxy login', async (t) => {
|
|
const { base, seen } = await fixture(t);
|
|
const redirect = await fetch(`${base}/runs/4?tab=active`, { redirect: 'manual', headers: { accept: 'text/html' } });
|
|
assert.equal(redirect.status, 302);
|
|
assert.equal(redirect.headers.get('location'), '/login?next=%2Fruns%2F4%3Ftab%3Dactive');
|
|
assert.equal((await fetch(`${base}/bundle.js`)).status, 401);
|
|
const auth = { cookie: 'sid=yes' };
|
|
assert.equal(await (await fetch(`${base}/bundle.js`, { headers: auth })).text(), 'bundle');
|
|
assert.equal((await fetch(`${base}/login`)).status, 200);
|
|
assert.equal(seen.filter((item) => item.url === '/login').length, 1);
|
|
assert.equal((await fetch(`${base}/%2f%2fevil`, { headers: auth })).status, 400);
|
|
});
|
|
|
|
test('streams exact compressed range bytes for GET and HEAD with mapped proxy requests', async (t) => {
|
|
const bytes = gzipSync(Buffer.from('preserve these exact compressed bytes'));
|
|
const { base, upstream, seen } = await fixture(t);
|
|
upstream.removeAllListeners('request');
|
|
upstream.on('request', (req, res) => {
|
|
if (req.url === '/') return res.end('authenticated');
|
|
seen.push({ url: req.url, headers: req.headers, method: req.method });
|
|
res.writeHead(206, { 'content-type': 'application/octet-stream', 'content-encoding': 'gzip', 'content-range': 'bytes 1-3/6', 'content-length': '3' });
|
|
res.end(bytes.subarray(1, 4));
|
|
});
|
|
const auth = { cookie: 'sid=yes', range: 'bytes=1-3' };
|
|
const response = await rawRequest(new URL(base).port, '/artifacts/x', 'GET', auth);
|
|
assert.equal(response.status, 206);
|
|
assert.equal(response.headers['content-encoding'], 'gzip');
|
|
assert.deepEqual(response.body, bytes.subarray(1, 4));
|
|
const head = await rawRequest(new URL(base).port, '/artifacts/x', 'HEAD', auth);
|
|
assert.equal(head.status, 206);
|
|
assert.equal(head.headers['content-length'], '3');
|
|
assert.equal(head.body.byteLength, 0);
|
|
assert.equal(seen.at(-1).headers.range, 'bytes=1-3');
|
|
});
|
|
|
|
test('rejects cross-origin and unauthenticated WebSocket upgrades before proxying', async (t) => {
|
|
const { preview, seen } = await fixture(t);
|
|
async function upgrade(headers) {
|
|
return new Promise((resolve) => {
|
|
const socket = net.connect(preview.port, '127.0.0.1', () => socket.write(`GET /connect HTTP/1.1\r\nHost: 127.0.0.1:${preview.port}\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n${headers}\r\n`));
|
|
let response = '';
|
|
socket.on('data', (chunk) => { response += chunk.toString(); if (response.includes('\r\n\r\n')) { socket.destroy(); resolve(response); } });
|
|
socket.on('error', () => resolve(response));
|
|
});
|
|
}
|
|
assert.match(await upgrade(`Origin: http://evil.test\r\nCookie: sid=yes\r\n`), /^HTTP\/1\.1 403/);
|
|
assert.match(await upgrade(`Origin: http://127.0.0.1:${preview.port}\r\n`), /^HTTP\/1\.1 401/);
|
|
assert.equal(seen.filter((item) => item.upgraded).length, 0);
|
|
});
|
|
|
|
test('authenticates and maps same-origin WebSocket Origin; bytes flow both directions and close completes', async (t) => {
|
|
const { preview, seen } = await fixture(t);
|
|
const socket = net.connect(preview.port, '127.0.0.1');
|
|
const chunks = [];
|
|
socket.on('data', (chunk) => chunks.push(chunk));
|
|
socket.write(`GET /connect HTTP/1.1\r\nHost: 127.0.0.1:${preview.port}\r\nOrigin: http://127.0.0.1:${preview.port}\r\nCookie: sid=yes\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nSec-WebSocket-Version: 13\r\n\r\n`);
|
|
await new Promise((resolve, reject) => {
|
|
const deadline = setTimeout(() => reject(new Error('upgrade timeout')), 1500);
|
|
const poll = setInterval(() => {
|
|
if (chunks.some((chunk) => chunk.toString().includes('101 Switching Protocols'))) { clearInterval(poll); clearTimeout(deadline); resolve(); }
|
|
}, 10);
|
|
});
|
|
const upgraded = seen.find((item) => item.upgraded);
|
|
assert.equal(upgraded.headers.origin, new URL(`http://${seen[0].headers.host}`).origin);
|
|
assert.equal(upgraded.headers.cookie, 'sid=yes');
|
|
await new Promise((resolve) => setTimeout(resolve, 5200));
|
|
assert.equal(socket.destroyed, false, 'healthy idle websocket must not time out');
|
|
const payload = Buffer.from([0x81, 0x02, 0x6f, 0x6b]);
|
|
socket.write(payload);
|
|
await new Promise((resolve, reject) => {
|
|
const deadline = setTimeout(() => reject(new Error('echo timeout')), 1500);
|
|
const poll = setInterval(() => {
|
|
if (Buffer.concat(chunks).includes(payload)) { clearInterval(poll); clearTimeout(deadline); resolve(); }
|
|
}, 10);
|
|
});
|
|
socket.destroy();
|
|
await preview.close();
|
|
});
|
|
|
|
test('fails closed on authentication timeout and closes idle upgraded sockets', async (t) => {
|
|
const { base } = await fixture(t, { auth: false, hanging: true });
|
|
const started = Date.now();
|
|
const response = await fetch(`${base}/bundle.js`);
|
|
assert.equal(response.status, 502);
|
|
assert.ok(Date.now() - started < 7000);
|
|
});
|
|
|
|
test('rejects encoded traversal and symlinked SPA fallback outside the root', async (t) => {
|
|
const root = await mkdtemp(join(tmpdir(), 'preview-'));
|
|
const outside = await mkdtemp(join(tmpdir(), 'preview-out-'));
|
|
await writeFile(join(outside, 'index.html'), 'private');
|
|
await symlink(join(outside, 'index.html'), join(root, 'index.html'));
|
|
const upstream = createServer((req, res) => res.end('authenticated'));
|
|
await new Promise((resolve) => upstream.listen(0, '127.0.0.1', resolve));
|
|
const preview = await start({ root, upstream: `http://127.0.0.1:${upstream.address().port}`, port: 0 });
|
|
t.after(async () => {
|
|
await preview.close();
|
|
await new Promise((resolve) => upstream.close(resolve));
|
|
await rm(root, { recursive: true, force: true });
|
|
await rm(outside, { recursive: true, force: true });
|
|
});
|
|
const response = await fetch(`http://127.0.0.1:${preview.port}/missing/route`, { headers: { cookie: 'sid=yes' } });
|
|
assert.equal(response.status, 403);
|
|
assert.notEqual(await response.text(), 'private');
|
|
assert.equal((await fetch(`http://127.0.0.1:${preview.port}/%2e%2e%2fsecret`, { headers: { cookie: 'sid=yes' } })).status, 403);
|
|
});
|