Merge branch 'main' into phase/029-handbuch

.env.example

@@ -60,6 +60,21 @@ SSHKV_BREAKGLASS_PASSWORD=
 # Zeitplan fuer den Abgleich aller Hosts (cron)
 SSHKV_SYNC_CRON=30 2 * * *
 
+# --- Syslog (optional, #027) ---------------------------------------------------
+# Jeder Protokolleintrag geht zusaetzlich als RFC-5424-Zeile an einen Syslog-Server – die
+# Kopie ausserhalb von sshkv. Ohne SSHKV_SYSLOG_HOST ist die Weiterleitung aus. Es gehen nur
+# Akteur, Aktion, Ergebnis, Host, Zielbenutzer, Fingerprint und Hash hinaus, nie Details/Diff.
+# Web und Worker protokollieren beide; beide brauchen die Variablen.
+# SSHKV_SYSLOG_HOST=syslog.intern
+# Standard 514
+# SSHKV_SYSLOG_PORT=514
+# udp (Standard) oder tcp (Oktettzaehlung nach RFC 6587)
+# SSHKV_SYSLOG_PROTOKOLL=udp
+# APP-NAME im Syslog-Kopf (Standard sshkv)
+# SSHKV_SYSLOG_APPNAME=sshkv
+# Facility (Standard authpriv; auch auth, daemon, user, local0 … local7)
+# SSHKV_SYSLOG_FACILITY=authpriv
+
 # --- Integrationstests (#011) ---------------------------------------------------
 # SSH-Testziele aus docker-compose.test.yml. Die Compose-Datei liest dieselben Variablen
 # fuer die Port-Bindung (host:port, nur 127.0.0.1).

docker-compose.yml

@@ -64,6 +64,12 @@ services:
       SSHKV_OIDC_GROUP_ADMIN: ${SSHKV_OIDC_GROUP_ADMIN:-sshkv-admins}
       SSHKV_OIDC_GROUP_OPERATOR: ${SSHKV_OIDC_GROUP_OPERATOR:-sshkv-operators}
       SSHKV_OIDC_GROUP_READER: ${SSHKV_OIDC_GROUP_READER:-sshkv-readers}
+      # Syslog-Kopie des Protokolls (#027) – optional, leer heisst aus.
+      SSHKV_SYSLOG_HOST: ${SSHKV_SYSLOG_HOST:-}
+      SSHKV_SYSLOG_PORT: ${SSHKV_SYSLOG_PORT:-514}
+      SSHKV_SYSLOG_PROTOKOLL: ${SSHKV_SYSLOG_PROTOKOLL:-udp}
+      SSHKV_SYSLOG_APPNAME: ${SSHKV_SYSLOG_APPNAME:-sshkv}
+      SSHKV_SYSLOG_FACILITY: ${SSHKV_SYSLOG_FACILITY:-authpriv}
     # Absichtlich KEIN Master-Key: eine Luecke im Webprozess allein entschluesselt keine
     # Private Keys. Nach aussen braucht er nur den OIDC-Anbieter.
     ports:
@@ -94,6 +100,12 @@ services:
       SSHKV_APP_SECRET: ${SSHKV_APP_SECRET}
       SSHKV_MASTER_KEY_FILE: /run/secrets/master_key
       SSHKV_SYNC_CRON: ${SSHKV_SYNC_CRON:-30 2 * * *}
+      # Syslog-Kopie des Protokolls (#027) – optional, leer heisst aus.
+      SSHKV_SYSLOG_HOST: ${SSHKV_SYSLOG_HOST:-}
+      SSHKV_SYSLOG_PORT: ${SSHKV_SYSLOG_PORT:-514}
+      SSHKV_SYSLOG_PROTOKOLL: ${SSHKV_SYSLOG_PROTOKOLL:-udp}
+      SSHKV_SYSLOG_APPNAME: ${SSHKV_SYSLOG_APPNAME:-sshkv}
+      SSHKV_SYSLOG_FACILITY: ${SSHKV_SYSLOG_FACILITY:-authpriv}
     secrets:
       - master_key
     # Der Worker braucht die Datenbank und den Weg zu den Hosts.

docs/issues/027-protokoll-ansicht.md

@@ -1,19 +1,40 @@
 # #027 Protokollansicht, CSV-Export, Syslog
-**Status:** offen
+**Status:** erledigt
 **Meilenstein:** v0.5.0
 **Labels:** ui, backend
-**Geschätzt:** 2 h   **Tatsächlich:** –
+**Geschätzt:** 2 h   **Tatsächlich:** 0 h 20 min
 
 ## Ziel
 Filterbare Ansicht, CSV, optionale Weiterleitung an Syslog.
 
 ## Aufgaben
-- [ ] wird zu Beginn der Phase verfeinert
+- [x] `/protokoll` statt Platzhalter, jede Rolle liest: Tabelle mit Zeitpunkt (TT.MM.JJJJ HH:MM:SS), Aktion (lesbar, farbig), Akteur, Host, Zielbenutzer, Fingerprint (gekürzt), Ergebnis; unter `md` Karten
+- [x] Zeile aufklappbar: Diff im Diff-Box-Stil, Details als Liste (Werte als JSON), Hash und Vorgänger-Hash
+- [x] Lesbare Texte für alle Aktionen in `src/lib/protokoll-aktionen.ts`, gruppiert (Anmeldung, Host-Key, Ausrollen, Schlüssel, Widerruf/Rotation, Zielkonto, Abgleich, Hosts, Personen und Vorlagen, Protokoll)
+- [x] Filter per GET: Zeitraum (Berliner Kalendertage), Aktionsgruppe, Akteur, Host, Ergebnis, Freitext (Fingerprint/Host/Benutzer)
+- [x] 50 je Seite, „Ältere laden“ hängt per Server Action an; Cursor über `id`, kein `OFFSET`; `?vor=<id>` als Einstieg
+- [x] Kopfzeile mit Anzahl und Syslog-Ziel; „Kette prüfen“ (Server Action) mit Ergebnis-Zwischenspeicher für 5 Minuten, Warnung mit Link auf die erste fehlerhafte ID
+- [x] CSV-Export `/api/protokoll.csv`: eigene Rechteprüfung, gleiche Filter, gestreamt in Stapeln zu 500, Formel-Entschärfung über `src/lib/csv.ts`, Export selbst als `protokoll.exportiert` protokolliert
+- [x] Kein Lösch-/Bearbeitungsweg; struktureller Test gegen `protokoll.update/delete…` und `UPDATE/DELETE/TRUNCATE "Protokoll"` in `src/`
+- [x] Syslog nach RFC 5424 (`src/lib/syslog.ts`, UDP oder TCP mit Oktettzählung, ohne neue Abhängigkeit), eingehängt in `protokollieren()` nach dem Schreiben
+- [x] `.env.example` und `docker-compose.yml` (web und worker) um `SSHKV_SYSLOG_*`
+- [x] Tests: Query/Cursor/Filter, CSV-Route, Kettenprüfung, Syslog (Format, Escaping, Länge, UDP-/TCP-Empfänger), Aktionstexte, Struktur; E2E `tests/e2e/protokoll.spec.ts`
+- [x] Screenshots `protokoll-desktop.png` und `protokoll-mobil.png`
 
 ## Akzeptanzkriterien
-- [ ] wird zu Beginn der Phase verfeinert
+- [x] Jede `aktion: "…"` im Quellcode hat einen lesbaren Text (Test)
+- [x] Filter und „Ältere laden“ liefern weder Lücken noch Doppelte, auch wenn zwischendurch Einträge dazukommen
+- [x] CSV ohne Sitzung → 403; Kopfzeile `id;zeitpunkt;akteur;aktion;…;hash`; große Protokolle werden in Stapeln gelesen
+- [x] Manipulierte Zeile → Warnung mit ID; unversehrte Kette → „Hash-Kette unversehrt“
+- [x] Ausgefallener Syslog-Server verhindert keine Aktion; Fehler höchstens einmal je Minute im Log
+- [x] 1440 und 390 px ohne Querscrollen
 
 ## Abhängigkeiten
 #005
 
 ## Notizen / Entscheidungen
+- **Kettenprüfung nur auf Knopfdruck, 5 Minuten zwischengespeichert (je Prozess).** `protokoll_kette_pruefen()` rechnet SHA-256 über jede Zeile und wächst linear mit dem Protokoll; beim bloßen Seitenaufruf wäre das bei 100 000 Einträgen spürbar. Gleichzeitige Klicks teilen sich eine laufende Prüfung. Ein Bruch wird selbst als `protokoll.kette_beschaedigt` (FEHLER) protokolliert, damit er auch beim Syslog ankommt.
+- **CSV gestreamt** über einen `ReadableStream` mit `pull`: je Stapel 500 Zeilen (Cursor über `id`), der nächste Stapel erst, wenn der Client den vorigen abgenommen hat. Der Exporteintrag wird vor dem ersten Byte geschrieben – scheitert er, gibt es keinen Export.
+- **IDs sind nicht lückenlos** (Spalten-Default und Trigger ziehen beide aus der Sequenz); Cursor und Tests verlassen sich nur auf die Ordnung.
+- **Syslog:** RFC 5424, SD-ID `sshkv@32473`, Parameter id/akteur/aktion/ergebnis/host/zielbenutzer/fingerprint/hash (escaped nach §6.3.3, Steuerzeichen ersetzt, je Wert ≤ 120 Byte, Zeile ≤ 2048 Byte), MSGID = Aktion, Severity ERFOLG=notice, VERWEIGERT=warning, FEHLER=err, Facility standardmäßig `authpriv` (`SSHKV_SYSLOG_FACILITY`). Diff und Details gehen nie hinaus. Fire-and-forget nach dem `create`; innerhalb einer Transaktion kann ein späterer Rollback eine Syslog-Zeile ohne Gegenstück hinterlassen – das ist die harmlosere Richtung (ihr Hash fehlt dann in der Kette).
+- `--ok` nur für erfolgreiche Aktionen, die etwas ändern; Anmeldungen, Abrufe und Export bleiben neutral, Fehler/Verweigert immer `--danger`.

scripts/screenshots.ts

@@ -49,6 +49,8 @@ const SEITEN: { name: string; pfad: string; oeffentlich?: boolean; folgen?: stri
     pfad: "/vorlagen",
     folgen: 'main a[aria-label="Deployment-Zugang bearbeiten"]',
   },
+  // Audit-Log (#027): unter md Karten statt Tabelle, die Seite darf nicht seitwaerts scrollen.
+  { name: "protokoll", pfad: "/protokoll" },
 ];
 
 const ANSICHTEN = [

src/app/(app)/protokoll/page.tsx

@@ -1,18 +1,202 @@
+import { Download, ScrollText, Search } from "lucide-react";
 import type { Metadata } from "next";
-import { Platzhalterseite } from "@/components/huelle/Platzhalterseite";
+import { KettenPruefung } from "@/components/protokoll/KettenPruefung";
+import { ProtokollListe } from "@/components/protokoll/ProtokollListe";
+import { Button, buttonKlassen } from "@/components/ui/Button";
+import { Auswahlliste, Feld } from "@/components/ui/Feld";
+import { Karte } from "@/components/ui/Karte";
+import { Leerzustand } from "@/components/ui/Leerzustand";
+import { Seitenkopf } from "@/components/ui/Seitenkopf";
+import { AKTIONSGRUPPEN } from "@/lib/protokoll-aktionen";
+import {
+  cursorAus,
+  ERGEBNIS_TEXT,
+  protokollFilterAktiv,
+  protokollFilterAus,
+  protokollFilterQuery,
+} from "@/lib/protokoll-filter";
+import { syslogZielText } from "@/lib/syslog";
 import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
+import { protokollAkteure, protokollSeite, protokollZaehlen } from "@/server/queries/protokoll";
+import { ketteZwischengespeichert, syslogKonfig } from "@/server/services/protokoll";
 
 export const metadata: Metadata = { title: "Audit-Log" };
 
-export default async function Protokoll() {
+type Suchparameter = Promise<Record<string, string | string[] | undefined>>;
+
+/**
+ * Audit-Log (#027): jede Rolle darf lesen. Filter per GET, damit Links, „ältere laden“ und
+ * der CSV-Export denselben Ausschnitt meinen. Es gibt hier bewusst keinen Knopf, der einen
+ * Eintrag aendert oder loescht.
+ */
+export default async function Protokoll({ searchParams }: { searchParams: Suchparameter }) {
   // Jede Seite prueft selbst; die Huelle ist nur das zweite Netz (CLAUDE.md).
-  await sitzungErforderlich();
+  await sitzungErforderlich("lesen", "/protokoll");
+  const parameter = await searchParams;
+  const filter = protokollFilterAus(parameter);
+  const vor = cursorAus(parameter["vor"]);
+  const [seite, zaehler, akteure] = await Promise.all([
+    protokollSeite(filter, vor),
+    protokollZaehlen(filter),
+    protokollAkteure(),
+  ]);
+  const gefiltert = protokollFilterAktiv(filter);
+  const query = protokollFilterQuery(filter);
+  const kette = ketteZwischengespeichert();
+  const syslog = syslogKonfig();
+
   return (
-    <Platzhalterseite
+    <div className="flex min-w-0 flex-col gap-6 sm:gap-7">
+      <Seitenkopf
         titel="Audit-Log"
-      untertitel="Lückenloses, verkettetes Protokoll aller Aktionen"
+        untertitel="Lückenloses, verkettetes Protokoll aller Aktionen – nur lesbar, nicht änderbar"
-      phase={5}
+        aktionen={
-      issue="#027"
+          <a href={`/api/protokoll.csv${query}`} download className={buttonKlassen("sekundaer")}>
+            <Download className="size-4" aria-hidden />
+            CSV exportieren
+          </a>
+        }
       />
+
+      <Karte innen="ohne" className="divide-border divide-y">
+        <div className="flex flex-wrap items-baseline gap-x-6 gap-y-1 px-5 py-4 sm:px-6">
+          <p className="text-[14px]">
+            <span className="font-display text-text text-[22px] font-semibold tabular-nums">
+              {zaehler.gesamt.toLocaleString("de-DE")}
+            </span>{" "}
+            <span className="text-muted">Einträge insgesamt</span>
+          </p>
+          {gefiltert && (
+            <p className="text-muted text-[14px]">
+              <span className="text-text font-medium tabular-nums">
+                {zaehler.treffer.toLocaleString("de-DE")}
+              </span>{" "}
+              passen zum Filter
+            </p>
+          )}
+          <p className="text-muted text-[13px] sm:ml-auto">
+            Syslog:{" "}
+            {syslog ? (
+              <span className="text-text font-mono">{syslogZielText(syslog)}</span>
+            ) : (
+              <span>nicht eingerichtet</span>
+            )}
+          </p>
+        </div>
+        <div className="px-5 py-4 sm:px-6">
+          <KettenPruefung
+            anfang={
+              kette
+                ? {
+                    fehlerhafteId: kette.fehlerhafteId,
+                    eintraege: kette.eintraege,
+                    geprueftAm: kette.geprueftAm.toISOString(),
+                  }
+                : null
+            }
+          />
+        </div>
+      </Karte>
+
+      <form method="get" role="search" className="grid grid-cols-2 items-end gap-3 lg:grid-cols-4">
+        <Feld
+          beschriftung="Suche"
+          name="q"
+          type="search"
+          defaultValue={filter.q}
+          placeholder="Fingerprint, Host oder Benutzer"
+          autoComplete="off"
+          spellCheck={false}
+          className="col-span-2"
+        />
+        <Feld
+          beschriftung="Host"
+          name="host"
+          defaultValue={filter.host}
+          placeholder="z. B. srv-pve01"
+          autoComplete="off"
+          spellCheck={false}
+          mono
+          className="col-span-2 sm:col-span-1"
+        />
+        <Auswahlliste
+          beschriftung="Akteur"
+          name="akteur"
+          defaultValue={filter.akteur}
+          className="col-span-2 sm:col-span-1"
+        >
+          <option value="">Alle</option>
+          {/* Ein gefilterter Name, der nicht mehr unter den haeufigsten ist, bleibt waehlbar. */}
+          {[...new Set([...akteure, ...(filter.akteur ? [filter.akteur] : [])])].map((name) => (
+            <option key={name} value={name}>
+              {name}
+            </option>
+          ))}
+        </Auswahlliste>
+        <Auswahlliste beschriftung="Aktion" name="gruppe" defaultValue={filter.gruppe}>
+          <option value="">Alle Aktionen</option>
+          {Object.entries(AKTIONSGRUPPEN).map(([wert, text]) => (
+            <option key={wert} value={wert}>
+              {text}
+            </option>
+          ))}
+        </Auswahlliste>
+        <Auswahlliste beschriftung="Ergebnis" name="ergebnis" defaultValue={filter.ergebnis}>
+          <option value="">Alle</option>
+          {Object.entries(ERGEBNIS_TEXT).map(([wert, text]) => (
+            <option key={wert} value={wert}>
+              {text}
+            </option>
+          ))}
+        </Auswahlliste>
+        <Feld beschriftung="Von" name="von" type="date" defaultValue={filter.von} />
+        <Feld beschriftung="Bis" name="bis" type="date" defaultValue={filter.bis} />
+        <div className="col-span-2 flex gap-2.5 sm:justify-end lg:col-span-4">
+          <Button type="submit" icon={<Search className="size-4" />} className="flex-1 sm:flex-none">
+            Filtern
+          </Button>
+          {gefiltert && (
+            <Button href="/protokoll" className="flex-1 sm:flex-none">
+              Zurücksetzen
+            </Button>
+          )}
+        </div>
+      </form>
+
+      {vor !== undefined && (
+        <p className="text-muted text-[14px]">
+          Einträge älter als #{String(vor)}.{" "}
+          <a href={`/protokoll${query}`} className="text-accent underline-offset-2 hover:underline">
+            Zu den neuesten
+          </a>
+        </p>
+      )}
+
+      {seite.zeilen.length === 0 ? (
+        gefiltert ? (
+          <Leerzustand
+            icon={<Search className="size-5" />}
+            titel="Keine Treffer"
+            text="Kein Eintrag passt zu Suche und Filter."
+            aktion={<Button href="/protokoll">Filter zurücksetzen</Button>}
+          />
+        ) : (
+          <Leerzustand
+            icon={<ScrollText className="size-5" />}
+            titel="Noch keine Einträge"
+            text="Sobald jemand sich anmeldet oder etwas ändert, steht es hier."
+          />
+        )
+      ) : (
+        <Karte>
+          {/* key: neue Filter oder ein neuer Cursor beginnen eine frische Liste. */}
+          <ProtokollListe
+            key={`${query}|${String(vor ?? "")}`}
+            seite={seite}
+            query={query.replace(/^\?/, "")}
+          />
+        </Karte>
+      )}
+    </div>
   );
 }

src/app/api/protokoll.csv/route.ts

@@ -0,0 +1,69 @@
+import { NextResponse } from "next/server";
+import { CSV_BOM, csvZeile } from "@/lib/csv";
+import { PROTOKOLL_CSV_KOPF, protokollCsvWerte, protokollFilterAus } from "@/lib/protokoll-filter";
+import { RechteFehler, rechtErforderlich } from "@/server/auth/sitzungspflicht";
+import { protokollStapelweise } from "@/server/queries/protokoll";
+import { protokollieren } from "@/server/services/protokoll";
+
+/**
+ * Protokoll als CSV (#027) mit denselben Filtern wie die Seite. Jede Rolle darf lesen; der
+ * Handler prueft das selbst.
+ *
+ * Gestreamt: die Datenbank liefert Stapel zu 500 Zeilen, jeder Stapel geht sofort hinaus.
+ * Ein Protokoll mit Hunderttausenden Eintraegen muss so nie ganz in den Speicher.
+ */
+export async function GET(anfrage: Request) {
+  let benutzer;
+  try {
+    ({ benutzer } = await rechtErforderlich("lesen"));
+  } catch (fehler) {
+    if (fehler instanceof RechteFehler) return NextResponse.json({ fehler: fehler.message }, { status: 403 });
+    throw fehler;
+  }
+  const filter = protokollFilterAus(Object.fromEntries(new URL(anfrage.url).searchParams));
+
+  // Vor dem ersten Byte: wer das Protokoll mitnimmt, steht selbst darin – und scheitert das
+  // Schreiben, gibt es auch keinen Export.
+  await protokollieren({
+    akteur: { id: benutzer.id, name: benutzer.name },
+    aktion: "protokoll.exportiert",
+    ergebnis: "ERFOLG",
+    details: { filter: Object.fromEntries(Object.entries(filter).filter(([, wert]) => wert)) },
+  });
+
+  const kodierer = new TextEncoder();
+  const stapel = protokollStapelweise(filter);
+  const strom = new ReadableStream<Uint8Array>({
+    start(steuerung) {
+      steuerung.enqueue(kodierer.encode(CSV_BOM + csvZeile(PROTOKOLL_CSV_KOPF) + "\r\n"));
+    },
+    // pull statt Schleife in start: der naechste Stapel wird erst gelesen, wenn der Client
+    // den vorigen abgenommen hat (Gegendruck).
+    async pull(steuerung) {
+      try {
+        const { value, done } = await stapel.next();
+        if (done) {
+          steuerung.close();
+          return;
+        }
+        steuerung.enqueue(
+          kodierer.encode(value.map((z) => csvZeile(protokollCsvWerte(z)) + "\r\n").join("")),
+        );
+      } catch (fehler) {
+        steuerung.error(fehler);
+      }
+    },
+    async cancel() {
+      await stapel.return(undefined);
+    },
+  });
+
+  const tag = new Date().toISOString().slice(0, 10);
+  return new NextResponse(strom, {
+    headers: {
+      "Content-Type": "text/csv; charset=utf-8",
+      "Content-Disposition": `attachment; filename="sshkv-protokoll-${tag}.csv"`,
+      "Cache-Control": "no-store",
+    },
+  });
+}

src/components/protokoll/KettenPruefung.tsx

@@ -0,0 +1,81 @@
+"use client";
+
+import { ShieldAlert, ShieldCheck, ShieldQuestion } from "lucide-react";
+import { useState, useTransition } from "react";
+import { Button } from "@/components/ui/Button";
+import { uhrzeit } from "@/lib/format";
+import { kettePruefenAktion, type KettenAntwort } from "@/server/actions/protokoll";
+
+/**
+ * Integritaet der Hash-Kette (#027). Geprueft wird nur auf Knopfdruck – die Pruefung liest
+ * jede Zeile; ein Ergebnis der letzten 5 Minuten bringt die Seite schon mit.
+ */
+export function KettenPruefung({ anfang }: { anfang: KettenAntwort | null }) {
+  const [ergebnis, setErgebnis] = useState<KettenAntwort | null>(anfang);
+  const [laeuft, starten] = useTransition();
+
+  const pruefen = () =>
+    starten(async () => {
+      setErgebnis(await kettePruefenAktion());
+    });
+
+  return (
+    <div
+      className="flex min-w-0 flex-col gap-3 sm:flex-row sm:items-center sm:justify-between"
+      aria-live="polite"
+    >
+      <Status ergebnis={ergebnis} />
+      <Button onClick={pruefen} disabled={laeuft} klein className="self-start sm:self-auto">
+        {laeuft ? "Prüft …" : "Kette prüfen"}
+      </Button>
+    </div>
+  );
+}
+
+function Status({ ergebnis }: { ergebnis: KettenAntwort | null }) {
+  if (!ergebnis) {
+    return (
+      <p className="text-muted flex items-center gap-2 text-[14px]">
+        <ShieldQuestion aria-hidden className="size-4 shrink-0" />
+        Hash-Kette noch nicht geprüft
+      </p>
+    );
+  }
+  if (ergebnis.fehler) {
+    return <p className="text-danger text-[14px]">{ergebnis.fehler}</p>;
+  }
+  const wann = ergebnis.geprueftAm ? ` um ${uhrzeit(ergebnis.geprueftAm)} Uhr` : "";
+  if (!ergebnis.fehlerhafteId) {
+    return (
+      <p className="text-ok flex items-center gap-2 text-[14px] font-medium">
+        <ShieldCheck aria-hidden className="size-4 shrink-0" />
+        <span>
+          Hash-Kette unversehrt
+          <span className="text-muted font-normal">
+            {" "}
+            · {ergebnis.eintraege?.toLocaleString("de-DE")} Einträge geprüft{wann}
+          </span>
+        </span>
+      </p>
+    );
+  }
+  const id = ergebnis.fehlerhafteId;
+  // Die Seite beginnt beim fehlerhaften Eintrag, der Anker hebt ihn hervor.
+  const ziel = `/protokoll?vor=${(BigInt(id) + 1n).toString()}#eintrag-${id}`;
+  return (
+    <div
+      role="alert"
+      className="border-danger-border bg-danger-soft text-danger rounded-box flex min-w-0 items-start gap-2.5 border px-3 py-2.5 text-[14px]"
+    >
+      <ShieldAlert aria-hidden className="mt-0.5 size-4 shrink-0" />
+      <p className="min-w-0">
+        <strong className="font-semibold">Hash-Kette beschädigt.</strong> Der Eintrag{" "}
+        <a href={ziel} className="font-mono underline underline-offset-2">
+          #{id}
+        </a>{" "}
+        stimmt nicht mit seinem Hash oder Vorgänger überein – ab hier ist das Protokoll nicht mehr belegbar.
+        Vergleichen Sie mit der Syslog-Kopie und sichern Sie die Datenbank.{wann && ` Geprüft${wann}.`}
+      </p>
+    </div>
+  );
+}

src/components/protokoll/ProtokollListe.tsx

@@ -0,0 +1,246 @@
+"use client";
+
+import { clsx } from "clsx";
+import { ChevronDown, History } from "lucide-react";
+import { useState, useTransition } from "react";
+import { Badge, type BadgeVariante } from "@/components/ui/Badge";
+import { Button } from "@/components/ui/Button";
+import { DiffBox } from "@/components/ui/DiffBox";
+import { Tabelle, TabellenZeile, TabellenZelle } from "@/components/ui/Tabelle";
+import { aktionText, aktionTon, type AktionsTon } from "@/lib/protokoll-aktionen";
+import { diffZeilen, ERGEBNIS_TEXT, protokollZeit } from "@/lib/protokoll-filter";
+import { fingerprintKurz } from "@/lib/schluessel";
+import type { ProtokollSeite, ProtokollZeile } from "@/server/queries/protokoll";
+import { aeltereLadenAktion } from "@/server/actions/protokoll";
+
+const TON_FARBE: Record<AktionsTon, string> = { ok: "text-ok", gefahr: "text-danger", neutral: "text-text" };
+const ERGEBNIS_BADGE: Record<ProtokollZeile["ergebnis"], BadgeVariante> = {
+  ERFOLG: "neutral",
+  FEHLER: "gefahr",
+  VERWEIGERT: "gefahr",
+};
+
+/**
+ * Protokolleintraege als Tabelle (ab md) bzw. Karten (darunter), jede Zeile aufklappbar
+ * (#027). „Ältere laden“ haengt die naechste Seite an, statt die Liste zu ersetzen – wer
+ * eine Spur verfolgt, will das Neuere dabei nicht aus dem Blick verlieren.
+ */
+export function ProtokollListe({ seite, query }: { seite: ProtokollSeite; query: string }) {
+  const [zeilen, setZeilen] = useState(seite.zeilen);
+  const [weiterVor, setWeiterVor] = useState(seite.weiterVor);
+  const [offen, setOffen] = useState<ReadonlySet<string>>(new Set());
+  const [fehler, setFehler] = useState<string>();
+  const [laedt, starten] = useTransition();
+
+  const umschalten = (id: string) =>
+    setOffen((vorher) => {
+      const neu = new Set(vorher);
+      if (neu.has(id)) neu.delete(id);
+      else neu.add(id);
+      return neu;
+    });
+
+  const aeltereLaden = () => {
+    if (!weiterVor) return;
+    starten(async () => {
+      const antwort = await aeltereLadenAktion(query, weiterVor);
+      if ("fehler" in antwort) {
+        setFehler(antwort.fehler);
+        return;
+      }
+      setFehler(undefined);
+      setZeilen((vorher) => [...vorher, ...antwort.zeilen]);
+      setWeiterVor(antwort.weiterVor);
+    });
+  };
+
+  return (
+    <div className="flex min-w-0 flex-col gap-4">
+      {/* Unter md Karten statt der Tabelle: acht Spalten passen nicht auf 390 px. */}
+      <ul className="flex flex-col md:hidden" aria-label="Protokolleinträge">
+        {zeilen.map((z) => (
+          <li key={z.id} className="border-border border-b py-3 last:border-b-0">
+            <ZeileKompakt z={z} />
+            <details className="group mt-1">
+              <summary className="text-muted hover:text-text -mx-2 flex min-h-11 cursor-pointer list-none items-center gap-1.5 rounded-box px-2 text-[13px]">
+                <ChevronDown aria-hidden className="size-4 transition-transform group-open:rotate-180" />
+                Einzelheiten
+              </summary>
+              <Einzelheiten z={z} />
+            </details>
+          </li>
+        ))}
+      </ul>
+
+      <Tabelle
+        className="hidden md:block"
+        beschriftung="Protokolleinträge"
+        spalten={[
+          { titel: "Zeitpunkt" },
+          { titel: "Aktion" },
+          { titel: "Akteur" },
+          { titel: "Host" },
+          { titel: "Zielbenutzer" },
+          { titel: "Fingerprint" },
+          { titel: "Ergebnis" },
+          { titel: "Einzelheiten", versteckt: true, className: "w-12" },
+        ]}
+      >
+        {zeilen.map((z) => {
+          const istOffen = offen.has(z.id);
+          return <ZeilenPaar key={z.id} z={z} offen={istOffen} umschalten={() => umschalten(z.id)} />;
+        })}
+      </Tabelle>
+
+      {fehler && <p className="text-danger text-[13px]">{fehler}</p>}
+      {weiterVor && (
+        <div className="flex justify-center">
+          <Button onClick={aeltereLaden} disabled={laedt} icon={<History className="size-4" />}>
+            {laedt ? "Lädt …" : "Ältere laden"}
+          </Button>
+        </div>
+      )}
+    </div>
+  );
+}
+
+function AktionZelle({ z }: { z: ProtokollZeile }) {
+  return (
+    <span title={z.aktion} className={clsx("font-medium", TON_FARBE[aktionTon(z.aktion, z.ergebnis)])}>
+      {aktionText(z.aktion)}
+    </span>
+  );
+}
+
+function ErgebnisBadge({ ergebnis }: { ergebnis: ProtokollZeile["ergebnis"] }) {
+  return <Badge variante={ERGEBNIS_BADGE[ergebnis]}>{ERGEBNIS_TEXT[ergebnis]}</Badge>;
+}
+
+function ZeilenPaar({ z, offen, umschalten }: { z: ProtokollZeile; offen: boolean; umschalten: () => void }) {
+  const detailId = `eintrag-${z.id}-einzelheiten`;
+  return (
+    <>
+      <TabellenZeile className={clsx(offen && "border-b-0")}>
+        <TabellenZelle mono className="text-muted whitespace-nowrap">
+          {/* Anker fuer den Sprung aus der Kettenpruefung zur ersten fehlerhaften ID. */}
+          <span
+            id={`eintrag-${z.id}`}
+            className="target:text-danger target:outline-danger scroll-mt-24 target:outline target:outline-offset-4"
+          >
+            {protokollZeit(z.zeitpunkt)}
+          </span>
+        </TabellenZelle>
+        <TabellenZelle className="min-w-[12rem]">
+          <AktionZelle z={z} />
+        </TabellenZelle>
+        <TabellenZelle className="whitespace-nowrap">{z.akteurName}</TabellenZelle>
+        <TabellenZelle mono className="whitespace-nowrap">
+          {z.hostName ?? <Leer />}
+        </TabellenZelle>
+        <TabellenZelle mono className="whitespace-nowrap">
+          {z.zielbenutzer ?? <Leer />}
+        </TabellenZelle>
+        <TabellenZelle mono className="text-muted whitespace-nowrap">
+          {z.fingerprint ? <span title={z.fingerprint}>{fingerprintKurz(z.fingerprint)}</span> : <Leer />}
+        </TabellenZelle>
+        <TabellenZelle className="whitespace-nowrap">
+          <ErgebnisBadge ergebnis={z.ergebnis} />
+        </TabellenZelle>
+        <TabellenZelle rechts className="w-12">
+          <button
+            type="button"
+            onClick={umschalten}
+            aria-expanded={offen}
+            aria-controls={detailId}
+            aria-label={`Einzelheiten zu Eintrag ${z.id}`}
+            className="text-muted hover:text-text hover:bg-raised rounded-feld -my-2 inline-flex size-11 items-center justify-center transition-colors"
+          >
+            <ChevronDown aria-hidden className={clsx("size-4 transition-transform", offen && "rotate-180")} />
+          </button>
+        </TabellenZelle>
+      </TabellenZeile>
+      {offen && (
+        <tr id={detailId} className="border-border border-b last:border-b-0">
+          <td colSpan={8} className="pb-4">
+            <Einzelheiten z={z} />
+          </td>
+        </tr>
+      )}
+    </>
+  );
+}
+
+function Leer() {
+  return <span className="text-muted">–</span>;
+}
+
+/** Kopf einer Karte in der mobilen Ansicht. */
+function ZeileKompakt({ z }: { z: ProtokollZeile }) {
+  return (
+    <div className="flex min-w-0 flex-col gap-1.5">
+      <div className="flex items-center justify-between gap-3">
+        <span className="text-muted font-mono text-[12.5px]">{protokollZeit(z.zeitpunkt)}</span>
+        <ErgebnisBadge ergebnis={z.ergebnis} />
+      </div>
+      <span className="text-[14.5px] leading-snug">
+        <AktionZelle z={z} />
+      </span>
+      <span className="text-muted text-[13px] break-words">{z.akteurName}</span>
+      {(z.hostName || z.zielbenutzer) && (
+        <span className="text-text font-mono text-[12.5px] break-all">
+          {z.zielbenutzer ? `${z.zielbenutzer}@` : ""}
+          {z.hostName ?? "–"}
+        </span>
+      )}
+      {z.fingerprint && (
+        <span className="text-muted font-mono text-[12.5px] break-all">{fingerprintKurz(z.fingerprint)}</span>
+      )}
+    </div>
+  );
+}
+
+function Einzelheiten({ z }: { z: ProtokollZeile }) {
+  return (
+    <div className="bg-sidebar border-border rounded-box flex min-w-0 flex-col gap-4 border p-4">
+      <dl className="grid min-w-0 gap-x-4 gap-y-2 text-[13px] sm:grid-cols-[9rem_minmax(0,1fr)]">
+        <dt className="text-muted">ID</dt>
+        <dd className="font-mono">{z.id}</dd>
+        <dt className="text-muted">Aktion (technisch)</dt>
+        <dd className="font-mono break-all">{z.aktion}</dd>
+        {z.fingerprint && (
+          <>
+            <dt className="text-muted">Fingerprint</dt>
+            <dd className="font-mono break-all">{z.fingerprint}</dd>
+          </>
+        )}
+        <dt className="text-muted">Hash</dt>
+        <dd className="font-mono break-all" data-feld="hash">
+          {z.hash}
+        </dd>
+        <dt className="text-muted">Vorgänger-Hash</dt>
+        <dd className="font-mono break-all">{z.vorgaengerHash || "– (erster Eintrag)"}</dd>
+      </dl>
+
+      {z.diff && (
+        <section className="flex min-w-0 flex-col gap-2" aria-label="Diff">
+          <h3 className="text-muted text-[13px] font-medium">Diff</h3>
+          <DiffBox zeilen={diffZeilen(z.diff)} />
+        </section>
+      )}
+
+      {z.details && (
+        <section className="flex min-w-0 flex-col gap-2" aria-label="Details">
+          <h3 className="text-muted text-[13px] font-medium">Details</h3>
+          <dl className="border-border bg-bg rounded-box grid min-w-0 gap-x-4 gap-y-1.5 border p-3 text-[12.5px] sm:grid-cols-[minmax(0,12rem)_minmax(0,1fr)]">
+            {z.details.map((d) => (
+              <div key={d.name} className="contents">
+                <dt className="text-muted font-mono break-all">{d.name}</dt>
+                <dd className="text-text mb-1.5 font-mono break-all whitespace-pre-wrap sm:mb-0">{d.wert}</dd>
+              </div>
+            ))}
+          </dl>
+        </section>
+      )}
+    </div>
+  );
+}

src/lib/protokoll-aktionen.ts

@@ -0,0 +1,137 @@
+/**
+ * Lesbare Beschriftung der technischen Protokoll-Aktionen (#027).
+ *
+ * Das Protokoll speichert stabile Schluessel wie `authorized_keys.geschrieben`, damit sich
+ * Auswertungen (CSV, Syslog, SIEM) nicht an Oberflaechentexten aufhaengen. Die Ansicht
+ * uebersetzt sie hier. `tests/protokoll-aktionen.test.ts` sucht jede `aktion: "…"` im
+ * Quellcode und verlangt einen Eintrag – eine neue Aktion ohne Text faellt so sofort auf.
+ *
+ * `aendert`: Die Aktion veraendert etwas (Datei geschrieben, Schluessel erzeugt …) und wird bei
+ * Erfolg in --ok gezeigt. Lesende oder rein informative Aktionen (Anmeldung, Abruf, Export)
+ * bleiben neutral, damit das Grün die Stellen markiert, an denen sich etwas getan hat.
+ */
+
+export const AKTIONSGRUPPEN = {
+  anmeldung: "Anmeldung",
+  hostkey: "Host-Key",
+  ausrollen: "Ausrollen",
+  schluessel: "Schlüssel",
+  widerruf: "Widerruf/Rotation",
+  zielkonto: "Zielkonto",
+  abgleich: "Abgleich",
+  hosts: "Hosts",
+  stammdaten: "Personen und Vorlagen",
+  protokoll: "Protokoll",
+} as const;
+
+export type Aktionsgruppe = keyof typeof AKTIONSGRUPPEN;
+
+type Beschreibung = { readonly text: string; readonly gruppe: Aktionsgruppe; readonly aendert: boolean };
+
+const a = (text: string, gruppe: Aktionsgruppe, aendert = true): Beschreibung => ({ text, gruppe, aendert });
+
+export const AKTIONEN: Readonly<Record<string, Beschreibung>> = {
+  // Anmeldung und Bestaetigung (#004)
+  "anmeldung.oidc": a("Anmeldung (OIDC)", "anmeldung", false),
+  "anmeldung.oidc.erstmals": a("Erste Anmeldung (OIDC)", "anmeldung"),
+  "anmeldung.verweigert": a("Anmeldung verweigert", "anmeldung", false),
+  "anmeldung.notfall": a("Anmeldung Notfall-Admin", "anmeldung", false),
+  "anmeldung.notfall.fehlgeschlagen": a("Notfall-Anmeldung fehlgeschlagen", "anmeldung", false),
+  "anmeldung.notfall.gesperrt": a("Notfall-Anmeldung gesperrt", "anmeldung", false),
+  "anmeldung.notfall.totp_falsch": a("Notfall-Anmeldung: TOTP falsch", "anmeldung", false),
+  "bestaetigung.oidc": a("Anmeldung bestätigt (Re-Auth)", "anmeldung", false),
+  "notfall.totp_eingerichtet": a("TOTP für Notfall-Admin eingerichtet", "anmeldung"),
+
+  // Host-Keys (#009)
+  "hostkey.abgerufen": a("Host-Key abgerufen", "hostkey", false),
+  "hostkey.bestaetigt": a("Host-Key bestätigt", "hostkey"),
+  "hostkey.ersetzt": a("Host-Key ersetzt", "hostkey"),
+  "hostkey.abgelehnt": a("Host-Key abgelehnt", "hostkey"),
+  "hostkey.abweichung": a("Host-Key weicht ab – Verbindung abgebrochen", "hostkey", false),
+
+  // Ausrollen (#016, #017)
+  "authorized_keys.geschrieben": a("authorized_keys geschrieben", "ausrollen"),
+  "privatekey.ausgerollt": a("Private Key ausgerollt", "ausrollen"),
+  "verwendung.public.angelegt": a("Public Key zugewiesen", "ausrollen"),
+  "verwendung.public.entfernen": a("Public-Key-Zuweisung zum Entfernen vorgemerkt", "ausrollen"),
+  "verwendung.private.angelegt": a("Private Key zugewiesen", "ausrollen"),
+  "verwendung.private.entfernen": a("Private-Key-Zuweisung zum Entfernen vorgemerkt", "ausrollen"),
+
+  // Schluessel (#012, #013, #014)
+  "schluessel.erzeugt": a("Schlüssel erzeugt", "schluessel"),
+  "schluessel.importiert": a("Schlüssel importiert", "schluessel"),
+  "schluessel.uebernommen": a("Schlüssel vom Host übernommen", "schluessel"),
+  "schluessel.selbst_hinterlegt": a("Eigenen Public Key hinterlegt", "schluessel"),
+  "schluessel.selbst_entfernt": a("Eigenen Public Key entfernt", "schluessel"),
+  "schluessel.geaendert": a("Schlüssel geändert", "schluessel"),
+  "privatekey.angefordert": a("Private Key angefordert", "schluessel", false),
+  "privatekey.angezeigt": a("Private Key angezeigt", "schluessel", false),
+  "privatekey.heruntergeladen": a("Private Key heruntergeladen", "schluessel", false),
+  "privatekey.geloescht": a("Private Key gelöscht", "schluessel"),
+  "deploymentkey.erzeugt": a("Deployment-Key erzeugt", "schluessel"),
+
+  // Widerruf und Rotation (#023, #024)
+  "schluessel.widerruf.eingeleitet": a("Widerruf eingeleitet", "widerruf"),
+  "schluessel.widerrufen": a("Schlüssel widerrufen", "widerruf"),
+  "schluessel.rotiert": a("Schlüssel rotiert", "widerruf"),
+  "schluessel.rotation.uebernommen": a("Rotation: Zuweisungen übernommen", "widerruf"),
+
+  // Zielkonten (#018)
+  "zielkonto.angelegt": a("Zielkonto angelegt", "zielkonto"),
+  "zielkonto.geaendert": a("Zielkonto geändert", "zielkonto"),
+  "zielkonto.entfernt": a("Zielkonto entfernt", "zielkonto"),
+
+  // Abgleich und Uebernahme (#021, #022)
+  abgleich: a("Abgleich durchgeführt", "abgleich", false),
+  "uebernahme.verwalten": a("Fremden Key übernommen und verwaltet", "abgleich"),
+  "uebernahme.bekannt": a("Fremden Key als bekannt aufgenommen", "abgleich"),
+
+  // Hosts, Gruppen, Kunden (#008, #010)
+  "host.angelegt": a("Host angelegt", "hosts"),
+  "host.geaendert": a("Host geändert", "hosts"),
+  "host.archiviert": a("Host archiviert", "hosts"),
+  "host.bootstrap.angefordert": a("Einrichtung angefordert", "hosts", false),
+  "host.bootstrap": a("Host eingerichtet (Bootstrap)", "hosts"),
+  "host.bootstrap.geprueft": a("Einrichtung geprüft", "hosts"),
+  "hostgruppe.angelegt": a("Hostgruppe angelegt", "hosts"),
+  "hostgruppe.geaendert": a("Hostgruppe geändert", "hosts"),
+  "kunde.angelegt": a("Kunde angelegt", "hosts"),
+  verbindungstest: a("Verbindung geprüft", "hosts", false),
+
+  // Personen und Vorlagen (#013, #019)
+  "person.angelegt": a("Person angelegt", "stammdaten"),
+  "person.geaendert": a("Person geändert", "stammdaten"),
+  "person.archiviert": a("Person archiviert", "stammdaten"),
+  "person.verknuepft": a("Person mit Konto verknüpft", "stammdaten"),
+  "vorlage.angelegt": a("Vorlage angelegt", "stammdaten"),
+  "vorlage.geaendert": a("Vorlage geändert", "stammdaten"),
+  "vorlage.archiviert": a("Vorlage archiviert", "stammdaten"),
+
+  // Protokoll selbst (#027)
+  "protokoll.exportiert": a("Protokoll exportiert (CSV)", "protokoll", false),
+  "protokoll.kette_beschaedigt": a("Hash-Kette beschädigt gefunden", "protokoll", false),
+};
+
+/** Text zur Aktion; unbekannte (etwa aus aelteren Versionen) bleiben technisch lesbar. */
+export function aktionText(aktion: string): string {
+  return AKTIONEN[aktion]?.text ?? aktion;
+}
+
+/** Alle bekannten Aktionen einer Gruppe – Grundlage fuer den Filter `aktion IN (…)`. */
+export function aktionenDerGruppe(gruppe: Aktionsgruppe): string[] {
+  return Object.entries(AKTIONEN)
+    .filter(([, b]) => b.gruppe === gruppe)
+    .map(([aktion]) => aktion);
+}
+
+export type AktionsTon = "ok" | "gefahr" | "neutral";
+
+/** Farbe in der Liste: Fehlschlag und Verweigerung immer --danger, Aenderungen --ok. */
+export function aktionTon(aktion: string, ergebnis: "ERFOLG" | "FEHLER" | "VERWEIGERT"): AktionsTon {
+  if (ergebnis !== "ERFOLG") return "gefahr";
+  return AKTIONEN[aktion]?.aendert ? "ok" : "neutral";
+}
+
+export function istAktionsgruppe(wert: string): wert is Aktionsgruppe {
+  return Object.hasOwn(AKTIONSGRUPPEN, wert);
+}

src/lib/protokoll-filter.ts

@@ -0,0 +1,211 @@
+import { istAktionsgruppe, type Aktionsgruppe } from "@/lib/protokoll-aktionen";
+import { ZEITZONE } from "@/lib/format";
+
+/**
+ * Filter der Protokollansicht (#027). Framework-frei: Seite, CSV-Route und Server Action
+ * lesen dieselben GET-Parameter, damit der Export genau den Ausschnitt der Seite liefert.
+ */
+export const PROTOKOLL_ERGEBNISSE = ["ERFOLG", "FEHLER", "VERWEIGERT"] as const;
+export type ProtokollErgebnisWert = (typeof PROTOKOLL_ERGEBNISSE)[number];
+
+export const ERGEBNIS_TEXT: Record<ProtokollErgebnisWert, string> = {
+  ERFOLG: "Erfolg",
+  FEHLER: "Fehler",
+  VERWEIGERT: "Verweigert",
+};
+
+export type ProtokollFilter = {
+  /** Tag im Format JJJJ-MM-TT (Europe/Berlin), einschliesslich. */
+  readonly von: string;
+  readonly bis: string;
+  readonly gruppe: Aktionsgruppe | "";
+  readonly akteur: string;
+  readonly host: string;
+  readonly ergebnis: ProtokollErgebnisWert | "";
+  readonly q: string;
+};
+
+export const LEERER_FILTER: ProtokollFilter = {
+  von: "",
+  bis: "",
+  gruppe: "",
+  akteur: "",
+  host: "",
+  ergebnis: "",
+  q: "",
+};
+
+const TAG = /^\d{4}-\d{2}-\d{2}$/;
+
+function gueltigerTag(wert: string): string {
+  if (!TAG.test(wert)) return "";
+  return Number.isNaN(new Date(`${wert}T00:00:00Z`).getTime()) ? "" : wert;
+}
+
+export function protokollFilterAus(
+  parameter: Record<string, string | string[] | undefined>,
+): ProtokollFilter {
+  const einzeln = (name: string) => {
+    const wert = parameter[name];
+    return ((Array.isArray(wert) ? wert[0] : wert) ?? "").trim().slice(0, 200);
+  };
+  const gruppe = einzeln("gruppe");
+  const ergebnis = einzeln("ergebnis");
+  return {
+    von: gueltigerTag(einzeln("von")),
+    bis: gueltigerTag(einzeln("bis")),
+    gruppe: istAktionsgruppe(gruppe) ? gruppe : "",
+    akteur: einzeln("akteur"),
+    host: einzeln("host"),
+    ergebnis: (PROTOKOLL_ERGEBNISSE as readonly string[]).includes(ergebnis)
+      ? (ergebnis as ProtokollErgebnisWert)
+      : "",
+    q: einzeln("q"),
+  };
+}
+
+export function protokollFilterAktiv(filter: ProtokollFilter): boolean {
+  return Object.values(filter).some(Boolean);
+}
+
+/** Dieselben Filter als Query-String (CSV-Link, „ältere laden“, Anker auf eine ID). */
+export function protokollFilterQuery(filter: ProtokollFilter, extra: Record<string, string> = {}): string {
+  const p = new URLSearchParams();
+  for (const [name, wert] of Object.entries(filter)) if (wert) p.set(name, wert);
+  for (const [name, wert] of Object.entries(extra)) p.set(name, wert);
+  const text = p.toString();
+  return text ? `?${text}` : "";
+}
+
+/** Cursor „älter als ID“; nur positive Ganzzahlen, sonst keiner. */
+export function cursorAus(wert: string | string[] | undefined): bigint | undefined {
+  const text = Array.isArray(wert) ? wert[0] : wert;
+  if (!text || !/^\d{1,19}$/.test(text)) return undefined;
+  const zahl = BigInt(text);
+  return zahl > 0n ? zahl : undefined;
+}
+
+/** Abstand Europe/Berlin zu UTC in Millisekunden zu einem Zeitpunkt (Sommer-/Winterzeit). */
+function berlinVersatz(zeitpunkt: Date): number {
+  const teile = new Intl.DateTimeFormat("en-US", {
+    timeZone: ZEITZONE,
+    hourCycle: "h23",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+  }).formatToParts(zeitpunkt);
+  const wert = (typ: string) => Number(teile.find((t) => t.type === typ)?.value ?? 0);
+  const alsUtc = Date.UTC(
+    wert("year"),
+    wert("month") - 1,
+    wert("day"),
+    wert("hour"),
+    wert("minute"),
+    wert("second"),
+  );
+  return alsUtc - Math.floor(zeitpunkt.getTime() / 1000) * 1000;
+}
+
+/**
+ * Mitternacht des Tages in Berlin als Zeitpunkt. Die Oberflaeche zeigt Berliner Zeit (#002),
+ * also muss „von 12.10.“ auch Berliner Mitternacht meinen – nicht UTC.
+ */
+export function berlinTagesbeginn(tag: string): Date {
+  const utcMitternacht = new Date(`${tag}T00:00:00Z`);
+  const erst = new Date(utcMitternacht.getTime() - berlinVersatz(utcMitternacht));
+  // Zweiter Schritt fuer Tage, an denen die Uhr umgestellt wird.
+  return new Date(utcMitternacht.getTime() - berlinVersatz(erst));
+}
+
+/** Zeitraum als halboffenes Intervall [ab, vor) – „bis“ schliesst den ganzen Tag ein. */
+export function zeitraum(filter: Pick<ProtokollFilter, "von" | "bis">): { ab?: Date; vor?: Date } {
+  const ergebnis: { ab?: Date; vor?: Date } = {};
+  if (filter.von) ergebnis.ab = berlinTagesbeginn(filter.von);
+  if (filter.bis) {
+    const folgetag = new Date(`${filter.bis}T00:00:00Z`);
+    folgetag.setUTCDate(folgetag.getUTCDate() + 1);
+    ergebnis.vor = berlinTagesbeginn(folgetag.toISOString().slice(0, 10));
+  }
+  return ergebnis;
+}
+
+/** „12.10.2026 08:42:17“ – Sekunden gehoeren ins Protokoll, Komma nicht (#027). */
+const ZEITSTEMPEL = new Intl.DateTimeFormat("de-DE", {
+  timeZone: ZEITZONE,
+  day: "2-digit",
+  month: "2-digit",
+  year: "numeric",
+  hour: "2-digit",
+  minute: "2-digit",
+  second: "2-digit",
+  hourCycle: "h23",
+});
+
+export function protokollZeit(wert: Date | string): string {
+  return ZEITSTEMPEL.format(new Date(wert)).replace(",", "");
+}
+
+export type ProtokollDiffZeile = { art: "hinzu" | "entfernt" | "kontext"; text: string };
+
+/**
+ * Der gespeicherte Diff ist Text mit `+ `/`- ` je Zeile (#016); Private-Key-Ausrollen schreibt
+ * nur „anlegen ~/.ssh/…“ – solche Zeilen bleiben Kontext.
+ */
+export function diffZeilen(diff: string): ProtokollDiffZeile[] {
+  return diff.split("\n").map((zeile) => {
+    if (zeile.startsWith("+")) return { art: "hinzu", text: zeile.replace(/^\+ ?/, "") };
+    if (zeile.startsWith("-")) return { art: "entfernt", text: zeile.replace(/^- ?/, "") };
+    return { art: "kontext", text: zeile };
+  });
+}
+
+/** Spalten des CSV-Exports (#027): technisch, damit Auswertungen stabil bleiben. */
+export const PROTOKOLL_CSV_KOPF = [
+  "id",
+  "zeitpunkt",
+  "akteur",
+  "aktion",
+  "ergebnis",
+  "host",
+  "zielbenutzer",
+  "fingerprint",
+  "diff",
+  "details",
+  "vorgaengerHash",
+  "hash",
+] as const;
+
+export type ProtokollCsvQuelle = {
+  readonly id: bigint | string;
+  readonly zeitpunkt: Date;
+  readonly akteurName: string;
+  readonly aktion: string;
+  readonly ergebnis: string;
+  readonly hostName: string | null;
+  readonly zielbenutzer: string | null;
+  readonly fingerprint: string | null;
+  readonly diff: string | null;
+  readonly details: unknown;
+  readonly vorgaengerHash: string;
+  readonly hash: string;
+};
+
+export function protokollCsvWerte(z: ProtokollCsvQuelle): (string | null)[] {
+  return [
+    String(z.id),
+    z.zeitpunkt.toISOString(),
+    z.akteurName,
+    z.aktion,
+    z.ergebnis,
+    z.hostName,
+    z.zielbenutzer,
+    z.fingerprint,
+    z.diff,
+    z.details == null ? null : JSON.stringify(z.details),
+    z.vorgaengerHash,
+    z.hash,
+  ];
+}

src/lib/syslog.ts

@@ -0,0 +1,255 @@
+import { createSocket, type Socket as UdpSocket } from "node:dgram";
+import { hostname } from "node:os";
+import { connect, type Socket as TcpSocket } from "node:net";
+
+/**
+ * Weiterleitung des Protokolls an Syslog (#027), RFC 5424 mit strukturierten Daten.
+ *
+ * Bewusst klein und ohne Abhaengigkeit: ein paar Zeilen Format, ein UDP- oder TCP-Socket.
+ * Die Kopie beim Syslog-Server ist der zweite, vom sshkv-Host unabhaengige Beleg – wer die
+ * Datenbank uebernimmt, kann die Hash-Kette zwar neu rechnen, aber nicht zurueckholen, was
+ * schon beim Syslog liegt (PLAN §3).
+ *
+ * Es gehen nur die Felder hinaus, die das Protokoll ohnehin geschwaerzt speichert und die
+ * Uebersicht zeigt – `details` und `diff` nie, dort koennten Pfade und Dateiinhalte stehen.
+ */
+
+export type SyslogProtokoll = "udp" | "tcp";
+
+export type SyslogKonfig = {
+  readonly host: string;
+  readonly port: number;
+  readonly protokoll: SyslogProtokoll;
+  readonly appName: string;
+  /** Facility-Nummer nach RFC 5424 (authpriv = 10). */
+  readonly facility: number;
+};
+
+export const FACILITIES: Readonly<Record<string, number>> = {
+  kern: 0,
+  user: 1,
+  daemon: 3,
+  auth: 4,
+  syslog: 5,
+  authpriv: 10,
+  local0: 16,
+  local1: 17,
+  local2: 18,
+  local3: 19,
+  local4: 20,
+  local5: 21,
+  local6: 22,
+  local7: 23,
+};
+
+/** Severity aus dem Ergebnis: Erfolg ist bemerkenswert, Verweigerung eine Warnung. */
+export const SEVERITY = { ERFOLG: 5, VERWEIGERT: 4, FEHLER: 3 } as const;
+
+export type SyslogEintrag = {
+  readonly id?: bigint | string | null;
+  readonly zeitpunkt: Date;
+  readonly akteur: string;
+  readonly aktion: string;
+  readonly ergebnis: keyof typeof SEVERITY;
+  readonly hostName?: string | null;
+  readonly zielbenutzer?: string | null;
+  readonly fingerprint?: string | null;
+  readonly hash?: string | null;
+};
+
+/** IANA-Private-Enterprise-Number fuer Beispiele/Eigenbau ist 32473 (RFC 5612). */
+export const SD_ID = "sshkv@32473";
+
+/** RFC 5426 verlangt mindestens 480, empfiehlt 2048 Byte; 2048 passt auch in UDP sicher. */
+export const HOECHSTLAENGE = 2048;
+/** Je SD-Wert in Byte vor dem Escapen; acht Werte passen so mit Kopf in 2048 Byte. */
+const WERT_HOECHSTBYTES = 120;
+
+/**
+ * Liest die Konfiguration aus der Umgebung. Ohne `SSHKV_SYSLOG_HOST` ist Syslog aus; Fehler
+ * in den uebrigen Werten fallen auf die Standards zurueck, statt den Start zu verhindern.
+ */
+export function syslogKonfigAus(umgebung: Record<string, string | undefined>): SyslogKonfig | null {
+  const host = umgebung["SSHKV_SYSLOG_HOST"]?.trim();
+  if (!host) return null;
+  const port = Number(umgebung["SSHKV_SYSLOG_PORT"] ?? 514);
+  const protokoll = umgebung["SSHKV_SYSLOG_PROTOKOLL"]?.trim().toLowerCase() === "tcp" ? "tcp" : "udp";
+  const appName = asciiDruckbar(umgebung["SSHKV_SYSLOG_APPNAME"]?.trim() || "sshkv", 48) || "sshkv";
+  const facilityName = umgebung["SSHKV_SYSLOG_FACILITY"]?.trim().toLowerCase() || "authpriv";
+  return {
+    host,
+    port: Number.isInteger(port) && port > 0 && port < 65536 ? port : 514,
+    protokoll,
+    appName,
+    facility: FACILITIES[facilityName] ?? FACILITIES["authpriv"]!,
+  };
+}
+
+/** Kopffelder duerfen nur druckbares ASCII ohne Leerzeichen enthalten (RFC 5424 §6). */
+function asciiDruckbar(wert: string, laenge: number): string {
+  return wert.replace(/[^\x21-\x7e]/g, "_").slice(0, laenge);
+}
+
+/** Werte in SD-PARAM: `"`, `\` und `]` mit Backslash (RFC 5424 §6.3.3). */
+export function sdWertEscapen(wert: string): string {
+  return wert.replace(/["\\\]]/g, (zeichen) => `\\${zeichen}`);
+}
+
+/** Kuerzt vor dem Escapen, damit kein Backslash ohne sein Zeichen am Ende steht. */
+function sdWert(wert: string | null | undefined, bytes: number): string {
+  // Steuerzeichen (Zeilenumbrueche) wuerden manche Empfaenger zum Zeilenende verleiten.
+  const sauber = (wert ?? "").replace(/[\x00-\x1f\x7f]/g, " ");
+  return sdWertEscapen(textKuerzen(sauber, bytes));
+}
+
+/** Kuerzt auf hoechstens `bytes` UTF-8-Bytes, ohne ein Zeichen zu zerschneiden. */
+export function textKuerzen(text: string, bytes: number): string {
+  if (Buffer.byteLength(text, "utf8") <= bytes) return text;
+  let ergebnis = "";
+  let laenge = 0;
+  for (const zeichen of text) {
+    const groesse = Buffer.byteLength(zeichen, "utf8");
+    if (laenge + groesse + 3 > bytes) break;
+    ergebnis += zeichen;
+    laenge += groesse;
+  }
+  return `${ergebnis}...`;
+}
+
+/** Baut eine vollstaendige RFC-5424-Zeile (ohne TCP-Rahmen). */
+export function syslogNachricht(
+  eintrag: SyslogEintrag,
+  konfig: Pick<SyslogKonfig, "appName" | "facility">,
+  optionen: { rechner?: string; prozess?: number; text?: string } = {},
+): string {
+  const pri = konfig.facility * 8 + SEVERITY[eintrag.ergebnis];
+  const rechner = asciiDruckbar(optionen.rechner ?? hostname(), 255) || "-";
+  const prozess = String(optionen.prozess ?? process.pid);
+  const msgId = asciiDruckbar(eintrag.aktion, 32) || "-";
+  const parameter: [string, string | null | undefined][] = [
+    ["id", eintrag.id == null ? null : String(eintrag.id)],
+    ["akteur", eintrag.akteur],
+    ["aktion", eintrag.aktion],
+    ["ergebnis", eintrag.ergebnis],
+    ["host", eintrag.hostName],
+    ["zielbenutzer", eintrag.zielbenutzer],
+    ["fingerprint", eintrag.fingerprint],
+    ["hash", eintrag.hash],
+  ];
+  const kopfMit = (wertBytes: number) => {
+    const sd = `[${SD_ID}${parameter
+      .filter(([, wert]) => wert != null && wert !== "")
+      .map(([name, wert]) => ` ${name}="${sdWert(wert, wertBytes)}"`)
+      .join("")}]`;
+    return `<${pri}>1 ${eintrag.zeitpunkt.toISOString()} ${rechner} ${konfig.appName} ${prozess} ${msgId} ${sd}`;
+  };
+  let kopf = kopfMit(WERT_HOECHSTBYTES);
+  // Nur bei absichtlich langen Werten voller Sonderzeichen: dann alle Werte knapper.
+  if (Buffer.byteLength(kopf, "utf8") > HOECHSTLAENGE - 64) kopf = kopfMit(32);
+  const text =
+    optionen.text ??
+    `${eintrag.akteur}: ${eintrag.aktion} ${eintrag.ergebnis}${eintrag.hostName ? ` auf ${eintrag.hostName}` : ""}`;
+  // Ohne BOM gilt MSG als beliebige Bytes; mit BOM wissen Empfaenger, dass es UTF-8 ist.
+  const rest = HOECHSTLAENGE - Buffer.byteLength(kopf, "utf8") - 4;
+  return `${kopf} \uFEFF${textKuerzen(text.replace(/[\r\n]+/g, " "), rest)}`;
+}
+
+/** Oktettzaehlung nach RFC 6587 – robuster als Zeilenumbruch als Trenner. */
+export function tcpRahmen(nachricht: string): Buffer {
+  const daten = Buffer.from(nachricht, "utf8");
+  return Buffer.concat([Buffer.from(`${daten.length} `, "ascii"), daten]);
+}
+
+/** Beschreibung fuer die Oberflaeche – Ziel ohne Zugangsdaten (es gibt keine). */
+export function syslogZielText(konfig: SyslogKonfig): string {
+  const host = konfig.host.includes(":") ? `[${konfig.host}]` : konfig.host;
+  return `${konfig.protokoll}://${host}:${konfig.port}`;
+}
+
+export type SyslogSender = {
+  senden(eintrag: SyslogEintrag): void;
+  schliessen(): void;
+};
+
+/**
+ * Sender mit Feuer-und-vergessen-Semantik: `senden()` wirft nie und wartet auf nichts.
+ * Fehler gehen an `fehlerMelden`, und zwar hoechstens einmal je Minute – ein ausgefallener
+ * Syslog-Server soll das Log nicht fluten und darf nie eine Aktion verhindern.
+ */
+export function syslogSender(
+  konfig: SyslogKonfig,
+  fehlerMelden: (fehler: unknown) => void = (fehler) =>
+    console.error("[sshkv] Syslog nicht erreichbar:", fehler instanceof Error ? fehler.message : fehler),
+  jetzt: () => number = Date.now,
+): SyslogSender {
+  let zuletztGemeldet = -Infinity;
+  const melden = (fehler: unknown) => {
+    const t = jetzt();
+    if (t - zuletztGemeldet < 60_000) return;
+    zuletztGemeldet = t;
+    try {
+      fehlerMelden(fehler);
+    } catch {
+      // Auch ein kaputter Logger darf hier nichts abbrechen.
+    }
+  };
+
+  let udp: UdpSocket | null = null;
+  let tcp: TcpSocket | null = null;
+
+  const udpSocket = () => {
+    if (udp) return udp;
+    const socket = createSocket(konfig.host.includes(":") ? "udp6" : "udp4");
+    socket.on("error", (fehler) => {
+      melden(fehler);
+      socket.close();
+      if (udp === socket) udp = null;
+    });
+    // Der Socket soll den Prozess (Worker, Tests) nicht am Beenden hindern.
+    socket.unref();
+    udp = socket;
+    return socket;
+  };
+
+  const tcpSocket = () => {
+    if (tcp && !tcp.destroyed) return tcp;
+    const socket = connect({ host: konfig.host, port: konfig.port });
+    socket.setKeepAlive(true);
+    socket.on("error", (fehler) => {
+      melden(fehler);
+      socket.destroy();
+    });
+    socket.on("close", () => {
+      if (tcp === socket) tcp = null;
+    });
+    socket.unref();
+    tcp = socket;
+    return socket;
+  };
+
+  return {
+    senden(eintrag) {
+      try {
+        const nachricht = syslogNachricht(eintrag, konfig);
+        if (konfig.protokoll === "tcp") {
+          // Schreibt vor dem Verbindungsaufbau in den Puffer des Sockets; bei Fehlern gehen
+          // diese Zeilen verloren – die Datenbank bleibt die Quelle der Wahrheit.
+          tcpSocket().write(tcpRahmen(nachricht));
+        } else {
+          const daten = Buffer.from(nachricht, "utf8");
+          udpSocket().send(daten, konfig.port, konfig.host, (fehler) => {
+            if (fehler) melden(fehler);
+          });
+        }
+      } catch (fehler) {
+        melden(fehler);
+      }
+    },
+    schliessen() {
+      udp?.close();
+      udp = null;
+      tcp?.end();
+      tcp = null;
+    },
+  };
+}

src/server/actions/protokoll.ts

@@ -0,0 +1,51 @@
+"use server";
+
+import { cursorAus, protokollFilterAus } from "@/lib/protokoll-filter";
+import { RechteFehler, rechtErforderlich } from "@/server/auth/sitzungspflicht";
+import { protokollSeite, type ProtokollSeite } from "@/server/queries/protokoll";
+import { kettePruefenZwischengespeichert } from "@/server/services/protokoll";
+
+/**
+ * Protokollansicht (#027): nur lesende Aktionen. Bewusst gibt es hier nichts, was einen
+ * Eintrag aendert oder loescht – das verbietet ohnehin der Trigger, und
+ * `tests/protokoll-ansicht.test.ts` haelt fest, dass auch kein Code es versucht.
+ */
+
+export type KettenAntwort = {
+  readonly fehlerhafteId?: string | null;
+  readonly eintraege?: number;
+  readonly geprueftAm?: string;
+  readonly fehler?: string;
+};
+
+export async function kettePruefenAktion(): Promise<KettenAntwort> {
+  try {
+    const { benutzer } = await rechtErforderlich("lesen");
+    const ergebnis = await kettePruefenZwischengespeichert({ id: benutzer.id, name: benutzer.name });
+    return {
+      fehlerhafteId: ergebnis.fehlerhafteId,
+      eintraege: ergebnis.eintraege,
+      geprueftAm: ergebnis.geprueftAm.toISOString(),
+    };
+  } catch (fehler) {
+    if (fehler instanceof RechteFehler) return { fehler: fehler.message };
+    throw fehler;
+  }
+}
+
+/** „Ältere laden“: dieselben GET-Filter wie die Seite, Cursor ist die kleinste gezeigte ID. */
+export async function aeltereLadenAktion(
+  query: string,
+  vor: string,
+): Promise<ProtokollSeite | { fehler: string }> {
+  try {
+    await rechtErforderlich("lesen");
+  } catch (fehler) {
+    if (fehler instanceof RechteFehler) return { fehler: fehler.message };
+    throw fehler;
+  }
+  const cursor = cursorAus(String(vor));
+  if (cursor === undefined) return { zeilen: [], weiterVor: null };
+  const filter = protokollFilterAus(Object.fromEntries(new URLSearchParams(String(query).slice(0, 2000))));
+  return protokollSeite(filter, cursor);
+}

src/server/queries/protokoll.ts

@@ -0,0 +1,156 @@
+import type { Prisma } from "@/generated/prisma/client";
+import { prisma } from "@/lib/db";
+import { aktionenDerGruppe } from "@/lib/protokoll-aktionen";
+import { zeitraum, type ProtokollFilter } from "@/lib/protokoll-filter";
+
+/**
+ * Lesemodell des Protokolls (#027). Jede Rolle darf das ganze Protokoll lesen (PLAN §4);
+ * die Rechtepruefung machen Seite, Action und Route selbst.
+ *
+ * Geblaettert wird ueber die ID („älter als“), nicht ueber OFFSET: das Protokoll waechst
+ * waehrend man liest, und OFFSET wuerde dann Zeilen doppelt zeigen oder ueberspringen –
+ * ausserdem muesste die Datenbank bei OFFSET 10 000 erst 10 000 Zeilen lesen und verwerfen.
+ */
+export const SEITENGROESSE = 50;
+
+export type ProtokollZeile = {
+  readonly id: string;
+  readonly zeitpunkt: string;
+  readonly akteurName: string;
+  readonly aktion: string;
+  readonly ergebnis: "ERFOLG" | "FEHLER" | "VERWEIGERT";
+  readonly hostName: string | null;
+  readonly zielbenutzer: string | null;
+  readonly fingerprint: string | null;
+  readonly diff: string | null;
+  /** Bereits beim Schreiben geschwaerzt (#005); oberste Ebene als Liste, Werte formatiert. */
+  readonly details: { readonly name: string; readonly wert: string }[] | null;
+  readonly vorgaengerHash: string;
+  readonly hash: string;
+};
+
+const AUSWAHL = {
+  id: true,
+  zeitpunkt: true,
+  akteurName: true,
+  aktion: true,
+  ergebnis: true,
+  hostName: true,
+  zielbenutzer: true,
+  fingerprint: true,
+  diff: true,
+  details: true,
+  vorgaengerHash: true,
+  hash: true,
+} satisfies Prisma.ProtokollSelect;
+
+type Rohzeile = Prisma.ProtokollGetPayload<{ select: typeof AUSWAHL }>;
+
+export function protokollWhere(filter: ProtokollFilter, vor?: bigint): Prisma.ProtokollWhereInput {
+  const und: Prisma.ProtokollWhereInput[] = [];
+  const { ab, vor: bis } = zeitraum(filter);
+  if (ab || bis) und.push({ zeitpunkt: { ...(ab ? { gte: ab } : {}), ...(bis ? { lt: bis } : {}) } });
+  if (filter.gruppe) und.push({ aktion: { in: aktionenDerGruppe(filter.gruppe) } });
+  if (filter.akteur) und.push({ akteurName: filter.akteur });
+  if (filter.host) und.push({ hostName: { contains: filter.host, mode: "insensitive" } });
+  if (filter.ergebnis) und.push({ ergebnis: filter.ergebnis });
+  if (filter.q) {
+    const enthaelt = { contains: filter.q, mode: "insensitive" } as const;
+    und.push({ OR: [{ fingerprint: enthaelt }, { hostName: enthaelt }, { zielbenutzer: enthaelt }] });
+  }
+  if (vor !== undefined) und.push({ id: { lt: vor } });
+  return und.length ? { AND: und } : {};
+}
+
+/** Texte bleiben Texte; Zahlen, Listen und Objekte als eingerueckte JSON. */
+function detailsListe(details: Prisma.JsonValue): ProtokollZeile["details"] {
+  if (details == null) return null;
+  const alsText = (wert: unknown) => (typeof wert === "string" ? wert : JSON.stringify(wert, null, 2));
+  if (typeof details !== "object" || Array.isArray(details))
+    return [{ name: "Wert", wert: alsText(details) }];
+  const eintraege = Object.entries(details).map(([name, wert]) => ({ name, wert: alsText(wert) }));
+  return eintraege.length ? eintraege : null;
+}
+
+function zeileAus(z: Rohzeile): ProtokollZeile {
+  return {
+    id: String(z.id),
+    zeitpunkt: z.zeitpunkt.toISOString(),
+    akteurName: z.akteurName,
+    aktion: z.aktion,
+    ergebnis: z.ergebnis,
+    hostName: z.hostName,
+    zielbenutzer: z.zielbenutzer,
+    fingerprint: z.fingerprint,
+    diff: z.diff,
+    details: detailsListe(z.details),
+    vorgaengerHash: z.vorgaengerHash,
+    hash: z.hash,
+  };
+}
+
+export type ProtokollSeite = {
+  readonly zeilen: ProtokollZeile[];
+  /** ID fuer „ältere laden“; fehlt, wenn es nichts Aelteres mehr gibt. */
+  readonly weiterVor: string | null;
+};
+
+/** Eine Seite, neueste zuerst; `vor` ist die kleinste ID der vorigen Seite. */
+export async function protokollSeite(filter: ProtokollFilter, vor?: bigint): Promise<ProtokollSeite> {
+  const roh = await prisma.protokoll.findMany({
+    where: protokollWhere(filter, vor),
+    orderBy: { id: "desc" },
+    take: SEITENGROESSE + 1,
+    select: AUSWAHL,
+  });
+  const mehr = roh.length > SEITENGROESSE;
+  const zeilen = roh.slice(0, SEITENGROESSE).map(zeileAus);
+  return { zeilen, weiterVor: mehr ? (zeilen.at(-1)?.id ?? null) : null };
+}
+
+/** Kopfzeile der Seite: Gesamtzahl und Treffer des Filters. */
+export async function protokollZaehlen(
+  filter: ProtokollFilter,
+): Promise<{ gesamt: number; treffer: number }> {
+  const [gesamt, treffer] = await Promise.all([
+    prisma.protokoll.count(),
+    prisma.protokoll.count({ where: protokollWhere(filter) }),
+  ]);
+  return { gesamt, treffer };
+}
+
+/** Namen fuer den Akteur-Filter – haeufigste zuerst, begrenzt, damit die Liste handlich bleibt. */
+export async function protokollAkteure(): Promise<string[]> {
+  const gruppen = await prisma.protokoll.groupBy({
+    by: ["akteurName"],
+    _count: { _all: true },
+    orderBy: { _count: { akteurName: "desc" } },
+    take: 100,
+  });
+  return gruppen.map((g) => g.akteurName).sort((a, b) => a.localeCompare(b, "de"));
+}
+
+/**
+ * Alle Treffer in Stapeln, neueste zuerst – fuer den CSV-Export. Liest je Stapel nur
+ * `stapel` Zeilen, damit auch ein grosses Protokoll nie ganz im Speicher liegt.
+ */
+export async function* protokollStapelweise(
+  filter: ProtokollFilter,
+  stapel = 500,
+): AsyncGenerator<Rohzeile[], void, undefined> {
+  let vor: bigint | undefined;
+  for (;;) {
+    const zeilen = await prisma.protokoll.findMany({
+      where: protokollWhere(filter, vor),
+      orderBy: { id: "desc" },
+      take: stapel,
+      select: AUSWAHL,
+    });
+    if (zeilen.length === 0) return;
+    yield zeilen;
+    if (zeilen.length < stapel) return;
+    vor = zeilen.at(-1)!.id;
+  }
+}
+
+export type { Rohzeile as ProtokollRohzeile };

src/server/queries/uebersicht.ts

@@ -1,5 +1,6 @@
 import type { AbweichungsArt } from "@/generated/prisma/enums";
 import { prisma } from "@/lib/db";
+import { aktionText } from "@/lib/protokoll-aktionen";
 
 /**
  * Lesemodell der Übersicht (#026). Alle Zahlen werden berechnet, nichts ist hinterlegt –
@@ -190,7 +191,11 @@ export async function uebersicht(jetzt = new Date()) {
       zeit: a.zeitpunkt,
       art: aktionEinordnen(a.aktion, a.ergebnis),
       aktion: a.aktion,
-      beschreibung: [a.aktion, a.zielbenutzer && a.hostName ? `${a.zielbenutzer}@${a.hostName}` : a.hostName]
+      // Lesbarer Text aus dem Audit-Log (#027) statt des technischen Aktionsnamens.
+      beschreibung: [
+        aktionText(a.aktion),
+        a.zielbenutzer && a.hostName ? `${a.zielbenutzer}@${a.hostName}` : a.hostName,
+      ]
         .filter(Boolean)
         .join(" · "),
       benutzer: a.akteurName,

src/server/services/protokoll.ts

@@ -2,6 +2,7 @@ import type { Prisma } from "@/generated/prisma/client";
 import type { ProtokollErgebnis } from "@/generated/prisma/enums";
 import { prisma } from "@/lib/db";
 import { schwaerzen } from "@/lib/protokoll-schwaerzen";
+import { syslogKonfigAus, syslogSender, type SyslogKonfig, type SyslogSender } from "@/lib/syslog";
 
 /**
  * Schreibt einen Eintrag ins revisionssichere Protokoll (#005).
@@ -26,7 +27,7 @@ export async function protokollieren(
   client: Prisma.TransactionClient = prisma,
 ): Promise<void> {
   const akteur = eintrag.akteur === "System" ? { id: null, name: "System" } : eintrag.akteur;
-  await client.protokoll.create({
+  const zeile = await client.protokoll.create({
     data: {
       akteurId: akteur.id,
       akteurName: akteur.name,
@@ -40,13 +41,119 @@ export async function protokollieren(
       diff: eintrag.diff ? (schwaerzen(eintrag.diff) as string) : null,
       details: eintrag.details ? (schwaerzen(eintrag.details) as Prisma.InputJsonValue) : undefined,
     },
+    select: { id: true, zeitpunkt: true, hash: true },
+  });
+  // Erst nach dem erfolgreichen Schreiben, ohne zu warten (#027): Syslog ist die Kopie,
+  // die Datenbank die Quelle. Innerhalb einer Transaktion kann ein spaeterer Rollback eine
+  // Syslog-Zeile ohne Gegenstueck hinterlassen – deren Hash fehlt dann in der Kette und faellt
+  // beim Vergleich auf; umgekehrt (Eintrag ohne Syslog-Zeile) waere schlimmer.
+  syslogWeitergeben({
+    id: zeile.id,
+    zeitpunkt: zeile.zeitpunkt,
+    akteur: akteur.name,
+    aktion: eintrag.aktion,
+    ergebnis: eintrag.ergebnis,
+    hostName: eintrag.hostName ?? null,
+    zielbenutzer: eintrag.zielbenutzer ?? null,
+    fingerprint: eintrag.fingerprint ?? null,
+    hash: zeile.hash,
   });
 }
 
-/** Prueft die Hash-Kette in der Datenbank; liefert die erste fehlerhafte ID oder null. */
+let syslog: { konfig: SyslogKonfig; sender: SyslogSender } | null | undefined;
+
+/** Konfiguration einmal je Prozess lesen; Web und Worker haben jeder einen Sender. */
+export function syslogKonfig(): SyslogKonfig | null {
+  if (syslog === undefined) {
+    const konfig = syslogKonfigAus(process.env);
+    syslog = konfig ? { konfig, sender: syslogSender(konfig) } : null;
+  }
+  return syslog?.konfig ?? null;
+}
+
+/** Nur fuer Tests: Umgebung neu lesen. */
+export function syslogZuruecksetzen(): void {
+  syslog?.sender.schliessen();
+  syslog = undefined;
+}
+
+function syslogWeitergeben(eintrag: Parameters<SyslogSender["senden"]>[0]): void {
+  try {
+    if (!syslogKonfig()) return;
+    syslog?.sender.senden(eintrag);
+  } catch {
+    // senden() wirft nicht; das hier faengt nur eine kaputte Konfiguration ab.
+  }
+}
+
+/**
+ * Prueft die Hash-Kette in der Datenbank; liefert die erste fehlerhafte ID oder null.
+ * Liest jede Zeile – fuer die Oberflaeche `ketteGeprueft()` mit Zwischenspeicher nehmen.
+ */
 export async function protokollKettePruefen(): Promise<bigint | null> {
   const [zeile] = await prisma.$queryRaw<
     { ergebnis: bigint | null }[]
   >`SELECT protokoll_kette_pruefen() AS ergebnis`;
   return zeile?.ergebnis ?? null;
 }
+
+export type Kettenpruefung = {
+  readonly fehlerhafteId: string | null;
+  readonly eintraege: number;
+  readonly geprueftAm: Date;
+};
+
+/** Wie lange ein Pruefergebnis gilt, bevor „Kette prüfen“ wieder rechnet (#027). */
+export const KETTE_ZWISCHENSPEICHER_MS = 5 * 60 * 1000;
+
+let letztePruefung: Kettenpruefung | null = null;
+let laufendePruefung: Promise<Kettenpruefung> | null = null;
+
+/**
+ * Die Pruefung rechnet SHA-256 ueber jede Zeile und waechst mit dem Protokoll; deshalb laeuft
+ * sie nie beim blossen Seitenaufruf, sondern auf Knopfdruck, und das Ergebnis gilt 5 Minuten
+ * je Prozess. Gleichzeitige Klicks teilen sich eine laufende Pruefung (#027).
+ */
+export function ketteZwischengespeichert(jetzt: Date = new Date()): Kettenpruefung | null {
+  if (!letztePruefung) return null;
+  return jetzt.getTime() - letztePruefung.geprueftAm.getTime() < KETTE_ZWISCHENSPEICHER_MS
+    ? letztePruefung
+    : null;
+}
+
+export async function kettePruefenZwischengespeichert(
+  akteur: ProtokollEintrag["akteur"],
+): Promise<Kettenpruefung> {
+  const vorhanden = ketteZwischengespeichert();
+  if (vorhanden) return vorhanden;
+  laufendePruefung ??= (async () => {
+    try {
+      const eintraege = await prisma.protokoll.count();
+      const fehlerhaft = await protokollKettePruefen();
+      const ergebnis = {
+        fehlerhafteId: fehlerhaft === null ? null : String(fehlerhaft),
+        eintraege,
+        geprueftAm: new Date(),
+      };
+      if (fehlerhaft !== null) {
+        // Ein Bruch ist ein Sicherheitsereignis und soll auch beim Syslog ankommen.
+        await protokollieren({
+          akteur,
+          aktion: "protokoll.kette_beschaedigt",
+          ergebnis: "FEHLER",
+          details: { fehlerhafteId: String(fehlerhaft) },
+        });
+      }
+      letztePruefung = ergebnis;
+      return ergebnis;
+    } finally {
+      laufendePruefung = null;
+    }
+  })();
+  return laufendePruefung;
+}
+
+/** Nur fuer Tests. */
+export function ketteZwischenspeicherLeeren(): void {
+  letztePruefung = null;
+}

tests/e2e/protokoll.spec.ts

@@ -0,0 +1,52 @@
+import { readFile } from "node:fs/promises";
+import { expect, test } from "@playwright/test";
+import { anmelden } from "./hilfen";
+
+/**
+ * Audit-Log (#027) gegen den gebauten Stand: Liste, Filter, Aufklappen, Kettenpruefung und
+ * CSV-Export. Die Anmeldung selbst erzeugt den ersten Eintrag – ohne SSH-Testziele lauffaehig.
+ */
+test("Audit-Log zeigt, filtert, prüft und exportiert", async ({ page }) => {
+  await anmelden(page);
+  await page.goto("/protokoll");
+  await expect(page.getByRole("heading", { name: "Audit-Log" })).toBeVisible();
+
+  const tabelle = page.getByRole("table", { name: "Protokolleinträge" });
+  await expect(tabelle.getByRole("row").nth(1)).toBeVisible();
+
+  // Filter nach Aktionsgruppe: nur noch Anmeldungen.
+  await page.getByLabel("Aktion").selectOption({ label: "Anmeldung" });
+  await page.getByRole("button", { name: "Filtern" }).click();
+  await expect(page).toHaveURL(/gruppe=anmeldung/);
+  const zeilen = tabelle.locator("tbody > tr");
+  await expect(zeilen.first()).toBeVisible();
+  const aktionen = await zeilen.locator("td:nth-child(2)").allInnerTexts();
+  expect(aktionen.length).toBeGreaterThan(0);
+  for (const aktion of aktionen) expect(aktion).toMatch(/Anmeld|TOTP/);
+
+  // Zeile aufklappen: Hash und Vorgaenger-Hash erscheinen.
+  await tabelle
+    .getByRole("button", { name: /Einzelheiten zu Eintrag/ })
+    .first()
+    .click();
+  await expect(tabelle.locator('[data-feld="hash"]').first()).toHaveText(/^[0-9a-f]{64}$/);
+
+  // Kettenpruefung auf Knopfdruck.
+  await page.getByRole("button", { name: "Kette prüfen" }).click();
+  await expect(page.getByText("Hash-Kette unversehrt")).toBeVisible({ timeout: 30_000 });
+
+  // CSV mit denselben Filtern; der Export landet selbst im Protokoll.
+  const [download] = await Promise.all([
+    page.waitForEvent("download"),
+    page.getByRole("link", { name: "CSV exportieren" }).click(),
+  ]);
+  expect(download.suggestedFilename()).toMatch(/^sshkv-protokoll-\d{4}-\d{2}-\d{2}\.csv$/);
+  const text = (await readFile((await download.path())!, "utf8")).replace(/^/, "");
+  expect(text.split("\r\n")[0]).toBe(
+    '"id";"zeitpunkt";"akteur";"aktion";"ergebnis";"host";"zielbenutzer";"fingerprint";"diff";"details";"vorgaengerHash";"hash"',
+  );
+  expect(text).toContain("anmeldung.");
+
+  await page.goto("/protokoll?gruppe=protokoll");
+  await expect(tabelle.getByText("Protokoll exportiert (CSV)").first()).toBeVisible();
+});

tests/protokoll-aktionen.test.ts

@@ -0,0 +1,75 @@
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { AKTIONEN, AKTIONSGRUPPEN, aktionenDerGruppe, aktionText, aktionTon } from "@/lib/protokoll-aktionen";
+
+/**
+ * Jede Protokoll-Aktion im Quellcode hat einen lesbaren Text (#027). Gesucht wird in allen
+ * Dateien, die `protokollieren(` rufen, nach `aktion: …`/`aktion = …` (auch in Ternaries), und
+ * ueberall nach Literalen, die mit einem bekannten Praefix beginnen (`"schluessel.uebernommen"`
+ * wird z. B. als Argument durchgereicht).
+ */
+function dateien(verzeichnis: string): string[] {
+  return readdirSync(verzeichnis).flatMap((name) => {
+    const pfad = path.join(verzeichnis, name);
+    if (statSync(pfad).isDirectory()) return name === "generated" ? [] : dateien(pfad);
+    return /\.tsx?$/.test(name) ? [pfad] : [];
+  });
+}
+
+const QUELLEN = dateien("src").map((datei) => ({ datei, inhalt: readFileSync(datei, "utf8") }));
+const LITERAL = /"([^"\n]+)"/g;
+
+function aktionenImCode(): Map<string, string> {
+  const gefunden = new Map<string, string>();
+  const praefixe = new Set(Object.keys(AKTIONEN).map((a) => a.split(".")[0]!));
+  for (const { datei, inhalt } of QUELLEN) {
+    if (inhalt.includes("protokollieren(")) {
+      for (const treffer of inhalt.matchAll(/\baktion\s*[:=]\s*([^,\n]+)/g)) {
+        // Bei `a === "x" ? "eins" : "zwei"` zaehlen nur die Zweige, nicht die Bedingung.
+        const ausdruck = treffer[1]!.includes("?")
+          ? treffer[1]!.slice(treffer[1]!.indexOf("?"))
+          : treffer[1]!;
+        for (const [, literal] of ausdruck.matchAll(LITERAL)) gefunden.set(literal!, datei);
+      }
+    }
+    for (const [, literal] of inhalt.matchAll(/"([a-z_]+(?:\.[a-z_]+)+)"/g)) {
+      if (praefixe.has(literal!.split(".")[0]!) && !literal!.endsWith(".ts")) gefunden.set(literal!, datei);
+    }
+  }
+  return gefunden;
+}
+
+describe("Protokoll-Aktionen", () => {
+  const imCode = aktionenImCode();
+
+  it("findet die Aktionen im Quellcode", () => {
+    expect(imCode.size).toBeGreaterThan(40);
+    expect(imCode.has("authorized_keys.geschrieben")).toBe(true);
+    expect(imCode.has("hostkey.ersetzt")).toBe(true);
+    expect(imCode.has("privatekey.angezeigt")).toBe(true);
+    expect(imCode.has("schluessel.uebernommen")).toBe(true);
+  });
+
+  it.each([...imCode])("%s hat einen lesbaren Text (%s)", (aktion) => {
+    expect(AKTIONEN[aktion], `${aktion} fehlt in src/lib/protokoll-aktionen.ts`).toBeDefined();
+  });
+
+  it("jede Gruppe hat Aktionen", () => {
+    for (const gruppe of Object.keys(AKTIONSGRUPPEN) as (keyof typeof AKTIONSGRUPPEN)[]) {
+      expect(aktionenDerGruppe(gruppe).length, gruppe).toBeGreaterThan(0);
+    }
+  });
+
+  it("faellt fuer unbekannte Aktionen auf den technischen Namen zurueck", () => {
+    expect(aktionText("hostkey.ersetzt")).toBe("Host-Key ersetzt");
+    expect(aktionText("gibt.es.nicht")).toBe("gibt.es.nicht");
+  });
+
+  it("faerbt nach Ergebnis und Art", () => {
+    expect(aktionTon("authorized_keys.geschrieben", "ERFOLG")).toBe("ok");
+    expect(aktionTon("anmeldung.oidc", "ERFOLG")).toBe("neutral");
+    expect(aktionTon("anmeldung.verweigert", "VERWEIGERT")).toBe("gefahr");
+    expect(aktionTon("verbindungstest", "FEHLER")).toBe("gefahr");
+  });
+});

tests/protokoll-ansicht.test.ts

@@ -0,0 +1,349 @@
+import { createSocket } from "node:dgram";
+import type { AddressInfo } from "node:net";
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { prisma } from "@/lib/db";
+import { LEERER_FILTER, protokollFilterAus, type ProtokollFilter } from "@/lib/protokoll-filter";
+import {
+  protokollAkteure,
+  protokollSeite,
+  protokollStapelweise,
+  protokollZaehlen,
+  SEITENGROESSE,
+} from "@/server/queries/protokoll";
+import {
+  kettePruefenZwischengespeichert,
+  ketteZwischengespeichert,
+  ketteZwischenspeicherLeeren,
+  protokollieren,
+  syslogKonfig,
+  syslogZuruecksetzen,
+} from "@/server/services/protokoll";
+import { datenbankLeeren } from "./hilfen/db";
+
+/**
+ * Protokollansicht (#027) gegen die Testdatenbank: Filter, Cursor, CSV-Route, Kettenpruefung
+ * und Syslog-Weiterleitung. Die Sitzung der Route wird nachgebildet – geprueft wird, dass der
+ * Handler das Recht selbst verlangt.
+ */
+const recht = vi.hoisted(() => ({ erlaubt: true }));
+vi.mock("@/server/auth/sitzungspflicht", async (original) => {
+  const echt = await original<typeof import("@/server/auth/sitzungspflicht")>();
+  return {
+    ...echt,
+    rechtErforderlich: vi.fn(async () => {
+      if (!recht.erlaubt) throw new echt.RechteFehler("Nicht angemeldet.");
+      return { benutzer: { id: "b-leser", name: "Lea Leser", rolle: "LESER" } };
+    }),
+  };
+});
+
+type Roh = {
+  aktion: string;
+  akteurName?: string;
+  ergebnis?: "ERFOLG" | "FEHLER" | "VERWEIGERT";
+  hostName?: string | null;
+  zielbenutzer?: string | null;
+  fingerprint?: string | null;
+  zeitpunkt?: Date;
+  diff?: string;
+};
+
+async function eintragen(daten: Roh) {
+  return prisma.protokoll.create({
+    data: {
+      akteurName: daten.akteurName ?? "Florian",
+      aktion: daten.aktion,
+      ergebnis: daten.ergebnis ?? "ERFOLG",
+      hostName: daten.hostName ?? null,
+      zielbenutzer: daten.zielbenutzer ?? null,
+      fingerprint: daten.fingerprint ?? null,
+      diff: daten.diff ?? null,
+      ...(daten.zeitpunkt ? { zeitpunkt: daten.zeitpunkt } : {}),
+    },
+  });
+}
+
+const filter = (teil: Partial<ProtokollFilter>): ProtokollFilter => ({ ...LEERER_FILTER, ...teil });
+
+beforeEach(async () => {
+  recht.erlaubt = true;
+  ketteZwischenspeicherLeeren();
+  await datenbankLeeren();
+});
+
+describe("protokollSeite", () => {
+  it("blaettert ueber die ID, neueste zuerst, ohne Luecken und Doppelte", async () => {
+    // IDs sind nicht lueckenlos (der Trigger zieht die Sequenz selbst) – nur die Ordnung zaehlt.
+    const ids: string[] = [];
+    for (let i = 0; i < SEITENGROESSE + 7; i += 1)
+      ids.unshift(String((await eintragen({ aktion: "host.angelegt" })).id));
+    const erste = await protokollSeite(LEERER_FILTER);
+    expect(erste.zeilen.map((z) => z.id)).toEqual(ids.slice(0, SEITENGROESSE));
+    expect(erste.weiterVor).toBe(ids[SEITENGROESSE - 1]);
+
+    // Ein neuer Eintrag zwischen zwei Seiten verschiebt den Cursor nicht (anders als OFFSET).
+    await eintragen({ aktion: "host.geaendert" });
+    const zweite = await protokollSeite(LEERER_FILTER, BigInt(erste.weiterVor!));
+    expect(zweite.zeilen.map((z) => z.id)).toEqual(ids.slice(SEITENGROESSE));
+    expect(zweite.weiterVor).toBeNull();
+  });
+
+  it("liefert Hash, Vorgaenger-Hash und Details als Liste", async () => {
+    await protokollieren({
+      akteur: "System",
+      aktion: "abgleich",
+      ergebnis: "ERFOLG",
+      details: { befunde: 2, benutzer: ["root"], hinweis: "ok" },
+    });
+    const [zeile] = (await protokollSeite(LEERER_FILTER)).zeilen;
+    expect(zeile!.hash).toMatch(/^[0-9a-f]{64}$/);
+    expect(zeile!.vorgaengerHash).toBe("");
+    // jsonb ordnet die Schluessel selbst; die Reihenfolge ist daher nicht Teil der Zusage.
+    expect(zeile!.details).toHaveLength(3);
+    expect(zeile!.details).toEqual(
+      expect.arrayContaining([
+        { name: "befunde", wert: "2" },
+        { name: "benutzer", wert: '[\n  "root"\n]' },
+        { name: "hinweis", wert: "ok" },
+      ]),
+    );
+  });
+
+  it("filtert nach Aktionsgruppe, Ergebnis, Akteur, Host und Freitext", async () => {
+    await eintragen({ aktion: "anmeldung.oidc", akteurName: "Anna" });
+    await eintragen({ aktion: "anmeldung.verweigert", akteurName: "Mallory", ergebnis: "VERWEIGERT" });
+    await eintragen({
+      aktion: "authorized_keys.geschrieben",
+      hostName: "srv-pve01",
+      zielbenutzer: "backup",
+      fingerprint: "SHA256:abcdef",
+    });
+    await eintragen({ aktion: "hostkey.ersetzt", hostName: "srv-db02" });
+
+    const aktionen = async (f: Partial<ProtokollFilter>) =>
+      (await protokollSeite(filter(f))).zeilen.map((z) => z.aktion);
+
+    expect(await aktionen({ gruppe: "anmeldung" })).toEqual(["anmeldung.verweigert", "anmeldung.oidc"]);
+    expect(await aktionen({ gruppe: "hostkey" })).toEqual(["hostkey.ersetzt"]);
+    expect(await aktionen({ ergebnis: "VERWEIGERT" })).toEqual(["anmeldung.verweigert"]);
+    expect(await aktionen({ akteur: "Anna" })).toEqual(["anmeldung.oidc"]);
+    expect(await aktionen({ host: "PVE" })).toEqual(["authorized_keys.geschrieben"]);
+    expect(await aktionen({ q: "abcdef" })).toEqual(["authorized_keys.geschrieben"]);
+    expect(await aktionen({ q: "BACKUP" })).toEqual(["authorized_keys.geschrieben"]);
+    expect(await aktionen({ q: "db02" })).toEqual(["hostkey.ersetzt"]);
+    expect(await aktionen({ gruppe: "ausrollen", host: "db02" })).toEqual([]);
+
+    expect(await protokollZaehlen(filter({ gruppe: "anmeldung" }))).toEqual({ gesamt: 4, treffer: 2 });
+    expect(await protokollAkteure()).toEqual(["Anna", "Florian", "Mallory"]);
+  });
+
+  it("filtert den Zeitraum nach Berliner Kalendertagen", async () => {
+    // 11.10. 23:30 Berlin = 21:30 UTC; 12.10. 00:30 Berlin = 22:30 UTC am 11.10.
+    await eintragen({ aktion: "host.angelegt", zeitpunkt: new Date("2026-10-11T21:30:00Z") });
+    await eintragen({ aktion: "host.geaendert", zeitpunkt: new Date("2026-10-11T22:30:00Z") });
+    await eintragen({ aktion: "host.archiviert", zeitpunkt: new Date("2026-10-12T21:59:00Z") });
+    await eintragen({ aktion: "kunde.angelegt", zeitpunkt: new Date("2026-10-12T22:01:00Z") });
+
+    const aktionen = async (f: Partial<ProtokollFilter>) =>
+      (await protokollSeite(filter(f))).zeilen.map((z) => z.aktion);
+    expect(await aktionen({ von: "2026-10-12", bis: "2026-10-12" })).toEqual([
+      "host.archiviert",
+      "host.geaendert",
+    ]);
+    expect(await aktionen({ bis: "2026-10-11" })).toEqual(["host.angelegt"]);
+    expect(await aktionen({ von: "2026-10-13" })).toEqual(["kunde.angelegt"]);
+  });
+
+  it("ignoriert unbekannte Filterwerte", () => {
+    expect(
+      protokollFilterAus({
+        gruppe: "drop table",
+        ergebnis: "VIELLEICHT",
+        von: "12.10.2026",
+        bis: "2026-13-45",
+      }),
+    ).toEqual(LEERER_FILTER);
+  });
+});
+
+describe("protokollStapelweise", () => {
+  it("liest alle Treffer in Stapeln", async () => {
+    const erwartet: bigint[] = [];
+    for (let i = 0; i < 12; i += 1) {
+      const zeile = await eintragen({ aktion: i % 2 ? "host.angelegt" : "anmeldung.oidc" });
+      if (i % 2) erwartet.unshift(zeile.id);
+    }
+    const groessen: number[] = [];
+    const ids: bigint[] = [];
+    for await (const stapel of protokollStapelweise(filter({ gruppe: "hosts" }), 4)) {
+      groessen.push(stapel.length);
+      ids.push(...stapel.map((z) => z.id));
+    }
+    expect(groessen).toEqual([4, 2]);
+    expect(ids).toEqual(erwartet);
+  });
+});
+
+describe("GET /api/protokoll.csv", () => {
+  async function abrufen(query = "") {
+    const { GET } = await import("@/app/api/protokoll.csv/route");
+    return GET(new Request(`http://localhost/api/protokoll.csv${query}`));
+  }
+
+  it("verweigert ohne Recht und protokolliert dann nichts", async () => {
+    recht.erlaubt = false;
+    const antwort = await abrufen();
+    expect(antwort.status).toBe(403);
+    expect(await prisma.protokoll.count()).toBe(0);
+  });
+
+  it("liefert Kopfzeile, Zeilen und entschaerft Formeln", async () => {
+    await eintragen({
+      aktion: "authorized_keys.geschrieben",
+      akteurName: "=HYPERLINK(1)",
+      hostName: "srv-pve01",
+      zielbenutzer: "root",
+      fingerprint: "SHA256:abc",
+      diff: '+ ssh-ed25519 AAAA "x"\n- ssh-rsa BBBB',
+    });
+    const antwort = await abrufen();
+    expect(antwort.status).toBe(200);
+    expect(antwort.headers.get("content-type")).toContain("text/csv");
+    expect(antwort.headers.get("content-disposition")).toMatch(/sshkv-protokoll-\d{4}-\d{2}-\d{2}\.csv/);
+    const text = (await antwort.text()).replace(/^/, "");
+    const [kopf] = text.split("\r\n");
+    expect(kopf).toBe(
+      '"id";"zeitpunkt";"akteur";"aktion";"ergebnis";"host";"zielbenutzer";"fingerprint";"diff";"details";"vorgaengerHash";"hash"',
+    );
+    expect(text).toContain(`"'=HYPERLINK(1)";"authorized_keys.geschrieben";"ERFOLG";"srv-pve01";"root"`);
+    // Mehrzeiliger Diff bleibt eine Zelle; das fuehrende „+“ wird wie eine Formel entschaerft.
+    expect(text).toContain(`"'+ ssh-ed25519 AAAA ""x""\n- ssh-rsa BBBB"`);
+    expect(text).toMatch(/\r\n"\d+";"\d{4}-\d{2}-\d{2}T[\d:.]+Z";"'=HYPERLINK/);
+  });
+
+  it("protokolliert den Export mit den Filtern", async () => {
+    await (await abrufen("?gruppe=hostkey&q=srv")).text();
+    const [eintrag] = await prisma.protokoll.findMany({ where: { aktion: "protokoll.exportiert" } });
+    expect(eintrag).toMatchObject({ akteurName: "Lea Leser", akteurId: "b-leser", ergebnis: "ERFOLG" });
+    expect(eintrag!.details).toEqual({ filter: { gruppe: "hostkey", q: "srv" } });
+  });
+
+  it("wendet die Filter der Seite an", async () => {
+    await eintragen({ aktion: "hostkey.ersetzt", hostName: "srv-a" });
+    await eintragen({ aktion: "anmeldung.oidc" });
+    const text = await (await abrufen("?gruppe=hostkey")).text();
+    expect(text).toContain("hostkey.ersetzt");
+    expect(text).not.toContain("anmeldung.oidc");
+  });
+
+  it("streamt grosse Protokolle ueber mehrere Stapel", async () => {
+    await prisma.protokoll.createMany({
+      data: Array.from({ length: 1203 }, (_, i) => ({
+        akteurName: "System",
+        aktion: "abgleich",
+        ergebnis: "ERFOLG" as const,
+        hostName: `h${i}`,
+      })),
+    });
+    const text = await (await abrufen("?gruppe=abgleich")).text();
+    expect(text.trimEnd().split("\r\n")).toHaveLength(1 + 1203);
+  });
+});
+
+describe("Kettenpruefung", () => {
+  it("prueft auf Anfrage und haelt das Ergebnis 5 Minuten", async () => {
+    await eintragen({ aktion: "host.angelegt" });
+    await eintragen({ aktion: "host.geaendert" });
+    expect(ketteZwischengespeichert()).toBeNull();
+    const ergebnis = await kettePruefenZwischengespeichert("System");
+    expect(ergebnis).toMatchObject({ fehlerhafteId: null, eintraege: 2 });
+    expect(ketteZwischengespeichert()).toBe(ergebnis);
+    expect(ketteZwischengespeichert(new Date(Date.now() + 6 * 60 * 1000))).toBeNull();
+  });
+
+  it("meldet die erste fehlerhafte ID und protokolliert den Fund", async () => {
+    await eintragen({ aktion: "host.angelegt" });
+    const zweiter = await eintragen({ aktion: "host.geaendert" });
+    await eintragen({ aktion: "host.archiviert" });
+    await prisma.$transaction([
+      prisma.$executeRawUnsafe(`ALTER TABLE "Protokoll" DISABLE TRIGGER "protokoll_kein_update"`),
+      prisma.$executeRawUnsafe(`UPDATE "Protokoll" SET "aktion" = 'gefaelscht' WHERE "id" = ${zweiter.id}`),
+      prisma.$executeRawUnsafe(`ALTER TABLE "Protokoll" ENABLE TRIGGER "protokoll_kein_update"`),
+    ]);
+    const ergebnis = await kettePruefenZwischengespeichert({ id: "b1", name: "Florian" });
+    expect(ergebnis.fehlerhafteId).toBe(String(zweiter.id));
+    expect(await prisma.protokoll.count({ where: { aktion: "protokoll.kette_beschaedigt" } })).toBe(1);
+  });
+});
+
+describe("Syslog-Weiterleitung in protokollieren()", () => {
+  afterEach(() => {
+    delete process.env["SSHKV_SYSLOG_HOST"];
+    delete process.env["SSHKV_SYSLOG_PORT"];
+    syslogZuruecksetzen();
+  });
+
+  it("ist ohne Umgebung aus", () => {
+    syslogZuruecksetzen();
+    expect(syslogKonfig()).toBeNull();
+  });
+
+  it("sendet nach dem Schreiben – ohne Details und Diff", async () => {
+    const empfaenger = createSocket("udp4");
+    const eingang = new Promise<string>((fertig) =>
+      empfaenger.once("message", (d) => fertig(d.toString("utf8"))),
+    );
+    await new Promise<void>((fertig) => empfaenger.bind(0, "127.0.0.1", fertig));
+    process.env["SSHKV_SYSLOG_HOST"] = "127.0.0.1";
+    process.env["SSHKV_SYSLOG_PORT"] = String((empfaenger.address() as AddressInfo).port);
+    syslogZuruecksetzen();
+    try {
+      await protokollieren({
+        akteur: { id: "b1", name: "Florian" },
+        aktion: "privatekey.angezeigt",
+        ergebnis: "ERFOLG",
+        fingerprint: "SHA256:xyz",
+        diff: "+ geheimer-diff",
+        details: { pfad: "/geheim/pfad", passwort: "x" },
+      });
+      const zeile = await eingang;
+      const [eintrag] = await prisma.protokoll.findMany();
+      expect(zeile).toMatch(/^<85>1 /);
+      expect(zeile).toContain(`hash="${eintrag!.hash}"`);
+      expect(zeile).toContain(`id="${eintrag!.id}"`);
+      expect(zeile).toContain('fingerprint="SHA256:xyz"');
+      expect(zeile).not.toContain("geheimer-diff");
+      expect(zeile).not.toContain("/geheim/pfad");
+    } finally {
+      empfaenger.close();
+    }
+  });
+
+  it("schreibt auch, wenn der Syslog-Server nicht erreichbar ist", async () => {
+    process.env["SSHKV_SYSLOG_HOST"] = "nicht-aufloesbar.invalid";
+    syslogZuruecksetzen();
+    const fehler = vi.spyOn(console, "error").mockImplementation(() => {});
+    await protokollieren({ akteur: "System", aktion: "abgleich", ergebnis: "ERFOLG" });
+    expect(await prisma.protokoll.count()).toBe(1);
+    fehler.mockRestore();
+  });
+});
+
+describe("Protokoll ist ueber die Anwendung nicht aenderbar", () => {
+  function dateien(verzeichnis: string): string[] {
+    return readdirSync(verzeichnis).flatMap((name) => {
+      const pfad = path.join(verzeichnis, name);
+      if (statSync(pfad).isDirectory()) return name === "generated" ? [] : dateien(pfad);
+      return /\.(ts|tsx|sql)$/.test(name) ? [pfad] : [];
+    });
+  }
+
+  it.each(dateien("src"))("%s aendert und loescht keine Protokolleintraege", (datei) => {
+    const inhalt = readFileSync(datei, "utf8");
+    expect(inhalt).not.toMatch(/\.protokoll\s*\.\s*(update|updateMany|upsert|delete|deleteMany)\b/);
+    expect(inhalt).not.toMatch(/(UPDATE|DELETE\s+FROM|TRUNCATE)\s+"?Protokoll"?/i);
+    expect(inhalt).not.toMatch(/DISABLE\s+TRIGGER/i);
+  });
+});

tests/syslog.test.ts

@@ -0,0 +1,219 @@
+import { createSocket, type Socket } from "node:dgram";
+import { createServer, type Server } from "node:net";
+import type { AddressInfo } from "node:net";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  HOECHSTLAENGE,
+  sdWertEscapen,
+  syslogKonfigAus,
+  syslogNachricht,
+  syslogSender,
+  syslogZielText,
+  tcpRahmen,
+  type SyslogEintrag,
+} from "@/lib/syslog";
+
+/** Syslog-Weiterleitung (#027): Format nach RFC 5424, Escaping, Laenge, Versand. */
+
+const EINTRAG: SyslogEintrag = {
+  id: 42n,
+  zeitpunkt: new Date("2026-10-12T14:03:07.123Z"),
+  akteur: "Florian",
+  aktion: "authorized_keys.geschrieben",
+  ergebnis: "ERFOLG",
+  hostName: "srv-pve01",
+  zielbenutzer: "root",
+  fingerprint: "SHA256:abc",
+  hash: "f00",
+};
+const KONFIG = { appName: "sshkv", facility: 10 };
+const FEST = { rechner: "vault", prozess: 7 };
+
+describe("syslogKonfigAus", () => {
+  it("ist ohne Host aus", () => {
+    expect(syslogKonfigAus({})).toBeNull();
+    expect(syslogKonfigAus({ SSHKV_SYSLOG_HOST: "  " })).toBeNull();
+  });
+
+  it("setzt Standardwerte", () => {
+    expect(syslogKonfigAus({ SSHKV_SYSLOG_HOST: "log.intern" })).toEqual({
+      host: "log.intern",
+      port: 514,
+      protokoll: "udp",
+      appName: "sshkv",
+      facility: 10,
+    });
+  });
+
+  it("liest Port, Protokoll, App-Name und Facility", () => {
+    const konfig = syslogKonfigAus({
+      SSHKV_SYSLOG_HOST: "10.0.0.5",
+      SSHKV_SYSLOG_PORT: "6514",
+      SSHKV_SYSLOG_PROTOKOLL: "TCP",
+      SSHKV_SYSLOG_APPNAME: "vault prod",
+      SSHKV_SYSLOG_FACILITY: "local3",
+    });
+    expect(konfig).toMatchObject({ port: 6514, protokoll: "tcp", appName: "vault_prod", facility: 19 });
+    expect(syslogZielText(konfig!)).toBe("tcp://10.0.0.5:6514");
+  });
+
+  it("faellt bei Unsinn auf die Standards zurueck", () => {
+    expect(
+      syslogKonfigAus({
+        SSHKV_SYSLOG_HOST: "x",
+        SSHKV_SYSLOG_PORT: "99999",
+        SSHKV_SYSLOG_FACILITY: "quatsch",
+      }),
+    ).toMatchObject({ port: 514, facility: 10, protokoll: "udp" });
+  });
+});
+
+describe("syslogNachricht", () => {
+  it("baut eine Zeile nach RFC 5424 mit strukturierten Daten", () => {
+    expect(syslogNachricht(EINTRAG, KONFIG, FEST)).toBe(
+      "<85>1 2026-10-12T14:03:07.123Z vault sshkv 7 authorized_keys.geschrieben " +
+        '[sshkv@32473 id="42" akteur="Florian" aktion="authorized_keys.geschrieben" ergebnis="ERFOLG" ' +
+        'host="srv-pve01" zielbenutzer="root" fingerprint="SHA256:abc" hash="f00"] ' +
+        "Florian: authorized_keys.geschrieben ERFOLG auf srv-pve01",
+    );
+  });
+
+  it("leitet die Severity aus dem Ergebnis ab", () => {
+    // authpriv (10) * 8 = 80; notice 5, warning 4, err 3
+    expect(syslogNachricht({ ...EINTRAG, ergebnis: "VERWEIGERT" }, KONFIG, FEST)).toMatch(/^<84>1 /);
+    expect(syslogNachricht({ ...EINTRAG, ergebnis: "FEHLER" }, KONFIG, FEST)).toMatch(/^<83>1 /);
+    expect(syslogNachricht(EINTRAG, { appName: "sshkv", facility: 16 }, FEST)).toMatch(/^<133>1 /);
+  });
+
+  it("escapt Anfuehrungszeichen, Backslash und eckige Klammer", () => {
+    expect(sdWertEscapen('a"b\\c]d')).toBe('a\\"b\\\\c\\]d');
+    const zeile = syslogNachricht({ ...EINTRAG, akteur: 'Eve "]x', zielbenutzer: "a\nb" }, KONFIG, FEST);
+    expect(zeile).toContain('akteur="Eve \\"\\]x"');
+    expect(zeile).toContain('zielbenutzer="a b"');
+    expect(zeile).not.toContain("\n");
+  });
+
+  it("laesst leere Felder weg", () => {
+    const zeile = syslogNachricht(
+      { ...EINTRAG, hostName: null, zielbenutzer: null, fingerprint: undefined },
+      KONFIG,
+      FEST,
+    );
+    expect(zeile).not.toContain("host=");
+    expect(zeile).not.toContain("fingerprint=");
+  });
+
+  it("bleibt unter der Hoechstlaenge, auch mit langen Werten", () => {
+    const lang = "ä".repeat(5000);
+    const zeile = syslogNachricht(
+      { ...EINTRAG, akteur: lang, hostName: '"'.repeat(3000), zielbenutzer: lang, fingerprint: lang },
+      KONFIG,
+      FEST,
+    );
+    expect(Buffer.byteLength(zeile, "utf8")).toBeLessThanOrEqual(HOECHSTLAENGE);
+    // Strukturierte Daten bleiben vollstaendig und geschlossen.
+    expect(zeile).toMatch(/hash="f00"\] /);
+    // Kein halbes Escape am Ende eines Werts.
+    expect(zeile).not.toMatch(/[^\\]\\"\s/);
+  });
+
+  it("rahmt fuer TCP mit Oktettzaehlung", () => {
+    expect(tcpRahmen("<85>1 ä").toString("utf8")).toBe("8 <85>1 ä");
+  });
+});
+
+describe("syslogSender", () => {
+  let empfaenger: Socket | undefined;
+  let server: Server | undefined;
+  afterEach(() => {
+    empfaenger?.close();
+    empfaenger = undefined;
+    server?.close();
+    server = undefined;
+  });
+
+  async function udpEmpfaenger(): Promise<{ port: number; naechste: () => Promise<string> }> {
+    const socket = createSocket("udp4");
+    empfaenger = socket;
+    const eingang: string[] = [];
+    const wartende: ((text: string) => void)[] = [];
+    socket.on("message", (daten) => {
+      const text = daten.toString("utf8");
+      const warten = wartende.shift();
+      if (warten) warten(text);
+      else eingang.push(text);
+    });
+    await new Promise<void>((fertig) => socket.bind(0, "127.0.0.1", fertig));
+    return {
+      port: (socket.address() as AddressInfo).port,
+      naechste: () =>
+        new Promise((fertig) => {
+          const vorhanden = eingang.shift();
+          if (vorhanden) fertig(vorhanden);
+          else wartende.push(fertig);
+        }),
+    };
+  }
+
+  it("sendet per UDP an einen lokalen Empfaenger", async () => {
+    const { port, naechste } = await udpEmpfaenger();
+    const sender = syslogSender({
+      host: "127.0.0.1",
+      port,
+      protokoll: "udp",
+      appName: "sshkv",
+      facility: 10,
+    });
+    sender.senden(EINTRAG);
+    const zeile = await naechste();
+    sender.schliessen();
+    expect(zeile).toMatch(
+      /^<85>1 2026-10-12T14:03:07.123Z \S+ sshkv \d+ authorized_keys.geschrieben \[sshkv@32473 /,
+    );
+    expect(zeile).toContain('hash="f00"');
+  });
+
+  it("sendet per TCP mit Rahmen", async () => {
+    const eingang = new Promise<string>((fertig) => {
+      server = createServer((verbindung) => {
+        verbindung.on("data", (daten) => fertig(daten.toString("utf8")));
+      });
+    });
+    await new Promise<void>((fertig) => server!.listen(0, "127.0.0.1", fertig));
+    const port = (server!.address() as AddressInfo).port;
+    const sender = syslogSender({
+      host: "127.0.0.1",
+      port,
+      protokoll: "tcp",
+      appName: "sshkv",
+      facility: 10,
+    });
+    sender.senden(EINTRAG);
+    const text = await eingang;
+    sender.schliessen();
+    const [laenge, ...rest] = text.split(" ");
+    expect(Number(laenge)).toBe(Buffer.byteLength(rest.join(" "), "utf8"));
+    expect(rest.join(" ")).toMatch(/^<85>1 /);
+  });
+
+  it("wirft nie und meldet Fehler hoechstens einmal je Minute", async () => {
+    const melden = vi.fn();
+    let uhr = 0;
+    // Port 1 auf localhost: niemand hoert zu, die Verbindung scheitert sofort.
+    const sender = syslogSender(
+      { host: "127.0.0.1", port: 1, protokoll: "tcp", appName: "sshkv", facility: 10 },
+      melden,
+      () => uhr,
+    );
+    expect(() => sender.senden(EINTRAG)).not.toThrow();
+    await vi.waitFor(() => expect(melden).toHaveBeenCalledTimes(1));
+    uhr = 30_000;
+    sender.senden(EINTRAG);
+    await new Promise((fertig) => setTimeout(fertig, 100));
+    expect(melden).toHaveBeenCalledTimes(1);
+    uhr = 61_000;
+    sender.senden(EINTRAG);
+    await vi.waitFor(() => expect(melden).toHaveBeenCalledTimes(2));
+    sender.schliessen();
+  });
+});