SHA-3

Aus Bitcoin Wiki
Dies ist die bestätigte sowie die neueste Version dieser Seite.
Wechseln zu: Navigation, Suche


SHA-3 algorithm Keccak

SHA-3 (Secure Hash Algorithm Version 3), auch Keccak genannt, ist eine unidirektionale Funktion zum Erzeugen digitaler Ausdrucke der ausgewählten Länge (der Standard akzeptiert 224, 256, 384 oder 512 Bit) aus Eingabedaten beliebiger Größe, die von a entwickelt werden Gruppe von Autoren, die 2008 von Yoan Dimen geleitet und 2015 als neuer FIPS-Standard angenommen wurde. Der Algorithmus arbeitet mittels der Mischfunktion mit Kompression auf die gewählte Größe „Kryptographieschwamm“.

Der ursprüngliche Keccak-Algorithmus verfügt über viele konfigurierbare Parameter (Datenblockgröße, Algorithmusstatusgröße, Anzahl der Runden in der f-Funktion usw.), um ein optimales Verhältnis von kryptografischer Stabilität und Leistung für die Anwendung auf der ausgewählten Plattform bereitzustellen. Die Version des SHA-3-Algorithmus weist einige Unterschiede zum ursprünglichen Keccak-Algorithmus auf:

  • langsame Modes c = 768 und c = 1024 werden verworfen
  • ein vereinfachter Füllalgorithmus
  • "Funktionen mit erweitertem Ergebnis" (XOF, Extendable-Output Functions) SHAKE128 und SHAKE256 eingeführt, für die die Hash-Nachricht erforderlich war, um das "Suffix" von 2 oder 4 Bits je nach Funktionstyp zu ergänzen.

Der Quellcode für die Referenzimplementierung war über CC0-Verzicht öffentlich zugänglich. Obwohl SHA-3 Teil derselben Standardserie ist, unterscheidet es sich intern stark von der MD5-ähnlichen Struktur von SHA-1 und SHA-2.

Keccak-Algorithmus[Bearbeiten]

Der Keccak-Algorithmus ist das Werk von Guido Bertoni, Joan Daemen (der zusammen mit Vincent Rijmen die Rijndael-Chiffre mitgestaltete), Michael Peeters und Gilles Van Assche. Es basiert auf früheren Hash-Funktionsentwürfen PANAMA und RadioGatún. PANAMA wurde 1998 von Daemen und Craig Clapp entworfen. RadioGatún, ein Nachfolger von PANAMA, wurde von Daemen, Peeters und Van Assche entworfen und wurde 2006 beim NIST Hash Workshop präsentiert.

SHA-3 algorithm

2006 begann NIST mit der Organisation des NIST-Hash-Funktionswettbewerbs, um einen neuen Hash-Standard, SHA-3, zu erstellen. SHA-3 soll SHA-2 nicht ersetzen, da kein signifikanter Angriff auf SHA-2 nachgewiesen wurde. Aufgrund der erfolgreichen Angriffe auf MD5, SHA-0 und SHA-1 erkannte NIST einen Bedarf an einem alternativen, unterschiedlichen kryptographischen Hash, der zu SHA-3 wurde.

Nach einer Aufbauphase sollten die Aufnahmen bis Ende 2008 eingereicht werden. Keccak wurde als einer der 51 Kandidaten angenommen.

Die Autoren von Keccak entwickelten ein einfaches (wenn Sie es verstehen) Schema, die sogenannte Schwammfunktion. In diesem "Schwamm" gibt es einen Zustand (1600 Bit Größe für SHA-3), auf den ein und dieselbe Funktion auf jede Runde angewendet wird, wodurch eine Pseudozufalls-Permutation implementiert wird. Das heißt, es ist im Wesentlichen eine schlüssellose Blockchiffre mit einer Blockgröße von 1600 Bits. Und wenn wir den Zustand mit Nullen füllen, zehn Runden ausführen (zehnmal wenden wir ihre Funktion f) in eine Richtung an und dann denselben Betrag in die entgegengesetzte Richtung (mit der Funktion invers f), dann erhalten wir wieder Nullen.

Um eine Zeichenkette zwischenzuspeichern, müssen Sie sie zunächst in Stücke einer bestimmten Größe aufteilen. In jeder Runde sollten Sie sie nicht mit dem gesamten 1600-Bit-Status mischen, sondern nur bis zum Anfang der Größe r. Hier werde ich den Kandidaten am meisten Bild einfügen, jetzt macht sie Sinn. In jeder Runde wird das nächste Stück der Zeichenfolge nur zu einem Teil des Zustands gemischt, während die Pseudo-Zufalls-Permutation f den gesamten Zustand behandelt, wodurch die Zeichenfolge von Zustand zu Zustand gebracht und von der gesamten Zeichenfolge abhängig wird.

Dies ist die sogenannte "Absorptionsstufe". Und jetzt ist klar, warum es so genannt wird. Um den eigentlichen Hash zu erhalten, wenden wir weiterhin die Permutationsfunktion f auf den Zustand an und kopieren in jedem Stadium nur ein Stück der Größe r von ihm, bis wir den Hash der erforderlichen Länge erhalten. Dieser sogenannte Schwamm "Quetschen".

SHA-3 ASIC[Bearbeiten]

SHA-3 läuft gut auf ASICs und Bergleute sehen darin einen strategischen Vorteil. Das Keccak-Team erklärt: „Der Durchsatz für ein bestimmtes Schaltungsgebiet ist um eine Größenordnung höher als bei SHA-2 oder einem der SHA-3-Finalisten. Und wenn Sie über die normale Geschwindigkeit hinaus interessiert sind, ist zu beachten, dass auch viel weniger Energie pro Bit verbraucht wird. In diesem Sinne ist Keccak ein grüner kryptographischer Primitiv. ”Nach ihrem besten Wissen sind ASICs für SHA-3 noch nicht weit verbreitet. Sicherheit ist das oberste Anliegen, und ein größeres Netzwerk-Risiko bedeutet ein viel härteres Ziel für Übeltäter. Hashes, die speicherintensiv sind oder andere Mittel verwenden, um den Vorteil spezialisierter Hardware zu mindern, machen Netzwerke leichter zu stürzen. Daher war es nicht sinnvoll, absichtlich einen ineffizienten Hash zu wählen. SHA-3 bietet mehr Sicherheit für weniger Strom; eine gewinnende Kombination.

Es ist auch unklar, ob ASICs tatsächlich zur Netzwerk-Zentralisierung beitragen. Die Debatte über diesen Punkt über Bitcoin war vor Jahren abgeklungen, und bei einigen von anderen Kryptowährungen verwendeten Hashes wurden ASICs entwickelt, ohne dass das gleiche Problem aufgeworfen wurde. Scrypt und X11. Die Ansicht ist, dass die Tokenverteilungsfunktion mehr als alles andere hat. Um dies zu beheben, haben wir einen speziellen Algorithmus zur Berechnung der Belohnung jedes Blocks implementiert.

Schließlich scheint SHA-3 die beste Resistenz gegen Angriffe auf Quantencomputing zu besitzen. Dies ist immer noch umstritten, aber neuere Forschungen sollten diese Bedenken lindern. Ein Team der University of Waterloo untersuchte, wie gut SHA-2 und SHA-3 einem Angriff vor dem Bild mit dem Quantensuch-Algorithmus von Grover standhalten konnten. SHA-3 hat sich sehr gut geschlagen.

Das SHA-3-Schema (Keccak) besteht aus zwei Stufen:

SHA-3 (Keccak) Arbeitsplan

Die Funktion von Keccak besteht aus den folgenden: Keccak[r,c](M) {

 Initialization and padding
 for(int x=0; x<5; x++)
   for(int y=0; y<5; y++)
     S[x,y] = 0;
 P = M || 0x01 || 0x00 || … || 0x00;
 P = P xor (0x00 || … || 0x00 || 0x80);
 //Absorbing phase
 forall block Pi in P
 for(int x=0; x<5; x++)
   for(int y=0; y<5; y++)
     S[x,y] = S[x,y] xor Pi[x+5*y];
   S = Keccak-f[r+c](S);
 //Squeezing phase
 Z = empty string;
do
{
 for(int x=0; x<5; x++)
   for(int y=0; y<5; y++)
     if((x+5y)<r/w)  
       Z = Z || S[x,y];
   S = Keccak-f[r+c](S)
}  while output is requested
 return Z;
}


Es ist absorbierend Funktion: Keccak-f[b](A)

{
 forall i in 0…nr-1
   A = Round[b](A, RC[i])
 return A
}

Hier ist b der Wert der ausgewählten Funktion (Standard ist 1600).

Und die Round () - Funktion ist eine pseudozufällige Permutation, die in jeder Runde angewendet wird. Die Anzahl der Runden "'nr'" wird aus den Werten von r und c berechnet. Die in jeder Runde ausgeführten Operationen stellen die folgende Funktion dar:

Round[b](A,RC)

{
 θ step
 for(int x=0; x<5; x++)
   C[x] = A[x,0] xor A[x,1] xor A[x,2] xor A[x,3] xor A[x,4];
 for(int x=0; x<5; x++)
   D[x] = C[x-1] xor rot(C[x+1],1);
 for(int x=0; x<5; x++)
   A[x,y] = A[x,y] xor D[x];
 ρ and π steps
 for(int x=0; x<5; x++)
   for(int y=0; y<5; y++)
     B[y,2*x+3*y] = rot(A[x,y], r[x,y]);
 χ step
 for(int x=0; x<5; x++)
   for(int y=0; y<5; y++)
     A[x,y] = B[x,y] xor ((not B[x+1,y]) and B[x+2,y]);
 ι step
 A[0,0] = A[0,0] xor RC
 return A
}


Es gibt 4 Schritte, in denen jeweils eine Reihe logischer Aktionen für die eingehenden Daten ausgeführt werden.

Hier bezeichnet die Funktion rot (X, n) die zyklische Verschiebung des x-Elements um n Positionen.

Das R [] -Array ist eine vordefinierte Menge von Werten, die angibt, wie viele Bytes in jeder Runde verschoben werden sollen:

SHA-3 Keccak) array RC

Ein RC-Array besteht aus einer Reihe von Konstanten, die ebenfalls vordefiniert sind:

SHA-3 Keccak) array r

Siehe auch[Bearbeiten]

Ressourcen[Bearbeiten]