AES-Verschlüsselung nach Base64

So verschlüsseln Sie Text mit einem Passwort

1. Lassen Sie Verschlüsseln und den Schlüsseltyp Passwort ausgewählt.
2. Geben Sie ein Passwort ein. Passwort anzeigen macht es beim Tippen sichtbar. Lassen Sie PBKDF2-Iterationen auf 310.000, wenn Sie keinen Grund zur Änderung haben; wer entschlüsselt, muss dieselbe Zahl eingeben.
3. Tippen Sie die Nachricht in Klartext und klicken Sie auf Verschlüsseln, oder drücken Sie Enter im Passwortfeld bzw. Strg+Enter im Text.
4. Kopieren Sie das Verschlüsselte Base64 oder laden Sie es herunter. Aktivieren Sie URL-sichere Ausgabe (- _ , ohne =), wenn die Zeichenkette in eine URL kommt.

Unter der Ausgabe zeigt das Tool eine Aufschlüsselung: die Größen von Salt, IV, Chiffretext und Tag, die Gesamtgröße und die verwendete Schlüsselableitung. Zum Versenden schicken Sie das Base64 in einer Nachricht und das Passwort über einen anderen Kanal, etwa per Telefon oder in einer anderen Chat-App. Der Empfänger öffnet AES entschlüsseln und kehrt den Vorgang um.

Wofür das Tool gedacht ist

Dieses Tool dient dazu, ein Stück Text sicher weiterzugeben, wenn es keinen besseren Kanal gibt: ein WLAN-Passwort für einen Gast, ein Wiederherstellungscode für eine Kollegin, eine Notiz in einem Ticket, das zu viele Leute lesen können. Es ersetzt „Ich schick’s eben im Chat“ durch etwas, das ein Mithörer nicht lesen kann.

Ein Secrets-Manager ist es nicht. Es speichert nichts, steuert keine Zugriffe, protokolliert nicht, wer was entschlüsselt hat, rotiert keine Schlüssel und kann ein einmal versendetes Geheimnis nicht widerrufen. Zugangsdaten von Anwendungen, Produktionsschlüssel und alles, was im Team geteilt wird, gehören in einen richtigen Secrets-Manager oder einen Passwortmanager mit Freigabefunktion. Bedenken Sie außerdem, dass der verschlüsselte Text für immer von jedem entschlüsselt werden kann, der später das Passwort erfährt.

Das genaue Format

Im Passwortmodus lautet die Ausgabe:

Base64( salt[16] ‖ iv[12] ‖ ciphertext ‖ tag[16] )

• Schlüssel: PBKDF2-HMAC-SHA256 über das Passwort als UTF-8, mit dem 16-Byte-Salt und 310.000 Iterationen, Ergebnis 32 Bytes.
• Chiffre: AES-256-GCM mit der 12-Byte-IV, einem 128-Bit-Tag und ohne Associated Data.
• Zufall: ein neues Salt und eine neue IV für jede Verschlüsselung, aus crypto.getRandomValues.

Der Chiffretext ist genau so lang wie die Nachricht in UTF-8, der Blob hat also 44 Bytes Overhead. Eine Nachricht mit 33 Bytes wird zu 77 Bytes, das sind 104 Base64-Zeichen. Es gibt kein Versionsbyte, und die Iterationszahl wird nicht gespeichert: Wenn Sie sie ändern, muss der Empfänger denselben Wert eingeben, sonst schlägt die Entschlüsselung mit demselben Fehler fehl wie bei einem falschen Passwort.

Im Modus Roher Schlüssel entfällt der PBKDF2-Schritt, und die Ausgabe ist Base64( iv[12] ‖ ciphertext ‖ tag[16] ), verschlüsselt mit Ihrem 16, 24 oder 32 Bytes langen Schlüssel als Base64 oder Hex. Zufälligen Schlüssel erzeugen legt einen an. Chrome und Edge unterstützen keine 192-Bit-AES-Schlüssel, und das Tool sagt das, statt stillschweigend zu scheitern; verwenden Sie 128 oder 256 Bit.

Entschlüsseln in Python oder Node.js

Der Empfänger braucht diese Website nicht. Mit Python und dem Paket cryptography (pip install cryptography):

import base64, os
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from cryptography.hazmat.primitives import hashes

def _key(password, salt):
    return PBKDF2HMAC(algorithm=hashes.SHA256(), length=32, salt=salt,
                      iterations=310000).derive(password.encode("utf-8"))

def decrypt(b64, password):
    data = base64.b64decode(b64)
    salt, iv, ct = data[:16], data[16:28], data[28:]
    return AESGCM(_key(password, salt)).decrypt(iv, ct, None).decode("utf-8")

def encrypt(text, password):
    salt, iv = os.urandom(16), os.urandom(12)
    ct = AESGCM(_key(password, salt)).encrypt(iv, text.encode("utf-8"), None)
    return base64.b64encode(salt + iv + ct).decode("ascii")

AESGCM.decrypt erwartet das Tag am Ende des Chiffretexts, und genau dort legt dieses Format es ab. In Node.js muss das Tag abgetrennt und separat übergeben werden:

const crypto = require("crypto");

function decrypt(b64, password) {
  const data = Buffer.from(b64, "base64");
  const salt = data.subarray(0, 16), iv = data.subarray(16, 28);
  const tag = data.subarray(data.length - 16), ct = data.subarray(28, data.length - 16);
  const key = crypto.pbkdf2Sync(password, salt, 310000, 32, "sha256");
  const d = crypto.createDecipheriv("aes-256-gcm", key, iv);
  d.setAuthTag(tag);
  return Buffer.concat([d.update(ct), d.final()]).toString("utf8");
}

Blobs von dieser Seite lassen sich mit beiden Funktionen entschlüsseln, und Blobs aus encrypt() lassen sich auf dieser Seite entschlüsseln. Wenn Sie die URL-sichere Ausgabe verwendet haben, liest Nodes Buffer.from(b64, "base64") sie unverändert; in Python nehmen Sie base64.urlsafe_b64decode(b64 + "=" * (-len(b64) % 4)). openssl enc hilft hier übrigens nicht weiter, da es GCM nicht unterstützt. Die Seiten zu Python und Node.js behandeln die Base64-Seite ausführlicher.

Häufige Fragen