+
+ Administrator darf alles, auch Benutzer und Systemeinstellungen.{" "}
+ Techniker darf alles Fachliche, aber keine Benutzer anlegen.{" "}
+ Kunde sieht nur die Hosts und Rechnungen des eigenen Kunden – ohne
+ Einkaufspreise – und darf Notizen schreiben sowie Warnungen quittieren.
+
+
+
+
+
+
+ );
+}
diff --git a/src/app/(dashboard)/einstellungen/passkeys/page.tsx b/src/app/(dashboard)/einstellungen/passkeys/page.tsx
new file mode 100644
index 0000000..bdfcd4f
--- /dev/null
+++ b/src/app/(dashboard)/einstellungen/passkeys/page.tsx
@@ -0,0 +1,47 @@
+import { headers } from "next/headers";
+import { PasskeyVerwaltung } from "@/components/auth/PasskeyVerwaltung";
+import { ContentHeader } from "@/components/layout/ContentHeader";
+import { oeffentlicheBasis } from "@/lib/adresse";
+import { prisma } from "@/lib/db";
+import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
+import { passkeysMoeglich } from "@/server/auth/passkeys";
+import { einstellungen } from "@/server/einstellungen";
+
+export const metadata = { title: "Meine Passkeys" };
+export const dynamic = "force-dynamic";
+
+export default async function PasskeySeite() {
+ const ich = await sitzungErforderlich();
+ const { dashboardUrl } = await einstellungen();
+
+ const [passkeys, kopfzeilen] = await Promise.all([
+ prisma.passkey.findMany({
+ where: { benutzerId: ich.benutzerId },
+ orderBy: { erstelltAm: "desc" },
+ select: { id: true, bezeichnung: true, erstelltAm: true, zuletztAm: true },
+ }),
+ headers(),
+ ]);
+
+ // Die Seite kennt die Anfrage nur über die Kopfzeilen; daraus entsteht dieselbe Adresse,
+ // die auch die Passkey-Endpunkte verwenden.
+ const basis = oeffentlicheBasis(new Request("http://platzhalter.invalid", { headers: kopfzeilen }), dashboardUrl);
+
+ return (
+ <>
+
+
+
+
+
+
+
+ );
+}
diff --git a/src/app/(dashboard)/layout.tsx b/src/app/(dashboard)/layout.tsx
index 59b657a..3aa2f0e 100644
--- a/src/app/(dashboard)/layout.tsx
+++ b/src/app/(dashboard)/layout.tsx
@@ -1,9 +1,7 @@
-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 { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
import { kennzahlen, offeneAlerts, suchIndex } from "@/server/queries/hosts";
/**
@@ -13,9 +11,9 @@ import { kennzahlen, offeneAlerts, suchIndex } from "@/server/queries/hosts";
export const dynamic = "force-dynamic";
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");
+ // Der Schutz liegt in proxy.ts; hier wird zusätzlich geprüft, damit kein Zustand ohne Benutzer
+ // entsteht – und weil hier Rolle und Kundenbindung herkommen.
+ const sitzung = await sitzungErforderlich();
const [zahlen, alerts, suche] = await Promise.all([kennzahlen(), offeneAlerts(), suchIndex()]);
@@ -31,12 +29,14 @@ export default async function DashboardLayout({ children }: { children: React.Re
}))}
suchEintraege={suche}
benutzer={sitzung.name}
+ rolle={sitzung.rolle}
/>
{children}
diff --git a/src/app/api/auth/passkey/anmelden/route.ts b/src/app/api/auth/passkey/anmelden/route.ts
new file mode 100644
index 0000000..d89ef0b
--- /dev/null
+++ b/src/app/api/auth/passkey/anmelden/route.ts
@@ -0,0 +1,64 @@
+import { cookies } from "next/headers";
+import { cookieOptionen, SITZUNGS_COOKIE, sitzungErzeugen, ueberHttps } from "@/lib/sitzung";
+import { prisma } from "@/lib/db";
+import { protokolliere } from "@/server/audit";
+import { anmeldungPruefen, anmeldungVorbereiten, herkunft } from "@/server/auth/passkeys";
+import { einstellungen } from "@/server/einstellungen";
+
+export const dynamic = "force-dynamic";
+
+const CHALLENGE_COOKIE = "pl_passkey_anmeldung";
+
+function challengeOptionen() {
+ return {
+ httpOnly: true,
+ sameSite: "strict" as const,
+ secure: ueberHttps(),
+ path: "/",
+ maxAge: 300,
+ };
+}
+
+/** Schritt 1: Aufgabe für die Anmeldung erzeugen – ohne Benutzernamen, der Browser wählt den Schlüssel. */
+export async function GET(request: Request) {
+ const optionen = await anmeldungVorbereiten(await herkunft(request));
+ (await cookies()).set(CHALLENGE_COOKIE, optionen.challenge, challengeOptionen());
+ return Response.json(optionen);
+}
+
+/** Schritt 2: Antwort prüfen und die Sitzung anlegen. */
+export async function POST(request: Request) {
+ const speicher = await cookies();
+ const challenge = speicher.get(CHALLENGE_COOKIE)?.value;
+ if (!challenge) {
+ return Response.json({ fehler: "Die Aufgabe ist abgelaufen. Bitte erneut versuchen." }, { status: 400 });
+ }
+
+ try {
+ const antwort = await request.json();
+ const benutzer = await anmeldungPruefen(antwort, challenge, await herkunft(request));
+
+ const { sitzungsdauerStunden } = await einstellungen();
+ const token = await sitzungErzeugen(
+ {
+ benutzerId: benutzer.id,
+ email: benutzer.email,
+ name: benutzer.name,
+ herkunft: "passkey",
+ },
+ sitzungsdauerStunden,
+ );
+ speicher.set(SITZUNGS_COOKIE, token, cookieOptionen(sitzungsdauerStunden));
+
+ await prisma.benutzer.update({ where: { id: benutzer.id }, data: { letzterLoginAm: new Date() } });
+ await protokolliere("anmeldung.erfolgreich", "Benutzer", benutzer.id, { weg: "passkey" });
+
+ return Response.json({ erfolg: true });
+ } catch (fehler) {
+ console.error("Passkey-Anmeldung fehlgeschlagen:", fehler);
+ // Bewusst unscharf: Ob es den Passkey gibt, geht einen Unbekannten nichts an.
+ return Response.json({ fehler: "Anmeldung mit diesem Passkey nicht möglich." }, { status: 400 });
+ } finally {
+ speicher.delete(CHALLENGE_COOKIE);
+ }
+}
diff --git a/src/app/api/auth/passkey/registrieren/route.ts b/src/app/api/auth/passkey/registrieren/route.ts
new file mode 100644
index 0000000..2b6868d
--- /dev/null
+++ b/src/app/api/auth/passkey/registrieren/route.ts
@@ -0,0 +1,63 @@
+import { cookies } from "next/headers";
+import { ueberHttps } from "@/lib/sitzung";
+import { protokolliere } from "@/server/audit";
+import { angemeldet } from "@/server/auth/sitzungspflicht";
+import { herkunft, registrierungAbschliessen, registrierungVorbereiten } from "@/server/auth/passkeys";
+
+export const dynamic = "force-dynamic";
+
+/** Die Aufgabe („challenge“) darf nur für diesen Browser und nur kurz gelten. */
+const CHALLENGE_COOKIE = "pl_passkey_registrierung";
+
+function challengeOptionen() {
+ return {
+ httpOnly: true,
+ sameSite: "strict" as const,
+ secure: ueberHttps(),
+ path: "/",
+ maxAge: 300,
+ };
+}
+
+/** Schritt 1: Aufgabe erzeugen. */
+export async function GET(request: Request) {
+ const benutzer = await angemeldet();
+ if (!benutzer) return new Response("Nicht angemeldet", { status: 401 });
+
+ const optionen = await registrierungVorbereiten(benutzer.benutzerId, await herkunft(request));
+ (await cookies()).set(CHALLENGE_COOKIE, optionen.challenge, challengeOptionen());
+
+ return Response.json(optionen);
+}
+
+/** Schritt 2: Antwort des Browsers prüfen und den Passkey hinterlegen. */
+export async function POST(request: Request) {
+ const benutzer = await angemeldet();
+ if (!benutzer) return new Response("Nicht angemeldet", { status: 401 });
+
+ const speicher = await cookies();
+ const challenge = speicher.get(CHALLENGE_COOKIE)?.value;
+ if (!challenge) return Response.json({ fehler: "Die Aufgabe ist abgelaufen. Bitte erneut versuchen." }, { status: 400 });
+
+ try {
+ const { antwort, bezeichnung } = await request.json();
+ const passkey = await registrierungAbschliessen(
+ benutzer.benutzerId,
+ antwort,
+ challenge,
+ await herkunft(request),
+ typeof bezeichnung === "string" ? bezeichnung : "Passkey",
+ );
+
+ await protokolliere("passkey.angelegt", "Passkey", passkey.id, { bezeichnung: passkey.bezeichnung });
+ return Response.json({ erfolg: true, bezeichnung: passkey.bezeichnung });
+ } catch (fehler) {
+ console.error("Passkey-Registrierung fehlgeschlagen:", fehler);
+ return Response.json(
+ { fehler: fehler instanceof Error ? fehler.message : "Der Passkey ließ sich nicht hinterlegen." },
+ { status: 400 },
+ );
+ } finally {
+ speicher.delete(CHALLENGE_COOKIE);
+ }
+}
diff --git a/src/components/auth/PasskeyAnmeldung.tsx b/src/components/auth/PasskeyAnmeldung.tsx
new file mode 100644
index 0000000..af2ff3f
--- /dev/null
+++ b/src/components/auth/PasskeyAnmeldung.tsx
@@ -0,0 +1,66 @@
+"use client";
+
+import { startAuthentication } from "@simplewebauthn/browser";
+import { useRouter } from "next/navigation";
+import { useState } from "react";
+
+/**
+ * Anmeldung per Passkey. Der Knopf erscheint immer; ob ein Passkey vorliegt, weiß erst der Browser –
+ * und das darf die Seite auch nicht vorher verraten (sonst ließen sich Konten ausspähen).
+ */
+export function PasskeyAnmeldung({ ziel }: { ziel: string }) {
+ const router = useRouter();
+ const [laeuft, setLaeuft] = useState(false);
+ const [fehler, setFehler] = useState(null);
+
+ async function anmelden() {
+ setLaeuft(true);
+ setFehler(null);
+
+ try {
+ const optionen = await fetch("/api/auth/passkey/anmelden").then((antwort) => antwort.json());
+ const antwort = await startAuthentication({ optionsJSON: optionen });
+
+ const ergebnis = await fetch("/api/auth/passkey/anmelden", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify(antwort),
+ }).then((a) => a.json());
+
+ if (ergebnis.erfolg) {
+ router.push(ziel.startsWith("/") ? ziel : "/");
+ router.refresh();
+ } else {
+ setFehler(ergebnis.fehler ?? "Anmeldung nicht möglich.");
+ }
+ } catch (fehler) {
+ setFehler(
+ fehler instanceof Error && fehler.name === "NotAllowedError"
+ ? "Abgebrochen."
+ : "Mit diesem Gerät geht es nicht. Passkeys brauchen HTTPS.",
+ );
+ } finally {
+ setLaeuft(false);
+ }
+ }
+
+ return (
+ <>
+ {fehler ? (
+
+ Über diese Adresse geht es nicht. Passkeys verlangen HTTPS; nur{" "}
+ localhost ist ausgenommen. Aufgerufen wurde {adresse}. Richten Sie
+ einen Reverse Proxy mit Zertifikat ein und tragen Sie die Adresse unter{" "}
+ Einstellungen → System ein.
+
+ ) : null}
+
+ {meldung ? (
+
+ {meldung.text}
+
+ ) : null}
+
+
+
+
+ setBezeichnung(e.target.value)}
+ placeholder="z. B. Arbeitsrechner oder Telefon"
+ disabled={!moeglich}
+ />
+
Hilft später beim Wiedererkennen, wenn mehrere hinterlegt sind.
+
+
+
+
+
+
+
+
+ {passkeys.length === 0 ? (
+
+ Noch keiner. Ohne Passkey bleibt die Anmeldung per Passwort oder OIDC – beides funktioniert
+ weiterhin.
+