Was ist eine kryptografische Hash-Funktion?

Eine kryptografische Hash-Funktion ist ein mathematischer Algorithmus, der eine Eingabe beliebiger Länge in eine Ausgabe fester Länge — den Hash-Wert oder Digest — umwandelt. Der Prozess ist deterministisch (gleiche Eingabe → gleicher Hash) und praktisch irreversibel. Wichtige Eigenschaften sind der Lawineneffekt (kleinste Änderung → komplett anderer Hash), Kollisionsresistenz (zwei verschiedene Eingaben sollten nicht denselben Hash erzeugen) und Präimage-Resistenz (aus dem Hash kann die Eingabe nicht rekonstruiert werden).

MD5 — der alte Standard (128 Bit)

Message Digest Algorithm 5 (MD5) wurde 1992 von Ronald Rivest entwickelt und erzeugt einen 128-Bit-Hash (32 hexadezimale Zeichen). MD5 ist kryptografisch gebrochen: Es sind praktische Kollisionsangriffe bekannt. MD5 sollte niemals für sicherheitskritische Anwendungen wie Passwort-Speicherung oder digitale Signaturen verwendet werden.

Noch akzeptable Verwendung: Nicht-sicherheitskritische Prüfsummen, Duplikaterkennung in Dateisystemen, interne Checksums in unkritischen Umgebungen.

SHA-1 — deprecated seit 2017 (160 Bit)

Secure Hash Algorithm 1 (SHA-1) erzeugt einen 160-Bit-Hash (40 Hex-Zeichen). Im Jahr 2017 demonstrierte Google mit dem SHAttered-Angriff die erste praktische SHA-1-Kollision. SHA-1 ist für Signaturen und Zertifikate verboten, wird aber noch in Git für Commit-Hashes und in Altsystemen verwendet.

SHA-2 Familie — der aktuelle Standard (224–512 Bit)

Die SHA-2-Familie (entwickelt von der NSA, veröffentlicht 2001) umfasst SHA-224, SHA-256, SHA-384 und SHA-512. Alle gelten derzeit als kryptografisch sicher. SHA-256 ist der Industriestandard für die meisten Anwendungen.

• SHA-256 (256 Bit / 64 Zeichen): Bitcoin, TLS 1.3, AWS-Signaturen, JWT, Code-Signing
• SHA-384 (384 Bit / 96 Zeichen): Hochsicherheits-Zertifikate, NSA Suite B
• SHA-512 (512 Bit / 128 Zeichen): Maximale Sicherheitsstufe, 64-Bit-Systeme (schneller als SHA-256 auf 64-Bit-CPUs)

SHA-3 — der Keccak-Standard (2015)

SHA-3 basiert auf dem Keccak-Algorithmus und verwendet eine völlig andere interne Struktur als SHA-2 (Schwamm-Konstruktion statt Merkle-Damgård). SHA-3 ist damit immun gegen Angriffe, die SHA-2 theoretisch betreffen könnten. Es wird zunehmend in Ethereum, Post-Quantum-Kryptografie-Forschung und modernen Protokollen eingesetzt.

BLAKE2 — schnell und sicher (2012)

BLAKE2 ist schneller als MD5 und dabei sicherer als SHA-3. Es wird in libsodium, Argon2 (Password-Hashing), WireGuard, und vielen Performance-kritischen Systemen eingesetzt. BLAKE2b (für 64-Bit) und BLAKE2s (für 32-Bit/IoT) sind die zwei Hauptvarianten.

CRC32 — kein kryptografischer Hash

CRC32 (Cyclic Redundancy Check) ist technisch gesehen kein kryptografischer Hash, sondern eine Fehlererkennungsprüfsumme. Sie wird in ZIP-Dateien, Ethernet-Frames und PNG-Dateien verwendet. CRC32 bietet keine Sicherheitsgarantien und ist leicht kollidierbar — verwenden Sie es ausschließlich für Fehlerprüfung, nie für Sicherheitszwecke.

RIPEMD-160 — Bitcoin und PGP (160 Bit)

RIPEMD-160 wurde 1996 als Alternative zu MD5/SHA-1 entwickelt und erzeugt einen 160-Bit-Hash. Seine bekannteste Anwendung ist die Berechnung von Bitcoin-Adressen (SHA-256 → RIPEMD-160) und in PGP-Systemen. Für neue Anwendungen wird SHA-256 oder stärker empfohlen.

📥 Beispiel 1: Datei-Download mit SHA-256 verifizieren

Wenn Sie eine Software herunterladen, stellt der Anbieter oft einen SHA-256-Hash bereit. So prüfen Sie die Integrität:

🔐 Beispiel 2: Passwort sicher hashen (mit Salt)

So sollte Passwort-Hashing in einer Anwendung aussehen:

// Node.js Beispiel — sicheres Passwort-Hashing mit Salt
const crypto = require('crypto');

function hashPassword(password) {
  // 1. Zufälligen Salt generieren (32 Bytes = 256 Bit)
  const salt = crypto.randomBytes(32).toString('hex');
  
  // 2. Passwort + Salt zusammen hashen
  const hash = crypto.createHash('sha256')
    .update(password + salt)
    .digest('hex');
  
  // 3. Hash + Salt in Datenbank speichern
  return { hash, salt };
}

function verifyPassword(password, storedHash, storedSalt) {
  const hash = crypto.createHash('sha256')
    .update(password + storedSalt)
    .digest('hex');
  return hash === storedHash; // Timing-sichere Prüfung in Produktion: crypto.timingSafeEqual
}

// Empfehlung für Produktion: bcrypt oder Argon2 statt SHA-256!

🌐 Beispiel 3: API-Anfrage mit HMAC-SHA256 signieren

// JavaScript — API-Request mit HMAC-SHA256 signieren
const crypto = require('crypto');

function signRequest(apiSecret, payload) {
  return crypto.createHmac('sha256', apiSecret)
    .update(JSON.stringify(payload))
    .digest('hex');
}

const payload = { userId: 123, action: 'transfer', amount: 100 };
const signature = signRequest('mein-geheimes-api-secret', payload);

// In der HTTP-Anfrage mitschicken:
// X-Signature: sha256=

⛓️ Beispiel 4: Git Commit Hash verstehen

Jeder Git-Commit hat einen SHA-1-Hash als eindeutige Identifikation. Git berechnet den Hash aus Inhalt, Autor, Zeitstempel und Parent-Commit. Selbst minimale Änderungen erzeugen völlig andere Hashes — das macht Git-Commits fälschungssicher.

# Git Commit Hash berechnen (wie Git es intern macht)
git cat-file commit HEAD | sha1sum

# Hash eines beliebigen Texts berechnen (wie Git es macht)
echo -n "blob 13\0Hello, World!" | sha1sum

⛏️ Beispiel 5: Blockchain Proof-of-Work verstehen

Bitcoin's Proof-of-Work sucht nach einem SHA-256-Hash, der mit einer bestimmten Anzahl von Nullen beginnt. Miner ändern dafür den Nonce-Wert, bis ein passender Hash gefunden wird — das ist rechenintensiv aber leicht verifizierbar.

// Simplified Proof-of-Work (educational only)
const crypto = require('crypto');

function mineBlock(data, difficulty) {
  let nonce = 0;
  while (true) {
    const input = data + nonce;
    const hash = crypto.createHash('sha256').update(input).digest('hex');
    if (hash.startsWith('0'.repeat(difficulty))) {
      return { nonce, hash };
    }
    nonce++;
  }
}

// Bei difficulty=4 muss der Hash mit "0000" beginnen
const result = mineBlock("Block-Daten", 4);

Rainbow-Table-Angriffe

Eine Rainbow Table ist eine vorberechnete Tabelle von Hash-Werten für häufige Passwörter und Zeichenkombinationen. Wenn ein Angreifer Zugriff auf eine Datenbank mit ungesalzenen MD5- oder SHA-1-Passwort-Hashes erhält, kann er diese in Sekundenschnelle mit Rainbow Tables knacken.

Schutzmaßnahme: Immer einen zufälligen Salt pro Benutzer verwenden. Dadurch werden Rainbow-Table-Angriffe wirkungslos, da für jeden Salt eine eigene Rainbow Table benötigt würde.

Hash-Kollisionen

Eine Kollision tritt auf, wenn zwei verschiedene Eingaben denselben Hash erzeugen. Theoretisch sind Kollisionen bei begrenzter Hash-Länge unvermeidlich (Geburtstagsparadoxon), aber bei sicheren Algorithmen wie SHA-256 praktisch unmöglich.

• MD5-Kollisionen: Praktisch durchführbar in Minuten
• SHA-1-Kollisionen: Demonstriert 2017 (SHAttered-Angriff)
• SHA-256-Kollisionen: Aktuell rechnerisch unmöglich (würde Jahrmillionen dauern)

Passwort-Hashing: SHA-256 ist nicht genug

SHA-256 ist sehr schnell — das ist für Passwörter ein Nachteil! Schnelle Hash-Funktionen erlauben Angreifern, Milliarden Kombinationen pro Sekunde zu testen. Für Passwörter sollten dedizierte langsame Algorithmen verwendet werden:

• bcrypt: Industriestandard, konfigurierbarer Kostenfaktor, weit unterstützt
• Argon2id: Gewinner des Password Hashing Competition (2015), empfohlen für neue Systeme
• PBKDF2: FIPS-zertifiziert, gut für Compliance-Umgebungen
• scrypt: Speicherintensiv, erschwert Hardware-Angriffe

Timing-Angriffe beim Hash-Vergleich

Beim Vergleich von Hash-Werten sollten Sie niemals einfache String-Vergleiche verwenden (== oder ===). Diese vergleichen zeichenweise und brechen bei der ersten Abweichung ab — die Laufzeit verrät damit Informationen über die ersten Zeichen des Hashes. Nutzen Sie stattdessen zeitkonstante Vergleichsfunktionen:

// Node.js — sicherer Timing-fester Hash-Vergleich
const crypto = require('crypto');

function safeCompare(a, b) {
  const hashA = crypto.createHash('sha256').update(a).digest();
  const hashB = crypto.createHash('sha256').update(b).digest();
  return crypto.timingSafeEqual(hashA, hashB);
}

Häufige Fehler beim Hashing

Hashing in APIs und Web-Services

APIs nutzen Hash-Funktionen für Anfrage-Signaturen (HMAC), Content-Hashing (ETag-Header) und API-Schlüssel-Verifizierung. AWS, Stripe, GitHub und praktisch jede moderne API verwenden HMAC-SHA256 für Webhook-Validierung.

// Webhook-Signatur von GitHub validieren
const crypto = require('crypto');

function validateGitHubWebhook(payload, signature, secret) {
  const hmac = crypto.createHmac('sha256', secret);
  const digest = 'sha256=' + hmac.update(payload).digest('hex');
  return crypto.timingSafeEqual(Buffer.from(digest), Buffer.from(signature));
}

Hashing in Datenbanken

Datenbanken nutzen Hashing für Hash-Indizes (O(1)-Lookup), Partitionierung (Konsistentes Hashing in verteilten Systemen) und Duplikaterkennung. PostgreSQL hat native SHA-256-Unterstützung:

-- SHA-256 Hash in PostgreSQL
SELECT encode(sha256('mein text'::bytea), 'hex');

-- Passwörter sicher mit pgcrypto speichern
SELECT crypt('mein_passwort', gen_salt('bf', 12)); -- bcrypt

Hashing in Versionskontrolle (Git)

Git ist ein inhaltsadressiertes Dateisystem — jedes Objekt (Blob, Tree, Commit, Tag) wird durch seinen SHA-1-Hash identifiziert. Git migriert derzeit auf SHA-256 für verbesserte Sicherheit (git init --object-format=sha256).

Hashing in Cloud-Systemen

Cloud-Dienste wie AWS S3 verwenden Content-MD5-Header zur Integritätsprüfung. Azure Blob Storage nutzt MD5-Checksums. Bei der Übertragung großer Dateien in die Cloud ist die Hash-Verifikation ein essentieller Integritätscheck.

Content-Addressable Storage (CAS)

Systeme wie IPFS (InterPlanetary File System), Docker Image Layers und Git nutzen Hashes als Datei-Adressen. Der Inhalt ist die Adresse — das ermöglicht automatische Deduplizierung und Integritätsprüfung ohne zentrales Verzeichnis.