Die PHP-Funktion hash() erzeugt kryptografische Hashwerte aus beliebigen Strings und unterstützt dabei eine Vielzahl von Algorithmen. Ob SHA-256, SHA-512 oder SHA-3: Mit einem einzigen Funktionsaufruf lässt sich eine Prüfsumme berechnen, die zur Datenintegrität, Signaturprüfung oder Dateiverifizierung dient. Dieses Tutorial erklärt die Syntax von hash(), zeigt Praxisbeispiele mit verschiedenen Algorithmen und behandelt verwandte Funktionen wie hash_file(), hash_hmac() und hash_equals(). Außerdem wird klar abgegrenzt, warum hash() nicht für Passwörter geeignet ist und wann stattdessen password_hash() zum Einsatz kommen sollte.
Zum Einstieg wird die Syntax der Funktion erklärt und gezeigt, wie sich mit wenigen Zeilen Code ein Hashwert erzeugen lässt.
Was macht hash()?
Die Funktion hash() berechnet den Hashwert eines Strings mit einem frei wählbaren Algorithmus. Sie gibt standardmäßig einen hexadezimalen String zurück.
<?php
hash(string $algo, string $data, bool $binary = false, array $options = []): string
Der erste Parameter $algo legt den Algorithmus fest, beispielsweise 'sha256' oder 'sha512'. Der zweite Parameter $data ist der String, aus dem der Hashwert berechnet wird. Der optionale dritte Parameter $binary steuert das Ausgabeformat: Bei false (Standard) wird der Hash als hexadezimaler String zurückgegeben, bei true als Rohbytes. Die Rohbyte-Ausgabe ist beispielsweise nützlich, wenn der Hash anschließend Base64-kodiert oder in einer binären Datei gespeichert werden soll.
<?php
$text = 'Hallo Welt';
/* Hexadezimaler Hashwert (Standard) */
$hex = hash('sha256', $text);
echo $hex;
/* 2d2da19e12b221d4bbc2aaf61f3c595e7208cad0bcc29e72c2f3edfa14710d58 */
/* Rohbytes mit Base64-Kodierung */
$raw = hash('sha256', $text, true);
echo base64_encode($raw);
/* LS2hnhKyIdS7wqr2HzxZXnIIytC8wp5ywvPt+hRxDVg= */
Der hexadezimale String besteht ausschließlich aus den Zeichen 0-9 und a-f. Seine Länge hängt vom gewählten Algorithmus ab: SHA-256 erzeugt immer 64 Zeichen, SHA-512 immer 128 Zeichen.
Verfügbare Algorithmen
PHP stellt über die Funktion hash_algos() eine vollständige Liste aller verfügbaren Hash-Algorithmen bereit. Welche Algorithmen zur Verfügung stehen, hängt von der PHP-Version und der Systemkonfiguration ab.
<?php
/* Alle verfügbaren Algorithmen auflisten */
$algorithmen = hash_algos();
echo 'Anzahl: ' . count($algorithmen) . "\n";
/* Ausgabe (Auszug): md5, sha1, sha256, sha512, sha3-256, sha3-512 ... */
foreach ($algorithmen as $algo) {
echo $algo . "\n";
}
Zu den wichtigsten Algorithmen gehören MD5 (128 Bit, unsicher), SHA-1 (160 Bit, veraltet), SHA-256 (256 Bit, empfohlen), SHA-512 (512 Bit, empfohlen) und SHA-3 (verschiedene Längen, neuester Standard). Für sicherheitskritische Anwendungen sollten ausschließlich SHA-256, SHA-512 oder SHA-3 verwendet werden. MD5 und SHA-1 gelten als unsicher, da für beide Algorithmen Kollisionsangriffe bekannt sind.
Praxisbeispiele mit verschiedenen Algorithmen
Die folgenden Beispiele zeigen die Funktion hash() im Einsatz mit den drei wichtigsten Algorithmus-Familien. Jeder Algorithmus erzeugt einen Hashwert mit unterschiedlicher Länge und Sicherheitsstufe.
SHA-256
SHA-256 gehört zur SHA-2-Familie und erzeugt einen 256 Bit langen Hashwert. Er ist der am häufigsten verwendete Algorithmus für Prüfsummen und digitale Signaturen.
<?php
$nachricht = 'Dieses Dokument ist vertraulich.';
$hashwert = hash('sha256', $nachricht);
echo $hashwert . "\n";
/* 64 Zeichen langer hexadezimaler String */
echo 'Länge: ' . strlen($hashwert) . " Zeichen\n";
/* Länge: 64 Zeichen */
/* Kleinste Änderung erzeugt völlig anderen Hash */
$hashwert2 = hash('sha256', 'Dieses Dokument ist vertraulich');
echo ($hashwert === $hashwert2) ? 'Identisch' : 'Unterschiedlich';
/* Unterschiedlich (Punkt fehlt) */
Bereits das Entfernen eines einzelnen Zeichens führt zu einem komplett anderen Hashwert. Diese Eigenschaft wird als Lawineneffekt bezeichnet und ist ein zentrales Merkmal kryptografischer Hashfunktionen.
SHA-512
SHA-512 gehört ebenfalls zur SHA-2-Familie und erzeugt einen 512 Bit langen Hashwert. Er bietet eine höhere Sicherheitsmarge als SHA-256 und ist auf 64-Bit-Systemen oft sogar schneller.
<?php
$daten = 'Transaktionsdaten: Betrag 150.00 EUR';
$hash512 = hash('sha512', $daten);
echo $hash512 . "\n";
/* 128 Zeichen langer hexadezimaler String */
echo 'Länge: ' . strlen($hash512) . " Zeichen\n";
/* Länge: 128 Zeichen */
SHA-512 eignet sich besonders für Szenarien, in denen maximale Sicherheit gefordert ist. Die doppelte Hash-Länge gegenüber SHA-256 erhöht den Schutz vor Brute-Force-Angriffen erheblich.
SHA-3
SHA-3 ist der neueste Standard des NIST und basiert auf einem völlig anderen Algorithmus (Keccak) als SHA-2. PHP unterstützt SHA-3 in den Varianten sha3-224, sha3-256, sha3-384 und sha3-512.
<?php
$eingabe = 'SHA-3 Testeingabe';
$sha3_256 = hash('sha3-256', $eingabe);
$sha3_512 = hash('sha3-512', $eingabe);
echo 'SHA3-256: ' . $sha3_256 . "\n";
echo 'SHA3-512: ' . $sha3_512 . "\n";
echo 'SHA3-256 Länge: ' . strlen($sha3_256) . " Zeichen\n";
/* SHA3-256 Länge: 64 Zeichen */
echo 'SHA3-512 Länge: ' . strlen($sha3_512) . " Zeichen\n";
/* SHA3-512 Länge: 128 Zeichen */
SHA-3 gilt als zukunftssicher und bietet eine Alternative für den Fall, dass jemals Schwachstellen in der SHA-2-Familie entdeckt werden sollten.
hash_file(): Dateien hashen
Die Funktion hash_file() berechnet den Hashwert direkt aus einer Datei, ohne dass deren Inhalt zuvor in den Speicher geladen werden muss. Das ist besonders bei großen Dateien deutlich effizienter als ein manuelles Einlesen mit file_get_contents().
<?php
/* Prüfsumme einer Datei berechnen */
$hash = hash_file('sha256', '/pfad/zur/datei.zip');
if ($hash === false) {
echo "Datei konnte nicht gelesen werden.\n";
} else {
echo 'SHA-256: ' . $hash . "\n";
}
/* Download-Verifizierung */
$erwartet = 'a3f2b8c9d1e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0';
$berechnet = hash_file('sha256', 'download.tar.gz');
if (hash_equals($erwartet, $berechnet)) {
echo "Datei ist integer und unverändert.\n";
} else {
echo "Warnung: Datei wurde manipuliert!\n";
}
Beim Vergleich zweier Hashwerte sollte immer die Funktion hash_equals() statt des normalen Vergleichsoperators === verwendet werden. hash_equals() führt einen timing-sicheren Vergleich durch, der gegen sogenannte Timing-Angriffe geschützt ist. Bei einem normalen String-Vergleich könnte ein Angreifer anhand der Vergleichsdauer Rückschlüsse auf den erwarteten Hashwert ziehen.
hash_hmac(): HMAC-basierte Hashes
Die Funktion hash_hmac() erzeugt einen HMAC (Hash-based Message Authentication Code). Dabei wird der Hash mit einem geheimen Schlüssel kombiniert, sodass nur Parteien mit Kenntnis dieses Schlüssels den Hash reproduzieren können.
<?php
$payload = '{"benutzer_id":42,"aktion":"bestellen"}';
$schluessel = 'mein_geheimer_api_schluessel';
/* HMAC-Signatur erzeugen */
$signatur = hash_hmac('sha256', $payload, $schluessel);
echo 'Signatur: ' . $signatur . "\n";
/* Signatur auf Empfängerseite prüfen */
$empfangene_signatur = $signatur;
$erwartete_signatur = hash_hmac('sha256', $payload, $schluessel);
if (hash_equals($erwartete_signatur, $empfangene_signatur)) {
echo "Signatur gültig. Nachricht ist authentisch.\n";
} else {
echo "Signatur ungültig. Nachricht wurde manipuliert.\n";
}
HMAC-basierte Hashes werden häufig für API-Signaturen, Webhook-Verifizierungen und Token-Validierungen eingesetzt. Der Schlüssel sollte dabei niemals im Quellcode stehen, sondern über Umgebungsvariablen oder eine sichere Konfigurationsdatei geladen werden.
hash() vs. password_hash()
Ein häufiger Fehler ist der Einsatz von hash() zum Speichern von Passwörtern. Die Funktion hash() ist dafür nicht geeignet, da sie zu schnell arbeitet. Ein Angreifer kann mit moderner Hardware Milliarden von SHA-256-Hashes pro Sekunde berechnen und Passwörter per Brute-Force knacken.
Das folgende Diagramm zeigt die Unterschiede zwischen hash() und password_hash() auf einen Blick.
flowchart LR
A["Eingabe"] --> B{"Zweck?"}
B -->|"Prüfsumme / Signatur"| C["hash()"]
B -->|"Passwort speichern"| D["password_hash()"]
C --> E["SHA-256 / SHA-512\nSchnell, kein Salt"]
D --> F["Bcrypt / Argon2\nLangsam, automatischer Salt"]
Die Funktion password_hash() verwendet bewusst langsame Algorithmen wie Bcrypt oder Argon2. Sie fügt automatisch einen zufälligen Salt hinzu und erzeugt bei jedem Aufruf einen anderen Hash für dasselbe Passwort. Für die Passwort-Prüfung beim Login steht password_verify() bereit. Wer Passwörter absichern will, sollte ausschließlich password_hash() und password_verify() verwenden.
hash() vs. md5() und sha1()
PHP bietet neben hash() auch die Funktionen md5() und sha1() als eigenständige Funktionen an. Beide erzeugen Hashwerte mit einem festen Algorithmus. Die Funktion hash() ist jedoch flexibler, da der Algorithmus frei gewählt werden kann. Der Aufruf hash('md5', $text) liefert das gleiche Ergebnis wie md5($text), bietet aber den Vorteil, dass der Algorithmus später ohne Änderung der Programmstruktur ausgetauscht werden kann. Da MD5 und SHA-1 als kryptografisch unsicher gelten, sollte für neue Projekte grundsätzlich hash() mit SHA-256 oder höher verwendet werden. Die Funktionen md5() und sha1() bleiben für Legacy-Code und nicht-sicherheitskritische Zwecke wie Cache-Keys oder einfache Deduplizierung weiterhin nutzbar.
Algorithmen-Benchmark
Die Wahl des Algorithmus hat direkten Einfluss auf die Ausführungszeit. Mit der Funktion microtime() lässt sich ein einfacher Benchmark erstellen, der die Geschwindigkeit verschiedener Algorithmen vergleicht.
<?php
$testdaten = str_repeat('A', 1000000); /* 1 MB Testdaten */
$algorithmen = ['md5', 'sha1', 'sha256', 'sha512', 'sha3-256', 'sha3-512'];
foreach ($algorithmen as $algo) {
$start = microtime(true);
for ($i = 0; $i < 100; $i++) {
hash($algo, $testdaten);
}
$dauer = (microtime(true) - $start) * 1000;
echo sprintf("%-10s: %6.2f ms\n", $algo, $dauer);
}
/*
Typische Ausgabe (variiert je nach System):
md5 : 25.41 ms
sha1 : 22.38 ms
sha256 : 35.67 ms
sha512 : 24.12 ms
sha3-256 : 48.93 ms
sha3-512 : 82.15 ms
*/
SHA-512 ist auf 64-Bit-Systemen oft schneller als SHA-256, da der Algorithmus nativ mit 64-Bit-Operationen arbeitet. SHA-3 ist in der Regel langsamer als SHA-2, da die PHP-Implementierung weniger optimiert ist. Für die meisten Anwendungsfälle ist SHA-256 ein guter Kompromiss aus Sicherheit und Geschwindigkeit.
Fazit
Die Funktion hash() ist das zentrale Werkzeug in PHP für die Erzeugung kryptografischer Hashwerte. Mit hash_algos() lassen sich alle verfügbaren Algorithmen auflisten, wobei SHA-256 und SHA-512 für sicherheitskritische Anwendungen empfohlen werden. Die Funktion hash_file() berechnet Prüfsummen effizient direkt aus Dateien, während hash_hmac() HMAC-basierte Signaturen mit einem geheimen Schlüssel erzeugt. Für den Vergleich zweier Hashwerte sollte immer hash_equals() statt des normalen Vergleichsoperators eingesetzt werden. Für die Speicherung von Passwörtern ist hash() nicht geeignet, hier kommt ausschließlich password_hash() mit Bcrypt oder Argon2 zum Einsatz. MD5 und SHA-1 sind für sicherheitsrelevante Zwecke veraltet und sollten nur noch für Legacy-Kompatibilität oder nicht-kritische Aufgaben verwendet werden.
