Starke, zufaellige Passwoerter zu erstellen ist eine Herausforderung, der sich jeder Administrator und Entwickler regelmaessig stellen muss — sei es bei der Einrichtung von Dienstkonten, der Bereitstellung von Benutzeranmeldeinformationen oder der Generierung von API-Schluesseln. Dieser Leitfaden behandelt mehrere Methoden zur Generierung sicherer zufaelliger Passwoerter auf verschiedenen Plattformen sowie Best Practices fuer Passwortkomplexitaet und -speicherung.

Anforderungen an die Passwortkomplexitaet

Bevor Sie Passwoerter generieren, sollten Sie verstehen, was ein Passwort stark macht:

  • Laenge — Mindestens 14 Zeichen fuer Administratorkonten, 12 fuer Standardbenutzer
  • Zeichenvielfalt — Enthalten Sie Grossbuchstaben, Kleinbuchstaben, Ziffern und Sonderzeichen
  • Zufaelligkeit — Verwenden Sie einen kryptografisch sicheren Zufallszahlengenerator, kein vorhersagbares Muster
  • Einzigartigkeit — Jedes Konto sollte ein anderes Passwort haben

Die meisten Compliance-Frameworks (NIST, PCI-DSS, HIPAA) verlangen, dass Passwoerter bestimmte Komplexitaetsregeln erfuellen. NIST SP 800-63B empfiehlt, den Fokus auf die Passwortlaenge statt auf Komplexitaetsanforderungen zu legen, aber viele Systeme erzwingen immer noch gemischte Zeichentypen.

PowerShell-Methoden

Verwendung der Membership-Klasse

Die einfachste Methode in PowerShell verwendet die Klasse System.Web.Security.Membership:

# Load the System.Web assembly
Add-Type -AssemblyName System.Web

# Generate a single password (16 characters, minimum 4 special characters)
[System.Web.Security.Membership]::GeneratePassword(16, 4)

# Generate multiple passwords
1..10 | ForEach-Object {
    [System.Web.Security.Membership]::GeneratePassword(20, 5)
}

Der erste Parameter ist die Gesamtlaenge und der zweite die Mindestanzahl nicht-alphanumerischer Zeichen.

Benutzerdefinierter PowerShell-Passwortgenerator

Fuer mehr Kontrolle ueber Zeichensaetze und Formatierung:

function New-RandomPassword {
    param(
        [int]$Length = 16,
        [int]$MinUpperCase = 2,
        [int]$MinLowerCase = 2,
        [int]$MinDigits = 2,
        [int]$MinSpecial = 2
    )

    $upper   = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    $lower   = 'abcdefghijklmnopqrstuvwxyz'
    $digits  = '0123456789'
    $special = '!@#$%^&*()-_=+[]{}|;:,.<>?'

    $password = @()

    # Ensure minimum requirements
    $password += ($upper.ToCharArray()   | Get-Random -Count $MinUpperCase)
    $password += ($lower.ToCharArray()   | Get-Random -Count $MinLowerCase)
    $password += ($digits.ToCharArray()  | Get-Random -Count $MinDigits)
    $password += ($special.ToCharArray() | Get-Random -Count $MinSpecial)

    # Fill remaining length with random characters from all sets
    $allChars = $upper + $lower + $digits + $special
    $remaining = $Length - $password.Count
    if ($remaining -gt 0) {
        $password += ($allChars.ToCharArray() | Get-Random -Count $remaining)
    }

    # Shuffle the result
    $password = $password | Get-Random -Count $password.Count

    return -join $password
}

# Generate a single password
New-RandomPassword -Length 20

# Generate a batch of passwords
1..25 | ForEach-Object { New-RandomPassword -Length 16 }

Kryptografisch sichere PowerShell-Methode

Fuer die hoechste Sicherheit verwenden Sie System.Security.Cryptography.RandomNumberGenerator:

function New-SecurePassword {
    param([int]$Length = 20)

    $charSet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*'
    $bytes = New-Object byte[] $Length
    $rng = [System.Security.Cryptography.RandomNumberGenerator]::Create()
    $rng.GetBytes($bytes)

    $password = New-Object char[] $Length
    for ($i = 0; $i -lt $Length; $i++) {
        $password[$i] = $charSet[$bytes[$i] % $charSet.Length]
    }

    return -join $password
}

New-SecurePassword -Length 24

Kryptografische Passwortgenerierung in .NET

Verwendung von RandomNumberGenerator (Empfohlen)

In .NET ist RandomNumberGenerator (der den aelteren RNGCryptoServiceProvider ersetzt hat) die korrekte Methode zur Generierung kryptografisch sicherer Zufallsdaten:

using System.Security.Cryptography;

public static string GeneratePassword(int length = 20)
{
    const string chars =
        "abcdefghijklmnopqrstuvwxyz" +
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +
        "0123456789" +
        "!@#$%^&*()-_=+[]{}|;:,.<>?";

    var password = new char[length];
    var randomBytes = new byte[length];

    using (var rng = RandomNumberGenerator.Create())
    {
        rng.GetBytes(randomBytes);
    }

    for (int i = 0; i < length; i++)
    {
        password[i] = chars[randomBytes[i] % chars.Length];
    }

    return new string(password);
}

Warum nicht System.Random?

Verwenden Sie niemals System.Random fuer die Passwortgenerierung:

// DO NOT use this for passwords -- it is predictable!
var random = new Random();
// An attacker who knows the seed can predict every output

System.Random verwendet einen deterministischen Pseudozufallszahlengenerator. Wenn ein Angreifer den Startwert erraten oder bestimmen kann (zum Beispiel die Systemzeit bei der Initialisierung), kann er die gesamte Sequenz reproduzieren. RandomNumberGenerator verwendet die kryptografische Zufallsquelle des Betriebssystems, die fuer sicherheitsrelevante Operationen geeignet ist.

Linux-Befehlszeilenmethoden

Verwendung von openssl

# Generate a 24-character random password (base64 encoded)
openssl rand -base64 24

# Generate a hex-encoded password
openssl rand -hex 16

Verwendung von pwgen

Das Dienstprogramm pwgen generiert aussprechbare (oder vollstaendig zufaellige) Passwoerter:

# Install pwgen
sudo apt install pwgen    # Debian/Ubuntu
sudo yum install pwgen    # RHEL/CentOS

# Generate one 16-character secure password
pwgen -s 16 1

# Generate 20 passwords of 20 characters each, fully random
pwgen -s -y 20 20

# Options:
#   -s  Fully random (not pronounceable)
#   -y  Include special characters
#   -c  Include at least one capital letter (default)
#   -n  Include at least one number (default)

Verwendung von /dev/urandom

# Generate a 20-character alphanumeric password
< /dev/urandom tr -dc 'A-Za-z0-9!@#$%^&*' | head -c 20; echo

# Generate multiple passwords
for i in $(seq 1 10); do
    < /dev/urandom tr -dc 'A-Za-z0-9!@#$%^&*()-_=+' | head -c 20
    echo
done

Verwendung von Python

# One-liner for a 20-character password
python3 -c "import secrets, string; print(''.join(secrets.choice(string.ascii_letters + string.digits + string.punctuation) for _ in range(20)))"

Das Modul secrets in Python 3.6+ ist speziell fuer die Generierung kryptografisch sicherer Token und Passwoerter konzipiert.

Massenpasswortgenerierung fuer Benutzerbereitstellung

Bei der Bereitstellung mehrerer Konten koennen Sie die Passwortgenerierung mit CSV-Ausgabe kombinieren:

PowerShell: Passwoerter fuer eine Benutzerliste generieren

# Read a list of usernames and generate passwords
$users = Import-Csv -Path "C:\users.csv"

$results = foreach ($user in $users) {
    [PSCustomObject]@{
        Username = $user.Username
        Password = [System.Web.Security.Membership]::GeneratePassword(16, 4)
    }
}

$results | Export-Csv -Path "C:\user-passwords.csv" -NoTypeInformation

Bash: Passwoerter aus einer Benutzerliste generieren

#!/bin/bash
while IFS= read -r username; do
    password=$(< /dev/urandom tr -dc 'A-Za-z0-9!@#$%^&*' | head -c 16)
    echo "$username,$password"
done < users.txt > user-passwords.csv

Sichere Passwortspeicherungspraktiken

Starke Passwoerter zu generieren ist nur die halbe Miete. Sie sicher zu speichern ist ebenso wichtig.

Fuer Benutzerauthentifizierung (Hashing)

Speichern Sie Benutzerpasswoerter niemals im Klartext. Verwenden Sie einen Einweg-Hash-Algorithmus mit einem eindeutigen Salt:

  • bcrypt — Der am haeufigsten empfohlene Algorithmus fuer Passwort-Hashing. Enthaelt integriertes Salting und einen konfigurierbaren Arbeitsfaktor.
  • scrypt — Speicherintensiver Algorithmus, der gegen GPU-basierte Angriffe resistent ist.
  • Argon2 — Gewinner des Password Hashing Competition. Bietet den besten Schutz gegen moderne Angriffe.

Vermeiden Sie MD5 und SHA-1/SHA-256 fuer Passwort-Hashing — sie sind zu schnell, was Brute-Force-Angriffe praktikabel macht.

Fuer Anwendungsgeheimnisse (Secrets-Management)

Fuer Passwoerter, die von Anwendungen verwendet werden (Datenbankzugangsdaten, API-Schluessel, Dienstkontopasswoerter):

  • Azure Key Vault — Verwalteter Secrets-Speicher fuer Azure-Umgebungen
  • AWS Secrets Manager — Verwalteter Secrets-Speicher mit Unterstuetzung fuer automatische Rotation
  • HashiCorp Vault — Open-Source-Secrets-Management fuer jede Umgebung
  • Umgebungsvariablen — Akzeptabel fuer die Entwicklung, aber verwenden Sie einen Secrets-Manager in der Produktion

Speichern Sie Geheimnisse niemals in:

  • Quellcode-Repositorys
  • Konfigurationsdateien, die in die Versionskontrolle eingecheckt sind
  • Unverschluesselten Textdateien auf Servern
  • Gemeinsam genutzten Dokumenten oder Wikis

Passwort-Manager fuer den persoenlichen Gebrauch

Zur Verwaltung individueller Passwoerter verwenden Sie einen Passwort-Manager:

  • Bitwarden — Open Source, plattformuebergreifend
  • 1Password — Funktionsreich, mit Team- und Familienplaenen
  • KeePass — Offline, Open Source

Zusammenfassung

Die Generierung sicherer zufaelliger Passwoerter erfordert die Verwendung kryptografisch sicherer Zufallszahlengeneratoren — sei es ueber die Membership-Klasse von PowerShell, den RandomNumberGenerator von .NET oder Linux-Tools wie openssl und pwgen. Vermeiden Sie vorhersagbare Quellen wie System.Random oder einfaches willkuerliches Tippen auf der Tastatur. Fuer die Massenbereitstellung automatisieren Sie den Generierungsprozess und exportieren Sie in ein sicheres Format. Speichern Sie Passwoerter immer mit geeigneten Hashing-Algorithmen fuer die Authentifizierung oder einem Secrets-Manager fuer Anwendungszugangsdaten.