3024 lines
137 KiB
JavaScript
3024 lines
137 KiB
JavaScript
#!/usr/bin/env node
|
|
// WINDOWS #20 (260909-eor) — richtet sich eine eigene Wegwerf-Datenbank ein
|
|
// und misst dort live, ob das reparierte forTenant()-Muster (Aufgabe 1)
|
|
// tatsaechlich das tut, was es behauptet. Aufgabe 2 erweitert dieses
|
|
// Werkzeug um einen zweiten Abschnitt fuer die auth_lookup_*-Funktionen.
|
|
//
|
|
// Ruehrt die Datenbank "tessera" NICHT an (T-EOR-07): der Name der
|
|
// Wegwerf-Datenbank ist fest im Werkzeug verdrahtet, nicht ueber eine
|
|
// Umgebungsvariable steuerbar, damit ein Tippfehler nicht in der echten
|
|
// Datenbank landet. Verbindungsangaben kommen ausschliesslich ueber
|
|
// TESSERA_SCRATCH_ADMIN_URL (Verbindung zu einer Wartungsdatenbank wie
|
|
// "postgres" mit Rechten, um eine neue Datenbank/Rolle anzulegen und wieder
|
|
// abzuraeumen). Ohne diese Variable bricht das Werkzeug mit einer Anleitung
|
|
// ab, statt eine Vorgabe zu raten.
|
|
//
|
|
// Nutzt ausschliesslich @prisma/client (bereits Abhaengigkeit der API) —
|
|
// kein neues Paket. Fuer DDL (CREATE DATABASE/ROLE mit festen, im Werkzeug
|
|
// hartkodierten Namen) ist Interpolation unvermeidlich, da PostgreSQL
|
|
// Identifier nicht parametrisieren kann; es fliesst dabei nirgends
|
|
// Nutzereingabe ein.
|
|
//
|
|
// Dupliziert bewusst das forTenant()-Verbindungsmuster statt die
|
|
// TypeScript-Quelle unter apps/api/src zu importieren — dasselbe Vorgehen
|
|
// wie im bestehenden apps/api/scripts/rls-preflight.mjs, weil ein reines
|
|
// Node-Skript ohne Build-Schritt kein .ts importieren kann.
|
|
//
|
|
// Meldet je Pruefung eine Zeile und beendet sich mit Rueckgabewert 1, sobald
|
|
// eine Pruefung scheitert. Gibt kein Kennwort und keine vollstaendige
|
|
// Verbindungszeichenkette aus.
|
|
|
|
import { PrismaClient } from '@prisma/client';
|
|
import { execFileSync } from 'node:child_process';
|
|
import { mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
|
|
import { tmpdir } from 'node:os';
|
|
import { dirname, join } from 'node:path';
|
|
import { fileURLToPath } from 'node:url';
|
|
|
|
const __dirname = dirname(fileURLToPath(import.meta.url));
|
|
const ADMIN_ENV_VAR = 'TESSERA_SCRATCH_ADMIN_URL';
|
|
const SCRATCH_DB_NAME = 'tessera_rls_scratch';
|
|
const SCRATCH_ROLE_NAME = 'tessera_rls_scratch_role';
|
|
const SCRATCH_ROLE_PASSWORD = 'scratch_only_local_never_reused';
|
|
const MIGRATIONS_DIR = join(__dirname, '../prisma/migrations');
|
|
const PRISMA_BIN = join(__dirname, '../node_modules/.bin/prisma');
|
|
|
|
/**
|
|
* Fuehrt ein mehrteiliges SQL-Skript (mehrere Anweisungen, DO $$ ... $$
|
|
* -Bloecke) als EIN Kommando aus. `prisma.$executeRawUnsafe` nutzt das
|
|
* erweiterte Protokoll und erlaubt pro Aufruf nur eine einzelne Anweisung —
|
|
* `prisma db execute --file` sendet das gesamte Skript dagegen als ein
|
|
* Kommando (einfaches Protokoll) und ist genau dafuer vorgesehen, ganze
|
|
* Migrationsdateien auszufuehren.
|
|
*/
|
|
function executeSqlScript(databaseUrl, sql) {
|
|
const dir = mkdtempSync(join(tmpdir(), 'rls-scratch-check-'));
|
|
const file = join(dir, 'script.sql');
|
|
writeFileSync(file, sql, 'utf-8');
|
|
try {
|
|
execFileSync(PRISMA_BIN, ['db', 'execute', '--file', file, '--url', databaseUrl], {
|
|
stdio: 'pipe',
|
|
});
|
|
} finally {
|
|
rmSync(dir, { recursive: true, force: true });
|
|
}
|
|
}
|
|
|
|
function fail(message) {
|
|
console.error(`FEHLER: ${message}`);
|
|
process.exit(1);
|
|
}
|
|
|
|
function parseAdminUrl() {
|
|
const raw = process.env[ADMIN_ENV_VAR];
|
|
if (!raw) {
|
|
fail(
|
|
`${ADMIN_ENV_VAR} ist nicht gesetzt. Beispiel: ` +
|
|
`${ADMIN_ENV_VAR}="postgresql://tessera:tessera_dev@172.19.0.2:5432/postgres" ` +
|
|
`node apps/api/scripts/rls-scratch-check.mjs`,
|
|
);
|
|
}
|
|
return raw;
|
|
}
|
|
|
|
function urlForDatabase(adminUrl, dbName) {
|
|
const url = new URL(adminUrl);
|
|
url.pathname = `/${dbName}`;
|
|
return url;
|
|
}
|
|
|
|
async function withAdminPrisma(adminUrl, fn) {
|
|
const prisma = new PrismaClient({ datasourceUrl: adminUrl });
|
|
try {
|
|
return await fn(prisma);
|
|
} finally {
|
|
await prisma.$disconnect();
|
|
}
|
|
}
|
|
|
|
async function setupScratchDatabase(adminUrl) {
|
|
await withAdminPrisma(adminUrl, async (admin) => {
|
|
await admin.$executeRawUnsafe(
|
|
`SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = '${SCRATCH_DB_NAME}' AND pid <> pg_backend_pid()`,
|
|
);
|
|
await admin.$executeRawUnsafe(`DROP DATABASE IF EXISTS ${SCRATCH_DB_NAME}`);
|
|
await admin.$executeRawUnsafe(`DROP ROLE IF EXISTS ${SCRATCH_ROLE_NAME}`);
|
|
await admin.$executeRawUnsafe(`CREATE DATABASE ${SCRATCH_DB_NAME}`);
|
|
await admin.$executeRawUnsafe(
|
|
`CREATE ROLE ${SCRATCH_ROLE_NAME} WITH LOGIN NOSUPERUSER NOBYPASSRLS NOCREATEDB NOCREATEROLE PASSWORD '${SCRATCH_ROLE_PASSWORD}'`,
|
|
);
|
|
});
|
|
|
|
const scratchAdminUrl = urlForDatabase(adminUrl, SCRATCH_DB_NAME).toString();
|
|
await withAdminPrisma(scratchAdminUrl, async (db) => {
|
|
await db.$executeRawUnsafe(`
|
|
CREATE TABLE probe (
|
|
id serial PRIMARY KEY,
|
|
"tenantId" text NOT NULL,
|
|
label text NOT NULL
|
|
);
|
|
`);
|
|
await db.$executeRawUnsafe(`
|
|
CREATE OR REPLACE FUNCTION current_tenant_id() RETURNS TEXT AS $$
|
|
SELECT current_setting('app.current_tenant', true);
|
|
$$ LANGUAGE sql STABLE;
|
|
`);
|
|
await db.$executeRawUnsafe(`ALTER TABLE probe ENABLE ROW LEVEL SECURITY;`);
|
|
await db.$executeRawUnsafe(`ALTER TABLE probe FORCE ROW LEVEL SECURITY;`);
|
|
await db.$executeRawUnsafe(`
|
|
CREATE POLICY tenant_isolation_policy ON probe
|
|
USING ("tenantId" = current_tenant_id());
|
|
`);
|
|
await db.$executeRawUnsafe(`GRANT USAGE ON SCHEMA public TO ${SCRATCH_ROLE_NAME}`);
|
|
await db.$executeRawUnsafe(
|
|
`GRANT SELECT, INSERT, UPDATE, DELETE ON probe TO ${SCRATCH_ROLE_NAME}`,
|
|
);
|
|
await db.$executeRawUnsafe(
|
|
`GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA public TO ${SCRATCH_ROLE_NAME}`,
|
|
);
|
|
await db.$executeRawUnsafe(
|
|
`GRANT EXECUTE ON FUNCTION current_tenant_id() TO ${SCRATCH_ROLE_NAME}`,
|
|
);
|
|
await db.$executeRawUnsafe(
|
|
`INSERT INTO probe ("tenantId", label) VALUES ('TENANT-A', 'a-row'), ('TENANT-B', 'b-row')`,
|
|
);
|
|
});
|
|
}
|
|
|
|
async function teardownScratchDatabase(adminUrl) {
|
|
await withAdminPrisma(adminUrl, async (admin) => {
|
|
await admin.$executeRawUnsafe(
|
|
`SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = '${SCRATCH_DB_NAME}' AND pid <> pg_backend_pid()`,
|
|
);
|
|
await admin.$executeRawUnsafe(`DROP DATABASE IF EXISTS ${SCRATCH_DB_NAME}`);
|
|
await admin.$executeRawUnsafe(`DROP ROLE IF EXISTS ${SCRATCH_ROLE_NAME}`);
|
|
});
|
|
}
|
|
|
|
function report(results, kennung, passed, detail) {
|
|
const status = passed ? 'bestanden' : 'FEHLGESCHLAGEN';
|
|
console.log(`${kennung}: ${status} — ${detail}`);
|
|
results.push({ kennung, passed, detail });
|
|
}
|
|
|
|
/**
|
|
* Repliziert exakt das reparierte forTenant()-Muster aus
|
|
* apps/api/src/prisma/prisma-tenant.extension.ts: set_config und die
|
|
* eigentliche Abfrage als Array-Form von $transaction, also auf einer
|
|
* gemeinsamen Verbindung.
|
|
*/
|
|
async function forTenantQuery(prisma, tenantId, queryFn) {
|
|
const setTenantContext = prisma.$executeRaw`SELECT set_config('app.current_tenant', ${tenantId}, true)`;
|
|
const [, result] = await prisma.$transaction([setTenantContext, queryFn(prisma)]);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Aufgabe 1 — misst die fuenf im Plan genannten Verhaltensweisen von
|
|
* forTenant() unter der Rolle ohne BYPASSRLS.
|
|
*/
|
|
async function runForTenantChecks(scratchRoleUrl, results) {
|
|
const prisma = new PrismaClient({ datasourceUrl: scratchRoleUrl });
|
|
|
|
try {
|
|
// 1+2: gleiche Verbindung UND gesetzter Kontext — als zwei Teilmessungen
|
|
// einer einzigen Array-Transaktion, im selben Format wie die urspruengliche
|
|
// Fehlerreproduktion (Backend-PID beim set_config-Schritt vs. Backend-PID
|
|
// bei der eigentlichen Abfrage; siehe Kopfkommentar von
|
|
// prisma-tenant.extension.ts: "inside tx"/"actual qry").
|
|
const [setStepRow, queryStepRow] = await prisma.$transaction([
|
|
prisma.$queryRaw`SELECT pg_backend_pid() AS pid, set_config('app.current_tenant', 'TENANT-A', true) AS applied`,
|
|
prisma.$queryRaw`SELECT pg_backend_pid() AS pid, current_tenant_id() AS t`,
|
|
]).then(([setRows, queryRows]) => [setRows[0], queryRows[0]]);
|
|
|
|
report(
|
|
results,
|
|
'gleiche-backend-verbindung',
|
|
setStepRow.pid === queryStepRow.pid,
|
|
`set_config-Schritt pg_backend_pid()=${setStepRow.pid}, Abfrage-Schritt pg_backend_pid()=${queryStepRow.pid}`,
|
|
);
|
|
report(
|
|
results,
|
|
'mandantenkontext-waehrend-abfrage-gesetzt',
|
|
queryStepRow.t === 'TENANT-A',
|
|
`current_tenant_id() waehrend der eigentlichen Abfrage=${JSON.stringify(queryStepRow.t)}`,
|
|
);
|
|
|
|
// 3+4: forTenant(A) liefert ausschliesslich Zeilen von A, keine von B.
|
|
const rowsForA = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
|
|
tx.$queryRaw`SELECT "tenantId" FROM probe ORDER BY id`,
|
|
);
|
|
const onlyA = rowsForA.length > 0 && rowsForA.every((r) => r.tenantId === 'TENANT-A');
|
|
report(
|
|
results,
|
|
'nur-eigene-mandanten-zeilen',
|
|
onlyA,
|
|
`forTenant(TENANT-A) liefert ${rowsForA.length} Zeile(n): ${JSON.stringify(rowsForA.map((r) => r.tenantId))}`,
|
|
);
|
|
|
|
const leaksB = rowsForA.some((r) => r.tenantId === 'TENANT-B');
|
|
report(
|
|
results,
|
|
'keine-fremdmandanten-zeilen',
|
|
!leaksB,
|
|
leaksB ? 'Zeile von TENANT-B sichtbar unter forTenant(TENANT-A)' : 'keine Zeile von TENANT-B sichtbar',
|
|
);
|
|
|
|
// 5: ungebundener Zugriff derselben Rolle liefert null Zeilen.
|
|
const unbound = await prisma.$queryRaw`SELECT "tenantId" FROM probe`;
|
|
report(
|
|
results,
|
|
'ungebunden-liefert-null-zeilen',
|
|
unbound.length === 0,
|
|
`ungebundener SELECT liefert ${unbound.length} Zeile(n)`,
|
|
);
|
|
} finally {
|
|
await prisma.$disconnect();
|
|
}
|
|
}
|
|
|
|
function readAuthLookupMigrationSql() {
|
|
const dirs = readdirSync(MIGRATIONS_DIR, { withFileTypes: true })
|
|
.filter((entry) => entry.isDirectory() && entry.name.endsWith('_auth_lookup_functions'))
|
|
.map((entry) => entry.name);
|
|
if (dirs.length !== 1) return null;
|
|
return readFileSync(join(MIGRATIONS_DIR, dirs[0], 'migration.sql'), 'utf-8');
|
|
}
|
|
|
|
/**
|
|
* Aufgabe 2 — spielt die auth_lookup_*-Migration in die Wegwerf-Datenbank
|
|
* ein (mit tessera_app durch die Wegwerf-Rolle ersetzt), legt zwei Benutzer
|
|
* in zwei Mandanten an und misst unter der Rolle ohne BYPASSRLS:
|
|
* Funktionsaufruf findet den Benutzer, gewoehnlicher SELECT auf "User"
|
|
* liefert null Zeilen, Suche nach unbekanntem Namen liefert nichts.
|
|
*/
|
|
async function runAuthLookupChecks(adminUrl, scratchRoleUrl, results) {
|
|
const migrationSql = readAuthLookupMigrationSql();
|
|
if (!migrationSql) {
|
|
report(
|
|
results,
|
|
'auth-lookup-migration-vorhanden',
|
|
false,
|
|
'Migrationsverzeichnis *_auth_lookup_functions nicht gefunden',
|
|
);
|
|
return;
|
|
}
|
|
|
|
await withAdminPrisma(urlForDatabase(adminUrl, SCRATCH_DB_NAME).toString(), async (db) => {
|
|
await db.$executeRawUnsafe(`
|
|
CREATE TABLE "User" (
|
|
id text PRIMARY KEY,
|
|
username text UNIQUE NOT NULL,
|
|
email text UNIQUE,
|
|
"tenantId" text NOT NULL,
|
|
"passwordHash" text,
|
|
"ldapDn" text,
|
|
"isActive" boolean NOT NULL DEFAULT true,
|
|
role text NOT NULL DEFAULT 'USER',
|
|
"displayName" text,
|
|
"mustChangePassword" boolean NOT NULL DEFAULT false
|
|
);
|
|
`);
|
|
await db.$executeRawUnsafe(`ALTER TABLE "User" ENABLE ROW LEVEL SECURITY;`);
|
|
await db.$executeRawUnsafe(`ALTER TABLE "User" FORCE ROW LEVEL SECURITY;`);
|
|
await db.$executeRawUnsafe(
|
|
`CREATE POLICY tenant_isolation_policy ON "User" USING ("tenantId" = current_tenant_id());`,
|
|
);
|
|
await db.$executeRawUnsafe(`GRANT SELECT, INSERT, UPDATE, DELETE ON "User" TO ${SCRATCH_ROLE_NAME}`);
|
|
await db.$executeRawUnsafe(`
|
|
INSERT INTO "User" (id, username, "tenantId", "passwordHash", "isActive")
|
|
VALUES ('user-a', 'alice', 'TENANT-A', 'hash-a', true),
|
|
('user-b', 'bob', 'TENANT-B', 'hash-b', true);
|
|
`);
|
|
|
|
// Migration nutzt echte Postgres-ENUM-Werte fuer "role" (Typ "Role") —
|
|
// die Wegwerf-Tabelle oben verwendet stattdessen text, das ist fuer die
|
|
// hier gemessenen drei Verhaltensweisen ausreichend. Die Funktion
|
|
// auth_lookup_user_by_username referenziert den Spaltentyp nicht direkt
|
|
// (SELECT u.role liefert einfach den gespeicherten Wert), daher
|
|
// funktioniert das ohne den ENUM-Typ anzulegen — mit einer Ausnahme:
|
|
// die RETURNS TABLE-Deklaration der echten Migration nennt den Typ
|
|
// "Role" explizit. Fuer die Wegwerf-Pruefung wird er hier nachgebildet.
|
|
await db.$executeRawUnsafe(`
|
|
DO $$ BEGIN
|
|
CREATE TYPE "Role" AS ENUM ('USER', 'ADMIN', 'SUPER_ADMIN');
|
|
EXCEPTION WHEN duplicate_object THEN NULL;
|
|
END $$;
|
|
`);
|
|
await db.$executeRawUnsafe(`ALTER TABLE "User" ALTER COLUMN role DROP DEFAULT;`);
|
|
await db.$executeRawUnsafe(`ALTER TABLE "User" ALTER COLUMN role TYPE "Role" USING role::"Role";`);
|
|
await db.$executeRawUnsafe(`ALTER TABLE "User" ALTER COLUMN role SET DEFAULT 'USER'::"Role";`);
|
|
|
|
await db.$executeRawUnsafe(`
|
|
CREATE TABLE "PasswordResetToken" (
|
|
id text PRIMARY KEY,
|
|
token text UNIQUE NOT NULL,
|
|
"userId" text NOT NULL REFERENCES "User"(id),
|
|
"expiresAt" timestamp(3) NOT NULL,
|
|
"usedAt" timestamp(3)
|
|
);
|
|
`);
|
|
|
|
// Die echte Migration erteilt das Ausfuehrungsrecht ausschliesslich an
|
|
// tessera_app — fuer die Wegwerf-Pruefung an die Scratch-Rolle
|
|
// umgeleitet, ohne den Rest der Migration zu veraendern. Ueber
|
|
// executeSqlScript (prisma db execute --file), weil die Migration
|
|
// mehrere Anweisungen inklusive DO $$ ... $$-Bloecke enthaelt, die sich
|
|
// nicht als einzelnes $executeRawUnsafe senden lassen.
|
|
});
|
|
|
|
const adaptedSql = migrationSql.replaceAll('tessera_app', SCRATCH_ROLE_NAME);
|
|
executeSqlScript(urlForDatabase(adminUrl, SCRATCH_DB_NAME).toString(), adaptedSql);
|
|
|
|
const prisma = new PrismaClient({ datasourceUrl: scratchRoleUrl });
|
|
try {
|
|
const found = await prisma.$queryRaw`SELECT * FROM auth_lookup_user_by_username('alice')`;
|
|
report(
|
|
results,
|
|
'anmeldesuche-findet-benutzer',
|
|
found.length === 1 && found[0].username === 'alice',
|
|
`auth_lookup_user_by_username('alice') liefert ${found.length} Zeile(n)`,
|
|
);
|
|
|
|
const notFound = await prisma.$queryRaw`SELECT * FROM auth_lookup_user_by_username('unknown-user')`;
|
|
report(
|
|
results,
|
|
'anmeldesuche-unbekannt-liefert-nichts-und-wirft-nicht',
|
|
notFound.length === 0,
|
|
`auth_lookup_user_by_username('unknown-user') liefert ${notFound.length} Zeile(n)`,
|
|
);
|
|
|
|
const rawSelect = await prisma.$queryRaw`SELECT * FROM "User"`;
|
|
report(
|
|
results,
|
|
'gewoehnlicher-select-auf-user-liefert-null-zeilen',
|
|
rawSelect.length === 0,
|
|
`SELECT * FROM "User" liefert ${rawSelect.length} Zeile(n)`,
|
|
);
|
|
} finally {
|
|
await prisma.$disconnect();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Liest die ausgelieferte RLS-Basismigration und schneidet die beiden
|
|
* `CREATE POLICY`-Anweisungen fuer "LdapConfig" und "LdapFieldMapping" bis
|
|
* zum abschliessenden Semikolon heraus (Vorbild: readAuthLookupMigrationSql).
|
|
* Der Dateiname wird ueber ein Suffix gesucht, nicht hartkodiert — aber die
|
|
* Groups-Migration endet ebenfalls auf "_rls_policies" und wird deshalb
|
|
* ausdruecklich ausgeschlossen, sonst faende der Filter zwei Verzeichnisse.
|
|
*/
|
|
function readRlsPoliciesMigrationSql() {
|
|
const dirs = readdirSync(MIGRATIONS_DIR, { withFileTypes: true })
|
|
.filter(
|
|
(entry) =>
|
|
entry.isDirectory() &&
|
|
entry.name.endsWith('_rls_policies') &&
|
|
!entry.name.endsWith('_groups_rls_policies'),
|
|
)
|
|
.map((entry) => entry.name);
|
|
if (dirs.length !== 1) return null;
|
|
return readFileSync(join(MIGRATIONS_DIR, dirs[0], 'migration.sql'), 'utf-8');
|
|
}
|
|
|
|
function extractPolicySql(migrationSql, tableName) {
|
|
const re = new RegExp(
|
|
`CREATE POLICY tenant_isolation_policy ON "${tableName}"[\\s\\S]*?;`,
|
|
);
|
|
const match = migrationSql.match(re);
|
|
return match ? match[0] : null;
|
|
}
|
|
|
|
/**
|
|
* Liest die Migration, die T-JTS-02, T-JTS-03 und WINDOWS #19 schliesst
|
|
* (Dateiname endet auf "_rls_widen_membership_grant_and_platform_read",
|
|
* 260910-jab). Die beiden abgeloesten Regeln (GroupMembership, ModuleGrant)
|
|
* MUESSEN ab hier aus dieser Datei extrahiert werden, nicht mehr aus
|
|
* `readGroupsRlsPoliciesMigrationSql()` — sonst misst dieses Werkzeug
|
|
* weiter die abgeloeste Regel (Befund D).
|
|
*/
|
|
function readRlsWidenMigrationSql() {
|
|
const dirs = readdirSync(MIGRATIONS_DIR, { withFileTypes: true })
|
|
.filter(
|
|
(entry) =>
|
|
entry.isDirectory() &&
|
|
entry.name.endsWith('_rls_widen_membership_grant_and_platform_read'),
|
|
)
|
|
.map((entry) => entry.name);
|
|
if (dirs.length !== 1) return null;
|
|
return readFileSync(join(MIGRATIONS_DIR, dirs[0], 'migration.sql'), 'utf-8');
|
|
}
|
|
|
|
/**
|
|
* Wie extractPolicySql(), aber liefert ALLE `CREATE POLICY ... ON
|
|
* "<Tabelle>"`-Anweisungen einer Tabelle statt nur der ersten (Befund D:
|
|
* extractPolicySql() hat keinen globalen Flag und kennt nur EINEN
|
|
* Policy-Namen — fuer eine Tabelle mit mehreren, nach Befehl getrennten
|
|
* Regeln unter verschiedenen Namen reicht das nicht). Policy-Name ist
|
|
* absichtlich ein Platzhalter (`\w+`), nicht `tenant_isolation_policy` —
|
|
* die vier Regeln auf "TenderRssFeedSource" heissen unterschiedlich.
|
|
*/
|
|
function extractAllPolicySql(migrationSql, tableName) {
|
|
const re = new RegExp(`CREATE POLICY \\w+ ON "${tableName}"[\\s\\S]*?;`, 'g');
|
|
return [...migrationSql.matchAll(re)].map((m) => m[0]);
|
|
}
|
|
|
|
/**
|
|
* Aufgabe 1 (260909-ipc) — misst die fuenf im Plan genannten Verhaltensweisen
|
|
* des Bereichs ldap unter der Rolle ohne BYPASSRLS, mit den beiden Policies
|
|
* WORTGLEICH aus der ausgelieferten Migration statt im Werkzeug neu getippt
|
|
* (T-IPC-08). Findet die Extraktion eine der beiden Policies nicht, meldet
|
|
* dieser Abschnitt eine FEHLGESCHLAGENE Pruefung und bricht ab, statt mit
|
|
* einer geratenen Policy weiterzumessen.
|
|
*/
|
|
async function runLdapAreaChecks(adminUrl, scratchRoleUrl, results) {
|
|
const migrationSql = readRlsPoliciesMigrationSql();
|
|
const ldapConfigPolicy = migrationSql
|
|
? extractPolicySql(migrationSql, 'LdapConfig')
|
|
: null;
|
|
const ldapFieldMappingPolicy = migrationSql
|
|
? extractPolicySql(migrationSql, 'LdapFieldMapping')
|
|
: null;
|
|
|
|
if (!ldapConfigPolicy || !ldapFieldMappingPolicy) {
|
|
report(
|
|
results,
|
|
'ldap-policies-aus-migration-gefunden',
|
|
false,
|
|
'CREATE POLICY fuer "LdapConfig" und/oder "LdapFieldMapping" nicht in der ausgelieferten *_rls_policies-Migration gefunden',
|
|
);
|
|
return;
|
|
}
|
|
|
|
await withAdminPrisma(urlForDatabase(adminUrl, SCRATCH_DB_NAME).toString(), async (db) => {
|
|
await db.$executeRawUnsafe(`
|
|
CREATE TABLE "LdapConfig" (
|
|
id text PRIMARY KEY,
|
|
"tenantId" text NOT NULL,
|
|
"serverUrl" text NOT NULL
|
|
);
|
|
`);
|
|
await db.$executeRawUnsafe(`
|
|
CREATE TABLE "LdapFieldMapping" (
|
|
id text PRIMARY KEY,
|
|
"ldapConfigId" text NOT NULL REFERENCES "LdapConfig"(id),
|
|
"ldapField" text NOT NULL,
|
|
"tesseraField" text NOT NULL
|
|
);
|
|
`);
|
|
await db.$executeRawUnsafe(`ALTER TABLE "LdapConfig" ENABLE ROW LEVEL SECURITY;`);
|
|
await db.$executeRawUnsafe(`ALTER TABLE "LdapConfig" FORCE ROW LEVEL SECURITY;`);
|
|
await db.$executeRawUnsafe(`ALTER TABLE "LdapFieldMapping" ENABLE ROW LEVEL SECURITY;`);
|
|
await db.$executeRawUnsafe(`ALTER TABLE "LdapFieldMapping" FORCE ROW LEVEL SECURITY;`);
|
|
await db.$executeRawUnsafe(ldapConfigPolicy);
|
|
await db.$executeRawUnsafe(ldapFieldMappingPolicy);
|
|
await db.$executeRawUnsafe(
|
|
`GRANT SELECT, INSERT, UPDATE, DELETE ON "LdapConfig" TO ${SCRATCH_ROLE_NAME}`,
|
|
);
|
|
await db.$executeRawUnsafe(
|
|
`GRANT SELECT, INSERT, UPDATE, DELETE ON "LdapFieldMapping" TO ${SCRATCH_ROLE_NAME}`,
|
|
);
|
|
await db.$executeRawUnsafe(`
|
|
INSERT INTO "LdapConfig" (id, "tenantId", "serverUrl") VALUES
|
|
('cfg-a', 'TENANT-A', 'ldap://a.example'),
|
|
('cfg-b', 'TENANT-B', 'ldap://b.example');
|
|
`);
|
|
await db.$executeRawUnsafe(`
|
|
INSERT INTO "LdapFieldMapping" (id, "ldapConfigId", "ldapField", "tesseraField") VALUES
|
|
('map-a', 'cfg-a', 'sAMAccountName', 'username'),
|
|
('map-b', 'cfg-b', 'sAMAccountName', 'username');
|
|
`);
|
|
});
|
|
|
|
const prisma = new PrismaClient({ datasourceUrl: scratchRoleUrl });
|
|
try {
|
|
// 1: forTenant(TENANT-A) sieht genau die LdapConfig-Zeile von A.
|
|
const configRowsForA = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
|
|
tx.$queryRaw`SELECT "tenantId" FROM "LdapConfig" ORDER BY id`,
|
|
);
|
|
report(
|
|
results,
|
|
'ldapconfig-gebunden-nur-eigene-zeile',
|
|
configRowsForA.length === 1 && configRowsForA[0].tenantId === 'TENANT-A',
|
|
`forTenant(TENANT-A) liefert ${configRowsForA.length} Zeile(n): ${JSON.stringify(configRowsForA.map((r) => r.tenantId))}`,
|
|
);
|
|
|
|
// 2: derselbe SELECT ohne Bindung liefert 0 Zeilen — die Fehlerrichtung,
|
|
// an der echten Policy gemessen statt an der Hilfstabelle "probe".
|
|
const unboundConfigRows = await prisma.$queryRaw`SELECT "tenantId" FROM "LdapConfig"`;
|
|
report(
|
|
results,
|
|
'ldapconfig-ungebunden-null-zeilen',
|
|
unboundConfigRows.length === 0,
|
|
`ungebundener SELECT auf "LdapConfig" liefert ${unboundConfigRows.length} Zeile(n)`,
|
|
);
|
|
|
|
// 3: forTenant(TENANT-A) sieht ueber den Join genau die Feldzuordnung,
|
|
// die an A's Konfiguration haengt.
|
|
const mappingRowsForA = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
|
|
tx.$queryRaw`SELECT "ldapConfigId" FROM "LdapFieldMapping" ORDER BY id`,
|
|
);
|
|
report(
|
|
results,
|
|
'fieldmapping-folgt-join-auf-ldapconfig',
|
|
mappingRowsForA.length === 1 && mappingRowsForA[0].ldapConfigId === 'cfg-a',
|
|
`forTenant(TENANT-A) liefert ${mappingRowsForA.length} Feldzuordnung(en): ${JSON.stringify(mappingRowsForA.map((r) => r.ldapConfigId))}`,
|
|
);
|
|
|
|
// 4: gebundenes INSERT mit A's eigener ldapConfigId gelingt.
|
|
let ownInsertOk = false;
|
|
let ownInsertDetail = '';
|
|
try {
|
|
await forTenantQuery(
|
|
prisma,
|
|
'TENANT-A',
|
|
(tx) =>
|
|
tx.$executeRaw`INSERT INTO "LdapFieldMapping" (id, "ldapConfigId", "ldapField", "tesseraField") VALUES ('map-a-2', 'cfg-a', 'mail', 'email')`,
|
|
);
|
|
ownInsertOk = true;
|
|
ownInsertDetail = 'INSERT mit eigener ldapConfigId erfolgreich';
|
|
} catch (err) {
|
|
ownInsertDetail = `INSERT mit eigener ldapConfigId fehlgeschlagen: ${err.message}`;
|
|
}
|
|
report(results, 'fieldmapping-schreiben-eigene-konfiguration-erlaubt', ownInsertOk, ownInsertDetail);
|
|
|
|
// 5: gebundenes INSERT unter TENANT-A mit B's ldapConfigId wird
|
|
// abgewiesen — die Abweisung IST das bestandene Ergebnis.
|
|
let foreignInsertRejected = false;
|
|
let foreignInsertDetail = '';
|
|
try {
|
|
await forTenantQuery(
|
|
prisma,
|
|
'TENANT-A',
|
|
(tx) =>
|
|
tx.$executeRaw`INSERT INTO "LdapFieldMapping" (id, "ldapConfigId", "ldapField", "tesseraField") VALUES ('map-foreign', 'cfg-b', 'mail', 'email')`,
|
|
);
|
|
foreignInsertDetail = 'INSERT mit fremder ldapConfigId ist NICHT fehlgeschlagen';
|
|
} catch (err) {
|
|
foreignInsertRejected = true;
|
|
foreignInsertDetail = `INSERT mit fremder ldapConfigId abgewiesen: ${err.message}`;
|
|
}
|
|
report(
|
|
results,
|
|
'fieldmapping-schreiben-fremde-konfiguration-abgelehnt',
|
|
foreignInsertRejected,
|
|
foreignInsertDetail,
|
|
);
|
|
} finally {
|
|
await prisma.$disconnect();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Liest die ausgelieferte Migration, die die drei Policies fuer "Group",
|
|
* "GroupMembership" und "ModuleGrant" enthaelt. Der Dateiname endet auf
|
|
* "_groups_rls_policies" — readRlsPoliciesMigrationSql() oben schliesst
|
|
* diese Migration ausdruecklich AUS, deshalb ein eigenes, unabhaengiges
|
|
* Lesehilfsmittel statt einer Aenderung am bestehenden (Aufgabe 1,
|
|
* 260909-jts-PLAN.md).
|
|
*/
|
|
function readGroupsRlsPoliciesMigrationSql() {
|
|
const dirs = readdirSync(MIGRATIONS_DIR, { withFileTypes: true })
|
|
.filter((entry) => entry.isDirectory() && entry.name.endsWith('_groups_rls_policies'))
|
|
.map((entry) => entry.name);
|
|
if (dirs.length !== 1) return null;
|
|
return readFileSync(join(MIGRATIONS_DIR, dirs[0], 'migration.sql'), 'utf-8');
|
|
}
|
|
|
|
/**
|
|
* Liest die ausgelieferte Migration, die (unter anderem) die Policy fuer
|
|
* "TenantModuleActivation" enthaelt (Dateiname endet auf
|
|
* "_rls_remaining_tenant_tables").
|
|
*/
|
|
function readRemainingTenantTablesMigrationSql() {
|
|
const dirs = readdirSync(MIGRATIONS_DIR, { withFileTypes: true })
|
|
.filter((entry) => entry.isDirectory() && entry.name.endsWith('_rls_remaining_tenant_tables'))
|
|
.map((entry) => entry.name);
|
|
if (dirs.length !== 1) return null;
|
|
return readFileSync(join(MIGRATIONS_DIR, dirs[0], 'migration.sql'), 'utf-8');
|
|
}
|
|
|
|
/**
|
|
* Aufgabe 1 (260909-jts/260910-jab), TEIL 1 — misst die im Plan genannten
|
|
* Verhaltensweisen des Bereichs groups unter der Rolle ohne BYPASSRLS, mit
|
|
* den vier Policies WORTGLEICH aus den ausgelieferten Migrationen (nicht im
|
|
* Werkzeug nachgetippt, vgl. runLdapAreaChecks). Findet die Extraktion eine
|
|
* der vier nicht, meldet dieser Abschnitt eine FEHLGESCHLAGENE Pruefung und
|
|
* bricht ab, statt mit einer geratenen Policy weiterzumessen.
|
|
*
|
|
* GroupMembership und ModuleGrant werden seit 260910-jab (T-JTS-02,
|
|
* T-JTS-03) aus `readRlsWidenMigrationSql()` gelesen, NICHT mehr aus
|
|
* `readGroupsRlsPoliciesMigrationSql()` — jene Datei traegt noch die
|
|
* abgeloeste, kuerzer greifende Fassung (Befund D). "Group" bleibt
|
|
* unveraendert und wird weiterhin aus der urspruenglichen Datei gelesen.
|
|
*
|
|
* Legt die Tabelle "Group" (samt je einer Zeile fuer TENANT-A und
|
|
* TENANT-B) an, auf der runTransactionShapeMeasurement() weiter unten
|
|
* aufsetzt — diese Funktion muss deshalb VOR jener aufgerufen werden. Setzt
|
|
* ausserdem auf der Tabelle "User" auf, die runAuthLookupChecks() vorher
|
|
* bereits angelegt hat (Zeilen user-a/TENANT-A, user-b/TENANT-B) — die neue
|
|
* GroupMembership/ModuleGrant-Regel prueft ueber diese Tabelle.
|
|
*/
|
|
async function runGroupsAreaChecks(adminUrl, scratchRoleUrl, results) {
|
|
const groupsMigrationSql = readGroupsRlsPoliciesMigrationSql();
|
|
const remainingMigrationSql = readRemainingTenantTablesMigrationSql();
|
|
const widenMigrationSql = readRlsWidenMigrationSql();
|
|
|
|
const groupPolicy = groupsMigrationSql ? extractPolicySql(groupsMigrationSql, 'Group') : null;
|
|
const groupMembershipPolicy = widenMigrationSql
|
|
? extractPolicySql(widenMigrationSql, 'GroupMembership')
|
|
: null;
|
|
const moduleGrantPolicy = widenMigrationSql
|
|
? extractPolicySql(widenMigrationSql, 'ModuleGrant')
|
|
: null;
|
|
const tenantModuleActivationPolicy = remainingMigrationSql
|
|
? extractPolicySql(remainingMigrationSql, 'TenantModuleActivation')
|
|
: null;
|
|
|
|
if (
|
|
!groupPolicy ||
|
|
!groupMembershipPolicy ||
|
|
!moduleGrantPolicy ||
|
|
!tenantModuleActivationPolicy
|
|
) {
|
|
report(
|
|
results,
|
|
'groups-policies-aus-migration-gefunden',
|
|
false,
|
|
'CREATE POLICY fuer "Group" (20260804130918_groups_rls_policies), "GroupMembership"/"ModuleGrant" (20260910120000_rls_widen_membership_grant_and_platform_read) und/oder "TenantModuleActivation" (20260909140000_rls_remaining_tenant_tables) nicht in den ausgelieferten Migrationen gefunden',
|
|
);
|
|
return;
|
|
}
|
|
|
|
await withAdminPrisma(urlForDatabase(adminUrl, SCRATCH_DB_NAME).toString(), async (db) => {
|
|
await db.$executeRawUnsafe(`
|
|
CREATE TABLE "Group" (
|
|
id text PRIMARY KEY,
|
|
"tenantId" text NOT NULL,
|
|
name text NOT NULL,
|
|
"isDefault" boolean NOT NULL DEFAULT false
|
|
);
|
|
`);
|
|
await db.$executeRawUnsafe(`
|
|
CREATE TABLE "GroupMembership" (
|
|
id text PRIMARY KEY,
|
|
"groupId" text NOT NULL,
|
|
"userId" text NOT NULL,
|
|
source text NOT NULL DEFAULT 'MANUAL'
|
|
);
|
|
`);
|
|
await db.$executeRawUnsafe(`
|
|
CREATE TABLE "ModuleGrant" (
|
|
id text PRIMARY KEY,
|
|
"tenantId" text NOT NULL,
|
|
"moduleId" text NOT NULL,
|
|
"groupId" text,
|
|
"userId" text
|
|
);
|
|
`);
|
|
await db.$executeRawUnsafe(`
|
|
CREATE TABLE "TenantModuleActivation" (
|
|
id text PRIMARY KEY,
|
|
"tenantId" text NOT NULL,
|
|
"moduleId" text NOT NULL,
|
|
"isActive" boolean NOT NULL DEFAULT true
|
|
);
|
|
`);
|
|
|
|
for (const table of ['Group', 'GroupMembership', 'ModuleGrant', 'TenantModuleActivation']) {
|
|
await db.$executeRawUnsafe(`ALTER TABLE "${table}" ENABLE ROW LEVEL SECURITY;`);
|
|
await db.$executeRawUnsafe(`ALTER TABLE "${table}" FORCE ROW LEVEL SECURITY;`);
|
|
}
|
|
await db.$executeRawUnsafe(groupPolicy);
|
|
await db.$executeRawUnsafe(groupMembershipPolicy);
|
|
await db.$executeRawUnsafe(moduleGrantPolicy);
|
|
await db.$executeRawUnsafe(tenantModuleActivationPolicy);
|
|
|
|
for (const table of ['Group', 'GroupMembership', 'ModuleGrant', 'TenantModuleActivation']) {
|
|
await db.$executeRawUnsafe(
|
|
`GRANT SELECT, INSERT, UPDATE, DELETE ON "${table}" TO ${SCRATCH_ROLE_NAME}`,
|
|
);
|
|
}
|
|
|
|
await db.$executeRawUnsafe(`
|
|
INSERT INTO "Group" (id, "tenantId", name, "isDefault") VALUES
|
|
('group-a', 'TENANT-A', 'Gruppe A', true),
|
|
('group-b', 'TENANT-B', 'Gruppe B', true);
|
|
`);
|
|
await db.$executeRawUnsafe(`
|
|
INSERT INTO "GroupMembership" (id, "groupId", "userId", source) VALUES
|
|
('membership-a', 'group-a', 'user-a', 'MANUAL'),
|
|
('membership-b', 'group-b', 'user-b', 'MANUAL');
|
|
`);
|
|
await db.$executeRawUnsafe(`
|
|
INSERT INTO "ModuleGrant" (id, "tenantId", "moduleId", "groupId", "userId") VALUES
|
|
('grant-a', 'TENANT-A', 'mod-1', 'group-a', NULL),
|
|
('grant-b', 'TENANT-B', 'mod-1', 'group-b', NULL);
|
|
`);
|
|
await db.$executeRawUnsafe(`
|
|
INSERT INTO "TenantModuleActivation" (id, "tenantId", "moduleId", "isActive") VALUES
|
|
('activation-a', 'TENANT-A', 'mod-1', true),
|
|
('activation-b', 'TENANT-B', 'mod-1', true);
|
|
`);
|
|
});
|
|
|
|
const prisma = new PrismaClient({ datasourceUrl: scratchRoleUrl });
|
|
try {
|
|
// group-gebunden-nur-eigene-zeile
|
|
const groupRowsForA = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
|
|
tx.$queryRaw`SELECT "tenantId" FROM "Group" ORDER BY id`,
|
|
);
|
|
report(
|
|
results,
|
|
'group-gebunden-nur-eigene-zeile',
|
|
groupRowsForA.length === 1 && groupRowsForA[0].tenantId === 'TENANT-A',
|
|
`forTenant(TENANT-A) liefert ${groupRowsForA.length} Zeile(n): ${JSON.stringify(groupRowsForA.map((r) => r.tenantId))}`,
|
|
);
|
|
|
|
// group-ungebunden-null-zeilen — die Belegzeile, die die Kritikschrift
|
|
// traegt, am echten, ausgelieferten Policy-Text gemessen.
|
|
const unboundGroupRows = await prisma.$queryRaw`SELECT "tenantId" FROM "Group"`;
|
|
report(
|
|
results,
|
|
'group-ungebunden-null-zeilen',
|
|
unboundGroupRows.length === 0,
|
|
`ungebundener SELECT auf "Group" liefert ${unboundGroupRows.length} Zeile(n)`,
|
|
);
|
|
|
|
// groupmembership-folgt-join-auf-group
|
|
const membershipRowsForA = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
|
|
tx.$queryRaw`SELECT "groupId" FROM "GroupMembership" ORDER BY id`,
|
|
);
|
|
report(
|
|
results,
|
|
'groupmembership-folgt-join-auf-group',
|
|
membershipRowsForA.length === 1 && membershipRowsForA[0].groupId === 'group-a',
|
|
`forTenant(TENANT-A) liefert ${membershipRowsForA.length} Mitgliedschaft(en): ${JSON.stringify(membershipRowsForA.map((r) => r.groupId))}`,
|
|
);
|
|
|
|
// groupmembership-schreiben-fremde-gruppe-abgelehnt
|
|
let foreignGroupInsertRejected = false;
|
|
let foreignGroupInsertDetail = '';
|
|
try {
|
|
await forTenantQuery(
|
|
prisma,
|
|
'TENANT-A',
|
|
(tx) =>
|
|
tx.$executeRaw`INSERT INTO "GroupMembership" (id, "groupId", "userId", source) VALUES ('membership-foreign-group', 'group-b', 'user-a', 'MANUAL')`,
|
|
);
|
|
foreignGroupInsertDetail = 'INSERT mit fremder groupId ist NICHT fehlgeschlagen';
|
|
} catch (err) {
|
|
foreignGroupInsertRejected = true;
|
|
foreignGroupInsertDetail = `INSERT mit fremder groupId abgewiesen: ${err.message}`;
|
|
}
|
|
report(
|
|
results,
|
|
'groupmembership-schreiben-fremde-gruppe-abgelehnt',
|
|
foreignGroupInsertRejected,
|
|
foreignGroupInsertDetail,
|
|
);
|
|
|
|
// groupmembership-schreiben-fremder-benutzer-abgelehnt (260910-jab,
|
|
// T-JTS-02) — Umkehr der bisherigen loch-behauptenden Pruefung
|
|
// `groupmembership-schreiben-fremder-benutzer-nicht-verhindert`. Gemessen
|
|
// mit `user-b`, den es in TENANT-B TATSAECHLICH gibt (nicht mit einer
|
|
// erfundenen Kennung wie vormals `user-nicht-in-a`) — nur so misst diese
|
|
// Pruefung den Fall, den T-JTS-02 benannt hat, statt eines
|
|
// Fremdschluessel-Nichts. Die ABWEISUNG ist jetzt das bestandene
|
|
// Ergebnis: die Regel prueft seit 20260910120000_rls_widen_membership_
|
|
// grant_and_platform_read beide Seiten der Beziehung.
|
|
let foreignUserInsertRejected = false;
|
|
let foreignUserInsertDetail = '';
|
|
try {
|
|
await forTenantQuery(
|
|
prisma,
|
|
'TENANT-A',
|
|
(tx) =>
|
|
tx.$executeRaw`INSERT INTO "GroupMembership" (id, "groupId", "userId", source) VALUES ('membership-foreign-user', 'group-a', 'user-b', 'MANUAL')`,
|
|
);
|
|
foreignUserInsertDetail =
|
|
'INSERT mit A-eigener Gruppe, aber einer Benutzerkennung aus TENANT-B (user-b) ist NICHT fehlgeschlagen';
|
|
} catch (err) {
|
|
foreignUserInsertRejected = true;
|
|
foreignUserInsertDetail = `INSERT mit A-eigener Gruppe, aber fremder Benutzerkennung (user-b, TENANT-B) abgewiesen: ${err.message} — Umkehr von 'groupmembership-schreiben-fremder-benutzer-nicht-verhindert' (T-JTS-02, Befund E): die Policy auf GroupMembership prueft jetzt zusaetzlich die Benutzerseite, nicht mehr nur die Gruppenseite`;
|
|
}
|
|
report(
|
|
results,
|
|
'groupmembership-schreiben-fremder-benutzer-abgelehnt',
|
|
foreignUserInsertRejected,
|
|
foreignUserInsertDetail,
|
|
);
|
|
|
|
// groupmembership-fremder-benutzer-ueber-die-wartungsrolle-weiterhin-moeglich
|
|
// — die Gegenmessung: dasselbe Einfuegen ueber die Verwaltungsrolle mit
|
|
// Umgehungsrecht GELINGT. Damit steht fest, dass die Abweisung oben von
|
|
// der Regel kommt und nicht vom Aufbau. Praezedenzfall:
|
|
// `gruppenpfad-ueber-die-wartungsrolle-liefert-die-fremde-gruppe-mit`.
|
|
let foreignUserInsertViaAdminSucceeded = false;
|
|
let foreignUserInsertViaAdminDetail = '';
|
|
try {
|
|
await withAdminPrisma(urlForDatabase(adminUrl, SCRATCH_DB_NAME).toString(), (db) =>
|
|
db.$executeRawUnsafe(
|
|
`INSERT INTO "GroupMembership" (id, "groupId", "userId", source) VALUES ('membership-foreign-user-admin', 'group-a', 'user-b', 'MANUAL')`,
|
|
),
|
|
);
|
|
foreignUserInsertViaAdminSucceeded = true;
|
|
foreignUserInsertViaAdminDetail =
|
|
'INSERT mit A-eigener Gruppe, aber fremder Benutzerkennung (user-b, TENANT-B) ist ueber die Wartungsrolle (BYPASSRLS) weiterhin GELUNGEN — der Ausschluss aus der vorigen Pruefung kommt damit nachweislich von der Regel, nicht vom Aufbau';
|
|
} catch (err) {
|
|
foreignUserInsertViaAdminDetail = `INSERT ueber die Wartungsrolle unerwartet abgewiesen: ${err.message}`;
|
|
}
|
|
report(
|
|
results,
|
|
'groupmembership-fremder-benutzer-ueber-die-wartungsrolle-weiterhin-moeglich',
|
|
foreignUserInsertViaAdminSucceeded,
|
|
foreignUserInsertViaAdminDetail,
|
|
);
|
|
|
|
// modulegrant-gebunden-nur-eigene-zeile
|
|
const grantRowsForA = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
|
|
tx.$queryRaw`SELECT "tenantId" FROM "ModuleGrant" ORDER BY id`,
|
|
);
|
|
report(
|
|
results,
|
|
'modulegrant-gebunden-nur-eigene-zeile',
|
|
grantRowsForA.length === 1 && grantRowsForA[0].tenantId === 'TENANT-A',
|
|
`forTenant(TENANT-A) liefert ${grantRowsForA.length} Zeile(n): ${JSON.stringify(grantRowsForA.map((r) => r.tenantId))}`,
|
|
);
|
|
|
|
// modulegrant-fremde-gruppe-abgelehnt (260910-jab, T-JTS-03) — Umkehr
|
|
// der bisherigen loch-behauptenden Pruefung
|
|
// `modulegrant-fremde-gruppe-trotz-eigener-mandantenkennung-erlaubt`. Die
|
|
// ABWEISUNG ist jetzt das bestandene Ergebnis. Eigene id
|
|
// ('grant-foreign-group-rejected-attempt'), NICHT 'grant-foreign-group'
|
|
// — jene Kennung bleibt fuer die Zeile reserviert, die die Gegenmessung
|
|
// unten ueber die Wartungsrolle anlegt und auf der zwei Pruefungen des
|
|
// Bereichs `module-registry` aufsetzen (Befund C).
|
|
let foreignGroupGrantRejected = false;
|
|
let foreignGroupGrantDetail = '';
|
|
try {
|
|
await forTenantQuery(
|
|
prisma,
|
|
'TENANT-A',
|
|
(tx) =>
|
|
tx.$executeRaw`INSERT INTO "ModuleGrant" (id, "tenantId", "moduleId", "groupId", "userId") VALUES ('grant-foreign-group-rejected-attempt', 'TENANT-A', 'mod-1', 'group-b', NULL)`,
|
|
);
|
|
foreignGroupGrantDetail = 'INSERT mit korrekter eigener tenantId, aber fremder groupId ist NICHT fehlgeschlagen';
|
|
} catch (err) {
|
|
foreignGroupGrantRejected = true;
|
|
foreignGroupGrantDetail = `INSERT mit korrekter eigener tenantId, aber fremder groupId (group-b, TENANT-B) abgewiesen: ${err.message} — Umkehr von 'modulegrant-fremde-gruppe-trotz-eigener-mandantenkennung-erlaubt' (T-JTS-03, Befund F): die Policy auf ModuleGrant prueft jetzt zusaetzlich, ob die referenzierte Gruppe zum Mandanten gehoert. assertTargetBelongsToTenant in module-grants.service.ts bleibt DAVON UNABHAENGIG bestehen — dieses zweite Netz wird durch die Regelaenderung nicht ersetzt`;
|
|
}
|
|
report(
|
|
results,
|
|
'modulegrant-fremde-gruppe-abgelehnt',
|
|
foreignGroupGrantRejected,
|
|
foreignGroupGrantDetail,
|
|
);
|
|
|
|
// modulegrant-fremder-benutzer-abgelehnt — NEU, der zweite Zweig des
|
|
// Entweder-oder (D-04): eine Freigabe mit eigener Mandantenkennung und
|
|
// fremder Benutzerkennung. T-JTS-03 hat nur den Gruppenzweig gemessen;
|
|
// ohne diese Pruefung bliebe die Haelfte des Lochs offen.
|
|
let foreignUserGrantRejected = false;
|
|
let foreignUserGrantDetail = '';
|
|
try {
|
|
await forTenantQuery(
|
|
prisma,
|
|
'TENANT-A',
|
|
(tx) =>
|
|
tx.$executeRaw`INSERT INTO "ModuleGrant" (id, "tenantId", "moduleId", "groupId", "userId") VALUES ('grant-foreign-user-rejected-attempt', 'TENANT-A', 'mod-1', NULL, 'user-b')`,
|
|
);
|
|
foreignUserGrantDetail = 'INSERT mit korrekter eigener tenantId, aber fremder userId ist NICHT fehlgeschlagen';
|
|
} catch (err) {
|
|
foreignUserGrantRejected = true;
|
|
foreignUserGrantDetail = `INSERT mit korrekter eigener tenantId, aber fremder userId (user-b, TENANT-B) abgewiesen: ${err.message} — T-JTS-03 hatte nur den Gruppenzweig des Entweder-oder (D-04) gemessen; dieser Zweig ist der zweite und schliesst die andere Haelfte des Lochs`;
|
|
}
|
|
report(
|
|
results,
|
|
'modulegrant-fremder-benutzer-abgelehnt',
|
|
foreignUserGrantRejected,
|
|
foreignUserGrantDetail,
|
|
);
|
|
|
|
// modulegrant-fremde-gruppe-ueber-die-wartungsrolle-weiterhin-moeglich —
|
|
// Ersatz/Umkehr-Gegenmessung fuer die vormals loch-behauptende Pruefung.
|
|
// Legt ZUGLEICH die Zeile 'grant-foreign-group' an, die vormals als
|
|
// Nebenwirkung der loch-behauptenden Pruefung entstand und auf der die
|
|
// beiden Pruefungen des Bereichs `module-registry` aufsetzen (Befund C)
|
|
// — jetzt ueber die Wartungsrolle bereitgestellt, weil das gebundene
|
|
// INSERT oben abgewiesen wird.
|
|
let foreignGroupGrantViaAdminSucceeded = false;
|
|
let foreignGroupGrantViaAdminDetail = '';
|
|
try {
|
|
await withAdminPrisma(urlForDatabase(adminUrl, SCRATCH_DB_NAME).toString(), (db) =>
|
|
db.$executeRawUnsafe(
|
|
`INSERT INTO "ModuleGrant" (id, "tenantId", "moduleId", "groupId", "userId") VALUES ('grant-foreign-group', 'TENANT-A', 'mod-1', 'group-b', NULL)`,
|
|
),
|
|
);
|
|
foreignGroupGrantViaAdminSucceeded = true;
|
|
foreignGroupGrantViaAdminDetail =
|
|
"INSERT mit korrekter eigener tenantId, aber fremder groupId ist ueber die Wartungsrolle (BYPASSRLS) weiterhin GELUNGEN — Umkehr von 'modulegrant-fremde-gruppe-trotz-eigener-mandantenkennung-erlaubt' (T-JTS-03): die Regel weist diese Zeile unter gebundenem Kontext nachweislich ab (siehe 'modulegrant-fremde-gruppe-abgelehnt'), die Wartungsrolle umgeht RLS grundsaetzlich; legt zugleich die Zeile 'grant-foreign-group' an, auf der zwei Pruefungen des Bereichs module-registry aufsetzen (Befund C)";
|
|
} catch (err) {
|
|
foreignGroupGrantViaAdminDetail = `INSERT ueber die Wartungsrolle unerwartet abgewiesen: ${err.message}`;
|
|
}
|
|
report(
|
|
results,
|
|
'modulegrant-fremde-gruppe-ueber-die-wartungsrolle-weiterhin-moeglich',
|
|
foreignGroupGrantViaAdminSucceeded,
|
|
foreignGroupGrantViaAdminDetail,
|
|
);
|
|
|
|
// tenantmoduleactivation-gebunden-nur-eigene-zeile
|
|
const activationRowsForA = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
|
|
tx.$queryRaw`SELECT "tenantId" FROM "TenantModuleActivation" ORDER BY id`,
|
|
);
|
|
report(
|
|
results,
|
|
'tenantmoduleactivation-gebunden-nur-eigene-zeile',
|
|
activationRowsForA.length === 1 && activationRowsForA[0].tenantId === 'TENANT-A',
|
|
`forTenant(TENANT-A) liefert ${activationRowsForA.length} Zeile(n): ${JSON.stringify(activationRowsForA.map((r) => r.tenantId))}`,
|
|
);
|
|
} finally {
|
|
await prisma.$disconnect();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Aufgabe 1 (260909-laa/260910-jab) — misst die Sonderfaelle des Bereichs
|
|
* tenders unter der Rolle ohne BYPASSRLS. Vier der fuenf Policies
|
|
* (TenderEmailConfig, TenderNotificationPref, TenderSavedSearch,
|
|
* TenderTriage) kommen WORTGLEICH aus der ausgelieferten Migration
|
|
* `_rls_remaining_tenant_tables` (dieselbe Datei, die bereits die
|
|
* TenantModuleActivation-Policy fuer runGroupsAreaChecks liefert).
|
|
* TenderRssFeedSource (WINDOWS #19) kommt seit 260910-jab NICHT mehr aus
|
|
* jener Datei — die dortige Fassung ist die abgeloeste, kuerzer greifende
|
|
* Regel (Befund D) — sondern als VIER nach Befehl getrennte Policies aus
|
|
* `readRlsWidenMigrationSql()`, extrahiert mit `extractAllPolicySql()`
|
|
* (mehrere Treffer je Tabelle, Befund D). Findet die Extraktion eine der
|
|
* Policies nicht, meldet dieser Abschnitt eine FEHLGESCHLAGENE Pruefung und
|
|
* bricht ab, statt mit einer geratenen Policy weiterzumessen.
|
|
*
|
|
* Legt keine Tabelle an, auf der eine andere Pruefung dieses Werkzeugs
|
|
* aufsetzt — anders als runGroupsAreaChecks() (Vorbedingung fuer
|
|
* runTransactionShapeMeasurement()) ist dieser Abschnitt in der Aufrufkette
|
|
* ein Blatt: er muss NACH runGroupsAreaChecks() und VOR
|
|
* runTransactionShapeMeasurement() laufen, weil Letztere weiterhin auf der
|
|
* von runGroupsAreaChecks() angelegten Tabelle "Group" aufsetzt — dieser
|
|
* Abschnitt aendert daran nichts.
|
|
*/
|
|
async function runTendersAreaChecks(adminUrl, scratchRoleUrl, results) {
|
|
const remainingMigrationSql = readRemainingTenantTablesMigrationSql();
|
|
const widenMigrationSql = readRlsWidenMigrationSql();
|
|
|
|
const emailConfigPolicy = remainingMigrationSql
|
|
? extractPolicySql(remainingMigrationSql, 'TenderEmailConfig')
|
|
: null;
|
|
const notificationPrefPolicy = remainingMigrationSql
|
|
? extractPolicySql(remainingMigrationSql, 'TenderNotificationPref')
|
|
: null;
|
|
const rssFeedPolicies = widenMigrationSql
|
|
? extractAllPolicySql(widenMigrationSql, 'TenderRssFeedSource')
|
|
: [];
|
|
const savedSearchPolicy = remainingMigrationSql
|
|
? extractPolicySql(remainingMigrationSql, 'TenderSavedSearch')
|
|
: null;
|
|
const triagePolicy = remainingMigrationSql
|
|
? extractPolicySql(remainingMigrationSql, 'TenderTriage')
|
|
: null;
|
|
|
|
if (
|
|
!emailConfigPolicy ||
|
|
!notificationPrefPolicy ||
|
|
rssFeedPolicies.length !== 4 ||
|
|
!savedSearchPolicy ||
|
|
!triagePolicy
|
|
) {
|
|
report(
|
|
results,
|
|
'tenders-policies-aus-migration-gefunden',
|
|
false,
|
|
`CREATE POLICY fuer "TenderEmailConfig", "TenderNotificationPref", "TenderSavedSearch" und/oder "TenderTriage" nicht in der ausgelieferten *_rls_remaining_tenant_tables-Migration gefunden, oder nicht genau vier Policies fuer "TenderRssFeedSource" in *_rls_widen_membership_grant_and_platform_read (gefunden: ${rssFeedPolicies.length})`,
|
|
);
|
|
return;
|
|
}
|
|
|
|
await withAdminPrisma(urlForDatabase(adminUrl, SCRATCH_DB_NAME).toString(), async (db) => {
|
|
await db.$executeRawUnsafe(`
|
|
CREATE TABLE "TenderEmailConfig" (
|
|
id text PRIMARY KEY,
|
|
"userId" text NOT NULL UNIQUE,
|
|
"tenantId" text NOT NULL
|
|
);
|
|
`);
|
|
await db.$executeRawUnsafe(`
|
|
CREATE TABLE "TenderNotificationPref" (
|
|
id text PRIMARY KEY,
|
|
"userId" text NOT NULL UNIQUE,
|
|
"tenantId" text NOT NULL
|
|
);
|
|
`);
|
|
await db.$executeRawUnsafe(`
|
|
CREATE TABLE "TenderRssFeedSource" (
|
|
id text PRIMARY KEY,
|
|
url text NOT NULL,
|
|
"userId" text,
|
|
"tenantId" text,
|
|
UNIQUE ("userId", url)
|
|
);
|
|
`);
|
|
await db.$executeRawUnsafe(`
|
|
CREATE TABLE "TenderSavedSearch" (
|
|
id text PRIMARY KEY,
|
|
"userId" text NOT NULL,
|
|
"tenantId" text NOT NULL,
|
|
name text NOT NULL,
|
|
UNIQUE ("userId", name)
|
|
);
|
|
`);
|
|
await db.$executeRawUnsafe(`
|
|
CREATE TABLE "TenderTriage" (
|
|
id text PRIMARY KEY,
|
|
"userId" text NOT NULL,
|
|
"tenantId" text NOT NULL,
|
|
"tenderId" text NOT NULL,
|
|
UNIQUE ("userId", "tenderId")
|
|
);
|
|
`);
|
|
|
|
for (const table of [
|
|
'TenderEmailConfig',
|
|
'TenderNotificationPref',
|
|
'TenderRssFeedSource',
|
|
'TenderSavedSearch',
|
|
'TenderTriage',
|
|
]) {
|
|
await db.$executeRawUnsafe(`ALTER TABLE "${table}" ENABLE ROW LEVEL SECURITY;`);
|
|
await db.$executeRawUnsafe(`ALTER TABLE "${table}" FORCE ROW LEVEL SECURITY;`);
|
|
}
|
|
await db.$executeRawUnsafe(emailConfigPolicy);
|
|
await db.$executeRawUnsafe(notificationPrefPolicy);
|
|
for (const policySql of rssFeedPolicies) {
|
|
await db.$executeRawUnsafe(policySql);
|
|
}
|
|
await db.$executeRawUnsafe(savedSearchPolicy);
|
|
await db.$executeRawUnsafe(triagePolicy);
|
|
|
|
for (const table of [
|
|
'TenderEmailConfig',
|
|
'TenderNotificationPref',
|
|
'TenderRssFeedSource',
|
|
'TenderSavedSearch',
|
|
'TenderTriage',
|
|
]) {
|
|
await db.$executeRawUnsafe(
|
|
`GRANT SELECT, INSERT, UPDATE, DELETE ON "${table}" TO ${SCRATCH_ROLE_NAME}`,
|
|
);
|
|
}
|
|
|
|
await db.$executeRawUnsafe(`
|
|
INSERT INTO "TenderEmailConfig" (id, "userId", "tenantId") VALUES
|
|
('ec-a', 'user-a1', 'TENANT-A'),
|
|
('ec-b', 'user-b', 'TENANT-B');
|
|
`);
|
|
await db.$executeRawUnsafe(`
|
|
INSERT INTO "TenderNotificationPref" (id, "userId", "tenantId") VALUES
|
|
('np-a', 'user-a1', 'TENANT-A'),
|
|
('np-b', 'user-b', 'TENANT-B');
|
|
`);
|
|
await db.$executeRawUnsafe(`
|
|
INSERT INTO "TenderRssFeedSource" (id, url, "userId", "tenantId") VALUES
|
|
('rss-a', 'https://a.example-tenders.invalid/feed', 'user-a1', 'TENANT-A'),
|
|
('rss-b', 'https://b.example-tenders.invalid/feed', 'user-b', 'TENANT-B'),
|
|
('rss-platform', 'https://platform.example-tenders.invalid/feed', NULL, NULL);
|
|
`);
|
|
await db.$executeRawUnsafe(`
|
|
INSERT INTO "TenderSavedSearch" (id, "userId", "tenantId", name) VALUES
|
|
('ss-a1', 'user-a1', 'TENANT-A', 'Profil A1'),
|
|
('ss-a2', 'user-a2', 'TENANT-A', 'Profil A2'),
|
|
('ss-b', 'user-b', 'TENANT-B', 'Profil B');
|
|
`);
|
|
await db.$executeRawUnsafe(`
|
|
INSERT INTO "TenderTriage" (id, "userId", "tenantId", "tenderId") VALUES
|
|
('tr-a', 'user-a1', 'TENANT-A', 'tender-x'),
|
|
('tr-b', 'user-b', 'TENANT-B', 'tender-y'),
|
|
('tr-shared', 'user-shared', 'TENANT-B', 'tender-shared');
|
|
`);
|
|
});
|
|
|
|
const prisma = new PrismaClient({ datasourceUrl: scratchRoleUrl });
|
|
try {
|
|
// tendersavedsearch-gebunden-nur-eigener-mandant
|
|
const savedSearchRowsForA = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
|
|
tx.$queryRaw`SELECT "tenantId", "userId" FROM "TenderSavedSearch" ORDER BY id`,
|
|
);
|
|
report(
|
|
results,
|
|
'tendersavedsearch-gebunden-nur-eigener-mandant',
|
|
savedSearchRowsForA.length === 2 &&
|
|
savedSearchRowsForA.every((r) => r.tenantId === 'TENANT-A'),
|
|
`forTenant(TENANT-A) liefert ${savedSearchRowsForA.length} Zeile(n): ${JSON.stringify(savedSearchRowsForA.map((r) => r.tenantId))}`,
|
|
);
|
|
|
|
// tendersavedsearch-ungebunden-null-zeilen — die Belegzeile, die diesen
|
|
// Abschnitt der Kritikschrift traegt, am echten, ausgelieferten
|
|
// Policy-Text gemessen.
|
|
const unboundSavedSearchRows = await prisma.$queryRaw`SELECT "tenantId" FROM "TenderSavedSearch"`;
|
|
report(
|
|
results,
|
|
'tendersavedsearch-ungebunden-null-zeilen',
|
|
unboundSavedSearchRows.length === 0,
|
|
`ungebundener SELECT auf "TenderSavedSearch" liefert ${unboundSavedSearchRows.length} Zeile(n)`,
|
|
);
|
|
|
|
// tendersavedsearch-fremder-nutzer-desselben-mandanten-sichtbar (Befund
|
|
// E): das GELINGEN — beide Nutzer von TENANT-A sind sichtbar — ist das
|
|
// bestandene Ergebnis. Es belegt, dass die Policy keine
|
|
// Benutzerdimension hat; die anwendungsseitige userId-Filterung bleibt
|
|
// deshalb der einzige Schutz gegen Quer-Lesen zwischen Nutzern
|
|
// desselben Mandanten und darf bei der Umstellung nicht entfallen.
|
|
const usersVisibleForA = new Set(savedSearchRowsForA.map((r) => r.userId));
|
|
const bothUsersVisible = usersVisibleForA.has('user-a1') && usersVisibleForA.has('user-a2');
|
|
report(
|
|
results,
|
|
'tendersavedsearch-fremder-nutzer-desselben-mandanten-sichtbar',
|
|
bothUsersVisible,
|
|
bothUsersVisible
|
|
? `forTenant(TENANT-A) liefert AUCH die Zeile des zweiten Nutzers (user-a2) — die Policy auf TenderSavedSearch prueft nur die Mandantenkennung, nicht die Benutzerkennung; die anwendungsseitige userId-Filterung bleibt der einzige Schutz gegen Quer-Lesen zwischen Nutzern desselben Mandanten und darf nicht entfallen`
|
|
: `sichtbare Nutzer unter forTenant(TENANT-A): ${JSON.stringify([...usersVisibleForA])}`,
|
|
);
|
|
|
|
// tenderemailconfig-gebunden-nur-eigener-mandant
|
|
const emailConfigRowsForA = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
|
|
tx.$queryRaw`SELECT "tenantId" FROM "TenderEmailConfig" ORDER BY id`,
|
|
);
|
|
report(
|
|
results,
|
|
'tenderemailconfig-gebunden-nur-eigener-mandant',
|
|
emailConfigRowsForA.length === 1 && emailConfigRowsForA[0].tenantId === 'TENANT-A',
|
|
`forTenant(TENANT-A) liefert ${emailConfigRowsForA.length} Zeile(n): ${JSON.stringify(emailConfigRowsForA.map((r) => r.tenantId))}`,
|
|
);
|
|
|
|
// tendertriage-gebunden-nur-eigener-mandant
|
|
const triageRowsForA = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
|
|
tx.$queryRaw`SELECT "tenantId" FROM "TenderTriage" ORDER BY id`,
|
|
);
|
|
report(
|
|
results,
|
|
'tendertriage-gebunden-nur-eigener-mandant',
|
|
triageRowsForA.length === 1 && triageRowsForA[0].tenantId === 'TENANT-A',
|
|
`forTenant(TENANT-A) liefert ${triageRowsForA.length} Zeile(n): ${JSON.stringify(triageRowsForA.map((r) => r.tenantId))}`,
|
|
);
|
|
|
|
// tendernotificationpref-gebunden-nur-eigener-mandant
|
|
const notificationPrefRowsForA = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
|
|
tx.$queryRaw`SELECT "tenantId" FROM "TenderNotificationPref" ORDER BY id`,
|
|
);
|
|
report(
|
|
results,
|
|
'tendernotificationpref-gebunden-nur-eigener-mandant',
|
|
notificationPrefRowsForA.length === 1 && notificationPrefRowsForA[0].tenantId === 'TENANT-A',
|
|
`forTenant(TENANT-A) liefert ${notificationPrefRowsForA.length} Zeile(n): ${JSON.stringify(notificationPrefRowsForA.map((r) => r.tenantId))}`,
|
|
);
|
|
|
|
// tenderrssfeed-plattformzeile-gebunden-sichtbar (260910-jab, WINDOWS
|
|
// #19) — Umkehr von 'tenderrssfeed-plattformzeile-unter-jedem-
|
|
// mandanten-unsichtbar': die plattformweite Zeile (userId/tenantId
|
|
// NULL) ist jetzt unter BEIDEN Mandantenkontexten SICHTBAR, weil die
|
|
// Leseregel der neuen vier Policies (tenant_platform_read_policy,
|
|
// 20260910120000_rls_widen_membership_grant_and_platform_read) Zeilen
|
|
// ohne Mandant ausdruecklich einschliesst.
|
|
const rssRowsForA = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
|
|
tx.$queryRaw`SELECT id FROM "TenderRssFeedSource" ORDER BY id`,
|
|
);
|
|
const rssRowsForB = await forTenantQuery(prisma, 'TENANT-B', (tx) =>
|
|
tx.$queryRaw`SELECT id FROM "TenderRssFeedSource" ORDER BY id`,
|
|
);
|
|
const platformRowVisibleForA = rssRowsForA.some((r) => r.id === 'rss-platform');
|
|
const platformRowVisibleForB = rssRowsForB.some((r) => r.id === 'rss-platform');
|
|
report(
|
|
results,
|
|
'tenderrssfeed-plattformzeile-gebunden-sichtbar',
|
|
platformRowVisibleForA && platformRowVisibleForB,
|
|
`forTenant(TENANT-A) sieht die Platform-Zeile: ${platformRowVisibleForA}, forTenant(TENANT-B) sieht sie: ${platformRowVisibleForB} — Umkehr von 'tenderrssfeed-plattformzeile-unter-jedem-mandanten-unsichtbar' (WINDOWS #19): eine plattformweite RSS-Quelle ist seit 20260910120000_rls_widen_membership_grant_and_platform_read unter JEDEM Mandantenkontext sichtbar`,
|
|
);
|
|
|
|
// tenderrssfeed-eigene-zeile-gebunden-weiterhin-sichtbar — die andere
|
|
// Fehlerrichtung derselben Aenderung: der gebundene Lesezugriff liefert
|
|
// ZUSAETZLICH weiterhin die eigene Zeile des Mandanten und NICHT die des
|
|
// anderen. Ohne diese Pruefung waere eine zu weit gefasste Leseregel
|
|
// unbemerkt geblieben.
|
|
const ownRowVisibleForA = rssRowsForA.some((r) => r.id === 'rss-a');
|
|
const foreignRowVisibleForA = rssRowsForA.some((r) => r.id === 'rss-b');
|
|
report(
|
|
results,
|
|
'tenderrssfeed-eigene-zeile-gebunden-weiterhin-sichtbar',
|
|
ownRowVisibleForA && !foreignRowVisibleForA,
|
|
`forTenant(TENANT-A) liefert ${JSON.stringify(rssRowsForA.map((r) => r.id))} — eigene Zeile (rss-a) sichtbar: ${ownRowVisibleForA}, fremde Zeile (rss-b, TENANT-B) sichtbar: ${foreignRowVisibleForA}`,
|
|
);
|
|
|
|
// tenderrssfeed-ungebunden-nur-die-plattformzeile — die Belegzeile fuer
|
|
// Befund F: ohne gesetzten Mandantenkontext liefert der Lesezugriff
|
|
// jetzt genau die plattformweiten Zeilen und keine persoenliche. Das ist
|
|
// die neue Fehlerrichtung, die Aufgabe 2 traegt (listForUser wird
|
|
// gebunden); hier gemessen, nicht behauptet.
|
|
const unboundRssRows = await prisma.$queryRaw`SELECT id FROM "TenderRssFeedSource" ORDER BY id`;
|
|
const unboundOnlyPlatform =
|
|
unboundRssRows.length === 1 && unboundRssRows[0].id === 'rss-platform';
|
|
report(
|
|
results,
|
|
'tenderrssfeed-ungebunden-nur-die-plattformzeile',
|
|
unboundOnlyPlatform,
|
|
`ungebundener SELECT auf "TenderRssFeedSource" liefert ${unboundRssRows.length} Zeile(n): ${JSON.stringify(unboundRssRows.map((r) => r.id))} — Befund F: aus einer schreienden Leere (vor der Reparatur: null Zeilen) wuerde nach dem Scharfschalten eine kurze, glaubhafte Teilantwort (nur die plattformweiten Zeilen); listForUser() wird deshalb in Aufgabe 2 gebunden`,
|
|
);
|
|
|
|
// tenderrssfeed-gebundenes-einfuegen-ohne-mandant-abgelehnt: ein
|
|
// gebundenes INSERT unter TENANT-A mit tenantId=NULL wird abgewiesen —
|
|
// die Abweisung IST das bestandene Ergebnis. Folge: createPlatform darf
|
|
// nicht gebunden werden. Die Abweisung kommt jetzt von der ausdruecklichen
|
|
// WITH-CHECK-Klausel der Einfuegeregel (tenant_insert_policy), nicht mehr
|
|
// von der stillschweigenden Zweitverwendung eines einzigen USING-
|
|
// Ausdrucks.
|
|
let platformInsertRejected = false;
|
|
let platformInsertDetail = '';
|
|
try {
|
|
await forTenantQuery(
|
|
prisma,
|
|
'TENANT-A',
|
|
(tx) =>
|
|
tx.$executeRaw`INSERT INTO "TenderRssFeedSource" (id, url, "userId", "tenantId") VALUES ('rss-rejected', 'https://rejected.example-tenders.invalid/feed', NULL, NULL)`,
|
|
);
|
|
platformInsertDetail = 'gebundenes INSERT mit tenantId=NULL ist NICHT fehlgeschlagen';
|
|
} catch (err) {
|
|
platformInsertRejected = true;
|
|
platformInsertDetail = `gebundenes INSERT mit tenantId=NULL abgewiesen (tenant_insert_policy): ${err.message} — createPlatform darf deshalb nicht gebunden werden`;
|
|
}
|
|
report(
|
|
results,
|
|
'tenderrssfeed-gebundenes-einfuegen-ohne-mandant-abgelehnt',
|
|
platformInsertRejected,
|
|
platformInsertDetail,
|
|
);
|
|
|
|
// tenderrssfeed-gebundenes-aendern-der-plattformzeile-abgelehnt — NEU:
|
|
// ein gebundenes UPDATE auf die plattformweite Zeile wird abgewiesen.
|
|
// Zusammen mit der folgenden Pruefung die Messung der Richtung "zu
|
|
// locker" (Befund K) und damit der eigentliche Grund fuer die Trennung
|
|
// nach Befehl: eine einzelne Leseregel, die die plattformweite Zeile
|
|
// einschliesst, wuerde ohne diese Trennung auch UPDATE/DELETE erlauben.
|
|
let platformUpdateRejected = false;
|
|
let platformUpdateDetail = '';
|
|
try {
|
|
await forTenantQuery(
|
|
prisma,
|
|
'TENANT-A',
|
|
(tx) =>
|
|
tx.$executeRaw`UPDATE "TenderRssFeedSource" SET url = 'https://gebunden-veraendert.example-tenders.invalid/feed' WHERE id = 'rss-platform'`,
|
|
);
|
|
// Ein UPDATE, das keine Zeile trifft, wirft in Postgres KEINEN Fehler
|
|
// — es muss deshalb explizit nachgesehen werden, ob die Zeile
|
|
// tatsaechlich unveraendert blieb (die USING-Klausel der
|
|
// Aenderungsregel filtert die Zielzeile heraus, bevor SET greift).
|
|
const [afterUpdate] = await withAdminPrisma(
|
|
urlForDatabase(adminUrl, SCRATCH_DB_NAME).toString(),
|
|
(db) =>
|
|
db.$queryRaw`SELECT url FROM "TenderRssFeedSource" WHERE id = 'rss-platform'`,
|
|
);
|
|
platformUpdateRejected =
|
|
afterUpdate.url !== 'https://gebunden-veraendert.example-tenders.invalid/feed';
|
|
platformUpdateDetail = platformUpdateRejected
|
|
? `gebundenes UPDATE auf die plattformweite Zeile traf keine Zeile (tenant_update_policy filtert sie heraus) — url unveraendert: ${JSON.stringify(afterUpdate.url)}`
|
|
: `gebundenes UPDATE auf die plattformweite Zeile ist UNERWARTET durchgegangen — url jetzt: ${JSON.stringify(afterUpdate.url)}`;
|
|
} catch (err) {
|
|
platformUpdateRejected = true;
|
|
platformUpdateDetail = `gebundenes UPDATE auf die plattformweite Zeile abgewiesen: ${err.message}`;
|
|
}
|
|
report(
|
|
results,
|
|
'tenderrssfeed-gebundenes-aendern-der-plattformzeile-abgelehnt',
|
|
platformUpdateRejected,
|
|
platformUpdateDetail,
|
|
);
|
|
|
|
// tenderrssfeed-gebundenes-loeschen-der-plattformzeile-abgelehnt — NEU:
|
|
// ein gebundenes DELETE auf die plattformweite Zeile wird abgewiesen.
|
|
let platformDeleteRejected = false;
|
|
let platformDeleteDetail = '';
|
|
try {
|
|
const deleteResult = await forTenantQuery(
|
|
prisma,
|
|
'TENANT-A',
|
|
(tx) =>
|
|
tx.$executeRaw`DELETE FROM "TenderRssFeedSource" WHERE id = 'rss-platform'`,
|
|
);
|
|
// $executeRaw liefert die Anzahl betroffener Zeilen — 0, wenn die
|
|
// USING-Klausel der Loeschregel die Zielzeile herausfiltert, bevor
|
|
// DELETE greift (kein Fehler, wie bei UPDATE oben).
|
|
platformDeleteRejected = deleteResult === 0;
|
|
platformDeleteDetail = platformDeleteRejected
|
|
? 'gebundenes DELETE auf die plattformweite Zeile traf 0 Zeilen (tenant_delete_policy filtert sie heraus)'
|
|
: `gebundenes DELETE auf die plattformweite Zeile ist UNERWARTET durchgegangen (${deleteResult} Zeile(n) betroffen)`;
|
|
} catch (err) {
|
|
platformDeleteRejected = true;
|
|
platformDeleteDetail = `gebundenes DELETE auf die plattformweite Zeile abgewiesen: ${err.message}`;
|
|
}
|
|
report(
|
|
results,
|
|
'tenderrssfeed-gebundenes-loeschen-der-plattformzeile-abgelehnt',
|
|
platformDeleteRejected,
|
|
platformDeleteDetail,
|
|
);
|
|
|
|
// tendertriage-einfuegen-auf-unsichtbare-zeile-verletzt-eindeutigkeit
|
|
// (Befund F): unter TENANT-A ein INSERT fuer ein Paar (userId,
|
|
// tenderId), dessen Zeile existiert, aber zu TENANT-B gehoert und daher
|
|
// unsichtbar ist (tr-shared). Bestanden, wenn der Fehler eine
|
|
// Verletzung der Eindeutigkeitsbedingung ist (P2002-Familie), nicht
|
|
// eine RLS-Policy-Abweisung — Postgres prueft Unique-Indizes gegen die
|
|
// physischen Zeilen, unabhaengig von der RLS-Sichtbarkeit. Folge fuer
|
|
// Aufgabe 2: aus einem stillen Ueberschreiben wird ein harter Fehler,
|
|
// der als verstaendliche Meldung herauskommen muss.
|
|
let uniqueViolationOnInvisibleRow = false;
|
|
let uniqueViolationDetail = '';
|
|
try {
|
|
await forTenantQuery(
|
|
prisma,
|
|
'TENANT-A',
|
|
(tx) =>
|
|
tx.$executeRaw`INSERT INTO "TenderTriage" (id, "userId", "tenantId", "tenderId") VALUES ('tr-a-attempt', 'user-shared', 'TENANT-A', 'tender-shared')`,
|
|
);
|
|
uniqueViolationDetail = 'gebundenes INSERT auf die unsichtbare (userId,tenderId)-Kombination ist NICHT fehlgeschlagen';
|
|
} catch (err) {
|
|
uniqueViolationOnInvisibleRow = err.code === '23505' || /unique/i.test(err.message);
|
|
uniqueViolationDetail = `gebundenes INSERT auf die unsichtbare (userId,tenderId)-Kombination scheitert an der Eindeutigkeitsbedingung, nicht an der Policy: ${err.message} — Befund F: aus einem stillen Ueberschreiben wird bei Aufgabe 2 ein harter, verstaendlich uebersetzter Fehler`;
|
|
}
|
|
report(
|
|
results,
|
|
'tendertriage-einfuegen-auf-unsichtbare-zeile-verletzt-eindeutigkeit',
|
|
uniqueViolationOnInvisibleRow,
|
|
uniqueViolationDetail,
|
|
);
|
|
} finally {
|
|
await prisma.$disconnect();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Aufgabe 1 (260910-jab) — misst, dass die UNVERAENDERT ausgelieferte Regel
|
|
* auf "SearchProvider" (20260909140000_rls_remaining_tenant_tables) eine
|
|
* mandantenlose Zeile weiterhin unter JEDEM Kontext unsichtbar laesst.
|
|
* Anders als bei TenderRssFeedSource ist das hier KEIN Loch, sondern
|
|
* korrektes Verhalten (Befund E): die Praemisse von WINDOWS #19 ist fuer
|
|
* diese Tabelle widerlegt — es gibt keinen Codeweg, der eine mandantenlose
|
|
* Zeile erzeugt (der einzige Schreibweg, dashboard.service.ts, verlangt die
|
|
* Mandantenkennung als Pflichtparameter; die Vorgabe-Suchmaschinen sind
|
|
* Konstanten, Entscheidung 05-02, keine Datenbankzeilen). Eine Lockerung
|
|
* hier waere die falsche Richtung. Eigene Wegwerf-Tabelle, weil keine
|
|
* andere Pruefung dieses Werkzeugs "SearchProvider" beruehrt.
|
|
*
|
|
* Legt keine Tabelle an, auf der eine andere Pruefung dieses Werkzeugs
|
|
* aufsetzt — wie runTendersAreaChecks() ist dieser Abschnitt in der
|
|
* Aufrufkette ein Blatt.
|
|
*/
|
|
async function runSearchProviderAreaChecks(adminUrl, scratchRoleUrl, results) {
|
|
const remainingMigrationSql = readRemainingTenantTablesMigrationSql();
|
|
const searchProviderPolicy = remainingMigrationSql
|
|
? extractPolicySql(remainingMigrationSql, 'SearchProvider')
|
|
: null;
|
|
|
|
if (!searchProviderPolicy) {
|
|
report(
|
|
results,
|
|
'searchprovider-policy-aus-migration-gefunden',
|
|
false,
|
|
'CREATE POLICY fuer "SearchProvider" nicht in der ausgelieferten *_rls_remaining_tenant_tables-Migration gefunden',
|
|
);
|
|
return;
|
|
}
|
|
|
|
await withAdminPrisma(urlForDatabase(adminUrl, SCRATCH_DB_NAME).toString(), async (db) => {
|
|
await db.$executeRawUnsafe(`
|
|
CREATE TABLE "SearchProvider" (
|
|
id text PRIMARY KEY,
|
|
"userId" text,
|
|
"tenantId" text,
|
|
name text NOT NULL
|
|
);
|
|
`);
|
|
await db.$executeRawUnsafe(`ALTER TABLE "SearchProvider" ENABLE ROW LEVEL SECURITY;`);
|
|
await db.$executeRawUnsafe(`ALTER TABLE "SearchProvider" FORCE ROW LEVEL SECURITY;`);
|
|
await db.$executeRawUnsafe(searchProviderPolicy);
|
|
await db.$executeRawUnsafe(
|
|
`GRANT SELECT, INSERT, UPDATE, DELETE ON "SearchProvider" TO ${SCRATCH_ROLE_NAME}`,
|
|
);
|
|
// Eine mandantenlose Zeile wird ueber die Wartungsrolle angelegt — unter
|
|
// der Anwendungsrolle liesse sie sich mit der unveraenderten Regel
|
|
// ohnehin nicht schreiben.
|
|
await db.$executeRawUnsafe(`
|
|
INSERT INTO "SearchProvider" (id, "userId", "tenantId", name) VALUES
|
|
('search-tenantless', NULL, NULL, 'Mandantenlose Suchmaschine');
|
|
`);
|
|
});
|
|
|
|
const prisma = new PrismaClient({ datasourceUrl: scratchRoleUrl });
|
|
try {
|
|
const rowsForA = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
|
|
tx.$queryRaw`SELECT id FROM "SearchProvider" ORDER BY id`,
|
|
);
|
|
const rowsForB = await forTenantQuery(prisma, 'TENANT-B', (tx) =>
|
|
tx.$queryRaw`SELECT id FROM "SearchProvider" ORDER BY id`,
|
|
);
|
|
const visibleForA = rowsForA.some((r) => r.id === 'search-tenantless');
|
|
const visibleForB = rowsForB.some((r) => r.id === 'search-tenantless');
|
|
report(
|
|
results,
|
|
'searchprovider-mandantenlose-zeile-bleibt-unter-jedem-kontext-unsichtbar',
|
|
!visibleForA && !visibleForB,
|
|
`forTenant(TENANT-A) sieht die mandantenlose Zeile: ${visibleForA}, forTenant(TENANT-B) sieht sie: ${visibleForB} — bewusst UNVERAENDERT (WINDOWS #19, Befund E: die Praemisse einer mandantenlosen SearchProvider-Zeile ist widerlegt, es gibt keinen Codeweg, der eine solche Zeile erzeugt — dashboard.service.ts verlangt die Mandantenkennung als Pflichtparameter, die Vorgabe-Suchmaschinen sind Konstanten, 05-02). Neu zu bewerten, WENN ein Schreibweg entsteht, der "tenantId" absichtlich leer laesst`,
|
|
);
|
|
} finally {
|
|
await prisma.$disconnect();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Aufgabe 1 (260909-mir), TEIL 1 — misst die neun im Plan genannten
|
|
* Verhaltensweisen des Bereichs dkv unter der Rolle ohne BYPASSRLS, mit
|
|
* den drei Policies fuer "DkvInvoiceHistory", "DkvModuleConfig" und
|
|
* "DkvVehicleMaster" WORTGLEICH aus der ausgelieferten
|
|
* *_rls_remaining_tenant_tables-Migration extrahiert, nicht im Werkzeug
|
|
* nachgetippt. Findet die Extraktion eine der drei nicht, meldet dieser
|
|
* Abschnitt eine FEHLGESCHLAGENE Pruefung und bricht ab, statt mit einer
|
|
* geratenen Policy weiterzumessen.
|
|
*
|
|
* TEIL 2 (die Nebenlaeufigkeitsform aus Befund C, auf die sich
|
|
* getHistory() stuetzt) ist als eigene Pruefung
|
|
* `dkv-zwei-parallele-gebundene-einzelabfragen-je-eigener-kontext` am Ende
|
|
* dieser Funktion mit untergebracht, nicht als eigener Abschnitt — sie
|
|
* braucht dieselben Tabellen und Testzeilen wie TEIL 1.
|
|
*
|
|
* Legt keine Tabelle an, auf der eine andere Pruefung dieses Werkzeugs
|
|
* aufsetzt — wie runTendersAreaChecks() ist dieser Abschnitt in der
|
|
* Aufrufkette ein Blatt: er muss NACH runTendersAreaChecks() und VOR
|
|
* runTransactionShapeMeasurement() laufen, weil Letztere weiterhin auf der
|
|
* von runGroupsAreaChecks() angelegten Tabelle "Group" aufsetzt — dieser
|
|
* Abschnitt aendert daran nichts.
|
|
*/
|
|
async function runDkvAreaChecks(adminUrl, scratchRoleUrl, results) {
|
|
const remainingMigrationSql = readRemainingTenantTablesMigrationSql();
|
|
|
|
const invoiceHistoryPolicy = remainingMigrationSql
|
|
? extractPolicySql(remainingMigrationSql, 'DkvInvoiceHistory')
|
|
: null;
|
|
const moduleConfigPolicy = remainingMigrationSql
|
|
? extractPolicySql(remainingMigrationSql, 'DkvModuleConfig')
|
|
: null;
|
|
const vehicleMasterPolicy = remainingMigrationSql
|
|
? extractPolicySql(remainingMigrationSql, 'DkvVehicleMaster')
|
|
: null;
|
|
|
|
if (!invoiceHistoryPolicy || !moduleConfigPolicy || !vehicleMasterPolicy) {
|
|
report(
|
|
results,
|
|
'dkv-policies-aus-migration-gefunden',
|
|
false,
|
|
'CREATE POLICY fuer "DkvInvoiceHistory", "DkvModuleConfig" und/oder "DkvVehicleMaster" nicht in der ausgelieferten *_rls_remaining_tenant_tables-Migration gefunden',
|
|
);
|
|
return;
|
|
}
|
|
|
|
await withAdminPrisma(urlForDatabase(adminUrl, SCRATCH_DB_NAME).toString(), async (db) => {
|
|
await db.$executeRawUnsafe(`
|
|
CREATE TABLE "DkvModuleConfig" (
|
|
id text PRIMARY KEY,
|
|
"tenantId" text NOT NULL UNIQUE,
|
|
"isActive" boolean NOT NULL DEFAULT true
|
|
);
|
|
`);
|
|
await db.$executeRawUnsafe(`
|
|
CREATE TABLE "DkvVehicleMaster" (
|
|
id text PRIMARY KEY,
|
|
"tenantId" text NOT NULL,
|
|
kennzeichen text NOT NULL,
|
|
UNIQUE ("tenantId", kennzeichen)
|
|
);
|
|
`);
|
|
await db.$executeRawUnsafe(`
|
|
CREATE TABLE "DkvInvoiceHistory" (
|
|
id text PRIMARY KEY,
|
|
"tenantId" text NOT NULL,
|
|
"exportFilename" text
|
|
);
|
|
`);
|
|
|
|
for (const table of ['DkvModuleConfig', 'DkvVehicleMaster', 'DkvInvoiceHistory']) {
|
|
await db.$executeRawUnsafe(`ALTER TABLE "${table}" ENABLE ROW LEVEL SECURITY;`);
|
|
await db.$executeRawUnsafe(`ALTER TABLE "${table}" FORCE ROW LEVEL SECURITY;`);
|
|
}
|
|
await db.$executeRawUnsafe(moduleConfigPolicy);
|
|
await db.$executeRawUnsafe(vehicleMasterPolicy);
|
|
await db.$executeRawUnsafe(invoiceHistoryPolicy);
|
|
|
|
for (const table of ['DkvModuleConfig', 'DkvVehicleMaster', 'DkvInvoiceHistory']) {
|
|
await db.$executeRawUnsafe(
|
|
`GRANT SELECT, INSERT, UPDATE, DELETE ON "${table}" TO ${SCRATCH_ROLE_NAME}`,
|
|
);
|
|
}
|
|
|
|
await db.$executeRawUnsafe(`
|
|
INSERT INTO "DkvModuleConfig" (id, "tenantId", "isActive") VALUES
|
|
('config-a', 'TENANT-A', true),
|
|
('config-b', 'TENANT-B', true);
|
|
`);
|
|
await db.$executeRawUnsafe(`
|
|
INSERT INTO "DkvVehicleMaster" (id, "tenantId", kennzeichen) VALUES
|
|
('veh-a1', 'TENANT-A', 'GEMEINSAM-1'),
|
|
('veh-a2', 'TENANT-A', 'A-ONLY-1'),
|
|
('veh-b1', 'TENANT-B', 'GEMEINSAM-1'),
|
|
('veh-b2', 'TENANT-B', 'B-ONLY-1');
|
|
`);
|
|
await db.$executeRawUnsafe(`
|
|
INSERT INTO "DkvInvoiceHistory" (id, "tenantId", "exportFilename") VALUES
|
|
('hist-a', 'TENANT-A', 'RG-DKV-TEST-A-260909.xlsx'),
|
|
('hist-b', 'TENANT-B', 'RG-DKV-TEST-B-260909.xlsx');
|
|
`);
|
|
});
|
|
|
|
const prisma = new PrismaClient({ datasourceUrl: scratchRoleUrl });
|
|
try {
|
|
// dkvmoduleconfig-gebunden-nur-eigene-zeile
|
|
const configRowsForA = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
|
|
tx.$queryRaw`SELECT "tenantId" FROM "DkvModuleConfig" ORDER BY id`,
|
|
);
|
|
report(
|
|
results,
|
|
'dkvmoduleconfig-gebunden-nur-eigene-zeile',
|
|
configRowsForA.length === 1 && configRowsForA[0].tenantId === 'TENANT-A',
|
|
`forTenant(TENANT-A) liefert ${configRowsForA.length} Zeile(n): ${JSON.stringify(configRowsForA.map((r) => r.tenantId))}`,
|
|
);
|
|
|
|
// dkvmoduleconfig-ungebunden-null-zeilen — die Belegzeile, die den
|
|
// gesamten dkv-Abschnitt der Kritikschrift traegt: der IDENTISCHE
|
|
// SELECT ohne vorheriges set_config liefert null Zeilen, nicht die
|
|
// beiden tatsaechlich vorhandenen.
|
|
const unboundConfigRows = await prisma.$queryRaw`SELECT "tenantId" FROM "DkvModuleConfig"`;
|
|
report(
|
|
results,
|
|
'dkvmoduleconfig-ungebunden-null-zeilen',
|
|
unboundConfigRows.length === 0,
|
|
`ungebundener SELECT auf "DkvModuleConfig" liefert ${unboundConfigRows.length} Zeile(n)`,
|
|
);
|
|
|
|
// dkvmoduleconfig-ungebundene-einzelabfrage-liefert-keine-zeile — die
|
|
// eigene, diesem Bereich vorbehaltene Messung: die Form, die der
|
|
// Planer-Startpfad heute benutzt (loadConfig() ohne Mandant, also ein
|
|
// findFirst() ohne jede Bedingung). Bestanden, wenn KEINE Zeile
|
|
// zurueckkommt, obwohl zwei existieren.
|
|
const unboundSingleRow = await prisma.$queryRaw`SELECT "tenantId" FROM "DkvModuleConfig" LIMIT 1`;
|
|
report(
|
|
results,
|
|
'dkvmoduleconfig-ungebundene-einzelabfrage-liefert-keine-zeile',
|
|
unboundSingleRow.length === 0,
|
|
`ungebundenes SELECT ... LIMIT 1 ohne jede Bedingung liefert ${unboundSingleRow.length} Zeile(n), obwohl 2 existieren — die Form, die der Planer-Startpfad heute benutzt: aus einer beliebigen-aber-vorhandenen Zeile wird KEINE Zeile, und der aufrufende Code liest das als "dieses Modul ist nicht eingerichtet"`,
|
|
);
|
|
|
|
// dkvinvoicehistory-gebunden-nur-eigener-mandant
|
|
const historyRowsForA = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
|
|
tx.$queryRaw`SELECT "tenantId" FROM "DkvInvoiceHistory" ORDER BY id`,
|
|
);
|
|
report(
|
|
results,
|
|
'dkvinvoicehistory-gebunden-nur-eigener-mandant',
|
|
historyRowsForA.length === 1 && historyRowsForA[0].tenantId === 'TENANT-A',
|
|
`forTenant(TENANT-A) liefert ${historyRowsForA.length} Zeile(n): ${JSON.stringify(historyRowsForA.map((r) => r.tenantId))}`,
|
|
);
|
|
|
|
// dkvvehiclemaster-gebunden-nur-eigener-mandant
|
|
const vehicleRowsForA = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
|
|
tx.$queryRaw`SELECT "tenantId" FROM "DkvVehicleMaster" ORDER BY id`,
|
|
);
|
|
report(
|
|
results,
|
|
'dkvvehiclemaster-gebunden-nur-eigener-mandant',
|
|
vehicleRowsForA.length === 2 && vehicleRowsForA.every((r) => r.tenantId === 'TENANT-A'),
|
|
`forTenant(TENANT-A) liefert ${vehicleRowsForA.length} Zeile(n): ${JSON.stringify(vehicleRowsForA.map((r) => r.tenantId))}`,
|
|
);
|
|
|
|
// dkvvehiclemaster-gebundenes-einfuegen-fremder-mandant-abgelehnt
|
|
// (Befund I): die ausgelieferten Policies tragen keine eigene
|
|
// WITH-CHECK-Klausel — was PostgreSQL daraus fuer ein INSERT ableitet,
|
|
// ist eine Eigenschaft der Datenbank, keine des Policy-Textes. Die
|
|
// Abweisung IST das bestandene Ergebnis.
|
|
let foreignInsertRejected = false;
|
|
let foreignInsertDetail = '';
|
|
try {
|
|
await forTenantQuery(
|
|
prisma,
|
|
'TENANT-A',
|
|
(tx) =>
|
|
tx.$executeRaw`INSERT INTO "DkvVehicleMaster" (id, "tenantId", kennzeichen) VALUES ('veh-rejected', 'TENANT-B', 'REJECTED-PLATE')`,
|
|
);
|
|
foreignInsertDetail = 'gebundenes INSERT unter TENANT-A mit tenantId=TENANT-B ist NICHT fehlgeschlagen';
|
|
} catch (err) {
|
|
foreignInsertRejected = true;
|
|
foreignInsertDetail = `gebundenes INSERT unter TENANT-A mit tenantId=TENANT-B abgewiesen: ${err.message}`;
|
|
}
|
|
report(
|
|
results,
|
|
'dkvvehiclemaster-gebundenes-einfuegen-fremder-mandant-abgelehnt',
|
|
foreignInsertRejected,
|
|
foreignInsertDetail,
|
|
);
|
|
|
|
// dkvvehiclemaster-gebundenes-update-ueber-kennung-allein-trifft-null-zeilen
|
|
// (Befund G): ein gebundenes UPDATE unter TENANT-A, das eine Zeile von
|
|
// TENANT-B allein ueber deren id anspricht — die Form, die
|
|
// updateVehicle()/deleteVehicle() im Schreibschritt nutzen. Bestanden,
|
|
// wenn null Zeilen betroffen sind: ein Schreibzugriff ueber die
|
|
// Kennung allein scheitert gebunden nicht laut, sondern trifft still
|
|
// nichts, deshalb bleibt die vorgeschaltete Besitzpruefung erhalten.
|
|
const foreignUpdateAffected = await forTenantQuery(
|
|
prisma,
|
|
'TENANT-A',
|
|
(tx) => tx.$executeRaw`UPDATE "DkvVehicleMaster" SET kennzeichen = 'UEBERSCHRIEBEN' WHERE id = 'veh-b1'`,
|
|
);
|
|
report(
|
|
results,
|
|
'dkvvehiclemaster-gebundenes-update-ueber-kennung-allein-trifft-null-zeilen',
|
|
foreignUpdateAffected === 0,
|
|
`gebundenes UPDATE unter TENANT-A ueber die Kennung 'veh-b1' (gehoert TENANT-B) allein betrifft ${foreignUpdateAffected} Zeile(n) — Folge fuer Aufgabe 3 (Befund G): die vorgeschaltete Besitzpruefung bleibt deshalb erhalten und wird nicht durch die Datenbank ersetzt`,
|
|
);
|
|
|
|
// dkvvehiclemaster-schluessel-traegt-mandant-keine-fremdkollision
|
|
// (Befund H, Gegenbefund zu tenders-Befund F): unter TENANT-A ein
|
|
// gebundenes INSERT auf ein Kennzeichen, das unter TENANT-B bereits
|
|
// existiert ('B-ONLY-1', veh-b2). Bestanden, wenn es GELINGT — weil der
|
|
// Mandant Teil des zusammengesetzten Schluessels (tenantId,
|
|
// kennzeichen) ist, gibt es hier keine Kollision auf einer
|
|
// unsichtbaren fremden Zeile und keine P2002-Uebersetzung zu bauen.
|
|
let noForeignCollision = false;
|
|
let noForeignCollisionDetail = '';
|
|
try {
|
|
await forTenantQuery(
|
|
prisma,
|
|
'TENANT-A',
|
|
(tx) =>
|
|
tx.$executeRaw`INSERT INTO "DkvVehicleMaster" (id, "tenantId", kennzeichen) VALUES ('veh-a-neu', 'TENANT-A', 'B-ONLY-1')`,
|
|
);
|
|
noForeignCollision = true;
|
|
noForeignCollisionDetail = `gebundenes INSERT unter TENANT-A auf das bereits unter TENANT-B vorhandene Kennzeichen 'B-ONLY-1' gelingt — der Mandant ist Teil des zusammengesetzten Schluessels, keine Kollision auf einer unsichtbaren fremden Zeile, keine P2002-Uebersetzung noetig`;
|
|
} catch (err) {
|
|
noForeignCollisionDetail = `gebundenes INSERT unter TENANT-A auf das bereits unter TENANT-B vorhandene Kennzeichen 'B-ONLY-1' ist fehlgeschlagen: ${err.message}`;
|
|
}
|
|
report(
|
|
results,
|
|
'dkvvehiclemaster-schluessel-traegt-mandant-keine-fremdkollision',
|
|
noForeignCollision,
|
|
noForeignCollisionDetail,
|
|
);
|
|
|
|
// dkv-zwei-parallele-gebundene-einzelabfragen-je-eigener-kontext (TEIL
|
|
// 2, Befund C): getHistory() fuehrt zwei Abfragen ueber Promise.all
|
|
// parallel aus — nach der Umstellung also zwei parallele
|
|
// Einzeloperationen auf EINEM gebundenen Klienten. Hier fuer ZWEI
|
|
// verschiedene Mandanten ueber DENSELBEN Klienten nachgebaut. Bestanden,
|
|
// wenn jede Abfrage den Kontext sieht, unter dem sie gestartet wurde,
|
|
// und jede die richtige Zeilenzahl liefert. Als Verletzung zaehlt
|
|
// beides: ein fremder oder fehlender Kontext und ein Abbruch.
|
|
const [parallelA, parallelB] = await Promise.all([
|
|
forTenantQuery(prisma, 'TENANT-A', (tx) =>
|
|
tx.$queryRaw`SELECT pg_backend_pid() AS pid, current_tenant_id() AS t, (SELECT count(*)::int FROM "DkvInvoiceHistory") AS rows`,
|
|
),
|
|
forTenantQuery(prisma, 'TENANT-B', (tx) =>
|
|
tx.$queryRaw`SELECT pg_backend_pid() AS pid, current_tenant_id() AS t, (SELECT count(*)::int FROM "DkvInvoiceHistory") AS rows`,
|
|
),
|
|
]);
|
|
const rowA = parallelA[0];
|
|
const rowB = parallelB[0];
|
|
const parallelOk =
|
|
Boolean(rowA) &&
|
|
Boolean(rowB) &&
|
|
rowA.t === 'TENANT-A' &&
|
|
rowB.t === 'TENANT-B' &&
|
|
rowA.rows === 1 &&
|
|
rowB.rows === 1;
|
|
report(
|
|
results,
|
|
'dkv-zwei-parallele-gebundene-einzelabfragen-je-eigener-kontext',
|
|
parallelOk,
|
|
`TENANT-A: pid=${rowA?.pid}, t=${JSON.stringify(rowA?.t)}, rows=${rowA?.rows}; TENANT-B: pid=${rowB?.pid}, t=${JSON.stringify(rowB?.t)}, rows=${rowB?.rows} — Nebenlaeufigkeitsform von getHistory(): zwei ueber Promise.all gleichzeitig gestartete gebundene Einzelabfragen ueber denselben Klienten, jede unter ihrem eigenen Kontext`,
|
|
);
|
|
} finally {
|
|
await prisma.$disconnect();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Vergleicht zwei SQL-Fragmente nach Normalisierung von Leerraum und
|
|
* abschliessendem Semikolon, damit der Vergleich nicht an Formatierung
|
|
* scheitert (Aufgabe 1, 260910-das).
|
|
*/
|
|
function normalizePolicySql(sql) {
|
|
return sql.trim().replace(/;\s*$/, '').replace(/\s+/g, ' ').trim();
|
|
}
|
|
|
|
/**
|
|
* Die im Anmeldeweg-Abschnitt (runAuthLookupChecks) von Hand getippte
|
|
* Policy auf "User" — Wortlaut identisch mit Zeile 285 dieser Datei. Dieser
|
|
* Abschnitt haelt sie GEGEN die aus der ausgelieferten Migration
|
|
* `20260618112133_rls_policies` geschnittene Fassung, statt eine dritte
|
|
* Fassung zu erzeugen (Befund O).
|
|
*/
|
|
const AUTH_LOOKUP_USER_POLICY_SQL =
|
|
'CREATE POLICY tenant_isolation_policy ON "User" USING ("tenantId" = current_tenant_id());';
|
|
|
|
/**
|
|
* Liest den SQLSTATE-Fehlercode aus einem PrismaClientKnownRequestError,
|
|
* der aus einem fehlgeschlagenen $executeRaw/$queryRaw stammt. Bei
|
|
* Rohabfragen setzt Prisma selbst `.code` auf den generischen Wert
|
|
* `P2010` ("Raw query failed") und legt den tatsaechlichen
|
|
* PostgreSQL-SQLSTATE-Code unter `.meta.code` ab (empirisch geprueft gegen
|
|
* `tessera-ctl-db-1`, 2026-09-10: `.code` ist fuer eine Eindeutigkeits-
|
|
* UND eine Zeilenschutz-Verletzung gleichermassen `P2010`, waehrend
|
|
* `.meta.code` `23505` bzw. `42501` unterscheidet) — deshalb wird hier
|
|
* `.meta.code` gelesen, nicht `.code`.
|
|
*/
|
|
function sqlStateOf(err) {
|
|
return err?.meta?.code ?? null;
|
|
}
|
|
|
|
/**
|
|
* Aufgabe 1 (260910-das) — misst die zwoelf im Plan genannten
|
|
* Verhaltensweisen des Bereichs `user` unter der Rolle ohne BYPASSRLS. Die
|
|
* Tabelle "User" existiert bereits (vom runAuthLookupChecks()-Abschnitt
|
|
* angelegt, samt eingeschaltetem und erzwungenem Zeilenschutz, beiden
|
|
* Eindeutigkeitsbedingungen `username`/`email` und zwei Testzeilen in zwei
|
|
* Mandanten, Befund O) — dieser Abschnitt legt sie NICHT neu an, sondern
|
|
* baut darauf auf und ergaenzt, was ihm fehlt: eine Tabelle "Tenant" ohne
|
|
* Zeilenschutz (die zu messende Eigenschaft selbst, nicht Beiwerk) und je
|
|
* eine weitere Benutzerzeile pro Mandant.
|
|
*
|
|
* Muss NACH runDkvAreaChecks() und VOR runTransactionShapeMeasurement()
|
|
* laufen (siehe Aufrufkette in main()) — Letztere setzt weiterhin auf der
|
|
* von runGroupsAreaChecks() angelegten Tabelle "Group" auf, dieser
|
|
* Abschnitt aendert daran nichts.
|
|
*/
|
|
async function runUserAreaChecks(adminUrl, scratchRoleUrl, results) {
|
|
const baseMigrationSql = readRlsPoliciesMigrationSql();
|
|
const extractedUserPolicy = baseMigrationSql
|
|
? extractPolicySql(baseMigrationSql, 'User')
|
|
: null;
|
|
|
|
if (
|
|
!extractedUserPolicy ||
|
|
normalizePolicySql(extractedUserPolicy) !== normalizePolicySql(AUTH_LOOKUP_USER_POLICY_SQL)
|
|
) {
|
|
report(
|
|
results,
|
|
'user-policy-aus-migration-wortgleich',
|
|
false,
|
|
extractedUserPolicy
|
|
? `Policy aus 20260618112133_rls_policies weicht von der im Anmeldeweg-Abschnitt getippten Fassung ab: extrahiert=${JSON.stringify(normalizePolicySql(extractedUserPolicy))}, getippt=${JSON.stringify(normalizePolicySql(AUTH_LOOKUP_USER_POLICY_SQL))} — die getippte Fassung wird durch die geschnittene ERSETZT, die Abweichung gehoert in die Kritikschrift`
|
|
: 'CREATE POLICY fuer "User" nicht in der ausgelieferten 20260618112133_rls_policies-Migration gefunden',
|
|
);
|
|
return;
|
|
}
|
|
report(
|
|
results,
|
|
'user-policy-aus-migration-wortgleich',
|
|
true,
|
|
'die im Anmeldeweg-Abschnitt (runAuthLookupChecks) von Hand getippte Policy auf "User" ist nach Normalisierung von Leerraum und abschliessendem Semikolon wortgleich mit der aus 20260618112133_rls_policies geschnittenen',
|
|
);
|
|
|
|
await withAdminPrisma(urlForDatabase(adminUrl, SCRATCH_DB_NAME).toString(), async (db) => {
|
|
// "Tenant" traegt bewusst KEINEN Zeilenschutz — das ist die zu
|
|
// messende Eigenschaft (Befund F/K), nicht ein Versehen.
|
|
await db.$executeRawUnsafe(`
|
|
CREATE TABLE "Tenant" (
|
|
id text PRIMARY KEY,
|
|
slug text NOT NULL UNIQUE
|
|
);
|
|
`);
|
|
await db.$executeRawUnsafe(
|
|
`GRANT SELECT, INSERT, UPDATE, DELETE ON "Tenant" TO ${SCRATCH_ROLE_NAME}`,
|
|
);
|
|
await db.$executeRawUnsafe(`
|
|
INSERT INTO "Tenant" (id, slug) VALUES
|
|
('TENANT-A', 'tenant-a'),
|
|
('TENANT-B', 'tenant-b');
|
|
`);
|
|
|
|
// Je eine weitere Benutzerzeile pro Mandant, zusaetzlich zu den beiden
|
|
// bereits vom Anmeldeweg-Abschnitt angelegten (alice/TENANT-A,
|
|
// bob/TENANT-B) — role braucht einen gueltigen Aufzaehlungswert
|
|
// (Befund O).
|
|
await db.$executeRawUnsafe(`
|
|
INSERT INTO "User" (id, username, "tenantId", "passwordHash", "isActive", role)
|
|
VALUES ('user-a2', 'carol', 'TENANT-A', 'hash-c', true, 'USER'),
|
|
('user-b2', 'dave', 'TENANT-B', 'hash-d', true, 'USER');
|
|
`);
|
|
});
|
|
|
|
const prisma = new PrismaClient({ datasourceUrl: scratchRoleUrl });
|
|
try {
|
|
// user-gebunden-nur-eigener-mandant
|
|
const userRowsForA = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
|
|
tx.$queryRaw`SELECT "tenantId" FROM "User" ORDER BY id`,
|
|
);
|
|
report(
|
|
results,
|
|
'user-gebunden-nur-eigener-mandant',
|
|
userRowsForA.length === 2 && userRowsForA.every((r) => r.tenantId === 'TENANT-A'),
|
|
`forTenant(TENANT-A) liefert ${userRowsForA.length} Zeile(n): ${JSON.stringify(userRowsForA.map((r) => r.tenantId))}`,
|
|
);
|
|
|
|
// user-ungebunden-null-zeilen — die Belegzeile, die den gesamten
|
|
// user-Abschnitt der Kritikschrift traegt: der IDENTISCHE SELECT ohne
|
|
// vorheriges set_config liefert null Zeilen, nicht die vier
|
|
// tatsaechlich vorhandenen.
|
|
const unboundUserRows = await prisma.$queryRaw`SELECT "tenantId" FROM "User"`;
|
|
report(
|
|
results,
|
|
'user-ungebunden-null-zeilen',
|
|
unboundUserRows.length === 0,
|
|
`ungebundener SELECT auf "User" liefert ${unboundUserRows.length} Zeile(n)`,
|
|
);
|
|
|
|
// user-ungebundene-suche-nach-benutzername-liefert-keine-zeile — die
|
|
// Form, die die Erstanlage-Pruefung beim Start heute benutzt: ein
|
|
// ungebundenes SELECT mit Gleichheitsbedingung auf einen Benutzernamen,
|
|
// den es GIBT ('bob', TENANT-B).
|
|
const unboundUsernameLookup =
|
|
await prisma.$queryRaw`SELECT id FROM "User" WHERE username = 'bob'`;
|
|
report(
|
|
results,
|
|
'user-ungebundene-suche-nach-benutzername-liefert-keine-zeile',
|
|
unboundUsernameLookup.length === 0,
|
|
`ungebundenes SELECT ... WHERE username = 'bob' liefert ${unboundUsernameLookup.length} Zeile(n), obwohl der Benutzer existiert — der aufrufende Code liest daraus "diesen Benutzer gibt es nicht" und legt an`,
|
|
);
|
|
|
|
// user-gebundene-suche-nach-fremdem-benutzernamen-liefert-keine-zeile —
|
|
// dieselbe Suche, gebunden an TENANT-A, nach einem Benutzernamen von
|
|
// TENANT-B ('bob'). Das ist der Moment, in dem eine Kollisionspruefung
|
|
// faelschlich "frei" meldet.
|
|
const boundForeignUsernameLookup = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
|
|
tx.$queryRaw`SELECT id FROM "User" WHERE username = 'bob'`,
|
|
);
|
|
report(
|
|
results,
|
|
'user-gebundene-suche-nach-fremdem-benutzernamen-liefert-keine-zeile',
|
|
boundForeignUsernameLookup.length === 0,
|
|
`forTenant(TENANT-A) liefert fuer WHERE username = 'bob' (gehoert TENANT-B) ${boundForeignUsernameLookup.length} Zeile(n) — die Kollisionspruefung meldet faelschlich "frei"`,
|
|
);
|
|
|
|
// user-eindeutigkeit-greift-trotz-unsichtbarkeit — die wichtigste
|
|
// Messung dieser Aufgabe und der Schluss der Kette: unmittelbar nach
|
|
// der vorherigen Pruefung ein gebundenes INSERT unter TENANT-A mit
|
|
// genau diesem, angeblich freien Benutzernamen ('bob'). Bestanden, wenn
|
|
// es abgewiesen wird UND die Ablehnung nachweislich eine
|
|
// Eindeutigkeitsverletzung ist (SQLSTATE 23505) und NICHT eine
|
|
// Zeilenschutz-Ablehnung (SQLSTATE 42501).
|
|
let uniquenessHoldsDespiteInvisibility = false;
|
|
let uniquenessDetail = '';
|
|
try {
|
|
await forTenantQuery(
|
|
prisma,
|
|
'TENANT-A',
|
|
(tx) =>
|
|
tx.$executeRaw`INSERT INTO "User" (id, username, "tenantId", "passwordHash", "isActive", role) VALUES ('user-a-collision', 'bob', 'TENANT-A', 'hash-x', true, 'USER')`,
|
|
);
|
|
uniquenessDetail =
|
|
'gebundenes INSERT unter TENANT-A mit dem angeblich freien Benutzernamen "bob" ist NICHT fehlgeschlagen';
|
|
} catch (err) {
|
|
const sqlState = sqlStateOf(err);
|
|
uniquenessHoldsDespiteInvisibility = sqlState === '23505';
|
|
uniquenessDetail = `gebundenes INSERT unter TENANT-A mit dem angeblich freien Benutzernamen "bob" wird abgewiesen mit SQLSTATE ${sqlState ?? 'unbekannt'} (${err.message.trim()}) — ${
|
|
uniquenessHoldsDespiteInvisibility
|
|
? 'eine Eindeutigkeitsverletzung (23505), NICHT eine Zeilenschutz-Ablehnung: genau die im Auftrag beschriebene Kette'
|
|
: 'KEINE Eindeutigkeitsverletzung, sondern eine andere Fehlerklasse — das waere NICHT die im Auftrag beschriebene Kette'
|
|
}`;
|
|
}
|
|
report(
|
|
results,
|
|
'user-eindeutigkeit-greift-trotz-unsichtbarkeit',
|
|
uniquenessHoldsDespiteInvisibility,
|
|
uniquenessDetail,
|
|
);
|
|
|
|
// user-gebundenes-einfuegen-fremder-mandant-abgelehnt — die Policy
|
|
// traegt keine eigene WITH-CHECK-Klausel; was PostgreSQL daraus fuer
|
|
// ein INSERT ableitet, ist eine Eigenschaft der Datenbank, keine des
|
|
// Policy-Textes.
|
|
let foreignTenantInsertRejected = false;
|
|
let foreignTenantInsertDetail = '';
|
|
try {
|
|
await forTenantQuery(
|
|
prisma,
|
|
'TENANT-A',
|
|
(tx) =>
|
|
tx.$executeRaw`INSERT INTO "User" (id, username, "tenantId", "passwordHash", "isActive", role) VALUES ('user-rejected-foreign-tenant', 'erin', 'TENANT-B', 'hash-e', true, 'USER')`,
|
|
);
|
|
foreignTenantInsertDetail =
|
|
'gebundenes INSERT unter TENANT-A mit tenantId=TENANT-B ist NICHT fehlgeschlagen';
|
|
} catch (err) {
|
|
foreignTenantInsertRejected = true;
|
|
foreignTenantInsertDetail = `gebundenes INSERT unter TENANT-A mit tenantId=TENANT-B abgewiesen: ${err.message.trim()}`;
|
|
}
|
|
report(
|
|
results,
|
|
'user-gebundenes-einfuegen-fremder-mandant-abgelehnt',
|
|
foreignTenantInsertRejected,
|
|
foreignTenantInsertDetail,
|
|
);
|
|
|
|
// user-ungebundenes-einfuegen-abgelehnt — die Zeile, die Befund J
|
|
// traegt: bliebe die Erstanlage des Administrators ungebunden, koennte
|
|
// eine frische Installation ihren ersten Administrator nach dem
|
|
// Scharfschalten nicht anlegen.
|
|
let unboundInsertRejected = false;
|
|
let unboundInsertDetail = '';
|
|
try {
|
|
await prisma.$executeRaw`INSERT INTO "User" (id, username, "tenantId", "passwordHash", "isActive", role) VALUES ('user-rejected-unbound', 'frank', 'TENANT-A', 'hash-f', true, 'USER')`;
|
|
unboundInsertDetail = 'ungebundenes INSERT mit gueltiger Mandantenkennung ist NICHT fehlgeschlagen';
|
|
} catch (err) {
|
|
unboundInsertRejected = true;
|
|
unboundInsertDetail = `ungebundenes INSERT mit gueltiger Mandantenkennung abgewiesen: ${err.message.trim()}`;
|
|
}
|
|
report(
|
|
results,
|
|
'user-ungebundenes-einfuegen-abgelehnt',
|
|
unboundInsertRejected,
|
|
unboundInsertDetail,
|
|
);
|
|
|
|
// user-gebundenes-update-ueber-kennung-allein-trifft-null-zeilen
|
|
const foreignUpdateAffected = await forTenantQuery(
|
|
prisma,
|
|
'TENANT-A',
|
|
(tx) =>
|
|
tx.$executeRaw`UPDATE "User" SET "displayName" = 'ueberschrieben' WHERE id = 'user-b'`,
|
|
);
|
|
report(
|
|
results,
|
|
'user-gebundenes-update-ueber-kennung-allein-trifft-null-zeilen',
|
|
foreignUpdateAffected === 0,
|
|
`gebundenes UPDATE unter TENANT-A ueber die Kennung 'user-b' (gehoert TENANT-B) allein betrifft ${foreignUpdateAffected} Zeile(n) — die vorgeschalteten Besitz- und Rollenpruefungen bleiben deshalb erhalten und werden in Aufgabe 2/3 nicht durch die Datenbank ersetzt`,
|
|
);
|
|
|
|
// user-gebundenes-loeschen-ueber-kennung-allein-trifft-null-zeilen
|
|
const foreignDeleteAffected = await forTenantQuery(
|
|
prisma,
|
|
'TENANT-A',
|
|
(tx) => tx.$executeRaw`DELETE FROM "User" WHERE id = 'user-b2'`,
|
|
);
|
|
report(
|
|
results,
|
|
'user-gebundenes-loeschen-ueber-kennung-allein-trifft-null-zeilen',
|
|
foreignDeleteAffected === 0,
|
|
`gebundenes DELETE unter TENANT-A ueber die Kennung 'user-b2' (gehoert TENANT-B) allein betrifft ${foreignDeleteAffected} Zeile(n)`,
|
|
);
|
|
|
|
// tenant-tabelle-ohne-zeilenschutz-bleibt-lesbar — die Eigenschaft, auf
|
|
// der sowohl die umgestellte Plattform-Administratorsicht als auch die
|
|
// Standardgruppen-Reparatur beim Start stehen (Befund F, Befund K).
|
|
// Zusaetzlich im Systemkatalog geprueft, damit die Aussage nicht allein
|
|
// daran haengt, dass dieser Abschnitt selbst keinen Zeilenschutz
|
|
// eingeschaltet hat.
|
|
const unboundTenantRows = await prisma.$queryRaw`SELECT id FROM "Tenant" ORDER BY id`;
|
|
const [rlsRow] =
|
|
await prisma.$queryRaw`SELECT relrowsecurity FROM pg_class WHERE relname = 'Tenant'`;
|
|
const tenantReadable = unboundTenantRows.length === 2 && rlsRow?.relrowsecurity === false;
|
|
report(
|
|
results,
|
|
'tenant-tabelle-ohne-zeilenschutz-bleibt-lesbar',
|
|
tenantReadable,
|
|
`ungebundenes SELECT auf "Tenant" liefert ${unboundTenantRows.length} Zeile(n): ${JSON.stringify(unboundTenantRows.map((r) => r.id))}; pg_class.relrowsecurity fuer "Tenant" = ${JSON.stringify(rlsRow?.relrowsecurity)}`,
|
|
);
|
|
|
|
// user-fan-out-je-mandant-gebunden-liefert-alle-zeilen — die
|
|
// Nachbildung der umgestellten Plattform-Administratorsicht: erst die
|
|
// Mandanten ungebunden lesen, dann je Mandant EIN gebundener SELECT,
|
|
// dann die Ergebnisse vereinigen. Die Gesamtmenge wird ueber die
|
|
// Wartungsrolle (mit BYPASSRLS) gemessen, nicht angenommen.
|
|
const tenantIds = unboundTenantRows.map((r) => r.id).sort();
|
|
let fannedOutUsernames = [];
|
|
for (const tenantId of tenantIds) {
|
|
const rows = await forTenantQuery(prisma, tenantId, (tx) =>
|
|
tx.$queryRaw`SELECT username FROM "User" ORDER BY username`,
|
|
);
|
|
fannedOutUsernames.push(...rows.map((r) => r.username));
|
|
}
|
|
fannedOutUsernames = fannedOutUsernames.sort();
|
|
|
|
const groundTruthUsernames = await withAdminPrisma(
|
|
urlForDatabase(adminUrl, SCRATCH_DB_NAME).toString(),
|
|
async (db) => {
|
|
const rows = await db.$queryRaw`SELECT username FROM "User" ORDER BY username`;
|
|
return rows.map((r) => r.username).sort();
|
|
},
|
|
);
|
|
|
|
const fanOutMatches =
|
|
fannedOutUsernames.length === groundTruthUsernames.length &&
|
|
fannedOutUsernames.every((u, i) => u === groundTruthUsernames[i]);
|
|
report(
|
|
results,
|
|
'user-fan-out-je-mandant-gebunden-liefert-alle-zeilen',
|
|
fanOutMatches,
|
|
`Vereinigung der je-Mandant gebundenen SELECTs liefert ${fannedOutUsernames.length} Benutzernamen: ${JSON.stringify(fannedOutUsernames)}; Gesamtmenge (ueber die Wartungsrolle mit BYPASSRLS gemessen) sind ${groundTruthUsernames.length}: ${JSON.stringify(groundTruthUsernames)}`,
|
|
);
|
|
} finally {
|
|
await prisma.$disconnect();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Liest die ausgelieferte Migration, die die Tabellen "Module" und
|
|
* "TenantModuleActivation" samt dem Eindeutigkeitsindex auf
|
|
* ("tenantId","moduleId") anlegt (Dateiname endet auf
|
|
* "_add_module_registry").
|
|
*/
|
|
function readModuleRegistryMigrationSql() {
|
|
const dirs = readdirSync(MIGRATIONS_DIR, { withFileTypes: true })
|
|
.filter((entry) => entry.isDirectory() && entry.name.endsWith('_add_module_registry'))
|
|
.map((entry) => entry.name);
|
|
if (dirs.length !== 1) return null;
|
|
return readFileSync(join(MIGRATIONS_DIR, dirs[0], 'migration.sql'), 'utf-8');
|
|
}
|
|
|
|
/**
|
|
* Liest die ausgelieferte Migration, die (unter anderem) die beiden
|
|
* partiellen Eindeutigkeitsindizes auf "ModuleGrant" anlegt (Dateiname endet
|
|
* auf "_add_groups_and_module_grants") — dieselbe Datei, aus der
|
|
* runGroupsAreaChecks() NICHT liest (jene braucht nur die RLS-Policy-
|
|
* Migration), deshalb ein eigenes, unabhaengiges Lesehilfsmittel.
|
|
*/
|
|
function readAddGroupsAndModuleGrantsMigrationSql() {
|
|
const dirs = readdirSync(MIGRATIONS_DIR, { withFileTypes: true })
|
|
.filter((entry) => entry.isDirectory() && entry.name.endsWith('_add_groups_and_module_grants'))
|
|
.map((entry) => entry.name);
|
|
if (dirs.length !== 1) return null;
|
|
return readFileSync(join(MIGRATIONS_DIR, dirs[0], 'migration.sql'), 'utf-8');
|
|
}
|
|
|
|
/**
|
|
* Schneidet eine `CREATE UNIQUE INDEX "<indexName>" ...;`-Anweisung
|
|
* wortgleich aus einem Migrationstext, nach demselben Muster wie
|
|
* extractPolicySql() oben.
|
|
*/
|
|
function extractIndexSql(migrationSql, indexName) {
|
|
const re = new RegExp(`CREATE UNIQUE INDEX "${indexName}"[\\s\\S]*?;`);
|
|
const match = migrationSql.match(re);
|
|
return match ? match[0] : null;
|
|
}
|
|
|
|
/**
|
|
* Aufgabe 1 (260910-exd) — misst die dreizehn im Plan genannten
|
|
* Verhaltensweisen des Bereichs `module-registry` unter der Rolle ohne
|
|
* BYPASSRLS. Setzt auf den Tabellen "Group", "GroupMembership",
|
|
* "ModuleGrant" und "TenantModuleActivation" auf, die runGroupsAreaChecks()
|
|
* bereits angelegt und mit Policies WORTGLEICH aus den ausgelieferten
|
|
* Migrationen versehen hat — dieser Abschnitt legt sie NICHT neu an. Neu
|
|
* angelegt werden nur: die Tabelle "Module" OHNE Zeilenschutz (die zu
|
|
* messende Eigenschaft selbst), der Eindeutigkeitsindex auf
|
|
* ("tenantId","moduleId") fuer "TenantModuleActivation" (bis hierhin fehlte
|
|
* er, weil runGroupsAreaChecks() ihn nicht braucht), zwei Direkt-Freigaben
|
|
* (eine je Mandant) und die Mitgliedschaft (group-b, user-a), die
|
|
* runGroupsAreaChecks() unter gebundenem Kontext bewusst nicht anlegen
|
|
* konnte.
|
|
*
|
|
* Die bereits von runGroupsAreaChecks() eingefuegte Zeile
|
|
* `grant-foreign-group` (TENANT-A, mod-1, groupId=group-b) wird
|
|
* WIEDERVERWENDET, nicht neu erzeugt.
|
|
*
|
|
* Muss NACH runUserAreaChecks() und VOR runTransactionShapeMeasurement()
|
|
* laufen (siehe Aufrufkette in main()) — Letztere setzt weiterhin auf der
|
|
* von runGroupsAreaChecks() angelegten Tabelle "Group" auf, dieser
|
|
* Abschnitt aendert daran nichts.
|
|
*/
|
|
async function runModuleRegistryAreaChecks(adminUrl, scratchRoleUrl, results) {
|
|
const moduleRegistryMigrationSql = readModuleRegistryMigrationSql();
|
|
const activationUniqueIndexSql = moduleRegistryMigrationSql
|
|
? extractIndexSql(
|
|
moduleRegistryMigrationSql,
|
|
'TenantModuleActivation_tenantId_moduleId_key',
|
|
)
|
|
: null;
|
|
|
|
const groupsAndGrantsMigrationSql = readAddGroupsAndModuleGrantsMigrationSql();
|
|
const grantGroupUniqueIndexSql = groupsAndGrantsMigrationSql
|
|
? extractIndexSql(groupsAndGrantsMigrationSql, 'ModuleGrant_tenant_module_group_unique')
|
|
: null;
|
|
const grantUserUniqueIndexSql = groupsAndGrantsMigrationSql
|
|
? extractIndexSql(groupsAndGrantsMigrationSql, 'ModuleGrant_tenant_module_user_unique')
|
|
: null;
|
|
|
|
if (!activationUniqueIndexSql || !grantGroupUniqueIndexSql || !grantUserUniqueIndexSql) {
|
|
report(
|
|
results,
|
|
'module-registry-regeln-aus-migration-gefunden',
|
|
false,
|
|
'Eindeutigkeitsindex fuer "TenantModuleActivation" und/oder die beiden partiellen Eindeutigkeitsindizes fuer "ModuleGrant" nicht in den ausgelieferten Migrationen gefunden',
|
|
);
|
|
return;
|
|
}
|
|
|
|
await withAdminPrisma(urlForDatabase(adminUrl, SCRATCH_DB_NAME).toString(), async (db) => {
|
|
// (a) Katalogtabelle OHNE Zeilenschutz — die zu messende Eigenschaft
|
|
// selbst (Befund E), nach dem Muster der Tabelle "Tenant" im
|
|
// Abschnitt des Bereichs `user`.
|
|
await db.$executeRawUnsafe(`
|
|
CREATE TABLE "Module" (
|
|
id text PRIMARY KEY,
|
|
name text NOT NULL
|
|
);
|
|
`);
|
|
await db.$executeRawUnsafe(`GRANT SELECT, INSERT, UPDATE, DELETE ON "Module" TO ${SCRATCH_ROLE_NAME}`);
|
|
await db.$executeRawUnsafe(`
|
|
INSERT INTO "Module" (id, name) VALUES ('mod-1', 'Modul Eins'), ('mod-2', 'Modul Zwei');
|
|
`);
|
|
|
|
// (b) Eindeutigkeitsindex auf ("tenantId","moduleId") fuer
|
|
// "TenantModuleActivation", wortgleich aus der ausgelieferten Migration
|
|
// — ohne ihn liesse sich Pruefung 12 nicht messen.
|
|
await db.$executeRawUnsafe(activationUniqueIndexSql);
|
|
|
|
// Zusaetzliche Aktivierungszeile fuer Pruefung 12: (TENANT-B, mod-2),
|
|
// unter TENANT-A unsichtbar, aber physisch vorhanden.
|
|
await db.$executeRawUnsafe(`
|
|
INSERT INTO "TenantModuleActivation" (id, "tenantId", "moduleId", "isActive") VALUES
|
|
('activation-b2', 'TENANT-B', 'mod-2', true);
|
|
`);
|
|
|
|
// (c) je eine Direkt-Freigabezeile pro Mandant (userId, kein groupId).
|
|
await db.$executeRawUnsafe(`
|
|
INSERT INTO "ModuleGrant" (id, "tenantId", "moduleId", "groupId", "userId") VALUES
|
|
('grant-direct-a', 'TENANT-A', 'mod-1', NULL, 'user-a'),
|
|
('grant-direct-b', 'TENANT-B', 'mod-1', NULL, 'user-b');
|
|
`);
|
|
|
|
// (d) die Mitgliedschaft (group-b, user-a), die runGroupsAreaChecks()
|
|
// unter gebundenem Kontext bewusst NICHT anlegen konnte (die Regel wies
|
|
// sie ab) — hier ueber die Verwaltungsrolle gesetzt, weil Pruefung 6
|
|
// sonst aus dem falschen Grund bestuende.
|
|
await db.$executeRawUnsafe(`
|
|
INSERT INTO "GroupMembership" (id, "groupId", "userId", source) VALUES
|
|
('membership-cross', 'group-b', 'user-a', 'MANUAL');
|
|
`);
|
|
});
|
|
|
|
const prisma = new PrismaClient({ datasourceUrl: scratchRoleUrl });
|
|
try {
|
|
// 1: modulegrant-ungebunden-null-zeilen — die Belegzeile dieses
|
|
// Abschnitts.
|
|
const actualGrantCount = await withAdminPrisma(
|
|
urlForDatabase(adminUrl, SCRATCH_DB_NAME).toString(),
|
|
async (db) => {
|
|
const [row] = await db.$queryRaw`SELECT count(*)::int AS n FROM "ModuleGrant"`;
|
|
return row.n;
|
|
},
|
|
);
|
|
const unboundGrantRows = await prisma.$queryRaw`SELECT "tenantId" FROM "ModuleGrant"`;
|
|
report(
|
|
results,
|
|
'modulegrant-ungebunden-null-zeilen',
|
|
unboundGrantRows.length === 0,
|
|
`ungebundener SELECT auf "ModuleGrant" liefert ${unboundGrantRows.length} Zeile(n), tatsaechlich vorhanden sind ${actualGrantCount}`,
|
|
);
|
|
|
|
// 2: tenantmoduleactivation-ungebunden-null-zeilen — dasselbe fuer die
|
|
// Aktivierungstabelle, die der Kurzschluss fuer ADMIN/SUPER_ADMIN als
|
|
// EINZIGE liest.
|
|
const actualActivationCount = await withAdminPrisma(
|
|
urlForDatabase(adminUrl, SCRATCH_DB_NAME).toString(),
|
|
async (db) => {
|
|
const [row] = await db.$queryRaw`SELECT count(*)::int AS n FROM "TenantModuleActivation"`;
|
|
return row.n;
|
|
},
|
|
);
|
|
const unboundActivationRows =
|
|
await prisma.$queryRaw`SELECT "tenantId" FROM "TenantModuleActivation"`;
|
|
report(
|
|
results,
|
|
'tenantmoduleactivation-ungebunden-null-zeilen',
|
|
unboundActivationRows.length === 0,
|
|
`ungebundener SELECT auf "TenantModuleActivation" liefert ${unboundActivationRows.length} Zeile(n), tatsaechlich vorhanden sind ${actualActivationCount}`,
|
|
);
|
|
|
|
// 3: admin-kurzschluss-gebunden-liefert-nur-eigene-aktivierungen
|
|
const activeActivationsForA = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
|
|
tx.$queryRaw`SELECT "tenantId" FROM "TenantModuleActivation" WHERE "isActive" = true ORDER BY id`,
|
|
);
|
|
report(
|
|
results,
|
|
'admin-kurzschluss-gebunden-liefert-nur-eigene-aktivierungen',
|
|
activeActivationsForA.length === 1 && activeActivationsForA[0].tenantId === 'TENANT-A',
|
|
`forTenant(TENANT-A) liefert ${activeActivationsForA.length} aktive Aktivierung(en): ${JSON.stringify(activeActivationsForA.map((r) => r.tenantId))}`,
|
|
);
|
|
|
|
// 4: direktfreigabe-gebunden-nur-eigene-zeile
|
|
const directGrantsForA = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
|
|
tx.$queryRaw`SELECT id FROM "ModuleGrant" WHERE "userId" = 'user-a' ORDER BY id`,
|
|
);
|
|
report(
|
|
results,
|
|
'direktfreigabe-gebunden-nur-eigene-zeile',
|
|
directGrantsForA.length === 1 && directGrantsForA[0].id === 'grant-direct-a',
|
|
`forTenant(TENANT-A) liefert fuer die Direkt-Freigabe-Abfrage (userId=user-a) ${directGrantsForA.length} Zeile(n): ${JSON.stringify(directGrantsForA.map((r) => r.id))}`,
|
|
);
|
|
|
|
// Der Drei-Tabellen-Weg (ModuleGrant ueber Group ueber GroupMembership),
|
|
// Grundlage fuer Pruefung 5 und 6 — EINE Abfrage, zwei Aussagen.
|
|
const groupPathForA = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
|
|
tx.$queryRaw`
|
|
SELECT mg.id FROM "ModuleGrant" mg
|
|
JOIN "Group" g ON g.id = mg."groupId"
|
|
JOIN "GroupMembership" gm ON gm."groupId" = g.id
|
|
WHERE mg."tenantId" = current_tenant_id() AND gm."userId" = 'user-a'
|
|
ORDER BY mg.id
|
|
`,
|
|
);
|
|
|
|
// 5: gruppenpfad-gebunden-folgt-der-gruppenregel
|
|
report(
|
|
results,
|
|
'gruppenpfad-gebunden-folgt-der-gruppenregel',
|
|
groupPathForA.length === 1 && groupPathForA[0].id === 'grant-a',
|
|
`forTenant(TENANT-A) liefert ueber den Drei-Tabellen-Weg (Freigabe ueber Gruppe ueber Mitgliedschaft) fuer user-a ${groupPathForA.length} Zeile(n): ${JSON.stringify(groupPathForA.map((r) => r.id))}`,
|
|
);
|
|
|
|
// 6: gruppenpfad-gebunden-schliesst-die-fremde-gruppe-aus — Meldetext
|
|
// seit 260910-jab RICHTIGGESTELLT: er behauptete vormals, die Regel auf
|
|
// "ModuleGrant" lasse 'grant-foreign-group' durch (T-JTS-03). Das ist
|
|
// nach der Reparatur unwahr — die Regel weist ein gebundenes Einfuegen
|
|
// dieser Zeile jetzt nachweislich ab (siehe 'modulegrant-fremde-gruppe-
|
|
// abgelehnt'); die Zeile existiert hier nur, weil
|
|
// 'modulegrant-fremde-gruppe-ueber-die-wartungsrolle-weiterhin-moeglich'
|
|
// sie ueber die Wartungsrolle (BYPASSRLS) angelegt hat.
|
|
const excludesForeignGroup = !groupPathForA.some((r) => r.id === 'grant-foreign-group');
|
|
report(
|
|
results,
|
|
'gruppenpfad-gebunden-schliesst-die-fremde-gruppe-aus',
|
|
excludesForeignGroup,
|
|
`forTenant(TENANT-A) liefert 'grant-foreign-group' ueber denselben Drei-Tabellen-Weg NICHT (Ergebnis: ${JSON.stringify(groupPathForA.map((r) => r.id))}) — die Zeile wurde ueber die Wartungsrolle angelegt (die Regel auf "ModuleGrant" weist ihr gebundenes Einfuegen seit T-JTS-02/T-JTS-03 nachweislich ab) und die Mitgliedschaft (group-b, user-a) ist vorhanden — diese Verteidigung greift erst nach dem Scharfschalten`,
|
|
);
|
|
|
|
// 7: gruppenpfad-ueber-die-wartungsrolle-liefert-die-fremde-gruppe-mit —
|
|
// die Gegenmessung ueber die Verwaltungsrolle mit BYPASSRLS.
|
|
const groupPathViaAdmin = await withAdminPrisma(
|
|
urlForDatabase(adminUrl, SCRATCH_DB_NAME).toString(),
|
|
async (db) => db.$queryRaw`
|
|
SELECT mg.id FROM "ModuleGrant" mg
|
|
JOIN "Group" g ON g.id = mg."groupId"
|
|
JOIN "GroupMembership" gm ON gm."groupId" = g.id
|
|
WHERE mg."tenantId" = 'TENANT-A' AND gm."userId" = 'user-a'
|
|
ORDER BY mg.id
|
|
`,
|
|
);
|
|
const adminIncludesForeignGroup = groupPathViaAdmin.some((r) => r.id === 'grant-foreign-group');
|
|
report(
|
|
results,
|
|
'gruppenpfad-ueber-die-wartungsrolle-liefert-die-fremde-gruppe-mit',
|
|
adminIncludesForeignGroup,
|
|
`dieselbe Abfrage ueber die Verwaltungsrolle (BYPASSRLS) liefert ${JSON.stringify(groupPathViaAdmin.map((r) => r.id))} — der Ausschluss aus Pruefung 6 kommt damit nachweislich von der Bindung, nicht vom Aufbau`,
|
|
);
|
|
|
|
// 8: module-tabelle-traegt-keinen-zeilenschutz
|
|
const unboundModuleRows = await prisma.$queryRaw`SELECT id FROM "Module" ORDER BY id`;
|
|
const [moduleRlsRow] =
|
|
await prisma.$queryRaw`SELECT relrowsecurity FROM pg_class WHERE relname = 'Module'`;
|
|
const moduleHasNoRls =
|
|
unboundModuleRows.length === 2 && moduleRlsRow?.relrowsecurity === false;
|
|
report(
|
|
results,
|
|
'module-tabelle-traegt-keinen-zeilenschutz',
|
|
moduleHasNoRls,
|
|
`ungebundenes SELECT auf "Module" liefert ${unboundModuleRows.length} Zeile(n): ${JSON.stringify(unboundModuleRows.map((r) => r.id))}; pg_class.relrowsecurity fuer "Module" = ${JSON.stringify(moduleRlsRow?.relrowsecurity)}`,
|
|
);
|
|
|
|
// 9: katalog-bindung-aendert-heute-nichts-an-der-ergebnismenge
|
|
const boundModuleRows = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
|
|
tx.$queryRaw`SELECT id FROM "Module" ORDER BY id`,
|
|
);
|
|
const catalogUnaffectedByBinding =
|
|
boundModuleRows.length === unboundModuleRows.length &&
|
|
boundModuleRows.every((r, i) => r.id === unboundModuleRows[i].id);
|
|
report(
|
|
results,
|
|
'katalog-bindung-aendert-heute-nichts-an-der-ergebnismenge',
|
|
catalogUnaffectedByBinding,
|
|
`forTenant(TENANT-A) liefert ${JSON.stringify(boundModuleRows.map((r) => r.id))}, ungebunden liefert ${JSON.stringify(unboundModuleRows.map((r) => r.id))} — identisch, weil "Module" keine Regel traegt (Befund E: die Nichtbindung des Katalogs ist heute keine Rettung vor Unsichtbarkeit, sondern eine Frage der Wahrhaftigkeit der Aufzeichnung; sie wird erst zur Rettung, WENN Etappe 3 dieser Tabelle eine Regel gibt)`,
|
|
);
|
|
|
|
// 10: gebundener-join-auf-den-katalog-liefert-den-modulnamen
|
|
const activationWithModuleName = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
|
|
tx.$queryRaw`
|
|
SELECT tma."moduleId", m.name FROM "TenantModuleActivation" tma
|
|
JOIN "Module" m ON m.id = tma."moduleId"
|
|
WHERE tma."isActive" = true
|
|
ORDER BY tma.id
|
|
`,
|
|
);
|
|
report(
|
|
results,
|
|
'gebundener-join-auf-den-katalog-liefert-den-modulnamen',
|
|
activationWithModuleName.length === 1 &&
|
|
activationWithModuleName[0].moduleId === 'mod-1' &&
|
|
activationWithModuleName[0].name === 'Modul Eins',
|
|
`forTenant(TENANT-A) liefert fuer den Verbund aus Aktivierung und Katalog: ${JSON.stringify(activationWithModuleName)}`,
|
|
);
|
|
|
|
// 11: aktivierung-gebundenes-einfuegen-fremder-mandant-abgelehnt
|
|
let foreignActivationInsertRejected = false;
|
|
let foreignActivationInsertDetail = '';
|
|
try {
|
|
await forTenantQuery(
|
|
prisma,
|
|
'TENANT-A',
|
|
(tx) =>
|
|
tx.$executeRaw`INSERT INTO "TenantModuleActivation" (id, "tenantId", "moduleId", "isActive") VALUES ('activation-rejected-foreign', 'TENANT-B', 'mod-2', true)`,
|
|
);
|
|
foreignActivationInsertDetail =
|
|
'gebundenes INSERT unter TENANT-A mit tenantId=TENANT-B ist NICHT fehlgeschlagen';
|
|
} catch (err) {
|
|
const sqlState = sqlStateOf(err);
|
|
foreignActivationInsertRejected = sqlState === '42501';
|
|
foreignActivationInsertDetail = `gebundenes INSERT unter TENANT-A mit tenantId=TENANT-B abgewiesen mit SQLSTATE ${sqlState ?? 'unbekannt'} (${err.message.trim()})`;
|
|
}
|
|
report(
|
|
results,
|
|
'aktivierung-gebundenes-einfuegen-fremder-mandant-abgelehnt',
|
|
foreignActivationInsertRejected,
|
|
foreignActivationInsertDetail,
|
|
);
|
|
|
|
// 12: aktivierung-eindeutigkeit-traegt-den-mandanten-keine-unsichtbare-kollision
|
|
let ownActivationInsertSucceeded = false;
|
|
let ownActivationInsertDetail = '';
|
|
try {
|
|
await forTenantQuery(
|
|
prisma,
|
|
'TENANT-A',
|
|
(tx) =>
|
|
tx.$executeRaw`INSERT INTO "TenantModuleActivation" (id, "tenantId", "moduleId", "isActive") VALUES ('activation-a2', 'TENANT-A', 'mod-2', true)`,
|
|
);
|
|
ownActivationInsertSucceeded = true;
|
|
ownActivationInsertDetail =
|
|
'gebundenes INSERT von (TENANT-A, mod-2) ist GELUNGEN, obwohl (TENANT-B, mod-2) bereits existiert und unter TENANT-A unsichtbar ist — der Eindeutigkeitsindex fuehrt mit der Mandantenkennung, genau die Entlastung, die die Bereiche `tenders` und `user` NICHT hatten (dort: unsichtbare Zeile, falsches "frei", harter Eindeutigkeitsfehler)';
|
|
} catch (err) {
|
|
ownActivationInsertDetail = `gebundenes INSERT von (TENANT-A, mod-2) unerwartet abgewiesen: ${err.message.trim()}`;
|
|
}
|
|
report(
|
|
results,
|
|
'aktivierung-eindeutigkeit-traegt-den-mandanten-keine-unsichtbare-kollision',
|
|
ownActivationInsertSucceeded,
|
|
ownActivationInsertDetail,
|
|
);
|
|
|
|
// 13: freigabe-eindeutigkeitsindizes-fuehren-mit-der-mandantenkennung —
|
|
// Textmessung statt Datenbankmessung.
|
|
const groupIndexLeadsWithTenant = /ON "ModuleGrant"\("tenantId",\s*"moduleId",\s*"groupId"\)/.test(
|
|
grantGroupUniqueIndexSql,
|
|
);
|
|
const userIndexLeadsWithTenant = /ON "ModuleGrant"\("tenantId",\s*"moduleId",\s*"userId"\)/.test(
|
|
grantUserUniqueIndexSql,
|
|
);
|
|
report(
|
|
results,
|
|
'freigabe-eindeutigkeitsindizes-fuehren-mit-der-mandantenkennung',
|
|
groupIndexLeadsWithTenant && userIndexLeadsWithTenant,
|
|
`aus 20260804130130_add_groups_and_module_grants extrahiert: ${JSON.stringify(grantGroupUniqueIndexSql)} und ${JSON.stringify(grantUserUniqueIndexSql)} — beide partiellen Eindeutigkeitsindizes auf "ModuleGrant" fuehren mit der Mandantenkennung, dieselbe Entlastung wie Pruefung 12, hier fuer die Freigabetabelle`,
|
|
);
|
|
} finally {
|
|
await prisma.$disconnect();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Aufgabe 1 (260910-krx) — misst die dreizehn im Plan genannten
|
|
* Verhaltensweisen des Bereichs `dashboard` unter der Rolle ohne BYPASSRLS,
|
|
* mit den drei Policies fuer "DashboardLayout", "WidgetInstance" und
|
|
* "SearchProvider" WORTGLEICH aus der ausgelieferten
|
|
* *_rls_remaining_tenant_tables-Migration geschnitten (nicht im Werkzeug
|
|
* nachgetippt). Findet die Extraktion eine der drei nicht, meldet dieser
|
|
* Abschnitt eine FEHLGESCHLAGENE Pruefung und bricht ab, statt mit einer
|
|
* geratenen Regel weiterzumessen — wie alle vorherigen Abschnitte.
|
|
*
|
|
* Legt die Tabellen "DashboardLayout" und "WidgetInstance" selbst neu an
|
|
* (bisher von keinem Abschnitt gebraucht). Die Tabelle "SearchProvider"
|
|
* dagegen wird von runSearchProviderAreaChecks() bereits angelegt, samt
|
|
* eingeschaltetem und erzwungenem Zeilenschutz, der unveraendert strengen
|
|
* Regel und der einen mandantenlosen Zeile 'search-tenantless' — dieser
|
|
* Abschnitt legt sie NICHT ein zweites Mal an, sondern ERGAENZT nur weitere
|
|
* Zeilen. Muss deshalb NACH runSearchProviderAreaChecks() laufen (in main()
|
|
* bereits der Fall: runSearchProviderAreaChecks() steht deutlich frueher in
|
|
* der Aufrufkette) und VOR runTransactionShapeMeasurement(), das weiterhin
|
|
* auf der von runGroupsAreaChecks() angelegten Tabelle "Group" aufsetzt —
|
|
* dieser Abschnitt aendert daran nichts. Die bestehende Pruefung
|
|
* `searchprovider-mandantenlose-zeile-bleibt-unter-jedem-kontext-unsichtbar`
|
|
* und ihre Testzeile ('search-tenantless') bleiben unveraendert; alle hier
|
|
* neu vergebenen Kennungen sind eigene, damit sie nicht kollidieren.
|
|
*
|
|
* "DashboardLayout" bildet die Eindeutigkeitsbedingung des Schemas
|
|
* (`"userId" text UNIQUE`) nach, weil Pruefung 5 (die Konfliktmessung) ohne
|
|
* sie nicht stattfinden kann.
|
|
*/
|
|
async function runDashboardAreaChecks(adminUrl, scratchRoleUrl, results) {
|
|
const remainingMigrationSql = readRemainingTenantTablesMigrationSql();
|
|
|
|
const dashboardLayoutPolicy = remainingMigrationSql
|
|
? extractPolicySql(remainingMigrationSql, 'DashboardLayout')
|
|
: null;
|
|
const widgetInstancePolicy = remainingMigrationSql
|
|
? extractPolicySql(remainingMigrationSql, 'WidgetInstance')
|
|
: null;
|
|
const searchProviderPolicy = remainingMigrationSql
|
|
? extractPolicySql(remainingMigrationSql, 'SearchProvider')
|
|
: null;
|
|
|
|
if (!dashboardLayoutPolicy || !widgetInstancePolicy || !searchProviderPolicy) {
|
|
report(
|
|
results,
|
|
'dashboard-policies-aus-migration-gefunden',
|
|
false,
|
|
'CREATE POLICY fuer "DashboardLayout", "WidgetInstance" und/oder "SearchProvider" nicht in der ausgelieferten *_rls_remaining_tenant_tables-Migration gefunden',
|
|
);
|
|
return;
|
|
}
|
|
|
|
await withAdminPrisma(urlForDatabase(adminUrl, SCRATCH_DB_NAME).toString(), async (db) => {
|
|
await db.$executeRawUnsafe(`
|
|
CREATE TABLE "DashboardLayout" (
|
|
id text PRIMARY KEY,
|
|
"userId" text NOT NULL UNIQUE,
|
|
"tenantId" text NOT NULL,
|
|
layouts jsonb NOT NULL DEFAULT '{}'::jsonb,
|
|
"createdAt" timestamp(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
|
"updatedAt" timestamp(3) NOT NULL DEFAULT CURRENT_TIMESTAMP
|
|
);
|
|
`);
|
|
await db.$executeRawUnsafe(`
|
|
CREATE TABLE "WidgetInstance" (
|
|
id text PRIMARY KEY,
|
|
"userId" text NOT NULL,
|
|
"tenantId" text NOT NULL,
|
|
"widgetType" text NOT NULL
|
|
);
|
|
`);
|
|
|
|
for (const table of ['DashboardLayout', 'WidgetInstance']) {
|
|
await db.$executeRawUnsafe(`ALTER TABLE "${table}" ENABLE ROW LEVEL SECURITY;`);
|
|
await db.$executeRawUnsafe(`ALTER TABLE "${table}" FORCE ROW LEVEL SECURITY;`);
|
|
}
|
|
await db.$executeRawUnsafe(dashboardLayoutPolicy);
|
|
await db.$executeRawUnsafe(widgetInstancePolicy);
|
|
|
|
for (const table of ['DashboardLayout', 'WidgetInstance']) {
|
|
await db.$executeRawUnsafe(
|
|
`GRANT SELECT, INSERT, UPDATE, DELETE ON "${table}" TO ${SCRATCH_ROLE_NAME}`,
|
|
);
|
|
}
|
|
|
|
// Zwei Zeilen unter TENANT-A mit VERSCHIEDENEN Benutzerkennungen (Befund
|
|
// G: die Regel kennt keine Benutzerdimension) plus eine Zeile unter
|
|
// TENANT-B fuer die Mandantengrenze.
|
|
await db.$executeRawUnsafe(`
|
|
INSERT INTO "DashboardLayout" (id, "userId", "tenantId", layouts) VALUES
|
|
('layout-a1', 'user-a1', 'TENANT-A', '{}'::jsonb),
|
|
('layout-a2', 'user-a2', 'TENANT-A', '{}'::jsonb),
|
|
('layout-b1', 'user-b1', 'TENANT-B', '{}'::jsonb);
|
|
`);
|
|
// Physisch vorhandene, unter TENANT-A unsichtbare Zeile fuer Pruefung 5
|
|
// (die Konfliktmessung) — ueber die Wartungsrolle angelegt, weil sich
|
|
// eine mandantenfremde Zeile unter der Anwendungsrolle ohnehin nicht
|
|
// schreiben liesse.
|
|
await db.$executeRawUnsafe(`
|
|
INSERT INTO "DashboardLayout" (id, "userId", "tenantId", layouts) VALUES
|
|
('layout-conflict-target', 'user-conflict', 'TENANT-B', '{}'::jsonb);
|
|
`);
|
|
|
|
await db.$executeRawUnsafe(`
|
|
INSERT INTO "WidgetInstance" (id, "userId", "tenantId", "widgetType") VALUES
|
|
('widget-a1', 'user-a1', 'TENANT-A', 'clock'),
|
|
('widget-a2', 'user-a2', 'TENANT-A', 'search'),
|
|
('widget-b1', 'user-b1', 'TENANT-B', 'clock');
|
|
`);
|
|
|
|
// Weitere Zeilen auf der bereits vorhandenen Tabelle "SearchProvider"
|
|
// (runSearchProviderAreaChecks) — eigene Kennungen, die bestehende Zeile
|
|
// 'search-tenantless' bleibt unberuehrt.
|
|
await db.$executeRawUnsafe(`
|
|
INSERT INTO "SearchProvider" (id, "userId", "tenantId", name) VALUES
|
|
('search-a1', 'user-a1', 'TENANT-A', 'Interne Suche A1'),
|
|
('search-a2', 'user-a2', 'TENANT-A', 'Interne Suche A2'),
|
|
('search-b1', 'user-b1', 'TENANT-B', 'Interne Suche B1');
|
|
`);
|
|
});
|
|
|
|
const prisma = new PrismaClient({ datasourceUrl: scratchRoleUrl });
|
|
try {
|
|
// 1 + 3: dashboardlayout-gebunden-nur-eigener-mandant UND
|
|
// dashboardlayout-fremder-nutzer-desselben-mandanten-gebunden-sichtbar —
|
|
// eine Abfrage, zwei Aussagen. Die Pruefung 3 bestehen zu lassen IST das
|
|
// erwartete Ergebnis: die Regel kennt keine Benutzerdimension.
|
|
const layoutRowsForA = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
|
|
tx.$queryRaw`SELECT id, "userId", "tenantId" FROM "DashboardLayout" ORDER BY id`,
|
|
);
|
|
report(
|
|
results,
|
|
'dashboardlayout-gebunden-nur-eigener-mandant',
|
|
layoutRowsForA.length === 2 && layoutRowsForA.every((r) => r.tenantId === 'TENANT-A'),
|
|
`forTenant(TENANT-A) liefert ${layoutRowsForA.length} Zeile(n): ${JSON.stringify(layoutRowsForA.map((r) => r.id))}`,
|
|
);
|
|
const secondUserVisible = layoutRowsForA.some((r) => r.userId === 'user-a2');
|
|
report(
|
|
results,
|
|
'dashboardlayout-fremder-nutzer-desselben-mandanten-gebunden-sichtbar',
|
|
secondUserVisible,
|
|
`forTenant(TENANT-A) liefert die Anordnung von 'user-a2' (anderer Benutzer, gleicher Mandant) mit: ${secondUserVisible} — die Regel auf "DashboardLayout" kennt keine Benutzerdimension, die anwendungsseitige Pruefung ueber die Benutzerkennung bleibt deshalb der einzige Schutz gegen Quer-Lesen zwischen Nutzern DESSELBEN Mandanten`,
|
|
);
|
|
|
|
// 2: dashboardlayout-ungebunden-null-zeilen — die Belegzeile dieses
|
|
// Abschnitts.
|
|
const unboundLayoutRows = await prisma.$queryRaw`SELECT "tenantId" FROM "DashboardLayout"`;
|
|
report(
|
|
results,
|
|
'dashboardlayout-ungebunden-null-zeilen',
|
|
unboundLayoutRows.length === 0,
|
|
`ungebundener SELECT auf "DashboardLayout" liefert ${unboundLayoutRows.length} Zeile(n), tatsaechlich vorhanden sind 4`,
|
|
);
|
|
|
|
// 4 + 13: widgetinstance-ungebunden-null-zeilen und
|
|
// widgetinstance-gebunden-nur-eigener-mandant / -fremder-nutzer-...
|
|
const unboundWidgetRows = await prisma.$queryRaw`SELECT "tenantId" FROM "WidgetInstance"`;
|
|
report(
|
|
results,
|
|
'widgetinstance-ungebunden-null-zeilen',
|
|
unboundWidgetRows.length === 0,
|
|
`ungebundener SELECT auf "WidgetInstance" liefert ${unboundWidgetRows.length} Zeile(n), tatsaechlich vorhanden sind 3`,
|
|
);
|
|
|
|
const widgetRowsForA = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
|
|
tx.$queryRaw`SELECT id, "userId", "tenantId" FROM "WidgetInstance" ORDER BY id`,
|
|
);
|
|
report(
|
|
results,
|
|
'widgetinstance-gebunden-nur-eigener-mandant',
|
|
widgetRowsForA.length === 2 && widgetRowsForA.every((r) => r.tenantId === 'TENANT-A'),
|
|
`forTenant(TENANT-A) liefert ${widgetRowsForA.length} Zeile(n): ${JSON.stringify(widgetRowsForA.map((r) => r.id))}`,
|
|
);
|
|
const widgetSecondUserVisible = widgetRowsForA.some((r) => r.userId === 'user-a2');
|
|
report(
|
|
results,
|
|
'widgetinstance-fremder-nutzer-desselben-mandanten-gebunden-sichtbar',
|
|
widgetSecondUserVisible,
|
|
`forTenant(TENANT-A) liefert das Widget von 'user-a2' (anderer Benutzer, gleicher Mandant) mit: ${widgetSecondUserVisible} — dieselbe fehlende Benutzerdimension wie bei "DashboardLayout" und "SearchProvider" (Befund G), der dritte der drei Faelle dieses Bereichs`,
|
|
);
|
|
|
|
// 5: dashboardlayout-gebundener-konfliktschreibvorgang-auf-unsichtbare-
|
|
// zeile-scheitert-laut — MISST, was ein gebundenes Einfuegen mit
|
|
// Konfliktbehandlung tut, wenn es auf eine physisch vorhandene, unter
|
|
// dem laufenden Mandanten unsichtbare Zeile trifft ('layout-conflict-
|
|
// target', TENANT-B). Bestanden ist diese Pruefung genau dann, wenn ein
|
|
// HARTER, benannter Fehler zurueckkommt — NICHT, wenn der Vorgang still
|
|
// gelingt, eine fremde Zeile aendert oder eine Dublette erzeugt. Das
|
|
// Ergebnis wird NICHT vorweggenommen: es haengt am Zusammenspiel von
|
|
// Eindeutigkeitsindex und Regel.
|
|
let conflictRejectedLoudly = false;
|
|
let conflictDetail = '';
|
|
try {
|
|
await forTenantQuery(
|
|
prisma,
|
|
'TENANT-A',
|
|
(tx) =>
|
|
tx.$executeRaw`INSERT INTO "DashboardLayout" (id, "userId", "tenantId", layouts) VALUES ('layout-conflict-attempt', 'user-conflict', 'TENANT-A', '{}'::jsonb) ON CONFLICT ("userId") DO UPDATE SET layouts = EXCLUDED.layouts`,
|
|
);
|
|
conflictDetail =
|
|
'gebundenes INSERT ... ON CONFLICT ("userId") DO UPDATE unter TENANT-A auf die unter TENANT-B physisch vorhandene, unsichtbare Zeile (user-conflict) ist NICHT fehlgeschlagen — still gelungen oder eine Dublette erzeugt';
|
|
} catch (err) {
|
|
conflictRejectedLoudly = true;
|
|
const sqlState = sqlStateOf(err);
|
|
conflictDetail = `gebundenes INSERT ... ON CONFLICT ("userId") DO UPDATE unter TENANT-A auf die unter TENANT-B physisch vorhandene, unsichtbare Zeile (user-conflict) scheitert LAUT mit SQLSTATE ${sqlState ?? 'unbekannt'}: ${err.message.trim()}`;
|
|
}
|
|
report(
|
|
results,
|
|
'dashboardlayout-gebundener-konfliktschreibvorgang-auf-unsichtbare-zeile-scheitert-laut',
|
|
conflictRejectedLoudly,
|
|
conflictDetail,
|
|
);
|
|
|
|
// 5b: dashboardlayout-gebundenes-upsert-auf-unsichtbare-zeile-wirft-unknown
|
|
//
|
|
// Pruefung 5 misst mit Roh-SQL, WAS die Datenbank tut (42501). Der
|
|
// Anwendungscode in `saveLayout` faengt aber nicht SQLSTATEs, sondern die
|
|
// Fehlerklasse, die der GENERIERTE Prisma-Client daraus macht — und die
|
|
// ist nicht dieselbe wie beim P2002-Fall der Bereiche `tenders`/`user`
|
|
// (`PrismaClientKnownRequestError`), sondern
|
|
// `PrismaClientUnknownRequestError`, weil die Regel den Schreibzugriff
|
|
// abweist, bevor eine Eindeutigkeit ueberhaupt geprueft wird. Genau
|
|
// DIESE Klasse muss `saveLayout` uebersetzen; eine Uebersetzung der
|
|
// falschen Klasse spraenge nie an.
|
|
//
|
|
// Diese Messung fehlte in der ersten Lieferung von 260910-krx — die
|
|
// Zusammenfassung berief sich auf eine nicht committete Ad-hoc-Messung.
|
|
// Vom Verifizierer gefunden, hier nachgereicht: derselbe Vorgang wie in
|
|
// Pruefung 5, aber ueber `bound.dashboardLayout.upsert(...)` auf dem
|
|
// gebundenen generierten Client, und gepruegt wird der KONSTRUKTORNAME
|
|
// des geworfenen Fehlers.
|
|
let upsertThrewUnknown = false;
|
|
let upsertDetail = '';
|
|
try {
|
|
const bound = buildInlineExtendedClient(prisma, 'TENANT-A');
|
|
await bound.dashboardLayout.upsert({
|
|
where: { userId: 'user-conflict' },
|
|
update: { layouts: {} },
|
|
create: {
|
|
id: 'layout-conflict-attempt-upsert',
|
|
userId: 'user-conflict',
|
|
tenantId: 'TENANT-A',
|
|
layouts: {},
|
|
},
|
|
});
|
|
upsertDetail =
|
|
'gebundenes dashboardLayout.upsert unter TENANT-A auf die unter TENANT-B unsichtbare Zeile (user-conflict) ist NICHT fehlgeschlagen';
|
|
} catch (err) {
|
|
const ctor = err?.constructor?.name ?? 'unbekannt';
|
|
upsertThrewUnknown = ctor === 'PrismaClientUnknownRequestError';
|
|
upsertDetail = `gebundenes dashboardLayout.upsert unter TENANT-A auf die unter TENANT-B unsichtbare Zeile wirft ${ctor}${err?.code ? ` (code ${err.code})` : ''} — saveLayout uebersetzt genau diese Klasse; ${upsertThrewUnknown ? 'stimmt mit dem Anwendungscode ueberein' : 'STIMMT NICHT mit dem Anwendungscode ueberein, die Uebersetzung in saveLayout spraenge nie an'}`;
|
|
}
|
|
report(
|
|
results,
|
|
'dashboardlayout-gebundenes-upsert-auf-unsichtbare-zeile-wirft-unknown',
|
|
upsertThrewUnknown,
|
|
upsertDetail,
|
|
);
|
|
|
|
// 6: widgetinstance-gebundenes-einfuegen-fremder-mandant-abgelehnt
|
|
let foreignWidgetInsertRejected = false;
|
|
let foreignWidgetInsertDetail = '';
|
|
try {
|
|
await forTenantQuery(
|
|
prisma,
|
|
'TENANT-A',
|
|
(tx) =>
|
|
tx.$executeRaw`INSERT INTO "WidgetInstance" (id, "userId", "tenantId", "widgetType") VALUES ('widget-rejected', 'user-a1', 'TENANT-B', 'clock')`,
|
|
);
|
|
foreignWidgetInsertDetail =
|
|
'gebundenes INSERT unter TENANT-A mit tenantId=TENANT-B ist NICHT fehlgeschlagen';
|
|
} catch (err) {
|
|
const sqlState = sqlStateOf(err);
|
|
foreignWidgetInsertRejected = sqlState === '42501';
|
|
foreignWidgetInsertDetail = `gebundenes INSERT unter TENANT-A mit tenantId=TENANT-B abgewiesen mit SQLSTATE ${sqlState ?? 'unbekannt'} (${err.message.trim()})`;
|
|
}
|
|
report(
|
|
results,
|
|
'widgetinstance-gebundenes-einfuegen-fremder-mandant-abgelehnt',
|
|
foreignWidgetInsertRejected,
|
|
foreignWidgetInsertDetail,
|
|
);
|
|
|
|
// 7: widgetinstance-gebundenes-loeschen-fremder-zeile-trifft-keine-zeile
|
|
// — die Datenbankseite von Befund D: ein gebundenes DELETE ueber die
|
|
// Kennung einer fremden Zeile (widget-b1, TENANT-B) entfernt nichts und
|
|
// meldet keinen Fehler.
|
|
const foreignWidgetDeleteAffected = await forTenantQuery(
|
|
prisma,
|
|
'TENANT-A',
|
|
(tx) => tx.$executeRaw`DELETE FROM "WidgetInstance" WHERE id = 'widget-b1'`,
|
|
);
|
|
report(
|
|
results,
|
|
'widgetinstance-gebundenes-loeschen-fremder-zeile-trifft-keine-zeile',
|
|
foreignWidgetDeleteAffected === 0,
|
|
`gebundenes DELETE unter TENANT-A ueber die Kennung 'widget-b1' (gehoert TENANT-B) trifft ${foreignWidgetDeleteAffected} Zeile(n) — die vorgeschaltete Besitzpruefung im Anwendungscode bleibt deshalb der einzige Schutz vor dem Scharfschalten`,
|
|
);
|
|
|
|
// 8 + 11: searchprovider-ungebunden-null-zeilen und
|
|
// searchprovider-gebunden-nur-eigener-mandant /
|
|
// -fremder-nutzer-desselben-mandanten-gebunden-sichtbar — gemessen
|
|
// gegen die neu hinzugefuegten Zeilen (search-a1/search-a2/search-b1),
|
|
// NICHT gegen 'search-tenantless' (bereits durch die bestehende
|
|
// Pruefung abgedeckt).
|
|
const actualSearchProviderCount = await withAdminPrisma(
|
|
urlForDatabase(adminUrl, SCRATCH_DB_NAME).toString(),
|
|
async (db) => {
|
|
const [row] = await db.$queryRaw`SELECT count(*)::int AS n FROM "SearchProvider"`;
|
|
return row.n;
|
|
},
|
|
);
|
|
const unboundSearchProviderRows = await prisma.$queryRaw`SELECT "tenantId" FROM "SearchProvider"`;
|
|
report(
|
|
results,
|
|
'searchprovider-ungebunden-null-zeilen',
|
|
unboundSearchProviderRows.length === 0,
|
|
`ungebundener SELECT auf "SearchProvider" liefert ${unboundSearchProviderRows.length} Zeile(n), tatsaechlich vorhanden sind ${actualSearchProviderCount}`,
|
|
);
|
|
|
|
const searchProviderRowsForA = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
|
|
tx.$queryRaw`SELECT id, "userId", "tenantId" FROM "SearchProvider" WHERE id IN ('search-a1', 'search-a2', 'search-b1') ORDER BY id`,
|
|
);
|
|
report(
|
|
results,
|
|
'searchprovider-gebunden-nur-eigener-mandant',
|
|
searchProviderRowsForA.length === 2 &&
|
|
searchProviderRowsForA.every((r) => r.tenantId === 'TENANT-A'),
|
|
`forTenant(TENANT-A) liefert ${searchProviderRowsForA.length} Zeile(n) aus den neu hinzugefuegten: ${JSON.stringify(searchProviderRowsForA.map((r) => r.id))}`,
|
|
);
|
|
const searchProviderSecondUserVisible = searchProviderRowsForA.some(
|
|
(r) => r.userId === 'user-a2',
|
|
);
|
|
report(
|
|
results,
|
|
'searchprovider-fremder-nutzer-desselben-mandanten-gebunden-sichtbar',
|
|
searchProviderSecondUserVisible,
|
|
`forTenant(TENANT-A) liefert die Suchmaschine von 'user-a2' (anderer Benutzer, gleicher Mandant) mit: ${searchProviderSecondUserVisible} — dieselbe fehlende Benutzerdimension wie bei "DashboardLayout" und "WidgetInstance" (Befund G)`,
|
|
);
|
|
|
|
// 12: searchprovider-gebundenes-einfuegen-ohne-mandant-abgelehnt — die
|
|
// Verteidigung der widerlegten Praemisse aus Befund F: selbst wenn ein
|
|
// kuenftiger Schreibweg es versuchte, kaeme er unter der
|
|
// Anwendungsrolle nicht durch, weil die Regel ohne eigene WITH-CHECK-
|
|
// Klausel die USING-Klausel dafuer wiederverwendet.
|
|
let searchProviderNoTenantInsertRejected = false;
|
|
let searchProviderNoTenantInsertDetail = '';
|
|
try {
|
|
await forTenantQuery(
|
|
prisma,
|
|
'TENANT-A',
|
|
(tx) =>
|
|
tx.$executeRaw`INSERT INTO "SearchProvider" (id, "userId", "tenantId", name) VALUES ('search-rejected-no-tenant', 'user-a1', NULL, 'Sollte abgewiesen werden')`,
|
|
);
|
|
searchProviderNoTenantInsertDetail =
|
|
'gebundenes INSERT unter TENANT-A mit tenantId=NULL ist NICHT fehlgeschlagen';
|
|
} catch (err) {
|
|
const sqlState = sqlStateOf(err);
|
|
searchProviderNoTenantInsertRejected = sqlState === '42501';
|
|
searchProviderNoTenantInsertDetail = `gebundenes INSERT unter TENANT-A mit tenantId=NULL abgewiesen mit SQLSTATE ${sqlState ?? 'unbekannt'} (${err.message.trim()})`;
|
|
}
|
|
report(
|
|
results,
|
|
'searchprovider-gebundenes-einfuegen-ohne-mandant-abgelehnt',
|
|
searchProviderNoTenantInsertRejected,
|
|
searchProviderNoTenantInsertDetail,
|
|
);
|
|
} finally {
|
|
await prisma.$disconnect();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Aufgabe 1 (260909-jts), TEIL 2 — misst, welche der drei Transaktionsformen
|
|
* den Mandantenkontext auf DERSELBEN Verbindung ueber alle Teilschritte
|
|
* traegt. Baut die Erweiterungsform aus prisma-tenant.extension.ts
|
|
* WORTGLEICH nach ($extends mit $allOperations, Array-Form von
|
|
* $transaction darin) statt ueber das vereinfachte forTenantQuery(), denn
|
|
* genau diese Erweiterungsschicht ist hier der Gegenstand der Messung.
|
|
*
|
|
* Setzt auf die Tabelle "Group" auf, die runGroupsAreaChecks() bereits
|
|
* angelegt und mit je einer Zeile fuer TENANT-A/TENANT-B befuellt hat.
|
|
*/
|
|
function buildInlineExtendedClient(prisma, tenantId) {
|
|
return prisma.$extends({
|
|
query: {
|
|
$allOperations({ args, query }) {
|
|
const setTenantContext = prisma.$executeRaw`SELECT set_config('app.current_tenant', ${tenantId}, true)`;
|
|
return prisma.$transaction([setTenantContext, query(args)]).then((res) => res[1]);
|
|
},
|
|
},
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Druckt die tatsaechlich beobachteten Werte einer Transaktionsform. Fliesst
|
|
* NICHT in die Pruefliste ein und beeinflusst den Rueckgabewert nicht — eine
|
|
* Form, die abbricht, ist ein Messergebnis und kein Werkzeugfehler.
|
|
*/
|
|
function beobachte(formName, payload) {
|
|
console.log(` [beobachtet] ${formName}: ${JSON.stringify(payload)}`);
|
|
}
|
|
|
|
/**
|
|
* Alle drei Bedingungen aus dem Plan: gleiche Verbindungskennung ueber
|
|
* beide Teilschritte, gelesener Mandantenkontext gleich TENANT-A in
|
|
* beiden Teilschritten, und der Lesezugriff liefert genau die eine Zeile
|
|
* von TENANT-A.
|
|
*/
|
|
function traegtKontextAufDerselbenVerbindung(step1, step2) {
|
|
return Boolean(
|
|
step1 &&
|
|
step2 &&
|
|
step1.pid === step2.pid &&
|
|
step1.t === 'TENANT-A' &&
|
|
step2.t === 'TENANT-A' &&
|
|
step2.rows === 1,
|
|
);
|
|
}
|
|
|
|
async function measureArrayFormOnBoundClient(scratchRoleUrl) {
|
|
const prisma = new PrismaClient({ datasourceUrl: scratchRoleUrl });
|
|
try {
|
|
const bound = buildInlineExtendedClient(prisma, 'TENANT-A');
|
|
const [step1Rows, step2Rows] = await bound.$transaction([
|
|
bound.$queryRaw`SELECT pg_backend_pid() AS pid, current_tenant_id() AS t`,
|
|
bound.$queryRaw`SELECT pg_backend_pid() AS pid, current_tenant_id() AS t, (SELECT count(*)::int FROM "Group") AS rows`,
|
|
]);
|
|
return { step1: step1Rows[0], step2: step2Rows[0] };
|
|
} finally {
|
|
await prisma.$disconnect();
|
|
}
|
|
}
|
|
|
|
async function measureInteractiveFormOnBoundClient(scratchRoleUrl) {
|
|
const prisma = new PrismaClient({ datasourceUrl: scratchRoleUrl });
|
|
try {
|
|
const bound = buildInlineExtendedClient(prisma, 'TENANT-A');
|
|
return await bound.$transaction(async (tx) => {
|
|
const step1Rows = await tx.$queryRaw`SELECT pg_backend_pid() AS pid, current_tenant_id() AS t`;
|
|
const step2Rows = await tx.$queryRaw`SELECT pg_backend_pid() AS pid, current_tenant_id() AS t, (SELECT count(*)::int FROM "Group") AS rows`;
|
|
return { step1: step1Rows[0], step2: step2Rows[0] };
|
|
});
|
|
} finally {
|
|
await prisma.$disconnect();
|
|
}
|
|
}
|
|
|
|
async function measureInteractiveFormOnUnboundClient(scratchRoleUrl) {
|
|
const prisma = new PrismaClient({ datasourceUrl: scratchRoleUrl });
|
|
const tenantId = 'TENANT-A';
|
|
try {
|
|
return await prisma.$transaction(async (tx) => {
|
|
const step1Rows = await tx.$queryRaw`SELECT pg_backend_pid() AS pid, set_config('app.current_tenant', ${tenantId}, true) AS applied, current_tenant_id() AS t`;
|
|
const step2Rows = await tx.$queryRaw`SELECT pg_backend_pid() AS pid, current_tenant_id() AS t, (SELECT count(*)::int FROM "Group") AS rows`;
|
|
return { step1: step1Rows[0], step2: step2Rows[0] };
|
|
});
|
|
} finally {
|
|
await prisma.$disconnect();
|
|
}
|
|
}
|
|
|
|
async function runTransactionShapeMeasurement(scratchRoleUrl, results) {
|
|
const forms = [
|
|
{ name: 'Form (i) — Array-Form auf gebundenem Client', fn: measureArrayFormOnBoundClient },
|
|
{
|
|
name: 'Form (ii) — interaktive Callback-Form auf gebundenem Client',
|
|
fn: measureInteractiveFormOnBoundClient,
|
|
},
|
|
{
|
|
name: 'Form (iii) — interaktive Callback-Form auf ungebundenem Client (set_config auf tx)',
|
|
fn: measureInteractiveFormOnUnboundClient,
|
|
},
|
|
];
|
|
|
|
const outcomes = [];
|
|
for (const form of forms) {
|
|
try {
|
|
const r = await form.fn(scratchRoleUrl);
|
|
beobachte(form.name, r);
|
|
outcomes.push({ name: form.name, passed: traegtKontextAufDerselbenVerbindung(r.step1, r.step2) });
|
|
} catch (err) {
|
|
beobachte(form.name, { abbruch: err.message });
|
|
outcomes.push({ name: form.name, passed: false });
|
|
}
|
|
}
|
|
|
|
const passedForms = outcomes.filter((o) => o.passed).map((o) => o.name);
|
|
const failedForms = outcomes.filter((o) => !o.passed).map((o) => o.name);
|
|
report(
|
|
results,
|
|
'mindestens-eine-transaktionsform-traegt-den-mandantenkontext',
|
|
passedForms.length > 0,
|
|
`bestanden: [${passedForms.join(' ; ')}] — nicht bestanden: [${failedForms.join(' ; ')}]`,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Ein einzelner Aufruf in Form (ii): interaktive Callback-Transaktion auf dem
|
|
* GEBUNDENEN Client. Liefert den im Inneren gelesenen Mandantenkontext.
|
|
*/
|
|
async function runOneBoundInteractive(prisma, tenantId) {
|
|
const bound = buildInlineExtendedClient(prisma, tenantId);
|
|
return bound.$transaction(async (tx) => {
|
|
const rows = await tx.$queryRaw`SELECT current_tenant_id() AS t`;
|
|
return rows[0]?.t;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Ein einzelner Aufruf in Form (iii): interaktive Callback-Transaktion auf dem
|
|
* UNGEBUNDENEN Client, set_config als erste Anweisung direkt auf tx.
|
|
*/
|
|
async function runOneUnboundInteractive(prisma, tenantId) {
|
|
return prisma.$transaction(async (tx) => {
|
|
await tx.$queryRaw`SELECT set_config('app.current_tenant', ${tenantId}, true)`;
|
|
const rows = await tx.$queryRaw`SELECT current_tenant_id() AS t`;
|
|
return rows[0]?.t;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Belastet eine Transaktionsform mit `parallelCount` gleichzeitigen Aufrufen,
|
|
* abwechselnd fuer TENANT-A und TENANT-B, ueber EINEN gemeinsamen Client —
|
|
* also aus demselben endlichen Verbindungsvorrat, so wie im Betrieb.
|
|
*
|
|
* Als Verletzung zaehlt beides: ein Aufruf, der einen fremden oder gar keinen
|
|
* Mandantenkontext sieht, UND ein Aufruf, der abbricht. Der Abbruch ist hier
|
|
* kein Werkzeugfehler, sondern das Messergebnis — genau deshalb wird er
|
|
* gefangen und gezaehlt statt nach oben durchgereicht.
|
|
*/
|
|
async function measureUnderLoad(scratchRoleUrl, runOne, parallelCount) {
|
|
const prisma = new PrismaClient({ datasourceUrl: scratchRoleUrl });
|
|
try {
|
|
const calls = Array.from({ length: parallelCount }, (_, i) => {
|
|
const tenantId = i % 2 === 0 ? 'TENANT-A' : 'TENANT-B';
|
|
return runOne(prisma, tenantId).then(
|
|
(seen) => (seen === tenantId ? null : `erwartet ${tenantId}, gesehen ${seen ?? 'NULL'}`),
|
|
(err) => `abbruch ${err.code ?? ''}: ${String(err.message).split('\n')[0]}`.trim(),
|
|
);
|
|
});
|
|
const verletzungen = (await Promise.all(calls)).filter(Boolean);
|
|
return {
|
|
aufrufe: parallelCount,
|
|
verletzungen: verletzungen.length,
|
|
beispiele: verletzungen.slice(0, 2),
|
|
};
|
|
} finally {
|
|
await prisma.$disconnect();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Die Lastprobe hinter der Entscheidung fuer Form (iii).
|
|
*
|
|
* Sie existierte zunaechst nur als Fliesstext im Kopf von
|
|
* `prisma-tenant.extension.ts` — eine Zahl, die eine Entscheidung trug, aber
|
|
* nicht nachvollziehbar war. Genau das Anti-Muster, das dieses Projekt sich
|
|
* selbst verboten hat. Deshalb steht sie jetzt hier.
|
|
*
|
|
* GEPRUEFT wird nur die Eigenschaft, auf die sich der Code stuetzt: die
|
|
* GEWAEHLTE Form ueberlebt Nebenlaeufigkeit ohne Verletzung. Das Verhalten von
|
|
* Form (ii) wird daneben BEOBACHTET und ausgedruckt, aber nicht gepruft —
|
|
* ob und ab welcher Last sie abbricht, haengt an Verbindungsvorrat und
|
|
* Maschine und taugt nicht als Bedingung fuer einen gruenen Lauf.
|
|
*/
|
|
async function runConcurrencyProbe(scratchRoleUrl, results) {
|
|
const PARALLEL = 40;
|
|
|
|
const formZwei = await measureUnderLoad(scratchRoleUrl, runOneBoundInteractive, PARALLEL);
|
|
beobachte(`Form (ii) unter ${PARALLEL} parallelen Aufrufen`, formZwei);
|
|
|
|
const formDrei = await measureUnderLoad(scratchRoleUrl, runOneUnboundInteractive, PARALLEL);
|
|
beobachte(`Form (iii) unter ${PARALLEL} parallelen Aufrufen`, formDrei);
|
|
|
|
report(
|
|
results,
|
|
'gewaehlte-transaktionsform-uebersteht-nebenlaeufigkeit',
|
|
formDrei.verletzungen === 0,
|
|
`Form (iii): ${formDrei.verletzungen} Verletzung(en) bei ${PARALLEL} parallelen Aufrufen` +
|
|
` — Form (ii) zum Vergleich, nicht gepruft: ${formZwei.verletzungen}` +
|
|
(formZwei.beispiele.length ? ` (z.B. ${formZwei.beispiele[0]})` : ''),
|
|
);
|
|
}
|
|
|
|
async function main() {
|
|
const adminUrl = parseAdminUrl();
|
|
const results = [];
|
|
|
|
console.log(`Richte Wegwerf-Datenbank "${SCRATCH_DB_NAME}" ein...`);
|
|
await setupScratchDatabase(adminUrl);
|
|
|
|
try {
|
|
const scratchRoleUrl = urlForDatabase(adminUrl, SCRATCH_DB_NAME);
|
|
scratchRoleUrl.username = SCRATCH_ROLE_NAME;
|
|
scratchRoleUrl.password = SCRATCH_ROLE_PASSWORD;
|
|
const scratchRoleUrlString = scratchRoleUrl.toString();
|
|
|
|
await runForTenantChecks(scratchRoleUrlString, results);
|
|
await runAuthLookupChecks(adminUrl, scratchRoleUrlString, results);
|
|
await runLdapAreaChecks(adminUrl, scratchRoleUrlString, results);
|
|
await runGroupsAreaChecks(adminUrl, scratchRoleUrlString, results);
|
|
await runTendersAreaChecks(adminUrl, scratchRoleUrlString, results);
|
|
await runSearchProviderAreaChecks(adminUrl, scratchRoleUrlString, results);
|
|
await runDkvAreaChecks(adminUrl, scratchRoleUrlString, results);
|
|
await runUserAreaChecks(adminUrl, scratchRoleUrlString, results);
|
|
await runModuleRegistryAreaChecks(adminUrl, scratchRoleUrlString, results);
|
|
await runDashboardAreaChecks(adminUrl, scratchRoleUrlString, results);
|
|
await runTransactionShapeMeasurement(scratchRoleUrlString, results);
|
|
await runConcurrencyProbe(scratchRoleUrlString, results);
|
|
} finally {
|
|
console.log(`Raeume Wegwerf-Datenbank "${SCRATCH_DB_NAME}" ab...`);
|
|
await teardownScratchDatabase(adminUrl);
|
|
}
|
|
|
|
const allPassed = results.every((r) => r.passed);
|
|
console.log(
|
|
allPassed
|
|
? `Alle ${results.length} Pruefungen bestanden.`
|
|
: `${results.filter((r) => !r.passed).length} von ${results.length} Pruefungen fehlgeschlagen.`,
|
|
);
|
|
process.exit(allPassed ? 0 : 1);
|
|
}
|
|
|
|
main().catch((err) => {
|
|
console.error('FEHLER beim Ausfuehren der Wegwerf-Pruefung:', err.message);
|
|
process.exit(1);
|
|
});
|