Password Generator

Was ist ein Password Generator?

Ein Password Generator erstellt zufällige Zeichenketten, die als Passwörter für Benutzerkonten, API-Schlüssel, Datenbank-Zugangsdaten und Verschlüsselungsgeheimnisse verwendet werden. Im Gegensatz zu manuell gewählten Passwörtern schöpfen generierte Passwörter aus dem vollständigen Raum möglicher Zeichenkombinationen und sind dadurch resistent gegen Wörterbuchangriffe und musterbasiertes Erraten. Dieses Tool generiert starke Zufallspasswörter online mithilfe des kryptografischen Zufallszahlengenerators deines Browsers.

Die Stärke eines Passworts hängt von zwei Faktoren ab: Länge und Zeichenvielfalt. Ein 20-Zeichen-Passwort mit Groß- und Kleinbuchstaben, Ziffern und Sonderzeichen hat rund 131 Bits Entropie. Auf diesem Niveau würde ein Brute-Force-Angriff mit einer Billion Versuchen pro Sekunde länger als das Alter des Universums benötigen, um jede Kombination durchzuprobieren. Die Berechnung ist einfach: Entropie = Länge × log2(Zeichensatzgröße).

Standards wie NIST SP 800-63B empfehlen Passwörter mit mindestens 8 Zeichen ohne vom Prüfer erzwungene Obergrenze und raten von erzwungenen Kompositionsregeln ab – etwa der Anforderung genau eines Sonderzeichens – und bevorzugen stattdessen längere Passphrasen. Für Maschine-zu-Maschine-Zugangsdaten und Dienstkonten gelten 20 oder mehr zufällige Zeichen aus einem vollständigen Zeichensatz als akzeptierter Basiswert in den meisten Sicherheits- und Compliance-Rahmenwerken.

Warum einen Password Generator verwenden?

Menschen sind schlechte Zufallszahlengeneratoren. Wir verwenden Passwörter wieder, wählen Wörterbuchwörter, ersetzen Buchstaben durch vorhersehbare Muster (@ statt a, 3 statt e) und tendieren zu kurzen Zeichenketten. Ein Password Generator entfernt menschliche Voreingenommenheit aus diesem Prozess.

Anwendungsfälle des Password Generators

Passwort-Entropie-Referenz

Entropie misst, wie unvorhersehbar ein Passwort ist. Sie wird berechnet als log2(Zeichensatzgröße ^ Länge). Höhere Entropie bedeutet mehr mögliche Kombinationen, die ein Angreifer durchsuchen muss. NIST und OWASP empfehlen mindestens 80 Bits Entropie für sicherheitskritische Anwendungen.

Crack-Zeiten setzen 1 Billion Versuche pro Sekunde voraus (Offline-Angriff mit modernen GPUs). Online-Angriffe mit Rate-Limiting sind um Größenordnungen langsamer.

CSPRNG vs. Math.random() zur Passwortgenerierung

Die Zufallsquelle ist genauso wichtig wie die Passwortlänge. Ein Passwort, das mit einem vorhersehbaren Zufallszahlengenerator erstellt wurde, kann von einem Angreifer rekonstruiert werden, der den Algorithmus und den Seed-Zustand kennt. Dieses Tool verwendet crypto.getRandomValues(), einen kryptografisch sicheren Pseudozufallszahlengenerator (CSPRNG), der in jeden modernen Browser integriert ist.

Code-Beispiele

Passwörter programmatisch in verschiedenen Sprachen generieren. Jedes Beispiel unten verwendet eine kryptografisch sichere Zufallsquelle – nicht Math.random() oder vergleichbare schwache PRNGs.

// Generate a random password in the browser or Node.js 19+
function generatePassword(length = 20) {
  const charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*'
  const values = new Uint32Array(length)
  crypto.getRandomValues(values)
  return Array.from(values, v => charset[v % charset.length]).join('')
}

console.log(generatePassword())    // → "kR7!mZp$Xw2&nLq9@Yf3"
console.log(generatePassword(32))  // → "Hd4%tNx!Qw8#mKp2Rv6&Zj0*Ls3Yb7@"

import secrets
import string

def generate_password(length: int = 20) -> str:
    """Generate a cryptographically secure random password."""
    alphabet = string.ascii_letters + string.digits + string.punctuation
    return ''.join(secrets.choice(alphabet) for _ in range(length))

# Single password
print(generate_password())      # → "kR7!mZp$Xw2&nLq9@Yf3"

# Batch of 5 passwords
for _ in range(5):
    print(generate_password(24))

# Ensure at least one char from each category
def generate_strong(length: int = 20) -> str:
    required = [
        secrets.choice(string.ascii_uppercase),
        secrets.choice(string.ascii_lowercase),
        secrets.choice(string.digits),
        secrets.choice(string.punctuation),
    ]
    remaining = length - len(required)
    alphabet = string.ascii_letters + string.digits + string.punctuation
    all_chars = required + [secrets.choice(alphabet) for _ in range(remaining)]
    secrets.SystemRandom().shuffle(all_chars)
    return ''.join(all_chars)

# OpenSSL — generate 32 random bytes, base64-encode
openssl rand -base64 32
# → "x7Kp2mNqR4wZ8vLs1Yb0Hd6tFj3Xc9Ga5eUi+Wo="

# /dev/urandom with tr — alphanumeric + symbols, 20 chars
tr -dc 'A-Za-z0-9!@#$%^&*' < /dev/urandom | head -c 20; echo
# → "kR7!mZp$Xw2&nLq9@Yf3"

# pwgen (install: apt install pwgen / brew install pwgen)
pwgen -sy 20 5
# Generates 5 passwords, 20 chars each, with symbols

package main

import (
    "crypto/rand"
    "fmt"
    "math/big"
)

func generatePassword(length int) (string, error) {
    charset := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()"
    result := make([]byte, length)
    for i := range result {
        idx, err := rand.Int(rand.Reader, big.NewInt(int64(len(charset))))
        if err != nil {
            return "", err
        }
        result[i] = charset[idx.Int64()]
    }
    return string(result), nil
}

func main() {
    pwd, _ := generatePassword(20)
    fmt.Println(pwd) // → "kR7!mZp$Xw2&nLq9@Yf3"
}

Häufig gestellte Fragen