- Add configurable ingestion batch item limits - Improve client serialization and sanitization - Add graceful handling for corrupt GZIP partitions in data API - Expand admin session token scope - Update project documentation for R4 status
619 lines
22 KiB
TypeScript
619 lines
22 KiB
TypeScript
import assert from "node:assert/strict";
|
|
import fs from "node:fs/promises";
|
|
import http from "node:http";
|
|
import { createRequire } from "node:module";
|
|
import type { AddressInfo } from "node:net";
|
|
import os from "node:os";
|
|
import path from "node:path";
|
|
import test from "node:test";
|
|
import zlib from "node:zlib";
|
|
import { NextRequest } from "next/server";
|
|
|
|
process.env.DATASTACK_DISABLE_LISTEN = "1";
|
|
|
|
import { GET as auditGet } from "../app/api/audit/route";
|
|
import { POST as settingsPost } from "../app/api/settings/route";
|
|
import { POST as webhookTestPost } from "../app/api/settings/webhook-test/route";
|
|
import { POST as s3TestPost } from "../app/api/storage/s3-test/route";
|
|
import { SettingsManager } from "../core/adminSettings/settingsManager";
|
|
import {
|
|
clearWebhookCooldownCacheForTests,
|
|
dispatchWebhookAlertAsync,
|
|
} from "../core/alerts/webhookNotifier";
|
|
import {
|
|
createAdminSessionToken,
|
|
getAdminSessionSecret,
|
|
} from "../core/auth/adminSession";
|
|
import {
|
|
createInitialAdmin,
|
|
createAdminTeamMemberAsync,
|
|
resetAdminStateForTests,
|
|
revokeAdminSessions,
|
|
updateAdminTeamMemberAsync,
|
|
deleteAdminTeamMemberAsync,
|
|
} from "../core/auth/adminUsers";
|
|
import {
|
|
clearAuditLogsForTests,
|
|
listAdminAuditLogsWithStatusAsync,
|
|
recordAdminAuditLogAsync,
|
|
} from "../core/auth/auditLog";
|
|
import { DataBufferEngine } from "../core/data/buffer";
|
|
import { SDKManager } from "../core/sdk/sdkManager";
|
|
import { getInternalIngestionHeaders } from "../core/Security/security";
|
|
import {
|
|
checkIpAddressAllowed,
|
|
validateOutboundUrlAsync,
|
|
validateOutboundUrlSync,
|
|
} from "../core/Security/ssrfGuard";
|
|
import { testS3Connection, uploadFileToS3 } from "../core/Storage/s3Archive";
|
|
import * as instrumentationHook from "../instrumentation";
|
|
|
|
const require = createRequire(import.meta.url);
|
|
const filesManager = require("../server/filesManager.js") as {
|
|
authenticateFilesRequest: (params: {
|
|
cookieHeader?: string;
|
|
dbPool?: unknown;
|
|
env?: NodeJS.ProcessEnv;
|
|
nowMs?: number;
|
|
}) => Promise<{
|
|
valid: boolean;
|
|
status?: number;
|
|
code?: string;
|
|
error?: string;
|
|
session?: { email: string; role: string; memberId: string; tokenVersion: number };
|
|
}>;
|
|
syncInMemoryAdminSessionState: (payload: Record<string, unknown>) => boolean;
|
|
clearInMemoryAdminSessionStateForTests: () => void;
|
|
};
|
|
|
|
const ingestionServer = require("../server/index.js") as {
|
|
app: (req: http.IncomingMessage, res: http.ServerResponse) => void;
|
|
setDbPoolForTests: (pool: unknown) => void;
|
|
syncSettingsFromDatabase: () => Promise<boolean>;
|
|
validateOutboundWebhookUrlAsync: (
|
|
rawUrl: string,
|
|
options?: Record<string, unknown>,
|
|
) => Promise<{ allowed: boolean; code?: string; error?: string; url?: string }>;
|
|
triggerWebhookAlert: (
|
|
payload: Record<string, unknown>,
|
|
options?: Record<string, unknown>,
|
|
) => Promise<{ dispatched: boolean; status?: number; code?: string; reason?: string; error?: string }>;
|
|
clearWebhookCooldownCacheForTests: () => void;
|
|
stopTimers: () => void;
|
|
};
|
|
|
|
const ORIGINAL_ENV = { ...process.env };
|
|
|
|
function restoreEnv(): void {
|
|
for (const key of Object.keys(process.env)) {
|
|
if (!(key in ORIGINAL_ENV)) {
|
|
delete process.env[key];
|
|
}
|
|
}
|
|
Object.assign(process.env, ORIGINAL_ENV);
|
|
}
|
|
|
|
async function createOwnerCookie(email = "r4p1-owner@datastack.dev"): Promise<string> {
|
|
resetAdminStateForTests();
|
|
await createInitialAdmin(email, "OwnerPassword123!");
|
|
const secret = getAdminSessionSecret();
|
|
const token = await createAdminSessionToken(
|
|
email,
|
|
secret,
|
|
Date.now() + 3600_000,
|
|
1,
|
|
"owner",
|
|
"owner-1",
|
|
);
|
|
return `datastack_admin_session=${token}`;
|
|
}
|
|
|
|
test.after(async () => {
|
|
SettingsManager.stopMaintenanceSchedulerForTests();
|
|
SDKManager.stopActivityFlushTimerForTests();
|
|
ingestionServer.stopTimers();
|
|
ingestionServer.setDbPoolForTests(null);
|
|
filesManager.clearInMemoryAdminSessionStateForTests();
|
|
await DataBufferEngine.shutdown();
|
|
clearAuditLogsForTests();
|
|
resetAdminStateForTests();
|
|
restoreEnv();
|
|
});
|
|
|
|
test("R4-Phase-01 [AUDIT-01 / ERR-R4-01]: ssrfGuard blocks loopback, RFC1918, metadata, internal hostnames, non-HTTP(S), DNS rebinding & redirects while respecting explicit opt-in", async () => {
|
|
delete process.env.DATASTACK_ALLOW_PRIVATE_URLS;
|
|
|
|
const blockedTargets = [
|
|
"http://127.0.0.1:4000/internal/settings-sync",
|
|
"http://localhost:3000/api/health",
|
|
"http://sub.localhost/hook",
|
|
"http://[::1]:4000/",
|
|
"http://[::ffff:127.0.0.1]/secret",
|
|
"http://10.0.0.5:9000/bucket",
|
|
"http://172.16.4.2/hook",
|
|
"http://192.168.1.50/hook",
|
|
"http://0.0.0.0/",
|
|
"http://ingestion:4000/internal",
|
|
"http://postgres.internal:5432/",
|
|
"http://169.254.169.254/latest/meta-data/iam/security-credentials/",
|
|
"http://metadata.google.internal/computeMetadata/v1/",
|
|
"file:///etc/passwd",
|
|
"ftp://files.example.com/archive",
|
|
"https://user:pass@hooks.example.com/hook",
|
|
];
|
|
|
|
for (const target of blockedTargets) {
|
|
const res = validateOutboundUrlSync(target, { fieldName: "Outbound URL" });
|
|
assert.equal(res.allowed, false, `Expected ${target} to be blocked`);
|
|
assert.equal(res.code, "SSRF_BLOCKED_HOST", `Expected SSRF_BLOCKED_HOST for ${target}`);
|
|
}
|
|
|
|
// Public HTTPS host passes sync + safe DNS lookup
|
|
const okPublic = await validateOutboundUrlAsync("https://hooks.example.com/v1/alert", {
|
|
fieldName: "Webhook URL",
|
|
dnsLookup: async () => [{ address: "93.184.216.34", family: 4 }],
|
|
});
|
|
assert.equal(okPublic.allowed, true);
|
|
|
|
// DNS rebinding hostname resolving to 127.0.0.1 or 169.254.169.254 is blocked
|
|
const rebindLoopback = await validateOutboundUrlAsync("https://rebind.example.com/hook", {
|
|
fieldName: "Webhook URL",
|
|
dnsLookup: async () => [{ address: "127.0.0.1", family: 4 }],
|
|
});
|
|
assert.equal(rebindLoopback.allowed, false);
|
|
assert.equal(rebindLoopback.code, "SSRF_BLOCKED_HOST");
|
|
|
|
const rebindMeta = await validateOutboundUrlAsync("https://rebind-meta.example.com/hook", {
|
|
fieldName: "Webhook URL",
|
|
dnsLookup: async () => [{ address: "169.254.169.254", family: 4 }],
|
|
});
|
|
assert.equal(rebindMeta.allowed, false);
|
|
assert.equal(rebindMeta.code, "SSRF_BLOCKED_HOST");
|
|
|
|
// Explicit opt-in allows RFC1918/loopback/single-label internal LAN hosts, YET ALWAYS blocks cloud metadata 169.254.169.254 & metadata.google.internal
|
|
assert.equal(checkIpAddressAllowed("127.0.0.1", true).allowed, true);
|
|
assert.equal(checkIpAddressAllowed("192.168.1.25", true).allowed, true);
|
|
assert.equal(checkIpAddressAllowed("169.254.169.254", true).allowed, false);
|
|
assert.equal(checkIpAddressAllowed("fe80::1", true).allowed, false);
|
|
assert.equal(
|
|
validateOutboundUrlSync("http://minio:9000", {
|
|
allowPrivate: true,
|
|
}).allowed,
|
|
true,
|
|
);
|
|
assert.equal(
|
|
validateOutboundUrlSync("http://169.254.169.254/latest/meta-data/", {
|
|
allowPrivate: true,
|
|
}).allowed,
|
|
false,
|
|
);
|
|
assert.equal(
|
|
validateOutboundUrlSync("http://metadata.google.internal/", {
|
|
allowPrivate: true,
|
|
}).allowed,
|
|
false,
|
|
);
|
|
});
|
|
|
|
test("R4-Phase-01 [AUDIT-01 / ERR-R4-01]: API routes (/api/settings, /api/settings/webhook-test, /api/storage/s3-test), Port 4000 triggerWebhookAlert & redirect:manual block SSRF", async () => {
|
|
delete process.env.DATABASE_URL;
|
|
delete process.env.DATASTACK_ALLOW_PRIVATE_URLS;
|
|
clearWebhookCooldownCacheForTests();
|
|
ingestionServer.clearWebhookCooldownCacheForTests();
|
|
|
|
const cookie = await createOwnerCookie("r4-ssrf-owner@datastack.dev");
|
|
|
|
// 1. POST /api/settings rejects private webhookUrl & private s3Endpoint with 400 SSRF_BLOCKED_HOST
|
|
const badWebhookSave = await settingsPost(
|
|
new NextRequest("http://localhost:3000/api/settings", {
|
|
method: "POST",
|
|
headers: { "content-type": "application/json", cookie },
|
|
body: JSON.stringify({ webhookUrl: "http://127.0.0.1:4000/internal/client-sync" }),
|
|
}),
|
|
);
|
|
assert.equal(badWebhookSave.status, 400);
|
|
assert.equal((await badWebhookSave.json()).code, "SSRF_BLOCKED_HOST");
|
|
|
|
const badS3Save = await settingsPost(
|
|
new NextRequest("http://localhost:3000/api/settings", {
|
|
method: "POST",
|
|
headers: { "content-type": "application/json", cookie },
|
|
body: JSON.stringify({ s3Endpoint: "http://169.254.169.254/latest/meta-data" }),
|
|
}),
|
|
);
|
|
assert.equal(badS3Save.status, 400);
|
|
assert.equal((await badS3Save.json()).code, "SSRF_BLOCKED_HOST");
|
|
|
|
// 2. POST /api/settings/webhook-test rejects loopback/metadata with 400 SSRF_BLOCKED_HOST
|
|
const badWebhookTest = await webhookTestPost(
|
|
new NextRequest("http://localhost:3000/api/settings/webhook-test", {
|
|
method: "POST",
|
|
headers: { "content-type": "application/json", cookie },
|
|
body: JSON.stringify({ webhookUrl: "http://localhost:4000/health" }),
|
|
}),
|
|
);
|
|
assert.equal(badWebhookTest.status, 400);
|
|
assert.equal((await badWebhookTest.json()).code, "SSRF_BLOCKED_HOST");
|
|
|
|
// 3. POST /api/storage/s3-test rejects internal/RFC1918 host with 400 SSRF_BLOCKED_HOST
|
|
const badS3Test = await s3TestPost(
|
|
new NextRequest("http://localhost:3000/api/storage/s3-test", {
|
|
method: "POST",
|
|
headers: { "content-type": "application/json", cookie },
|
|
body: JSON.stringify({
|
|
s3Endpoint: "http://10.0.0.12:9000",
|
|
s3Bucket: "test-bucket",
|
|
s3AccessKeyId: "AKIA_TEST",
|
|
s3SecretAccessKey: "secret_key_test",
|
|
}),
|
|
}),
|
|
);
|
|
assert.equal(badS3Test.status, 400);
|
|
assert.equal((await badS3Test.json()).code, "SSRF_BLOCKED_HOST");
|
|
|
|
// 4. Port 4000 triggerWebhookAlert & validateOutboundWebhookUrlAsync block loopback & metadata
|
|
const p4Blocked = await ingestionServer.triggerWebhookAlert(
|
|
{
|
|
event: "CLIENT_IP_FORBIDDEN",
|
|
severity: "warning",
|
|
title: "Probe",
|
|
message: "Test",
|
|
},
|
|
{
|
|
enableWebhookAlerts: true,
|
|
webhookUrl: "http://127.0.0.1:4000/internal/client-sync",
|
|
bypassCooldown: true,
|
|
},
|
|
);
|
|
assert.equal(p4Blocked.dispatched, false);
|
|
assert.equal(p4Blocked.code, "SSRF_BLOCKED_HOST");
|
|
|
|
// 5. redirect: 'manual' blocks HTTP 302 redirects across webhookNotifier, S3, and Port 4000
|
|
let targetHitAfterRedirect = false;
|
|
const redirectServer = http.createServer((req, res) => {
|
|
if (req.url && req.url.startsWith("/bounce")) {
|
|
res.writeHead(302, { Location: "http://169.254.169.254/latest/meta-data/" });
|
|
res.end();
|
|
return;
|
|
}
|
|
targetHitAfterRedirect = true;
|
|
res.writeHead(200);
|
|
res.end("ok");
|
|
});
|
|
await new Promise<void>((resolve) => redirectServer.listen(0, "127.0.0.1", resolve));
|
|
const addr = redirectServer.address() as AddressInfo;
|
|
const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "datastack-r4-ssrf-redir-"));
|
|
const gzPath = path.join(tmpDir, "2026-11-20.csv.gz");
|
|
await fs.writeFile(gzPath, zlib.gzipSync(Buffer.from("clientId,eventId,timestamp,payload\n")));
|
|
|
|
try {
|
|
process.env.DATASTACK_ALLOW_PRIVATE_URLS = "true";
|
|
|
|
const whRedirect = await dispatchWebhookAlertAsync(
|
|
{
|
|
event: "TEST_ALERT",
|
|
severity: "info",
|
|
title: "Redirect check",
|
|
message: "Must not follow 302",
|
|
},
|
|
{
|
|
enabled: true,
|
|
webhookUrl: `http://127.0.0.1:${addr.port}/bounce`,
|
|
webhookSecret: "",
|
|
cooldownSec: 0,
|
|
},
|
|
{ bypassCooldown: true },
|
|
);
|
|
assert.equal(whRedirect.ok, false);
|
|
assert.equal(whRedirect.code, "SSRF_BLOCKED_HOST");
|
|
|
|
const s3ProbeRedir = await testS3Connection({
|
|
endpoint: `http://127.0.0.1:${addr.port}/bounce`,
|
|
region: "auto",
|
|
bucket: "bkt",
|
|
prefix: "",
|
|
accessKeyId: "AKIA",
|
|
secretAccessKey: "SEC",
|
|
});
|
|
assert.equal(s3ProbeRedir.ok, false);
|
|
assert.equal(s3ProbeRedir.code, "SSRF_BLOCKED_HOST");
|
|
|
|
const s3PutRedir = await uploadFileToS3(
|
|
{
|
|
endpoint: `http://127.0.0.1:${addr.port}/bounce`,
|
|
region: "auto",
|
|
bucket: "bkt",
|
|
prefix: "",
|
|
accessKeyId: "AKIA",
|
|
secretAccessKey: "SEC",
|
|
},
|
|
gzPath,
|
|
"c/2026-11-20.csv.gz",
|
|
);
|
|
assert.equal(s3PutRedir.ok, false);
|
|
assert.equal(s3PutRedir.code, "SSRF_BLOCKED_HOST");
|
|
|
|
const p4Redirect = await ingestionServer.triggerWebhookAlert(
|
|
{
|
|
event: "DISK_SPACE_LOW",
|
|
severity: "warning",
|
|
title: "Redirect check",
|
|
message: "Must not follow 302",
|
|
},
|
|
{
|
|
enableWebhookAlerts: true,
|
|
webhookUrl: `http://127.0.0.1:${addr.port}/bounce`,
|
|
allowPrivate: true,
|
|
bypassCooldown: true,
|
|
},
|
|
);
|
|
assert.equal(p4Redirect.dispatched, false);
|
|
assert.equal(p4Redirect.code, "SSRF_BLOCKED_HOST");
|
|
assert.equal(targetHitAfterRedirect, false);
|
|
} finally {
|
|
delete process.env.DATASTACK_ALLOW_PRIVATE_URLS;
|
|
await new Promise<void>((resolve) => redirectServer.close(() => resolve()));
|
|
await fs.rm(tmpDir, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test("R4-Phase-01 [AUDIT-03 / ERR-R4-02]: Port 4000 ensureDatabaseSchema creates all 7 tables including admin_team_members and admin_audit_logs", async () => {
|
|
const executedSql: string[] = [];
|
|
const mockPool = {
|
|
async query(sql: string) {
|
|
executedSql.push(sql);
|
|
if (sql.includes("FROM admin_settings")) {
|
|
return { rowCount: 0, rows: [] };
|
|
}
|
|
return { rowCount: 0, rows: [] };
|
|
},
|
|
};
|
|
|
|
try {
|
|
ingestionServer.setDbPoolForTests(mockPool);
|
|
const synced = await ingestionServer.syncSettingsFromDatabase();
|
|
assert.equal(synced, true);
|
|
|
|
const createStatements = executedSql.filter((s) => /CREATE TABLE IF NOT EXISTS/i.test(s));
|
|
assert.equal(createStatements.length, 7, "Port 4000 must create all 7 tables");
|
|
const joined = createStatements.join("\n");
|
|
for (const tableName of [
|
|
"client_sdks",
|
|
"admin_settings",
|
|
"deleted_clients",
|
|
"admin_users",
|
|
"admin_login_attempts",
|
|
"admin_team_members",
|
|
"admin_audit_logs",
|
|
]) {
|
|
assert.ok(
|
|
joined.includes(tableName),
|
|
`Port 4000 schema missing table ${tableName}`,
|
|
);
|
|
}
|
|
} finally {
|
|
ingestionServer.setDbPoolForTests(null);
|
|
}
|
|
});
|
|
|
|
test("R4-Phase-01 [AUDIT-04 / ERR-R4-03]: Next.js instrumentation.register() boots maintenance scheduler unattended on nodejs runtime and survives unreachable DB", async () => {
|
|
delete process.env.DATABASE_URL;
|
|
const prevDisable = process.env.DATASTACK_DISABLE_LISTEN;
|
|
const prevRuntime = process.env.NEXT_RUNTIME;
|
|
SettingsManager.stopMaintenanceSchedulerForTests();
|
|
|
|
try {
|
|
// 1. Edge runtime does NOT start Node maintenance scheduler
|
|
process.env.NEXT_RUNTIME = "edge";
|
|
delete process.env.DATASTACK_DISABLE_LISTEN;
|
|
await instrumentationHook.register();
|
|
assert.equal(SettingsManager.isMaintenanceSchedulerActive(), false);
|
|
|
|
// 2. Node.js runtime starts maintenance scheduler automatically on boot
|
|
process.env.NEXT_RUNTIME = "nodejs";
|
|
await instrumentationHook.register();
|
|
assert.equal(SettingsManager.isMaintenanceSchedulerActive(), true);
|
|
|
|
// 3. Even if DB fails during boot hydration, bootstrapMaintenanceSchedulerOnBoot catches error cleanly without crashing
|
|
SettingsManager.stopMaintenanceSchedulerForTests();
|
|
process.env.DATABASE_URL = "postgresql://user:pass@127.0.0.1:1/unreachable";
|
|
const bootRes = await SettingsManager.bootstrapMaintenanceSchedulerOnBoot();
|
|
assert.equal(bootRes.schedulerActive, true);
|
|
assert.equal(bootRes.hydrated, false);
|
|
} finally {
|
|
SettingsManager.stopMaintenanceSchedulerForTests();
|
|
delete process.env.DATABASE_URL;
|
|
if (prevDisable === undefined) delete process.env.DATASTACK_DISABLE_LISTEN;
|
|
else process.env.DATASTACK_DISABLE_LISTEN = prevDisable;
|
|
if (prevRuntime === undefined) delete process.env.NEXT_RUNTIME;
|
|
else process.env.NEXT_RUNTIME = prevRuntime;
|
|
}
|
|
});
|
|
|
|
test("R4-Phase-01 [AUDIT-09 / ERR-R4-04 & ERR-R4-05]: Fail-loud audit DB degraded warnings + no-DB Files Manager session revocation sync", async () => {
|
|
delete process.env.DATABASE_URL;
|
|
clearAuditLogsForTests();
|
|
filesManager.clearInMemoryAdminSessionStateForTests();
|
|
|
|
const cookie = await createOwnerCookie("r4-audit-owner@datastack.dev");
|
|
const globals = globalThis as typeof globalThis & {
|
|
__dataStackCorePool?: unknown;
|
|
};
|
|
const prevPool = globals.__dataStackCorePool;
|
|
|
|
// 1. Simulate PostgreSQL failure on audit write + read -> must log console.warn and expose degraded metadata & header
|
|
const failingPool = {
|
|
async query(sql: string) {
|
|
if (/CREATE TABLE|ALTER TABLE/i.test(sql)) {
|
|
return { rowCount: 0, rows: [] };
|
|
}
|
|
if (sql.includes("FROM admin_users")) {
|
|
return {
|
|
rowCount: 1,
|
|
rows: [
|
|
{
|
|
email: "r4-audit-owner@datastack.dev",
|
|
created_at: new Date(),
|
|
token_version: 1,
|
|
},
|
|
],
|
|
};
|
|
}
|
|
if (sql.includes("admin_audit_logs")) {
|
|
throw new Error("simulated PG outage");
|
|
}
|
|
return { rowCount: 0, rows: [] };
|
|
},
|
|
};
|
|
|
|
try {
|
|
process.env.DATABASE_URL = "postgresql://mock:mock@127.0.0.1:5432/mock";
|
|
globals.__dataStackCorePool = failingPool;
|
|
const warnings: string[] = [];
|
|
const origWarn = console.warn;
|
|
console.warn = (...args: unknown[]) => {
|
|
warnings.push(args.map((a) => String(a)).join(" "));
|
|
};
|
|
try {
|
|
await recordAdminAuditLogAsync({
|
|
actorEmail: "r4-audit-owner@datastack.dev",
|
|
actorRole: "owner",
|
|
action: "SETTINGS_UPDATED",
|
|
target: "admin_settings",
|
|
});
|
|
const listResult = await listAdminAuditLogsWithStatusAsync({ limit: 10 });
|
|
assert.equal(listResult.storageMode, "memory");
|
|
assert.equal(listResult.degraded, true);
|
|
assert.equal(listResult.code, "AUDIT_STORAGE_DEGRADED");
|
|
assert.match(listResult.warning || "", /PostgreSQL/i);
|
|
assert.ok(
|
|
warnings.some((w) => w.includes("[DataStack Audit]")),
|
|
"Expected console.warn fail-loud audit log",
|
|
);
|
|
|
|
// Verify GET /api/audit surfaces degraded status & header
|
|
const apiRes = await auditGet(
|
|
new NextRequest("http://localhost:3000/api/audit?limit=10", {
|
|
headers: { cookie },
|
|
}),
|
|
);
|
|
assert.equal(apiRes.status, 200);
|
|
assert.equal(apiRes.headers.get("X-DataStack-Audit-Degraded"), "1");
|
|
const apiJson = await apiRes.json();
|
|
assert.equal(apiJson.degraded, true);
|
|
assert.equal(apiJson.code, "AUDIT_STORAGE_DEGRADED");
|
|
assert.equal(apiJson.storageMode, "memory");
|
|
} finally {
|
|
console.warn = origWarn;
|
|
}
|
|
} finally {
|
|
delete process.env.DATABASE_URL;
|
|
globals.__dataStackCorePool = prevPool;
|
|
}
|
|
|
|
// 2. Verify no-DB (!dbPool) Files Manager session revocation via Port 4000 /internal/admin-session-sync bridge
|
|
const testBridgeServer = http.createServer(ingestionServer.app);
|
|
await new Promise<void>((resolve) => testBridgeServer.listen(0, "127.0.0.1", resolve));
|
|
const bridgePort = (testBridgeServer.address() as AddressInfo).port;
|
|
process.env.INGESTION_INTERNAL_URL = `http://127.0.0.1:${bridgePort}`;
|
|
|
|
try {
|
|
// Reject unauthenticated POST /internal/admin-session-sync
|
|
const unauthSync = await fetch(
|
|
`http://127.0.0.1:${bridgePort}/internal/admin-session-sync`,
|
|
{
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify({ memberId: "owner-1", minTokenVersion: 99 }),
|
|
},
|
|
);
|
|
assert.equal(unauthSync.status, 401);
|
|
|
|
// Owner session v1 works before logout/revocation
|
|
const secret = getAdminSessionSecret();
|
|
const ownerTokenV1 = await createAdminSessionToken(
|
|
"r4-audit-owner@datastack.dev",
|
|
secret,
|
|
Date.now() + 3600_000,
|
|
1,
|
|
"owner",
|
|
"owner-1",
|
|
);
|
|
const beforeLogout = await filesManager.authenticateFilesRequest({
|
|
cookieHeader: `datastack_admin_session=${ownerTokenV1}`,
|
|
dbPool: null,
|
|
});
|
|
assert.equal(beforeLogout.valid, true);
|
|
|
|
// Calling revokeAdminSessions syncs minTokenVersion=2 to Port 4000 bridge -> v1 Files Manager cookie is rejected
|
|
const nextVer = await revokeAdminSessions({
|
|
memberId: "owner-1",
|
|
email: "r4-audit-owner@datastack.dev",
|
|
});
|
|
assert.ok(nextVer >= 2);
|
|
const afterLogout = await filesManager.authenticateFilesRequest({
|
|
cookieHeader: `datastack_admin_session=${ownerTokenV1}`,
|
|
dbPool: null,
|
|
});
|
|
assert.equal(afterLogout.valid, false);
|
|
assert.equal(afterLogout.status, 401);
|
|
assert.equal(afterLogout.code, "SESSION_REVOKED");
|
|
|
|
// Team member disable/delete also revokes no-DB Files Manager session immediately
|
|
const opMember = await createAdminTeamMemberAsync({
|
|
email: "r4-op@datastack.dev",
|
|
password: "OperatorPassword123!",
|
|
role: "operator",
|
|
});
|
|
const opTokenV1 = await createAdminSessionToken(
|
|
opMember.email,
|
|
secret,
|
|
Date.now() + 3600_000,
|
|
opMember.tokenVersion,
|
|
opMember.role,
|
|
opMember.id,
|
|
);
|
|
const opBefore = await filesManager.authenticateFilesRequest({
|
|
cookieHeader: `datastack_admin_session=${opTokenV1}`,
|
|
dbPool: null,
|
|
});
|
|
assert.equal(opBefore.valid, true);
|
|
|
|
await updateAdminTeamMemberAsync(opMember.id, { status: "disabled" });
|
|
const opAfterDisable = await filesManager.authenticateFilesRequest({
|
|
cookieHeader: `datastack_admin_session=${opTokenV1}`,
|
|
dbPool: null,
|
|
});
|
|
assert.equal(opAfterDisable.valid, false);
|
|
assert.equal(opAfterDisable.code, "SESSION_REVOKED");
|
|
|
|
await deleteAdminTeamMemberAsync(opMember.id);
|
|
|
|
// Also verify authenticated /internal/admin-session-sync endpoint returns 200 & synced=true
|
|
const authSyncRes = await fetch(
|
|
`http://127.0.0.1:${bridgePort}/internal/admin-session-sync`,
|
|
{
|
|
method: "POST",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
...getInternalIngestionHeaders(),
|
|
},
|
|
body: JSON.stringify({
|
|
memberId: "adm_manual_test",
|
|
email: "manual@datastack.dev",
|
|
minTokenVersion: 5,
|
|
disabled: true,
|
|
}),
|
|
},
|
|
);
|
|
assert.equal(authSyncRes.status, 200);
|
|
const authSyncJson = (await authSyncRes.json()) as { success: boolean; synced: boolean };
|
|
assert.equal(authSyncJson.success, true);
|
|
assert.equal(authSyncJson.synced, true);
|
|
} finally {
|
|
delete process.env.INGESTION_INTERNAL_URL;
|
|
filesManager.clearInMemoryAdminSessionStateForTests();
|
|
await new Promise<void>((resolve) => testBridgeServer.close(() => resolve()));
|
|
}
|
|
});
|