feat(auth): Anmeldung mit Passwort und OIDC, Schutz aller Seiten (#013)

Signierte Sitzungs-Cookies mit jose, OIDC ueber openid-client (authentik), Schutz in proxy.ts, Anmeldeseite, Audit-Log-Ansicht, Sicherheits-Kopfzeilen und Rate-Limit. Kein Auth.js, weil Version 5 Beta ist. 147 Tests. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-09-17 22:40:03 +02:00
parent 6cc39591b7
commit ee487775ec
26 changed files with 945 additions and 27 deletions
@@ -0,0 +1,62 @@
+import Link from "next/link";
+import { AnmeldeFormular } from "@/components/auth/AnmeldeFormular";
+import { Logo } from "@/components/Logo";
+import { oidcEinstellungen } from "@/server/auth/oidc";
+
+export const dynamic = "force-dynamic";
+export const metadata = { title: "Anmelden" };
+
+type SuchParameter = Promise<Record<string, string | string[] | undefined>>;
+
+export default async function AnmeldeSeite({ searchParams }: { searchParams: SuchParameter }) {
+  const roh = await searchParams;
+  const einzeln = (wert: string | string[] | undefined) => (Array.isArray(wert) ? wert[0] : wert);
+  const ziel = einzeln(roh.ziel) ?? "/";
+  const fehler = einzeln(roh.fehler);
+  const oidc = oidcEinstellungen();
+
+  return (
+    <main className="d-flex align-items-center justify-content-center min-vh-100 p-3">
+      <div style={{ width: "min(24rem, 100%)" }}>
+        <div className="text-center mb-4">
+          <Logo groesse={64} titel="ProxLedger" />
+          <h1 className="h4 mt-3 mb-1" style={{ fontWeight: 300 }}>
+            ProxLedger
+          </h1>
+          <p className="text-body-secondary small mb-0">Proxmox Subscription Dashboard</p>
+        </div>
+
+        <div className="card shadow-sm">
+          <div className="card-body">
+            {fehler ? (
+              <div className="alert alert-danger py-2" role="alert">
+                {fehler === "oidc"
+                  ? "Die Anmeldung über den Anbieter hat nicht geklappt."
+                  : "Anmeldung nicht möglich."}
+              </div>
+            ) : null}
+
+            {oidc ? (
+              <>
+                <Link
+                  href={`/api/auth/oidc/start?ziel=${encodeURIComponent(ziel)}`}
+                  className="btn btn-primary w-100 pl-touch-target mb-3"
+                >
+                  <i className="bi bi-box-arrow-in-right me-1" aria-hidden="true" />
+                  Mit {oidc.bezeichnung} anmelden
+                </Link>
+                <div className="text-center text-body-secondary small mb-3">oder mit Passwort</div>
+              </>
+            ) : null}
+
+            <AnmeldeFormular ziel={ziel} />
+          </div>
+        </div>
+
+        <p className="text-center text-body-secondary small mt-3 mb-0">
+          Der lokale Zugang bleibt auch dann nutzbar, wenn der Anmeldedienst ausfällt.
+        </p>
+      </div>
+    </main>
+  );
+}
@@ -0,0 +1,112 @@
+import Link from "next/link";
+import { ContentHeader } from "@/components/layout/ContentHeader";
+import { Card } from "@/components/ui/Card";
+import { prisma } from "@/lib/db";
+import { formatDatumZeit } from "@/lib/format";
+
+export const metadata = { title: "Protokoll" };
+
+type SuchParameter = Promise<Record<string, string | string[] | undefined>>;
+
+export default async function AuditSeite({ searchParams }: { searchParams: SuchParameter }) {
+  const roh = await searchParams;
+  const einzeln = (wert: string | string[] | undefined) => (Array.isArray(wert) ? wert[0] : wert);
+  const aktion = einzeln(roh.aktion);
+  const entitaet = einzeln(roh.entitaet);
+
+  const [eintraege, aktionen] = await Promise.all([
+    prisma.auditEintrag.findMany({
+      where: {
+        ...(aktion ? { aktion } : {}),
+        ...(entitaet ? { entitaet } : {}),
+      },
+      orderBy: { erstelltAm: "desc" },
+      take: 200,
+      include: { benutzer: { select: { name: true, email: true } } },
+    }),
+    prisma.auditEintrag.groupBy({ by: ["aktion"], _count: { _all: true }, orderBy: { aktion: "asc" } }),
+  ]);
+
+  return (
+    <>
+      <ContentHeader titel="Protokoll" brotkrumen={[{ titel: "Einstellungen" }, { titel: "Protokoll" }]} />
+
+      <div className="app-content">
+        <div className="container-fluid">
+          <Card titel={`Letzte ${eintraege.length} Einträge`} rahmen="primary" tabelle>
+            <form className="row g-2 p-3 border-bottom">
+              <div className="col-md-4">
+                <select name="aktion" defaultValue={aktion ?? ""} className="form-select" aria-label="Aktion">
+                  <option value="">Alle Aktionen</option>
+                  {aktionen.map((eintrag) => (
+                    <option key={eintrag.aktion} value={eintrag.aktion}>
+                      {eintrag.aktion} ({eintrag._count._all})
+                    </option>
+                  ))}
+                </select>
+              </div>
+              <div className="col-md-3">
+                <input
+                  name="entitaet"
+                  defaultValue={entitaet ?? ""}
+                  className="form-control"
+                  placeholder="Entität, z. B. Host"
+                  aria-label="Entität"
+                />
+              </div>
+              <div className="col-md-2">
+                <button type="submit" className="btn btn-primary w-100">
+                  Filtern
+                </button>
+              </div>
+              <div className="col-md-3 d-flex align-items-center">
+                {aktion || entitaet ? <Link href="/einstellungen/audit">Filter zurücksetzen</Link> : null}
+              </div>
+            </form>
+
+            <div className="table-responsive">
+              <table className="table table-striped align-middle">
+                <thead>
+                  <tr>
+                    <th scope="col">Zeitpunkt</th>
+                    <th scope="col">Aktion</th>
+                    <th scope="col">Entität</th>
+                    <th scope="col">Benutzer</th>
+                    <th scope="col">Details</th>
+                  </tr>
+                </thead>
+                <tbody>
+                  {eintraege.map((eintrag) => (
+                    <tr key={eintrag.id}>
+                      <td className="small">{formatDatumZeit(eintrag.erstelltAm)}</td>
+                      <td className="pl-mono small">{eintrag.aktion}</td>
+                      <td className="small">
+                        {eintrag.entitaet}
+                        {eintrag.entitaetId ? (
+                          <div className="text-body-secondary pl-mono">{eintrag.entitaetId}</div>
+                        ) : null}
+                      </td>
+                      <td className="small">{eintrag.benutzer?.name ?? "System"}</td>
+                      <td className="small text-body-secondary" style={{ maxWidth: "28rem" }}>
+                        <span className="d-inline-block text-truncate w-100">
+                          {eintrag.aenderung ? JSON.stringify(eintrag.aenderung) : "–"}
+                        </span>
+                      </td>
+                    </tr>
+                  ))}
+                  {eintraege.length === 0 ? (
+                    <tr>
+                      <td colSpan={5} className="text-center text-body-secondary py-4">
+                        Keine Einträge gefunden.
+                      </td>
+                    </tr>
+                  ) : null}
+                </tbody>
+              </table>
+            </div>
+          </Card>
+        </div>
+      </div>
+    </>
+  );
+}
@@ -1,6 +1,9 @@
+import { cookies } from "next/headers";
+import { redirect } from "next/navigation";
 import { Footer } from "@/components/layout/Footer";
 import { Header } from "@/components/layout/Header";
 import { Sidebar } from "@/components/layout/Sidebar";
+import { SITZUNGS_COOKIE, sitzungLesen } from "@/lib/sitzung";
 import { kennzahlen, offeneAlerts, suchIndex } from "@/server/queries/hosts";

 /**
@@ -9,9 +12,11 @@ import { kennzahlen, offeneAlerts, suchIndex } from "@/server/queries/hosts";
 */
 export const dynamic = "force-dynamic";

-const BENUTZER = "Florian";
-
 export default async function DashboardLayout({ children }: { children: React.ReactNode }) {
+  // Der Schutz liegt in proxy.ts; hier wird zusätzlich geprüft, damit kein Zustand ohne Benutzer entsteht.
+  const sitzung = await sitzungLesen((await cookies()).get(SITZUNGS_COOKIE)?.value);
+  if (!sitzung) redirect("/login");
+
  const [zahlen, alerts, suche] = await Promise.all([kennzahlen(), offeneAlerts(), suchIndex()]);

  return (
@@ -25,13 +30,13 @@ export default async function DashboardLayout({ children }: { children: React.Re
          hostId: alert.hostId,
        }))}
        suchEintraege={suche}
-        benutzer={BENUTZER}
+        benutzer={sitzung.name}
      />
      <Sidebar
        hostsAnzahl={zahlen.hostsGesamt}
        offeneRechnungspunkte={zahlen.offeneRechnungspunkte}
        offeneWarnungen={zahlen.offeneAlerts}
-        benutzer={BENUTZER}
+        benutzer={sitzung.name}
      />
      <main className="app-main">{children}</main>
      <Footer />
@@ -0,0 +1,10 @@
+import { cookies } from "next/headers";
+import { SITZUNGS_COOKIE } from "@/lib/sitzung";
+
+export const dynamic = "force-dynamic";
+
+/** Abmelden per Link; löscht das Sitzungs-Cookie. */
+export async function GET(request: Request) {
+  (await cookies()).delete(SITZUNGS_COOKIE);
+  return Response.redirect(new URL("/login", request.url), 302);
+}
@@ -0,0 +1,41 @@
+import { cookies } from "next/headers";
+import { cookieOptionen, SITZUNGS_COOKIE, sitzungErzeugen } from "@/lib/sitzung";
+import { mitOidcAnmelden } from "@/server/auth/benutzer";
+import { anmeldungAbschliessen, oidcEinstellungen } from "@/server/auth/oidc";
+
+export const dynamic = "force-dynamic";
+
+/** Nimmt die Rückkehr vom Anmeldedienst entgegen und legt die Sitzung an. */
+export async function GET(request: Request) {
+  const einstellungen = oidcEinstellungen();
+  const speicher = await cookies();
+  const pruefwert = speicher.get("pl_oidc_pruefwert")?.value;
+  const zustand = speicher.get("pl_oidc_zustand")?.value;
+  const ziel = speicher.get("pl_oidc_ziel")?.value ?? "/";
+
+  for (const name of ["pl_oidc_pruefwert", "pl_oidc_zustand", "pl_oidc_ziel"]) {
+    speicher.delete(name);
+  }
+
+  if (!einstellungen || !pruefwert || !zustand) {
+    return Response.redirect(new URL("/login?fehler=oidc", request.url), 302);
+  }
+
+  try {
+    const angaben = await anmeldungAbschliessen(einstellungen, new URL(request.url), pruefwert, zustand);
+    const benutzer = await mitOidcAnmelden(angaben.subject, angaben.email, angaben.name);
+
+    const token = await sitzungErzeugen({
+      benutzerId: benutzer.id,
+      email: benutzer.email,
+      name: benutzer.name,
+      herkunft: "oidc",
+    });
+    speicher.set(SITZUNGS_COOKIE, token, cookieOptionen());
+
+    return Response.redirect(new URL(ziel.startsWith("/") ? ziel : "/", request.url), 302);
+  } catch (fehler) {
+    console.error("OIDC-Rückkehr fehlgeschlagen:", fehler);
+    return Response.redirect(new URL("/login?fehler=oidc", request.url), 302);
+  }
+}
@@ -0,0 +1,35 @@
+import { cookies } from "next/headers";
+import { anmeldungStarten, oidcEinstellungen } from "@/server/auth/oidc";
+
+export const dynamic = "force-dynamic";
+
+/** Schickt den Browser zum Anmeldedienst und merkt sich PKCE-Prüfwert und Zustand im Cookie. */
+export async function GET(request: Request) {
+  const einstellungen = oidcEinstellungen();
+  if (!einstellungen) {
+    return Response.redirect(new URL("/login?fehler=oidc", request.url), 302);
+  }
+
+  const ziel = new URL(request.url).searchParams.get("ziel") ?? "/";
+
+  try {
+    const start = await anmeldungStarten(einstellungen);
+    const speicher = await cookies();
+    const optionen = {
+      httpOnly: true,
+      sameSite: "lax" as const,
+      secure: process.env.NODE_ENV === "production",
+      path: "/",
+      maxAge: 600,
+    };
+
+    speicher.set("pl_oidc_pruefwert", start.pruefwert, optionen);
+    speicher.set("pl_oidc_zustand", start.zustand, optionen);
+    speicher.set("pl_oidc_ziel", ziel.startsWith("/") ? ziel : "/", optionen);
+
+    return Response.redirect(start.url, 302);
+  } catch (fehler) {
+    console.error("OIDC-Start fehlgeschlagen:", fehler);
+    return Response.redirect(new URL("/login?fehler=oidc", request.url), 302);
+  }
+}
@@ -0,0 +1,55 @@
+"use client";
+
+import { useActionState } from "react";
+import { anmelden } from "@/server/actions/auth";
+import type { AktionsErgebnis } from "@/server/actions/kunden";
+
+const LEER: AktionsErgebnis = {};
+
+export function AnmeldeFormular({ ziel }: { ziel: string }) {
+  const [ergebnis, aktion, laeuft] = useActionState(anmelden, LEER);
+
+  return (
+    <form action={aktion}>
+      <input type="hidden" name="ziel" value={ziel} />
+
+      {ergebnis.fehler ? (
+        <div className="alert alert-danger py-2" role="alert">
+          {ergebnis.fehler}
+        </div>
+      ) : null}
+
+      <div className="mb-3">
+        <label className="form-label" htmlFor="email">
+          E-Mail-Adresse
+        </label>
+        <input
+          id="email"
+          name="email"
+          type="email"
+          className="form-control"
+          autoComplete="username"
+          required
+        />
+      </div>
+
+      <div className="mb-3">
+        <label className="form-label" htmlFor="passwort">
+          Passwort
+        </label>
+        <input
+          id="passwort"
+          name="passwort"
+          type="password"
+          className="form-control"
+          autoComplete="current-password"
+          required
+        />
+      </div>
+
+      <button type="submit" className="btn btn-primary w-100 pl-touch-target" disabled={laeuft}>
+        {laeuft ? "Meldet an …" : "Anmelden"}
+      </button>
+    </form>
+  );
+}
@@ -214,7 +214,9 @@ export function Header({
              <Link href="/einstellungen/system" className="dropdown-item">
                Einstellungen
              </Link>
-              <span className="dropdown-item text-body-secondary">Abmelden (ab #013)</span>
+              <a className="dropdown-item" href="/api/auth/abmelden">
+                Abmelden
+              </a>
            </div>
          </li>
        </ul>
@@ -58,6 +58,7 @@ export function Sidebar({
    { href: "/einstellungen/tokens", titel: "Agent-Tokens", icon: "bi-key" },
    { href: "/einstellungen/warnregeln", titel: "Warnregeln", icon: "bi-shield-exclamation" },
    { href: "/einstellungen/benachrichtigungen", titel: "Benachrichtigungen", icon: "bi-bell" },
+    { href: "/einstellungen/audit", titel: "Protokoll", icon: "bi-list-check" },
    { href: "/einstellungen/system", titel: "System", icon: "bi-sliders" },
  ];

@@ -0,0 +1,64 @@
+import { SignJWT, jwtVerify } from "jose";
+
+/**
+ * Sitzungen als signiertes Token im Cookie – kein Serverzustand nötig.
+ * Der Schlüssel kommt aus `APP_SECRET`; ohne ihn startet die Anmeldung nicht.
+ */
+
+export const SITZUNGS_COOKIE = "pl_sitzung";
+export const SITZUNGSDAUER_STUNDEN = 12;
+
+export interface Sitzung {
+  benutzerId: string;
+  email: string;
+  name: string;
+  /** Woher die Anmeldung stammt – für das Audit-Log und die Anzeige. */
+  herkunft: "passwort" | "oidc";
+}
+
+function schluessel(): Uint8Array {
+  const geheimnis = process.env.APP_SECRET;
+  if (!geheimnis || geheimnis.length < 32) {
+    throw new Error(
+      "APP_SECRET fehlt oder ist zu kurz (mindestens 32 Zeichen). Beispiel: openssl rand -base64 48",
+    );
+  }
+  return new TextEncoder().encode(geheimnis);
+}
+
+export async function sitzungErzeugen(sitzung: Sitzung): Promise<string> {
+  return new SignJWT({ ...sitzung })
+    .setProtectedHeader({ alg: "HS256" })
+    .setSubject(sitzung.benutzerId)
+    .setIssuedAt()
+    .setIssuer("proxledger")
+    .setExpirationTime(`${SITZUNGSDAUER_STUNDEN}h`)
+    .sign(schluessel());
+}
+
+/** Prüft das Token; bei ungültiger Signatur oder Ablauf kommt null zurück. */
+export async function sitzungLesen(token: string | undefined): Promise<Sitzung | null> {
+  if (!token) return null;
+  try {
+    const { payload } = await jwtVerify(token, schluessel(), { issuer: "proxledger" });
+    if (typeof payload.benutzerId !== "string" || typeof payload.email !== "string") return null;
+    return {
+      benutzerId: payload.benutzerId,
+      email: payload.email,
+      name: typeof payload.name === "string" ? payload.name : payload.email,
+      herkunft: payload.herkunft === "oidc" ? "oidc" : "passwort",
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function cookieOptionen() {
+  return {
+    httpOnly: true,
+    sameSite: "lax" as const,
+    secure: process.env.NODE_ENV === "production",
+    path: "/",
+    maxAge: SITZUNGSDAUER_STUNDEN * 3600,
+  };
+}
@@ -0,0 +1,38 @@
+import { NextResponse, type NextRequest } from "next/server";
+import { SITZUNGS_COOKIE, sitzungLesen } from "@/lib/sitzung";
+
+/**
+ * Schützt die Oberfläche: Ohne gültige Sitzung führt jeder Weg zur Anmeldung.
+ * Die Agent-API bleibt bewusst außen vor – sie authentifiziert sich mit eigenen Tokens.
+ * (In Next 16 heißt diese Datei `proxy.ts`, früher `middleware.ts`.)
+ */
+
+const OEFFENTLICH = [
+  "/login",
+  "/api/auth",
+  "/api/agent",
+  "/install.sh",
+  "/agent.sh",
+  "/favicon.ico",
+  "/icon.svg",
+];
+
+export async function proxy(request: NextRequest) {
+  const pfad = request.nextUrl.pathname;
+
+  if (OEFFENTLICH.some((eintrag) => pfad === eintrag || pfad.startsWith(`${eintrag}/`))) {
+    return NextResponse.next();
+  }
+
+  const sitzung = await sitzungLesen(request.cookies.get(SITZUNGS_COOKIE)?.value);
+  if (sitzung) return NextResponse.next();
+
+  const ziel = new URL("/login", request.url);
+  if (pfad !== "/") ziel.searchParams.set("ziel", `${pfad}${request.nextUrl.search}`);
+  return NextResponse.redirect(ziel);
+}
+
+export const config = {
+  // Statische Dateien und Bilder brauchen keine Prüfung.
+  matcher: ["/((?!_next/static|_next/image|.*\\.(?:png|jpg|svg|ico|woff2)$).*)"],
+};
@@ -0,0 +1,47 @@
+"use server";
+
+import { cookies, headers } from "next/headers";
+import { redirect } from "next/navigation";
+import { cookieOptionen, SITZUNGS_COOKIE, sitzungErzeugen } from "@/lib/sitzung";
+import { clientIp } from "@/lib/ratelimit";
+import { protokolliere } from "@/server/audit";
+import { AnmeldeFehler, mitPasswortAnmelden } from "@/server/auth/benutzer";
+import type { AktionsErgebnis } from "./kunden";
+
+/** Anmeldung mit E-Mail und Passwort (Rückfallweg, wenn OIDC nicht erreichbar ist). */
+export async function anmelden(_vorher: AktionsErgebnis, formular: FormData): Promise<AktionsErgebnis> {
+  const email = formular.get("email")?.toString().trim() ?? "";
+  const passwort = formular.get("passwort")?.toString() ?? "";
+  const ziel = formular.get("ziel")?.toString() || "/";
+
+  if (!email || !passwort) {
+    return { fehler: "Bitte E-Mail-Adresse und Passwort eingeben." };
+  }
+
+  try {
+    const kopfzeilen = await headers();
+    const benutzer = await mitPasswortAnmelden(email, passwort, clientIp(kopfzeilen));
+
+    const token = await sitzungErzeugen({
+      benutzerId: benutzer.id,
+      email: benutzer.email,
+      name: benutzer.name,
+      herkunft: "passwort",
+    });
+
+    (await cookies()).set(SITZUNGS_COOKIE, token, cookieOptionen());
+  } catch (fehler) {
+    if (fehler instanceof AnmeldeFehler) return { fehler: fehler.message };
+    throw fehler;
+  }
+
+  // Nur eigene Pfade als Ziel zulassen, damit die Anmeldung nicht auf fremde Seiten führt.
+  redirect(ziel.startsWith("/") && !ziel.startsWith("//") ? ziel : "/");
+}
+
+export async function abmelden() {
+  const speicher = await cookies();
+  speicher.delete(SITZUNGS_COOKIE);
+  await protokolliere("abmeldung", "Benutzer", null, {});
+  redirect("/login");
+}
@@ -1,17 +1,32 @@
+import { cookies } from "next/headers";
 import { prisma } from "@/lib/db";
+import { SITZUNGS_COOKIE, sitzungLesen } from "@/lib/sitzung";

 /**
- * Schreibt einen Eintrag ins Audit-Log. Solange es keine Anmeldung gibt (#013),
- * bleibt `benutzerId` leer und die Änderung gilt als vom System ausgelöst.
+ * Schreibt einen Eintrag ins Audit-Log. Läuft die Aktion in einer Anfrage, wird der angemeldete
+ * Benutzer vermerkt; im Worker oder in Skripten bleibt das Feld leer („System“).
 */
+async function angemeldeterBenutzer(): Promise<string | null> {
+  try {
+    const sitzung = await sitzungLesen((await cookies()).get(SITZUNGS_COOKIE)?.value);
+    return sitzung?.benutzerId ?? null;
+  } catch {
+    // Außerhalb einer Anfrage gibt es keine Cookies – das ist kein Fehler.
+    return null;
+  }
+}
+
 export async function protokolliere(
  aktion: string,
  entitaet: string,
  entitaetId: string | null,
  aenderung?: Record<string, unknown>,
 ) {
+  const benutzerId = await angemeldeterBenutzer();
+
  await prisma.auditEintrag.create({
    data: {
+      benutzerId,
      aktion,
      entitaet,
      entitaetId,
@@ -0,0 +1,77 @@
+import { verify } from "@node-rs/argon2";
+import type { BenutzerModel } from "@/generated/prisma/models";
+import { prisma } from "@/lib/db";
+import { RateLimit } from "@/lib/ratelimit";
+import { protokolliere } from "@/server/audit";
+
+/** Anmeldeversuche: fünf pro Viertelstunde je Kennung, damit Raten teuer wird. */
+export const anmeldeRateLimit = new RateLimit(5, 5 / 900);
+
+export class AnmeldeFehler extends Error {}
+
+/** Prüft E-Mail und Passwort. Fehlermeldungen verraten bewusst nicht, welcher Teil falsch war. */
+export async function mitPasswortAnmelden(
+  email: string,
+  passwort: string,
+  quelle: string,
+): Promise<BenutzerModel> {
+  const kennung = `${quelle}:${email.toLowerCase()}`;
+  if (!anmeldeRateLimit.pruefe(kennung).erlaubt) {
+    throw new AnmeldeFehler("Zu viele Versuche. Bitte einige Minuten warten.");
+  }
+
+  const benutzer = await prisma.benutzer.findUnique({ where: { email: email.toLowerCase().trim() } });
+
+  if (!benutzer?.passwortHash || !benutzer.aktiv) {
+    await protokolliere("anmeldung.fehlgeschlagen", "Benutzer", benutzer?.id ?? null, { email });
+    throw new AnmeldeFehler("E-Mail-Adresse oder Passwort stimmt nicht.");
+  }
+
+  const stimmt = await verify(benutzer.passwortHash, passwort).catch(() => false);
+  if (!stimmt) {
+    await protokolliere("anmeldung.fehlgeschlagen", "Benutzer", benutzer.id, { email });
+    throw new AnmeldeFehler("E-Mail-Adresse oder Passwort stimmt nicht.");
+  }
+
+  await prisma.benutzer.update({ where: { id: benutzer.id }, data: { letzterLoginAm: new Date() } });
+  await protokolliere("anmeldung.erfolgreich", "Benutzer", benutzer.id, { weg: "passwort" });
+
+  return benutzer;
+}
+
+/**
+ * Ordnet eine OIDC-Anmeldung einem Benutzer zu: erst über die Subject-ID, sonst über die E-Mail.
+ * Ein unbekanntes Konto wird angelegt – wer sich bei authentik anmelden darf, darf auch hier arbeiten.
+ */
+export async function mitOidcAnmelden(subject: string, email: string, name: string): Promise<BenutzerModel> {
+  const normalisiert = email.toLowerCase().trim();
+
+  const vorhanden =
+    (await prisma.benutzer.findUnique({ where: { oidcSubject: subject } })) ??
+    (await prisma.benutzer.findUnique({ where: { email: normalisiert } }));
+
+  if (vorhanden && !vorhanden.aktiv) {
+    throw new AnmeldeFehler("Dieses Konto ist deaktiviert.");
+  }
+
+  const benutzer = vorhanden
+    ? await prisma.benutzer.update({
+        where: { id: vorhanden.id },
+        data: { oidcSubject: subject, name: name || vorhanden.name, letzterLoginAm: new Date() },
+      })
+    : await prisma.benutzer.create({
+        data: {
+          email: normalisiert,
+          name: name || normalisiert,
+          oidcSubject: subject,
+          letzterLoginAm: new Date(),
+        },
+      });
+
+  await protokolliere("anmeldung.erfolgreich", "Benutzer", benutzer.id, {
+    weg: "oidc",
+    neuAngelegt: vorhanden === null,
+  });
+
+  return benutzer;
+}
@@ -0,0 +1,100 @@
+import * as client from "openid-client";
+
+/**
+ * Anmeldung über OIDC (getestet mit authentik). Die Einrichtung erfolgt über Umgebungsvariablen,
+ * damit Zugangsdaten nicht in der Datenbank liegen.
+ */
+
+export interface OidcEinstellungen {
+  ausstellerUrl: string;
+  clientId: string;
+  clientSecret: string;
+  /** Anzeigename auf dem Anmeldeknopf. */
+  bezeichnung: string;
+}
+
+export function oidcEinstellungen(): OidcEinstellungen | null {
+  const ausstellerUrl = process.env.OIDC_ISSUER;
+  const clientId = process.env.OIDC_CLIENT_ID;
+  const clientSecret = process.env.OIDC_CLIENT_SECRET;
+
+  if (!ausstellerUrl || !clientId || !clientSecret) return null;
+
+  return {
+    ausstellerUrl,
+    clientId,
+    clientSecret,
+    bezeichnung: process.env.OIDC_NAME ?? "authentik",
+  };
+}
+
+export function rueckkehrAdresse(): string {
+  const basis = (process.env.APP_URL ?? "http://localhost:3000").replace(/\/$/, "");
+  return `${basis}/api/auth/oidc/callback`;
+}
+
+async function konfiguration(einstellungen: OidcEinstellungen) {
+  return client.discovery(
+    new URL(einstellungen.ausstellerUrl),
+    einstellungen.clientId,
+    einstellungen.clientSecret,
+  );
+}
+
+export interface AnmeldeStart {
+  url: string;
+  pruefwert: string;
+  zustand: string;
+}
+
+/** Baut die Adresse beim Anbieter samt PKCE-Prüfwert. */
+export async function anmeldungStarten(einstellungen: OidcEinstellungen): Promise<AnmeldeStart> {
+  const konfig = await konfiguration(einstellungen);
+  const pruefwert = client.randomPKCECodeVerifier();
+  const herausforderung = await client.calculatePKCECodeChallenge(pruefwert);
+  const zustand = client.randomState();
+
+  const url = client.buildAuthorizationUrl(konfig, {
+    redirect_uri: rueckkehrAdresse(),
+    scope: "openid email profile",
+    code_challenge: herausforderung,
+    code_challenge_method: "S256",
+    state: zustand,
+  });
+
+  return { url: url.href, pruefwert, zustand };
+}
+
+export interface OidcBenutzer {
+  subject: string;
+  email: string;
+  name: string;
+}
+
+/** Löst den Rückkehr-Code beim Anbieter ein und liest die Benutzerangaben. */
+export async function anmeldungAbschliessen(
+  einstellungen: OidcEinstellungen,
+  aktuelleUrl: URL,
+  pruefwert: string,
+  zustand: string,
+): Promise<OidcBenutzer> {
+  const konfig = await konfiguration(einstellungen);
+
+  const tokens = await client.authorizationCodeGrant(konfig, aktuelleUrl, {
+    pkceCodeVerifier: pruefwert,
+    expectedState: zustand,
+  });
+
+  const angaben = tokens.claims();
+  if (!angaben?.sub) throw new Error("Der Anbieter hat keine Benutzerkennung geliefert.");
+
+  const email = typeof angaben.email === "string" ? angaben.email : "";
+  if (!email) throw new Error("Der Anbieter hat keine E-Mail-Adresse geliefert.");
+
+  const name =
+    (typeof angaben.name === "string" && angaben.name) ||
+    (typeof angaben.preferred_username === "string" && angaben.preferred_username) ||
+    email;
+
+  return { subject: angaben.sub, email, name };
+}