Passwort-Generator und -Prüfungs-Tool

Erzeugen Sie starke Passwörter und Passphrasen mit Unterstützung für Batch-Generierung, Einzigartigkeit, Stärke- und Richtlinienprüfung sowie mehrsprachige Codebeispiele und praktisches Wissen.

Passwort-Richtlinien-Tester

Zu testendes Passwort

Minimale Länge Kleinbuchstaben erforderlich Großbuchstaben erforderlich Ziffern erforderlich Symbole erforderlich Verbot von fortlaufenden Mustern (z. B. abc, 123) Verbot von zu langen Wiederholungen (z. B. aaaa)

Ergebnisse

Länge
Kleinbuchstaben
Großbuchstaben
Ziffern
Symbole
Fortlaufende Sequenzen
Wiederholungen
Sperrliste

Alle Prüfungen werden lokal in Ihrem Browser durchgeführt.

Passphrasen-Generator

Anzahl der Wörter

Trennzeichen

Ersten Buchstaben großschreiben Zahl hinzufügen

Die Wörter werden mithilfe von kryptographisch sicheren Zufallszahlen (Web Crypto) ausgewählt. Die Beispielwortliste ist aufgrund von Größenbeschränkungen kurz.

Passwort-Hashing-Referenz

Argon2id

Argon2id mit angemessenen Speicher-Hardness-Parametern verwenden
Mindestens 2 Iterationen, Speicher ≥ 64 MB (an Umgebung anpassen)
Einzelner Salt pro Benutzer; optional Pepper auf Anwendungsebene verwenden

PBKDF2

SHA-256 oder SHA-512 wählen, mindestens 210.000 Iterationen (anforderungsgerecht anpassen)
Ein eindeutiger Salt pro Hash; Unterstützung für Parameter-Upgrades
Beim nächsten Login auf höhere Kostenparameter migrieren

BCrypt

Kosten zwischen 10 und 14, abhängig von der Serverleistung
Vermeiden Sie Abschneideprobleme; vollständige Passwörter hashen
Authentifizierungsendpunkte limitieren und überwachen

Quelle: NIST SP 800-63B, OWASP ASVS. Parameter müssen an Hardware-Kapazitäten und SLOs angepasst werden.

Passwortstärke bewerten

Die Stärke basiert näherungsweise auf Entropie: Entropie = log2(Zeichenvorrat) × Länge. Ein größerer Zeichenvorrat und eine längere Länge erhöhen die Widerstandsfähigkeit gegen Ratesangriffe.

Schwach: < 50 Bit —— Nur geeignet für einmalige/niedrigwertige Szenarien
Mittel: 50–80 Bit —— Akzeptabel für Niedrigrisiko-Szenarien
Stark: 80–110 Bit —— Empfohlenes Standardziel
Sehr stark: > 110 Bit —— Geeignet für Admin-/Konten mit kritischer Bedeutung

Hinweis: Echte Angriffsmodelle können abweichen; vermeiden Sie Passwort-Wiederverwendung und aktivieren Sie die Mehrfaktor-Authentifizierung (MFA).

Bedienungsanleitung

Wählen Sie Länge und Zeichensatz aus (Kleinbuchstaben/Großbuchstaben/Ziffern/Symbole); aktivieren Sie gegebenenfalls „Ähnliche Zeichen vermeiden“ und „Jedes Zeichen erforderlich“
Für feinere Kontrolle: Zeichen oder Zeichengruppen ausschließen oder Symbolgruppen auswählen
Klicken Sie auf „Generieren“; bei Mehrfachgenerierung: Aktivieren Sie die Batch-Generierung und kopieren Sie alle Ergebnisse mit einem Klick
Um vorhandene Passwörter zu prüfen, nutzen Sie den „Richtlinientester“; für merkfähige Passphrasen verwenden Sie den „Passphrase-Generator“

Funktionen

Sichere Zufallsquelle (Web Crypto)
Konfigurierbare Zeichensätze und Symbolgruppen
Filterung ähnlicher Zeichen und benutzerdefinierte Ausschlüsse
Batch-Generierung, Sicherstellung der Einzigartigkeit und Deduplizierungsstatistik
Stärke- und Entropie-Metriken
Richtlinientester und Passphrase-Generator
Mehrsprachige Codebeispiele （JS、Python、PHP、Go、Java、C#、Rust）
Ein-Klick-Kopieren (einzeln oder alle)

Beispiele für Passwortgenerierung

Stark (Strong)

Länge 24, enthält Groß-/Kleinbuchstaben, Ziffern und Symbole

Mer kfähig (Memorable)

Länge 16, enthält Groß-/Kleinbuchstaben und Ziffern, ähnliche Zeichen vermieden

Passwort-Wissensdatenbank

1) Passwortstärke und Entropie

Entropie ≈ log2(Größen der Zeichenvorrat) × Länge; die Länge hat in der Regel größeren Einfluss
Empfohlenes Ziel: Normale Konten ≥ 80 Bit; Hochrechte/Finanzkonten ≥ 110 Bit
Größerer Zeichenvorrat + längere Länge → bessere Widerstandsfähigkeit gegen Ratesuche

2) Länge vs. Komplexität

Blindes Hinzufügen von Sonderzeichen ist weniger wirksam als das Verlängern des Passworts
Vermeiden Sie vorhersehbare Muster (z. B. immer „Großbuchstabe am Anfang + Zahl am Ende!“)
Stellen Sie zuerst eine ausreichende Länge sicher, bevor Sie die Zeichenvielfalt leicht erhöhen

3) Häufige Fehler und Anti-Patterns

Tastatursequenzen (qwerty), wiederholte Blöcke, Geburtsdaten/Jahreszahlen usw. werden leicht durch Regeln erkannt
„Stammpasswort + Website-Endung“ ist eine Variante mit Wiederholung – riskant und leicht zu erraten
Verwenden Sie dasselbe Passwort nicht auf mehreren Websites

4) Empfehlungen zur Passwortverwaltung

Verwenden Sie einen Passwortmanager; einzigartiges Passwort pro Dienst; aktivieren Sie MFA für wichtige Konten
Übertragen Sie Passwörter nicht im Klartext über öffentliche Kanäle; verwenden Sie bei Bedarf „sprachfreundliche“ Passphrasen
Ändern Sie Passwörter sofort, wenn Leckagen oder Wiederverwendungen festgestellt werden, und stellen Sie Einzigartigkeit sicher

5) Leitfaden für Passphrasen

Kombinationen aus 4–6 Wörtern sind meist stark und leicht merkbar
Mischen Sie Trennzeichen, Großschreibung und Zahlen ein, um Stärke und Lesbarkeit zu verbessern
Vermeiden Sie direkte Übernahmen gängiger Phrasen, Songtexte oder Zitate

Leitfaden zur Passwortsicherheit

Best Practices

Verwenden Sie möglichst lange Passwörter: 16+ Zeichen für normale Konten, 24+ für kritische Konten.
Für merkbare Passwörter bevorzugen Sie Passphrasen; zufällige, hochsichere Passwörter sollten von einem Passwort-Manager gespeichert werden.
Aktivieren Sie so weit wie möglich die Mehrfaktor-Authentifizierung (MFA).
Verwenden Sie kein Passwort mehrfach über verschiedene Websites hinweg – jeder Account sollte ein einzigartiges Passwort haben.

Entropie und Stärke

Entropie misst die Unvorhersehbarkeit basierend auf Länge und Zeichenvorrat; eine höhere Anzahl an Entropie-Bits bedeutet in der Regel eine höhere Sicherheit.

Erhöhen Sie zuerst die Länge, um den größten Sicherheitsgewinn zu erzielen.
Verwenden Sie, wenn möglich, verschiedene Zeichensätze.
Zu strenge Einschränkungen reduzieren den Zeichenvorrat und schwächen das Passwort.

Richtlinien und Rotation

Bevorzugen Sie Länge und Blacklists für gängige/leaked Passwörter gegenüber komplexen Zusammensetzungsregeln.
Vermeiden Sie häufige, erzwungene Passwortwechsel; ändern Sie Passwörter nur bei bekanntem Leak oder Risiko.
Nutzen Sie Listen bekannter kompromittierter Passwörter, um deren Verwendung zu blockieren.

Passphrasen

Verwenden Sie 4–6 zufällige Wörter, verbunden durch Trennzeichen, z. B. lake-CARROT-planet_7.
Vermeiden Sie bekannte Zitate, Songtexte oder gängige Phrasen; Zufälligkeit ist wichtiger als „Intelligenz“.
Für kritische Konten empfehlen wir, echte hochentropische zufällige Passwörter mit einem Passwort-Manager zu speichern.

Hinweise zur Generierung

„Require each selected set“ stellt sicher, dass mindestens ein Zeichen aus jeder ausgewählten Gruppe vorhanden ist.
„Avoid similar“ verbessert die Lesbarkeit, verringert aber leicht den Zeichenvorrat.
Symbole können auf eine vom Zielsystem akzeptierte Teilmenge beschränkt werden.

Serverseitige Speicherung

Speichern Sie Passwörter niemals im Klartext; verwenden Sie starke Hash-Funktionen (Argon2id/PBKDF2/BCrypt) mit Salt.
Konfigurieren Sie Parameter (Speicher, Zeit, Kosten) angemessen; verwenden Sie gegebenenfalls einen Pepper.
Limitieren Sie die Anzahl der Versuche und überwachen Sie fehlgeschlagene Logins; bei Angriffen CAPTCHA oder Geräteüberprüfung hinzufügen.

Mehrfaktor-Authentifizierung und Wiederherstellung

Verwenden Sie bevorzugt TOTP oder Hardware-Schlüssel; vermeiden Sie SMS so weit wie möglich.
Sichern Sie den Wiederherstellungsprozess: Nutzen Sie mehrere Faktoren oder E-Mail-Validierung mit Cooling-Period.
Bieten Sie Backup-Wiederherstellungscodes an und empfehlen Sie Benutzern, diese sicher aufzubewahren.

Schutz vor Brute-Force-Angriffen

Implementieren Sie schrittweise Verzögerungen oder Sperrungen sowie IP-/Geräte-Risikobewertungen.
Konfigurieren Sie WAF und Rate-Limiting für APIs und Login-Formulare.
Überwachen Sie Credential Stuffing und ermutigen Sie Benutzer, eindeutige Passwörter zu verwenden.

Lokale Speicherung und Verarbeitung

Verwenden Sie vertrauenswürdige Passwort-Manager zur Speicherung und automatischen Ausfüllung.
Teilen Sie Passwörter nicht per Chat oder E-Mail im Klartext; nutzen Sie für Teams Secret-Management-Tools.
Wenn Sie Passwörter physisch notieren müssen, stellen Sie sicher, dass sie physisch gesichert sind.

Haftungsausschluss: Dieses Tool generiert Passwörter lokal im Browser mit Web Crypto; es werden keine Daten an einen Server gesendet.

Wie man Passwörter programmatisch generiert

JavaScript（Web Crypto）

function randomPassword(length = 16, sets = {lower:true, upper:true, digits:true, symbols:true}) {
  const pools = {
    lower: 'abcdefghijklmnopqrstuvwxyz',
    upper: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
    digits: '0123456789',
    symbols: '!@#$%^&*+-=_~`|/?()[]{}<>,.;:\'\"'
  };
  let pool = '';
  for (const k of Object.keys(sets)) if (sets[k]) pool += pools[k];
  if (!pool) throw new Error('No charset');
  const bytes = new Uint32Array(length);
  crypto.getRandomValues(bytes);
  let out = '';
  for (let i = 0; i < length; i++) out += pool[bytes[i] % pool.length];
  return out;
}

Python（secrets）

import secrets

def random_password(length=16, lower=True, upper=True, digits=True, symbols=True):
    pools = {
        'lower': 'abcdefghijklmnopqrstuvwxyz',
        'upper': 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
        'digits': '0123456789',
        'symbols': '!@#$%^&*+-=_~`|/?()[]{}<>,.;:\'\"'
    }
    pool = ''.join(v for k, v in pools.items() if locals()[k])
    if not pool:
        raise ValueError('No charset')
    return ''.join(secrets.choice(pool) for _ in range(length))

PHP（random_int）

function random_password($length = 16, $sets = ['lower'=>true,'upper'=>true,'digits'=>true,'symbols'=>true]) {
    $pools = [
        'lower' => 'abcdefghijklmnopqrstuvwxyz',
        'upper' => 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
        'digits' => '0123456789',
        'symbols' => '!@#$%^&*+-=_~`|/?()[]{}<>,.;:\'\"'
    ];
    $pool = '';
    foreach ($sets as $k => $on) if ($on) $pool .= $pools[$k];
    if ($pool === '') throw new Exception('No charset');
    $out = '';
    for ($i = 0; $i < $length; $i++) {
        $out .= $pool[random_int(0, strlen($pool)-1)];
    }
    return $out;
}

Go（crypto/rand）

package main

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

func RandomPassword(length int, pool string) (string, error) {
  out := make([]byte, length)
  for i := 0; i < length; i++ {
    nBig, err := rand.Int(rand.Reader, big.NewInt(int64(len(pool))))
    if err != nil { return "", err }
    out[i] = pool[nBig.Int64()]
  }
  return string(out), nil
}

Java（SecureRandom）

import java.security.SecureRandom;

public class Pw {
  static final String POOL = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*+-=_~`|/?()[]{}<>,.;:'\"";
  static final SecureRandom SR = new SecureRandom();
  static String randomPassword(int length) {
    StringBuilder sb = new StringBuilder(length);
    for (int i = 0; i < length; i++) {
      int idx = SR.nextInt(POOL.length());
      sb.append(POOL.charAt(idx));
    }
    return sb.toString();
  }
}

C#（.NET RandomNumberGenerator）

using System;
using System.Security.Cryptography;

public static class Pw {
  public static string RandomPassword(int length, string pool) {
    using var rng = RandomNumberGenerator.Create();
    var bytes = new byte[length];
    rng.GetBytes(bytes);
    var chars = new char[length];
    for (int i = 0; i < length; i++) {
      chars[i] = pool[bytes[i] % pool.Length];
    }
    return new string(chars);
  }
}

Rust（rand + getrandom）

use rand::rngs::OsRng;
use rand::RngCore;

fn random_password(length: usize, pool: &str) -> String {
    let mut bytes = vec![0u8; length];
    OsRng.fill_bytes(&mut bytes);
    let chars: Vec = pool.chars().collect();
    bytes
        .iter()
        .map(|b| chars[(*b as usize) % chars.len()])
        .collect()
}

fn main() {
    let pool = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*+-=_~`|/?()[]{}<>,.;:'\"";
    let pw = random_password(16, pool);
    println!("{}", pw);
}