SHA-256 Hash Generator

Was ist SHA-256-Hashing?

SHA-256 (Secure Hash Algorithm 256-bit) ist eine kryptografische Hashfunktion aus der SHA-2-Familie, die 2001 vom NIST als Teil von FIPS 180-2 (aktualisiert in FIPS 180-4) veröffentlicht wurde. Für jede Eingabe — ein einzelnes Zeichen, eine mehrere Gigabyte große Datei oder eine leere Zeichenkette — erzeugt SHA-256 einen festen 256-Bit-Digest (32 Byte), der üblicherweise als 64 hexadezimale Zeichen dargestellt wird. SHA-256 ist die am weitesten verbreitete Hashfunktion in Produktivsystemen und bildet die Grundlage für TLS-Zertifikatsketten, Bitcoins Proof-of-Work, Subresource Integrity (SRI) und Code-Signing-Workflows.

SHA-256 ist eine Einwegfunktion: Die Berechnung eines Hashes aus einer Eingabe ist schnell (Hunderte von Megabytes pro Sekunde auf moderner Hardware), aber der umgekehrte Weg — eine Eingabe zu finden, die einen bestimmten Hash erzeugt — ist rechnerisch nicht durchführbar. Diese Eigenschaft, Urbildresistenz genannt, macht SHA-256 geeignet für Passwort-Hashing (in Kombination mit einem Salt und Key-Stretching), digitale Signaturen und die Überprüfung der Datenintegrität. Im Gegensatz zu MD5 und SHA-1 wurde bislang weder ein Kollisions- noch ein Urbildangriff gegen vollständiges SHA-256 nachgewiesen.

Die SHA-2-Familie umfasst sechs Varianten: SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224 und SHA-512/256. SHA-256 arbeitet mit 32-Bit-Wörtern und 64 Runden pro Block, optimiert für 32-Bit-Prozessoren. SHA-512 verwendet 64-Bit-Wörter und 80 Runden, was auf 64-Bit-Plattformen schneller sein kann. Für die meisten Anwendungen, bei denen ein 256-Bit-Digest ausreicht, bleibt SHA-256 die Standardempfehlung von NIST, IETF und dem CA/Browser Forum.

Wozu ein Online-SHA-256-Generator?

Die Berechnung eines SHA-256-Hashes erfordert normalerweise einen Terminalbefehl oder einige Zeilen Code. Dieses browserbasierte Werkzeug ermöglicht die Berechnung von SHA-256-Digests ohne Installation, Kontextwechsel oder das Schreiben eines Skripts.

SHA-256 Anwendungsfälle

SHA-2-Familienvarianten im Vergleich

SHA-256 gehört zur SHA-2-Familie, die in FIPS 180-4 definiert ist. Jede Variante unterscheidet sich in Digest-Größe, Performance-Eigenschaften und Sicherheitsmarge. Die folgende Tabelle vergleicht alle SHA-2-Varianten, denen man wahrscheinlich begegnet.

SHA-256 vs. SHA-1 vs. MD5 vs. SHA-3

Die Wahl des richtigen Hash-Algorithmus hängt von den Sicherheitsanforderungen und Kompatibilitätsbeschränkungen ab. SHA-256 ist der praktische Kompromiss: sicher, universell unterstützt (einschließlich der Web Crypto API) und für die meisten Workloads schnell genug. Die folgende Vergleichstabelle deckt die Eigenschaften ab, die bei der Auswahl einer Hashfunktion am wichtigsten sind.

Wie SHA-256 intern funktioniert

SHA-256 verarbeitet Eingaben in 512-Bit-Blöcken (64 Byte) durch eine Merkle-Damgård-Konstruktion. Der Algorithmus initialisiert acht 32-Bit-Zustandswörter (H0–H7), die aus den Nachkommastellen der Quadratwurzeln der ersten acht Primzahlen abgeleitet werden. Jeder Block durchläuft 64 Misch-Runden mit bitweisen Operationen (AND, XOR, NOT, Rechtsrotation, Rechtsverschiebung) und 64 Rundenkonstanten, die aus den Kubikwurzeln der ersten 64 Primzahlen stammen.

Der Lawineneffekt stellt sicher, dass das Kippen eines einzelnen Eingabebits etwa 50 % der Ausgabebits verändert. Diese Eigenschaft in Kombination mit einer Kollisionsresistenz von 2^128 ist der Grund, warum SHA-256 im Jahr 2026 die Baseline-Empfehlung für sicherheitskritische Anwendungen bleibt.

SHA-256 Code-Beispiele

SHA-256 ist in jeder gängigen Sprache und Laufzeitumgebung nativ verfügbar. Die Web Crypto API stellt es in Browsern ohne zusätzliche Bibliothek bereit. Die folgenden Beispiele zeigen praxisnahe Verwendungsmuster einschließlich Unicode-Eingabebehandlung und Datei-Hashing.

// Works in all modern browsers and Node.js 18+
async function sha256(text) {
  const data = new TextEncoder().encode(text)
  const hashBuffer = await crypto.subtle.digest('SHA-256', data)
  const hashArray = Array.from(new Uint8Array(hashBuffer))
  return hashArray.map(b => b.toString(16).padStart(2, '0')).join('')
}

await sha256('hello world')
// → "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"

// Node.js (built-in crypto module)
const crypto = require('crypto')
crypto.createHash('sha256').update('hello world').digest('hex')
// → "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"

import hashlib

# Basic SHA-256 hash
result = hashlib.sha256(b'hello world').hexdigest()
print(result)  # → "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"

# Hash a string (encode to bytes first)
text = 'café ☕'
hashlib.sha256(text.encode('utf-8')).hexdigest()
# → "3eb53e00aa1bb4b1e8aab1ab38e56e6b8fb0b20e1cf7e1d19f36e4fad2537445"

# Hash a file in chunks (memory-efficient)
with open('release.tar.gz', 'rb') as f:
    sha = hashlib.sha256()
    for chunk in iter(lambda: f.read(8192), b''):
        sha.update(chunk)
    print(sha.hexdigest())

package main

import (
    "crypto/sha256"
    "fmt"
)

func main() {
    data := []byte("hello world")
    hash := sha256.Sum256(data)
    fmt.Printf("%x\n", hash)
    // → b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9
}

# Using sha256sum (Linux) or shasum (macOS)
echo -n "hello world" | sha256sum
# → b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9  -

# macOS
echo -n "hello world" | shasum -a 256
# → b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9  -

# Verify a file checksum
echo "b94d27b...  myfile.bin" | sha256sum -c
# → myfile.bin: OK

# Using openssl (cross-platform)
echo -n "hello world" | openssl dgst -sha256
# → SHA2-256(stdin)= b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9

Häufig gestellte Fragen