Files
lolympus-tournament-support/scripts/dependency-security.test.mjs
T
dahyeon 9d7c888b0a fix: migrate deprecated APIs and patch vulnerable dependencies
Use current Mongoose, NATS, React, and ESLint APIs. Upgrade Vite and other affected dependencies, restrict the compatibility plugin to resolved module IDs, and keep qs unchanged.
2026-11-11 22:41:42 +09:00

193 lines
6.6 KiB
JavaScript

import assert from "node:assert/strict";
import { once } from "node:events";
import http from "node:http";
import { createRequire } from "node:module";
import { test } from "node:test";
import { fileURLToPath, pathToFileURL } from "node:url";
import { gzipSync } from "node:zlib";
const apiRequire = createRequire(
new URL("../apps/api/package.json", import.meta.url),
);
const webRequire = createRequire(
new URL("../apps/web/package.json", import.meta.url),
);
const expressRequire = createRequire(
apiRequire.resolve("@nestjs/platform-express"),
);
const proxyaddr = createRequire(expressRequire.resolve("express"))(
"proxy-addr",
);
const { ExpressAdapter } = apiRequire("@nestjs/platform-express");
const { Server } = apiRequire("socket.io");
const { io } = webRequire("socket.io-client");
const engineRequire = createRequire(
createRequire(apiRequire.resolve("socket.io")).resolve("engine.io"),
);
const WebSocket = engineRequire("ws");
test("proxy trust does not accept unrelated IPv4 addresses through IPv6 subnets", () => {
for (const subnet of ["::ffff:10.0.0.0/8", "::/1"]) {
const trust = proxyaddr.compile(subnet);
assert.equal(trust("203.0.113.9"), false, subnet);
}
for (const subnet of ["10.0.0.0/8", "::ffff:10.0.0.0/104"]) {
const trust = proxyaddr.compile(subnet);
assert.equal(trust("10.1.2.3"), true);
assert.equal(trust("::ffff:10.1.2.3"), true);
assert.equal(trust("203.0.113.9"), false);
}
});
test(
"Socket.IO rejects mismatched and omitted upgrade protocol versions",
{ timeout: 10000 },
async (t) => {
const server = http.createServer();
const sockets = new Server(server);
t.after(() => new Promise((resolve) => sockets.close(resolve)));
server.listen(0, "127.0.0.1");
await once(server, "listening");
const origin = `http://127.0.0.1:${server.address().port}`;
for (const protocol of ["3", undefined]) {
const response = await fetch(
`${origin}/socket.io/?EIO=4&transport=polling`,
);
const handshake = await response.text();
assert.equal(handshake[0], "0");
const { sid } = JSON.parse(handshake.slice(1));
const query = new URLSearchParams({ transport: "websocket", sid });
if (protocol) query.set("EIO", protocol);
const status = await new Promise((resolve, reject) => {
const socket = new WebSocket(
`${origin.replace("http:", "ws:")}/socket.io/?${query}`,
);
socket.once("unexpected-response", (_, incoming) => {
incoming.resume();
resolve(incoming.statusCode);
});
socket.once("open", () => {
socket.close();
resolve(101);
});
socket.once("error", reject);
});
assert.equal(status, 400, `upgrade EIO=${protocol ?? "(omitted)"}`);
}
sockets.on("connection", (socket) =>
socket.on("echo", (value, ack) => ack(value)),
);
const client = io(origin, { autoConnect: false, reconnection: false });
t.after(() => client.disconnect());
const connected = once(client, "connect");
client.connect();
const upgraded = once(client.io.engine, "upgrade");
await connected;
await upgraded;
assert.equal(client.io.engine.transport.name, "websocket");
assert.deepEqual(
await client.timeout(2000).emitWithAck("echo", { bid: 42 }),
{ bid: 42 },
);
},
);
test(
"Nest Express preserves raw JSON and survives compressed trailing data",
{ timeout: 10000 },
async (t) => {
const adapter = new ExpressAdapter();
adapter.registerParserMiddleware("", true);
const app = adapter.getInstance();
app.post("/echo", (req, res) =>
res.json({ body: req.body, raw: req.rawBody.toString() }),
);
app.get("/health", (_, res) => res.send("ok"));
app.use((error, _req, res, _next) => res.status(error.status ?? 500).end());
const server = http.createServer(app);
t.after(
() =>
new Promise((resolve) => {
server.closeAllConnections();
server.close(resolve);
}),
);
server.listen(0, "127.0.0.1");
await once(server, "listening");
const origin = `http://127.0.0.1:${server.address().port}`;
const json = JSON.stringify({ bid: 42 });
for (const compressed of [false, true]) {
const response = await fetch(`${origin}/echo`, {
method: "POST",
headers: {
"content-type": "application/json",
...(compressed ? { "content-encoding": "gzip" } : {}),
},
body: compressed ? gzipSync(json) : json,
});
assert.equal(response.status, 200);
assert.deepEqual(await response.json(), { body: { bid: 42 }, raw: json });
}
for (const trailing of [
Buffer.from("invalid trailing bytes"),
Buffer.from([0x1f, 0x8b, 0xff]),
]) {
const payload = Buffer.concat([gzipSync(json), trailing]);
const status = await new Promise((resolve, reject) => {
const request = http.request(
`${origin}/echo`,
{
method: "POST",
headers: {
"content-type": "application/json",
"content-encoding": "gzip",
"content-length": payload.length,
},
},
(response) => {
response.resume();
response.on("end", () => resolve(response.statusCode));
},
);
request.on("error", reject);
request.end(payload);
});
assert.equal(status, 400);
assert.equal(await (await fetch(`${origin}/health`)).text(), "ok");
}
},
);
test("Vite only loads compatibility modules resolved from real imports", async (t) => {
const { createServer } = await import(
pathToFileURL(webRequire.resolve("vite")).href
);
const server = await createServer({
root: fileURLToPath(new URL("../apps/web", import.meta.url)),
logLevel: "silent",
optimizeDeps: { noDiscovery: true },
server: { middlewareMode: true, ws: false, hmr: false, watch: null },
});
t.after(() => server.close());
const canary = fileURLToPath(
new URL("../apps/api/src/app.service.ts", import.meta.url),
).replaceAll("\\", "/");
const forgedId =
"\0es-toolkit-compat-esm:AppService:" +
encodeURIComponent(canary);
await assert.rejects(server.transformRequest(forgedId), {
code: "ERR_LOAD_URL",
});
const resolved = await server.environments.client.pluginContainer.resolveId(
"es-toolkit/compat/sortBy",
webRequire.resolve("recharts"),
);
assert.ok(resolved?.id.startsWith("\0es-toolkit-compat-esm:"));
const transformed = await server.transformRequest(resolved.id);
assert.match(transformed?.code ?? "", /sortBy/);
});