SHA-2

Sichere Hash-Algorithmen ⓘ
Konzepte
Hash-Funktionen - SHA - DSA
Wichtigste Standards
SHA-0 - SHA-1 - SHA-2 - SHA-3

SHA-2 ⓘ

Allgemein
Entwerfer	Nationale Sicherheitsagentur
Erstmals veröffentlicht	2001; vor 22 Jahren
Reihe	(SHA-0), SHA-1, SHA-2, SHA-3
Zertifizierung	FIPS PUB 180-4, CRYPTREC, NESSIE
Einzelheiten
Digest-Größen	224, 256, 384 oder 512 Bits
Aufbau	Merkle-Damgård-Konstruktion mit Davies-Meyer-Kompressionsfunktion
Rundungen	64 oder 80
Beste öffentliche Kryptoanalyse
Ein Angriff aus dem Jahr 2011 bricht die Preimage-Resistenz für 57 von 80 Runden von SHA-512 und für 52 von 64 Runden von SHA-256. Pseudokollisionsangriff gegen bis zu 46 Runden von SHA-256. SHA-256 und SHA-512 sind anfällig für Längenerweiterungsangriffe. Durch Erraten des versteckten Teils des Zustands sind Längenerweiterungsangriffe auf SHA-224 und SHA-384 mit der Wahrscheinlichkeit 2-(256-224) = 2-32 > 2-224 bzw. 2-(512-384) = 2-128 > 2-384 erfolgreich.

SHA-2 (Secure Hash Algorithm 2) ist eine Reihe von kryptografischen Hash-Funktionen, die von der Nationalen Sicherheitsbehörde der Vereinigten Staaten (NSA) entwickelt und erstmals 2001 veröffentlicht wurden. Sie werden mit Hilfe der Merkle-Damgård-Konstruktion aus einer Einweg-Kompressionsfunktion aufgebaut, die ihrerseits mit Hilfe der Davies-Meyer-Struktur aus einer speziellen Blockchiffre aufgebaut wird. ⓘ

SHA-2 enthält wesentliche Änderungen gegenüber seinem Vorgänger SHA-1. Die SHA-2-Familie besteht aus sechs Hash-Funktionen mit Digests (Hash-Werten), die 224, 256, 384 oder 512 Bit lang sind: SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224, SHA-512/256. SHA-256 und SHA-512 sind neue Hash-Funktionen, die mit acht 32-Bit- bzw. 64-Bit-Wörtern berechnet werden. Sie verwenden unterschiedliche Verschiebungsbeträge und additive Konstanten, aber ihre Strukturen sind ansonsten praktisch identisch und unterscheiden sich nur durch die Anzahl der Runden. SHA-224 und SHA-384 sind verkürzte Versionen von SHA-256 bzw. SHA-512, die mit unterschiedlichen Ausgangswerten berechnet werden. SHA-512/224 und SHA-512/256 sind ebenfalls verkürzte Versionen von SHA-512, aber die Anfangswerte werden nach der in Federal Information Processing Standards (FIPS) PUB 180-4 beschriebenen Methode erzeugt. ⓘ

SHA-2 wurde erstmals vom National Institute of Standards and Technology (NIST) als US-Bundesstandard (FIPS) veröffentlicht. Die Algorithmen der SHA-2-Familie sind in den USA patentiert. Die Vereinigten Staaten haben das Patent im Rahmen einer lizenzgebührenfreien Lizenz freigegeben. ⓘ

(Stand: 2011) Die besten öffentlichen Angriffe brechen die Preimage-Resistenz für 52 von 64 Runden von SHA-256 oder 57 von 80 Runden von SHA-512 und die Kollisionsresistenz für 46 von 64 Runden von SHA-256. ⓘ

Hash-Standard

Eine Iteration in einer Kompressionsfunktion der SHA-2-Familie. Die blauen Komponenten führen die folgenden Operationen durch:
    $\operatorname {Ch} (E,F,G)=(E\land F)\oplus (\neg E\land G)$
    $\operatorname {Ma} (A,B,C)=(A\land B)\oplus (A\land C)\oplus (B\land C)$
    $\Sigma _{0}(A)=(A\!\ggg \!2)\oplus (A\!\ggg \!13)\oplus (A\!\ggg \!22)$
    $\Sigma _{1}(E)=(E\!\ggg \!6)\oplus (E\!\ggg \!11)\oplus (E\!\ggg \!25)$
Bei der bitweisen Drehung werden für SHA-512 andere Konstanten verwendet. Die angegebenen Zahlen gelten für SHA-256.
Die rote $\color {red}\boxplus$ ist die Addition modulo 2³² für SHA-256 bzw. 2⁶⁴ für SHA-512. ⓘ

Mit der Veröffentlichung von FIPS PUB 180-2 fügte das NIST drei weitere Hash-Funktionen der SHA-Familie hinzu. Die Algorithmen sind unter dem Namen SHA-2 bekannt, benannt nach ihrer Digestlänge (in Bits): SHA-256, SHA-384 und SHA-512. ⓘ

Die Algorithmen wurden erstmals im Jahr 2001 im Entwurf FIPS PUB 180-2 veröffentlicht, zu dem die Öffentlichkeit Stellung nehmen konnte. Im August 2002 wurde FIPS PUB 180-2 zum neuen Secure Hash Standard und ersetzte FIPS PUB 180-1, der im April 1995 veröffentlicht wurde. Der aktualisierte Standard enthielt den ursprünglichen SHA-1-Algorithmus mit einer aktualisierten technischen Notation, die mit der Beschreibung der Funktionsweise der SHA-2-Familie übereinstimmt. ⓘ

Im Februar 2004 wurde eine Änderungsmitteilung für FIPS PUB 180-2 veröffentlicht, in der eine zusätzliche Variante, SHA-224, definiert wurde, die der Schlüssellänge von Triple DES mit zwei Schlüsseln entspricht. Im Oktober 2008 wurde der Standard in FIPS PUB 180-3 aktualisiert, wobei SHA-224 aus der Änderungsmitteilung aufgenommen wurde, ansonsten aber keine grundlegenden Änderungen am Standard vorgenommen wurden. Die Hauptmotivation für die Aktualisierung des Standards war die Verlagerung von Sicherheitsinformationen über die Hash-Algorithmen und Empfehlungen für ihre Verwendung in die Special Publications 800-107 und 800-57. Detaillierte Testdaten und Beispiel-Nachrichten-Digests wurden ebenfalls aus dem Standard entfernt und als separate Dokumente bereitgestellt. ⓘ

Im Januar 2011 veröffentlichte das NIST die Norm SP800-131A, in der festgelegt wurde, dass die Sicherheit von 80 Bit (SHA-1), die bis Ende 2013 für die Verwendung durch Bundesbehörden zulässig ist, auf 112 Bit (SHA-2) als Mindestanforderung (ab 2014) und empfohlene Sicherheitsstufe (ab dem Veröffentlichungsdatum 2011) erhöht wird. ⓘ

Im März 2012 wurde der Standard in FIPS PUB 180-4 aktualisiert, wobei die Hash-Funktionen SHA-512/224 und SHA-512/256 hinzugefügt und eine Methode zur Erzeugung von Anfangswerten für verkürzte Versionen von SHA-512 beschrieben wurden. Darüber hinaus wurde die Beschränkung für das Auffüllen der Eingabedaten vor der Hash-Berechnung aufgehoben, so dass die Hash-Daten gleichzeitig mit der Generierung von Inhalten, wie z. B. Echtzeit-Video- oder Audio-Feeds, berechnet werden können. Das Auffüllen des endgültigen Datenblocks muss weiterhin vor der Hash-Ausgabe erfolgen. ⓘ

Im Juli 2012 überarbeitete das NIST die SP800-57, die Leitlinien für die Verwaltung kryptografischer Schlüssel enthält. Die Veröffentlichung verbietet die Erstellung digitaler Signaturen mit einer Hash-Sicherheit von weniger als 112 Bit nach 2013. In der vorherigen Überarbeitung aus dem Jahr 2007 war als Stichtag das Ende des Jahres 2010 angegeben. Im August 2012 überarbeitete das NIST SP800-107 in gleicher Weise. ⓘ

Im Rahmen des NIST-Hash-Funktionswettbewerbs wurde 2012 eine neue Hash-Funktion, SHA-3, ausgewählt. Der SHA-3-Algorithmus ist nicht von SHA-2 abgeleitet. ⓘ

Anwendungen

Die SHA-2-Hash-Funktion ist in einigen weit verbreiteten Sicherheitsanwendungen und -protokollen implementiert, darunter TLS und SSL, PGP, SSH, S/MIME und IPsec. ⓘ

SHA-256 wird für die Authentifizierung von Debian-Softwarepaketen und im DKIM-Standard für die Nachrichtensignierung verwendet; SHA-512 ist Teil eines Systems zur Authentifizierung von Archivvideos des Internationalen Strafgerichtshofs für den Völkermord in Ruanda. SHA-256 und SHA-512 werden für die Verwendung in DNSSEC vorgeschlagen. Unix- und Linux-Anbieter gehen dazu über, 256- und 512-Bit-SHA-2 für sicheres Passwort-Hashing zu verwenden. ⓘ

Mehrere Kryptowährungen, darunter Bitcoin, verwenden SHA-256 zur Verifizierung von Transaktionen und zur Berechnung von Proof of Work oder Proof of Stake. Das Aufkommen von ASIC SHA-2-Beschleunigerchips hat zur Verwendung von Scrypt-basierten Proof-of-Work-Verfahren geführt. ⓘ

SHA-1 und SHA-2 sind die gesetzlich vorgeschriebenen Secure Hash Algorithmen für bestimmte Anwendungen der US-Regierung, einschließlich der Verwendung in anderen kryptographischen Algorithmen und Protokollen, zum Schutz sensibler, nicht klassifizierter Informationen. FIPS PUB 180-1 hat auch die Annahme und Verwendung von SHA-1 durch private und kommerzielle Organisationen gefördert. Das U.S. National Institute of Standards and Technology (NIST) sagt: "Bundesbehörden sollten die Verwendung von SHA-1 für ... Anwendungen, die Kollisionssicherheit erfordern, so schnell wie möglich einstellen und nach 2010 die SHA-2-Familie von Hash-Funktionen für diese Anwendungen verwenden" (Hervorhebung im Original). Die Anweisung des NIST, dass die US-Regierungsbehörden SHA-1 nach 2010 nicht mehr verwenden dürfen, sollte die Abkehr von SHA-1 beschleunigen. ⓘ

Die SHA-2-Funktionen wurden anfangs nicht schnell angenommen, obwohl sie besser gesichert sind als SHA-1. Gründe dafür könnten die fehlende Unterstützung für SHA-2 auf Systemen mit Windows XP SP2 oder älter und die mangelnde Dringlichkeit sein, da SHA-1-Kollisionen noch nicht gefunden worden waren. Das Google Chrome-Team kündigte einen Plan an, der vorsieht, dass der Webbrowser SHA-1-abhängige TLS-Zertifikate ab Ende 2014 und Anfang 2015 schrittweise nicht mehr anerkennt. In ähnlicher Weise kündigte Microsoft an, dass Internet Explorer und Edge ab Februar 2017 keine öffentlichen, mit SHA-1 signierten TLS-Zertifikate mehr anerkennen würden. Mozilla deaktivierte SHA-1 Anfang Januar 2016, musste es aber nach Problemen mit den webbasierten Benutzeroberflächen einiger Routermodelle und Sicherheitsanwendungen über ein Firefox-Update vorübergehend wieder aktivieren. ⓘ

Kryptoanalyse und Validierung

Bei einer Hash-Funktion, bei der L die Anzahl der Bits im Message Digest ist, kann eine Nachricht, die einem bestimmten Message Digest entspricht, immer mit einer Brute-Force-Suche in 2^L-Auswertungen gefunden werden. Dies wird als Preimage-Angriff bezeichnet und kann je nach L und der jeweiligen Computerumgebung praktisch sein oder nicht. Das zweite Kriterium, das Auffinden von zwei verschiedenen Nachrichten, die denselben Message Digest ergeben, bekannt als Kollision, erfordert im Durchschnitt nur 2^L/2 Auswertungen mit einem Geburtstagsangriff. ⓘ

Einige der Anwendungen, die kryptografische Hashes verwenden, wie z. B. die Speicherung von Passwörtern, werden durch einen Kollisionsangriff nur geringfügig beeinträchtigt. Die Konstruktion eines Passworts, das für ein bestimmtes Konto funktioniert, erfordert einen Angriff mit einem Vorabbild sowie den Zugriff auf den Hash des ursprünglichen Passworts (in der Regel in der Schattendatei), was trivial sein kann, aber nicht muss. Die Umkehrung der Kennwortverschlüsselung (z. B. um ein Kennwort zu erhalten, das für ein anderes Benutzerkonto verwendet werden soll) wird durch diese Angriffe nicht ermöglicht. (Allerdings kann auch ein sicherer Passwort-Hash keine Brute-Force-Angriffe auf schwache Passwörter verhindern.) ⓘ

Im Falle der Unterzeichnung von Dokumenten könnte ein Angreifer nicht einfach eine Unterschrift von einem vorhandenen Dokument fälschen - der Angreifer müsste ein Paar von Dokumenten vorlegen, ein harmloses und ein schädliches, und den Inhaber des privaten Schlüssels dazu bringen, das harmlose Dokument zu unterzeichnen. Bis Ende 2008 war es möglich, gefälschte SSL-Zertifikate mit einer MD5-Kollision zu erstellen, die von weit verbreiteten Webbrowsern akzeptiert wurden. ⓘ

Das verstärkte Interesse an der kryptografischen Hash-Analyse während des SHA-3-Wettbewerbs führte zu mehreren neuen Angriffen auf die SHA-2-Familie, von denen die besten in der folgenden Tabelle aufgeführt sind. Nur die Kollisionsangriffe sind von praktischer Komplexität; keiner der Angriffe erstreckt sich auf die vollständige Hash-Funktion. ⓘ

Auf der FSE 2012 hielten Forscher von Sony eine Präsentation, in der sie vorschlugen, dass Pseudokollisionsangriffe auf 52 Runden bei SHA-256 und 57 Runden bei SHA-512 ausgeweitet werden könnten, indem sie auf dem biclique Pseudo-Preimage-Angriff aufbauen. ⓘ

Veröffentlicht in	Jahr	Angriffsmethode	Angriff	Variante	Rundungen	Komplexität ⓘ
Neue Kollisionsangriffe gegen bis zu 24-stufige SHA-2	2008	Deterministisch	Kollision	SHA-256	24/64	228.5
				SHA-512	24/80	232.5
Präimages für stufenreduziertes SHA-2	2009	Meet-in-the-middle	Vorabbild	SHA-256	42/64	2251.7
					43/64	2254.9
				SHA-512	42/80	2502.3
					46/80	2511.5
Erweiterte Meet-in-the-middle-Preimage-Angriffe	2010	Meet-in-the-middle	Vorabbild	SHA-256	42/64	2248.4
				SHA-512	42/80	2494.6
Differentialangriff höherer Ordnung auf reduzierten SHA-256	2011	Differential	Pseudo-Kollision	SHA-256	46/64	2178
					33/64	246
Bicliques für Preimages: Angriffe auf Skein-512 und die SHA-2-Familie	2011	Biclique	Vorabbild	SHA-256	45/64	2255.5
				SHA-512	50/80	2511.5
			Pseudo-Präimages	SHA-256	52/64	2255
				SHA-512	57/80	2511
Verbesserung von lokalen Kollisionen: Neue Angriffe auf reduzierte SHA-256	2013	Differential	Kollision	SHA-256	31/64	265.5
			Pseudo-Kollision	SHA-256	38/64	237
Verzweigungsheuristiken bei der differentiellen Kollisionssuche mit Anwendungen auf SHA-512	2014	Differenzielle Heuristik	Pseudo-Kollision	SHA-512	38/80	240.5
Analyse von SHA-512/224 und SHA-512/256	2016	Differential	Kollision	SHA-256	28/64	praktische
				SHA-512	27/80	praktische
			Pseudo-Kollision	SHA-512	39/80	praktische

Offizielle Validierung

Implementierungen aller FIPS-zugelassenen Sicherheitsfunktionen können offiziell durch das CMVP-Programm validiert werden, das gemeinsam vom National Institute of Standards and Technology (NIST) und dem Communications Security Establishment (CSE) durchgeführt wird. Für die informelle Überprüfung wird auf der NIST-Website ein Paket zur Generierung einer großen Anzahl von Testvektoren zum Download bereitgestellt; die daraus resultierende Überprüfung ersetzt jedoch nicht die formelle CMVP-Validierung, die für bestimmte Anwendungen gesetzlich vorgeschrieben ist. ⓘ

Im Dezember 2013 gab es über 1300 validierte SHA-256-Implementierungen und über 900 SHA-512-Implementierungen, von denen nur fünf in der Lage waren, Nachrichten mit einer Länge in Bits, die kein Vielfaches von acht ist, zu verarbeiten und gleichzeitig beide Varianten zu unterstützen. ⓘ

Test-Vektoren

Hash-Werte einer leeren Zeichenkette (d. h. eines Eingabetextes mit der Länge Null).

SHA224("")
0x d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f
SHA256("")
0x e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
SHA384("")
0x 38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b
SHA512("")
0x cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e
SHA512/224("")
0x 6ed0dd02806fa89e25de060c19d3ac86cabb87d6a0ddd05c333b84f4
SHA512/256("")
0x c672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967a ⓘ

Selbst eine kleine Änderung in der Nachricht wird (mit überwältigender Wahrscheinlichkeit) aufgrund des Lawineneffekts zu einem weitgehend anderen Hash führen. Wenn man zum Beispiel einen Punkt am Ende des folgenden Satzes hinzufügt, ändert sich fast die Hälfte (111 von 224) der Bits im Hash:

SHA224("Der schnelle braune Fuchs springt über den faulen Hund")
0x 730e109bd7a8a32b1cb9d9a09aa2325d2430587ddbc0c38bad911525
SHA224("Der schnelle braune Fuchs springt über den faulen Hund.")
0x 619cba8e8e05826e9b8c519c0a5c68f4fb653e8a3d8aa04bb2c8cd4c ⓘ

Eine kleine Änderung der Nachricht, beispielsweise in der Länge oder des Inhalts, erzeugt einen ganz anderen Hash. Diese Eigenschaft wird in der Kryptographie auch als Lawineneffekt bezeichnet. ⓘ

SHA224("Franz jagt im komplett verwahrlosten Taxi quer durch Bayern") =
49b08defa65e644cbf8a2dd9270bdededabc741997d1dadd42026d7b
SHA224("Frank jagt im komplett verwahrlosten Taxi quer durch Bayern") =
58911e7fccf2971a7d07f93162d8bd13568e71aa8fc86fc1fe9043d1 ⓘ

Pseudocode

Es folgt der Pseudocode für den SHA-256-Algorithmus. Man beachte die starke Zunahme der Vermischung zwischen den Bits der w[16..63]-Wörter im Vergleich zu SHA-1. ⓘ

Anmerkung 1: Alle Variablen sind 32-Bit-Ganzzahlen ohne Vorzeichen und die Addition wird modulo 232 berechnet.
Anmerkung 2: Für jede Runde gibt es eine Rundenkonstante k[i] und einen Eintrag im Nachrichtenplan-Array w[i], 0 ≤ i ≤ 63
Anmerkung 3: Die Kompressionsfunktion verwendet 8 Arbeitsvariablen, a bis h
Anmerkung 4: Bei der Darstellung der Konstanten in diesem Pseudocode wird die Big-Endian-Konvention verwendet,
    und beim Parsen von Nachrichtenblockdaten von Bytes zu Wörtern, zum Beispiel,
    das erste Wort der Eingabenachricht "abc" nach dem Auffüllen ist 0x61626380 ⓘ

Hash-Werte initialisieren:
(die ersten 32 Bits der Bruchteile der Quadratwurzeln der ersten 8 Primzahlen 2..19):
h0 := 0x6a09e667
h1 := 0xbb67ae85
h2 := 0x3c6ef372
h3 := 0xa54ff53a
h4 := 0x510e527f
h5 := 0x9b05688c
h6 := 0x1f83d9ab
h7 := 0x5be0cd19 ⓘ

Array mit runden Konstanten initialisieren:
(die ersten 32 Bits der Nachkommastellen der Kubikwurzeln der ersten 64 Primzahlen 2..311):
k[0..63] :=
   0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
   0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
   0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
   0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
   0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
   0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
   0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
   0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 ⓘ

Vorverarbeitung (Auffüllen):
Beginn mit der ursprünglichen Nachricht der Länge L Bits
Anhängen eines einzelnen '1'-Bits
Anhängen von K '0'-Bits, wobei K die Mindestzahl >= 0 ist, so dass (L + 1 + K + 64) ein Vielfaches von 512 ist
L als 64-Bit-Big-Endian-Ganzzahl anhängen, so dass die gesamte nachbearbeitete Länge ein Vielfaches von 512 Bits ist
so dass die Bits in der Nachricht sind: 
1 ⓘ 

(die Anzahl der Bits ist ein Vielfaches von 512) ⓘ

Verarbeiten Sie die Nachricht in aufeinanderfolgenden 512-Bit-Blöcken:
Aufteilung der Nachricht in 512-Bit-Blöcke
für jeden Brocken
    Erstellen eines 64 Einträge umfassenden Nachrichtenplan-Arrays w[0..63] aus 32-Bit-Wörtern
    (Die Anfangswerte in w[0..63] spielen keine Rolle, weshalb viele Implementierungen sie hier auf Null setzen)
    Kopieren des Chunks in die ersten 16 Wörter w[0..15] des Nachrichtenplan-Arrays ⓘ

    Erweitern Sie die ersten 16 Wörter in die verbleibenden 48 Wörter w[16..63] des Nachrichtenplan-Arrays:
    für i von 16 bis 63
        s0 := (w[i-15] rightrotate 7) xor (w[i-15] rightrotate 18) xor (w[i-15] rightshift 3)
        s1 := (w[i-2] Rechtsdrehung 17) xor (w[i-2] Rechtsdrehung 19) xor (w[i-2] Rechtsverschiebung 10)
        w[i] := w[i-16] + s0 + w[i-7] + s1 ⓘ

    Initialisierung der Arbeitsvariablen auf den aktuellen Hash-Wert:
    a := h0
    b := h1
    c := h2
    d := h3
    e := h4
    f := h5
    g := h6
    h := h7 ⓘ

    Hauptschleife der Komprimierungsfunktion:
    für i von 0 bis 63
        S1 := (e Rechtsdrehung 6) xor (e Rechtsdrehung 11) xor (e Rechtsdrehung 25)
        ch := (e und f) xor ((nicht e) und g)
        temp1 := h + S1 + ch + k[i] + w[i]
        S0 := (a Rechtsdrehung 2) xor (a Rechtsdrehung 13) xor (a Rechtsdrehung 22)
        maj := (a und b) xor (a und c) xor (b und c)
        temp2 := S0 + maj ⓘ

        h := g
        g := f
        f := e
        e := d + temp1
        d := c
        c := b
        b := a
        a := temp1 + temp2 ⓘ

    Hinzufügen des komprimierten Chunks zum aktuellen Hashwert:
    h0 := h0 + a
    h1 := h1 + b
    h2 := h2 + c
    h3 := h3 + d
    h4 := h4 + e
    h5 := h5 + f
    h6 := h6 + g
    h7 := h7 + h ⓘ

Erzeugen Sie den endgültigen Hash-Wert (Big-Endian):
digest := hash := h0 anhängen h1 anhängen h2 anhängen h3 anhängen h4 anhängen h5 anhängen h6 anhängen h7 ⓘ

Die Berechnung der ch- und maj-Werte kann auf die gleiche Weise optimiert werden, wie für SHA-1 beschrieben. ⓘ

SHA-224 ist identisch mit SHA-256, mit dem Unterschied, dass:

• die anfänglichen Hash-Werte h0 bis h7 sind unterschiedlich, und
• die Ausgabe wird durch Weglassen von h7 konstruiert.

SHA-224-Hash-Anfangswerte (in Big Endian):
(Die zweiten 32 Bits der Nachkommastellen der Quadratwurzeln der 9. bis 16. Primzahl 23..53)
h[0..7] :=
    0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4 ⓘ

SHA-512 ist von der Struktur her identisch mit SHA-256, aber:

• die Nachricht wird in 1024-Bit-Blöcke aufgeteilt,
• die anfänglichen Hash-Werte und Rundenkonstanten sind auf 64 Bit erweitert,
• es gibt 80 Runden anstelle von 64,
• das Nachrichtenplan-Array w besteht aus 80 64-Bit-Wörtern anstelle von 64 32-Bit-Wörtern,
• um das Nachrichtenplan-Array w zu erweitern, ist die Schleife von 16 bis 79 statt von 16 bis 63,
• die Rundungskonstanten basieren auf den ersten 80 Primzahlen 2..409,
• die für die Berechnungen verwendete Wortgröße ist 64 Bit lang,
• die angehängte Länge der Nachricht (vor der Vorverarbeitung), in Bits, ist eine 128-Bit Big-Endian-Ganzzahl, und
• die verwendeten Werte für Verschiebung und Drehung sind unterschiedlich. ⓘ

SHA-512-Hash-Anfangswerte (in Big-Endian):
h[0..7] := 0x6a09e667f3bcc908, 0xbb67ae8584caa73b, 0x3c6ef372fe94f82b, 0xa54ff53a5f1d36f1, 
           0x510e527fade682d1, 0x9b05688c2b3e6c1f, 0x1f83d9abfb41bd6b, 0x5be0cd19137e2179 ⓘ

SHA-512 Runde Konstanten:
k[0..79] := 0x428a2f98d728ae22, 0x7137449123ef65cd, 0xb5c0fbcfec4d3b2f, 0xe9b5dba58189dbbc, 0x3956c25bf348b538, 
            0x59f111f1b605d019, 0x923f82a4af194f9b, 0xab1c5ed5da6d8118, 0xd807aa98a3030242, 0x12835b0145706fbe, 
            0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2, 0x72be5d74f27b896f, 0x80deb1fe3b1696b1, 0x9bdc06a725c71235, 
            0xc19bf174cf692694, 0xe49b69c19ef14ad2, 0xefbe4786384f25e3, 0x0fc19dc68b8cd5b5, 0x240ca1cc77ac9c65, 
            0x2de92c6f592b0275, 0x4a7484aa6ea6e483, 0x5cb0a9dcbd41fbd4, 0x76f988da831153b5, 0x983e5152ee66dfab, 
            0xa831c66d2db43210, 0xb00327c898fb213f, 0xbf597fc7beef0ee4, 0xc6e00bf33da88fc2, 0xd5a79147930aa725, 
            0x06ca6351e003826f, 0x142929670a0e6e70, 0x27b70a8546d22ffc, 0x2e1b21385c26c926, 0x4d2c6dfc5ac42aed, 
            0x53380d139d95b3df, 0x650a73548baf63de, 0x766a0abb3c77b2a8, 0x81c2c92e47edaee6, 0x92722c851482353b, 
            0xa2bfe8a14cf10364, 0xa81a664bbc423001, 0xc24b8b70d0f89791, 0xc76c51a30654be30, 0xd192e819d6ef5218, 
            0xd69906245565a910, 0xf40e35855771202a, 0x106aa07032bbd1b8, 0x19a4c116b8d2d0c8, 0x1e376c085141ab53, 
            0x2748774cdf8eeb99, 0x34b0bcb5e19b48a8, 0x391c0cb3c5c95a63, 0x4ed8aa4ae3418acb, 0x5b9cca4f7763e373, 
            0x682e6ff3d6b2b8a3, 0x748f82ee5defb2fc, 0x78a5636f43172f60, 0x84c87814a1f0ab72, 0x8cc702081a6439ec, 
            0x90befffa23631e28, 0xa4506cebde82bde9, 0xbef9a3f7b2c67915, 0xc67178f2e372532b, 0xca273eceea26619c, 
            0xd186b8c721c0c207, 0xeada7dd6cde0eb1e, 0xf57d4f7fee6ed178, 0x06f067aa72176fba, 0x0a637dc5a2c898a6, 
            0x113f9804bef90dae, 0x1b710b35131c471b, 0x28db77f523047d84, 0x32caab7b40c72493, 0x3c9ebe0a15c9bebc, 
            0x431d67c49c100d4c, 0x4cc5d4becb3e42b6, 0x597f299cfc657e2a, 0x5fcb6fab3ad6faec, 0x6c44198c4a475817 ⓘ

SHA-512 Summe & Sigma:
S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)
S1 := (e Rechtsdrehung 14) xor (e Rechtsdrehung 18) xor (e Rechtsdrehung 41) ⓘ

s0 := (w[i-15] Rechtsdrehung 1) xor (w[i-15] Rechtsdrehung 8) xor (w[i-15] Rechtsverschiebung 7)
s1 := (w[i-2] Rechtsdrehung 19) xor (w[i-2] Rechtsdrehung 61) xor (w[i-2] Rechtsverschiebung 6) ⓘ

SHA-384 ist identisch mit SHA-512, mit der Ausnahme, dass:

• die anfänglichen Hash-Werte h0 bis h7 unterschiedlich sind (sie stammen von der 9. bis 16. Primzahl), und
• die Ausgabe durch Weglassen von h6 und h7 konstruiert wird.

SHA-384-Hash-Anfangswerte (in Big-Endian):
h[0..7] := 0xcbbb9d5dc1059ed8, 0x629a292a367cd507, 0x9159015a3070dd17, 0x152fecd8f70e5939, 
           0x67332667ffc00b31, 0x8eb44a8768581511, 0xdb0c2e0d64f98fa7, 0x47b5481dbefa4fa4 ⓘ

SHA-512/t ist identisch mit SHA-512, außer dass:

• Die anfänglichen Hash-Werte h0 bis h7 werden von der SHA-512/t IV-Generierungsfunktion vorgegeben,
• die Ausgabe wird durch Abschneiden der Verkettung von h0 bis h7 bei t Bits erstellt,
• t gleich 384 ist nicht zulässig, stattdessen sollte wie angegeben SHA-384 verwendet werden, und
• Die t-Werte 224 und 256 werden ausdrücklich als zulässig genannt. ⓘ

Die SHA-512/t IV-Generierungsfunktion wertet ein modifiziertes SHA-512 an der ASCII-Zeichenkette "SHA-512/t" aus, die durch die dezimale Darstellung von t ersetzt wird. Das modifizierte SHA-512 entspricht SHA-512, außer dass die Anfangswerte h0 bis h7 jeweils mit der hexadezimalen Konstante 0xa5a5a5a5a5a5a5 gekreuzt wurden. ⓘ

Ein Beispiel für eine C-Implementierung der SHA-2-Familie von Hash-Funktionen ist in RFC 6234 zu finden. ⓘ

Vergleich von SHA-Funktionen

In der nachstehenden Tabelle bezeichnet der interne Zustand die "interne Hash-Summe" nach jeder Komprimierung eines Datenblocks. ⓘ

Vergleich der SHA-Funktionen

Algorithmus und Variante		Größe der Ausgabe (Bits)	Intern Zustandsgröße (Bits)	Blockgröße (Bits)	Rundungen	Operationen	Sicherheit gegen Kollisionsangriffe (Bits)	Sicherheit gegen Längenausdehnungsangriffe (Bits)	Leistung auf Skylake (Median cpb)		Erstmals veröffentlicht
									Lange Nachrichten	8 Bytes
MD5 (als Referenz)		128	128 (4 × 32)	512	64	Und, Xor, Oder, Rot, Addieren (mod 232)	≤ 18 (Kollisionen gefunden)	0	4.99	55.00	1992
SHA-0		160	160 (5 × 32)	512	80	Und, Xor, Oder, Rot, Addieren (mod 232)	< 34 (Kollisionen gefunden)	0	≈ SHA-1	≈ SHA-1	1993
SHA-1							< 63 (Kollisionen gefunden)		3.47	52.00	1995
SHA-2	SHA-224 SHA-256	224 256	256 (8 × 32)	512	64	Und, Xor, Oder, Rot, Shr, Add (mod 232)	112 128	32 0	7.62 7.63	84.50 85.25	2004 2001
	SHA-384	384	512 (8 × 64)	1024	80	Und, Xor, Oder, Drehen, Schrumpfen, Addieren (mod 264)	192	128 (≤ 384)	5.12	135.75	2001
	SHA-512	512					256	0	5.06	135.50	2001
	SHA-512/224 SHA-512/256	224 256					112 128	288 256	≈ SHA-384	≈ SHA-384	2012
SHA-3	SHA3-224 SHA3-256 SHA3-384 SHA3-512	224 256 384 512	1600 (5 × 5 × 64)	1152 1088 832 576	24	Und, Xor, Rot, Nicht	112 128 192 256	448 512 768 1024	8.12 8.59 11.06 15.88	154.25 155.50 164.00 164.00	2015
	SHAKE128 SHAKE256	d (willkürlich) d (willkürlich)		1344 1088			min(d/2, 128) min(d/2, 256)	256 512	7.08 8.59	155.25 155.50

In der Spalte der bitweisen Operationen steht "Rot" für rotate no carry und "Shr" für right logical shift. Alle diese Algorithmen verwenden in irgendeiner Weise modulare Addition, mit Ausnahme von SHA-3. ⓘ

Detailliertere Leistungsmessungen auf modernen Prozessorarchitekturen sind in der nachstehenden Tabelle aufgeführt. ⓘ

CPU-Architektur	Frequenz	Algorithmus	Wortgröße (Bits)	Zyklen/Byte x86	MiB/s x86	Zyklen/Byte x86-64	MiB/s x86-64 ⓘ
Intel Ivy Bridge	3,5 GHz	SHA-256	32	16.80	199	13.05	256
		SHA-512	64	43.66	76	8.48	394
AMD Piledriver APU	3,8 GHz	SHA-256	32	22.87	158	18.47	196
		SHA-512	64	88.36	41	12.43	292

Die mit "x86" gekennzeichneten Leistungszahlen wurden mit 32-Bit-Code auf 64-Bit-Prozessoren ausgeführt, während die "x86-64"-Zahlen nativen 64-Bit-Code darstellen. SHA-256 ist zwar für 32-Bit-Berechnungen konzipiert, profitiert aber von Code, der für 64-Bit-Prozessoren auf der x86-Architektur optimiert ist. 32-Bit-Implementierungen von SHA-512 sind deutlich langsamer als ihre 64-Bit-Pendants. Varianten beider Algorithmen mit unterschiedlichen Ausgabegrößen sind ähnlich leistungsfähig, da die Funktionen zur Nachrichtenerweiterung und -komprimierung identisch sind und sich nur die anfänglichen Hash-Werte und Ausgabegrößen unterscheiden. Die besten Implementierungen von MD5 und SHA-1 erreichen auf modernen Prozessoren zwischen 4,5 und 6 Zyklen pro Byte. ⓘ

Die Tests wurden von der University of Illinois at Chicago auf ihrem hydra8-System mit einem Intel Xeon E3-1275 V2 und einer Taktfrequenz von 3,5 GHz sowie auf ihrem hydra9-System mit einer AMD A10-5800K APU und einer Taktfrequenz von 3,8 GHz durchgeführt. Die oben angegebenen Geschwindigkeiten von Zyklen pro Byte sind die mittlere Leistung eines Algorithmus, der eine 4.096 Byte große Nachricht mit der kryptografischen Benchmarking-Software SUPERCOP verdaut. Die MiB/s-Leistung wird aus der CPU-Taktfrequenz eines einzelnen Kerns extrapoliert; die tatsächliche Leistung variiert aufgrund einer Vielzahl von Faktoren. ⓘ

Implementierungen

Im Folgenden finden Sie eine Liste von Kryptographie-Bibliotheken, die SHA-2 unterstützen:

• Botan
• Hüpfburg
• Cryptlib
• Krypto++
• Libgcrypt
• Mbed TLS
• libsodium
• Nessel
• LibreSSL
• OpenSSL
• GnuTLS
• wolfSSL ⓘ

Hardware-Beschleunigung wird durch die folgenden Prozessor-Erweiterungen bereitgestellt:

• Intel SHA-Erweiterungen: Verfügbar auf einigen Intel und AMD x86 Prozessoren.
• VIA PadLock
• ARMv8 Kryptographie-Erweiterungen
• IBM z/Architektur: Verfügbar seit 2005 als Teil der Message-Security-Assist-Erweiterungen 1 (SHA-256) und 2 (SHA-512) ⓘ