Alles andere auf diesen Seiten ist eine Behauptung. Hier stehen die Mittel, sie zu überprüfen — mit unserem Werkzeug und, wichtiger, ohne es.
Wir schreiben an mehreren Stellen, dass Ihre Daten Ihr Gerät nur verschlüsselt verlassen. Sie können das nicht sehen. Sie können es glauben — oder wir geben Ihnen die Zahlen und Schritte, um es nachzuprüfen.
Genau das steht hier. Das Verfahren ist kein Eigenbau, sondern eine Zusammensetzung aus Standardteilen, die es in jedem Browser und in jeder ernstzunehmenden Programmiersprache fertig gibt. Das ist kein Zufall: Ein Verfahren, das nur mit unserem Code funktioniert, wäre für Sie nicht überprüfbar.
Der zweite Grund ist praktischer Natur. Wenn ein Tresor-Export im Ernstfall gebraucht wird, sind wir vielleicht nicht mehr erreichbar. Dann muss die Anleitung reichen.
Diese Werte stehen so im ausgelieferten Code. Wer nachbauen will, braucht Zahlen und keine Umschreibungen.
Der Authentifizierungs-Tag hängt hinten am Chiffrat — so macht es die Web-Crypto-Schnittstelle, und so erwarten es die üblichen Bibliotheken auch. Das Salz ist kein Geheimnis: Es verhindert, dass jemand eine Tabelle vorberechnet, die für alle Nutzer gleichzeitig gilt.
Auf der Werkzeugseite können Sie einen Text verschlüsseln und bekommen genau das zurück, was bei einem echten Tresoreintrag auch in unserer Datenbank stünde. Nehmen Sie es mit und versuchen Sie, es zu brechen.
Das Werkzeug ruft dieselbe Datei auf, die auch jeden Tresoreintrag verschlüsselt — keine Nachbildung. Es beweist damit allerdings nur, dass unser Code tut, was wir sagen. Dass es dieselben Standardteile sind, zeigt erst der Weg darunter.
Zum WerkzeugNehmen Sie ein Ergebnis aus unserem Werkzeug und entschlüsseln Sie es mit fremden Mitteln. Wenn dabei Ihr Text herauskommt, haben Sie zweierlei gezeigt: dass wir wirklich diese Standardverfahren benutzen, und dass Sie Ihre Daten auch ohne uns lesen können.
Umgekehrt funktioniert es genauso: Verschlüsseln Sie etwas mit dem Code unten und geben Sie es in unser Werkzeug. Was passt, ist dasselbe Verfahren.
Der kürzeste Weg. Die Web-Crypto-Schnittstelle steckt in jedem Browser; hier läuft kein Code von uns.
// In den Entwicklerwerkzeugen (F12) → Konsole einfügen.
// Läuft in jedem Browser, ohne finilog-Code.
const payload = { salt: "…", iv: "…", ciphertext: "…" }; // aus dem Werkzeug
const passwort = "…";
const b64 = s => Uint8Array.from(atob(s), c => c.charCodeAt(0));
const material = await crypto.subtle.importKey(
"raw", new TextEncoder().encode(passwort), "PBKDF2", false, ["deriveKey"]
);
const schluessel = await crypto.subtle.deriveKey(
{ name: "PBKDF2", salt: b64(payload.salt), iterations: 1000000, hash: "SHA-256" },
material,
{ name: "AES-GCM", length: 256 },
false, ["decrypt"]
);
const klar = await crypto.subtle.decrypt(
{ name: "AES-GCM", iv: b64(payload.iv) }, schluessel, b64(payload.ciphertext)
);
console.log(new TextDecoder().decode(klar));Wenn Sie es lieber unabhängig vom Browser prüfen oder das Ergebnis weiterverarbeiten wollen.
# pip install cryptography
import base64, json
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from cryptography.hazmat.primitives import hashes
payload = json.loads(open("chiffrat.json").read())
passwort = "…".encode()
b64 = base64.b64decode
schluessel = PBKDF2HMAC(
algorithm=hashes.SHA256(),
length=32, # AES-256
salt=b64(payload["salt"]),
iterations=1_000_000,
).derive(passwort)
# WebCrypto hängt den 16-Byte-Authentifizierungs-Tag hinten an das
# Chiffrat — genau so erwartet ihn AESGCM.decrypt() auch.
klar = AESGCM(schluessel).decrypt(b64(payload["iv"]), b64(payload["ciphertext"]), None)
print(klar.decode())Der Export enthält die Chiffrate Ihrer Einträge und beschreibt sich selbst: Verfahren, Rundenzahl und Schlüssellänge stehen als Felder in der Datei. Er braucht kein Konto, keinen Login und keine Verbindung zu uns.
Zwei Stufen, und die Reihenfolge ist der ganze Witz der Umschlag-Verschlüsselung: Ihr Passwort öffnet nur den Umschlag um den Eintragsschlüssel — erst dieser öffnet die Daten. Ihr Passwort berührt den Inhalt nie.
# Ein Tresor-Export, ohne Konto und ohne uns.
# Zwei Stufen: Das Passwort öffnet nur den Umschlag um den
# Eintragsschlüssel — erst dieser öffnet die Daten.
#
# Beide Stufen sind an ihren Zweck gebunden: Der jeweilige Text geht als
# "additional authenticated data" in AES-GCM ein und muss beim Entschlüsseln
# mitgegeben werden. Er ist nicht geheim — er gehört zum Format und verhindert,
# dass ein Chiffrat als etwas anderes gelesen werden kann, als es geschrieben
# wurde. Exporte von vor September 2026 tragen keine Bindung; dort steht an
# beiden Stellen None.
AAD_UMSCHLAG = b"finilog-aad-v1|dek-password"
AAD_DATEN = b"finilog-aad-v1|vault-entry"
export = json.loads(open("finilog-vault-export-….json").read())["finilog_vault_export"]
for eintrag in export["entries"]:
dek_umschlag = eintrag["encrypted_dek_user"]
schluessel = PBKDF2HMAC(
algorithm=hashes.SHA256(), length=32,
salt=b64(dek_umschlag["salt"]), iterations=export["kdf"]["iterations"],
).derive(passwort)
dek = AESGCM(schluessel).decrypt(
b64(dek_umschlag["iv"]), b64(dek_umschlag["ciphertext"]), AAD_UMSCHLAG
)
daten = eintrag["encrypted_data"]
klar = AESGCM(dek).decrypt(b64(daten["iv"]), b64(daten["ciphertext"]), AAD_DATEN)
umschlag = json.loads(klar) # {version, title, category, beneficiaryIds, content}
print(umschlag["title"], "—", umschlag["content"])Ein veröffentlichter Quelltext beweist für sich genommen nichts — wir könnten im Browser etwas anderes ausführen. Das können Sie überprüfen, und zwar an dem Punkt, an dem es zählt: beim Speichern eines Eintrags.
Wer das einmal gemacht hat, braucht unser Wort nicht mehr. Genau deshalb steht die Anleitung hier und nicht im Kleingedruckten.
Diese Prüfung zeigt, dass der Code in dem Moment, in dem Sie hinsehen, richtig arbeitet. Sie zeigt nicht, dass wir Ihnen morgen dieselbe Datei ausliefern. Diese Lücke ist keinem Anbieter zu nehmen, der Code über das Netz ausliefert — wir benennen sie lieber, als sie zu übergehen.
Sie zeigt außerdem nichts über die Stärke Ihres Passworts. Das beste Verfahren scheitert an einem Passwort, das in einer Wörterliste steht. Was hier gerechnet wird, macht Durchprobieren teuer, nicht unmöglich.
Und sie sagt nichts darüber, wer sonst noch an Ihrem Gerät sitzt. Verschlüsselung schützt Daten auf dem Weg und im Lager — nicht vor jemandem, der Ihnen beim Tippen zusieht.