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.
161 lines
5.4 KiB
JavaScript
161 lines
5.4 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 { 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");
|
|
}
|
|
},
|
|
);
|