SHA-1 Hash Generator

Was ist SHA-1-Hashing?

SHA-1 (Secure Hash Algorithm 1) ist eine kryptografische Hash-Funktion, die aus beliebigen Eingaben einen festen 160-Bit-(20-Byte-)Digest erzeugt. Von der NSA entwickelt und 1995 durch das NIST als FIPS PUB 180-1 standardisiert sowie später in RFC 3174 dokumentiert, wurde SHA-1 als stärkerer Nachfolger von SHA-0 und MD5 konzipiert. Der Algorithmus verarbeitet Eingaben in 512-Bit-Blöcken durch 80 Runden bitweiser Operationen und erzeugt dabei einen 40-stelligen hexadezimalen Fingerabdruck, der über ein Jahrzehnt lang die Grundlage von SSL/TLS, PGP, SSH und IPsec bildete.

Wie alle kryptografischen Hash-Funktionen ist SHA-1 eine Einwegumwandlung: Aus einer Eingabe lässt sich der Hash schnell berechnen, aber aus dem Hash allein kann die ursprüngliche Eingabe nicht wiederhergestellt werden. Selbst eine einzelne Bit-Änderung in der Eingabe erzeugt einen völlig anderen 160-Bit-Digest — eine Eigenschaft, die als Lawineneffekt bezeichnet wird. SHA-1 bildet einen beliebig großen Eingaberaum auf einen festen 160-Bit-Ausgaberaum ab, weshalb Kollisionen (zwei verschiedene Eingaben mit demselben Hash) mathematisch garantiert existieren. Die Sicherheitsaussage einer Hash-Funktion lautet, dass das Auffinden solcher Kollisionen ungefähr 2^80 Operationen erfordern sollte — die Hälfte der Ausgabe-Bitlänge.

Im Jahr 2017 veröffentlichten Google und CWI Amsterdam den SHAttered-Angriff und demonstrierten damit die erste praktische SHA-1-Kollision, indem zwei verschiedene PDF-Dateien mit demselben Digest erzeugt wurden. Der Angriff erforderte ungefähr 2^63,1 SHA-1-Berechnungen — weit unter dem theoretischen Grenzwert von 2^80. Im Jahr 2020 senkten Gaetan Leurent und Thomas Peyrin die Kosten mit einem Chosen-Prefix-Kollisionsangriff weiter, der etwa 2^63,4 Operationen benötigte. Infolgedessen haben alle großen Browser, Zertifizierungsstellen und Normungsgremien SHA-1 für digitale Signaturen und TLS-Zertifikate als veraltet eingestuft. Für nicht sicherheitskritische Zwecke bleibt SHA-1 jedoch weiterhin aktiv im Einsatz: Git-Objekt-IDs (obwohl Git zu SHA-256 migriert), ältere HMAC-Konstruktionen und Dateiintegritätsprüfsummen, bei denen keine adversarielle Kollisionsresistenz erforderlich ist.

Warum diesen SHA-1-Generator verwenden?

SHA-1-Hashes sofort generieren — ohne Installation oder Code schreiben. Text einfügen und den 40-stelligen Hex-Digest in Echtzeit erhalten — nützlich zur Überprüfung älterer Prüfsummen, zum Debuggen von Git-Interna oder zum Testen Hash-basierter Workflows.

SHA-1-Anwendungsfälle

SHA-1 vs. andere Hash-Algorithmen

SHA-1 erzeugt einen 160-Bit-Digest — länger als MD5 (128 Bit), aber deutlich kürzer als die Algorithmen der SHA-2-Familie. Die folgende Tabelle vergleicht Digest-Größen, Standards und geeignete Anwendungsfälle der einzelnen Algorithmen.

Wie SHA-1 funktioniert

SHA-1 folgt der Merkle-Damgård-Konstruktion: Die Nachricht wird aufgefüllt, in 512-Bit-Blöcke aufgeteilt, und jeder Block wird durch 80 Runden bitweiser Operationen verarbeitet, die die Eingabe mit einem aus dem Block abgeleiteten Message Schedule mischen. Fünf 32-Bit-Zustandswörter (H0 bis H4) tragen den laufenden Hash-Zustand, und die abschließende Verkettung dieser Wörter ergibt den 160-Bit-Digest.

Der wesentliche Unterschied zwischen SHA-1 und MD5 liegt in der Anzahl der Zustandswörter (5 vs. 4), der Anzahl der Runden pro Block (80 vs. 64) und der Verwendung eines Message Schedules mit Left-Rotate-Feedback. Diese Unterschiede geben SHA-1 eine größere Ausgabe (160 vs. 128 Bit) und boten ursprünglich eine höhere Sicherheitsmarge — jedoch gelten beide Algorithmen mittlerweile für die Kollisionsresistenz als gebrochen.

Code-Beispiele

SHA-1-Hashes in gängigen Sprachen und Umgebungen generieren. Anders als MD5 ist SHA-1 in der Browser Web Crypto API verfügbar und kann daher ohne externe Bibliotheken sowohl im Browser als auch in Node.js-Umgebungen verwendet werden.

// SHA-1 is available in the Web Crypto API
async function sha1(text) {
  const data = new TextEncoder().encode(text)
  const hashBuffer = await crypto.subtle.digest('SHA-1', data)
  const hashArray = Array.from(new Uint8Array(hashBuffer))
  return hashArray.map(b => b.toString(16).padStart(2, '0')).join('')
}

await sha1('hello world')
// → "2aae6c35c94fcfb415dbe95f408b9ce91ee846ed"

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

import hashlib

# Basic SHA-1 hash
result = hashlib.sha1(b'hello world').hexdigest()
print(result)  # → "2aae6c35c94fcfb415dbe95f408b9ce91ee846ed"

# Hash a string (encode to bytes first)
text = 'hello world'
hashlib.sha1(text.encode('utf-8')).hexdigest()
# → "2aae6c35c94fcfb415dbe95f408b9ce91ee846ed"

# Hash a file in chunks
with open('file.bin', 'rb') as f:
    sha1 = hashlib.sha1()
    for chunk in iter(lambda: f.read(8192), b''):
        sha1.update(chunk)
    print(sha1.hexdigest())

package main

import (
    "crypto/sha1"
    "fmt"
)

func main() {
    data := []byte("hello world")
    hash := sha1.Sum(data)
    fmt.Printf("%x\n", hash)
    // → 2aae6c35c94fcfb415dbe95f408b9ce91ee846ed
}

# Using sha1sum (Linux) or shasum (macOS)
echo -n "hello world" | sha1sum
# → 2aae6c35c94fcfb415dbe95f408b9ce91ee846ed  -

# macOS
echo -n "hello world" | shasum -a 1
# → 2aae6c35c94fcfb415dbe95f408b9ce91ee846ed  -

# Hash a file
sha1sum package.json
# → a1b2c3d4e5f6...  package.json

# Using openssl (cross-platform)
echo -n "hello world" | openssl sha1
# → SHA1(stdin)= 2aae6c35c94fcfb415dbe95f408b9ce91ee846ed

Häufig gestellte Fragen