IT-Security. Teil 16: Hash-Verfahren

Transkript

1 IT-Security Teil 16: Hash-Verfahren

2 Literatur [16-1] [16-2] [16-3] [16-4] [16-5] [16-6] 2

3 Übersicht Hash-Funktionen Geburtstagsangriff Beispiel: SHA-256 3

4 Definition Hash-Funktion I Hash-Funktion = Funktion h(x), für die folgendes gilt: Kompression: Abbildung eines beliebigen Bitstrings auf einen Ausgabewert mit einer festen in der Regel kurzen Länge. Dieser ist der Hash-Wert. Effizienz: Für jeden Eingabewert x lasst sich die Funktion h(x) mit geringem Aufwand berechnen. Das muss nicht umgekehrt gelten. Beispiele: Berechnung des Paritätsbits: Rechnernetze Cyclic Redundancy Check (CRC): Rechnernetze, Plattenblöcke Indizierung von Tabellen einer relationalen Datenbank Zugriff auf Symboltabellen innerhalb von Compilern 4

5 Definition Hash-Funktion II Kryptographische Hash-Funktion = Hash-Funktion h(x), für die zusätzlich noch folgendes gilt: Unbestimmbarkeit von Urbildern: Nur mit erheblichen Aufwand ist das x für ein gegebenes y bei y=h(x) zu bestimmen. Unbestimmbarkeit eines weiteren Urbildes: Nur mit erheblichen Aufwand ist für ein gegebenes x ein weiteres x' zu bestimmen, wobei h(x)=h(x') gilt. Kollisionsfreiheit (Collision Resistance): Nur mit erheblichen Aufwand sind zwei beliebige x und x' zu bestimmen, wobei h(x)=h(x') gilt. Der kryptographische Schutz basiert auf dem hohen Aufwand in den letzten drei Forderungen. Diese Asymmetrie in der Effizienz führt dazu, dass manchmal kryptographische Hash-Funktionen als One-Way-Verfahren bezeichnet werden. Siehe dazu: 5

6 Bemerkungen Kollision = Eine Kollision liegt vor, wenn derselbe Hash-Wert anhand verschiedener Urbilder erzeugt werden kann. Da das Urbild x (fast) immer größer ist als der Hash-Wert, z.b. 160 bit, sind Kollisionen prinzipiell nie zu vermeiden: Beispiel: Block von 1 kbyte: *8 Bit-Kombinationen werden auf Möglichkeiten abgebildet. Praktisch haben Kollisionen nur in wenigen Fällen Relevanz, da menschlich lesbare Texte, z. B. Verträge, nur eine sehr kleine Teilmenge aller Bitkombinationen benutzen. Der Schutz basiert auf dem hohen Aufwand in einem konkreten Fall eine Kollision zu erzeugen, nicht darauf, ob Kollisionen überhaupt möglich sind. 6

7 Struktur der Hash-Funktionen (Konzept) 7

8 Ergänzungen f() ist eine Kompressionsfunktion. Bitlänge des Hash-Wertes sollte mindestens 160 bit sein. Implementiert werden diese Funktionen, indem ein Register mit der Hash-Wertlänge (mind. 160 bit) in Schleifen (Runden) blockweise verknüpft wird: 8

9 Geburtstagsangriff I Idee Wie viele Personen müssen sich in einem Raum befinden, dass zwei Personen mit 50%iger Wahrscheinlichkeit am selben Tag Geburtstag haben? Antwort: 23 Allgemeiner: Wie viele Elemente müssen aus einer Menge mit n Elementen ausgewählt werden, damit mit einer Wahrscheinlichkeit 0,5 zwei identische gefunden werden? Antwort: Ca. Wurzel aus n Anders: Wie viele Texte müssen zufällig erstellt werden, damit zwei beliebige mit 50%iger Wahrscheinlichkeit denselben Hash- Wert besitzen? Bei einer Hash-Wertlänge von 160 bit: 2 80, was als nicht realisierbar gilt. 9

10 Wie verläuft der Geburtstagsangriff? 1. Es gibt zwei Nachrichten m 1 und m 2, wobei m 1 für den Angreifer schlecht und m 2 gut ist. 2. Der Angreifer variiert m 1 und m 2 - z. B. Einfügen von Blanks oder Zeichen, die mit einem nachfolgenden Backspace unsichtbar gemacht werden o.ä. - und bestimmt die Hash- Werte. 3. Nach durchschnittlich 2 r/2 Versuchen, wobei r die Länge des Hash-Wertes ist, hat der Angreifer zwei Variationen m 1 ' und m 2 ', gefunden, die denselben Hash-Wert besitzen. 4. Nun lässt der Angreifer m 1 ' unterschreiben. 5. Der Angreifer tauscht den unterschriebenen Text m 1 ' mit dem anderen Text m 2 ' aus... 10

11 Geburtstagsangriff II Was lehrt uns das? Der Unterschreibende sollte vor der Leistung der Unterschrift den Text kosmetisch, z.b. durch willkürliches Einfügen von Leerzeichen verändern. Das Besagte bezog sich auf ASCII-Texte (siehe Backspace etc.). Mit Textsystemen ist es noch schlimmer, da auf der Binärfile -Ebene "unsichtbar" Daten eingefügt werden können... Siehe dazu: 11

12 Einfache Hash-Funktionen Einfachstes Verfahren: H(m) = b 1 XOR b 2 XOR... XOR b n Blockweises Exclusiv-Oder aller Blöcke der Nachricht m Ergebnis: Einfache longitudinale Parität Nicht besonders sicher bzw. wirksam Anwendungsbeispiel: Feststellung von Bitkippern Verbesserung: 1. Hash-Register:=0 2. Für jeden n-bit-block: Verschiebung der Hash-Registers um 1 Bit nach links Register:= Register XOR Block Hohes Maß an Erkennung von Bitkippern Probleme beider Verfahren: Es lässt sich leicht eine andere Nachricht mit demselben Hash-Wert generieren. 12

13 Secure Hash Algorithm (SHA) Version Version SHA-0 (fehlerhaft) 1995 SHA SHA2-Varianten: SHA-256, SHA-384, SHA SHA SHA-3-Varianten: SHA3-224, SHA3-256, SHA3-384, SHA3-512 Sollten nicht benutzt werden Empfehlung Algorithmus Hash-Size Word-Size Block-Size Runden SHA SHA SHA SHA

14 SHA-256 Globaler Algorithmus func SHA-256(Message m) { Initial_HashArray(); while not End-of-Information(m) { M:= getnextblock(m); if last Block(M) { padding_block(m); MSG-Scheduling(M); Initial_Register(); MSG-Compression(); Hash-Value(); return H[0..7]; 14

15 SHA-256 Initialisierung des Hash-Arrays proc Initial_HashArray { H[0]:= 0x6a09e667; H[1]:= 0xbb67ae85; H[2]:= 0x3c6ef372; H[3]:= 0xa54ff53a; H[4]:= 0x510e527f; H[5]:= 0x9b05688c; H[6]:= 0x1f83d9ab; H[7]:= 0x5be0cd19; Initialisierung der ersten 8 32-Bit-Worte des Hash-Wertes in einem Array H[0..7] Die Werte sind die Stellen hinter dem Komma der 2.Wurzel aus den ersten 8 Primzahlen, jeweils als 32-bit-Werte. 15

16 SHA-256 Konstanten K Dann wird noch ein Array K[0..79] von 64 bit-konstanten benötigt. Diese Zahlen sind die Stellen hinter dem Komma der 3. Wurzel aus den ersten 80 Primzahlen. Quelle: NIST.FIPS

17 SHA Padding n*512 bit l bit k bit 64 bit Message 1 0 Length Eine 1 hinten anfügen Dann k-mal 0 anfügen, wobei l+k (mod 512); es wird das kleinste k benutzt Am Ende die Länge der Nachricht als 64 bit-wert 17

18 SHA Funktionen Name Funktion Ch() ch( x, y, z) = (x AND y) XOR ( (NOT x) AND z) Maj maj( x, y, z) = (x AND y) XOR (x AND z) XOR (y AND z) Σ 0 (x) BSIG0(x) = rotr(2,x) XOR rotr(13,x) XOR rotr(22,x) Σ 1 (x) σ 0 (x) σ 1 (x) BSIG1(x) = rotr(6,x) XOR rotr(11,x) XOR rotr(25,x) SSIG0(x) = rotr(7,x) XOR rotr(18,x) XOR shr(3,x) SSIG1(x) = rotr(17,x) XOR rotr(19,x) XOR shr(10,x) shr(n,x) Shift right x>>n rotr(n,x) Rotate right (x>>n) (x<<(w-n)) Das gilt für w=32 bit-worte 18

19 SHA-256 Nachricht M (n*512 bit) Bei jeder Bearbeitung eines Blocks wird das Array W gesetzt. Ein Block von 512 bit einer Nachricht wird als Array M[0..15] von jeweils 32 bit-worten dargestellt. M[0] sind daher die ersten 4 Bytes enthalten. Das Ganze im Big- Endian-Format. Der Block wird nun in das Array W[0..63] expandiert (Message Scheduling). Mit diesen W-Werten wird gearbeitet. Das Array W wird wie folgt gefüllt: proc MSG-Scheduling(Block M) { for j:= 0 to 15 { W[j]:= M[j]; for j:= 16 to 63 { W[j]:= SSIG1(W[j-2])+W[j-7]+SSIG0(W[j-15])+W[j-16]; + ist die normale 32 bit-addition 19

20 SHA-256 Kompressionsfunktion I A (H 0 ) B (H 1 ) C (H 2 ) D (H 3 ) E (H 4 ) F (H 5 ) G (H 6 ) H (H 7 ) (1x initialisiert) 1. Runde A B C D E F G H Die Register A bis H sind temporäre Variablen, die in jeder Runde überschrieben werden. Sie werden einmalig mit H[0..7] initialisiert. proc Initial_Register { A:= H[0]; B:= H[1]; C:= H[2]; D:= H[3]; E:= H[4]; F:= H[5]; G:= H[6]; H:= H[7]; 20

21 SHA-256 Kompressionsfunktion II proc MSG-Compression { for i:= 0 to 63 { T[0]:= H+BSIG1(E)+ch(E,F,G)+K[i]+W[i]; T[1]:= BSIG0(A)+maj(A,B,C); H:= G; G:= F; F:= E; E:= D+T[0]; D:= C; C:= B; B:= A; A:= T[0]+T[1]; Hier werden die 64 Runden unter Benutzung des Arrays W mit der Nachricht durchgeführt. In den Registern A bis H steht dann das Ergebnis. 21

22 SHA-256 Kompressionsfunktion III A B C D E F G H maj ch + K BSIG0 BSIG1 + T[1] W + + T[0] A B C D E F G H 22

23 SHA-256 Berechnung des Hash-Werts proc Hash-Value { H[0]:= A+H[0]; H[1]:= B+H[1]; H[2]:= C+H[2]; H[3]:= D+H[3]; H[4]:= E+H[4]; H[5]:= F+H[5]; H[6]:= G+H[6]; H[7]:= H+H[7]; Globaler Algorithmus func SHA-256(Message m) { Initial_HashArray(); while not End-of-Information(m) { M:= getnextblock(m); if last Block(M) { padding_block(m); MSG-Scheduling(M); Initial_Register(); MSG-Compression(); Hash-Value(); return H[0..7]; Die anderen Varianten von SHA2 arbeiten sehr ähnlich zu SHA

24 Empfehlungen Die Länge des Hash-Wertes sollte mindestens 256 bit sein, also sind folgende Verfahren zu empfehlen: SHA-256, SHA-384 und SHA-512 SHA3-256, SHA3-384 und SHA3-512 Langfristig sollte auf SHA3 umgestiegen werden. 24

25 Nach dieser Anstrengung etwas Entspannung... 25