Passwort-Entropie: Wie du deine Passwortstärke misst und maximierst

P@$$w0rd! erfüllt alle gängigen Komplexitätsregeln (Großbuchstaben, Zahlen, Sonderzeichen), kann aber in unter einer Sekunde geknackt werden.

Das Maß für Passwortstärke ist nicht, welche Zeichen du verwendest, sondern Entropie: ein Konzept aus der Informationstheorie, das quantifiziert, wie unvorhersagbar dein Passwort ist.

Dieser Leitfaden erklärt, wie Passwort-Entropie funktioniert, wie man sie berechnet und wie man Passwörter generiert, die tatsächlich schwer zu knacken sind.

Was ist Passwort-Entropie?

Passwort-Entropie misst, wie unvorhersagbar ein Passwort ist, ausgedrückt in Bits. Jedes zusätzliche Bit Entropie verdoppelt die Anzahl der Versuche, die ein Angreifer für einen Brute-Force-Angriff braucht.

Vergleich mit Würfeln: Ein 6-seitiger Würfel hat etwa 2,6 Bits Entropie pro Wurf (6 mögliche Ergebnisse). Ein 20-seitiger Würfel hat etwa 4,3 Bits. Mehr Seiten bedeuten mehr Unsicherheit.

Passwörter funktionieren genauso: Mehr mögliche Zeichen (größerer „Würfel”) und mehr Zeichen im Passwort (mehr „Würfe”) erhöhen beide die Entropie.

Deshalb ist Entropie ein besseres Maß als Komplexitätsregeln. Ein Passwort kann komplex aussehen (Tr0ub4dor&3), aber niedrige Entropie haben, weil es vorhersagbaren Mustern folgt. Gleichzeitig kann eine einfach aussehende Passphrase (correct horse battery staple) hohe Entropie haben, weil sie aus einem großen Pool von Möglichkeiten gezogen wird.

Die Formel: Passwort-Entropie berechnen

Die Formel:

E = L × log₂(R)

Wobei:

E = Entropie in Bits
L = Passwortlänge (Anzahl der Zeichen)
R = Poolgröße (Anzahl möglicher Zeichen pro Position)

Zeichenpool-Größen

Zeichentyp	Poolgröße (R)	Bits pro Zeichen
Nur Kleinbuchstaben (a-z)	26	4,70
Kleinbuchstaben + Ziffern	36	5,17
Groß + Klein + Ziffern	62	5,95
Vollständiges druckbares ASCII	94	6,55
Diceware-Wortliste	7.776	12,92 pro Wort

In Code berechnen

// Passwort-Entropie in JavaScript berechnen
const entropy = (length, poolSize) =>
  length * Math.log2(poolSize);

entropy(8, 26);   // → 37.60 Bits (nur Kleinbuchstaben)
entropy(12, 62);  // → 71.45 Bits (alphanumerisch)
entropy(16, 94);  // → 104.87 Bits (voller Zeichensatz)

import math

def entropy(length: int, pool_size: int) -> float:
    return length * math.log2(pool_size)

entropy(8, 26)   # → 37.60 Bits
entropy(12, 62)  # → 71.45 Bits
entropy(16, 94)  # → 104.87 Bits

Wichtig: Diese Formel setzt voraus, dass jedes Zeichen gleichmäßig zufällig gewählt wird. Wenn ein Mensch das Passwort mit Mustern oder Wörterbuchwörtern wählt, ist die tatsächliche Entropie viel niedriger als das theoretische Maximum.

Wie viel Entropie reicht aus?

Die Antwort hängt davon ab, was du schützt und wie schnell ein Angreifer raten kann.

Moderne GPUs können über 10¹² (eine Billion) Passwort-Hashes pro Sekunde gegen schnelle Algorithmen wie MD5 testen. Hier ist, was das in der Praxis bedeutet:

Entropie (Bits)	Stärke	Knackzeit bei 10¹² Versuchen/s	Empfohlen für
< 40	Schwach	Unter 1 Sekunde	Niemals verwenden
40–59	Ausreichend	Sekunden bis Stunden	Wegwerf-Konten
60–79	Stark	Tage bis Jahrhunderte	Reguläre Konten
80–99	Sehr stark	Jahrtausende+	E-Mail, Banking
100+	Extrem	Jenseits des Wärmetods des Universums	Verschlüsselungsschlüssel, Master-Passwörter

Ein 16-Zeichen-Passwort mit dem vollständigen druckbaren ASCII-Satz gibt etwa 105 Bits Entropie. Der Zufalls-Passwort-Generator zeigt die Echtzeit-Entropieanalyse für jedes Passwort an.

Was NIST sagt (Update 2024)

NIST SP 800-63B, aktualisiert 2024, hat die Passwortrichtlinien geändert:

Gestrichen: Pflicht-Komplexitätsregeln (keine erzwungenen Sonderzeichen mehr)
Gestrichen: Pflicht-Passwortwechsel in regelmäßigen Abständen
Erhöht: Minimum auf 15 Zeichen (von 8 in vorherigen Versionen)
Betont: Abgleich gegen bekannte kompromittierte Passwörter
Bevorzugt: Länge und Zufälligkeit über Komplexität

Das deckt sich mit der Entropie-Mathematik: Länge und Zufälligkeit sind wichtiger als Zeichenvielfalt.

Warum Länge Komplexität schlägt

Zwei Möglichkeiten, die Entropie eines 12-Zeichen-Passworts zu erhöhen:

Option A: 12 Zeichen behalten, von alphanumerisch (62) auf volles ASCII (94) wechseln:

12 × log₂(94) - 12 × log₂(62) = 78,66 - 71,45 = +7,21 Bits

Option B: Alphanumerisch (62) behalten, ein Zeichen mehr (12 → 13):

13 × log₂(62) - 12 × log₂(62) = 77,40 - 71,45 = +5,95 Bits

Ein einzelnes zusätzliches Zeichen gibt dir fast so viel Entropie wie der Wechsel zu einem viel größeren Zeichensatz. Füge zwei Zeichen hinzu und du hast ihn übertroffen.

Betrachte nun P@$$w0rd! (9 Zeichen). Es nutzt den vollen ASCII-Pool, ist aber zu kurz. Schlimmer noch, es folgt dem vorhersagbaren „Leet Speak”-Muster, das Wörterbuch-Angriffe bereits abdecken, sodass seine effektive Entropie weit unter den theoretischen 59 Bits liegt.

Für zufällige Passwörter ist das Hinzufügen von Länge effizienter als das Erweitern des Zeichensatzes. Aber der eigentliche Feind ist Vorhersagbarkeit, nicht Kürze.

Passphrase vs. Zufallspasswort

Dimension	Zufallspasswort	Passphrase (Diceware)
Beispiel	`kX#9mP$2vL!nQ7wR`	`correct horse battery staple`
Bits pro Einheit	6,55 pro Zeichen	12,92 pro Wort
Länge für ~78 Bits	12 Zeichen	6 Wörter
Merkbarkeit	Schlecht	Gut
Mobilgeräte-Eingabe	Mühsam	Einfach
Am besten für	Passwort-Manager-Einträge	Master-Passwörter, auswendig gelernte Logins

Wie Diceware funktioniert

Diceware verwendet eine Wortliste mit 7.776 Einträgen (6⁵ = 7.776). Du würfelst fünf Würfel, um jedes Wort auszuwählen, was genau 12,92 Bits Entropie pro Wort ergibt.

Vier Wörter geben ~51 Bits; sechs Wörter geben ~77 Bits.

Was solltest du verwenden?

Für Passwörter im Manager: Verwende zufällige 16+ Zeichen-Passwörter mit vollem Zeichensatz. Du tippst sie nie manuell, also spielt Merkbarkeit keine Rolle. Der Zufalls-Passwort-Generator kann bis zu 50 auf einmal erzeugen.
Für dein Master-Passwort: Verwende eine 5–6-Wort-Diceware-Passphrase. Sie ist einprägsam genug zum täglichen Tippen und bietet 64–77 Bits Entropie.
Für API-Schlüssel und Token: Verwende openssl rand oder crypto.randomBytes() für maximale Entropie ohne Merkbarkeitsanforderung.

Entropie in der Praxis: Entwickler-Tools und Code

Hier sind die häufigsten Methoden, wie Entwickler hochentropische Geheimnisse erzeugen:

Browser (Web Crypto API)

// Kryptografisch sichere Passwort-Erzeugung
function generatePassword(length, charset) {
  const array = new Uint32Array(length);
  crypto.getRandomValues(array);
  return Array.from(array, v => charset[v % charset.length]).join('');
}

const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*';
generatePassword(16, chars);
// → 'kX#9mP$2vL!nQ7wR' (jedes Mal zufällig)

Node.js

const crypto = require('crypto');
const token = crypto.randomBytes(32).toString('base64url');
// → 'Ql2Hj8xK9mNp3rVw5tYz7uBa0cEf4gIk' (43 Zeichen, 256 Bits)

Python

import secrets
token = secrets.token_urlsafe(32)  # 256 Bits Entropie
password = secrets.token_hex(16)    # 128 Bits, Hex-Format

Kommandozeile

# 192 Bits Entropie, Base64-kodiert
openssl rand -base64 24

# 256 Bits, Hex-kodiert
openssl rand -hex 32

Entropie-Vergleich nach Methode

Methode	Ausgabelänge	Entropie (Bits)
UUID v4	36 Zeichen	122
`openssl rand -base64 24`	32 Zeichen	192
16-Zeichen volles ASCII	16 Zeichen	105
6-Wort Diceware	~30 Zeichen	78
4-Wort Diceware	~20 Zeichen	52

Verwende niemals Math.random() für sicherheitsrelevante Zwecke. Es nutzt einen nicht-kryptografischen PRNG. Die Ausgabe ist vorhersagbar, wenn ein Angreifer den Seed kennt. Verwende immer crypto.getRandomValues() im Browser oder crypto.randomBytes() in Node.js.

Passwortspeicherung: Warum Entropie allein nicht reicht

Selbst ein 128-Bit-Passwort ist wertlos, wenn der Server es als einfachen MD5-Hash speichert. Wenn eine Datenbank geleakt wird, können Angreifer Billionen von MD5-Hashes pro Sekunde auf einer einzelnen GPU testen.

Langsame Hashing-Algorithmen machen jeden Versuch absichtlich teuer:

Algorithmus	Geschwindigkeit auf GPU	Effektive Verlangsamung
MD5	~10 Milliarden/s	Baseline (nicht verwenden)
SHA-256	~5 Milliarden/s	~2× langsamer
bcrypt (cost=12)	~5/s	~2 Milliarden× langsamer
argon2id	~2/s	~5 Milliarden× langsamer

bcrypts Cost-Parameter ist besonders elegant: Jede Erhöhung verdoppelt den erforderlichen Aufwand. Ein Cost-Faktor von 12 bedeutet 2¹² = 4.096 Runden Hashing. Das fügt effektiv 12 Bits „Speicher-Entropie” zur eigenen Entropie des Passworts hinzu.

Das duale Schutzmodell: Hochentropische Passwörter schützen gegen Offline-Brute-Force, während langsames Hashing gegen Datenbank-Leaks schützt. Du brauchst beides.

Siehe auch: MD5 vs SHA-256 Vergleich | MD5 Hash-Generator

Verbreitete Passwort-Mythen entkräftet

„Ändere dein Passwort alle 90 Tage”

Die NIST-Richtlinien von 2024 empfehlen explizit gegen regelmäßige Pflicht-Änderungen. Häufige Wechsel führen dazu, dass Nutzer schwächere, vorhersagbarere Passwörter wählen: eine Zahl am Ende hinzufügen, durch einen kleinen Satz rotieren. Ändere Passwörter nur, wenn du Grund zur Annahme hast, dass sie kompromittiert wurden.

„a→@, e→3 macht es stärker”

Leet-Speak-Substitutionen gehören zu den ersten Mustern, die Wörterbuch-Angriffe prüfen. Das Ersetzen von a durch @ in password fügt praktisch null Entropie hinzu, weil Angreifer es bereits erwarten.

Echte Zufälligkeit, nicht clevere Substitutionen, erhöht die Entropie.

„8 Zeichen mit Symbolen reichen”

Selbst mit dem vollen 94-Zeichen-ASCII-Satz geben 8 Zeichen nur 52 Bits Entropie. Bei 10¹² Versuchen pro Sekunde ist das in etwa 75 Minuten geknackt.

Verwende mindestens 12 Zeichen, 16+ für wichtige Konten.

„Je komplexer es aussieht, desto sicherer ist es”

Visuelle Komplexität und Entropie sind verschiedene Dinge. Tr0ub4dor&3 sieht komplex aus, folgt aber einem vorhersagbaren Basiswort-plus-Substitutionen-Muster. mfYq8kL2nR sieht einfacher aus, hat aber höhere Entropie, weil es wirklich zufällig ist.

Siehe auch: Web-Sicherheits-Leitfaden

FAQ

Wie viele Bits Entropie gelten als sicher?

Für die meisten Online-Konten bieten 60–80 Bits starken Schutz. Für hochwertige Ziele wie Master-Passwörter oder Verschlüsselungsschlüssel strebe 100+ Bits an. Jedes zusätzliche Bit verdoppelt den erforderlichen Aufwand des Angreifers.

Erhöht das Hinzufügen von Sonderzeichen immer die Entropie?

Nur wenn die Zeichen zufällig aus dem vollständigen Pool gewählt werden. Vorhersagbare Substitutionen wie @ für a oder ! am Ende fügen praktisch keine Entropie hinzu, weil Angreifer diese Muster bereits in ihren Wörterbüchern berücksichtigen.

Was ist die Entropie einer 4-Wort-Diceware-Passphrase?

Mit der Standard-7.776-Wort-Diceware-Liste trägt jedes Wort 12,92 Bits bei. Vier Wörter geben ungefähr 51,7 Bits, ausreichend für niedrige Sicherheitsanforderungen. Für wichtige Konten verwende 5–6 Wörter (64–78 Bits).

Ist Math.random() sicher für die Passworterzeugung?

Nein. Math.random() ist ein Pseudozufallszahlengenerator, der nicht kryptografisch sicher ist. Verwende crypto.getRandomValues() im Browser oder crypto.randomBytes() in Node.js für sicherheitsrelevante Zufallserzeugung.

Wie beeinflusst bcrypts Cost-Faktor die Sicherheit?

Jede Erhöhung des bcrypt-Cost-Faktors verdoppelt die für das Hashen (und damit für Brute-Force) eines Passworts erforderliche Berechnung. Ein Cost von 12 bedeutet 2¹² = 4.096 Iterationen und fügt effektiv 12 Bits Schwierigkeit zur eigentlichen Entropie des Passworts hinzu.

Was hat sich in den NIST-Passwortrichtlinien 2024 geändert?

NIST SP 800-63B hat Pflicht-Komplexitätsanforderungen (erzwungene Sonderzeichen, gemischte Groß-/Kleinschreibung) und periodische Passwortwechsel gestrichen. Die neue Empfehlung bevorzugt längere Passwörter (15+ Zeichen empfohlen), Abgleich gegen Datenbanken kompromittierter Passwörter und die Erlaubnis aller druckbaren Zeichen einschließlich Leerzeichen.

Wichtige Erkenntnisse

Entropie = L × log₂(R): Jedes zusätzliche Bit verdoppelt die Anzahl benötigter Versuche
Länge > Komplexität: Ein Zeichen hinzuzufügen ist effektiver als den Zeichensatz zu erweitern
Crypto-APIs verwenden: crypto.getRandomValues() oder crypto.randomBytes(), niemals Math.random()
Passwort-Manager + Zufallserzeugung ist die beste Praxis für die meisten Menschen
Serverseitig zählt auch: Verwende bcrypt oder argon2, speichere Passwörter nie mit MD5

Siehe auch: Zufalls-Passwort-Generator (mit Echtzeit-Entropieanalyse)

Passwort-Entropie: Stärke berechnen und verbessern