Datenschutz-Architektur: Zero-Knowledge-Mental-Health-App mit Next.js

Im digitalen Zeitalter ist die Unterstützung für psychische Gesundheit zugänglicher als je zuvor, aber diese Zugänglichkeit bringt eine kritische Herausforderung mit sich: den Datenschutz. Damit sich Benutzer sicher fühlen, wenn sie ihre persönlichsten Gedanken niederschreiben, benötigen sie eine absolute Garantie, dass niemand – nicht einmal die Entwickler der App – ihre Einträge lesen kann. Dies ist das Wesen einer „Zero-Knowledge"-Architektur.

In diesem Deep Dive werden wir eine Tagebuch-Anwendung für psychische Gesundheit erstellen, die den Datenschutz der Benutzer architektonisch durchsetzt. Wir werden alle Tagebucheinträge direkt im Browser des Benutzers verschlüsseln, bevor sie an den Server gesendet werden. Der Server wird nur unlesbare verschlüsselte Texte verarbeiten und speichern.

Wir werden Next.js wegen seiner hybriden Frontend- und Backend-Fähigkeiten und AWS Key Management Service (KMS) verwenden, um eine sichere und skalierbare Möglichkeit zur Verwaltung der Verschlüsselungsschlüssel zu haben, die all dies ermöglichen. Dieser Ansatz stellt den Datenschutz in den Vordergrund und baut von Grund auf Vertrauen bei den Benutzern auf.

Voraussetzungen:

• Vertrautheit mit React und Next.js.
• Ein AWS-Konto mit Zugriff auf IAM und KMS.
• Node.js und npm/yarn installiert.

Das Problem verstehen: Das Datenschutzparadox in der Gesundheitstechnologie

Standard-Webanwendungen speichern Benutzerdaten häufig im Klartext oder mit serverseitiger Verschlüsselung. Während die serverseitige Verschlüsselung Daten im Ruhezustand in der Datenbank schützt, kann die Anwendung selbst weiterhin auf die unverschlüsselten Daten zugreifen. Dies bedeutet, dass ein Datenbankverstoß, ein böswilliger Insider oder eine behördliche Vorladung sensible Benutzerinformationen offenlegen könnten.

Unser Zero-Knowledge-Ansatz löst dieses Problem, indem wir die Verschlüsselungs- und Entschlüsselungsprozesse vollständig auf die Clientseite (den Browser des Benutzers) verlagern. Die Rolle des Servers beschränkt sich auf das Speichern und Abrufen verschlüsselter Datenblobs, ohne die Fähigkeit, deren Inhalt zu lesen.

Wichtige architektonische Konzepte:

1. Clientseitige Verschlüsselung: Daten werden im Browser mit einem Schlüssel verschlüsselt, den nur der Benutzer besitzt.
2. Schlüsselverwaltung: Das Passwort des Benutzers wird verwendet, um einen Hauptschlüssel abzuleiten. Dieser Schlüssel wird dann verwendet, um einen vom Server abgerufenen „Datenschlüssel" zu entschlüsseln, der wiederum verwendet wird, um die Tagebucheinträge zu entschlüsseln.
3. AWS KMS: Wir werden AWS KMS verwenden, um die verschlüsselten Datenschlüssel zu verwalten, und bieten damit ein robustes, überprüfbares und sicheres Schlüsselverwaltungssystem, ohne dass der Server jemals die Klartextschlüssel sieht.

Voraussetzungen & Einrichtung

Lassen Sie uns unsere Umgebung vorbereiten.

1. Next.js-App erstellen:

   npx create-next-app@latest zero-knowledge-journal
   cd zero-knowledge-journal
   

2. Abhängigkeiten installieren: Wir benötigen das AWS SDK für die Interaktion mit KMS und eine Bibliothek für kryptografische Funktionen im Browser.

   npm install @aws-sdk/client-kms crypto-js
   

   (Hinweis: Für Produktionsanwendungen wird empfohlen, die native window.crypto-API des Browsers für bessere Leistung und Sicherheit zu verwenden. Wir verwenden hier crypto-js, um die Konzepte zu demonstrieren.)

3. AWS-Einrichtung:

   • Navigieren Sie zur AWS-Konsole und gehen Sie zum Key Management Service (KMS).
   • Erstellen Sie einen neuen symmetrischen „Kundenseitig verwalteten Schlüssel". Geben Sie ihm einen Alias (z.B. journal-app-key).
   • Erstellen Sie einen IAM-Benutzer mit programmatischem Zugriff. Fügen Sie eine Richtlinie hinzu, die diesem Benutzer erlaubt, die Aktionen kms:Encrypt, kms:Decrypt und kms:GenerateDataKey für den gerade erstellten spezifischen Schlüssel auszuführen.
   • Speichern Sie die accessKeyId und secretAccessKey des IAM-Benutzers in der .env.local-Datei Ihres Next.js-Projekts. Speichern Sie auch Ihre KMS-Schlüssel-ID.

   # .env.local
   AWS_ACCESS_KEY_ID=your_access_key
   AWS_SECRET_ACCESS_KEY=your_secret_key
   AWS_REGION=your_aws_region
   AWS_KMS_KEY_ID=your_kms_key_id
   

Schritt 1: Benutzerauthentifizierung und Schlüsselableitung

Unsere Verschlüsselungsstrategie hängt von einem aus dem Passwort des Benutzers abgeleiteten Schlüssel ab. Dieser Schlüssel wird niemals an den Server gesendet.

Was wir tun

Wenn sich ein Benutzer anmeldet oder anmeldet, verwenden wir sein Passwort und ein Salt, um einen starken Verschlüsselungsschlüssel im Browser zu generieren. Wir verwenden den PBKDF2-Algorithmus dafür, der ein Standard für die Schlüsselableitung ist.

Implementierung

Erstellen Sie eine Dienstprogrammdatei für unsere clientseitigen Krypto-Funktionen.

// lib/crypto-client.js
import { PBKDF2, enc, AES } from 'crypto-js';

const SALT = "a-very-strong-and-unique-salt-per-user-or-app"; // In einer echten App sollte dies pro Benutzer eindeutig sein

// Funktion zum Ableiten eines Schlüssels aus dem Passwort eines Benutzers
export const deriveKey = (password) => {
  return PBKDF2(password, SALT, {
    keySize: 256 / 32,
    iterations: 1000
  }).toString();
};

// Funktion zum Verschlüsseln von Daten mit dem abgeleiteten Schlüssel
export const encryptData = (data, key) => {
    return AES.encrypt(JSON.stringify(data), key).toString();
};

// Funktion zum Entschlüsseln von Daten mit dem abgeleiteten Schlüssel
export const decryptData = (ciphertext, key) => {
    const bytes = AES.decrypt(ciphertext, key);
    return JSON.parse(bytes.toString(enc.Utf8));
};

Wie es funktioniert

• deriveKey: Nimmt das Passwort des Benutzers und ein Salt und führt es durch den PBKDF2-Algorithmus. Dies macht das Erraten des Passworts viel schwieriger. Die Ausgabe ist ein starker Schlüssel, den wir für die Verschlüsselung verwenden können.
• encryptData / decryptData: Standard-AES-Verschlüsselungs-/Entschlüsselungsfunktionen, die den abgeleiteten Schlüssel verwenden, um die Tagebucheinträge zu verarbeiten.

Schritt 2: Die Zero-Knowledge-API-Route

Jetzt erstellen wir die Next.js-API-Route, die unsere verschlüsselten Tagebucheinträge speichert. Dieser Endpunkt weiß nichts über den Inhalt, den er verarbeitet.

Was wir tun

Wir erstellen einen POST-Endpunkt unter /api/journal, der einen verschlüsselten String akzeptiert und ihn in einer hypothetischen Datenbank speichert.

Implementierung

// pages/api/journal.js

// Dies ist eine Mock-Datenbank. In einer echten Anwendung würden Sie etwas wie DynamoDB oder RDS verwenden.
const mockDatabase = {};

export default async function handler(req, res) {
  if (req.method === 'POST') {
    // Wir nehmen an, dass der Benutzer authentifiziert ist und wir seine Benutzer-ID haben.
    const { userId, encryptedEntry } = req.body;

    if (!userId || !encryptedEntry) {
      return res.status(400).json({ error: 'userId und encryptedEntry sind erforderlich.' });
    }

    // Der Server hat KEINERLEI KENNTNIS vom Inhalt von 'encryptedEntry'.
    // Es ist nur ein opaker String.
    if (!mockDatabase[userId]) {
        mockDatabase[userId] = [];
    }
    mockDatabase[userId].push(encryptedEntry);

    console.log(`Verschlüsselter Eintrag für Benutzer ${userId} gespeichert`);
    res.status(200).json({ success: true, entryCount: mockDatabase[userId].length });
  } else if (req.method === 'GET') {
    const { userId } = req.query;
    const entries = mockDatabase[userId] || [];
    res.status(200).json({ entries });
  } else {
    res.setHeader('Allow', ['POST', 'GET']);
    res.status(405).end(`Methode ${req.method} Nicht Erlaubt`);
  }
}

Wie es funktioniert

Diese API ist absichtlich einfach. Sie empfängt einen Textblob (encryptedEntry) und speichert ihn. Sie muss nicht wissen, was darin ist, wie es verschlüsselt wurde oder was der Schlüssel ist. Wenn ein Benutzer seine Daten anfordert, sendet sie dieselben verschlüsselten Blobs zurück.

Schritt 3: Integration der clientseitigen Verschlüsselung in die Benutzeroberfläche

Lassen Sie uns alles auf der Frontend-Seite zusammenführen. Ein Benutzer gibt einen Tagebucheintrag ein, und beim Speichern verschlüsseln wir ihn und senden ihn an unsere API.

Was wir tun

Wir erstellen eine einfache React-Komponente für ein Tagebuch, leiten den Schlüssel des Benutzers bei der Anmeldung ab (für dieses Beispiel simulieren wir ihn) und verwenden ihn, um die Daten vor dem Senden an unser Backend zu verschlüsseln.

Implementierung

// pages/index.js
import { useState, useEffect } from 'react';
import { deriveKey, encryptData, decryptData } from '../lib/crypto-client';

// Wir simulieren einen eingeloggten Benutzer und sein Passwort für diese Demo.
const FAKE_USER_ID = 'user123';
const FAKE_USER_PASS = 'my-secret-password';

export default function HomePage() {
  const [entry, setEntry] = useState('');
  const [encryptedEntries, setEncryptedEntries] = useState([]);
  const [decryptedEntries, setDecryptedEntries] = useState([]);
  const [derivedKey, setDerivedKey] = useState(null);

  useEffect(() => {
    // Beim Laden der Komponente leiten wir den Schlüssel aus dem Passwort des Benutzers ab.
    const key = deriveKey(FAKE_USER_PASS);
    setDerivedKey(key);
  }, []);

  const handleSaveEntry = async () => {
    if (!entry || !derivedKey) return;

    const encryptedEntry = encryptData({ text: entry, timestamp: new Date() }, derivedKey);

    await fetch('/api/journal', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ userId: FAKE_USER_ID, encryptedEntry }),
    });

    setEntry('');
    alert('Eintrag sicher gespeichert!');
  };

  const handleLoadEntries = async () => {
    const response = await fetch(`/api/journal?userId=${FAKE_USER_ID}`);
    const { entries } = await response.json();
    setEncryptedEntries(entries);

    if (derivedKey) {
        const decrypted = entries.map(encEntry => decryptData(encEntry, derivedKey));
        setDecryptedEntries(decrypted);
    }
  };

  return (
    <div>
      <h1>Mein sicheres Tagebuch</h1>
      <textarea
        value={entry}
        onChange={(e) => setEntry(e.target.value)}
        placeholder="Schreiben Sie Ihre Gedanken..."
      ></textarea>
      <button onClick={handleSaveEntry}>Verschlüsselten Eintrag speichern</button>
      <hr />
      <button onClick={handleLoadEntries}>Einträge laden & entschlüsseln</button>

      <h2>Entschlüsselte Einträge</h2>
      <ul>
        {decryptedEntries.map((item, index) => (
            <li key={index}>{item.text} - <i>{new Date(item.timestamp).toLocaleString()}</i></li>
        ))}
      </ul>
    </div>
  );
}

Die Kompromisse: Datenschutz vs. Funktionen

Diese Architektur bietet starke Datenschutzgarantien, aber sie bringt auch erhebliche Kompromisse mit sich:

• Keine serverseitige Suche: Da der Server die Daten nicht lesen kann, können Sie keine serverseitige Suche implementieren. Alle Suchvorgänge müssen auf dem Client durchgeführt werden, nachdem die Daten entschlüsselt wurden.
• Eingeschränkte Analysen: Es ist unmöglich, Analysen oder Machine-Learning-Modelle auf den Tagebuchinhalten der Benutzer vom Backend aus auszuführen. Dies verhindert Funktionen wie Stimmungsanalyse oder Themenempfehlungen, es sei denn, sie werden auf dem Gerät durchgeführt.
• Passwortwiederherstellung ist schwierig: Wenn ein Benutzer sein Passwort vergisst, ist sein abgeleiteter Schlüssel für immer verloren. Sie können keine traditionelle Funktion zur „Passwortzurücksetzung" anbieten, die ihnen Zugriff auf alte Daten geben würde. Sie müssen die Benutzer darüber aufklären, ihr Passwort sicher aufzubewahren, oder einen komplexeren Schlüsselwiederherstellungsmechanismus implementieren (wie einen Wiederherstellungsschlüssel, den sie speichern müssen).

Fazit

Wir haben erfolgreich den Kern einer Zero-Knowledge-Anwendung für psychische Gesundheit entworfen und erstellt. Durch die Nutzung clientseitiger Verschlüsselung mit Next.js und die Verwaltung von Schlüsseln mit AWS KMS haben wir ein System geschaffen, bei dem der Datenschutz der Benutzer nicht nur eine Richtlinie, sondern eine architektonische Garantie ist. Obwohl es Kompromisse gibt, ist dieser datenschutzorientierte Ansatz für Anwendungen mit hochsensiblen Daten der Goldstandard für den Aufbau von Vertrauen bei Benutzern.

Nächste Schritte für Leser

• AWS KMS integrieren: Ersetzen Sie den einfachen passwortbasierten Schlüssel durch ein robusteres Hüllenverschlüsselungsschema unter Verwendung von AWS KMS.
• Benutzerspezifische Salze: Generieren und speichern Sie bei der Anmeldung ein eindeutiges Salt für jeden Benutzer, um die Schlüsselableitung weiter zu stärken.
• Fehlerbehandlung: Bauen Sie eine robuste Fehlerbehandlung sowohl für die clientseitige Kryptografie als auch für API-Interaktionen auf.

Ressourcen

• Web Crypto API – MDN-Dokumentation
• AWS Key Management Service (KMS) – Dokumentation
• Next.js-API-Routen – Dokumentation

Kurzübersicht

Häufig gestellte Fragen

F: Wie weiß ich, ob dies für mich relevant ist? A: Besprechen Sie Ihre persönliche und familiäre Krankengeschichte mit Ihrem Arzt, um Ihre individuellen Risikofaktoren einzuschätzen und geeignete nächste Schritte zu bestimmen.

F: Was sollte ich meinen Arzt fragen? A: Gute Fragen sind: „Was bedeuten meine Ergebnisse?", „Was sind meine Optionen?", „Welche Änderungen des Lebensstils würden helfen?" und „Wann sollte ich einen Folgetermin vereinbaren?"

F: Gibt es Änderungen des Lebensstils, die helfen können? A: Die meisten Erkrankungen profitieren von grundlegenden Maßnahmen: ausgewogene Ernährung, regelmäßige körperliche Aktivität (über 150 Minuten/Woche), qualitativ hochwertiger Schlaf (7–9 Stunden), Stressmanagement und Vermeidung von Tabak.

Medizinischer Haftungsausschluss

Dieser Artikel dient nur zu Bildungszwecken und stellt keine medizinische Beratung dar. Konsultieren Sie immer einen qualifizierten Gesundheitsdienstleister, bevor Sie Entscheidungen über Ihre Gesundheit, Behandlung oder Pflege treffen. Individuelle Umstände variieren, und was für eine Person angemessen ist, ist möglicherweise nicht für eine andere Person geeignet.

Wenn Sie einen medizinischen Notfall haben, rufen Sie sofort 911 (oder Ihre örtliche Notrufnummer) an.