openssl_pbkdf2 — Funktion · PHP-Referenz

Signatur

openssl_pbkdf2(string $password, string $salt, int $key_length, int $iterations, string $digest_algo = 'sha1'): string|false

Beschreibung

openssl_pbkdf2 implementiert die Password-Based Key Derivation Function 2 (PBKDF2) gemäß PKCS#5 v2. Sie wird eingesetzt, um aus einem Passwort einen Schlüssel definierter Länge abzuleiten – beispielsweise für Verschlüsselung, Integritätsprüfungen oder das sichere Speichern von Passwörtern. Durch die wiederholte Anwendung einer kryptografischen Hash-Funktion (HMAC) wird ein Brute-Force-Angriff erheblich verlangsamt.

Im Gegensatz zu einfachen Hash-Funktionen wie md5() oder sha1() ist PBKDF2 speziell für Passwort-Hashing konzipiert: Die hohe Iterationszahl macht das Berechnen von Hashes aufwendig, was Wörterbuch- und Brute-Force-Angriffe deutlich erschwert. Der Salt verhindert dabei den Einsatz von Regenbogentabellen.

Die Funktion gibt den abgeleiteten Schlüssel als Binärstring zurück. Für die Speicherung in Datenbanken oder die Übertragung empfiehlt sich eine anschließende Kodierung mit bin2hex() oder base64_encode(). Als Digest-Algorithmus sollte mindestens sha256 oder stärker gewählt werden; sha1 gilt als veraltet.

Für die reine Passwortspeicherung ohne eigene Schlüsselableitung sollten stattdessen password_hash() und password_verify() bevorzugt werden, da diese speziell auf diesen Anwendungsfall optimiert sind (bcrypt, Argon2).

Parameter

Name	Typ	Default	Beschreibung
$password Pflicht	string		Das Quell-Passwort, aus dem der Schlüssel abgeleitet wird.
$salt Pflicht	string		Ein kryptografisch zufälliger Salt-Wert. Sollte für jeden Benutzer/Einsatz einzigartig sein und mindestens 16 Byte lang sein. Empfohlen wird die Erzeugung mit `random_bytes()`.
$key_length Pflicht	int		Die gewünschte Länge des abgeleiteten Schlüssels in Byte. Typische Werte sind 32 (für AES-256) oder 16 (für AES-128).
$iterations Pflicht	int		Anzahl der Iterationen des HMAC-Algorithmus. Höhere Werte erhöhen die Sicherheit, aber auch den Rechenaufwand. NIST empfiehlt mindestens 600.000 Iterationen für SHA-256 (Stand 2023).
$digest_algo	string	sha1	Der zu verwendende Hash-Algorithmus, z. B. `'sha256'` oder `'sha512'`. Verfügbare Algorithmen können mit `openssl_get_md_methods()` abgerufen werden. `sha1` als Standard gilt als veraltet.

Rückgabewert

Typ

string|false

Beschreibung

Gibt bei Erfolg den abgeleiteten Schlüssel als rohen Binärstring der angegebenen Länge zurück. Bei einem Fehler (z. B. unbekannter Algorithmus) wird false zurückgegeben.

Beispiele

Schlüsselableitung für AES-256-Verschlüsselung

<?php
$password   = 'mein-geheimes-passwort';
$salt       = random_bytes(16);          // kryptografisch sicherer Salt
$keyLength  = 32;                        // 256 Bit für AES-256
$iterations = 100000;
$algo       = 'sha256';

$key = openssl_pbkdf2($password, $salt, $keyLength, $iterations, $algo);

if ($key === false) {
    throw new RuntimeException('PBKDF2-Schlüsselableitung fehlgeschlagen.');
}

// Für Speicherung/Übertragung als Hex kodieren
$keyHex  = bin2hex($key);
$saltHex = bin2hex($salt);

echo 'Salt (hex): ' . $saltHex . PHP_EOL;
echo 'Key  (hex): ' . $keyHex  . PHP_EOL;

Salt (hex): <zufälliger 32-Zeichen Hex-String> Key (hex): <deterministischer 64-Zeichen Hex-String>

Passwort-Verifikation mit gespeichertem PBKDF2-Hash

<?php
function pbkdf2Hash(string $password, int $iterations = 100000): string
{
    $salt = random_bytes(16);
    $key  = openssl_pbkdf2($password, $salt, 32, $iterations, 'sha256');

    if ($key === false) {
        throw new RuntimeException('Hashing fehlgeschlagen.');
    }

    // Speichert Algorithmus, Iterationen, Salt und Hash gemeinsam
    return implode('$', [
        'sha256',
        $iterations,
        base64_encode($salt),
        base64_encode($key),
    ]);
}

function pbkdf2Verify(string $password, string $storedHash): bool
{
    [$algo, $iterations, $saltB64, $keyB64] = explode('$', $storedHash);
    $salt = base64_decode($saltB64);
    $key  = openssl_pbkdf2($password, $salt, 32, (int)$iterations, $algo);

    if ($key === false) {
        return false;
    }

    // Timing-sicherer Vergleich
    return hash_equals(base64_decode($keyB64), $key);
}

$stored = pbkdf2Hash('geheim123');
echo 'Gespeicherter Hash: ' . $stored . PHP_EOL;
echo 'Verifizierung korrekt: ' . (pbkdf2Verify('geheim123', $stored) ? 'ja' : 'nein') . PHP_EOL;
echo 'Verifizierung falsch:  ' . (pbkdf2Verify('falsch',    $stored) ? 'ja' : 'nein') . PHP_EOL;

Gespeicherter Hash: sha256$100000$<Base64-Salt>$<Base64-Key> Verifizierung korrekt: ja Verifizierung falsch: nein

// Wichtig · Fallstricke

Sicherheitshinweise:

Standard-Algorithmus sha1 ist veraltet – immer explizit mindestens sha256 angeben.
Iterationszahl: Zu niedrige Werte machen die Ableitung anfällig für Brute-Force. NIST SP 800-132 empfiehlt für SHA-256 mindestens 600.000 Iterationen (2023). Der Wert sollte regelmäßig angepasst werden.
Salt: Niemals einen statischen oder vorhersehbaren Salt verwenden. Immer random_bytes() nutzen, nie mt_rand() oder ähnliche nicht-kryptografische Funktionen.
Timing-sicherer Vergleich: Bei der Verifikation stets hash_equals() verwenden, um Timing-Angriffe zu verhindern.
Passwort-Hashing vs. Schlüsselableitung: Für die reine Passwortspeicherung ist password_hash() mit PASSWORD_BCRYPT oder PASSWORD_ARGON2ID die bevorzugte Wahl, da Argon2 speicherintensiv ist und dadurch GPU-Angriffe zusätzlich erschwert.

Siehe auch

password_hash password_verify hash_pbkdf2 openssl_random_pseudo_bytes random_bytes hash_equals openssl_get_md_methods