refactor(auth): standardize session management and security

- Centralize secret retrieval using `getAdminSessionSecret`
- Replace manual session parsing with `verifyRequestAdminSession` utility
- Tighten API validation and improve security headers handling
- Enforce environment variable security for production deployments
This commit is contained in:
Team Dark Devil committed 2026-11-18 05:18:55 +06:00
1 parent 34519c07df
commit 177ed4a844
78 files changed
+6748 -3157

No files matched your search

+375
View File
@@ -0,0 +1,375 @@
import assert from "node:assert/strict";
import { createRequire } from "node:module";
import type { AddressInfo } from "node:net";
import test, { after, before } from "node:test";
import { NextRequest } from "next/server";
import { io as ioClient, type Socket } from "socket.io-client";
import { GET as getSettingsRoute, POST as postSettingsRoute } from "../app/api/settings/route";
import { SettingsManager } from "../core/adminSettings/settingsManager";
import {
createAdminSessionToken,
getAdminSessionSecret,
} from "../core/auth/adminSession";
import {
createInitialAdmin,
resetAdminStateForTests,
} from "../core/auth/adminUsers";
import { ApiEngine } from "../core/apiEngine/apiService";
import { SDKManager } from "../core/sdk/sdkManager";
import {
SecurityEngine,
getInternalIngestionHeaders,
} from "../core/Security/security";
const require = createRequire(import.meta.url);
interface IngestionServerModule {
server: import("node:http").Server;
io: import("socket.io").Server;
bufferQueue: Array<{ clientId: string; eventId: string; timestamp: string; payload: string }>;
runtimeConfig: {
jwtSecret: string;
maxEventsPerSec: number;
maxPayloadSizeBytes: number;
batchFlushThreshold: number;
batchFlushIntervalMs: number;
fileRotationMb: number;
enableIdempotency: boolean;
autoPruneDays: number;
};
stopTimers: () => void;
}
const g = globalThis as typeof globalThis & {
__dataStackBufferState?: {
flushTimer: ReturnType<typeof setInterval> | null;
};
__dataStackAdminSettings?: unknown;
__dataStackClientsMap?: Map<string, unknown>;
__dataStackDeletedClients?: Set<string>;
__dataStackSyncedSocketEvents?: Map<string, number>;
};
let serverMod: IngestionServerModule;
let ingestionUrl = "";
const prevIngestionUrl = process.env.INGESTION_INTERNAL_URL;
const prevDisableListen = process.env.DATASTACK_DISABLE_LISTEN;
const prevDbUrl = process.env.DATABASE_URL;
const prevInternalSecret = process.env.DATASTACK_INTERNAL_SECRET;
const openSockets: Socket[] = [];
function connectSocket(token: string): Promise<Socket> {
return new Promise((resolve, reject) => {
const client = ioClient(ingestionUrl, {
auth: { token },
transports: ["websocket"],
reconnection: false,
timeout: 3000,
});
openSockets.push(client);
const onConnect = () => {
cleanup();
resolve(client);
};
const onError = (err: Error) => {
cleanup();
client.disconnect();
reject(err);
};
function cleanup() {
client.off("connect", onConnect);
client.off("connect_error", onError);
}
client.on("connect", onConnect);
client.on("connect_error", onError);
});
}
function emitWithAck<T = unknown>(
socket: Socket,
event: string,
payload: unknown,
): Promise<T> {
return new Promise((resolve, reject) => {
socket.timeout(3000).emit(event, payload, (err: unknown, res: T) => {
if (err) reject(err);
else resolve(res);
});
});
}
async function createAdminCookieHeader(): Promise<string> {
resetAdminStateForTests();
await createInitialAdmin("admin@datastack.dev", "InitialAdminPass123!");
const secret = getAdminSessionSecret();
assert.ok(secret, "Expected admin session secret in test environment");
const token = await createAdminSessionToken(
"admin@datastack.dev",
secret,
Date.now() + 3600_000,
1,
);
return `datastack_admin_session=${token}`;
}
before(async () => {
process.env.DATASTACK_DISABLE_LISTEN = "1";
delete process.env.DATABASE_URL;
delete process.env.DATASTACK_INTERNAL_SECRET;
delete g.__dataStackAdminSettings;
g.__dataStackClientsMap?.clear();
g.__dataStackDeletedClients?.clear();
g.__dataStackSyncedSocketEvents?.clear();
resetAdminStateForTests();
serverMod = require("../server/index.js") as IngestionServerModule;
await new Promise<void>((resolve) => {
serverMod.server.listen(0, "127.0.0.1", () => resolve());
});
const addr = serverMod.server.address() as AddressInfo;
ingestionUrl = `http://127.0.0.1:${addr.port}`;
process.env.INGESTION_INTERNAL_URL = ingestionUrl;
});
after(async () => {
for (const sock of openSockets) {
try {
sock.disconnect();
} catch {
// ignore
}
}
if (serverMod) {
serverMod.stopTimers();
await new Promise<void>((resolve) => {
serverMod.io.close(() => {
serverMod.server.close(() => resolve());
});
});
}
if (g.__dataStackBufferState?.flushTimer) {
clearInterval(g.__dataStackBufferState.flushTimer);
g.__dataStackBufferState.flushTimer = null;
}
if (prevIngestionUrl === undefined) delete process.env.INGESTION_INTERNAL_URL;
else process.env.INGESTION_INTERNAL_URL = prevIngestionUrl;
if (prevDisableListen === undefined) delete process.env.DATASTACK_DISABLE_LISTEN;
else process.env.DATASTACK_DISABLE_LISTEN = prevDisableListen;
if (prevDbUrl === undefined) delete process.env.DATABASE_URL;
else process.env.DATABASE_URL = prevDbUrl;
if (prevInternalSecret === undefined) delete process.env.DATASTACK_INTERNAL_SECRET;
else process.env.DATASTACK_INTERNAL_SECRET = prevInternalSecret;
});
test("BUG-13: Port 4000 /internal/* rejects unauthenticated callers and accepts valid internal secret while /health remains public", async () => {
const healthRes = await fetch(`${ingestionUrl}/health`);
assert.equal(healthRes.status, 200);
for (const [method, path, body] of [
["GET", "/internal/metrics", undefined],
["POST", "/internal/flush", {}],
["GET", "/internal/recent", undefined],
["POST", "/internal/client-sync", { clientId: "x", action: "registered" }],
["POST", "/internal/settings-sync", { maxEventsPerSec: 120 }],
] as const) {
const noAuth = await fetch(`${ingestionUrl}${path}`, {
method,
headers: body ? { "Content-Type": "application/json" } : undefined,
body: body ? JSON.stringify(body) : undefined,
});
assert.equal(noAuth.status, 401, `${method} ${path} must reject missing secret`);
const wrongAuth = await fetch(`${ingestionUrl}${path}`, {
method,
headers: {
...(body ? { "Content-Type": "application/json" } : {}),
"x-datastack-internal-secret": "wrong-secret-value",
},
body: body ? JSON.stringify(body) : undefined,
});
assert.equal(wrongAuth.status, 401, `${method} ${path} must reject wrong secret`);
const validAuth = await fetch(`${ingestionUrl}${path}`, {
method,
headers: {
...(body ? { "Content-Type": "application/json" } : {}),
...getInternalIngestionHeaders(),
},
body: body ? JSON.stringify(body) : undefined,
});
assert.equal(validAuth.status, 200, `${method} ${path} must accept valid internal secret`);
}
});
test("BUG-06: POST /api/settings validates allowlisted bounds, syncs Port 4000 immediately, preserves autoPruneDays=0, and disconnects sockets on JWT rotation", async () => {
const unauthGet = await getSettingsRoute(new NextRequest("http://localhost:3000/api/settings"));
assert.equal(unauthGet.status, 401);
const cookieHeader = await createAdminCookieHeader();
const badJsonReq = new NextRequest("http://localhost:3000/api/settings", {
method: "POST",
headers: { "Content-Type": "application/json", cookie: cookieHeader },
body: "{bad-json",
});
const badJsonRes = await postSettingsRoute(badJsonReq);
assert.equal(badJsonRes.status, 400);
const unsupportedReq = new NextRequest("http://localhost:3000/api/settings", {
method: "POST",
headers: { "Content-Type": "application/json", cookie: cookieHeader },
body: JSON.stringify({ serverPort: 9999 }),
});
assert.equal((await postSettingsRoute(unsupportedReq)).status, 400);
const weakSecretReq = new NextRequest("http://localhost:3000/api/settings", {
method: "POST",
headers: { "Content-Type": "application/json", cookie: cookieHeader },
body: JSON.stringify({ jwtSecret: "too-short" }),
});
assert.equal((await postSettingsRoute(weakSecretReq)).status, 400);
const validUpdateReq = new NextRequest("http://localhost:3000/api/settings", {
method: "POST",
headers: { "Content-Type": "application/json", cookie: cookieHeader },
body: JSON.stringify({
maxEventsPerSec: 42,
autoPruneDays: 0,
enableIdempotency: true,
}),
});
const validUpdateRes = await postSettingsRoute(validUpdateReq);
assert.equal(validUpdateRes.status, 200);
const updatedJson = await validUpdateRes.json();
assert.equal(updatedJson.settings.maxEventsPerSec, 42);
assert.equal(updatedJson.settings.autoPruneDays, 0);
assert.equal(serverMod.runtimeConfig.maxEventsPerSec, 42);
assert.equal(serverMod.runtimeConfig.autoPruneDays, 0);
// Register client & open WebSocket before JWT rotation
const client = await SDKManager.registerClientAsync({
clientId: "phase02_jwt_rot",
name: "Phase02 Rotation",
rateLimit: 50,
});
const oldToken = client.token;
const socket = await connectSocket(oldToken);
assert.equal(socket.connected, true);
const disconnectedPromise = new Promise<string>((resolve) => {
socket.once("disconnect", (reason) => resolve(reason));
});
const newSecret = "phase02-rotated-production-secret-key-minimum-32-chars";
const rotateReq = new NextRequest("http://localhost:3000/api/settings", {
method: "POST",
headers: { "Content-Type": "application/json", cookie: cookieHeader },
body: JSON.stringify({ jwtSecret: newSecret }),
});
const rotateRes = await postSettingsRoute(rotateReq);
assert.equal(rotateRes.status, 200);
assert.equal(serverMod.runtimeConfig.jwtSecret, newSecret);
const disconnectReason = await Promise.race([
disconnectedPromise,
new Promise<string>((_, reject) =>
setTimeout(() => reject(new Error("Expected socket disconnect on JWT rotation")), 2000),
),
]);
assert.ok(disconnectReason.length > 0);
// Old JWT token must fail handshake after rotation
await assert.rejects(() => connectSocket(oldToken), /AUTH_INVALID|jwt|signature/i);
// New resigned client token must succeed cleanly
const refreshedClient = SDKManager.getClient("phase02_jwt_rot");
assert.ok(refreshedClient && refreshedClient.token !== oldToken);
const reconnected = await connectSocket(refreshedClient.token);
assert.equal(reconnected.connected, true);
reconnected.disconnect();
});
test("BUG-07: In-memory client registry, socket event counting, token rotation & revocation enforce cleanly on Port 4000", async () => {
const client = await SDKManager.registerClientAsync({
clientId: "phase02_mem_client",
name: "Phase02 Memory Sync",
rateLimit: 25,
});
const socket = await connectSocket(client.token);
const ack = await emitWithAck<{ success: boolean; eventId: string }>(
socket,
"sync_data",
{ eventId: "evt-mem-1", data: { ok: true } },
);
assert.equal(ack.success, true);
const listFirst = await SDKManager.listClientsAsync();
const syncedFirst = listFirst.find((c) => c.clientId === "phase02_mem_client");
assert.ok(syncedFirst);
assert.equal(syncedFirst.totalEvents, 1);
assert.ok(syncedFirst.lastActive);
// Polling again must NOT double-count socket activity
const listSecond = await SDKManager.listClientsAsync();
const syncedSecond = listSecond.find((c) => c.clientId === "phase02_mem_client");
assert.equal(syncedSecond?.totalEvents, 1);
// Advance across JWT iat 1-second boundary before regenerating client token
await new Promise((r) => setTimeout(r, 1100));
// Regenerating client token must kick active socket and reject old token
const rotatedClient = await SDKManager.regenerateTokenAsync("phase02_mem_client");
assert.ok(rotatedClient && rotatedClient.token !== client.token);
await new Promise((r) => setTimeout(r, 50));
assert.equal(socket.connected, false);
await assert.rejects(() => connectSocket(client.token), /TOKEN_ROTATED/);
// New token works; revoking kicks and rejects
const socket2 = await connectSocket(rotatedClient.token);
assert.equal(socket2.connected, true);
await SDKManager.updateClientAsync("phase02_mem_client", { status: "revoked" });
await new Promise((r) => setTimeout(r, 50));
assert.equal(socket2.connected, false);
await assert.rejects(() => connectSocket(rotatedClient.token), /CLIENT_REVOKED/);
});
test("BUG-08: Rate-limit error reports effectiveRateLimit and ApiEngine aggregates Port 3000 + Port 4000 security metrics", async () => {
await SettingsManager.updateSettingsAsync({ maxEventsPerSec: 3, enableIdempotency: true });
const rlClientId = "phase02_rl_msg";
let lastError = "";
for (let i = 0; i < 5; i += 1) {
const res = SecurityEngine.validateEvent(rlClientId, `rl-evt-${i}`, { i }, 100);
if (!res.allowed && res.code === "RATE_LIMIT_EXCEEDED") {
lastError = res.reason || "";
break;
}
}
assert.match(lastError, /Rate limit of 3 events\/sec exceeded/);
const client = await SDKManager.registerClientAsync({
clientId: "phase02_stats_client",
name: "Phase02 Stats Client",
rateLimit: 50,
});
await new Promise((r) => setTimeout(r, 80));
const socket = await connectSocket(client.token);
await emitWithAck(socket, "sync_data", { eventId: "evt-stats-ws-1", data: { a: 1 } });
socket.disconnect();
const metrics = await ApiEngine.getDashboardMetrics();
assert.ok(
metrics.securityStats.activeIdempotencyKeys >= 2,
`Expected aggregated idempotency keys >= 2 (HTTP + WS), got ${metrics.securityStats.activeIdempotencyKeys}`,
);
assert.ok(
metrics.securityStats.rateLimitedClientsCount >= 2,
`Expected aggregated rateLimitedClientsCount >= 2, got ${metrics.securityStats.rateLimitedClientsCount}`,
);
});