Files
pipelines/app/test/tool/preview.test.mjs
T

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);
});