Dateien mit AES-256-GCM im Browser verschlüsseln
Zuletzt aktualisiert:
Eine Datei mit AES-256-GCM im Browser zu verschlüsseln heißt, die Datei auf dem eigenen Rechner in Geheimtext zu verwandeln, mit einem Schlüssel, der aus einem selbst gewählten Passwort abgeleitet wird, bevor die Datei irgendwohin geht — auf ein Cloud-Laufwerk, in einen E-Mail-Anhang, auf einen USB-Stick. Die Verschlüsselung läuft in der Seite, mit WebCrypto, und Datei und Passwort verlassen den Browser nie. Das ist wichtig, weil eine Datei nicht wie eine Nachricht ist, die man neu tippen kann: Sie ist das Geheimnis selbst. Ein Chat kann AES-GCM beschreiben, aber er kann Ihre echte Datei nicht verschlüsseln, und die Datei in einen Chat einzufügen oder sie auf eine beliebige Seite hochzuladen, die "online verschlüsseln" verspricht, heißt, den Klartext zuerst einem Fremden zu übergeben. Dateien lassen sich im Datei-Verschlüsseler vollständig im Browser ver- und entschlüsseln, ohne Größenbegrenzung.
Ihre Datei ist das Geheimnis — fügen Sie sie nie in einen Chat ein und laden Sie sie nie auf eine beliebige Seite hoch
Menschen sind vorsichtig mit Passwörtern und nachlässig mit Dateien, und Dateien sind das schlimmere Leck. Ein Passwort kann man ändern; eine Datei kann man, einmal gelesen, nicht ungelesen machen. Eine Steuererklärung, ein Vertragsentwurf, ein Scan des Personalausweises, ein Ordner mit Familienfotos — jedes davon trägt Informationen, die jahrelang sensibel bleiben, und sobald eine Kopie den eigenen Rechner verlässt, kann man sie nicht zurückrufen. Das ist die erste Regel dieses Artikels: Fügen Sie eine Datei nie in einen Chat ein, und laden Sie sie nie auf eine Seite hoch, deren einziger Vertrauensbeweis der Satz "online verschlüsseln" ist. Der Dienst, der Ihre Datei für Sie verschlüsselt, hat den Klartext per Definition gesehen. Wird er gehackt, verkauft oder protokolliert er einfach nur Uploads, ist die Verschlüsselung, die er danach anwendet, Dekoration.
Browser-lokale Verschlüsselung kehrt diese Reihenfolge um. Die Datei wird von der Seite gelesen, Block für Block auf dem eigenen Rechner verschlüsselt, und nur der Geheimtext verlässt ihn — in den Downloads-Ordner, und von dort, wohin Sie ihn legen. Die Seite erhält weder die Datei noch das Passwort noch den Schlüssel, denn es gibt keine Serverseite, die sie empfangen könnte: Das Tool ist eine statische Seite. Dieselbe Logik erklärt, warum dieses Tool überhaupt existiert, statt eine Chatbot-Antwort zu sein. Ein Chatbot kann AES-GCM perfekt erklären und kann Ihre echte Datei trotzdem nicht verschlüsseln, und in dem Moment, in dem Sie die Datei einfügen, damit er es tut, haben Sie den Klartext genau der Partei übergeben, vor der Sie ihn schützen wollten. Wenn ein Arbeitsablauf die Datei selbst braucht, muss die Arbeit dort stattfinden, wo die Datei bereits ist — auf dem eigenen Rechner.
AES-256-GCM in einfachen Worten: ein Schlüssel, eine frische Prüfung pro Block
AES-256-GCM vereint zwei Garantien in einem Algorithmus, und beide sind für Dateien wichtig. Der Teil "AES-256" ist die Chiffre: Ein 256-Bit-Schlüssel verwürfelt jeden Datenblock so gründlich, dass der Geheimtext bei einem Schlüssel, den niemand erraten kann, nichts über den Klartext verrät. Der Teil "GCM" ist die Authentifizierung: Für jeden Block der Datei berechnet der Algorithmus ein 16-Byte-Tag, einen Fingerabdruck aus diesem Block, seiner Position und dem Schlüssel. Die Entschlüsselung berechnet das Tag neu und vergleicht es; wurde auch nur ein einziges Byte geändert — ein gekipptes Bit bei der Übertragung, ein falsches Passwort, ein Block, der mit einem aus einer anderen Datei vertauscht wurde — stimmt das Tag nicht überein, und die Entschlüsselung verweigert sich, statt still beschädigte Daten zu liefern.
Diese zweite Garantie ist der Grund, warum GCM dem älteren CBC-Modus für Dateien überlegen ist, und es lohnt sich, den Unterschied zu verstehen. CBC verschlüsselt jeden Block verkettet mit dem vorherigen, hat aber keine eingebaute Möglichkeit zu erkennen, ob der Geheimtext manipuliert wurde: Ein Angreifer, der Bits in einer CBC-Datei kippen kann, kann die entschlüsselte Ausgabe auf vorhersagbare Weise verändern, und die klassischen Padding-Oracle-Angriffe gegen CBC nutzen genau diese Schwäche aus. Mit CBC braucht man ein separates HMAC, um Manipulation zu erkennen, und genau bei dieser Konstruktion gehen Implementierungen schief. GCM baut die Prüfung ein — jeder Block trägt sein eigenes Tag, das geprüft wird, bevor seinem Klartext vertraut wird — also gibt es keinen zweiten Mechanismus anzubauen und kein Padding anzugreifen. Ein Schlüssel, ein Algorithmus, Vertraulichkeit und Authentifizierung zusammen.
Passwort oder Schlüsselpaar? Wann ein geteiltes Passwort das richtige Werkzeug ist
Es gibt zwei ehrliche Wege, eine Datei für jemand anderen zu verschlüsseln, und sie lösen unterschiedliche Probleme. Ein Passwort ist ein geteiltes Geheimnis: Sie und der Empfänger vereinbaren es — idealerweise über einen anderen Kanal, persönlich oder über ein Medium, auf dem die Datei selbst nicht reisen wird — und die Datei kann von jedem geöffnet werden, der es kennt. Ein Schlüsselpaar, das PGP-Modell, ist asymmetrisch: Sie verschlüsseln mit dem öffentlichen Schlüssel des Empfängers, nur dessen privater Schlüssel öffnet sie, und niemand muss vorher ein Geheimnis vereinbaren. Das Schlüsselpaar gewinnt, wenn Sie kein Geheimnis sicher teilen können, wenn der Empfänger genau eine Person sein muss, und wenn Sie Signaturen wollen, die beweisen, wer die Datei geschickt hat. Es verliert beim Einrichtungsaufwand: Schlüssel zu erzeugen, zu speichern, zu sichern und zu widerrufen, und ein Empfänger, der bereits eines haben muss.
Das Passwort gewinnt immer dann, wenn der Einrichtungsaufwand eines Schlüsselpaars der Grund ist, warum Verschlüsselung überhaupt nicht stattfindet — was für die meisten Menschen und die meisten Dateien der Normalfall ist. Eine Datei für das eigene zukünftige Ich, ein Backup auf einer Platte, der man nicht ganz traut, ein Dokument für einen Kollegen, dem man das Passwort persönlich übergeben kann: Das braucht keine Schlüsselinfrastruktur, nur ein starkes Passwort und ein Format, das der Empfänger öffnen kann. Verwenden Sie dafür den Datei-Verschlüsseler. Wenn der Empfänger ein Fremder ist, wenn die Datei Ihnen zurechenbar sein muss, oder wenn Sie für mehrere Personen verschlüsseln müssen, ohne ein Geheimnis unter ihnen zu teilen, verwenden Sie stattdessen die PGP-Suite — dieselbe Seite, dieselbe Regel "alles im Browser", und das richtige Werkzeug für Nachrichten und Identität. Das Passwort-Tool zu wählen, wenn man das Schlüsselpaar-Tool gebraucht hätte, ist ein echter Fehler; das Schlüsselpaar-Tool zu wählen und dann nie etwas zu verschlüsseln, weil die Einrichtung einen besiegt hat, ist der häufigere.
Warum andere Tools Dateien auf 10 MB begrenzen — und wie Streaming die Begrenzung aufhebt
Wer schon einmal versucht hat, eine Datei online zu verschlüsseln, kennt die Begrenzung: 10 MB, manchmal weniger, und alles Größere wird abgelehnt. Die Begrenzung ist kein Geiz. Die meisten Tools lesen die ganze Datei in den Speicher, verschlüsseln sie in einem Durchgang, halten den gesamten Geheimtext im Speicher und bieten ihn dann als Download an — vier Kopien einer großen Datei gleichzeitig im RAM, plus die eigenen Grenzen des Browsers für die Größe eines einzelnen In-Memory-Blobs. Ein 2-GB-Video bräuchte auf diese Weise Gigabytes an Speicher, und auf einem bescheidenen Rechner schlägt das schlicht fehl. Also begrenzt das Tool die Eingabe auf eine Größe, die es überlebt, und große Dateien bleiben unverschlüsselt.
Die Lösung ist, aufzuhören, die ganze Datei auf einmal zu halten. Der Verschlüsseler liest die Datei in 1-MiB-Scheiben, verschlüsselt eine Scheibe, schreibt ihren Geheimtext hinaus und vergisst die Scheibe, bevor er die nächste liest — der Speicherverbrauch bleibt nahe einem Megabyte, egal wie groß die Datei ist. In Chromium und Edge geht die Ausgabe über die File System Access API, sodass jeder verschlüsselte Block auf die Platte geschrieben wird, sobald er erzeugt wurde: echtes Streaming, ohne dass die Datei irgendwo in der Pipeline vollständig gepuffert wird. Firefox und Safari bieten diese API noch nicht an, dort werden die Blöcke am Ende zu einem Download zusammengeführt — die Seite sagt das offen, und für sehr große Dateien in diesen Browsern lautet der ehrliche Rat, für die Aufgabe einen Chromium-Browser zu verwenden. Die Blockgröße von 1 MiB ist durch das Dateiformat festgelegt, keine Einstellung: Sie ist das, was der Entschlüsseler erwartet, und sie festzuhalten ist es, was jede Datei, die dieses Tool erzeugt, für jede andere Implementierung des Formats lesbar hält.
Das Format, dokumentiert: Ihre Datei ist nicht an diese Seite gebunden
Eine verschlüsselte Datei, die man ohne die Website öffnen kann, die sie erstellt hat, ist eine Geisel, kein Backup. Deshalb ist das Containerformat auf der Tool-Seite vollständig dokumentiert, und dieser Abschnitt ist die Kurzfassung. Eine .sysxenc-Datei beginnt mit den acht magischen Bytes SYSXENC1, dann einer zwei Byte langen Header-Länge, dann einem JSON-Header: die Formatversion, der KDF-Name und die Iterationszahl, ein zufälliges 16-Byte-Salz, die Blockgröße von 1 MiB, der ursprüngliche Dateiname, die Klartextgröße, der SHA-256 des Klartexts und ein Zeitstempel. Der Rumpf ist eine Folge von Blöcken, jeder mit einer vier Byte langen Geheimtextlänge, einem frischen zufälligen 12-Byte-IV und dem Geheimtext mit seinem 16-Byte-GCM-Tag. Der Schlüssel stammt aus Ihrem Passwort über PBKDF2-SHA-256 mit 600.000 Iterationen — der Zahl, die OWASP empfiehlt — und jeder Block wird mit Zusatzdaten authentifiziert, die ihn an diese Datei und seine Position binden: die exakten Header-Bytes plus der Blockindex, sodass ein umgeordneter oder aus einer anderen Datei eingespleißter Block seine Tag-Prüfung nicht besteht.
Der Sinn, all das aufzuschreiben, ist, dass jeder einen Leser implementieren kann, und der Python-Entschlüsseler unten ist der Beweis. Er verwendet nur die Standardbibliothek plus das Paket cryptography, liest den Header, leitet den Schlüssel neu ab, entschlüsselt Block für Block und prüft jedes Tag, und vergleicht schließlich den SHA-256 des Klartexts — genau das, was das Browser-Tool tut. Er wurde mit Dateien ausgeführt, die in diesem Format erzeugt wurden, darunter eine mehrere Megabyte große Datei, eine leere Datei, ein falsches Passwort und eine manipulierte Datei, und verhielt sich in jedem Fall korrekt. Eine ehrliche Einschränkung: Die OpenSSL-Kommandozeile kann dieses blockweise Format nicht direkt entschlüsseln, weil sie keine Möglichkeit hat, IVs pro Block, zusätzliche authentifizierte Daten und Tags auszudrücken. Das ist eine Eigenschaft des Formatdesigns, kein Geheimnis, und dieser Artikel wird nicht so tun, als wäre es anders — verwenden Sie das Skript unten oder eine beliebige AES-GCM-Implementierung.
Die Fehlermodi: wovor Verschlüsselung Sie nicht retten kann
Der erste Fehlermodus ist der, vor dem das Tool am lautesten warnt, weil es keine Abhilfe gibt: Verlieren Sie das Passwort, ist die Datei weg. Es gibt keine Wiederherstellung, keinen Link "Passwort vergessen", keinen Master-Key, der irgendwo liegt — der Schlüssel wird nur aus Ihrem Passwort abgeleitet, und ohne ihn ist der Geheimtext von Zufallsbytes nicht zu unterscheiden. Schreiben Sie das Passwort an einem sicheren Ort auf, getrennt von der Datei, bevor Sie das Original löschen. Der zweite Fehlermodus ist ein schwaches Passwort. PBKDF2 mit 600.000 Iterationen verlangsamt das Raten, kann aber "password123" nicht stark machen: Ein Angreifer, der die Datei bekommt, kann offline raten, so schnell wie seine Hardware es erlaubt, ohne dass ein Server ihn aussperrt. Verwenden Sie eine lange Passphrase, an die Sie sich erinnern können, kein kurzes Passwort, das man schnell tippen kann.
Der dritte und vierte Fehlermodus betreffen das, was Verschlüsselung nicht abdeckt. Der Header speichert den ursprünglichen Dateinamen, die Dateigröße und die Erstellungszeit im Klartext — der Inhalt ist geheim, die Metadaten sind es nicht. Wenn der Dateiname selbst sensibel ist, benennen Sie die Datei vor dem Verschlüsseln um, und ziehen Sie in Betracht, sie zuerst durch den Dokumenten-Reiniger zu schicken, denn Dokumente tragen eigene Metadaten in sich: Autorennamen, Bearbeitungsverlauf, eingebettete Vorschaubilder. Und auf einem kompromittierten Gerät hilft keine Verschlüsselung. Wenn der Rechner, auf dem Sie verschlüsseln, bereits Malware ausführt, kann sie die Datei vor der Verschlüsselung lesen und das Passwort, während Sie es tippen. Verschlüsselung schützt eine Datei bei der Übertragung und im Ruhezustand; sie schützt keine Datei auf einem Rechner, der bereits übernommen ist. Das ist kein Grund, Verschlüsselung zu überspringen — es ist der Grund, genau zu wissen, was sie einem bringt.
Eine .sysxenc-Datei mit Python entschlüsseln
#!/usr/bin/env python3
"""Decrypt a SYSXENC v1 file produced by the SysOSX file encryptor.
Format (SYSXENC v1), as documented at
https://www.sysosx.com/tools/file-encryptor/ :
header: 8-byte magic b"SYSXENC1", u16BE header length, header JSON bytes
{"v": 1, "kdf": "PBKDF2-SHA256", "iter": 600000,
"salt": <base64, 16 bytes>, "chunkSize": 1048576,
"name": <original filename>, "size": <plaintext bytes>,
"sha256": <hex of plaintext>, "created": <ISO timestamp>}
body: chunks, each u32BE ciphertext length (ciphertext INCLUDING the
16-byte GCM tag) + 12-byte random IV + ciphertext+tag.
The last chunk may be shorter; an empty file has zero chunks.
AAD per chunk: the exact header JSON bytes + u32LE chunk index.
KDF: PBKDF2-HMAC-SHA-256, 600,000 iterations, 256-bit key.
Requires the `cryptography` package: pip install cryptography
Note: OpenSSL's command-line tool cannot decrypt this chunked format
directly — it has no way to express per-chunk IVs, AAD, and tags — so
use this script (or any AES-GCM implementation) instead.
Usage:
python3 sysxenc_decrypt.py encrypted.sysxenc decrypted.bin
python3 sysxenc_decrypt.py encrypted.sysxenc decrypted.bin --password hunter2
(without --password, the password is read securely from the terminal)
"""
import argparse
import base64
import getpass
import hashlib
import json
import struct
import sys
MAGIC = b"SYSXENC1"
HEADER_LEN_FMT = ">H" # u16 big-endian
CHUNK_LEN_FMT = ">I" # u32 big-endian
CHUNK_INDEX_FMT = "<I" # u32 little-endian
IV_LEN = 12
TAG_LEN = 16
KEY_LEN = 32
def _read_exact(f, n, what):
data = f.read(n)
if len(data) != n:
raise ValueError(f"truncated file: could not read {what}")
return data
def decrypt_file(in_path, out_path, password):
with open(in_path, "rb") as f:
magic = _read_exact(f, 8, "magic")
if magic != MAGIC:
raise ValueError(
f"bad magic {magic!r}: not a SYSXENC v1 file")
(header_len,) = struct.unpack(
HEADER_LEN_FMT, _read_exact(f, 2, "header length"))
header_bytes = _read_exact(f, header_len, "header JSON")
header = json.loads(header_bytes.decode("utf-8"))
if header.get("v") != 1:
raise ValueError(
f"unsupported format version: {header.get('v')!r}")
if header.get("kdf") != "PBKDF2-SHA256":
raise ValueError(
f"unsupported KDF: {header.get('kdf')!r}")
iterations = int(header["iter"])
salt = base64.b64decode(header["salt"])
chunk_size = int(header["chunkSize"])
expected_size = int(header["size"])
expected_sha256 = header["sha256"]
key = hashlib.pbkdf2_hmac(
"sha256", password.encode("utf-8"), salt, iterations, KEY_LEN)
# Imported here so a bad file fails fast with a format error,
# not an ImportError.
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
aesgcm = AESGCM(key)
hasher = hashlib.sha256()
written = 0
index = 0
with open(out_path, "wb") as out:
while True:
len_bytes = f.read(4)
if len(len_bytes) == 0:
break # end of body
if len(len_bytes) != 4:
raise ValueError(
f"truncated file: chunk {index} length field")
(ct_len,) = struct.unpack(CHUNK_LEN_FMT, len_bytes)
iv = _read_exact(f, IV_LEN, f"chunk {index} IV")
ct_and_tag = _read_exact(
f, ct_len, f"chunk {index} ciphertext")
aad = header_bytes + struct.pack(CHUNK_INDEX_FMT, index)
try:
plain = aesgcm.decrypt(iv, ct_and_tag, aad)
except Exception as exc:
raise ValueError(
f"chunk {index} failed authentication: "
"wrong password or tampered file") from exc
out.write(plain)
hasher.update(plain)
written += len(plain)
index += 1
if written != expected_size:
raise ValueError(
f"size mismatch: header says {expected_size} bytes, "
f"decrypted {written}")
if hasher.hexdigest() != expected_sha256:
raise ValueError(
"SHA-256 mismatch: decrypted content does not match "
"the header digest (file tampered or corrupt)")
return header
def main(argv=None):
parser = argparse.ArgumentParser(
description="Decrypt a SYSXENC v1 (.sysxenc) file.")
parser.add_argument("input", help="encrypted .sysxenc file")
parser.add_argument("output", help="where to write the plaintext")
parser.add_argument("--password",
help="password (if omitted, prompted securely)")
args = parser.parse_args(argv)
password = args.password
if password is None:
password = getpass.getpass("Password: ")
try:
header = decrypt_file(args.input, args.output, password)
except (ValueError, OSError, KeyError) as exc:
print(f"error: {exc}", file=sys.stderr)
return 1
print(f"decrypted {header.get('name', args.input)} "
f"({header['size']} bytes, {header['sha256'][:12]}..., "
f"SHA-256 verified)")
return 0
if __name__ == "__main__":
raise SystemExit(main())