fix(deps): resolve production high and critical vulnerabilities

Pin vulnerable transitive dependencies to patched releases and replace Infisical SDK bootstrap calls with a compatible HTTP client. Add dependency-security and secret-loading regression coverage.
This commit is contained in:
dahyeon committed 2026-11-07 20:21:54 +09:00
1 parent 5bc748dc4d
commit 9117c9c0a4
7 files changed
+685 -88

No files matched your search

+160
View File
@@ -0,0 +1,160 @@
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 { 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");
}
},
);