Basis: Certvia dev@a48c5fb als Fundament für Craftvia

Unveränderter Stand von certvia/dev (a48c5fb) plus Craftvia-Spezifikation
und Brandbook unter docs/craftvia/. ISMS-Module werden im Folgecommit entfernt.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

scripts/test-action-error.ts

@@ -0,0 +1,99 @@
+// Test der Error-Boundary `withActionErrors` (Sicherheitsbefund F-16).
+//
+// Prüft:
+//  1. Bei `ForbiddenError` wirft die Boundary nach außen die GENERISCHE Meldung
+//     ("Vorgang nicht möglich.") — kein Leak interner Details ("Fehlende
+//     Berechtigung: …").
+//  2. Intern wird der denied-Pfad genommen: ein Audit-Eintrag `action:"denied"`
+//     landet für Mandant + Entität in der DB.
+//  3. Ein generischer Fehler wird ebenfalls generisch gekappt, aber NICHT
+//     auditiert (keine Zugriffsverweigerung).
+//  4. Der Erfolgsfall reicht den Rückgabewert unverändert durch.
+//
+// Lauf: npx tsx scripts/test-action-error.ts
+// Nutzt die lokale Postgres-DB (wie test-tenant-isolation.ts); .env liegt im Worktree.
+
+import "dotenv/config";
+import { prisma } from "../src/server/db";
+import { withActionErrors, GENERIC_ACTION_ERROR } from "../src/server/action-error";
+import { ForbiddenError, type Permission } from "../src/server/rbac";
+
+let failures = 0;
+const ok = (cond: boolean, msg: string) => {
+  console.log(`${cond ? "✓" : "✗ FEHLER"} ${msg}`);
+  if (!cond) failures++;
+};
+
+const SLUG = "zz-actionerr-test";
+const ENTITY = "risk_ae_test";
+
+async function cleanup() {
+  const tenant = await prisma.tenant.findFirst({
+    where: { slug: SLUG },
+    select: { id: true },
+  });
+  if (tenant) {
+    await prisma.auditLog.deleteMany({ where: { tenantId: tenant.id } });
+    await prisma.tenant.deleteMany({ where: { id: tenant.id } });
+  }
+}
+
+async function main() {
+  await cleanup();
+  const tenant = await prisma.tenant.create({
+    data: { name: "AE-Test", slug: SLUG },
+  });
+  const ctx = { tenantId: tenant.id, actorId: undefined, entity: ENTITY };
+
+  // (1) + (2) ForbiddenError → generische Meldung + denied-Audit.
+  let outward = "";
+  try {
+    await withActionErrors(async () => {
+      throw new ForbiddenError("risk:write" as Permission);
+    }, ctx);
+  } catch (e) {
+    outward = e instanceof Error ? e.message : String(e);
+  }
+  ok(outward === GENERIC_ACTION_ERROR, `ForbiddenError → nach außen "${GENERIC_ACTION_ERROR}"`);
+  ok(
+    !/Fehlende Berechtigung/.test(outward),
+    "ForbiddenError → interne Meldung leakt NICHT nach außen",
+  );
+
+  const deniedRows = await prisma.auditLog.findMany({
+    where: { tenantId: tenant.id, entity: ENTITY, action: "denied" },
+  });
+  ok(deniedRows.length === 1, `denied-Audit geschrieben (gefunden: ${deniedRows.length})`);
+
+  // (3) Generischer Fehler → generisch gekappt, KEIN zusätzliches Audit.
+  let outward2 = "";
+  try {
+    await withActionErrors(async () => {
+      throw new Error("interne DB-Details XYZ");
+    }, ctx);
+  } catch (e) {
+    outward2 = e instanceof Error ? e.message : String(e);
+  }
+  ok(outward2 === GENERIC_ACTION_ERROR, "generischer Fehler → generisch gekappt");
+  ok(!/XYZ/.test(outward2), "generischer Fehler → interne Details leaken NICHT");
+  const afterRows = await prisma.auditLog.count({
+    where: { tenantId: tenant.id, entity: ENTITY, action: "denied" },
+  });
+  ok(afterRows === 1, `kein zusätzliches denied-Audit für generischen Fehler (weiterhin ${afterRows})`);
+
+  // (4) Erfolgsfall reicht Rückgabewert durch.
+  const result = await withActionErrors(async () => 42, ctx);
+  ok(result === 42, "Erfolgsfall → Rückgabewert unverändert durchgereicht");
+
+  await cleanup();
+
+  console.log(failures === 0 ? "\nOK" : `\nFEHLGESCHLAGEN (${failures})`);
+  await prisma.$disconnect();
+  process.exit(failures === 0 ? 0 : 1);
+}
+
+main().catch(async (e) => {
+  console.error(e);
+  await prisma.$disconnect();
+  process.exit(1);
+});