Files
DataStack/tests/phase01-auth.test.ts
T
victorsteele428 667a140c4e P01: cross-platform lockfile, regression contracts and verified CI closure (#1)
fix(p01): cross-platform lock, TS regressions and notes [skip ci]
2026-11-22 02:12:46 +00:00

1062 lines
37 KiB
TypeScript

import assert from "node:assert/strict";
import { after, afterEach, beforeEach, describe, it } from "node:test";
import { NextRequest } from "next/server";
import { POST as loginPost } from "@/app/api/auth/login/route";
import { POST as logoutPost } from "@/app/api/auth/logout/route";
import { GET as profileGet, PUT as profilePut } from "@/app/api/auth/profile/route";
import { POST as setupPost } from "@/app/api/auth/setup/route";
import { GET as clientsGet, POST as clientsPost } from "@/app/api/clients/route";
import {
DELETE as clientDelete,
GET as clientGet,
PATCH as clientPatch,
} from "@/app/api/clients/[id]/route";
import { GET as dataGet } from "@/app/api/data/route";
import { GET as eventsGet, POST as eventsPost } from "@/app/api/events/route";
import { GET as exportGet } from "@/app/api/export/route";
import { GET as healthGet } from "@/app/api/health/route";
import { GET as metricsGet } from "@/app/api/metrics/route";
import { GET as storageGet, POST as storagePost } from "@/app/api/storage/route";
import { SettingsManager } from "@/core/adminSettings/settingsManager";
import {
createAdminSessionToken,
getAdminSessionPayload,
getAdminSessionSecret,
getSessionCookieOptions,
} from "@/core/auth/adminSession";
import {
AdminDatabaseRequiredError,
consumeAdminLoginAttempt,
createInitialAdmin,
getAdminSetupKey,
isAdminSetupComplete,
requiresPersistentAdminDatabase,
resetAdminStateForTests,
verifyAdminCredentials,
verifyAdminSetupKey,
verifyRequestAdminSession,
} from "@/core/auth/adminUsers";
import { AuthService, resolveDefaultJwtSecret } from "@/core/auth/jwt";
import { DatabaseEngine } from "@/core/Database/database";
import { SDKManager } from "@/core/sdk/sdkManager";
import { extractClientIp } from "@/lib/adminAuth";
import { isSameOriginRequest, middleware } from "@/middleware";
const ORIGINAL_ENV = { ...process.env };
function restoreEnv() {
for (const key of Object.keys(process.env)) {
if (!(key in ORIGINAL_ENV)) {
delete process.env[key];
}
}
Object.assign(process.env, ORIGINAL_ENV);
AuthService.setSecret(resolveDefaultJwtSecret() || "");
}
describe("Phase-01 Auth, Secrets, Revocation & Proxy Hardening", () => {
beforeEach(() => {
restoreEnv();
process.env.INGESTION_INTERNAL_URL = "http://127.0.0.1:1";
resetAdminStateForTests();
const g = globalThis as {
__dataStackClientsMap?: Map<string, unknown>;
__dataStackDeletedClients?: Set<string>;
};
g.__dataStackClientsMap?.clear();
g.__dataStackDeletedClients?.clear();
});
afterEach(() => {
restoreEnv();
resetAdminStateForTests();
});
after(() => {
const bufState = (
globalThis as {
__dataStackBufferState?: { flushTimer?: ReturnType<typeof setInterval> | null };
}
).__dataStackBufferState;
if (bufState?.flushTimer) {
clearInterval(bufState.flushTimer);
bufState.flushTimer = null;
}
});
it("BUG-01 & BUG-02: fails closed in production when secrets or DB/setup are missing", async () => {
(process.env as Record<string, string | undefined>).NODE_ENV = "production";
delete process.env.DATABASE_URL;
delete process.env.DATASTACK_ADMIN_SESSION_SECRET;
delete process.env.DATASTACK_ADMIN_SETUP_KEY;
delete process.env.DATASTACK_JWT_SECRET;
delete process.env.DATASTACK_ADMIN_PASSWORD;
assert.equal(getAdminSessionSecret(), null);
assert.equal(getAdminSetupKey(), null);
assert.equal(resolveDefaultJwtSecret(), "");
assert.equal(
verifyAdminSetupKey("datastack-default-setup-key-32-chars"),
false,
);
assert.equal(await isAdminSetupComplete(), false);
await assert.rejects(
() => verifyAdminCredentials("admin@datastack.dev", "admin12345678"),
/setup/i,
);
AuthService.setSecret(resolveDefaultJwtSecret());
assert.equal(AuthService.isConfigured(), false);
assert.throws(() => AuthService.generateClientToken({ clientId: "c1" }));
});
it("BUG-03: bumps tokenVersion on credential update and rejects old session cookies", async () => {
delete process.env.DATABASE_URL;
process.env.DATASTACK_ALLOW_DEMO_ADMIN = "false";
const created = await createInitialAdmin("owner@datastack.dev", "InitialPass123!");
assert.equal(created, true);
assert.equal(await isAdminSetupComplete(), true);
const secret = getAdminSessionSecret()!;
const v1Token = await createAdminSessionToken(
"owner@datastack.dev",
secret,
Date.now() + 3600_000,
1,
);
const checkV1 = await verifyRequestAdminSession(v1Token);
assert.equal(checkV1.valid, true);
const updateReq = new NextRequest("http://localhost:3000/api/auth/profile", {
method: "PUT",
headers: {
"content-type": "application/json",
cookie: `datastack_admin_session=${v1Token}`,
},
body: JSON.stringify({
email: "owner2@datastack.dev",
currentPassword: "InitialPass123!",
newPassword: "UpdatedPass456!",
}),
});
const updateRes = await profilePut(updateReq);
assert.equal(updateRes.status, 200);
const setCookie = updateRes.cookies.get("datastack_admin_session")?.value;
assert.ok(setCookie);
const newPayload = await getAdminSessionPayload(setCookie!, secret);
assert.ok(newPayload);
assert.equal(newPayload!.tokenVersion, 2);
// Old v1 session must now return 401
const staleProfileReq = new NextRequest("http://localhost:3000/api/auth/profile", {
method: "GET",
headers: { cookie: `datastack_admin_session=${v1Token}` },
});
const staleRes = await profileGet(staleProfileReq);
assert.equal(staleRes.status, 401);
// New v2 session succeeds
const freshProfileReq = new NextRequest("http://localhost:3000/api/auth/profile", {
method: "GET",
headers: { cookie: `datastack_admin_session=${setCookie}` },
});
const freshRes = await profileGet(freshProfileReq);
assert.equal(freshRes.status, 200);
});
it("BUG-04: throttles by composite IP+email without locking out other admin IPs", async () => {
const secret = "test-throttle-secret-at-least-32-chars-long";
const targetEmail = "admin@datastack.dev";
for (let i = 0; i < 5; i++) {
const dec = await consumeAdminLoginAttempt(targetEmail, secret, "198.51.100.10");
assert.equal(dec.allowed, true);
}
// 6th attempt from attacker IP is blocked
const blocked = await consumeAdminLoginAttempt(targetEmail, secret, "198.51.100.10");
assert.equal(blocked.allowed, false);
assert.ok(blocked.retryAfterSeconds >= 1);
// Real admin from different IP is still allowed
const otherIpAllowed = await consumeAdminLoginAttempt(
targetEmail,
secret,
"203.0.113.55",
);
assert.equal(otherIpAllowed.allowed, true);
// Same IP spraying 25 distinct emails triggers IP bucket block on 26th
for (let i = 0; i < 25; i++) {
const spray = await consumeAdminLoginAttempt(
`spray${i}@example.com`,
secret,
"198.51.100.99",
);
assert.equal(spray.allowed, true);
}
const sprayBlocked = await consumeAdminLoginAttempt(
"spray25@example.com",
secret,
"198.51.100.99",
);
assert.equal(sprayBlocked.allowed, false);
});
it("BUG-05 & BUG-15: redacts tokens in client list, returns 400 on malformed JSON, and blocks deleted/unregistered Bearer tokens", async () => {
delete process.env.DATABASE_URL;
await createInitialAdmin("admin@datastack.dev", "AdminPass123!");
const secret = getAdminSessionSecret()!;
const adminCookie = await createAdminSessionToken(
"admin@datastack.dev",
secret,
Date.now() + 3600_000,
1,
);
const createReq = new NextRequest("http://localhost:3000/api/clients", {
method: "POST",
headers: {
"content-type": "application/json",
cookie: `datastack_admin_session=${adminCookie}`,
},
body: JSON.stringify({
clientId: "phase01_probe_client",
name: "Phase01 Probe",
rateLimit: 50,
}),
});
const createRes = await clientsPost(createReq);
assert.equal(createRes.status, 201);
const createdJson = await createRes.json();
const clientToken = createdJson.client.token as string;
assert.ok(clientToken.length > 20);
// List endpoint must redact full token & secret
const listReq = new NextRequest("http://localhost:3000/api/clients", {
method: "GET",
headers: { cookie: `datastack_admin_session=${adminCookie}` },
});
const listRes = await clientsGet(listReq);
assert.equal(listRes.status, 200);
const listJson = await listRes.json();
const listed = listJson.clients.find(
(c: { clientId: string }) => c.clientId === "phase01_probe_client",
);
assert.ok(listed);
assert.equal("token" in listed, false);
assert.equal("secret" in listed, false);
assert.equal(listed.tokenPreview, `${clientToken.slice(0, 12)}...`);
// Single client GET omits token by default, reveals on ?includeToken=true
const getDefaultRes = await clientGet(
new NextRequest("http://localhost:3000/api/clients/phase01_probe_client", {
headers: { cookie: `datastack_admin_session=${adminCookie}` },
}),
{ params: Promise.resolve({ id: "phase01_probe_client" }) },
);
const defaultClient = (await getDefaultRes.json()).client;
assert.equal("token" in defaultClient, false);
const getIncludeRes = await clientGet(
new NextRequest(
"http://localhost:3000/api/clients/phase01_probe_client?includeToken=true",
{ headers: { cookie: `datastack_admin_session=${adminCookie}` } },
),
{ params: Promise.resolve({ id: "phase01_probe_client" }) },
);
const includeClient = (await getIncludeRes.json()).client;
assert.equal(includeClient.token, clientToken);
// Malformed JSON on POST /api/events returns 400 (not 500)
const malformedRes = await eventsPost(
new NextRequest("http://localhost:3000/api/events", {
method: "POST",
headers: {
authorization: `Bearer ${clientToken}`,
"content-type": "application/json",
},
body: "{bad-json",
}),
);
assert.equal(malformedRes.status, 400);
// Delete client -> subsequent Bearer ingestion fails closed with 403 CLIENT_REVOKED
const delRes = await clientDelete(
new NextRequest("http://localhost:3000/api/clients/phase01_probe_client", {
method: "DELETE",
headers: { cookie: `datastack_admin_session=${adminCookie}` },
}),
{ params: Promise.resolve({ id: "phase01_probe_client" }) },
);
assert.equal(delRes.status, 200);
const rejectedRes = await eventsPost(
new NextRequest("http://localhost:3000/api/events", {
method: "POST",
headers: {
authorization: `Bearer ${clientToken}`,
"content-type": "application/json",
},
body: JSON.stringify({ eventId: "evt_after_delete", data: { ok: 1 } }),
}),
);
assert.equal(rejectedRes.status, 403);
// Unregistered signed Bearer token also rejected with 403 CLIENT_REVOKED
const ghostToken = AuthService.generateClientToken({
clientId: "unregistered_ghost_client",
});
const ghostRes = await eventsPost(
new NextRequest("http://localhost:3000/api/events", {
method: "POST",
headers: {
authorization: `Bearer ${ghostToken}`,
"content-type": "application/json",
},
body: JSON.stringify({ eventId: "evt_ghost", data: { ok: 1 } }),
}),
);
assert.equal(ghostRes.status, 403);
});
it("BUG-26: validates Origin or Referer against Host / X-Forwarded-Host", () => {
const reqOriginOk = new NextRequest("http://localhost:3000/api/clients", {
method: "POST",
headers: {
origin: "https://console.example.com",
"x-forwarded-host": "console.example.com",
},
});
assert.equal(isSameOriginRequest(reqOriginOk), true);
const reqRefererOk = new NextRequest("http://localhost:3000/api/clients", {
method: "POST",
headers: {
referer: "https://console.example.com/vcon/clients",
host: "console.example.com",
},
});
assert.equal(isSameOriginRequest(reqRefererOk), true);
const reqCrossOrigin = new NextRequest("http://localhost:3000/api/clients", {
method: "POST",
headers: {
origin: "https://evil.example.com",
host: "console.example.com",
},
});
assert.equal(isSameOriginRequest(reqCrossOrigin), false);
const reqMissingBoth = new NextRequest("http://localhost:3000/api/clients", {
method: "POST",
headers: {
host: "console.example.com",
},
});
assert.equal(isSameOriginRequest(reqMissingBoth), false);
});
it("BUG-A02: rejects spoofable x-datastack-admin-client, DataStack-CLI, and cross-site Sec-Fetch-Site headers without same-origin proof", async () => {
process.env.DATASTACK_ADMIN_SESSION_SECRET = "test-secret-at-least-32-chars-long-for-session";
// 1. Missing origin/referer -> 403
const blockedReq = new NextRequest("http://localhost:3000/api/clients", {
method: "POST",
headers: { host: "localhost:3000" },
});
const blockedRes = await middleware(blockedReq);
assert.equal(blockedRes.status, 403);
// 2. Spoofed x-datastack-admin-client header must still be rejected 403
const headlessReq = new NextRequest("http://localhost:3000/api/clients", {
method: "POST",
headers: {
host: "localhost:3000",
"x-datastack-admin-client": "true",
},
});
const headlessRes = await middleware(headlessReq);
assert.equal(headlessRes.status, 403);
// 3. Spoofed DataStack-CLI User-Agent + cross-origin must still be rejected 403
const cliReq = new NextRequest("http://localhost:3000/api/clients", {
method: "POST",
headers: {
host: "localhost:3000",
origin: "https://evil.example.com",
"user-agent": "DataStack-CLI/1.0",
},
});
const cliRes = await middleware(cliReq);
assert.equal(cliRes.status, 403);
// 4. Genuine same-origin passes CSRF and reaches auth check (401 without cookie)
const sameOriginReq = new NextRequest("http://localhost:3000/api/clients", {
method: "POST",
headers: {
host: "localhost:3000",
origin: "http://localhost:3000",
},
});
const sameOriginRes = await middleware(sameOriginReq);
assert.equal(sameOriginRes.status, 401);
});
it("BUG-A01: enforces tokenVersion revocation across /api/data, GET /api/events, /api/export, /api/metrics, and /api/storage", async () => {
delete process.env.DATABASE_URL;
process.env.DATASTACK_ALLOW_DEMO_ADMIN = "false";
await createInitialAdmin("owner@datastack.dev", "InitialPass123!");
const secret = getAdminSessionSecret()!;
const v1Token = await createAdminSessionToken(
"owner@datastack.dev",
secret,
Date.now() + 3600_000,
1,
);
const updateRes = await profilePut(
new NextRequest("http://localhost:3000/api/auth/profile", {
method: "PUT",
headers: {
"content-type": "application/json",
cookie: `datastack_admin_session=${v1Token}`,
},
body: JSON.stringify({
email: "owner@datastack.dev",
currentPassword: "InitialPass123!",
newPassword: "RotatedPass456!",
}),
}),
);
assert.equal(updateRes.status, 200);
const v2Cookie = updateRes.cookies.get("datastack_admin_session")?.value;
assert.ok(v2Cookie);
const endpoints: Array<() => Promise<Response>> = [
() => dataGet(new NextRequest("http://localhost:3000/api/data", { headers: { cookie: `datastack_admin_session=${v1Token}` } })),
() => eventsGet(new NextRequest("http://localhost:3000/api/events", { headers: { cookie: `datastack_admin_session=${v1Token}` } })),
() => exportGet(new NextRequest("http://localhost:3000/api/export?flush=false", { headers: { cookie: `datastack_admin_session=${v1Token}` } })),
() => metricsGet(new NextRequest("http://localhost:3000/api/metrics", { headers: { cookie: `datastack_admin_session=${v1Token}` } })),
() => storageGet(new NextRequest("http://localhost:3000/api/storage", { headers: { cookie: `datastack_admin_session=${v1Token}` } })),
() => storagePost(new NextRequest("http://localhost:3000/api/storage", { method: "POST", headers: { cookie: `datastack_admin_session=${v1Token}` } })),
];
for (const invoke of endpoints) {
const res = await invoke();
assert.equal(res.status, 401);
}
const okMetrics = await metricsGet(
new NextRequest("http://localhost:3000/api/metrics", {
headers: { cookie: `datastack_admin_session=${v2Cookie}` },
}),
);
assert.equal(okMetrics.status, 200);
});
it("BUG-A04 & BUG-A05: rejects unregistered clients on /api/health & admin POST /api/events and validates PATCH /api/clients/[id]", async () => {
delete process.env.DATABASE_URL;
await createInitialAdmin("admin@datastack.dev", "AdminPass123!");
const secret = getAdminSessionSecret()!;
const adminCookie = await createAdminSessionToken(
"admin@datastack.dev",
secret,
Date.now() + 3600_000,
1,
);
// Public unauthenticated /api/health probe stays 200
const publicHealth = await healthGet(new NextRequest("http://localhost:3000/api/health"));
assert.equal(publicHealth.status, 200);
// Unregistered signed client Bearer token on /api/health -> 403 CLIENT_REVOKED
const ghostToken = AuthService.generateClientToken({ clientId: "ghost_health_client" });
const ghostHealth = await healthGet(
new NextRequest("http://localhost:3000/api/health", {
headers: { authorization: `Bearer ${ghostToken}` },
}),
);
assert.equal(ghostHealth.status, 403);
// Admin cookie POST /api/events for unregistered clientId -> 403 CLIENT_REVOKED
const ghostAdminPost = await eventsPost(
new NextRequest("http://localhost:3000/api/events", {
method: "POST",
headers: {
"content-type": "application/json",
cookie: `datastack_admin_session=${adminCookie}`,
},
body: JSON.stringify({ clientId: "unregistered_admin_target", data: { ok: 1 } }),
}),
);
assert.equal(ghostAdminPost.status, 403);
// Create normalized client and verify mixed-case/unvalidated PATCH checks
const createdRes = await clientsPost(
new NextRequest("http://localhost:3000/api/clients", {
method: "POST",
headers: {
"content-type": "application/json",
cookie: `datastack_admin_session=${adminCookie}`,
},
body: JSON.stringify({ clientId: "Norm_Client_01", name: "Normalized", rateLimit: 50 }),
}),
);
assert.equal(createdRes.status, 201);
// Invalid non-string name -> 400 (not 500)
const badNameRes = await clientPatch(
new NextRequest("http://localhost:3000/api/clients/Norm_Client_01", {
method: "PATCH",
headers: {
"content-type": "application/json",
cookie: `datastack_admin_session=${adminCookie}`,
},
body: JSON.stringify({ name: 12345 }),
}),
{ params: Promise.resolve({ id: "Norm_Client_01" }) },
);
assert.equal(badNameRes.status, 400);
// Invalid status -> 400
const badStatusRes = await clientPatch(
new NextRequest("http://localhost:3000/api/clients/Norm_Client_01", {
method: "PATCH",
headers: {
"content-type": "application/json",
cookie: `datastack_admin_session=${adminCookie}`,
},
body: JSON.stringify({ status: "suspended" }),
}),
{ params: Promise.resolve({ id: "Norm_Client_01" }) },
);
assert.equal(badStatusRes.status, 400);
// Valid mixed-case normalized PATCH -> 200
const goodPatchRes = await clientPatch(
new NextRequest("http://localhost:3000/api/clients/NORM_CLIENT_01", {
method: "PATCH",
headers: {
"content-type": "application/json",
cookie: `datastack_admin_session=${adminCookie}`,
},
body: JSON.stringify({ name: "Updated Clean Name", rateLimit: 250 }),
}),
{ params: Promise.resolve({ id: "NORM_CLIENT_01" }) },
);
assert.equal(goodPatchRes.status, 200);
const patchedJson = await goodPatchRes.json();
assert.equal(patchedJson.client.clientId, "norm_client_01");
assert.equal(patchedJson.client.rateLimit, 250);
});
it("FORENSIC BUG-01: blocks volatile RAM admin setup in production without DATABASE_URL and returns 409 SETUP_REQUIRED on pre-setup login", async () => {
(process.env as Record<string, string | undefined>).NODE_ENV = "production";
delete process.env.DATABASE_URL;
delete process.env.DATASTACK_ADMIN_PASSWORD;
process.env.DATASTACK_ADMIN_SESSION_SECRET =
"prod-session-secret-at-least-32-characters-long";
process.env.DATASTACK_ADMIN_SETUP_KEY =
"prod-setup-key-at-least-32-characters-long";
assert.equal(requiresPersistentAdminDatabase(), true);
await assert.rejects(
() => createInitialAdmin("owner@datastack.dev", "StrongPass123!"),
AdminDatabaseRequiredError,
);
const setupRes = await setupPost(
new NextRequest("http://localhost:3000/api/auth/setup", {
method: "POST",
headers: {
"content-type": "application/json",
host: "localhost:3000",
origin: "http://localhost:3000",
},
body: JSON.stringify({
email: "owner@datastack.dev",
password: "StrongPass123!",
setupKey: process.env.DATASTACK_ADMIN_SETUP_KEY,
}),
}),
);
assert.equal(setupRes.status, 503);
const setupJson = await setupRes.json();
assert.equal(setupJson.code, "DATABASE_NOT_CONFIGURED");
const loginRes = await loginPost(
new NextRequest("http://localhost:3000/api/auth/login", {
method: "POST",
headers: {
"content-type": "application/json",
host: "localhost:3000",
origin: "http://localhost:3000",
},
body: JSON.stringify({
email: "owner@datastack.dev",
password: "StrongPass123!",
}),
}),
);
assert.equal(loginRes.status, 409);
const loginJson = await loginRes.json();
assert.equal(loginJson.code, "SETUP_REQUIRED");
});
it("FORENSIC BUG-04: throttles POST /api/auth/setup brute-force attempts and checks setup completion before verifying setupKey", async () => {
delete process.env.DATABASE_URL;
process.env.DATASTACK_ALLOW_DEMO_ADMIN = "false";
process.env.DATASTACK_ADMIN_SETUP_KEY =
"custom-setup-key-at-least-32-characters-long";
for (let i = 0; i < 5; i++) {
const badRes = await setupPost(
new NextRequest("http://localhost:3000/api/auth/setup", {
method: "POST",
headers: {
"content-type": "application/json",
"x-forwarded-for": "198.51.100.77",
},
body: JSON.stringify({
email: "admin@datastack.dev",
password: "StrongPass123!",
setupKey: "wrong-key-attempt",
}),
}),
);
assert.equal(badRes.status, 403);
}
const throttledRes = await setupPost(
new NextRequest("http://localhost:3000/api/auth/setup", {
method: "POST",
headers: {
"content-type": "application/json",
"x-forwarded-for": "198.51.100.77",
},
body: JSON.stringify({
email: "admin@datastack.dev",
password: "StrongPass123!",
setupKey: process.env.DATASTACK_ADMIN_SETUP_KEY,
}),
}),
);
assert.equal(throttledRes.status, 429);
assert.ok(Number(throttledRes.headers.get("retry-after")) >= 1);
// Different IP succeeds and initializes admin
const okRes = await setupPost(
new NextRequest("http://localhost:3000/api/auth/setup", {
method: "POST",
headers: {
"content-type": "application/json",
"x-forwarded-for": "203.0.113.88",
},
body: JSON.stringify({
email: "admin@datastack.dev",
password: "StrongPass123!",
setupKey: process.env.DATASTACK_ADMIN_SETUP_KEY,
}),
}),
);
assert.equal(okRes.status, 200);
// Subsequent setup attempt returns 409 even if setupKey is invalid
const postInitRes = await setupPost(
new NextRequest("http://localhost:3000/api/auth/setup", {
method: "POST",
headers: {
"content-type": "application/json",
"x-forwarded-for": "203.0.113.89",
},
body: JSON.stringify({
email: "other@datastack.dev",
password: "StrongPass123!",
setupKey: "completely-invalid-key",
}),
}),
);
assert.equal(postInitRes.status, 409);
});
it("FORENSIC BUG-05: revokes session cookie server-side on logout, ignores spoofed Origin for Secure flag, and allows privacy-stripped same-origin requests", async () => {
delete process.env.DATABASE_URL;
process.env.DATASTACK_ALLOW_DEMO_ADMIN = "false";
await createInitialAdmin("logout-test@datastack.dev", "LogoutPass123!");
const secret = getAdminSessionSecret()!;
const sessionToken = await createAdminSessionToken(
"logout-test@datastack.dev",
secret,
Date.now() + 3600_000,
1,
);
// Valid before logout
const preLogoutRes = await profileGet(
new NextRequest("http://localhost:3000/api/auth/profile", {
headers: { cookie: `datastack_admin_session=${sessionToken}` },
}),
);
assert.equal(preLogoutRes.status, 200);
// Logout bumps tokenVersion server-side
const logoutRes = await logoutPost(
new NextRequest("http://localhost:3000/api/auth/logout", {
method: "POST",
headers: { cookie: `datastack_admin_session=${sessionToken}` },
}),
);
assert.equal(logoutRes.status, 200);
// Replaying captured pre-logout cookie must return 401
const replayProfile = await profileGet(
new NextRequest("http://localhost:3000/api/auth/profile", {
headers: { cookie: `datastack_admin_session=${sessionToken}` },
}),
);
assert.equal(replayProfile.status, 401);
// Cookie Secure flag must ignore spoofed https Origin on plain http request
const spoofedOriginReq = new Request("http://localhost:3000/api/auth/login", {
method: "POST",
headers: { origin: "https://evil.example.com" },
});
const plainOpts = getSessionCookieOptions(spoofedOriginReq, 3600);
assert.equal(plainOpts.secure, false);
assert.equal(plainOpts.sameSite, "lax");
const httpsProxyReq = new Request("http://localhost:3000/api/auth/login", {
method: "POST",
headers: { "x-forwarded-proto": "https" },
});
const httpsOpts = getSessionCookieOptions(httpsProxyReq, 3600);
assert.equal(httpsOpts.secure, true);
assert.equal(httpsOpts.sameSite, "none");
// Privacy extension stripping Origin & Referer with Sec-Fetch-Site: same-origin passes CSRF
const privacySameOriginReq = new NextRequest("http://localhost:3000/api/clients", {
method: "POST",
headers: {
host: "localhost:3000",
"sec-fetch-site": "same-origin",
},
});
assert.equal(isSameOriginRequest(privacySameOriginReq), true);
const crossSiteReq = new NextRequest("http://localhost:3000/api/clients", {
method: "POST",
headers: {
host: "localhost:3000",
"sec-fetch-site": "cross-site",
},
});
assert.equal(isSameOriginRequest(crossSiteReq), false);
});
it("FORENSIC BUG-06: prevents empty production jwtSecret PG persistence and propagates DB write errors instead of silently swallowing them", async () => {
const origGetPool = DatabaseEngine.getPool;
const origEnsureSchema = DatabaseEngine.ensureSchema;
const settingsGlobals = globalThis as {
__dataStackAdminSettings?: unknown;
__dataStackSettingsHydrated?: boolean;
};
const queries: string[] = [];
try {
// 1. Production with empty jwtSecret must not persist empty jwt_secret row into PG
(process.env as Record<string, string | undefined>).NODE_ENV = "production";
delete process.env.DATASTACK_JWT_SECRET;
settingsGlobals.__dataStackAdminSettings = undefined;
settingsGlobals.__dataStackSettingsHydrated = false;
DatabaseEngine.getPool = (() =>
({
query: async (sql: string) => {
queries.push(sql);
return { rowCount: 0, rows: [] };
},
}) as unknown as ReturnType<typeof DatabaseEngine.getPool>);
DatabaseEngine.ensureSchema = async () => true;
await SettingsManager.getSettingsAsync();
assert.equal(
queries.some((sql) => sql.includes("INSERT INTO admin_settings")),
false,
);
// 2. Failing PG write must reject (not silently return 200) and must not mutate RAM
(process.env as Record<string, string | undefined>).NODE_ENV = "test";
process.env.DATASTACK_JWT_SECRET =
"valid-jwt-secret-at-least-32-characters-long";
AuthService.setSecret(process.env.DATASTACK_JWT_SECRET);
settingsGlobals.__dataStackAdminSettings = undefined;
settingsGlobals.__dataStackSettingsHydrated = false;
DatabaseEngine.getPool = (() =>
({
query: async (sql: string) => {
if (sql.includes("INSERT INTO") || sql.includes("UPDATE")) {
throw new Error("simulated PG outage");
}
return { rowCount: 0, rows: [] };
},
}) as unknown as ReturnType<typeof DatabaseEngine.getPool>);
await assert.rejects(
() => SettingsManager.updateSettingsAsync({ maxEventsPerSec: 777 }),
/DATABASE_WRITE_FAILED/,
);
await assert.rejects(
() =>
SDKManager.registerClientAsync({
clientId: "db_fail_client",
name: "DB Fail Client",
}),
/DATABASE_WRITE_FAILED/,
);
assert.equal(SDKManager.getClient("db_fail_client"), undefined);
} finally {
DatabaseEngine.getPool = origGetPool;
DatabaseEngine.ensureSchema = origEnsureSchema;
settingsGlobals.__dataStackAdminSettings = undefined;
settingsGlobals.__dataStackSettingsHydrated = false;
}
});
it("R2 PHASE-01 BUG-01: enforces same-origin CSRF check on POST /api/auth/login and POST /api/auth/setup while preserving same-origin and Bearer /api/events", async () => {
process.env.DATASTACK_ADMIN_SESSION_SECRET =
"test-secret-at-least-32-chars-long-for-session";
// Cross-origin POST /api/auth/login -> 403
const crossLoginRes = await middleware(
new NextRequest("http://localhost:3000/api/auth/login", {
method: "POST",
headers: {
host: "localhost:3000",
origin: "https://evil.example.com",
},
}),
);
assert.equal(crossLoginRes.status, 403);
assert.deepEqual(await crossLoginRes.json(), {
error: "Cross-origin request rejected.",
});
// Missing origin/referer/sec-fetch-site POST /api/auth/login -> 403
const bareLoginRes = await middleware(
new NextRequest("http://localhost:3000/api/auth/login", {
method: "POST",
headers: { host: "localhost:3000" },
}),
);
assert.equal(bareLoginRes.status, 403);
// Cross-origin POST /api/auth/setup -> 403
const crossSetupRes = await middleware(
new NextRequest("http://localhost:3000/api/auth/setup", {
method: "POST",
headers: {
host: "localhost:3000",
origin: "https://evil.example.com",
},
}),
);
assert.equal(crossSetupRes.status, 403);
// Missing origin POST /api/auth/setup -> 403
const bareSetupRes = await middleware(
new NextRequest("http://localhost:3000/api/auth/setup", {
method: "POST",
headers: { host: "localhost:3000" },
}),
);
assert.equal(bareSetupRes.status, 403);
// Same-origin POST /api/auth/login passes middleware (200 next)
const sameOriginLoginRes = await middleware(
new NextRequest("http://localhost:3000/api/auth/login", {
method: "POST",
headers: {
host: "localhost:3000",
origin: "http://localhost:3000",
},
}),
);
assert.equal(sameOriginLoginRes.status, 200);
// Privacy-stripped same-origin POST /api/auth/login via Sec-Fetch-Site passes middleware
const privacyLoginRes = await middleware(
new NextRequest("http://localhost:3000/api/auth/login", {
method: "POST",
headers: {
host: "localhost:3000",
"sec-fetch-site": "same-origin",
},
}),
);
assert.equal(privacyLoginRes.status, 200);
// Same-origin POST /api/auth/setup passes middleware (200 next)
const sameOriginSetupRes = await middleware(
new NextRequest("http://localhost:3000/api/auth/setup", {
method: "POST",
headers: {
host: "localhost:3000",
origin: "http://localhost:3000",
},
}),
);
assert.equal(sameOriginSetupRes.status, 200);
// Bearer-authenticated POST /api/events without Origin stays allowed (machine-to-machine SDK)
const bearerEventsRes = await middleware(
new NextRequest("http://localhost:3000/api/events", {
method: "POST",
headers: {
host: "localhost:3000",
authorization: "Bearer sdk.jwt.token",
},
}),
);
assert.equal(bearerEventsRes.status, 200);
// Non-Bearer cross-origin POST /api/events is rejected 403
const crossEventsRes = await middleware(
new NextRequest("http://localhost:3000/api/events", {
method: "POST",
headers: {
host: "localhost:3000",
origin: "https://evil.example.com",
},
}),
);
assert.equal(crossEventsRes.status, 403);
// Safe GET public API endpoints remain accessible without Origin
const healthRes = await middleware(
new NextRequest("http://localhost:3000/api/health", {
method: "GET",
headers: { host: "localhost:3000" },
}),
);
assert.equal(healthRes.status, 200);
});
it("R2 PHASE-01 BUG-02: extractClientIp trusts X-Real-IP and rightmost X-Forwarded-For hop, blocking spoofed-XFF lockouts on login & setup", async () => {
// Direct unit assertions on extractClientIp
assert.equal(
extractClientIp(
new NextRequest("http://localhost:3000/api/auth/login", {
headers: {
"x-forwarded-for": "1.2.3.4, 203.0.113.9",
"x-real-ip": "203.0.113.9",
},
}),
),
"203.0.113.9",
);
assert.equal(
extractClientIp(
new NextRequest("http://localhost:3000/api/auth/login", {
headers: {
"x-forwarded-for": "1.2.3.4, 198.51.100.50, ",
"x-real-ip": " ",
},
}),
),
"198.51.100.50",
);
assert.equal(
extractClientIp(new NextRequest("http://localhost:3000/api/auth/login")),
"unknown",
);
// End-to-end brute-force lockout on POST /api/auth/login despite rotating spoofed leftmost XFF
delete process.env.DATABASE_URL;
process.env.DATASTACK_ALLOW_DEMO_ADMIN = "false";
process.env.DATASTACK_ADMIN_SETUP_KEY =
"phase01-setup-key-at-least-32-characters-long";
// First verify setup route blocks rotating spoofed leftmost XFF
for (let i = 0; i < 5; i++) {
const badSetup = await setupPost(
new NextRequest("http://localhost:3000/api/auth/setup", {
method: "POST",
headers: {
"content-type": "application/json",
"x-forwarded-for": `10.1.0.${i + 1}, 198.51.100.42`,
},
body: JSON.stringify({
email: "admin@datastack.dev",
password: "StrongPass123!",
setupKey: "wrong-key",
}),
}),
);
assert.equal(badSetup.status, 403);
}
const blockedSetup = await setupPost(
new NextRequest("http://localhost:3000/api/auth/setup", {
method: "POST",
headers: {
"content-type": "application/json",
"x-forwarded-for": "10.1.0.99, 198.51.100.42",
},
body: JSON.stringify({
email: "admin@datastack.dev",
password: "StrongPass123!",
setupKey: process.env.DATASTACK_ADMIN_SETUP_KEY,
}),
}),
);
assert.equal(blockedSetup.status, 429);
// Create admin and verify login route blocks rotating spoofed leftmost XFF with X-Real-IP
await createInitialAdmin("lockout@datastack.dev", "RealPassword123!");
for (let i = 0; i < 5; i++) {
const badLogin = await loginPost(
new NextRequest("http://localhost:3000/api/auth/login", {
method: "POST",
headers: {
"content-type": "application/json",
"x-forwarded-for": `172.16.0.${i + 1}, 203.0.113.9`,
"x-real-ip": "203.0.113.9",
},
body: JSON.stringify({
email: "lockout@datastack.dev",
password: "WrongPassword!",
}),
}),
);
assert.equal(badLogin.status, 401);
}
const blockedLogin = await loginPost(
new NextRequest("http://localhost:3000/api/auth/login", {
method: "POST",
headers: {
"content-type": "application/json",
"x-forwarded-for": "172.16.0.99, 203.0.113.9",
"x-real-ip": "203.0.113.9",
},
body: JSON.stringify({
email: "lockout@datastack.dev",
password: "RealPassword123!",
}),
}),
);
assert.equal(blockedLogin.status, 429);
assert.ok(Number(blockedLogin.headers.get("retry-after")) >= 1);
});
});