Clientseitige Kryptografie im Browser

Probieren Sie clientseitige Verschlüsselung mit unserem Verschlüsselungstool. Keine Daten verlassen Ihren Browser.

Sicherheitsmodell

Clientseitige Kryptografie hat ein einzigartiges Sicherheitsmodell. Der Browser fungiert als sichere Sandbox. Daten werden verschlüsselt, bevor sie den Browser verlassen.

Dies bedeutet, dass selbst wenn ein Server kompromittiert wird, sind die Daten geschützt, da der Server nie Zugriff auf die Klartextdaten hat.

Vorteile der clientseitigen Verschlüsselung

Clientseitige Kryptografie bietet mehrere Vorteile:

Zero-Knowledge-Server - Der Server kann verschlüsselte Daten nicht lesen
Keine Datenpersistenz - Keine Datenbank mit sensiblen Informationen
Reduzierte Angriffsfläche - Server hat keine Klartextdaten zu verlieren
Benutzerkontrolle - Der Benutzer kontrolliert seine eigenen Schlüssel

Einschränkungen

Es gibt auch Einschränkungen zu beachten:

Kein Passwort-Recovery möglich - Der Server kennt das Passwort nicht
Client-seitige Bedrohungen bleiben - Keylogger und Malware können Daten abfangen
Abhängigkeit vom Browser - Sicherheit hängt von der Browser-Implementierung ab

Best Practices

Für maximale Sicherheit bei clientseitiger Kryptografie:

Verwenden Sie starke Passwörter oder zufällige Schlüssel
Nutzen Sie die Web Crypto API für alle kryptografischen Operationen
Validieren Sie alle Eingaben clientseitig
Implementieren Sie sichere Schlüsselableitung (PBKDF2, Argon2)

Clientseitige Verschlüsselung implementieren

Hier ist ein vollständiges Beispiel für clientseitige Verschlüsselung mit der Web Crypto API:

Vollständiges Verschlüsselungs-/Entschlüsselungsbeispiel

// Clientseitige Verschlüsselung mit Web Crypto API
class ClientCrypto {
  async deriveKey(password, salt) {
    const encoder = new TextEncoder();
    const keyMaterial = await crypto.subtle.importKey(
      'raw', encoder.encode(password), 'PBKDF2', false, ['deriveKey']
    );
    return crypto.subtle.deriveKey(
      { name: 'PBKDF2', salt, iterations: 100000, hash: 'SHA-256' },
      keyMaterial, { name: 'AES-GCM', length: 256 }, false, ['encrypt', 'decrypt']
    );
  }
  async encrypt(plaintext, password) {
    const salt = crypto.getRandomValues(new Uint8Array(16));
    const iv = crypto.getRandomValues(new Uint8Array(12));
    const key = await this.deriveKey(password, salt);
    const encoder = new TextEncoder();
    const ciphertext = await crypto.subtle.encrypt(
      { name: 'AES-GCM', iv }, key, encoder.encode(plaintext)
    );
    return { ciphertext, iv, salt };
  }
  async decrypt(encryptedData, password) {
    const { ciphertext, iv, salt } = encryptedData;
    const key = await this.deriveKey(password, salt);
    const decrypted = await crypto.subtle.decrypt(
      { name: 'AES-GCM', iv }, key, ciphertext
    );
    return new TextDecoder().decode(decrypted);
  }
}
// Verwendung
const crypto = new ClientCrypto();
const encrypted = await crypto.encrypt('Geheime Daten', 'passwort123');
// Verschlüsselte Daten an Server senden...
const decrypted = await crypto.decrypt(encrypted, 'passwort123');

Keine Netzwerkanfragen verifizieren

// DevTools (F12) öffnen und vor der Verschlüsselung ausführen:
console.log('Verschlüsselungstest starten...');
const startTime = performance.now();
// Verschlüsselung durchführen
const encrypted = await encryptData('Testdaten', 'passwort');
const endTime = performance.now();
console.log(`Verschlüsselung dauerte ${endTime - startTime}ms`);
console.log('Netzwerk-Tab prüfen - keine Anfragen sollten erscheinen');
// Im Netzwerk-Tab (F12 → Netzwerk) verifizieren
// Wenn keine neuen Anfragen erscheinen, blieben Ihre Daten lokal!