docs: README, Datenschutztexte, Dockerfile und Sicherungsskripte

Damit ist Etappe 1 abgeschlossen und betriebsfertig dokumentiert.

README mit beiden Betriebswegen. Docker Compose auf eigenem Server ist
der Hauptweg; Vercel und Neon sind vollstaendig beschrieben, aber mit
einer klaren Begruendung, warum ich davon abrate: beide Anbieter sind
US-Unternehmen und unterliegen auch bei EU-Region potenziell dem
CLOUD-Act. Bei Gesundheitsdaten einer nicht entscheidungsfaehigen Person
ist das eine Abwaegung, die man bewusst treffen muss.

Reverse-Proxy-Beispiele fuer Caddy, nginx und Traefik - der Proxy selbst
ist nicht Teil des Compose-Setups, weil er auf dem Zielserver schon
steht. Die Datenbank hat keine Portfreigabe.

Sicherung: pg_dump schreibt direkt in die Verschluesselung, der Klartext
landet nie auf der Platte. Danach eine Selbstpruefung - laesst sich die
Datei nicht wieder entschluesseln, endet der Lauf mit Fehler statt mit
einem stillen Scheinerfolg. Der jeweils erste Stand eines Monats bleibt
dauerhaft stehen.

Die README sagt ausdruecklich, was das Backup NICHT enthaelt: den
Schluessel ENC_KEY_V1 und die Dateien im Objektspeicher. Dazu eine
Anleitung, die Wiederherstellung einmal im Jahr zu ueben - mit dem
letzten Schritt, in der Anwendung nachzusehen, ob die Diagnosen im
Klartext erscheinen. Erst dann stimmt nicht nur die Datenbank, sondern
auch der Schluessel.

Verarbeitungsverzeichnis und Datenschutzhinweise als ausfuellbare
Textbausteine. Die Hinweise sind in einfacher Sprache geschrieben - sie
sollen der betreuten Person vorgelesen werden koennen. Die Seite
/datenschutz liest denselben Text aus docs/, damit es nicht zwei
Fassungen gibt, die auseinanderlaufen.

Dockerfile in drei Stufen mit Tesseract, deutschen Sprachdaten und
poppler-utils. Zeitzone Europe/Berlin ist gesetzt - ohne sie rechnet der
Server in UTC und verschiebt Fristen um einen Tag.

Etappe: 1
Phase: Fundament

src/app/api/dokumente/datei/[signatur]/route.ts

@@ -0,0 +1,170 @@
+import { NextResponse } from 'next/server'
+import type { Modul } from '@prisma/client'
+import { protokollieren } from '@/lib/audit'
+import { darf } from '@/lib/auth/rollen'
+import { aktuellerBenutzer } from '@/lib/auth/sitzung'
+import { db, nichtGeloescht } from '@/lib/db'
+import { typErkennen } from '@/lib/speicher/dateityp'
+import { betreuteIdAusSchluessel, lesen } from '@/lib/speicher'
+import { zugriffTokenPruefen } from '@/lib/speicher/schluessel'
+
+/**
+ * Auslieferung einer abgelegten Datei beim Dateitreiber.
+ *
+ * Hierher zeigt `signierteUrl()`, wenn kein Objektspeicher konfiguriert
+ * ist. Vier Schranken stehen hintereinander, und jede muss halten:
+ *
+ *   1. **Signatur** - der Link traegt einen HMAC ueber Schluessel und
+ *      Ablauf. Ohne AUTH_SECRET laesst er sich weder faelschen noch
+ *      verlaengern.
+ *   2. **Anmeldung** - ein weitergeleiteter Link nuetzt einem Fremden
+ *      nichts, er ist nicht angemeldet.
+ *   3. **Berechtigung** - geprueft wird gegen die betreuteId, die im
+ *      Schluessel steht. Wer diese Person nicht betreut, kommt nicht an
+ *      ihre Unterlagen, auch nicht mit gueltigem Link.
+ *   4. **Auslieferung** - immer als Anhang, nie als HTML, mit
+ *      X-Content-Type-Options: nosniff. Eine hochgeladene Datei darf
+ *      niemals als Seite im Kontext dieser Anwendung ausgefuehrt werden.
+ *
+ * Jeder erfolgreiche Abruf steht danach im Audit-Log.
+ */
+
+const MODUL: Modul = 'DOKUMENTE'
+
+/** Nur diese Typen werden ueberhaupt ausgeliefert - HTML ist nicht dabei. */
+const AUSLIEFERBAR = new Set([
+  'application/pdf',
+  'image/jpeg',
+  'image/png',
+  'image/webp',
+  'image/tiff',
+  'image/heic',
+])
+
+function nurText(status: number, meldung: string): NextResponse {
+  return new NextResponse(meldung, {
+    status,
+    headers: {
+      'Content-Type': 'text/plain; charset=utf-8',
+      'X-Content-Type-Options': 'nosniff',
+      'Cache-Control': 'no-store',
+    },
+  })
+}
+
+export async function GET(
+  _anfrage: Request,
+  { params }: { params: Promise<{ signatur: string }> },
+): Promise<NextResponse> {
+  const { signatur } = await params
+
+  // 1. Signatur und Ablauf
+  const geprueft = zugriffTokenPruefen(decodeURIComponent(signatur))
+  if (!geprueft.gueltig) {
+    return nurText(
+      geprueft.grund === 'abgelaufen' ? 410 : 400,
+      geprueft.grund === 'abgelaufen'
+        ? 'Dieser Link ist abgelaufen. Öffne das Dokument erneut in der Akte.'
+        : 'Dieser Link ist ungültig.',
+    )
+  }
+  const schluessel = geprueft.schluessel
+
+  // 2. Angemeldet?
+  const benutzer = await aktuellerBenutzer()
+  if (!benutzer) return nurText(401, 'Bitte melde dich an.')
+
+  // 3. Zugriff auf genau diese betreute Person
+  const betreuteId = betreuteIdAusSchluessel(schluessel)
+  if (!betreuteId) return nurText(400, 'Dieser Link ist ungültig.')
+
+  const betreute = await db.betreute.findFirst({
+    where: { id: betreuteId, ...nichtGeloescht },
+    select: { id: true },
+  })
+  if (!betreute) return nurText(404, 'Nicht gefunden.')
+
+  const eintrag = await db.betreuungsZugang.findUnique({
+    where: { userId_betreuteId: { userId: benutzer.id, betreuteId } },
+    select: { rolle: true, freigegebeneModule: true },
+  })
+  const zugang = eintrag
+    ? { rolle: eintrag.rolle, freigegebeneModule: eintrag.freigegebeneModule }
+    : benutzer.rolle === 'ADMIN'
+      ? { rolle: 'ADMIN' as const, freigegebeneModule: [] }
+      : null
+
+  if (!darf(zugang, MODUL, 'lesen')) {
+    return nurText(403, 'Für diesen Bereich fehlt dir die Berechtigung.')
+  }
+
+  // Der Datensatz zur Datei - fuer Anzeigename und Protokolleintrag.
+  const dokument = await db.dokument.findFirst({
+    where: { objektSchluessel: schluessel, betreuteId },
+    select: { id: true, titel: true, dateiname: true, geloeschtAm: true },
+  })
+
+  let inhalt: Buffer
+  try {
+    inhalt = await lesen(schluessel)
+  } catch {
+    return nurText(404, 'Die Datei liegt nicht mehr im Speicher.')
+  }
+
+  // 4. Auslieferung: Typ am Inhalt bestimmen, nie am gespeicherten Feld.
+  const erkannt = typErkennen(inhalt)
+  const typ = erkannt && AUSLIEFERBAR.has(erkannt.mimeTyp) ? erkannt.mimeTyp : 'application/octet-stream'
+
+  const name = dateinamen(dokument?.dateiname ?? null, schluessel)
+
+  await protokollieren({
+    aktion: 'DOKUMENT_HERUNTERGELADEN',
+    entitaet: 'Dokument',
+    entitaetId: dokument?.id ?? null,
+    bezeichnung: dokument?.titel ?? name,
+    betreuteId,
+    userId: benutzer.id,
+    userEmail: benutzer.email,
+    userName: benutzer.name,
+  })
+
+  return new NextResponse(new Uint8Array(inhalt), {
+    status: 200,
+    headers: {
+      'Content-Type': typ,
+      'Content-Length': String(inhalt.length),
+      // Niemals im Browser rendern - auch dann nicht, wenn jemand einen
+      // Weg gefunden haette, eine HTML-Datei hier abzulegen.
+      'Content-Disposition': `attachment; filename="${asciiName(name)}"; filename*=UTF-8''${encodeURIComponent(name)}`,
+      'X-Content-Type-Options': 'nosniff',
+      'Content-Security-Policy': "default-src 'none'; sandbox",
+      'Referrer-Policy': 'no-referrer',
+      // Private Daten gehoeren in keinen Zwischenspeicher.
+      'Cache-Control': 'private, no-store, max-age=0',
+      ...(dokument?.geloeschtAm ? { 'X-Papierkorb': '1' } : {}),
+    },
+  })
+}
+
+function dateinamen(gespeichert: string | null, schluessel: string): string {
+  if (gespeichert && gespeichert.trim() !== '') return gespeichert
+  const endung = schluessel.slice(schluessel.lastIndexOf('.') + 1)
+  return `dokument.${endung}`
+}
+
+/** Fallback fuer Browser, die filename* nicht verstehen. */
+function asciiName(name: string): string {
+  return (
+    name
+      .replace(/[\u00e4]/g, 'ae')
+      .replace(/[\u00f6]/g, 'oe')
+      .replace(/[\u00fc]/g, 'ue')
+      .replace(/[\u00c4]/g, 'Ae')
+      .replace(/[\u00d6]/g, 'Oe')
+      .replace(/[\u00dc]/g, 'Ue')
+      .replace(/[\u00df]/g, 'ss')
+      // eslint-disable-next-line no-control-regex
+      .replace(/[^\u0020-\u007e]/g, '_')
+      .replace(/["\\]/g, '_') || 'dokument'
+  )
+}