Konstruktion von Hashfunktionen

Transcription

Diplomarbeit
Konstruktion von Hashfunktionen
Mohammed Meziani
Technische Universität Darmstadt
Fachbereich Informatik
Fachgebiet Theoretische Informatik – Kryptographie und Computeralgebra
angefertigt bei:
Prof. Dr. Johannes Buchmann
Betreut von:
Dipl.-Math. Erik Dahmen
13. August 2007
2
Selbstständigkeitserklärung
Hiermit erkläre ich, dass ich die vorliegende Diplomarbeit selbständig verfasst und
keine anderen Hilfsmittel als die angegebenen Quellen verwendet habe. Weiter erkläre
ich, die Diplomarbeit in gleicher oder ähnlicher Form keiner anderen Prüfungsbehörde
vorgelegt zu haben.
Darmstadt, den 13.08.2007
Mohammed Meziani
3
Danksagung
Ich möchte mich an dieser Stelle bei Herrn Prof. Dr. Johannes Buchmann für die
Vergabe des äußerst interessanten Diplomthemas bedanken. Dipl.-Math. Erik Dahmen möchte ich für die hilfreiche Betreuung und tatkräftige Unterstützung danken.
Weiterhin bedanke ich mich bei allen Personen, die mir durch ihre Unterstützung geholfen haben, diese Arbeit zu erstellen.
Ein besonders herzlicher Dank geht an meine Eltern, die mir dieses Studium finanziell
ermöglicht haben und mir während des gesamten Studiums hilfreich und unterstützend
zur Seite standen.
Mohammed Meziani
4
Inhaltsverzeichnis
1 Einleitung
10
1.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2 Struktur der Arbeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2 kryptographische Hashfunktionen und ihre Anwendungen
2.1 Hashfunktionen und Ihre Eigenschaften . . . . . . . . .
2.1.1 Definitionen . . . . . . . . . . . . . . . . . . . .
2.1.2 Eigenschaften von Hashfunktionen . . . . . . .
2.1.2.1 Allgemeine Eigenschaften . . . . . . .
2.1.2.2 Sicherheitseigenschaften . . . . . . . .
2.2 Generische Angriffe auf Hashfunktionen . . . . . . . . .
2.3 Anwendungen von Hashfunktionen . . . . . . . . . . .
2.3.1 Passwortschutz . . . . . . . . . . . . . . . . . .
2.3.2 Datenintegrität . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
12
12
12
13
14
14
16
17
17
18
3 Die Merkle-Damgård Konstruktion
3.1 Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2 Allgemeiner Aufbau . . . . . . . . . . . . . . . . . . . . . . . . .
3.2.1 Iterative Konstruktion . . . . . . . . . . . . . . . . . . .
3.2.2 Merkle-Damgård-Konstruktion . . . . . . . . . . . . . .
3.3 Schwächen vom MD-Konstruktion . . . . . . . . . . . . . . . . .
3.3.1 Länge-Verlängerung (Length Extension) . . . . . . . . .
3.3.2 Kollision bei Nachrichtenteilen (Partial-message-collision)
3.4 Angriffe auf die MD-Konstruktion . . . . . . . . . . . . . . . . .
3.4.1 Geburtstagsangriff . . . . . . . . . . . . . . . . . . . . .
3.4.2 Multikollision-Angriff (Joux-Angriff) . . . . . . . . . . .
3.4.3 Kelsey-Schneier 2nd -Preimage-Angriff . . . . . . . . . . .
3.4.3.1 Die Erzeugung von expandierbaren Nachrichten
3.4.3.2 Das Finden eines zweiten Urbildes . . . . . . .
3.4.4 Herding-Angriff . . . . . . . . . . . . . . . . . . . . . . .
3.5 Alternative Konstruktionen . . . . . . . . . . . . . . . . . . . .
3.5.1 Luks’s Konstruktionen . . . . . . . . . . . . . . . . . . .
3.5.1.1 Wide-Pipe-Hashfunktion . . . . . . . . . . . . .
3.5.1.2 Double-Pipe-Hashfunktion . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
19
19
19
19
21
25
25
26
27
27
30
34
34
36
36
40
40
40
42
5
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Inhaltsverzeichnis
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
47
49
52
52
56
60
4 Blockchiffren-basierte Hashfunktionen
4.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2 Grundlagen und Definitionen . . . . . . . . . . . . . . . .
4.3 Single-Block-Length Konstruktionen . . . . . . . . . . . .
4.3.1 Beispiele als Motivation . . . . . . . . . . . . . . .
4.3.1.1 Matyas-Meyer-Oseas-Verfahren . . . . . .
4.3.1.2 Davies-Meyer-Verfahren . . . . . . . . . .
4.3.1.3 Miyaguchi-Preenel-Verfahren . . . . . . .
4.3.2 Preneel-Govaets-Vandewalle-Konstruktionen (PGV)
4.3.2.1 PGV-Analyse . . . . . . . . . . . . . . . .
4.3.2.2 ICM-Analyse . . . . . . . . . . . . . . . .
4.3.2.2.1 Kollisionsresistenz . . . . . . . .
4.3.2.2.2 Preimage-Resistenz . . . . . . . .
4.3.2.2.3 2nd -Preimage-Resistenz . . . . . .
4.4 Double-Block-Length Konstruktionen . . . . . . . . . . . .
4.4.1 MDC-2 und MDC-4 . . . . . . . . . . . . . . . . .
4.4.2 Parallel Davies-Meyer (Parallel-DM) . . . . . . . .
4.4.3 Yi-Lam-Hash . . . . . . . . . . . . . . . . . . . . .
4.4.4 Nandi-Hash . . . . . . . . . . . . . . . . . . . . . .
4.4.5 Hirose-Hash . . . . . . . . . . . . . . . . . . . . . .
4.4.5.1 ROM-Konstruktion . . . . . . . . . . . . .
4.4.5.2 ICM-Konstruktion . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
65
65
66
70
71
71
72
74
74
76
79
85
89
89
91
91
93
95
97
100
101
106
3.6
3.5.2 3C und 3C-X Hashfunktionen . . . . . . .
3.5.3 Randomisiertes Hashing : RMX-Transform
Konkrete Beispiele . . . . . . . . . . . . . . . . .
3.6.1 MD-Hashfunktionen . . . . . . . . . . . .
3.6.2 SHA-Hashfunktionen . . . . . . . . . . . .
3.6.3 Tiger . . . . . . . . . . . . . . . . . . . . .
. .
.
. .
. .
. .
. .
.
.
.
.
.
.
.
.
.
.
.
.
5 Zusammenfassung
108
5.1 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
5.2 Ausblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
A Anhang
111
A.1 Grundlagen der Wahrscheinlichkeitstheorie . . . . . . . . . . . . . . . . 111
A.2 Geburtstagsangriff . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
Literaturverzeichnis
118
Index
124
6
Abbildungsverzeichnis
3.1
3.2
3.3
3.4
3.5
3.6
3.7
Die iterative Hashberechnung. . . . . . . . . .
Schematische Darstellung des Joux-Angriffs. .
Die Erstellung einer Diamantstruktur. . . . .
Die Wide-Pipe-Hashfunktion. . . . . . . . . .
Die Double-Pipe-Hashfunktion. . . . . . . . .
Die einfachste Variante der 3C-Hashfunktion.
Die Tiger-Kompressionsfunktion. . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
20
31
38
41
44
48
62
4.1
4.2
4.3
4.4
4.5
4.6
4.7
4.8
4.9
4.10
Die Matyas-Meyer-Oseas-Hashfunktion. . . . . . . .
Die Davies-Meyer-Hashfunktion. . . . . . . . . . . .
Die Miyaguchi-Preenel-Hashfunktion. . . . . . . . .
Schematische Darstellung der PGV-Konstruktionen.
Die MDC-2 Kompressionsfunktion. . . . . . . . . .
Die MDC-4 Kompressionsfunktion. . . . . . . . . .
Die Parallel Davies-Meyer-Hashfunktion. . . . . . .
Die Yi-Lam-Hashfunktion. . . . . . . . . . . . . . .
Die 1/3-Rate Nandi-Hashfunktion. . . . . . . . . .
Die Double-Length Hashfunktion von Hirose. . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
72
73
74
75
92
94
95
96
100
107
7
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Tabellenverzeichnis
3.1
Die Eigenschaften der SHA-2 Familie. . . . . . . . . . . . . . . . . . . . 57
4.1
4.2
4.3
4.4
4.5
4.6
4.7
4.8
4.9
PGV-Angriffe auf die 64 Konstruktionen. .
Die 12 sichere PGV-Hashfunktionen. . . .
Die 20 ICM-sichere PGV-Hashfunktionen. .
Methoden zur Konstruktion von Knoten und
Die
Die
Die
Die
Die
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
Kanten eines Graphs. . . . . .
Kollisionsresistenz der 20 PGV-Konstruktionen. . . . . . . . . . .
Preimage-Resistenz der 20 PGV-Konstruktionen. . . . . . . . . . .
2nd -Preimage-Resistenz der 20 PGV-Konstruktionen mit Plain-Pad.
2nd -Preimage-Resistenz der 20 PGV-Konstruktionen mit MD-Pad.
Sicherheistniveaus der 20 sicheren PGV-Konstruktionen. . . . . . .
8
78
78
80
85
90
90
90
90
91
Algorithmenverzeichnis
1
2
3
4
Multi-Geburtstagsangriff . .
2k -Kollisionsfinder . . . . . .
KaskadKollision(h, h0 , n, n0 )
FindeEineKollision(t, hin ) . .
.
.
.
.
.
.
.
.
.
.
.
.
5
6
SimulateOracles(A, n) . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
GraphDrawing(A, n) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
9
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
30
31
33
35
Kapitel 1
Einleitung
1.1 Motivation
Bei digital elektronischem Datenaustausch wird häufig über die digitale Unterschrift
(auch digitale Signatur) geredet, welche nicht als eine handgeschriebene Unterschrift
zu sehen ist. Man möchte damit ein Mittel gegen Verfälschungen haben. Vereinfacht
man unter einer digitalen Unterschrift eine Zahl, die im Zusammenhang mit einer
digitalen Nachricht ähnliche Eigenschaften aufweist wie eine Unterschrift von Hand
auf einem Dokument aus Papier.
In der Regel basieren die digitale Signaturen auf asymmetrischen Verfahren. Dabei
wird mit dem privaten Schlüssel unterschrieben und mit dem öffentlichen Schlüssel
die Signatur auf Echtheit überprüft. Grundsätzlich wird das Signatureverfahren immer auf die gesamte Nachricht angewendet, welche mit der dazugehörigen Signatur
zusammen geschickt wird. Bei grossen Nachrichten (mit einer grossen Bitlänge) werden die erzeugten Signaturen recht unhandlich, weil sie die gleiche Länge haben wie
die Nachricht selbst. Um dieses Problem zu umgehen, wird nie eine ganze Nachricht
signiert. Stattdessen wird aus der Nachricht eine Prüfsumme von übersichtlicher Länge
berechnet und nur diese signiert. Eine solche Prüfsumme wird anhand der sogenannten Hashfunktionen erzeugt. Eine Hashfunktion bildet aus einem Dokument beliebiger Länge einen Wert fester Länge, den sogenannten Hashwert (auch Hash-Wert). Die
Bezeichnung Hash stammt von dem altfranzösischen hachis für das Gehacktes beim
Metzger.
Mathematisch gesehen besitzt eine Hashfunktion einen unendlichen Definitionsbereich
(die Menge aller Dokumente) und einen endlichen Wertebereich. Das bedeutet, dass
die Eingabe und die Ausgabe eine unterschiedliche Mächtigkeit haben. Diese Eigenschaft stellt eine grosses Problem dar. Mehrere verschiedene Dokumente können den
gleichen Hashwert haben, Kollisionen genannt, und daher auch gleiche Signaturen,
was aber in kryptographischen Fälle zu unerwünschten Sicherheitsprobleme führt. Ein
bösartiger Partner kann in diesem Fall die Gelegenheit ausnutzen, für ein eigentliches
Dokument ein anderes erzeugen, dessen Hashwert mit dem eigentlichen übereinstimmt.
Mit anderen Worten soll eine ein-eindeutige Beziehung zwischen einer Nachricht und
10
Kapitel 1 Einleitung
ihrem Hashwert gegeben sein. Dies geschieht, wenn die Hashfunktion spezifischen Sicherheitseigenschaften aufweist.
Es gibt eine Menge von Hashfunktionen, welche sich in ihren Implementierungen
unterscheiden und jedoch in ihrem Design nach demselben theoretischen Prinzip,
Merkle-Damgård-Prinzip bezeichnet, konstruiert sind. Das Ziel dieser Arbeit ist es, das
Konzept zunächst der Konstruktion von Hashfunktionen nach dem Merkle-DamgårdPrinzip zu verdeutlichen und die darauf mögliche durchfürbaren Angriffe voruzustellen.
Als Anwendung solches Prinzips wird eine Klasse von Hashfunktionen vorgestellt und
untersucht.
1.2 Struktur der Arbeit
Die vorliegende Diplomarbeit ist folgendermaßen aufgebaut:
• Kapitel 2 gibt eine Einführung in Hashfunktionen, ihre Eigenschaften und ihre
Anwendungen.
• Kapitel 3 befasst sich zunächst mit dem Merkle-Damgård Designprinzip sowie
seinen Schwäche und die daraus neu entwickelten Angriffsmethoden. Danach
werden einige Alternative vorgestellt und diskutiert. Am Ende werden konkrete
Beispiele gegeben und ihre aktuellen Sicherheitszustände besprochen.
• Kapitel 4 stellt die auf Blockchiffren basierenden Hashfunktionen vor, welche
aus zwei wichtigen Kategorien bestehen, den Single und Double Block-Length
Hashfunktionen. Zu dem Single Block-Length Typ gehören besonders die PGVKonstruktion. Diese werden vorgestellt und auf ihre Sicherheit in zwei Sicherheitsmodelle, das Black-Box und das ideal Cipher Modell, hin untersucht. In
dem letzten Teil dieses Kapitels werden verschiedene Double Block-Length Hashfunktionen vorgestellt und ihre Sicherheit besprochen.
• Kapitel 5 gibt eine Zusammenfassung der vorliegenden Arbeit sowie einen Ausblick.
• Anhang gibt zunächst eine Einführung in die Wahrscheinlichkeitstheorie und
dann Beweise für einige Theoreme des dritten Kapitels.
11
Kapitel 2
kryptographische Hashfunktionen und
ihre Anwendungen
Bisher wurde nichts darüber gesagt, wie eine Hashfunktion konkret aussehen könnte.
Wie bereits im vorhergehenden Kapitel erwähnt, soll bei digitalen Signaturen praktisch unmöglich sein, eine zweite Nachricht zu erzeugen, für die diese Signatur ebenfalls gültig ist. Das impliziert, dass die Sicherheit einer digitalen Signatur immer von
der von der kryptographischen Stärke der verwendeten Hashfunktion abhängt. Diese
muss bestimmte Eigenschaften besitzen, welche auch zu anderen Verwendungszwecke
benötigt sind. In diesem Kapitel werden wir uns mit der wesentlichen Grundkriterien der Hashfunktionen sowie mit ihren aktuellen Anwendungen beschäftigen. Entlang
dieses Kapitels werden die folgende Bezeichnungen verwendet:
• X = {0, 1}∗ bezeichnet die Menge aller Bitstrings bzw. Nachrichten beliebiger
Länge.
• Y = {0, 1}n bezeichnet die Menge aller Bitstrings bzw. Nachrichten der Länge
n, wobei n eine natürliche Zahl ist.
2.1 Hashfunktionen und Ihre Eigenschaften
2.1.1 Definitionen
Definition 2.1 (Einwegfunktion (One-Way-Function))
Eine Einwegfunktion ist eine mathematische Funktion, deren Funktionswerte leicht“
”
berechenbar und deren Urbilder jedoch schwer“ sind .
”
In der Komplexitätstheorie sind die Begriffe leicht“ oder schwer“ berechenbar genau
”
”
erklärt. Unter leicht“ verteht man, dass zur Berechnung der Funktionswerte einen po”
lynomialen Aufwand benötigt wird . Als schwer bedeutet hier, dass kein Algorithmus
”
”
existiert, welcher in akzeptabler Zeit die Urbilder bestimmt.
12
Kapitel 2 kryptographische Hashfunktionen und ihre Anwendungen
Beispiele:
• In einem gedruckten Telefonbuch ist es sehr einfach, mit einem Namen die passende Telefonnummer herausfinden, da die Namen alphabetisch sortiert sind,
dagegen ist es nur sehr schwer möglich, zu einer Telefonnummer den passenden
Namen zu finden.
• In der Zahlentheorie stellt die Multiplikation großer Primzahlen eine Einwegfunktion dar. Es ist schwierig, eine Primfaktorzerlegung für eine vordefinierte
Zahl zu finden.
Definition 2.2 (Falltürfunktion (Trapdoor-Funktion))
Eine Falltürfunktion ist eine Einwegfunktion, deren Invserse mit Hilfe einer geheimen
Information relativ leicht zu ermitteln..
Beispiel: Die Quadrierungsfunktion x → x2 mod n mit n = p · q, wobei p und q
bekannt sind, ist eine Falltürfunktion. Die geheime Information hier ist die Kenntnis
der Zerlegung von n.
Die Einwegfunktionen sind also von der mathematischen Seite her die Grundlage für
Verschlüsselung und auch für die Nutzung von Hashfunktionen, die eine Basis für die
Anwendung von digitalen Signaturen sind.
Definition 2.3 (Hashfunktion)
Eine Hashfunktion h ist eine Funktion, die effizient zu einem gegebenen Bitstring x beliebiger Länge ein Bitstring y = h(x), Hashwert genannt, mit fester Länge (bezeichnet
mit n) berechnet (Komprimierung oder Kompression).
Mathematisch ausgedrückt sieht die Hashfunktion so aus:
h : X → Y : x → h(x) = y.
Der Komprimierunsvorgang führt dazu, diese Hashfunktion nicht injektiv ist. Es existieren zwei verschiedene Bitstring x0 und xaus X, deren Hashwerte übereinstimmen.
d.h h(x) = h(x0 ). Solche Bitstrings werden Kollisionen genannt, deren Zustandekommen theoretisch nicht auszuschließen ist. In der Praxis soll dies aber eine schwierige
Aufgabe sein. Deswegen soll die Hashfunktion so konstruiert, dass ein Ereignis der
Form {h(x) = h(x0 ) : x 6= x0 } mit einer geringer Wahrscheinlichkeit vorkommt.
2.1.2 Eigenschaften von Hashfunktionen
Eine Hashfunktion h ist eine Funktion, welche jedes Bitstring x mit beliebiger Länge
(x ∈ X) auf ein Bitstring h(x) mit fest vorgegebener Länge n abbildet (h(x) ∈ Y ).
13
Sie muss eine Reihe von Kriterien bzw. Eigenschaften erfüllen, damit sie in der Praxis
eingesetzt werden kann.
2.1.2.1 Allgemeine Eigenschaften
1. Effizienz:
Da eine Hashfunktion auf Bitstrings beliebiger Länge angewendet wird, darf der
Rechenaufwand in Abhängigkeit von der Länge dieser Bitstrings nicht zu stark
steigen. Das heißt, die Hashwerte müssen leicht und relativ schnell berechenbar
sein.
2. Zufälligkeit und Gleichverteilung:
Eine Hashfunktion soll sich wie eine echte“ Zufallsfunktion verhalten. Die er”
zeugte Hashwerte müssen zufällig und gleichmäßig verteilt über den Wertbereich
sein, d.h jeder mögliche Hashwert aus Y soll mit einer Wahrscheinlichkeit 1/2n
vorkommen. Für zwei ähnliche Bitstrings sollen sich völlig verschiedene Hashwerte ergeben werden. Sonst hätte ein Angreifer bei bestimmten Hashwerte, welche
öfter auftreten, eine günstige Gelegenheit, durch Raten und Probieren ein Urblid zum Hashwert zu ermitteln. Damit die Hashfunktion die GleichverteilungEigenschaft aufweist, soll sie den so genannten Avalanche-Effekt besitzen. Der
Avalanche-Effekt besagt, dass bei jeder Änderung der Eingabe sich durchschnittlich die Hälfte der Ausgabebits verändern [44, 63].
2.1.2.2 Sicherheitseigenschaften
Damit eine Hashfunktion in der Kryptographie als sicher gilt, muss sie noch zusätzliche
Eigenschaften bzw. Anforderungen erfüllen, die im Folgenden nach [44] dargestellt
werden. Betrachten wir eine Hashfunktion h : X → Y .
1. Einwegfunktion:
h heißt Einwegfunktion, wenn es rechnerisch unmöglich ist, zu einem gegebenen
Hashwert y, eine beliebiges Bitstring x zu finden, mit h(x) = y. Die Eigenschaft
wird auch als Preimage-Resistenz (preimage resistance) bezeichnet.
2. Schwache Kollisionsresistenz:
h wird als schwach kollisionsresistent bezeichnet, wenn es ebenfalls unmöglich
ist, zu einem vorgegebenen Bitstring x ein x0 , x 6= x0 , mit h(x) = h(x0 ) zu finden. Diese Eigenschaft wird auch zweite Preimage-Resistenz( 2nd -preimage
resistance) genannt. Im Gegensatz zur Einweg-Eigenschaft wird hier zusätzlich
zu einem Hashwert das entsprechende Bitstring vorgegeben.
3. Starke Kollisionsresistenz:
h heißt stark kollisionsresistent, wenn es praktisch unmöglich ist, zwei beliebige
14
Bitstrings x, x0 mit x 6= x0 zu finden, die denselben Hashwert haben, d.h h(x) =
h(x0 ). Diese Eigenschaft wird auch Kollisionsresistenz (collision resistance)
genannt.
Bemerkungen
1. Die starke Kollisionsresistenz kann auch wie folgt definiert werden:
h heißt stark kollisionsresistent, wenn h schwach kollisionsresistent für alle x ∈ X
ist. Damit stellt die schwache Kollisionsresistenz eine lokale Eigenschaft dar, im
Gegensatz zur globalen Eigenschaft der starken Kollisionsresistenz. Daraus folgt,
dass die starke Kollisionsresistenz die schwache Kollisionsresistenz impliziert.
2. Die schwache Kollisionsresistenz und die Einwegfunktion sehen zwar so ähnlich
aus, aber sie sind im allgemeinen unvergleichbar. Eine schwach kollisionsresistente Hashfunktion ist nicht notwendigerweise eine Einwegfunktion und umgekehrt.
Es gilt jedoch eine Implikation unter bestimmten Voraussetzung und zwar falls
jedes y ∈ Y mindestens zwei Urbilder aus X unter h besitzt und h schwach kollisionsresistent ist, dann ist h eine Einwegfunktion . Nehmen wir an, dass h keine
Einwegfunktion ist. Für eine h(x) ∈ Y mit x ∈ X existiert nicht ein x0 ∈ X, so
dass h(x0 ) = h(x) gilt. Da die Untermenge h−1 (h(x)) mindestens zwei Elemente
aus enthält, folgt daraus, dass die Wahrscheinlichkeit für x 6= x0 sehr groß ist.
Damit werden Kollisionen gebildet.
3. Neben der vorhergehenden Sicherheitseigenschaften wurde zusätzliche Kriterien
sowie ihre Zusammenhänge und Implikationen von Rogaway und Schripmton in
[60] ausführlich untersucht.
Definition 2.4 (kryptographische Hashfunktion)
Eine kryptographische Hashfunktion ist eine Einwegfunktion, die stark kollisionsresistent ist.
Namensgebung
Leider ist die Name kryptographische Hashfunktion“ in der Literatur unübersichtlich.
”
Es gibt unzählige Bezeichnungen, welche statt kryptographischer Hashfunktion verwendet werden. Einige davon sind folgende:
• Fingerprint,
• Data Integrity Check (DIC),
• Message Digest (MD),
• Manipulation Detection Code (MDC),
• Compression Function,
• Contraction Function.
15
2.2 Generische Angriffe auf Hashfunktionen
Nachdem wir uns mit der wichtigsten Eigenschaften von (kryptographischen) Hashfunktionen beschäftigt haben, fragen wir uns erst einmal, wie ein Angriff auf Hashfunktionen aussehen kann. Die Sicherheit einer Hashfunktion hängt vor allem von der
Länge der erzeugten Hashwert n. Ein zu kurzer Hashwert ermöglicht eine schnellere
Suche in Y und bietet keine Sicherheit. Wir wollen nur die Sicherheit einer Hashfunktion h im Bezug auf der drei Eigenschaften in Abhängigkeit von n untersuchen. Zu
diesem Zweck gehen wir davon aus, dass die Hashfunktion ideal“ ist. Ideal bedeutet
”
hier, dass die Hashfunktion alle bereits vorgestellten Eigenschaften erfüllt.Versuchen
wir also den Aufwand in Abhängigkeit von n abzuschätzen. Da jedes Btring x wird auf
einen zufällig gleichmäßig verteilten Hashwert abgebildet wird, folgt daraus, dass die
Wahrscheinlichkeit zu einem vorgegebenen y ein Bitstring x zu finden mit h(x) = y,
1/2n beträgt. Das heißt, es müssen mindestens 2n Bistrings aus X getestet werden,
damit die Einwegfunktion bzw. die schwach Kollisionsresistenz-Eigenschaft verletzt
wird. Bei der starken Kollisionsresistenz müssen zwei beliebige Bitstring gesucht werden, die denselben Hashwert liefern. Um den Aufwand in diesem Fall zu ermitteln,
wird den so genannten Geburtstagsangriff (Abs.3.4.1) benötigt, welchen wir im Kapitel 3 behandeln werden. Der besagt, dass zu Finden einer Kollision müssen mindestens
2n/2 Hashwerte geprüft werden.
Ein Angriff, welche zum Finden der Kollisionen bzw. Urbilder verwendet wird, heisst
ein Kollisionsangriff (Collision-Attack) bzw. ein Preimage-Angriff (Preimage-Attack).
Die beiden Angriffe lassen sich theoretisch mit dem Rohen-Gewalt-Angriff (Brute
Force-Angriff ) realisieren. Darunter versteht man das Ausprobieren aller möglichen
Kombinationen von Nachrichten, bis ein richtige Nachricht gefunden wurde. Solche
Angriffsmethode kann auf verschlüsselte Dateien, Nachrichten und Informationen oder
auch auf Passwörter angesetzt werden. Die Einfachheit dieser Angriffsmethode hat offensichtlich einen Nachteil: Die Durchführung ist rechen- und somit zeitaufwändig.
Definition 2.5 (Kollisionsangriff)
Eine Kollisionsangriff ist ein Angriff auf eine Hashfunktion h mit dem Ziel zwei Nachrichten x und x0 mit x0 6= x zu finden, die denselben Hashwert liefern. Formal heißt
das
Gesucht : x und x0 mit x0 6= x, so dass gilt : h(x0 ) = h(x).
Definition 2.6 (Preimage-Angriff)
Ein Preimage-Angriff ist ein Angriff auf eine Hashfunktion h mit dem Ziel zu einer
gegebenen Nachricht (preimage) eine weitere Nachricht zu finden, die den gleichen
16
Hashwert liefert. Formal heißt das
Gegeben : eine Nachricht x mit dazugehörigem Hashwert h(x).
Gesucht : x0 6= x, so dass gilt : h(x0 ) = h(x).
Die Preimage-Angriffe sind viel schwerer durchzuführen als Kollisionsangriffe. Bei idealen Hashfunktionen ist der Gesamtaufwand mit Preimage-Angriffe um den Faktor 2n/2
höher als mit Kollisionsangriffe.
In der Realität ist es tatsächlich noch nicht bewiesen, ob überhaupt ideale Hashfunktionen existieren. Das bedeutet nicht dass, es immer möglich ist, auf jeder beliebigen
Hashfunktion ein Kollisionsangriff bzw. ein Preimage durchzuführen. Es gibt nämlich
Hashfunktion, für die keine Kollisionen oder Urbilder erzeugt werden können. Die Widerstandsfähigkeit solcher Hashfunktionen gegen diese zwei Arten von Angriffe wird
durch das so genannte Sicherheitsniveau (security level) beschrieben, welches wir folgt
definiert ist.
Definition 2.7 (Sicherheitsniveau)
Das Sicherheitsniveau einer Hashfunktion ist die Anzahl der benötigten Berechnungen
bzw. Rechenoperationen, die zum Finden einer Kollision mit dem besten bekannten
Kollisionsangriff führen. Im kryptographischen Sinne wird dieser Begriff auch die Komplexität genannt.
Nach heutigem Stand der Sicherheit von Hashfunktionen bezeichnet die Zahl 280 das
minimale Sicherheitsniveau. Das bedeudet, dass der Hashwert einer Hashfunktion mindestens die Länge 160 Bit besitzen sollte.
2.3 Anwendungen von Hashfunktionen
Kryptographische Hashfunktionen kommen in vielen Bereichen der IT-Sicherheit zum
Einsatz. Wir wollen hier zwei wichtige Beispiele aus der Praxis vorstellen.
2.3.1 Passwortschutz
Bei passwortgeschützten Systemen werden die Hashfunktionen häufig eingesetzt. Jedes eingegebene Passwort wird zunächst unter Verwendung einer Hashfunktion gehasht und danach in einer bestimmten Passwortdatei des Systems gespeichert. Dank
der Einwegfunktion wird das Originalpasswort nicht mehr möglich wiederherzustellen.
Beim Einloggen wird das eingegebene Passwort abgebildet und mit dem gespeicherten
Hashwert verglichen. Sind diese gleich, so stimmen die Passwörter überein und wird
17
der Zugriff auf das System gestattet. Erhält ein Angreifer den Zugriff irgendwie auf die
Passwortdatei, so kann er trotzdem kein einziges Originalpasswort rekonstruieren. Ein
Beispiel für das Passwortschutz findet man in Standard-Linux-Distributionen, in denen
die Datei /etc/passwd die Liste aller Benutzernamen zusammen mit den Hashwerte
darstellt.
2.3.2 Datenintegrität
Unter Datenintegrität (auch Datenkonsistenz ) versteht man eine Sicherheitsmaßnahme, die dafür sorgt, dass Daten während der Übertragung vor Verlust sowie vor unautorisierter Modifikationen geschützt werden. Ein Angreifer, der sich zwischen zwei
kommunizierenden Partner befindet, könnte die übertragende Daten manipulieren wollen. Um festzustellen, dass die bei Empfänger eingetroffenen Daten unverändert sind,
kann eine Hashfunktion eingesetzt werden, indem zusätzlich zu Daten der Hashwert
über einen sicheren Kanal transportiert wird. Nach der Übertragung wird der Hashwert erneut berechnet und mit dem übermittelten Hashwert verglichen. Stimmen
diese überein, so wurden die Daten nicht verändert. Falls keinen sicheren Kanal vorliegt, dann muss der Hashwert zunächst mit einem Signatureverfahren signiert und
danach übermittelt werden. Wurde der signierte Hashwert manipuliert, so ist die Signatur ungültig. Ein Beispiel dafür ist der Download von Software, deren Hashwerte
bekannt sein oder veröffentlicht werden müssen. Das Ziel hier ist, sicherzustellen, die
Software nicht mit einem Virus verseucht wurde. Es gibt eine Menge von Software,
welche besonders zur Offline Sicherung der Datenintegrität entwickelt wurden. Ein
Beispiel ist die Software von der Firma Tripwire Inc.[80].
18
Kapitel 3
Die Merkle-Damgård Konstruktion
3.1 Einleitung
Die Konstruktion von Hashfunktionen ,welche alle im Kapitel 2 vorgestellten Anforderungen besitzen sollen, ist keine leichte Aufgabe. Ein schwieriger Teil dieser Aufgaben
besteht allerdings darin, dass sie auf beliebigen Eingabegrößen operieren sollen und
dabei ihre Eigenschaften nicht verlieren dürfen.
Weiterhin ist es schwierig, eine Hashfunktion auf eine bestimmte Eigenschaft zu untersuchen. Woher weiß man, dass eine Hashfunktion, die sicher kryptographisch erscheint,
auch wirklich sicher ist. Die einzige zurzeit verfügbare Methode ist, die Funktion zu
veröffentlichen und durch Kryptographen brechen zu lassen.
Um sichere Hashfunktionen einzubauen, Ivan Damgård [16]und Ralf Merkle[46, 45] haben ein Konstruktionsprinzip für die Erstellung sicherer Hashfunkktionen, unabhängig
voneinander im Jahr 1989 entdeckt und in CRYPTO’89 vorgestellt. Diese Vorgehensweise ist heute die Grundarchitektur beinahe aller Hashfunktionen. Die Grundidee
besteht darin, eine Hashfunktion für beliebig lange Eingaben dadurch zu realisieren,
dass man eine Funktion ,die so genannte ,,Kompressionsfunktion”, für Eingaben fester
Länge iteriert. Solche Hashfunktionen werden iterative Hashfunktionen gennant.
3.2 Allgemeiner Aufbau
3.2.1 Iterative Konstruktion
Für das Verständnis der iterativen Konstruktion von Hashfunktion brauchen wir
zunächst noch einiges an Grundlagen wie etwa das Konzept der Kompressionsfunktionen und ihre Anwendungen. Unter einer Kompressionsfunktion oder Komprimierungs-
19
Kapitel 3 Die Merkle-Damgård Konstruktion
funktion versteht man eine Funktion, die Bitstrings einer festen Länge auf Bitstrings
fester kürzerer Länge abbildet. Mathematisch ist sie wie folgt definiert :
f : {0, 1}m → {0, 1}n ,mit m > n ≥ 2.
Existiert so eine Funktion, bezeichnet mit f , so lässt sich die Hashberechnung nach
einer iterativen Methode durchführen. Diese erfolgt in drei Schritten, wie in der Abblidung 3.1 verdeutlicht und im Folgenden erklärt wird.
Abbildung 3.1: Die iterative Hashberechnung.
1. Vorbereitungsphase:
Jede Nachricht m wird in k Blöcke mi , i = 1 . . . k mit je b Bit geteilt. Falls
die Nachrichtlänge kein Vielfaches von b ist, dann müssen üblicherweise noch
zusätzlichen Bits an die Nachricht angehängt werden. Diese Bits werden PaddingBits gennant . Damit der Hashwert dieser Nachricht sich von anderen Hashwerte unterscheidet, wird oft ein zusätzlicher Block angehängt, welcher aus
der Binäredastellung der ursprünglichen Nachricht besteht. Diese Technick wird
als MD-strengthening [62, 44] bezeichnet.
20
2. Berechnungsphase:
Gegeben sei einen Initialwert h0 = IV. Nach der Vorbereitungsphase wird die
Nachricht blockweise bearbeitet. Jeder Block mi wird mit dem Ergebnis hi−1 der
vorhergehenden Iteration als Input für die Kompressionsfunktion f benutzt, um
das neue Zwischenergebnis hi zu bereschnen. Der ganze Ablauf sieht wie folgt
aus:
h0 = IV,
hi = f (hi−1 , mi ) , i = 1, . . . , t.
Wobei die Zahl t die Blöckeanzahl der Nachricht nach dem Paddingsvorgang
bezeichnet.
3. Ausgabetransformation:
Dieser Schritt wird optional, wenn der sich aus Berechnungsphase ergebende Hashwert die gewünschte Bitlänge besitzt. Wäre nicht der Fall, so soll eine Funktion
g auf diesen Hashwert angewendet werden. Diese wird eine Ausgabetransformation genannt. Der entgültige Hashwert ist damit h(m) = g(ht ).
3.2.2 Merkle-Damgård-Konstruktion
Eine konkrete Ausprägung der soeben vorgestellten iterativen Methode ist das MerkleDamgård-Desginprinzip, welches von Ivan Damgård [16] und Ralf Merkle[46, 45] im
Jahr 1998 unabhängig voneinander entdeckt wurde. Die Autoren haben jeweils eine
Methode zur Konstruktion von Hashfunktionen vorgeschlagen. Diese beiden Methoden sehen sehr ähnlich aus und basieren auf der Idee, aus einer kollisionsresistenten
Kompressionsfunktion eine kollisionsresistente Hashfunktion zu realisieren. Dies stellt
einen unschätzbaren Vorteil dar, weil das Problem der Suche nach sicheren Hashfunktionen auf der Suche nach sicheren Kompressionsfunktionen reduziert wird.
Die Merkle’s Methode, die sogenannte Metha-Methode, beschreibt die Konstruktion
und den Paddingsvorgang jeder Nachricht beliebiger Länge, während die Damgård’s
Methode zusätzlich einen Sicherheitsbeweis für die Konstruktion vorstellt.
Bei dem Merkle-Damgård-Desginprinzip wird eine Kompressionsfunktion verwendet,
die r Bits auf s Bit abbildet, mit r > s. Unter Annahme, dass diese Funktion kollisionsresistent ist, wird eine Hashfunktion realisiert, die jedes Bit-String beliebiger Länge auf
ein s-Bit-String abbildet, mit dem Ziel, dass diese Hashfunktion die Kollisionsresistenz
aufweist. Da dieses Desginprinzip sehr einfach und effizient ist, wird bei allen in der
Praxis eingesetzten Hashfunktionen angewendet. Die Merkle-Damgård-Konstruktion
ist wie folgt beschrieben.
21
Definition 3.1 (Merkle-Damgård Konstruktion)
Gegeben sei eine Kompressionsfunktion f : {0, 1}m → {0, 1}n , mit m > n. Jede
Nachricht m wird in Blöcke m1 , · · · , mk mit je (m − n) Bit aufgeteilt, nachdem ein
einziges Eins und genügend Nullen an die Nachricht anhängt wurden, damit die Länge
der Gesamtnachricht ein Vielfaches vom m − n wird. Der Letzte Block mk besteht aus
der binären Darstellung von der Länge der Originalnachricht. Bezeichnen wir mit h
die daraus entstehnde Hashfunktion. Diese wird dann wie folgt definiert:
h : {0, 1}∗ → {0, 1}n ,
wobei die Menge {0, 1}∗ aller Bit-Strings darstellt.
Sei h0 den Initialwert, mit h0 = 0n . Bezeichnen wir mit 0n das n-Bit Nullstring.
Die Hashwerterzeugung erfolgt durch einen iterativen Ablauf folgendermaßen:
h1 = f (0n ||m1 ),
hi = f (hi−1 ||mi ),
i = 2, 3, · · · , k.
Der endgültige Hashwert ist:
h(m) = hk .
Wie schon erwähnt, basiert die Sicherheit der MD-Konstruktion auf der Sicherheit der
verwendeten Kompressionsfunktion. Ist eine Kompressionsfunktion kollisionsresistent,
so muss auch die daraus enstehende Hashfunktion diese Eigenschaft besitzen. Diese
Behauptung wurde mathematisch zunächst von Damgård und Merkle [16, 46] und
dann später von von Xuejia Lai und James Massey [39] gezeigt.
Im Folgenden werden drei wichtigen Theorems vorgestellt, die den Zusammenhang
zwischen der Sicherheit einer Kompressionsfunktion und deren Hashfunktion erklären.
Theorem 3.1 (Merkle-Damgård-Paradigm)
Ist die in der Definition 3.1 vorgestellten Kompressionsfunktion f kollisionsresistent
und m − n ≥ 2, so ist die mit Merkle-Damgård-Methode konstruierte Hashfunktion
auch kollisionsresistent.
Beweis:
Mittels eines indirekten Beweis zeigen wir, dass die Kollisionsresistenz von f die Kollisionsresistenz von h impliziert.
Angenommen, dass ein Paar (m, m0 ) mit h(m) = h(m0 ) existiert.
Wir führen den Beweis per vollständige Induktion über die Anzahl der Blöcke k.
Seien m und m0 mit m 6= m0 . Dann sind zwei Fälle zu unterscheiden:
22
1. Falls m und m0 die gleiche Länge haben, d.h |m| = |m0 |.
• Induktionsanfang: Für k = 1 gilt:
h(m) = f (0n ||m1 )
= h(m0 ) ⇔ f (0n ||m1 ) = f (0n ||m01 ).
Wegen 0n ||m1 6= 0n ||m01 ist f nicht kollisionsresistent.
• Induktionsschritt:
• Induktionsvoraussetzung: Angenommen, dass die Eigenschaft bis Ordnung
k erfüllt ist.
• Induktionsschluss: Zeige, dass diese auch für k + 1 erfüllt ist.
Es gilt :
f (hi−1 ||mi ) = f (hi−1 ||m0i ), für alle 1 ≤ i ≤ k.
Daraus folgt:
m1 , · · · , mk = m01 , · · · , m0k .
Da m 6= m0 , dann muss gelten mk+1 6= m0k+1 .
Wegen h(m) = h(m0 ) folgt daraus:
f (hk+1 ||mk ) = f (hk+1 ||m0k ).
Dies steht im Widerspruch zur Voraussetzung, dass f kollisionsresistent ist, weil
(hk+1 ||mk ) 6= (hk+1 ||m0k ) gilt.
2. Falls |m| =
6 |m0 |. O.B.d.A. nehmen wir an, dass |m| < |m0 | ist.
Damit eine Kollision auftritt, soll es sich in der letzten Iteration der Kompressionsfunktion f denselben Hashwert ergeben.
Wegen |m| 6= |m0 | folgt daraus, dass die letzte Blöcke von m von m0 mit verschiedenen Anzahl der Padding-Bits aufgefüllt werden und somit unterscheidet
sich auch die jeweils letzten Blöcke, welche nur diese Anzahl darstellt.
Aus h(m) = h(m0 ) ergibt sich: f (hk+1 ||mk ) = f (hk+1 ||m0k ). Daraus folgt dass,
die Nachrichten hk+1 ||mk und hk+1 ||m0k eine Kollision für f bilden und somit ist
die Kompressionsfunktion nicht kollisionsresistent.
23
Ein ähnliches Ergebnis erzielte die Arbeit von Lai und Massey [39]. Die Autoren zeigten, wie die Sicherheit einer Kompressionsfunktion auf der Sicherheit der nach MDPrinzip gebauten Hashfunktion auswirkt. Dies wird im nachstehenden Theorem ohne
Beweis gegeben.
Theorem 3.2 (Lai-Massey)
Ist in der MD-Konstruktion ein Angriff auf die Kompressionsfunktion erfolgreich
durchführbar, so ist auch auf die daraus entstehende Hashfunktion.
Beweis: Siehe [39].
Aufbauend auf dem vorhergehenden Theorem wurde von Bart Preenel [56] ein anderes Theorem hergeleitet. Dabei wurde gezeigt, wie sich die 2nd -Preimage-ResistenzEigenschaft einer Kompressionsfunktion auf deren Hashfunktion und umgekehrt
übertragen lässt.
Theorem 3.3 (Lai-Massey-Preneel)
Angenommen, dass in jeder Nachricht, welche mindestens aus zwei Blöcke besteht,
ein MD-Strengthenning durchgeführt wird. Dann gilt: Das Finden eines zweiten Urbildes für die Hashfunktion h unter Verwendung eines festen Initialswertes IV mit dem
Aufwand 2n Hashberechnungen ist zum Finden eines zweiten Urbildes für Kompressionsfunktion f unter Verwendung eines willkürlich ausgewählten Zwischenhashwertes
hi−1 mit dem gleichen Aufwand äquivalent.
Beweis:
Im Folgenden wird o.B.d.A. angenommen, dass die Nachricht aus zwei Blöcke besteht.
⇒-Richtung: Seien m und m0 zwei Nachrichten mit h(m) = h(m0 ), wobei m0 ein zweites
Urbild darstellt.
Setze m = m1 ||m2 und m0 = m01 ||m02 . Dann ergeben sich die drei folgende Fälle:
{m1 = m01 } ∨ {m2 = m02 } ∨ {m1 = m01 ∧ m2 = m02 }.
Wegen h(m) = h(m0 ), folgt für diese Fälle daraus, dass das zweite Urblid für die Kompressionsfunktion in der letzten Iteration oder in einer Iteration mit einem bekannten
hi−1 gefunden wird.
⇐-Richtung: Um ein zweites Urblid für die Hashfunktion h zu finden,versucht man
ein zweites Urbildd für die Kompressionsfunktion zu produzieren. Dies wird erst nach
der Bearbeitung des ersten Nachrichtblock geschehen. Damit erhalten wir zwei Nachrichten m = m1 ||m2 und m0 = m01 ||m02 mit m2 6= m02 ,welche denselben Hashwert
erzeugen.
24
3.3 Schwächen vom MD-Konstruktion
Dank des Vorschlages von Merkle-Damgård wurde das Problem der Suche nach sicheren Hashfunktionen auf der Suche nach sicheren Kompressionsfunktionen eingeschränkt. Wenn die Kompressionsfunktion Anfälligkeiten gegen bestimmten Angriffe
aufweist, muss sie weiter nicht eingesetzt werden, auch wenn die Übertragung dieser
Angriffe auf die vollständige Hashfunktion nicht möglich ist.
Trotz vorteilhaften Auswirkungen des Paddingprozesses und des MD-StrengtheningAnsatzes, indem die Kollisionsresistenz der Hashfunktion verbessert wird, leiden fast
alle iterativ gebauten hashfunktionen an ernsthafter Schwäsche, die ausgenutzt werden
können, um möglicherweise eine Reihe von Angriffe durchzuführen.
Im Folgenden werden zwei Schwähen der MD-Konstruktion vorgestellt, die Length
Extension und Partial-message-collision-Eigenschaft [24]. Es wird jeweils zunächst die
Schwäche erläutert und danach erklärt, inwieweit ein Angriff der jeweiligen Schwäche
möglich ist und anschließend wird gezeigt, wie man diese umgehen kann.
3.3.1 Länge-Verlängerung (Length Extension)
Die Length-extension-Eigenschaft[24] ist einer der bekanntesten theoretischen Eigeschenschaft von fast allen nach MD-Prinzip gebauten Hashfunktionen. Diese hat gravierende Auswirkungen, wenn sie nicht beseitigt wird. Um zu erklären, was man
überhaupt unter eine Length-extension-Eigenschaft versteht, stellen wir das folgende Problem vor :
Sei eine Nachricht m, bestehend aus k Blöcken m1 , . . . , mk , mit dem Hashwert
H = h(m). Ausserdem wählen wir eine andere Nachricht m0 , bestehend aus k + 1
Blöcken, so dass die k ersten Blöcke mit der Nachricht m identisch sind. Somit gilt
m0 = m||mk+1 , wobei mk+1 ein zusätzlich an die Nachricht m gehängter Block ist. So
gilt die folgende Beziehung :
h(m0 ) = f (h(m), mk+1 )
Die Length-extension-Eigenschaft wird immer existieren , solange es keine spezielle
Verarbeitung am Ende der Hashfunktion geben würde. Die Konsequenz davon lautet,
dass der Hashwert h(m) eine nützliche Information über den Zwischenhashwert von
m0 nach den k ersten Blöcke der Nachricht m0 liefert. Jetzt stellt sich nur noch die
Frage, welche Auswirkung könnte überhaupt diese Eigenschaft auf eine Hashfunktion
haben ?. Dies werden wir nachfolgend erläutern.
25
Angenommen, wir haben eine Nachricht m, bestehend aus k − 1 Blöcken m1 , . . . , mk−1
mit Hashwert h(m). Kennt ein Angreifer den Hashwert und die Nachrichtlänge aber
nicht die Nachricht, so geht er wie folgt vor :
• Sind nur Nullen anstelle der binären Darstellung zu der Nachricht hinzugefügt,
erzeugt er zunächst einen Block mk und fügt dann ihn an die Nachricht. Weil es
bei meisten Hashfunktionen das MD-Strengthening benutzt wird, fügt er dazu
noch einen zweiten Block mk+1 , welcher aus der Binäredarstellung der Originalnachricht ensteht. Als nächstes betrachtet er eine neue Nachricht m0 = m||mk
und berechnet dann zwei Hashwerte folgendenmaßen:
h(m0 ) = h(h(m), mk+1 )
• Wüsste der Angreifer, dass im Voraus einen zusätlichen Block mk durch das MDStrengthening erzeugt wurde, so setzt er mk+1 = m||mk als neue Nachricht und
berechnet dann den Hashwert h(m, mk+1 ) und schickt ihn dem Emfänger. Wir
beachten hier, dass der Paddingvorgang zwei mal durchgeführt wurde, zunächst
durch MD-Stengthening und dann durch den Angreifer.
Da in beiden Fälle der Hashwert stimmt, kann der Emfänger diese Manipulation nicht
mehr entdecken.
3.3.2 Kollision bei Nachrichtenteilen (Partial-message-collision)
Das zweite Problem ist das sogenannte Partial-message-collision[24]. Wir erläutern
dieses an folgenden Beispiel: Gegeben sei ein Authentifikationssystem, mit dem sich
ein Benutzer mit der Nachricht h(m||x) bei einem Server authentifiziert, wobei jeweils
m die Benutzername und K der Authentifikationsschlüssel ist. Damit ein Angreifer
erfolgreich als legitimer Benutzer authentifiziert ist, findet er eine Nachricht m0 (z.B.
mit Geburtstagangriff), welche den Hashwert h(m) liefert, d.h h(m) = h(m0 ). Augrund
der iterativen Hashberechnung erfüllt jeder beliebige String K die folgende Gleichung:
h(m||K) = f (h(m)||K) = f (h(m0 )||K) = h(m0 ||K).
Auf diese Weise gelingt dem Angreifer, sich erfolgreich als legitimer Benutzer zu authentifizieren.
Zur Beseitigung dieser Schwachstellen haben Schneier und Fergusion haben [24] zwei
Lösungsmöglichkeiten [24] vorgestellt, welche Doppeltes Hashing (Double-Hashing) 1
Schemas gennant weden.
Die Idee besteht darin, dass ein zweimaliges Anwenden des Hashvorgangs auf eine
Nachricht alle Informationen über den internen Zustand der Hashfunktion zerstören
kann. Bei der ersten Möglichkeit wird zunächst den Hashwert h(m) der Nachricht m
1
Double Hashing wird in vielen literature als DHASH bezeichnet
26
berechnet und dann miteinander zusammenhängt und schliesslich darauf die Hashfunktion angewendet. Der endgültige Hashwert ist also h(h(m)||m) statt h(m), das
heisst die Hashfunktion
x → h(x) wird durch einfach x → h(h(x)||x) ersetzt.
Dieser Ansatz ist sehr zeitaufwendig, da man sowohl den Hashwert der Nachricht M
als auch das String h(m)||m berechnen muss. Zur Behebung des Problems steht eine
andere Lösung zu Verfügung. Anstelle der Hashfunktion x → h(x) verwendet man
x → h(h(x)), was aber den Nachteil hat, dass das Sicherheitsniveau der Hashfunktion
auf x → h(h(x)) reduziert wird. Aufgrund der hohen Wahrscheinlichkeit von Kollisionsangriffen, versucht man ein Kompromiss zwischen der Hashwertlänge und dem
gefordeten Sicherheitsniveau zu finden.
3.4 Angriffe auf die MD-Konstruktion
In der Kryptoanalyse von Hashfunktionen wurde stets versucht, effiziente Angriffe zu
entwickeln mit dem Ziel, die Kollisionsfestigkeit von der Kompressionfunktion und der
daraus enstehenden Hashfunktion zu verringern. Während der letzten Jahre wurden
im Allgemein nur Angriffe auf die meisten eingesetzten Hashfunktionen vorgestellt,
die nach MD-Prinzip gebaut sind. Aus diesem Grund wurde eine wichtige Frage von
Kryptoexperten gestellt, ob das MD-Prinzip überhaupt als geeignet zur Kontruktion
moderner Hashfunktionen gilt. Bevor wir uns mit einer Reihe von Angriffe auf die
MD-Konstruktion befassen, wollen wir zunächst den sogenannten Geburtstagsangriff
vorstellen, weil er für weiteren Angriffe nützlich ist.
3.4.1 Geburtstagsangriff
Der Geburtstagsangriff (Birthday Attack) ist ein generischer Angriff, der von dem sogenannten Geburtstagsparadoxproblem abgeleitet wurde, dem folgende Frage zugrunde
liegt: Wie viele Personen müssen in einem Raum sein, damit mindestens zwei Personen
mit einer Wahrscheinlichkeit grösser als 50 prozent am gleichen Tag Geburtstag haben?. Zwischen diesem Problem und Hashfunktionen besteht eine enge Beziehung und
zwar die Hashwerte können als Geburtstage aufgefasst werden und die zu haschende
Nachricht als Personen.
So lässt sich die Frage dahingehend umformulieren: Wie viele Nachrichten müssen
gehasht werden, damit man mindestens zwei Nachricht mit demselben Hashwert mit
einer Wahrscheinlichkeit grösser als 50 Prozent findet ?. Wird die Hashfunktion als
ein Blak-Box modelliert, indem keine Informationen über deren innere Struktur zur
27
Verfügung gestellt werden, so bestimmt dieser Angriff die benötigten Anfragen, die
von einem Angreifer an die Hashfunktion gesendet werden sollen, damit er mindestens
zwei Nachrichten mit demselben Hashwert mit einer signifikanten Wahrscheinlichekit
findet.
Der erste Geburtstagsangriff war vom Gideon Yuval[79] als eine Anwendung des Geburtstagsparadoxproblems in Hashfunktionen eingeführt. Dieser Angriff gibt die erwartete Anzahl der zu hashenden Nachrichten an, welche zu einem Preimage oder
einer Kollision führen. Bevor wir den Aufwand dieses Angriffs vorstellen, wollen wir
einige Begriffe geben.
Definition 3.2 (Kollision)
Eine Kollision für eine Hashfunktion h ist ein Paar von zwei verschiedenen Nachrichten m und m0 , die denselben Hashwert haben,d.h h(m) = h(m0 ).
Diese lässt sich nachfolgend verallgmeinern :
Definition 3.3 (k-Kollision)
Eine k-Kollision (auch k-Weg-Kollision) für eine Hashfunktion h sind k paarweise
verschiedene Bitsstrings m(1) , m(2) , . . . m(k) , die alle denselben Hashwert haben, d.h
h(m(1) ) = h(m(2) ) = . . . = h(m(k) ).
Ist k ≥ 3, so wird die k-Kollision als Multikollision bezeichnet.
Wir bezeichnen eine Hashfunktion h als k-kollisionsresistent, wenn sich eine k-Kollision
für h nicht berechnen lässt.
Definition 3.4 (Multiweg-Urbil (multi-way-preimage))
Ein k-Weg-Urbild für eine Hashfunktion sind k paarweise verschiedene Bitsstrings
m(1) , m(2) , . . . m(k) mit demselben vorgebebenen Hashwert. Für einen vorgegebenen
Hashwert h heisst das wie folgt:
h(m(i) ) = h(m(j) ) = h , ∀i 6= j mit i, j ∈ {1, 2, · · · , k}.
Ein Mutilweg-Urbil ist ein k-Weg-Urbild mit k ≥ 3.
Ist ein k-Weg-Urbild für eine Hashfunktion h nicht einfach zun finden,so ist h als
k-Weg-resistent bezeichnet.
Im folgendem wollen uns nun die Sicherheit einer Hashfunktion h gegenüber der Kollisionsresistenz und Preimage-Resistenz im sogenannten Zufallsorakelmodell (RandomOracle Modell) betrachten.
Definition 3.5 (Zufallsorakelmodell)
Ein Zufallsorakel (auch ideale Hashunktion gennant) stellt eine idealisierte Hashfunktion h dar, welche zufällig und gleichmäßig aus der Menge aller Hashfunktionen ausgewählt wird und deren Bescheibung überhaupt nicht bekannt ist und deren Ausgabe
28
h(x) für eine Eingabe x echt zufällig ist. Die einzige Möglichkeit h(x) zu bestimmen
ist das Orakel zu befragen.
Man kann ein Zufallsorakel also als ein Black-Box für die Hashfunktion h auffassen,
der die Hashfunktion auswertet.
Eine wichtiger weiterer Begriff zur Untersuchung der Effizienz von Algorithmen ist die
sogenannte die Ordnung (auch Notation). Unter Ordnung verteht man ist ein mathematisches Verfahren zur Einordnung der Komplexität von Funktionen in Abhängigkeit
von der Eingaben. Insgesamt gibt es drei Arten von Notationen, welche wir hier zusammenfasst geben wollen.
Definition 3.6 (Notation) Gegeben seien zwei positive f und g Funktionen.
1. O-Notation (big O-notation): Wir sagen f (n) ist O(g(n)) genau dann wenn
∃ C > 0 und eine eine natürliche Zahl N0 , so dass
f (n) ≤ C · g(n), ∀n ≥ N0 .
2. Ω-Notation (Ω-notation): Wir sagen f (n) ist Ω(g(n)) genau dann wenn
∃ C > 0 und eine eine natürliche Zahl N0 , so dass
f (n) ≥ C · g(n), ∀n ≥ N0 .
3. Θ-Notation (Θ-notation): Wir sagen f (n) ist Ω(g(n)) genau dann wenn
∃ C1 , C2 > 0 und eine eine natürliche Zahl N0 , so dass
C1 · g(n) ≤ f (n) ≤ C2 · g(n), ∀n ≥ N0 .
Unter der Bedingung, dass die Hashfunktion h ein Zufallsorakel darstellt, erhalten wir
die zwei folgenden Sätze, deren Beweise im Anhang A.2 gegeben sind.
Theorem 3.4 (Geburtstagangriff)
Ist die Hashfunktion durch ein Zufallsorakel modelliert, so beträgt die Anzahl der zu
haschenden Nachrichten mindestens 2n bzw. 2n/2 , um ein Urbild bzw eine Kollision zu
finden.
Beweis: Siehe A.2
Statt dessen hat MCkinney in [43] das Resultat verallgemeinert, indem er zeigte,
welcher Aufwand zum Finden einer k-Kollision erforderlich ist.
Theorem 3.5 (k-Kollision)
hashenden Nachrichten mindestens 2n(k−1)/k , um eine k-Kollision zu finden.
Beweis: Siehe A.2
29
Der folgende Algorithmus beschreibt abstrakt die Vorgehensweise zum Finden einer
k-Kollision für eine Hashfuntion h : D → W im Zufallsorakelmodell, wobei die Bezeichnungen D für den Definitionsbereich bzw. W für den Wertebereich stehen.
Algorithm 1 Multi-Geburtstagsangriff
1. Eingabe: Eine ideale Hashfunktion h und die Fragenanzahl t.
2. Berechnungen:
2.1. Wähle m1 , . . . , mt aus D zufällig aus .
2.2. Für i = 1 bis t berechne hi = h(mi )
3. Ausgabe: Falls es k-elementige Untermenge A aus {m1 , . . . , mt } existiert,
dann gib sie aus, Sonst keine k-Kollision gefunden.
3.4.2 Multikollision-Angriff (Joux-Angriff)
Der Multikollisionen-Angriff ist ein Angriff auf iterativen Hashfunktion, welcher von
Antoine Joux [32] erfunden und während des Workshops CRYPTO 2004 vorgestellt
wurde. In seinem Paper bewies er, dass in iterierende Hashfunktionen Multikollisionen
nicht viel schwerer zu finden sind als einfache Kollisionen . Anders ausgedrückt: wenn
man Kollisionen für die Hashfunktion (bzw. die Kompressionsfunktion) finden kann,
dann ist es sogar leicht, Multikollisionen für h zu erzeugen. Der Aufwand zum Finden
k
k
einer 2k -Kollision beträgt lediglich k × 2n/2 statt 2n((2 −1)/2 ) mit dem Geburtstagangriff.
Für den Joux-Angriff wird zunächst ein Kollionsfinder wie beispielsweise Geburtstagangriff vorausgesetzt, welcher bei der Eingabe von f und einem Zwischenhashwert hi
zwei verschiedene Blöcke x und x0 der Länge n als Ausgabe zurückliefert, welche eine
Kollision für die Kompressionsfunktion f erzeugen, d.h f (hi , x) = f (hi , x0 ).
Theorem 3.6 (Multikollision (Joux 2004))
Sei h eine Hashfunktion, welche nach dem MD-Prinzip konstruiert ist, deren zugrundeliegende Kompressionsfunktion als f bezeichnet. Dann zum Finden einer 2k -Kollision
für h werden etwa k × 2n/2 der Hashfunktionsaufrufe h erwartet, wobei n für die Hashwertlänge steht.
Beweis:
Wir geben den folgenden Algorithmus, welcher eine 2k -Kollision für f findet. Zu diesem
Zweck ist einen Kollionsfinder CF : {0, 1}n × {0, 1}r → {0, 1}n gegeben.
Wie die Abbildung 3.2 verdeutlicht, besteht die Idee des Multikollision-Algorithmus
darin, dass man k erfolgreiche Aufrufe vom Kollsionsfinder wie folgt durchführt:
30
Algorithm 2 2k -Kollisionsfinder
1. Eingabe: f, h, k und einen Kollisionfinder CF
2. Berechnungen:
2.1. Wähle einen Initialwert h0 aus.
2.2. Für j = 1 bis k
(mj0 , mj1 ) ← CF (h0 )
h0 ← f (h0 , mj )
3. Ausgabe: 2k verschiedenen Nachrichten der Form m1i ||m2i || . . . ||mki mit i ∈ {0, 1}.
• f (h0 , m1 ) = f (m0 , m01 ) , m1 6= m01
• f (f (h0 , m1 ), m2 ) = f (f (h0 , m01 ), m02 ) , m2 6= m02
..
..
..
..
•
.
.
.
.
• f (f (· · · , mk−1 ), mk ) = f (f (· · · , m0k−1 ), m0k ), mk 6= m0k
Abbildung 3.2: Schematische Darstellung des Joux-Angriffs.
Mit anderen Worten wird einen Kollionsfinder für alle 1 ≤ i ≤ k ausgeführt, um
mj 6= m0j zu finden, die die Gleichung f (hi−1 , mi ) = f (hi−1 , m0j ) erfüllen.
Wir erhalten damit
{x1 || · · · ||xk : xi ∈ {mi , m0i } , 1 ≤ i ≤ k} .
31
Diese bildet alle mögliche k-Kollisionen. Die Komplesxität des Angriffs lautet somit
O(k ∗ 2n/2 ).
Aus Algorithmus folgt, dass wir die Nachrichten der Form m1i ||m2i || . . . ||mki mit
i ∈ {0, 1} erhalten, die denselben Hashwert für h liefern:
h(m1 ||m2 || · · · ||mk ) = h(m01 ||m2 || · · · ||mk )
= h(m1 ||m02 || · · · ||mk )
.
..
..
..
= ..
.
.
.
0
0
= h(m1 ||m2 || · · · ||mk )
= h(m01 ||m02 || · · · ||m0k ).
Wegen i ∈ {0, 1} gibt es insgesamt 2k Kombinationen.
Eine besonders erstaunliche Anwendung des Joux-Multikollisionsangriffs findet man
bei den sogenannten Kaskadierten Hashfunktionen. Solche Hashfunktionen wurden
von Preneel [55](S.45) vorgeschlagen und dazu eingesetzt, um die Kollisionsresistenz
zu erhöhen. Ihre Implementierung erfolgt, indem man zwei unabhängig verschiedene
Hashfunktionen h und h0 nebeneinander verknüpft.
Zur Erzeugung des endgültigen Hashwert konkateniert man die Hashwerte von h und
h0 der Hashwertlänge n bzw. n0 miteinander. Dabei werden auch zwei unterschiedlichen Initialswerte IV bzw.IV 0 verwendet. Sei g die von h und h0 erzeugte kaskadierte
Hashfunktion. Wir definieren die Hashfunktion g dann als
g(m) = h(m)||h0 (m).
In [32] hat Antoine Joux auch gezeigt, dass solche Konstruktion von Hashfunktion keine zusätzliche Sicherheit gegen den Multikollisionsangriff bieten. Daher wurde es festgestellt, dass Multikollisionen nicht wirklich schwieriger zu finden sind als
gewöhnliche Kollisionen. Zum Finden einer Kollision werden deutlich wenige Aufrufe
benötigt,sofern eine der beiden Hashfunktionen h oder h0 eine iterierte Hashfuntion
ist.
Theorem 3.7 (Kaskadierte Hashfunktion)
Seien h und h0 zwei unabhängige Hashfunktionen, welche Hashwerte der Länge n bzw.
n0 erzeugen. Falls h oder h0 nach MD-Prinzip kontruiert ist, dann beträgt der Aufwand
32
0
zum Finden einer Kollision für g etwa O(n0 ∗ 2n/2 + 2n /2 ) Hashfunktionsaufrufe.
Beweis:
0
Sei O.B.d.A n ≤ n0 und k = n2 . Nach Anwendung des vorausgehenden Theorem
benötigt man zum Finden einer 2k -Kollision für h etwa n0 ∗ 2n/2 Rechenoperationen.
Nach dem Prinzip des Geburtstagangriffs erzeugt eine der soeben 2k erhaltenen Kollisionen eine für h0 , d.h das Auffinden einer Kollision für g = h||h0 erfordet insgesamt
0
etwa n0 ∗ 2n/2 + 2n /2 Rechenoperationen.
Der soeben durchgeführten Beweis kann zusammengefasst durch den Algorithmus 3
dargestellt werden.
Algorithm 3 KaskadKollision(h, h0 , n, n0 )
1. Eingabe: Zwei Hashfunktionen h, h0 , deren Hashwertlänge n bzw. n0 beträgt.
2. Berechnungen:
2.1. Führe den Algorithmus 2 für h aus, um eine 2k -Kollision für h zu finden.
2.2. Aus der 2k gefundenen Kollisionen suche nach zwei Nachrichten m und m0 ,
welche eine Kollision für h0 erzeugen.
3. Ausgabe: Die Nachrichten m und m0 bilden eine Kollision für die kaskadierte
Hashfunktion g = h||h0 .
Bemerkung 2.1:
• Wenn die Hashfunktionen h und h0 als Zufallsorakeln modelliert sind, dann
n
n0
benötigt das Finden einer Kollision für g etwa 2( 2 + 2 ) .
• Aus Theorem 3.7 kann man festsetllen, dass die Aneinanderkettung zweier Hashfunktionen gleicher Hashwertlänge keine ausreichende Sicherheit für die daraus
enstehende Hashfunktion bringt.
Dank des Mutlikollionsangriffs[32] lassen sich Multiweg-Urbilder effizient und erfolgreich ermiltteln. Zum Finden eines 2k -Weg-Urbildes für einer n-Bit-Hashfunktion sind
lediglich 2n statt 2k × 2n Rechenoperationen erforderlich. Zunächst findet man eine 2k Kollision und sucht dann nach einem Urblid, um diese Kollisionen zu zwingen, einen
bestimmten Zielpunkt zu erreichen.
Theorem 3.8 (Multiweg-Urblid)
Seien h eine n-Bit-Hashfunktion, welche nach dem MD-Prinzip gebaut ist. Für das
33
Finden eines 2k -Weg-Urbildes mit dem vorgegebenen Hashwert T wird lediglich ein
Aufwand von 2n Berechnungen benötigt.
Beweis:
Zunächst wird nach einer 2k -Kollision für h gesucht, indem man das Theorems 3.6
anwendet. Dabei beträgt der Aufwand 2k × 2n Hashberechnungen.
Bezeichne mit Z der sich ergebende Zwishenhashwert nach der Bearbeitung jedes k ten Nachrichtenblocks aller 2k Kollisionen. Die nächste Aufgabe ist es, einen Block m0
zu finden, welcher die Beziehung f (Z, m0 ) = T genügt. Das Auffinden solches Urblid
benötigt 2n Aurufe der Hashfunktion. Da Z ein gemeinsamer Hashwert der 2k -Kollision
ist, folgt nach Anwendung der Kompressionsfunktion f auf der Konkatenierung von
Z mit dem Block m0 daraus, dass der vorgegebene Hashwert erzielt wird. Somit wenn
k vernachlässigbar gegenüber 2n (k << 2n ) ist, dann ist der Gesamtaufwand ungefähr
k × 2n + 2n = O(2n ).
3.4.3 Kelsey-Schneier 2nd -Preimage-Angriff
Im Grundsätzlichen gilt eine Hashfunktion als sicher in Bezuf auf der PreimageResistenz, wenn das Auffinden von Urbilder und zweiten Urbilder für eine n-BitHashfunktion mindestens 2n Hashfunktionsaufrufe verlangt. In diesem Abschnitt wird
es gezeigt, dass solchen Aufwand reduziert werden kann. Dies wurde von Kelsey und
Schneier in [35] festgestellt. Sie haben gezeigt, dass zum Finden eines Preimages lediglich etwa k × 2n/2+1 + 2n−k+1 Hashberechnungen erforderlich sind, wobei k für die
Anzahl der Nachrichtenblöcke steht. Für die MD-Konstrunktion ist dies eine Herausforderung, da im Allgemein lange Nachrichten verwendet werden.
Der Angriff, auf welcher wir in diesem Abschnitt eingehen wollen, basiert auf dem
Begriff der sogenannten expandierbarer Nachrichten (engl. expandable messages).
3.4.3.1 Die Erzeugung von expandierbaren Nachrichten
Eine expandierbare Nachricht für eine Hashfunktion ist eine Menge von Nachrichten
unterschiedlicher Länge, die denselben Hashwert für h erzeugen, bevor der Paddingsprozess durchgefürt wird. Formal heisst das:
Definition 3.7 (expandierbare Nachricht)
Eine (α, β)-expandierbare Nachricht,mit α < β,ist eine Menge von β − α + 1 Nachrichten mit je α, α + 1, · · · , β Blöcke und die denselben Hashwert haben.
Expandierbare Nachricht können durch die sogennanten Fixpunkte ermittelt werden.
34
Unter einem Fixpunkt für eine Kompressionsfunktion f versteht man ein Nachrichtpaar (x, y), welches die folgende Beziehung erfüllt :
f (x, y) = y,
wobei x und y als ein Nachrichtenblock bzw.als ein Zwischenhashwert aufzufassen sind.
Im Folgenden zeigen wir, wie Fixpunkte dazu verwendet werden können, eine expandierbare Nachricht zu ermitteln, welche aus zwei Nachrichten besteht, die einen einzigen Block ( 1-Block ) bzw.t Blöcke (t-Blöcke) enthalten. Beide Nachrichten starten
von einen beliebigem Wert hin und erzeugen denselben Hashwert. Das Ganze erfolgt
durch die Durchführung des Algorithmus 4, welcher in [35] beschrieben wurde.
Algorithm 4 FindeEineKollision(t, hin )
1. Eingabe: t > 0, ein Startwert hin ∈ {0, 1}n .
2. Berechnungen:
2.1. Wähle zufällig einen Nachricthenblock q aus.
2.2. Setze htmp = hin .
2.3. Für = 0 bis t − 2 berechne htmp = f (htmp , q).
2.4. Erstelle zwei Listen A und B der Länge jeweils 2n/2 mit Hilfe von 2n/2 zufällig
ausgewählten Blöcke mi :
2.4.1. A [i] = f (h0 , mi ) für i = 0, · · · , 2n/2 − 1, wobei h0 der Initialwert.
2.4.2. B [i] = f (htmp , mi ) für i = 0, · · · , 2n/2 − 1.
2.5. Finde i, j, mit A [i] = B [j].
3. Ausgabe: Gebe die kollidierende Nachrichten (mi ||q||q|| · · · ||mj ) und A [i] aus.
Der Aufwand dieses Algorithmus hängt nur von dem Soll-Nachrichtenblock t und der
Hashwertlänge n ab und beträgt O(t−1+2n/2+1 ) Aufrufe der Kompressionsfunktion f .
Basierend auf diesem Algorithmus können expandierbare Nachrichten ziemlich effizient gefunden werden. Zunächst findet man 2n/2 Fixpunkte f (hi , mi ) = hi sowie
Nachrichtenpaare (h0i , m0i ),welches die Gleichung h0i = f (h0 , m0i ) erfüllt, wobei h0 für
den Intialwert der Hashfunktion h steht. Es ist klar, dass dies ungefähr 2n/2 Berechnungen benötigt . Unter diesen Nachrichten und mit einer guten Wahrscheinlichkeit
kann man zwei Indizes α und β bekommen, so dass h0α = h0β gilt. Auf diese Weise
erhalten wir eine (1, k)-expandierbare Nachricht(ohne den Paddingsvorgang), welche
aus der Nachrichten m0α und mβ wie folgt erzeugt und mit hm0α , mβ i bezeichnet wird:
hm0α , mβ i = m0α , m0α ||mβ , m0α ||mβ ||mβ , · · ·
35
3.4.3.2 Das Finden eines zweiten Urbildes
Wir gehen davon aus, dass ein Urbild einer langen Nachricht mtarget = m0 ||m1 || · · · ||mk
existiert, welches keine Paddingsbits enthält. Das Auffinden eines zweiten Urblides
erfolgt dann mithilfe von expandierbaren Nachrichten und verläuft algorithmisch wie
folgt:
1. Berechne für mtarget die ersten k Zwischenhashwerte hi für i = 0, · · · k.
2. Finde eine (1, k)-expandierbare Nachricht < α, β > und bezeichne mit hg ihren
gemeinsamen Hashwert.
3. Für zufällig ausgewählten Blöcke Bi wird f (hg , Bi ) solange berechnet, bis ein
Block Br gefunden wird, welcher die Bedingung f (hg , Br ) = hs für ein 1 ≤ s ≤ k
genügt .
4. Setze dann m0 = α|| β||β|| · · · ||β ||Br ||ms ||ms+1 || · · · ||mk .
{z
}
|
k-2
0
5. Die Nachricht m ist ein zweites Urbild, bevor sie auf derselben Weise wie mtarget
aufgefüllt wurde.
Wie wir sehen, liegt der Gesamtaufwand dieses Algorithmus bei O(2n/2+1 + 2n−log2 (t) )
Berechnungen für die Kompressionsfunktion f , da zur Erzeugung einer expandierbaren Nachricht etwa O(2n/2+1 ) benötigt, während das Finden nach einer Verbindung
zwischen den Zwischenhashwerte O(2n /k) kostet. Das besondere Interessante am Ergebnis ist, die erstaunliche Effizienz dieses Angriffs für ausreichend gross gewählt k im
Vergleich zum Brute-Force-Angriff, welcher O(2n ) Rechenoperationen benötigt.
3.4.4 Herding-Angriff
Der Herding-Angriff ist eine besondere Variante von Preimage-Angriffen, mithilfe derer Kelsey und Kohno eine andere geringfügige Schwäche in [33] von MD-Konstruktion
zeigten. Dieser Angriff basiert auf der so genannten Chosen-Target-Forced-Prefix
Preimage-Resistenz Eigenschaft ( eng. Chosen-Target-Forced-Prefix Perimage resistence(CTFP), welche wie folgt definiert ist.
Definition 3.8 (CTFP-Perimage-Resistenz)
Eine Hashfunktion h heisst Chosen-Target-Forced-Prefix Preimage-resistent , wenn es
schwer ist, zu einem gegebenen Nachrichtenpräfix P sowie Hashwert T ein Nachrichtensuffix S zu finden, so dass der Hashwert der Aneinanderkettung von P mit S mit
dem Hashwert T übereinstimmt. D.h h(P ||S) = T.
Die Herausforderung für den Angreifer besteht also darin, das ihm bereitgestellte Nachrichtenpräfix P zu zwingen, einen vorher ausgewählten Hashwert zu erreichen, indem
36
er ein Nachrichtensuffix ermitteln muss. Der Ablauf dieses Angriffs erfolgt in drei
Schritten. Zunächst erstellt der Angreifer eine so genannte Diamantstruktur und findet danach ein Linking-Nachrichtenblock, welcher als eine Verbindungstelle zwischen
dem gegebenen Präfix und einem Element der Diamanstruktur dient, um den SollHashwert zu erzielen . Schliesslich erzeugt er das gesuchte Suffix. Im Folgenden wollen
wir erläutern, wie das ganze Vorgehen abläuft.
• Erstellung einer Diamantstruktur:
Bei dieser Struktur handelt sich um ein Binärbaum2 , dessen Knoten Hashwerte
sind und dessen Kanten die Nachrichtenblöcke charakterisieren. Die Konstruktion solcher Struktur möchten wir zunächst anhand eines Beispieles erläutern,
welcher in der Abbildung 3.3 graphisch dargestellt ist und dann später eine verallgemeinerte Version geben. In unserem Beispiel startet der Angreifer zuerst mit
acht verschiedenen Nachrichtenblöcke m1 , · · · , m8 , deren Hashwerte verschieden
sind und mit h1 , · · · , h8 bezeichnet sind. Danach versucht er vier kollidierenden Hashwerte davon herauszufinden, die als Kindknoten der nächsten Stufe des
Baumes dienen. Erneut wiederholt der Angreifer diesen Vorgang für die vier Hashwerte und schliesslich für die zwei restlichen. Die daraus entstehende Struktur
bildet dann die so genannte Diamantstruktur, welche insgesamt aus 15 Knoten
besteht.
Verallgemeinert generiert der Angreifer zunächst 2k verschiedenen Hashwerte
aus 2k und findet daraus kollidierenden Paare, die dann zu 2k−1 neuen Hashwerte führen. Das Vorgehen wird solange wiederholt, bis der Angreifer den
Target-Hashwert erreicht. Insgesamt ergeben sich 2k+1 − 2 wischenregebnisee als
Strukturknoten.
• Das Finden einer Linking-Nachricht:
Wird einmal die Diamanstruktur konstruiert , so soll der Angreifer eine LinkingNachricht Mlink finden, welche das vorliegende Präfix mit einem Knot der Diamantstruktur vebindet. Nehmen wir an, dass 2k Startwerte (Hashwerte) generiert
und die Hashfunktion einen Hashwert der Länge n produziert. Als nächtes ermittelt der Angreifer aus 2n−k Nachrichten eine Nachricht S 0 , welche denselben
Hashwert eines Knotes der Diamantstruktur hat.
• Erzeugung des Suffixes:
Um das gesuchte Nachrichtensuffix zu erzeugen, geht der Angreifer folgendermaßen vor. Beginnend mit einem beliebigen Startknot, versucht er entlang des Baumes Nachrichtenblöcke (Kanten) zu finden, deren Hashwerte zu Target-Hashwert
führen. Dadurch entsteht das Suffix, indem er die gefundene Blöcke miteinander
konkateniert.
2
Als Binärbaum bezeichnet man in der Graphentheorie eine spezielle Form eines Graphen. Genauer gesagt handelt es sich um einen gewurzelten Baum, bei dem jeder Knoten höchstens zwei
Kindknoten besitzt.
37
Abbildung 3.3: Die Erstellung einer Diamantstruktur.
Wie wir wissen, benötigt das Auffinden von Urbilder normalerweise mehr als 2n Rechenoperation. Basierend auf der Idee des Herding-Angriffs Kelsey und Kohno haben
in [33] gezeigt, dass ein Aufwand vom O(2n−k−1 + 2(n+k)/2+2 ) benötigt wird, wenn das
vorliegende Präfix aus k + 1 Blöcke besteht. Dies erfolgt durch die Erzeugung einer
Diamantstruktur in etwa O(2(n+k)/2+2 ) sowie das Finden einer Linking-Nachricht in
etwa O(2n−k−1 ) der Kompressionsfunktionsaufrufe.
Theorem 3.9 (Herding-Angriff)
Sei h eine n-Bit-Hashfunktion. Der Aufwand des Herding-Angriffs beträgt etwa
O(2n−k + 2(n+k)/2+2 ) Kompressionsfunktionsaufrufe, wobei das Suffix aus k + 1 Blöcke
besteht.
Beweis: Der Beweis erfolgt in zwei Schritten:
• Bei der Erstellung einer Diamantstruktur werden in einer Stufe 2k Hashwerte als
Startwerte auf 2k−1 Hashwerte in der nächsten abgebildet. Das geschieht , indem
der Angreifer zunächst etwa 2(n+k+1)/2 Nachrichtenblöcke aus jedem Hashwert
aus 2k Möglichkeiten erzeugt und versucht dann , wie schon erwähnt, die kollidierende Hashwerte daraus zu finden. Um den Gesamtaufwand zu berechnen,
stellen wir die folgende intuitive Überlegung an: Wenn man 2(n+k+1)/2 Nachrichtenblöcke auf 2k Kanten verteilt, bekommt man 2(n+k+1)/2−k Blöcke pro eine
38
Kante und die Wahrscheinlichkeit, dass zwei Kanten davon kollidieren, ist etwa
((2(n+k+1)/2−k )2 /2n ) = 2−k+1 .. Daraus ergibt sich, dass etwa (2 = 21−k × 2k )
Hashwerte mit irgendeinem Hashwert kollidieren werden. Der gesamte Aufwand
in diesem Schritt ist daher etwa O(2(n+k)/2+2 ) Kompressionsfunktionsaufrufe.
• Zum Finden einer Linking-Nachricht werden 2n Nachrichten generiert, damit
ein Nachrichtblock geliefert wird, welcher als ein Anknüpfungspunkt zu einem
bestimmten Hashwert dient. Da die Diamantstruktur insgesamt über 2k+1 − 2
Konten verfügt (2k davon sind Startwerte), folgt daraus, dass man im Durchschnitt 2n−k−1 Nachrichten erzeuegen soll.
Das ganze Angriffssznerio benötigt den Aufwand O(2n−k−1 + 2(n+k)/2+2 ) von Kompressionsfunktionsaufrufe.
Bemerkung 2.2:
• Die hier vorgestellte Methode zur Erstellung einer Diamanstruktur ist besonders
ineffizient, wenn das gesuchte Suffix eine grossere Länge besitzt. Für längere Suffix setzt man eine elegante Variante ein, welche auf der Idee der expandierbaren
Nachrichten basiert und in [33] zu finden ist.
• Will man wissen, wie die Suffixlänge auszuwählen ist, damit sich ein maximaler bzw.einen minimaler Aufand des Herding-Angriffs , so betrachtet man die
Aufwandfunktion und sucht nach ihrer Extremstellen.
Definiere die Aufwandfunktion A als
A(k) = 2n−k−1 + 2(n+k)/2+2
Um eine Extremstelle zu bestimmen, muss man die erste Ableitung dieser Funktion bilden und gleich null setzen.
A0 (k) = ln(2) × (2(n+k+2)/2 − 2n−k−1 )
A0 (k) = 0 ⇔ 2(n+k+2)/2 = 2n−k−1
⇔ (n + k + 2)/2 = n − k − 1
n−4
.
⇔ k=
3
39
Der Aufwand an dieser Stelle ist gleich
n−4
n−4
n−4
= 2(n+ 3 +2)/2 − 2n− 3 −1
A
3
= 3 × 2(2n+1)/3 .
Aus diesem Ergebnis folgt daraus, dass der Gesamtaufwand für ein Suffix mit
n+1
Blockanzahl um den Faktor 2n/3 geringer als der Standardaufwand 2n ist.
3
3.5 Alternative Konstruktionen
Wegen der entdeckten Schwachpunkte im MD-Design und den daraus entstehenden
Angriffe sind für die Verbesserung der MD-Konstruktion in letzter Zeit verschiedenen
Ideen eingebracht. Die meistens davon basieren darauf, den Entwurf des Eingangs
bzw. des Ausgangs sowie die Innenstruktur der Kompressionsfunktion durch Einfügung
zusätzlicher Funktionen oder gebräuchlicher Operationen zu modifizieren, mit dem
Ziel, ideale und sichere Konstruktionen mit guten Gütekriterien zu realisieren.
In nachstehenden Abschnitte wollen wir auf einige wichtige Verbesserungsvorschläge
eingehen sowie ihre Sicherheit untersuchen. Weitere Vorschläge zur Verstärkung sowie
zur Idealiseirung des MD-Designs sind beispielerweise Prefix-free Merkle-Damgård [31],
Enveloped Merkle-Damgard (EMD-Transform)[5] und das Framework für iterativen
Hashfunktionen HAIFA [9].
3.5.1 Luks’s Konstruktionen
3.5.1.1 Wide-Pipe-Hashfunktion
Um die Sicherheit der MD-Konstruktion perfekt zu machen, schlug Stefan Lucks in
[40, 41] die sogenannte Wide-Pipe-Hashfunktion (engl.Wide-Pipe-Hashing) vor. Seine Grundidee besteht darin, die Bitlänge der inneren Struktur der Hashfunktion bei
MD-Design zu erhöhen, um die Anfälligkeit der MD-Struktur gegen den Joux Multikollisionsangriff zu beseitigen. Bei diesem neuen Design werden zwei Kompressionsfunktionen eingesetezt. Eine davon erzeugt Zwischenergebnisse grösser Länge w, welche
durch die restliche Kompressionsfunktion auf eine Bitlänge n abgebildet wird, wobei
n viel kleiner als w sein muss.
Wir bezeichnen mit hW P diese Hashfunktion 3 sowie mit f und g die zugrunde liegende
3
Wide-Pipe-Hashfunktion wird mit WPHF abgekürzt.
40
Kompressionsfunktionen, welche wie folgt definiert sind:
f : {0, 1}w × {0, 1}n → {0, 1}w
und
g : {0, 1}w → {0, 1}n .
Zur Hasherzeugung wird zunächst die Nachricht in Blöcke mi mit je n Bit eingeteilt.
Dann wird die erste Kompressionsfunktion f verwendet, welche Zwischenergebnisse einer Bitlänge w produziert, die ausreichend grösser als die Blocklänge n sein soll. Sinn
und Zweck des Einssetzens solcher Kompressionsfunktion liegt darin, das Zustandkommen innerer Kollisionen auszuschliessen. Um zu dem engültigen Hashwert zu kommen,
wird das Endeergebnis hk der Funktion f wiederum auf eine weitere Kompressionsfunktion g angewendet, welche die w Bit auf n Bit abbildet. Der formale Ablauf der
Hashberechnung mit der WP-Hashfunktion ist in der Abblidung 3.4 dargestellt und
sieht damit folgendermaßen aus:
Unter Verwendung eines Startwertes h0 ∈ {0, 1}w wird den Hashwert einer Nachricht
m = m1 ||m2 || · · · ||mk iterativ wie folgt berechnet:
h1 = f (h0 , m1 )
hi = f (hi−1 , mi ) für i = 2, 3, · · · , k
hW P (m) = g (hk ) .
Abbildung 3.4: Die Wide-Pipe-Hashfunktion.
Im Folgenden wollen wir die Sicherheit der WPHF im Zufallsorakelmodell untersuchen
und stellen dazu Theoreme und Beweise vor, die im Wesentlichen aus den Arbeiten
[40, 41] entnommen wurden. Zunächst möchten wir uns mit der Multikollisionsresistenz
beschäftigen und danach mit Multiweg-Preimage-Resistenz.
Theorem 3.10 (Wide-Pipe-Multikollision)
Sind die Kompressionsfunktionen f und g Zufallsorakeln , so benötigt das Auffinden
k
k
einer 2k -Kollision für die WPHF etwa min{k × 2w/2 , 2n(2 −1)/2 } Anfragen.
41
Beweis:
Hier wird die folgende Fallunterscheidung vorgenommen, in welcher berücksichtigt
wird, für welche der beiden Kompressionsfunktionen f oder g eine 2k -Kollision gefunden ist.
• 2k -Kollision für f : die Kompressionsfunktion f erzeugt eine Ausgabe der Länge
w. Daraus fogt nach Theorem 3.6 (Multikollision), dass das Finden einer 2k Kollision für f etwa k × 2w/2 Anfragen an f verlangt.
• 2k -Kollision für g : Nach Anwendung des Theorems 3.5 ergibt sich, dass etwa
k
k
2n(2 −1)/2 Anfragen benötigt werden, um eine 2k -Kollision für g zu finden.
o
n
w/2 n(2k −1)/2k
.
Daher beträgt der Gesamtaufwand für die WPHF min k × 2 , 2
Auf ähnliche Weise ergibt sich der Aufwand zum Auffinden eines Multiweg-Urblides
für die WPHF, unter Annahme, dass die verwendeten Kompressionsfunktionen als
Zufallsorakeln modelliert sind. Der Beweis des folgenden Therorems findet sich in [41].
Theorem 3.11 (Wide-Pipe-Multiweg-Urblid)
Sind f und g unabhängig voneinander als Zufallsorakeln modelliert, so zum Finden
• eines Urblides werden O(2n ) Anfragen an die WPHF benötigt.
• eines k-Weg-Urbildes sind O(min 2w/2 ) Anfragen an WPHF erforderlich.
• eines k-Weg-zewites Urbildes werden O(min 2w/2 , k × 2n ) Anfragen an die
WPHF benötigt.
Beweis: Siehe [41].
Es ist offensichtlich, dass die Erhöhung der Bitlänge w eine zusätzliche Sicherheit der
Hashfunktion gegen die Multiweg-Urbild-Angriffe bringt. Allerdings wird eine Laufzeit
grösser als 2w benötigt, so kann der Angreifer trotzdem den Joux-Angriff laufen lassen
und Nutzen aus der iterativen Struktur ziehen. Deswegen kann eine solche Hashfunktion mit solchem inneren Zustand (mit Bitlänge w) nicht als eine ideale Hashfunktion
eingeschätzt werden.
3.5.1.2 Double-Pipe-Hashfunktion
Aus der Gefährdung der Sicherheit von Wipe-Pipe-Hashfunktion durch den JouxMultikollisionsangriff und und das daraus resultierende Verhalten der Wipe-PipeHashfunktion als ideale Hashfunktion, ist es notwendig, den Baustein von WPHF
42
mit einem höhen Sicherheitsniveau auszustatten. Wie in [41] betont wurde, wird dies
erreicht, indem man w ≥ 2n auswählt. In [41] wurde darauf hingewiesen, dass notwendig (aber nicht ausreichend) ist, w ≥ 2n auszuwählen. Dies erfordert jedoch den
Aufbau neuer Kompressionsfunktion der Form
{0, 1}w × {0, 1}t → {0, 1}w .
Stattdessen schlug Stefan Lucks die Double-Pipe-Konstruktion vor, welche als eine
ausgedehnte Kompressionsfunktion aufzufassen ist, unter Verwendung einer Kompressionsfunktion der Form f : {0, 1}n × {0, 1}n+t → {0, 1}n mit t ≥ n, welche die one
single narrow-pipe-Kompressionsfunktion [41] genannt ist.
Bei der Double-Pipe-Hashfunktion, welche in der Abbildung 3.5 dargestellet wird, werden zwei Zwischenhashwerte gleichzeitig in jeder Iteration berechnet. Dabei sollen die
zwei Ausgabewerte zunächst miteinenander verkettet und dann in der nächten Iteration verwendet werden. Für den Algorithmus werden drei verschiedenen Initialswerte
IV1 ,IV2 und IV3 aus {0, 1}n benutzt.
Bezeichnen wir mit hDP die Double-Pipe-Hashfunktion 4 .Also für eine Nachricht
m = m1 ||m2 || · · · ||mk
erfolgt die Hashberechnung durch
h01 = f (IV1 , IV2 ||m1 )
h001 = f (IV2 , IV1 ||m1 )
und für i = 2, 3, · · · , k
h0i = f h0i−1 , h00i−1 ||mi
h00i = f h00i−1 , h0i−1 ||mi
und der entgültige Hashwert von m mit DPHF lautet
hDP (m) = f IV3 , h0k ||h00k ||0t−n .
4
die DPHF ist die Abkürzung von Doube-Pipe-Hashfunktion
43
Abbildung 3.5: Die Double-Pipe-Hashfunktion.
Wie man sieht, ist die Double-Pipe-Hashfunktion einerseits nur eine Variante der
Wide-Pipe-Hashfunktion , bei welcher jeder Zwischenhashwert hi−1 ∈ {0, 1}w durch
das Paare (h0i−1 , h00i−1 ) ∈ {0, 1}n × {0, 1}n ersetzt wird. Das heisst(w = 2n. In jeder
Iteration hängen die halbe Zwischenwerte h0i und h00i im Wesentlich von der vorherigen
h0i−1 und h00i−1 ab. Das ist sehr wichtig für die Sicherheit der DPHF. Anderseits beachtet man, dass diese Konstruktion zu einer Kaskadierung zweier Hashfunktion ausarten
würde, welche durch den Joux-Angriff gefährdet ist.
Anhand der Parameteranzahl, welche die Double-Pipe-Kompressionsfunktion in jeder
Iteration übernimmt, werden wir im Folgenden zwei neuen Begriffe von Kollisionen
definieren, damit wir die Sicherheit der DPHF analysieren können.
Definition 3.9 (Strikte Kollision)
Eine strikte Kollision (eng. strict collision) ist ein Paare von 3-Tupeln (h0 , h00 , m) und
(g 0 , g 00 , n) mit
h0 6= h00 , g 0 6= g 00 , und m 6= n,
so dass gilt
f (h0 , h00 ||m) = f (g 0 , g 00 ||n) und f (h00 , h0 ||m) = f (g 00 , g 0 ||n).
Definition 3.10 (Querkollision)
Eine Querkollsion ist ein 3-Tupel (h0 , h00 , m) mit h0 6= h00 so dass gilt
f (h0 , h00 ||m) = f (h00 , h0 ||m).
Eine Double-Pipe-Hashfunktion hDP heisst strikt kollisionsfrei (auch strikt kollisionsresistent bzw querkollisionsfrei (auch querkollisionsresistent falls es schwierig ist ,
eine strikte Kollision bwz. eine Querkollision für hDP zu finden ist.
Für die beiden Kollisionen in einem Zufallsorakelmodell ergibt sich das folgende Theoreme, welche aus der Arbeit [41] entnommen wurden. Zu diesem Zweck nehemen wir
44
an, dass das Finden strikter Kollisionen, Querkollisionen bzw. einer K-Kollision mindestens einen Zeitaufwand TS , TX bzw.T (K) benötigt.
Theorem 3.12 (Double-Pipe-Strikte -und Querkollision)
Falls die Kompressionsfunktion f als Zufallsorakel modelliert ist , dann wird zum
Finden
1. strikter Kollisionen eine Laufzeitskomplexität von TS = Ω(2n ) benötigt.
2. Querkollisionen eine Laufzeitskomplexität von TX = Ω(2n ) benötigt.
Beweis:
0
00
0
00
1. Sei (gi−1
, gi−1
, mi−1 ) einen 3-Tupel mit gi−1
6= gi−1
. Wählen wir eine Paare
2n
0 00
(gi , gi ) aus {0, 1} mit der Eigenschaft
0
00
00
0
gi0 = (gi−1
, gi−1
||mi−1 ) und gi00 = (gi−1
, gi−1
||mi−1 ).
Dieses Paare ist zufällig gleichverteilt 2n-Bit-Hashwert und unabhängig von allen
Werte der Form f (·, ·||·).
Sendet der Angreifer q zufällig verschiedene 3-Tupeln an den Orakel, so ist die
Erfolgwahrscheinlichkeit gleich
P
1
2n
× 22n
= q(q+1)
0≤j≤q j/2
2
Wegen
q(q+1)
2
×
1
22n
2
= 12 . 2q2n +
q
22n
≥
q2
22n
∈ Ω(q 2 /22n )
Damit diese Wahrscheinlichkeit sehr hoch wird, ist es ausreichend q = 2n zu
nehmen. Das heisst, um eine strikte Kollision zu finden, werden TS = Ω(2n )
Anfragen an Orakel benötigt.
00
0
, mi ) ist Querkollision falls
, gi−1
2. jeder 3-Tupel (gi−1
00
0
6= gi−1
gi−1
und
0
00
00
0
f (gi−1
, gi−1
||mi ) = f (gi−1
, gi−1
||mi )
erfüllt ist.
0
00
Da jedes Paare (gi−1
, gi−1
) zufällig gleichverteilt in der Menge {0, 1}2n ist, folgt
daraus, dass die Wahrscheinlichkeit des Zustandkommens einer Querkollision
0
00
0
00
(gi−1
, gi−1
, mi ) ist 2n /22n = 2−n , wobei gi−1
6= gi−1
und daher erwartet man
n
TX = Ω(2 ) Anfragen um eine Querkollision zu bekommen.
45
Nun wollen wir auf die Multikollisionsresistenz eingehen. Dazu brauchen wir das folgende Lemma.
Lemma
Wählt der Angreifer selber die zwei Intitialwerte h00 und h000 mit h00 6= h000 aus, so gelten
die folgenden Aussagen:
1. Jede innere Kollision für hDP führen entweder auf eine strikte Kollision oder
auf eine Querkollision zurück.
2. Zum Auffinden einer k-Kollision benötigt den Angreifer eine Laufzeitskomplexität von Ω(min {TX , TS , T (k)}).
Beweis:
1. Wegen h00 6= h000 liefert das Zustandkommen einer nicht-strikten Kollision einen
3-Tupel (h0i−1 , h00i−1 , mi ) mit
h0i−1 = h00i−1 , i ≥ 2.
Also es existiert ein j ≤ i − 2, welche die folgende Beziehung genügt
h0j 6= h00j , h0j+1 = (h0j , h00j , mj+1 ) = (h00j , h0j , mj+1 ) = h00j+1 .
Dies besagt, dass (h0j , h00j , mj+1 ) eine Querkollision ist und daher ist bewiesen,
dass eine nicht-strikte Kollision zu der Existenz einer Querkollision führt.
2. Eine k-Kollision für hDP ensteht daraus, wenn entweder eine finale k-Kollision
5
oder eine inneren Kollision vorkommt.
Nach voausgehender Behauptung, reduziert sich jede innere Kollision entweder
auf eine strikte Kollision oder auf Querkollion. Dies benötigt einen Zeitaufwand
von Ω(min {TX , TS , T (k)}). Darüber hinaus beträgt der Aufwand zum Finden
einer finale k-Kollision Ω(T (k)). Am Schluss ensteht einen Gesamtaufwand von
Ω(min {TX , TS , T (k)}).
Nach Anwendung von Theorems 3.8 und dem vorausgehenden Lemma erhalten wir
das nachstehende Resultat
Theorem 3.13 (Double-Pipe-Multikollision)
Sei eine DP-Hashfunktion. Falls zugrundeliegende Kompressionsfunktion f als ein Zufallsorakel modelliert ist und dem Angreifer die Auswahl zweier verschiedenen Intitialwerte h00 und h000 zur Verfügung gestellt worden sind, zum Auffinden einer k-Kollision
für hDP sind Ω(2n(k−1)/k ) Berechnungen von f erforderlich.
5
Unter finale Kollision versteht man eine Kollision, welche in der letzten Iteration für die Kompressionsfunktion aufftrit.
46
Die Analyse der DP-Hashfunktion bezüglich der (2nd ) Preimage-Resistenz kann so
ähnlich wie bei der Wipe-Pipe-Hashfunktion durchgeführt werden. Dabei ergibt sich
das folgende Theorem
Theorem 3.14 (Double-Pipe-Multiweg-Urbild)
Betrachte eine DP-Hashfunktion hDP , deren zugrundeliegende Kompressionsfunktion f als ein Zufallsorakel modelliert ist. Für einen Angreifer, der selber einen h0
auswählen kann, wird eine Ω(2n ) zum Finden eines Multiweg- bzw. eines 2nd -MultiwegUrbildes verlangt.
Als Fazit können wir sagen, dass im Zufallsorakelmodell die DP-Hashfunktion asymptotisch genauso sicher wie die Wide-Pipe-Hashfunktion mit w = 2n ist.
3.5.2 3C und 3C-X Hashfunktionen
Auf der Konferenz ACISP 2006 schlug Praveen Gauravaram et al. [52] die
3C-Hashfunktion und ihre erweiterte Version 3C-X vor. Sie ist eine Modifikation sowie eine Verbesserungsvariante der MD-Konstruktion. Das Ziel des Vorschlages ist es,
eine neuen Designentwurf zu realisieren, welcher nicht von dem Design der meist eingesetzten Hashfunktionen wie MD5 und SHA1 abweicht und gegen die neu endeckten
Angriffsstrategieen [77, 8, 73] resistent ist.
Die Konstruktionsidee ist auf den Arbeiten [3],[4] von Bellare, Canetti und Krawczyk basiert. Ein großer Vorteil dieser Konstruktion ist die Tatsache, dass jedes
Software, dessen Struktur bereits eine MD-Konstruktion enthält, kann auch die 3CKonstrunktion einsetzen, ohne die vorliegende MD-Kompressionsfunktion zu modifizieren. Im Folgenden wird die einfachste Variante der 3C-Hashfunktion vorgestellt und
besprochen, welche sich nicht viel von der in [52] vorgestellten Version unterscheidet.
Die Benennung 3C (3 Compression) stammt grundsätztlich von der Tatsache, dass
die Bearbeitung einer beliebigen Nachricht nach drei Ausführungen der Kompressionsfunktion durchgeführt wird. Das geschieht, wie die Abbildung 3.6 verdeutlicht,
zuerst für den Nachrichtenblocks mi , danach für den aufgefüllten Block P AD(ui ) (MDstrengthening) und schließlich für die Zwischenhastwerte hi und hi+1 . Am Ende jeder
Iteration ergeben sich zwei Werte hi und zi−1 , die bei letzten Durchlauf des Verfahrens
kombiniert werden müssen, bevor den endgültigen Hashwert ausgegeben wird.
Der Verlauf der 3C-Hashberechnung kann wie folgt formal beschrieben werden. Für
eine Nachricht m, bestehende aus k Blöcke ,m1 , m2 || · · · , mk mit je s Bit definieren
wir den folgende Paddingvorgang
47
P ad(x) = x|| 0||0|| · · · 0
| {z }
s−|x|
dann wird den Hashwert folgendermassen berechnet:
h1 = f (h0 , m1 )
u0 = h1
hi = f (hi−1 , mi ) für i = 2, 3, · · · , k
ui−1 = f (ui−2 , P ad (hi )) für i = 2, 3, · · · , k
hk+1 = (hk , P ad (uk−1 ))
h (m) = hk+1
Abbildung 3.6: Die einfachste Variante der 3C-Hashfunktion.
Im Vergleich zu der 3C-Hashfunktion wird bei der erweiterten Version 3C-X eine XOROperation anstelle die Kompressionsfunktion f eingeführt. Dabei ist es das Ziel, die
Performance der 3C-Hashfunktion zu verbessern. Dies geschieht, indem das PaddingVerfahren der ui eliminiert wird, aber nicht in der letzten Iteration, bevor den Hashwert
ausgegeben wird. Nach Praveen Gauravaram et al. gilt diese Modifikation als die einfachste Konstruktion, die man durch die MD-Konstrunktion erhalten kann, ohne auf
mehr Forderungen in Bezug auf der Performance zu bestehen.
Analog zu der MD-Konstruktion (Abs. 3.2.2) wurde gezeigt, dass Kollisionsresistenz
der Kompressionsfunktion die Kollisionsresistenz der Hashfunktion impliziert. Dies
wird als bewiesenes Theorem in in [52] gegeben.
Was die Sicherheit angeht, werden die beide Konstruktionen in [52, 54] auf Anfälligkeit
gegen drei Sicherheitseigenschfaten getestet , zunächst gegen die sogenannte MultiBlock-Kollision ( Multi-Block-Collision -MBC) [77, 8, 73], dann gegen
48
Joux-Multikollision [32] und schliesslich gegen die 2nd -Preimage Kollision sowie die
Length-Extension (Abs. 3.3.1, S.25). Die Analyse kam zu dem Ergebnis, dass diese
beide Schemas nicht besser als das ursprüngliche MD-Design sind, sowohl bezüglich der
MBC-Resisentenz [77, 8, 73] als auch der Multikollisionsresistenz [32]. Im Gegensatz
dazu bieten aber die beide Konstruktionen, aufgrund einer dreimaligen Anwendung
der Kompressionsfunktion, eine beweisbare Sicherheit gegen die restlichen Angriffe .
Was die Performance betrifft, ist die 3C viel weniger aufwändig als die
MD-Konstruktion, vor allem wenn sie zum Hashen kurzer Nachrichten eingesetzt wird.
Um einen Block beispielsweise (bzw. zwei Blöcke) zu bearbeiten, ist der Zeitaufwand
doppelt zu gross (bzw. dreihalb mal so gross vielfach ) wie bei MD-Konstruktion.
3.5.3 Randomisiertes Hashing : RMX-Transform
Unter dem randomisierten Hashing [28] oder auch RMX-Transform versteht man ein
Hashverfahren, in dem die zu haschende Nachricht randomiesert wird. Vereinfacht gesagt: die Nachricht wird ein zufälliger Charakter verliehen. Das dahinter stehende Ziel
ist die Erhöhung der Sicherheit der iterativen Hashfunktionen im Rahmen der digitalen Signatur gegen die Kollisionsangriffe, ohne die Änderung der Strukturen sowie
der Implementierung der Hash-und Signarture-Algorithmen vorzunehmen. Der Randomisierungsvorgang einer Nachricht wird durch zufälligen Parametern (random seeds)
gesteuert, indem jeden Nachrichtenblock mit einem zufällig generierten Strings durch
XOR-Operation veknüpft, selbst wenn die Hashfunktion nicht randomisiert wird.
Sei eine Nachricht m, welche in Blöcke der Bitlänge L eingeteilt ist und keine PaddingBits beinhält
m = m1 |m2 || · · · ||mk .
Der Verlauf der Hashberechnung erfolgt in zwei Schritten und sieht algorithmisch
folgendermassen aus :
1. Erzeugung von zwei Zufallszahlen r1 und r2
a) Generiere eine L-Bit Zuffalszahl r1
b) Falls |mk | kleiner als L, dann schneide die (|mk |) niedrigsten Bits von r1 ab
und setze sie als r2 ein.
2. Hashwertberechnung
a) h1 = f (h0 , r1 ), wobei h0 der Initialwert ist
b) hi = f (hi−1 , mi−1 ⊕ r1 ) für i = 2, 3, · · · , k − 1.
c) hk = f (hk−1 , mk ⊕ r2 )
49
d) Setze h (m) = hk als den endgültige Hashwert.
Ausführlich beschrieben wird bei dem randomisierten Hashalgorithmus zunächst die
RMX-Transform-Funktion gebildet. Zu diesem Zweck werden zwei Zahlen r1 und r2
generiert, welche die Länge L beziehungsweise |mk | haben, mithilfe deren eine neue
Zufallszahl r konstruiert wird, indem zunächst die Zahl r1 (k − 1)-mal mit sich selbst
konkateniert und dann mit der Zahl r2 verknüpft. Formal heisst das:
r = r1 ||r1 || · · · ||r1 ||r2 .
{z
}
|
k−1
Der nächste Schritt besteht darin, dass die Zufallszahl r zuerst einmal mit der Nachricht m blockenweise durch die XOR-Operation verknüpft werden soll. Diese Vorgehensweise bildet die sogennante die RMX-Transform-Funktion, welche mathematisch
wie folgt definiert ist:
RM X(r1, m1 |m2 || · · · ||mk ) = r1 ||r1 ⊕ m1 ||r1 ⊕ m2 || · · · ||r1 ⊕ mk−1 ||r2 ⊕ mk
Auf das daraus entstehende Ergebnis wird die Kompressionsfunktion angewendet, um
es iterativ und blockenweise zu bearbeiten. Wollen wir das soeben vorgestellte randomisierte Hashing durch eine Funktion hr1 charakterisieren, so können wir diese formal
auf folgende Weise definieren:
hr1 (m) = h(r1 ||r1 ⊕ m1 ||r1 ⊕ m2 || · · · ||r1 ⊕ mk−1 ||r2 ⊕ mk )
,wobei h für die aus f erzeugte Hashfunktion steht.
Der wichtigste Vorteil von Anwendung solcher Transformation (RMX) ist, dass die
resultierende digitalen Signature unabhängig von der off-line-Kollisionsresistenz der
verwendeteten Hashfunktion ist. Das bedeutet, dass die Sicherheit der digitalen Signature garantiert wird, selbst wenn off-line Kollisionen der Hashfunktion vorliegen.
Dies wird gewährleistet, indem die Zahl r1 vor Unbefügten geheim gehalten wird, welche zum Verifizieren des Hashwerts der Nachtricht erforderlich ist.
Eine besondere Eigenschaft bei einer RMX-Tranform-Hashfunktion hr , wobei r eine Zufallszahl, 6 ist die sogennante Enhancend Target Collision Resistance (eTCR),
welche eine Erweiterung der Target-Kollisionsresistanz -Eigenschaft (Target Collision
6
In der Kryptologie nennt solche Zufallszahl auch ein Salt-Wert. Darunter versteht (engl. für Salz)
eine Reihe von (typischerweise mindestens 12) zufälligen Bits, die als Teil der Eingabe einer SaltedHash-Funktion benutzt werden. Durch die Verwendung eines Salz-Wertes ist ein unverschlüsselter
Wert nicht mehr eindeutig einem verschlüsselten Wert zuzuordnen.
50
Resistance (TCR))ist. Die TCR-Hashfunktion wurden am Anfang in [50] als universelle Einweghashfunktionen (Universal one-way hash functions in bekannt und dann
später von Bellare und Rogaway in [7] umbenannt und eingeführt.
Definition 3.11 (Target-Kollisionsresistenz)
Sei S eine Indexmenge. Eine Familie von Hashfunktionen (hs )s∈S heisst
Target-Kollisionsresistent, wenn es einen effizienten Angreifer A gibt, der das folgende
Spiel mit einer vernachlässigbaren Wahrscheinlichkeit gewinnt :
1. A wählt eine Nachricht m
2. A bekommt eine zufällig ausgewählte s ∈ S
3. A muss eine Nachricht m0 6= m finden, so dass hs (m) = hs (m0 ) erfüllt ist.
Liegt eine TCR-Hashfunktion vor, so kann eine sichere digitale Signature einer Nachricht m auf folgende Weise erstellt werden. Zunächst generiert der Signer einen zufälligen
Salt-Wert r und berechnet dann den Hashwert hr (m). Anschließend unterzeichnet er
sowohl die Zahl r als auch die Nachricht (r||hr (m)) unter Verwendung eines bestimmten Signatureverfahren SIGN . Das Paare (SIGN (r), SIGN ((r||hr (m)))) stellt die
digitale Signatur der Nachricht m dar. Diese Verfahrensweise ist manchmal vergebens,
wenn sie beispielerweise mit dem RSA-Signatureverfahren verwendet wird, da das Signieren von r zur Änderung der Datenverschlüsselung wie PKCS#1 führt.
Um das Problem zu vermeiden, wurden die Enhancend Target-Kollisionsresistent Hashfunktionen eingeführt (eTCR), welche die Sicherheit der darauf basierenden Signature
gewährleistet, wenn lediglich den Hashwert hr (m) ohne r signiert wird.
Definition 3.12 (Enhancend Target-Kollisionsresistenz)
Sei S eine Indexmenge . Eine Familie von Hashfunktionen (hs )s∈S heisst Enhancend
Target-Kollisionsresistent wenn es einen effizienten Angreifer A gibt, der das folgende
Spiel mit einer vernachlässigbaren Wahrscheinlichkeit gewinnt :
1. A wählt eine Nachricht m aus
2. A bekommt eine zufällig ausgewählte s ∈ S
3. A muss eine Nachricht m0 und eine s0 ∈ S mit (s, m) 6= (s0 , m0 ) finden, so dass
hs (m) = hs0 (m0 )
In [28] gezeigt, ist die Hashfunktion h 2nd -Preimage-resistent, so ist das daraus resultirende RMX-Transfom eTCR-Kollisionsresistent. Den Beweis dafür findet man in [28].
Bemerkung 2.3:
51
In [65] wurde eine ähnliche Konstruktion vorgeschlagen. Die Grundidee besteht darin,
anhand von einer TCR-Kompressionsfunktion eine TCR-Hashfunktion zu implementieren.Diese Konstruktion sieht wie folgt aus:
Zunächst wird eine Nachricht m in k Blöcke mit je t Bit zerlegt, dann wird eine
dlog(k)e-elementige Menge B definiert
B = b1 , b2 , · · · , bdlog(k)e
Darüber hinaus wird einen Salt-Wert der Länge t zufällig ausgewählt. Mit Hilfe einer
Kompressionsfunktion f wird den Hashwert folgendermassen erzeugt:
• Für i = 1, 2, · · · , k
– Wähle zufällig ein Element bji aus B
– Berechne hi = f (hi−1 ⊕ bji , mi ⊕ r),
wobei man für h0 wieder einen Intialwert vorgeben muss.
3.6 Konkrete Beispiele
3.6.1 MD-Hashfunktionen
Die derzeit weltweit am häufig implementierten Hashfunktionen gehören zu MD4Familie. Sie basieren alle auf dem Merkle-Damgård Designprinzip, welches in Abschnitt
3.2.2 beschrieben wurde. Ihre Kompressionsfunktionen entsprechen einem Ad-HocDesign, das nicht auf andere Bausteine der Kryptpgraphie wie Blockchiffren baut.
Diese Familie enthält eine Menge von Hashfunktionen, welche im Folgenden genauer
beschrieben werden. Diese Beschreibung orientiert sich an Standards ISO/IEC 101183 und FIPS 180-2. Bei Darstellung solcher Hashfunktionen werden wir die folgende
Bezeichnungen und Defintionen verwenden:
Ausdruck
word
x+y
x⊕y
x∧y
¬x
x << s
x >> s
x||y
Bedeutung
Ein Bit-string, welche aus 32 Bits besteht
Addition modulo 232 oder 264 (abhängig von der Hashfunktion)
Bitweises ODER von x und y
Bitweises exklusives Oder von x und y
Negation bzw. das bitweise Komplement von x
Die Linke Shift-Operation von x um s Positionen
Die rechte Shift-Operation von x um s Positionen
Aneinanderkettung von x und y
52
MD4
1. Beschreibung
Die MD4-Hashfunktion [58] (eng. Message Digest 4) dokumentiert in RFC 1320,
wurde 1990 von Ronald L. Rivest veröffentlicht. Sie ist darauf ausgelegt, auf 32
bit Rechnern möglichst effektiv zu laufen. MD4 arbeitet mit 512 Bit Blöcken,
die wie folgt erzeugt werden:
1. Schritt (Padding-Bits)
Die Länge der Nachricht wird zunächst mit 1 bis 512 Bits so erweitert, dass sie
zu 448 modulo 29 kongruent ist. Das heisst, die Nachricht besitzt eine Länge,
welche vielfach von 512 minus 64 (448) ist. Die Füllbits, die zu Erweiterung verwendet werden, sind wie folgt angehängt: Das erste Bit ist “1” gefolgt von Nullen.
2. Schritt (Längenpadding)
Ein 64-Bit-String mit führenden Nullen wird angehängt, welcher die binäre Darstellung der Nachricht vor dem Padding enthält.
3. Schritt (Initialisierung des MD-Speichers)
Es wird ein 4 32-Wort-Puffer (A, B, C, D), welche wie folgt mit hexadezimalen
Werten initialisiert sind:
word A : 01 23 45 67
word B : 89 ab cd ef
word C : f e dc ba 98
word D : 76 54 32 10
4. Schritt (Verarbeitung der Nachricht)
Die Nachricht wird in Blöcke mit je 512 Bit eingeteilt, die mit dem Speicher
verknüpft und nacheinander mithilfe von folgenden Grundfunktionen in drei
Runden verarbeitet sind, wobei die vier Teile des Speichers 16 Mal permutiert
werden.
f (x, y, z) = (x ∧ y) ∨ (¬(x)z)
g (x, y, z) = (x ∧ y) ∨ (x ∧ z) ∨ (y ∧ z)
h (x, y, z) = x ⊕ y ⊕ z
Bezeichne mit m = m1 ||m2 || · · · ||mt eine Nachricht der Bitlänge L = 512.t.
Sei mi einen Block, welcher in 16 Wörter (words) zerlegt wird. Das heisst
mi = mi [0] || · · · ||mi [15]
53
Der erste Block m1 wird dann in drei Runden wie folgt verarbeitet:
• Erste Runde: In dieser Runde wird mit [abcd r
s] die Operation
a = (a + f (b, c, d) + m1 [r]) << s
bezeichnet. Dann werden die folgende 16 Operationen nacheinander verrichtet
[ABCD 0 3] , [DABC 1 7] , [CDAB 2 11] , [BCDA 3 19]
• Zweite Runde: In dieser Runde wird eine andere Operation ausgeführt,die
wieder mit [abcd r s] bezeichnet und wie folgt definiert ist:
a = (a + g(b, c, d) + m1 [r] + K1 ) << s
,wobei das Wort K1 = 5A827999 eine Konstante im Hexadezimal-System
dargestellt wird. Wir führen dann die folgende Operationen
aus.
• Dritte Runde: Wir bezeichen mit [abcd k
s] die folgende Operation
a = (a + h(b, c, d) + m1 [r] + K2 ) << s,
wobei K2 = 6ED9EBA1 eine Konstante in Hexadezimal-System. Dann
werden die nachstehende Operationen ausgeführt:
[ABCD 3 3] , [DABC 11 9] , [CDAB 7 11] , [BCDA 15 15] .
54
Um den zweiten Block m2 zu verabeiten, werden zunächst die vier SpeicherWerte (A, B, C, D) mit den folgenden Werten überschrieben
A = A + AA
B = B + BB
C = C + CC
D = D + DD
und danach startet man mit der ersten Runde, und so weiter, werden alle restlichen Blöcke bearbeitet.
4. Schritt (Hashwertaugabe)
Der ausgegebene Hashwert ist die Konkatenierung der letzten 32-Bit Wörter
(128 Bit) im Speicher (A, B, C, D):
M D4(m) = A||B||C||D.
Es wurde eine erweiterte Version vorgeschlagen, welche Extended-MD4 genannt
wurde. Diese Version erzeugt einen Hashwert der Länge 256 bit und und besitzt eine Kompressionsfunktion, deren Struktur aus zwei parallel geschalteten
Strängen der MD4-Kompressionsfunktion besteht, das heisst 6 Runden.
2. Sicherheit
Im Jahr 1991 untersuchten Boer und Bosselaers und Merkle [18] die MD4Hashfunktion und fanden Kollision für die Kompressionsfunktion. Fünf Jahre
später beschrieb Hans Dobbertin [19] eine effiziente Methode, wie Kollisionen
für die MD4 mit Hilfe eines einfachen Computer (kein Superrechner) in weniger
als einer Minute gefunden werden können. Acht Jahr später und in Cryto 2004
stellte ein chinesisches Wissenschaftlerteam einen Angriff [71] vor, der sich teilweise von Hand durchführen lässt . Dieser Angriff kann eine Kollision mit einer
Wahrscheinlichkeit zwischen 1/26 und 1/28 und lediglich mit einer Komplexität
von 28 Hashberechnungen und daher galt MD4 als gebrochen und sollte nicht
mehr eingesetzt werden.
MD5
Im April 1992 stellte Rivest mit dem RFC 1321 MD5 [59], eine verstärkte Variante
von MD4 (auch 128 bit Hashwert ) vor, an welcher Veränderungen lediglich im Verarbeitungsschritt vorgenommen wurden. Die wesentlichen Unterschiede zwichen MD4
und MD5 sind:
55
1. MD5 hat eine vierte Runde, in welcher eine eine neue Funktionen l verwendet
wurde.
l (x, y, z) = y ⊕ (x ⊕ ¬z)
2. In der zweiten Runde wurde die Funktion g durch die Funktion
g (x, y, z) = (x ∧ z) ∨ (y ∧ ¬z)
ersetzt.
3. Statt zwei (In Runde 2 und 3) wurden 64 Konstanten (16 Konstanten pro Runde)
in MD5 vewendet, basierend auf dem ganzahligen Teil von 232 |sin(j)|, wobei
1 ≤ j ≤ 64. Das heisst die ersten 32Bit der Binäredarstellung von |sin(j)|,
1 ≤ j ≤ 64.
4. Übernahme des Ergebnis der vorhergehenden Operation in jeden der insgesamt
64 Operationen.
Obwohl die MD5-Hashfunktion am meisten bekannte war und als sicher angesehen
wurde, ist sie ebenfalls gebrochen. In [71] (2004) bzw. in [72] (2005) wurde gezeigt,
wie sich eine Kollision für MD5-Hashfunktion finden lässt.
3.6.2 SHA-Hashfunktionen
Die SHA (eng.Secure Hash Algorithm) bezeichnet eine Gruppe standardisierter Hashfunktionen. Die erste 160-Bit-Version von SHA (bezeichnet SHA-0 auch SHS (Secure Hash Standard)) wurde von den US-Bundesbehörden NIST (National Institute
of Standards and Technology) und NSA (National Security Agency) entwickelt und
als NIST-Standard FIPS 180 im Jahr 1993 vorgeschalgen. Gleichzeitig war sie als Bestandteil des Digital Signature Algorithms (DSA) für den Digital Signature Standard
(DSS) gedacht.
SHA-0 ist im Wesentlichen eine andere Weiterentwicklung von MD4. Wegen Designfehlers wurde sie im Jahr 1995 korrigiert, als SHA-1 bezeichnet und in FIPS PUB 180-1
spezifiziert. 2002 wurden in FIPS PUB 180-2 drei weitere Versionen veröffentlicht:
SHA-256, SHA-384 und SHA-512. 2004 wurde die Variante SHA-224 veröffentlicht .
Diese Reihe von Hashfunktionen erzeugt eine grössere Hashwertlänge zwischen 224 bit
(SHA-224) und 512 bit (SHA-512) und ist als SHA-2 bezeichnet und besitzt unterschiedlichen Eigenschaften, die in der nachstehenden Tabelle zusammengefasst sind.
1. Beschreibung
Zunächst wird die Blockeinteilung für die zu verabeitende Nachricht durchgeführt. Wie die Tabelle 3.1 zeigt, ist die Blockgrösse unterschiedlich. Bei SHA-1,
56
Hashfunktion
Hashlänge
Blockgrösse
Bitlänge eines Wortes
Anzahl der Grundfunktionen
Anzahl der Initialwerten
Schrittanzahl pro Block
Anzahl der Konstanten
Maximale Nachrichtengrösse
SHA-1 SHA-224 SHA-256 SHA-384 SHA-512
160
224
256
384
512
512
512
512
1024
1024
32
32
64
64
64
3
6
6
6
6
5
8
8
8
8
80
64
64
80
80
4
64
64
80
80
64
64
64
128
128
2 −1 2 −1
2 −1
2 −1
2 −1
Tabelle 3.1: Die Eigenschaften der SHA-2 Familie.
SHA-224 und SHA-256 beträgt sie 512 Bit und bei SHA-384 und SHA-512 1024
Bit. Im Vergleich zu MD4 benutzt die SHA-Familie die Big-Endian-Architektur,
bei der das Byte mit höchstwertigen Bits (d.h. die signifikantesten Stellen) zuerst
gespeichert. Wenn das umgekehrt ist, dann handelt es sich um die Little-EndianArchitektur. Das war genau der Fall bei MD4.
Die Länge der Nachricht wird so erweitert, dass sie ein Vielfaches von 512 bzw.
1024 Bit minus 64 bzw. 128 Bit wird. Das erste Füllbit ist “1” gefolgt von vielen
Nullen.
Eine 64 bzw. 128 Bit-String mit führenden Nullen wird nach dem Big-EndianPrinzip angehängt, welcher die binäre Darstellung der Nachricht vor dem Padding enthält.
3. Schritt (Initialisierung des SHA-Speichers)
Je nach Typ der verwendeten Hashfunktion wird der SHA-Speicher mit einer
bestimmten Anzahl der Werten initialisiert. Bei SHA-1 bzw.SHA-224, SHA-256,
SHA-384 und SHA-512 werden 5 bzw. 8 Intialisierungswerten verwendet. Beispielsweise bei SHA-1 wird ein 5 -Wörter-Speicher (A, B, C, D, E) benutzt, wel(0)
(1)
(2)
(3)
(4)
cher mit folgenden Werten (bezeichnet mit H0 , H0 , H0 , H0 , H0 ) intialisiert
wird:
(0)
H0
(1)
H0
(3)
H0
(4)
H0
= 67452301
= ef cdab89
= 98badcf e
= 10325476
57
Wie bei MD4 hängt die Kompressionsfunktion jeder SHA-2-Hashfunktion
grundsätzlich von der Anzahl der darin bestehenden Grundfunktionen und Konstanten ab (siehe Tablle 3.1). Im folgenden werden wir uns nur auf Berechnungsphase der SHA-1 beschränken. Für die restlichen Hashfunktionen kann die
originale Quelle [51] nachgeschlagen werden.
Bei SHA-1 wird die Nachricht m in 512-bit-Blöcke zerlegt m1 , m2 , · · · , mL und
dann blockenweise verarbeitet. Jeder Block mi wird in 16 32-Bit-Unterblöcke
(0)
(15)
(Wort) eingeteilt, die wir mit mi , · · · , mi
bezeichnen. Aus diesen Unterblöcken werden 80 Wörter Wt , t = 0, · · · , 79 auf folgende Weise erzeugt.
(
(t)
mi
für t = 0, 1, · · · , 15,
Wt =
(Wt−3 ⊕ Wt−8 ⊕ Wt−14 ⊕ Wt−16 ) << 1 für t = 16, · · · , 79.
Mithilfe von Wt , 0 ≤ t ≤ 79 werden 80 Rechenoperationen durchgeführt, um
den Inhalt des Speichers (5 Wörter) in jedem Schritt zu aktualisieren. Zu diesem
Zweck benötigen wir die folgenden Konstanten Kt , t = 0, · · · , 79.

5a827999 0 ≤ t ≤ 19



6ed9eba1 20 ≤ t ≤ 39
Kt =

8f 1bbcdc 40 ≤ t ≤ 59



ca62c1d6 60 ≤ t ≤ 79
und die folgenden Funktionen ft , t = 0, · · · , 79.

f (x, y, z)



g(x, y, z)
ft =

h(x, y, z)



g(x, y, z)
0 ≤ t ≤ 19
20 ≤ t ≤ 39
40 ≤ t ≤ 59
60 ≤ t ≤ 79
, wobei f, g und h die Grundfunktionen von MD4. Der Ablauf einer Operation
t sieht dann folgendermassen aus:
a) Setze T = (A << 5) + ft (B, C, D) + E + Wt + Kt .
b) (A, B, C, D, E) = (T, A, (B << 30), C, D).
Bezeichnen wir den Ergebniswert der (i − 1)-ten Iteration (0 ≤ i ≤ L) mit
(0)
(1)
(2)
(3)
(4)
Hi−1 = (Hi−1 , Hi−1 , Hi−1 , Hi−1 , Hi−1 )
58
Dann wird der Ergebniswert der nächsten Iteration wie folgt berechnet:
(0)
= A + Hi−1
(0)
(1)
= B + Hi−1
(2)
= C + Hi−1
(3)
= D + Hi−1
(4)
= E + Hi−1
Hi
(1)
Hi
(2)
Hi
Hi
(3)
(4)
Hi
Der ausgegebene 160-Bit-Hashwert ist die Konkatenierung der 5 Wörter-Speicher
(160 Bit) (A, B, C, D, E). Formal heisst das
(0)
(1)
(2)
(3)
(4)
SHA1(m)= HL ||HL ||HL ||HL ||HL ,
wobei L die Blockanzahl der Nachricht m.
2. Sicherheit
Die Hashfunktion SHA-1 bildet Hashwerte mit 160 Bit und somit gibt es also
2160 Möglichkeiten für verschiedene Werte. Will man eine Kollision (mit einem
Kollisionsangriff) finden, so würden bereits 280 Operationen genügen. Das bedeutet, die Sicherheit der SHA-1 beruht auf diesen mindestens 280 Operationen
und damit der technischen Unmöglichkeit eines solchen Angriffs.
1998 haben Florent Chabaud und Antoine Joux [15] einen Angriff auf SHA-0
vorgestellt, der die Komplexität auf 261 (Statt 280 mit dem Geburtstagangriff)
reduziert. 2004 haben Eli Biham [23] Rafi Chen zunächst die sogennante NearKollision7 und dann später eine volle Kollision gefunden.
Mitte Februar 2005 stellte das chinesische Wissenschaftsteam [72] eine Methode
vor, mit der sich eine Kollision für SHA-0 mit einem Aufwand weniger als 239
finden lässt. Fünf Monate später wurde der erste Angriff [77] auf die volle SHA-1
von demselben Team veröffentlicht, der den Rechenaufwand weniger als 269 für
die Berechnung einer Kollision benötigt. Im Oktober 2005 wurde dieser Aufwand
nach unten auf 263 korrigiert .
7
eine Near-Kollision sind zwei verschiedenen Nachrichten mit einem ähnlichenHashwert. Vereinfacht
gesagt, die zwei Nachricht unterscheiden sich nur in eine keine Menge von Bits.
59
Auf der Konferenz Crypto 2006 wurde ein erweiterter Angriff von Rechberger
vorgestellt, welcher auf einer reduzierten Variante der SHA-1 mit 64 Berechnungsrunden anwendbar ist. Bei der neuen Angriff kann ein Teil der gefälschten
Nachricht frei gewählt werden.[14]. Nach Einschätzung der Experten lässt sich
dieser auch auf die vollständige Variante verallgemeinern. Dies wurde von Entwickler dieses Angriffs vermutet, indem der frei wählbare Anteil sich durch weitere Optimierung des Angriffs noch steigern lässt.
Bisher wurden noch keine praktische Angriffe gegen die SHA-2 Familie veröffentlicht. Manche Kryptanalytiker bezweifeln, ob sie tatsächlich die mögliche kurzfristig Alternativen zu SHA-1 sind. Der Grund dafür ist, dass sie zur selben
Familie wie SHA-1 gehören und somit unter Umständen gegen dieselben Attacken anfällig sind. Eine weitere Alternative ist die Tiger-Hashfunktion, die in der
nächten Abschnitt beschrieben wird.
3.6.3 Tiger
1. Beschreibung:
Tiger ist eine Hashfunktion, die von Ross Anderson und Eli Biham im Jahr 1996
entwickelt wurde und Haswerte der Länge 192 Bit produziert. Sie ist noch nicht
patentiert und besitzt noch zwei weitere Version 128 und 160. Eine Besonderheit dieser Hashfunktion besteht an ihrer Performanz. Laut den Tiger-Autoren
besitzt diese Hasfunktion eine gute Performance im Vergleich zu SHA-1. Sie ist
bis zu 3 mal schneller als SHA-1, wenn sie auf 64-Bit-Prozessoren getestet wird.
Tiger arbeitet mit 512 Bit Blöcken, die folgendermassen erzeugt werden:
Das Padding verläuft ähnlich wie bei MD4.
Das Längenpadding ist analog zu MD4.
3. Schritt (Initialisierung des MD-Speichers)
Es wird ein 3 64-Wort-Puffer (eine Wort ist ein 64-Bit-String) (a, b, c) verwendet,
welches wie folgt mit hexadezimalen Werten initialisiert ist:
a : 0123456789ABCDEF
b : F EDCBA9876543210
c : F 096A5B4C3B2E187
Diees Phase erfolgt in 4 Schritten
60
• Sicherung der Initialwerte:
Die Sicherung erfolgt durch
aa = a
bb = a
cc = c
• Verarbeitungsphase:
Jeder 512-Bit-Block wird in 8 64-Bit-Teilblöcke zerlegt, die jeweils in drei
Durchläufe verarbeitet werden, wobei jeder Durchlauf aus 8 Runden besteht.
Bezeichnen wir mit M einen Nachrichtenblock, welcher in Teilblöcke xi mit
je 64 Bits eingeteilt wird. Das heisst:
M = x0 ||x2 || · · · ||x7 .
Wie die Abbildung 3.7 zeigt , werden in jeder Runde die folgende Operationen für jedes xi unter Verwendung von zwei booleschen Funktionen namens
EV EN und ODD durchgeführt:
a
a
b
b
=
=
=
=
a ⊕ xi
a − EV EN (c)
b − ODD(c)
(Const) · b
Diese Funktionen benutzen vier S-Boxen T1 , · · · T4 : {0, 1}8 → {0, 1}64 und
sind wie folgt definiert:
EV EN (y) = T1 (y[0]) ⊕ T1 (y[2]) ⊕ T1 (y[4]) ⊕ T1 (y[6])
ODD(y) = T1 (y[1]) ⊕ T1 (y[3]) ⊕ T1 (y[5]) ⊕ T1 (y[7]),
wobei y[i] das i-te Byte des Wortes y bezeichnet, 0 ≤ i ≤ 7.
• Key-Schedule-Phase:
Nach der Bearbeitung jedes Blocks wird dann eine Key-Schedule-Prozess
unter Verwendung der Teilblöcke xi , zweier Konstanten (bezeichnet mit
Cont1 und Cont2 ) und der bitweise Operationen ausgeführt. Der Ablauf
61
Abbildung 3.7: Die Tiger-Kompressionsfunktion.
der Key-Schedule ist algorithmisch wie folgt vorgestellt:
x0
x1
x2
x3
x4
x5
x6
x7
x0
x1
x2
x3
x4
x5
x6
x7
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
x0 − (Cont1 ⊕ x7 )
x1 ⊕ x0
x2 + x1
x3 − (x2 ⊕ (¬x1 << 19))
x4 ⊕ x3
x5 + x4
x6 − (x5 (¬x4 >> 23))
x7 ⊕ x6
x0 + x7
x1 − (x0 ⊕ (¬x7 << 19))
x2 ⊕ x1
x3 + x2
x4 − (x3 ⊕ (¬x2 >> 23))
x5 ⊕ x4
x6 + x5
x7 − (x6 ⊕ Cont2 )
62
mit
Cont1 = A5A5A5A5A5A5A5A5
Cont2 = 0123456789ABCDEF.
• Feedforward-Phase:
Mithilfe der gesicherten Werte werden die Anfangswerte für den nächten
Block wie folgt vorbereitet:
a = aa ⊕ a
a = bb − b
b = cc + c
Der Tiger-Hashwert ist die Konkatenation der 3 64-Bit-Werte a, b und c, welche
sich aus der Bearbeitung des letztes Nachrichtenblocks nach der FeedforwardPhase ergeben.
2. Sicherheit:
Es ist offensichtlich, dass die Tiger-Hashfunktion ein höhes Sicherheitniveau besitzt, da sie eine 192-Bit Hashwert produziert. Wie wir gesehen haben, unterscheidet sich die Tiger-Kompressionsfunktion völlig von der Kompressionsfunktionen der MD.bzw SHA-Familie. Diese Funktion verwendet die im Gegensatz
zu MD-Familie einen Key Schedule Algorithmus sowie algebraische Kombinationen von Funktionen, die nach Kryprtoexperten als ein wichtiger Bestandteil der
globalen Struktur der Tiger angesehen sind. Deswegen scheint Tiger sicherer als
SHA-1 zu sein.
Da die Tiger-Hashfunktion sich demnächst als alternative für eine langfristige
Perspektive anbietet, wurde in der letzten Zeit intensiv analysiert. Die Ergebnisse haben gezeigt, dass die reduzierten Versionen von Tiger gegen KollisionsPreimage-Angriffe anfällig sind. 2006 haben John Kelsey und Stefan Lucks [34]
Kollisionen bzw. Near-Kollisionen für die 16-reduzierte bzw. 20-reduzierte Variante gefunden. Ihre Angriffsstartegie war eine differentielle Kryptoanalyse, welche auf die Message-Modification-Techniques basieren. Vereinfacht gesagt, wählte
man so lange zwei Nachrichten m und m0 mit bestimmter Differenz bis diese kollidieren. Darauf aufbauend stellten F.Mendel, B. Preneel, V.Rijmen, H.Yoshida
und D.Watanabe [26] während der Indocrypt Konferenz 2006 einen neuen differentiellen Angriff vor, in dem die Wahrscheinlichkeitsverhalten der Ausgabe der
Key-Schedule-Phase betrachtet wurde. Sie haben gezeigt, dass der Aufwand zum
Auffinden einer Kollision bzwz einer Near-Kollision für die 19- bzw. 22-reduzierte
63
Tiger-Version zwischen 262 und 269 liegt bzw. etwa 244 beträgt. In Hinsicht auf
die Preimage-Resistenz präsentierten Indesteege und Preneel in WEWoRC 2007
(Western European Workshop on Research in Cryptology) Preimage-Angriffe
auf die Tiger-Kompressionsfunktion. Schließlich kam man zum Ergebnis, dass
solche Angriffe auf die reduzierten Tiger-Varianten 12 bzw. 13 einen Aufwand
von 263.5 bzw. 264 Kompressionsfunktion benötigen.
64
Kapitel 4
Blockchiffren-basierte Hashfunktionen
4.1 Motivation
Im vorhergehenden Kapitel haben wir den iterativen Ansatz zur Konstruktion von Hashfunktionen kennen gelernt und keine explizite Form für die Kompressionsfunktionen
angegeben. Die einfachste Methode, eine Hashfunktion zu konstruieren, besteht in der
Verwendung einer Blockchiffre als Kompressionsfunktion. Der Vorteil dieser Methode ist, dass es einerseits bereits effizienten Implementierungen von Blockchiffren gibt,
und anderseits wenn eine Blockchiffre wie DES [2] und AES [1] gewisse Sicherheitseingenschaften besitzt ,liegt es nahe, diese so weit wie möglich auf die Hashfunktion zu
übertragen. So kann man sich die Zertifizierung ( das Überprüfen ) einer Hashfunktion
ersparen. Diese Eigenschaft wurde von Merkle in [45] pre-certified“ genannt.
”
Zur Konstruktion von Hashfunktionen auf der Basis von Blockchiffren gibt es mehrere Möglichkeiten: Am häufigsten wird die mit einer Hashfunktion zu bearbeitende
Nachricht in gleich lange Blöcke gespalten, die der Schllüssellänge entsprechen. Der
Hashwert wird daraus erzeugt, indem jeder dieser Blöcke als Schlüssel nacheinander
mit einem beliebigen Initial-Block bearbeitet wird. Eine andere Möglichkeit besteht
darin, dass einen festen Schlüssel verwendet wird, mit dem die zu bearbeitende Nachricht blockweise verschlüsslt wird. Der Hashwert wird gewonnen, indem jeder Block
mit dem vorhergehenden durch eine XOR-Operation verknüpft. Neben der soeben
vorgestellten Einsätze von Blockchiffren als Kompressionsfunktion gibt es weietere
Möglichkeiten, welche im Laufe dieses Kapitels erläutert werden.
Bevor wir uns genau anschauen, wie sich eine Hashfunktion durch Blockchiffren konstruieren lässt, sollten wir uns erst einmal klar machen, wie Blockchiffren überhaupt
gebaut sind und welche grundlegenden Kriterien besitzen.
65
Kapitel 4 Blockchiffren-basierte Hashfunktionen
4.2 Grundlagen und Definitionen
Blockchiffren sind symmetrische1 Verschlüsselungsalgorithmen. Sie arbeiten eine Nachricht blockweise ab. Jede Nachrchrit wird zunächst in einzelne, jeweils gleichlange
Blöcke aufgeteilt (meist 64 oder 128 Bit), welche anschliessend unter Verwendung eines Geheimschlüssels unabhängig voneinander verschüsselt sind.
Wenn die Länge der zu verschlüsselnden Nachricht kein Vielfaches der Blockgrösse ist,
wird üblicherweise der letzte Block auf die fest vorgegebene Blockgrösse aufgefüllt (so
genanntes Padding). Die wichtige Größen bei einer Blockchiffre sind die Blocklänge
n und die benutzte Schlüssellänge k. Vereinfacht kann man die Funktionsweise einer
Blockchiffre wie folgt darstellen:
1. Es wird ein geheimer Schlüssel gewählt.
2. Die Nachricht wird in viele gleichlange Blöcke mi zerlegt, m1 , m2 , · · · , mr .
3. Mit einem Algorithmus wird jeder dieser Blöcke mit Hilfe des Schlüssel verschlüssselt. Der Chiffretext c ergibt sichdurch die Konkatenation dieser Chiffretextblöcke, die gleichgross wie den Klartext ist, also c = c1 ||c2 || · · · ||cr .
4. Mit dem inversen Algorithmus und demselben Schlüssel kann aus der
verschlüsselten Nachricht blockweise der Klartext wiederhergestellt werden.
Mathematisch ausgedrückt heißt das, dass eine Blockchiffre aus einer Funktion e besteht, die zwei Eingabewerte in jeder Iteration bekommt, nämlich der Nachrichtenblock
mi und den Schlüssel K. Für eine formale Beschreibung einer Blockchiffre wird die
folgende Definition gegeben, die dem Skript [27] entnommen ist.
Definition 4.1 (Blockchiffre)
Eine Blockchiffre ist eine Funktion e : D → R, wobei D = {0, 1}k × {0, 1}n → {0, 1}n
und R = {0, 1}n mit k, n ≥ 1. Diese Funktion nimmt zwei Eingabewerte, einen
Schlüssel K ∈ {0, 1}k und einen Klartext m ∈ {0, 1}n an und gibt einen Chiffretext
c ∈ {0, 1}n zurück mit c = e(K, m). Für jeden Schlüssel K ∈ {0, 1}k wird die Funktion
eK (·) als eK (·) = e(K, ·) definiert. Also für jede Blockchiffre e mit dem Schlüssel K
kann die Funktion eK als eine Permutation auf {0, 1}n aufgefasst werden.
Beispiel
Die AES bzw. Advanced Encryption Standard ist einer der bekanntesten Blockchiffre.
Sie verwendet einen Schlüssel der Länge 128,192 oder 256 Bits und verarbeitet Nachrichten, deren Blöckgrösse 128 Bits beträgt.
1
Ein Verfahren wird als symmetrisch bezeichnet, wenn sowohl zum Ver- als auch zum Entschlüsseln
der gleiche Schlüssel verwendet wird.
66
Jede Blockchiffre ist eine Verschlüsselungsfunktion und daher besitzt eine Umkehrfunk2
tion e−1
K , weil sie eine Permutation ist. Diese Funktion wird als Entschlüsselungsfunktion
bezeichnet und benutzt denselben Schlüssel K . Für jede Nachricht m, die mit dem
Schlüssel K chiffriert ist, gilt die folgende Beziehung :
m = e−1
K (eK (m)).
Nun bezeichnen wir mit Ek,n die Menge aller Blockchiffren, die auf {0, 1}k × {0, 1}n
definiert sind. Daraus erhalten wir die folgende Definition
Definition 4.2 (Ideale Blockchiffre)
Eine Ideale Blockchiffre ist eine Blockchiffre, die zufällig aus Ek,n gewählt ist. Eine
ideale Blockchiffe wird mit ê bezeichnet.
Um Aussagen über die Sicherheit von Blockchiffren-basierte Hashfunktionen treffen zu
können, wird zunächst ein formales Angriffsmodell aufgestellt und die zu beweisende
Sicherheitseigenschaft in diesem Modell definiert. Dann soll gezeigt werden, ob die zugrunde liegende Blockchiffre diese Eigenschaft erfüllt. Eine der wichtigsten Eigenschaften bei Blockchiffren ist, dass sie gute Pseudozufallspermutationen (Pseudo-Random
Permutationen (PRP)) sind. Das heisst, jede Blockchiffre eK mit einem Schlüssel K
lässt sich nicht von einer echt zufälligen Permutation unterscheiden werden. Das auf
dieser Eigenschaft basierende Sicherheitsmodell wird als Standardmodell bezeichnet.
Allerdings wurde in [66] gezeigt, dass eine Blockchiffre, welche lediglich die Pseudozufallseigenschaft besitzt, keine sichere Konstruktion von Hashfunktionen garantiert.
D.h es kann keine hilfreichen Hinweise geben, die einen Sicherheitsbeweis der Konstruktion erlauben. Deswegen soll die Sicherheit in einem neuen Modell untersucht
werden. Das neue Sicherheitsmodell geht auf Shannon [64] zurück und wird das Ideale
Chiffremodell (Ideal Cipher Model) genannt. In der Literatur wird dieses häufig als
Blockchiffre-Modell (Block cipher Model) oder Shannon-Modell (Shannon model) bezeichnet.
Definition 4.3 (Das Ideale Chiffremodell)(ICM)
In einem idealen Chiffremodell wird eine Blockchiffre als eine Funktion aufgefasst, ohne weitere Details der Verschlüsselungsfunktion zu kennen. Die einzigen Angaben, die
als bekannt vorausgesetzt werden können, sind die Block- und Schlüssellänge.
2
Der Beweis dafür, dass eine Verschlüsselungsfunktion eine Permutation ist, findet man im Buch
[13] S. 68.
67
Mit anderen Worten besitzt die Blockchiffre keine besondere mathematische Struktur,
welche durch einen Angreifer ausgenutzt werden kann.
Bemerkung 4.1
Die Betrachtung dieses Modells ist nicht realistisch genug, weil reale Blockchiffren
häufig bereits bekannte Schwächen wie Bit Dependence Criterion (BDC)3 aufweisen,
welche nicht von einer idealen Blockchiffre zu erwarten sind.
Bemerkung 4.2
Das Ideale Cipher Modell ist dem Zufallsorakelmodell (ROM) [6, 25] mit folgenden
bemerkenswerten Ausnahmen ähnlich:
• Ein Angreifer, der mit einem idealen Chiffre-Orakel (ICO) kommuniziert, hat den
Zugang zu Orakeln eK und e−1
K ,wobei eK eine Blockchiffre mit k-bit Schlüsseln
k
aus einer Familie von 2 Zufallspermutationen ausgewählt wird. Um den Chiffretext c = eK (m) zu erfahren, stellt er dem Orakel e die Frage (K, m), während
er dagegen den Klartext m erhält, indem er die Anfrage (K, c) an das Orakel
e−1 sendet.
• Die Blöcklänge der idealen Blockchiffre (IC) ist im Voraus festgesetzt, d.h das
IC ein endliches Objekt ist, während das RO immer unendlich ist.
Definition 4.4 (Blockchiffre-basierte Kompressionsfunktion)
Eine Blockchiffre-basierte Kompressionsfunktion ist eine Funktion f
f : Ek,n × ({0, 1}a × {0, 1}b ) → {0, 1}n
wobei a, b und c natürliche Zahlen sind mit a + b ≥ n.
Für eine feste Blockchiffre e aus Ek,n erhalten wir eine Kompressionsfunktion f e mit
f e : {0, 1}a × {0, 1}b → {0, 1}n
Definition 4.5 (Blockchiffre-basierte Hashfunktion)
Eine Blockchiffre-basierte Hashfunktion ist eine Funktion he
he : Ek,n × {0, 1}∗b → {0, 1}n
so dass für eine Nachricht
m = m1 ||m2 || · · · ||ml
3
Unter BDC versteht man die Existenz einer Korrelation zwischen zwei Ausgabebitänderungen bei
Änderung eines Eingabebits
68
gilt
he (m) = hl , hi = f e (hi−1 , mi ), 1 ≤ i ≤ l, h0 ∈ {0, 1}n .
Definition 4.6 (Hash-Rate)
Wenn genau q Anfragen der Blockchiffre q benötigt werden, um die Berechnung von
f e (h, m) durchzuführen, dann besitzt die Kompressionsfunktion f ( und daraus entstehende Hashfunktion) die Hash-Rate r mit r = (b/n)/q.
Eine Hash-Rate einer Kompressionsfunktion ist die durchschnittliche Anzahl der Nachrichtenblöcke, die nach einem einzelnen Aufruf der zugrundeliegende Blockchiffre bearbeitet werden. Die Hash-Rate dient grundsätzlich dazu , die Effizienz einer Blockchiffrebasierte Hashfunktion zu beurteilen. Je kleiner die Hash-Rate ist, desto schlechter ist
auch die Effizienz der Hashfunktion. Deswegen wird stets zum Effizienzvergleich der
Hashfunktionen berücksichtigt. Beispielsweise für b/n = 3 und q = 2 erhalten wir eine
(3/2)-Rate-Kompressionsfunktion.
$
Im Folgenden bezeichnen mit x ← S das Ereignis , dass ein Element x zufällig aus der
endlichen S Menge ausgewählt wird.
Zur Untersuchung einer Blockchiffren-basierte Hashfunktion auf die Kollisionsresistenz, wird zunächst jede Blockchiffre durch eine zufällig gewählte Blockchiffre e aus
der Menge Ek,n instanziert. Will ein Angreifer eine Kollision für eine Blockchiffrebasierte Hashfunktion he finden, so sendet er insgesamt q Anfragen. Eine Kollison für
he ist ein Nachrichtpaar (m, m0 ) mit he (m) = he (m0 ).
Zur Bewertung der Sicherheit dieser Hashfunktion im Bezug auf Kollisionsresistenz
wird der Rechenaufwand als Funktion in Abhängigkeit von q betrachtet und mit der
Erfolgswahrscheinlichkeit zum Finden einer Kollision verglichen.
Im Folgenden definieren wir drei verschiedene Begriffe von Resistenz und setzen he = h
für den Rest des Kapitels.
Definition 4.7 (Kollisionsresistenz)
Sei h eine Blockchiffren-basierte Hashfunktion mit h : Ek,n ×{0, 1}∗ → {0, 1}n ,k, n, a ≤
1. Der Vorteil (Advandage) eines Angreifers A zum Finden einer Kollision für h ist
gegeben durch
AdvhKoll (A)
h
i
$
$
0
e,e−1
0
0
= Pr e ← Ek,n ; (m, m ) ← A
: m 6= m ∧ h(m) = h(m )
Für q ≥ 1 definieren wir AdvhKoll (q) = maxA AdvhKoll (A) , wobei das Maximum über
alle Gegner genommen wird, welche höchstens q Anfragen an beiden Orakeln e und
e−1 stellen.
69
Neben der Kollisionsresistenz der Hashfunktionen, interessieren wir uns auch für deren
Inverse, d.h die Preimage- und die zweite Preimage-Resistenz.
Definition 4.8 (Preimage-Resistenz)
Sei h eine Blockchiffren-basierte Hashfunktion,h : Ek,n × {0, 1}∗ → {0, 1}n , wobei
k, n ≥ 1. Der Vorteil (Advandage) eines Angreifers A zum Finden eines Urbilds für h
ist gegeben durch
h
i
−1
$
$
$
AdvhP re (A) = Pr e ← Ek,n ; τ ← {0, 1}a ; m ← Ae,e (τ ) : h(m) = τ .
Definition 4.9 (2nd -Preimage-Resistenz)
Sei h eine Blockchiffren-basierte Hashfunktion,h : Ek,n × {0, 1}∗ → {0, 1}a , wobei
,k, n ≥ 1. Der Vorteil (Advandage) eines Angreifers A zum Finden eines zweiten
Urbilds für h ist gegeben durch
i
h
−1
$
$
$
AdvhsP re (A) = Pr e ← Ek,n ; m ← {0, 1}n ; m0 ← Ae,e (m) : h(m) = h(m0 ) .
Wie schon bereits erwähnt, bietet sich die Möglichkeit an, mittels n-Bit-Blockchiffren
Hashfunktionen zu konstruieren. Diese Blockchiffren haben die Eigenschaft, sich des
iterativen Ansatzes zu bedienen.
Die Nachricht, für die der Hashwert zu berechnen ist, wird zunächst in Blöcke mi
zerlegt. Die Blockgrösse entspricht je nach der Methode der Länge des Schlüssels bzw.
der Grösse der Klartextblöcke der verwendeten Blockchiffre.
Die am häufigsten in der Literatur vorgestellte Hashfunktionen lassen sich in zwei
Hauptklassen unterteilen:
1. Die Single-Block-Length-Hashfunktionen (SBL-Hash).
2. Die Double-Block-Length-Hashfunktionen (DBL-Hash).
Mit diesen wollen wir uns in der folgenden Abschnitte befassen.
4.3 Single-Block-Length Konstruktionen
Bei Single-Block-Length Hashfunktionen 4 handelt es sich um kryptographische Hashfunktionen, die einen Hashwert produzieren, der genauso groß wie die Blocklänge der
verwendeten Blockchiffre ist, d.h die Hashlänge und Blockgrösse sind gleich.
4
Single-Block-Length Hashfunktion wird als SBL-Hashfunktion abgekürzt
70
Bevor wir mit der Beschreibung eines allgemeinen Designprinzips anfangen, wollen wir
uns als Motivation zuerst einmal drei wichtige Hashfunktionen vorstellen, auf welche
in der Literatur viel Aufmerksamkeit gerichtet wurde.
4.3.1 Beispiele als Motivation
In der nachstehenden Beispiele bezeichnen wir mit k die Schlüssellänge und mit n die
Blocklänge der verwendeten Blockchiffre. Wie in der Definition 4.5 bezeichnen wir mit
hi der Zwischenhashwert der Hashfunktion, wobei h0 ein fester Startwert ist und hl
der endgültige Hashwert.
4.3.1.1 Matyas-Meyer-Oseas-Verfahren
Die Matyas-Meyer-Oseas Hashfunktion5 gilt als eine der ersten sicheren Hashfunktionen, welche von S.Matyas, C.Meyer und J.Oseas in [67] veröffentlicht. Das Schema ist
im Teil 2 des ISO-Standards (10118-2) definiert und als Generator allenn auf Blockchiffren basierten Hashfunktionen festgeschrieben.
Zuerst wird eine Nachricht in l Blöcke mi der Länge n zerlegt. Wie die Abbildung
4.1 zeigt, wird der Nachrichtenblock mi als Klartext genommen. Durch eine entsprechende Funktion g wird das Zwischenergebnis hi−1 so verändert, dass das Ergebnis als
Schlüssel geeignet ist, falls die Schlüssel- und Blocklänge unterschiedlich sind. Besitzt
aber hi−1 bereits die richtige Länge, so kann die Funktion g einfach weggelassen werden. Unter Verwendung einer XOR-Operation wird der resultierende Chiffretextblock
mit dem aktuellen Nachrichtenblock mi verknüpft, um den neuen Zwischenwert hi zu
berechnen:
hi = eg(hi−1 ) (mi ) ⊕ mi , 1 ≤ i ≤ l.
Diese Hashfunktion besitzt eine Hash-Rate1, weil es genau eine Verschlüsselung benötigt
wird, um den Hashwert eines Nachrichtenblocks zu produzieren.
wie bereits erwähnt, ist dieses Schema als einer der sicheren Konstruktionen angesehen,
da es keinen anderen Angriffe auf dieses Schema außer dem Geburtstagangriff bekannt
gegeben wurde. Diese Sicherheit kann wie folgt begründet werden:
Bei der Kenntniss des Schlüssels besteht das Ziel eines Angreifers darin, zwei Nachrichten m und m0 zu finden, welche denselben Hashwert liefern. Vereinfachen wir die
Situation zunächst etwas: Angenommen, daß die gesuchte Nachrichten jeweils aus einzelnem Block bestehen. Daraus ergibt sich die folgende Beziehung:
5
Matyas-Meyer-Oseas wird häufig mit MMO-Schema genannt.
71
Abbildung 4.1: Die Matyas-Meyer-Oseas-Hashfunktion.
m ⊕ eK (m) = eK (m0 ) ⊕ m0 ⇔ m ⊕ m0 = eK (m) = eK (m0 ).
Unter Annahme, dass die Blockchiffre einen zufällig gleichverteilten Chiffretextblock
aus einem Klartextblock erzeugt, sollte für die soeben aufgestellte Gleichung nicht
einmal klar sein, ob sie lösbar ist; d.h für einen Angreifer sollte es schwierig sein,
solche Nachrichten zu finden.
4.3.1.2 Davies-Meyer-Verfahren
Davies-Meyer-Verfahren6 wird häufig auch als duales Verfahren zum Matyas-MeyerOseas-Verfahren bezeichnet, weil hier die Rolle vom Zwischenergebnis hi−1 mit der
Rolle vom Nachrichtenblock getauscht wird.(Siehe die Abbildung 4.2).
zum MMO-Schema wird zunächst die Nachricht in l Blöcke der Länge k geteilt, die
als Schlüssel der aktuellen Nachrichtenblock dient. Der Zwischenergebnis hi−1 der vorherigen Runde geht als Klartext in die Blockchiffre ein:
hi = emi (hi−1 ) ⊕ hi−1 , 1 ≤ i ≤ l.
6
das Verfahren wird D.Davies in [75, 74] und C.Meyer in [17] zugeschrieben,aber D.Davies hat in
einer persönlichen Nachricht bestätigt, dass er nicht das Schema vorgeschlagen hat. Trotzdem ist
weithin als Davies-Meyer-Schema bekannt und ist häufig mit DM-Hashfunktion bezeichnet
72
Abbildung 4.2: Die Davies-Meyer-Hashfunktion.
Die Hash-Rate dieser Hashfunktion beträgt k/n. Ist die Blocklänge n größer als die
Schlüssellänge k, so wird die Performanz dieser Hashfunktion im Vergleich zu dem
MMO-Schema kleiner. Beispielsweise bei der Verwendung der Blockchiffre DES in
Davies-Meyer-Schema ist die Hash-Rate gleich 7/8, da die DES eine 56 Bit-Schlüsselund 64 Bit-Blocklänge benutzt. Bei einer auf AES basierenden Davies-Meyer-Hashfunktion
erhält man die Räte 1, 1.5 oder 2, je nachdem, ob die Schlüssellänge der AES4.2 128,192
oder 256 beträgt.
Was die Sicherheit dieses Schemas betrifft, wurde es in [57] gezeigt, dass diese Hashfunktion gegen den Fixpunkte-Angriff einige Schwachstellen aufweist. im Grundsätzlichen
für Hashfunktionen, welche Nachrichtenblöcke mi als Schlüsseln benutzen, ist es recht
einfach, eine Menge von Fixpunkten für deren liegenden Kompressionsfunktionen
f (h, m) = em (h) ⊕ h folgendermaßen zu finden:
1. Wähle zufällig eine Nachricht m aus.
2. Berechne h = e−1
m (0).
3. Dieses Ergebnis ist ein Fixpunkt für f : f (h, m) = h.
Ein solcher Angriff stellt in der Praxis keine Gefahr dar. Man könnte ihn erschweren
und abwehren, indem man das so genannte Präfixfreie Encoding 7 für die Nachricht
durchführt oder die Länge der Nachricht nach der Paddingprozess hinzufügt.
7
Dieser Ansatz wurde in [31] als eine alternative Lösung vorgeschlagen, um die Schwäche der iterativen MD-Konstrunktion gegen alle mögliche generischen Angriffe zu beseitigen.
73
4.3.1.3 Miyaguchi-Preenel-Verfahren
Die Miyaguchi-Preenel-Hashfunktion [61] ist eine erweitere Variante des Matyas-MeyerOseas-Schema,welche von Shoji Miyaguchi und Bart Preneel unabhängig voneinander
vorgeschlagen wurde. Sie wird bei der Konstruktion von Wihrpool-Hashfunktion verwendet. Der Unterschied zu MMO-Hashfunktion ist es, dass das Zwischenergebnis
hi−1 zusätzlich zu mi mit der XOR-Operation hinzugefügt werden muss.(Siehe Abbildung 4.3). Diese Hashfunktion besitzt auch die Hash-Rate 1.
Abbildung 4.3: Die Miyaguchi-Preenel-Hashfunktion.
4.3.2 Preneel-Govaets-Vandewalle-Konstruktionen (PGV)
Wie wir an obigen Beispiele gesehen haben, handelt sich es tatsächlich um drei sicheren
Single-Block-Length Hashfunktion. Wir wollen nun nach der Existenz von ähnlichen
Hashfunktionen fragen. Leider ist es nicht bekannt, welche Eigenschaften eine Blockchiffre besitzen sollte, um einen guten Baustein einer Hashfunktionen darzustellen.
Die wichtige Bemerkung, die wir aus den drei Beispiele ziehen können, ist die, dass
die drei Hashfunktionen nach einem recht einfachen Prinzip entworfen sind. Dieses
Konstruktionsprinzip wurde von Preneel, Govaets und und Vandewalle in [57] vorgeschlagen, mit dem Absicht, weitere sicheren Variationen der SBL-Hashfunktionen zu
74
entwerfen.
Bei einem PGV-Schema handelt sich um eine Hashfunktion, deren Interna aus einer
Kompressionsfunktion besteht, die eine abstrakte n-Bit-Blockchiffre verwendet. Diese
besitzt zwei Parametern als Eingabe, ein Schlüssel und ein Klartext, und gibt einen
Chiffretext zurück. Dieses Ergebnis wird dann mit einem Forwarding-Parameter per
XOR-Operation verknüpft, um den nächsten Zwischenhashwert zu berechnen. Der
formale Ablaul der Hashberechnung ist in der Abbildung 4.4 dargestellt und wird wie
folgt beschrieben:
hi = eAk (Ak ) ⊕ Ak , k = 1, 2, 3 für ein Startwert h0 = IV,
wobei jedes Ak einen Wert aus der Menge {mi , hi−1 , hi−1 ⊕ mi , v} nehmen kann. Zum
Vereinfachen setzen wir wi = hi−1 ⊕ mi .
Abbildung 4.4: Schematische Darstellung der PGV-Konstruktionen.
Nachdem wir das allgemeine PGV-Designprinzip vorgestellt haben, wollen wir nun
die Sicherheit dieser Konstruktionen auf zwei verschiedene Weise untersuchen, die im
Folgenden die PGV- bzw. ICM-Analyse genannt werden.
75
4.3.2.1 PGV-Analyse
Die PGV-Konstruktion besteht insgesamt aus 43 = 64 Schemata, da die drei Variable Ak , k = 1, 2, 3 aus einer vierelementigen Menge {mi , hi−1 , hi−1 ⊕ mi , v} ausgewählt
werden können.
Bei der PGV-Analyse [57] ging es darum, diese Hashfunktionen daraufhin zu testen, ob
alle in der Lage sind, gegen fünf verschiedenen Angriffe widerstehen zu können, d.h die
PGV-Analyse ist eine angriffsbasierte Untersuchung. Diese Angriffe bezogen sich nicht
auf die Hashfunktionen sondern auf die zugrunde liegenden Kompressionsfunktionen.
Dabei handelt es sich um die folgende Gleichung unter bestimmten Bedingungen nach
einer oder meherer Variablen zu lösen:
hi = f (hi−1 , mi ),
wobei mi der Nachrichtenblock ist, während hi und hi−1 die Zwischenergebnisse darstellen. Diese Angriffe werden im Folgenden kurz vorgestellt und erklärt.
• Direkter Angriff (D): Dieser Angriff besteht darin, zu gegebenen mi und hi
jeweils ein mi 6= m0i mit f (hi−1 , mi ) = f (hi−1 , m0i ) zu finden ( bzw. zu hi und
hi−1 ein mi , wenn kein Urbild bekannt ist). Dieser Angriff ist nicht überhaupt
zur Ermittelung von sinnvollen Urbilder geeignet.
• Permutation-Angriff (P): Dabei sind hi und hi−1 gegeben und es soll ein mi
ermittelt werden, so dass gilt:
hi = hi−1 ⊕ g(mi ),
wobei g eine Einwegfunktion ist, d.h die Kompressionsfunktion ist darstellbar
als Verkettung von einer XOR-Operation und einer Einwegfunktion. In diesem
Fall ist der Hashwert unabhängig von der Reihenfolge der Nachrichtenblöcke und
somit ist es möglich, ein Urbild bzw. eine Kollision für die Kompressionsfunktion
zu finden. Dies geschieht folgendermaßen:
Zur Vereinfachung betrachten wir zwei Nachrichten m und m0 , welche jeweils
aus drei Blöcke bestehen. Formal ausgedrückt:
m = m1 ||m2 ||m3 ,
m0 = m3 ||m1 ||m2 ,
deren Hashwerte mit H bzw. H 0 bezeichnet sind. Ist h0 ein Initialwert, so erhalten
wir
H = h0 ⊕ g(m1 ) ⊕ g(m2 ) ⊕ g(m3 ),
H 0 = h0 ⊕ g(m3 ) ⊕ g(m1 ) ⊕ g(m2 ).
76
Da die XOR-Operation kommutativ ist, ergibt sich daraus, dass die beide Hashwerte übereinstimmen. Man kann hier feststellen, dass es nicht einfach ist, einen
Nachrichtenblock direkt aus der Gleichung hi = hi−1 ⊕ g(mi ) herauszufinden, Da
die Funktion g schwierig umzukehren ist.
• Forward-Angriff (F): Dieser Angriff ist eine Variante eines 2nd -PreimageAngriffs. Dabei können einige Teile des zweiten Urbildes frei gewählt werden.
Ist eine Nachricht m gegeben , so wird ein 2nd -Preimage m0 wie folgt konstruiert:
Bezeichne mit mi einen Nachrichtblock von m. Die Aufgabe bei diesem Angriff
besteht darin, zunächst für j < i alle mj durch m0j zu ersetzen und dann ein
m0i 6= mi zu bestimmen, sodass gilt
hi = f (hi−1 , mi ) = f (h0i−1 , m0i ).
• Backward-Angriff (B): Dieser Angriff besteht darin, zu gegebenem hi ein Paar
(hi−1 , mi ) mit hi = f (hi−1 , mi ) zu finden. Das geshieht folgendermaßen:
Die Gleichung hi = f (hi−1 , mi ) wird zunächst für ein gewünschtes mi nach hi−1
aufgelöst, mit dem Ziel, dass dieses einen nützlichen Wert ergibt. Ist nicht der
Fall, so wiederholt sich der Vorgang nochmal für kleine Modifikationen von mi .
• Fixpunkt-Angriff (FP): Bei diesem Angriff geht es darum, hi−1 und mi mit
hi−1 = f (hi−1 , mi ) zu finden. Solcher Angriff kann als 2nd -Preimage-Angriff aufgefasst werden, indem zu gegebenem hi−1 ein passendes mi sucht. Erfüllt f die
Eiwegfunktion, so lässt sich dieser Angriff schwierig durchzuführen.
Die Tabelle 4.1 stellt die Ergebnisse der PGV-Untersuchung dar. Mit s+ bzw. − kenngezeichnete Schemata entsprechen den sicheren bzw. schwachen Konstruktionen.
Preneel, Govaerts und Vandewalle [57] kamen zu einem wichtigen Ergebnis, dass nur 12
Kanditaten von gesamten Möglichkeiten sicher sind. Um dieses Ergebnis zu bestätigen,
wurde die DES-basierte Konstruktion untersucht. Das daraus resultierende Ergebnis zeigte, dass nur vier Hashfunktionen wirklich sind, während die 8 restlichen eine Schwachstelle bezüglich des Fixpunkte-Angriff aufweisen, aber das ist, wie schon
erwähnt, glücklicherweise durch den Präfixfreien Codierungs- Ansatz [16](Prefix-free
Encoding) vermeidbar.
Diese 12 sichere PGV-Hashfunktionen sind in der Tabelle 4.2 vorgestellt, wobei die 4
ersten sicher und die 8 restlichen anfällig gegen den Fixpunkte-Angriff sind.
Bemerkung 4.3
Es ist wichtig zu beachten, dass alle diese Konstruktionen eine gemeinsame Eigenschaften teilen. Bei jeder Iteration wird der Schlüssel verwendet, welcher in der vorherigen
Iteration bereitgestellt wurde. Das ist nicht der Fall bei gängigen Blockchiffren, die
77
Feedforward Ak
v
mi
hi−1
wi
Schlüssel Ak
mi
hi−1
wi
v
mi
hi−1
wi
v
mi
hi−1
wi
v
mi
hi−1
wi
v
mi
−
D
B
−
−
s+
FP
−
P
D
FP
D
P
s+
B
P
Klartext Ak
hi−1 wi v
B
B
−
−
D
−
B
F
F
−
D
−
B
B
−
D
s+ D
FP B
B
D
B
−
FP FP
P
−
D
−
FP B
B
−
D
−
FP FP P
D
s+ D
B
F
F
D
F
D
Tabelle 4.1: PGV-Angriffe auf die 64 Konstruktionen.
No.
1
2
3
4
5
6
7
8
9
10
11
12
Kompressionsfunktion
ehi−1 (mi ) ⊕ mi
ehi−1 (wi ) ⊕ wi
ehi−1 (mi ) ⊕ wi
ehi−1 (wi ) ⊕ mi
emi (hi−1 ) ⊕ hi−1
emi (wi ) ⊕ wi
emi (hi−1 ) ⊕ wi
emi (wi ) ⊕ hi−1
ewi (mi ) ⊕ mi
ewi (hi−1 ) ⊕ hi−1
ewi (mi ) ⊕ hi−1
ewi (hi−1 ) ⊕ mi
Tabelle 4.2: Die 12 sichere PGV-Hashfunktionen.
über einen inneren Key Scheduling Algorithmus (KSA) verfügen. Liegt eine Blockchiffre mit eine langsamen Key Scheduling Algorithmus vor, so kann sich den Ansatz
der 12 Konstruktionen auf die Effizienz und die Qualität der daraus entstehenden
Hashfunktion vorteilhaft auswirken.
78
4.3.2.2 ICM-Analyse
Im vorhergehenden Abschnitt haben wir gesehen, dass sich lediglich 12 sichere Konstruktionen ergaben, welche ohne Beweise in [57] vorgestellt wurden.
Die Autoren in [57] haben einfach behauptet, dass es möglich ist, Sicherheitsbeweise
für diese Schemas geben zu können, auf die selbe Weise wie es in der Arbeit von Winternitz in [75] vorgestellt wurde. Dabei wurde es gezeigt, dass das MMO-Schema in
einem Modell sicher ist. Das Modell basiert grundsätzlich auf der Annahme, dass der
DES-Algorithmus als eine Black-Box angesehen werden soll. Das selbe Modell wurde
dann später von Merkle in [46] verwendet.
Die Analyse, mit der wir uns im Folgenden beschäftigen wollen, wurde zuerst im Jahr
2002 von Black, Rogaway und Schrimpton (BRS) [10] in 2002 veröffentlicht und später
von Lei Duo und Chao Li (DC) [21] im Jahr 2006 verbessert. Wir werden hier die letzte
Analyse vorstellen, da sie eine verbesserte Variante von BRS ist.
Diese Analyse wurde im Ideal-Cipher-Modell durchgeführt, in welchem jede PGVBlockchiffre e zufällig aus der Menge aller Blockchiffren Ek,n ausgwählt wurde. Die
Verschlüsselungsfunktion e (bezeichnet mit R1 ) und die Entschlüsselungsfunktion e−1
(bezeichnet mit R2 ) können als zwei verschiedenen Orakeln aufgefasst werden, deren
Aufgaben unterschiedlich und wie folgt festgelegt sind:
• Das Orakel R1 erält einen Schlüssel K und einen Klartext x und gibt zufällig
einen Chiffretext y zurück.
• Das Orakel R2 bekommt dagegen einen Schlüssel K und Chiffretext y und gibt
zufällig einen Klartext x zurück.
Ein Gegner A, der eine Blockchiffre-basierte Hashfunktion he angreifen will, wobei
e die verwendete Blockchiffre ist, hat den Zugang zu R1 und R2 , indem er sie auf
folgende Wiese befragt:
• Sendet A eine Anfrage (K, x) an R1 , so bekommt er ein y zurück.
• Stellt A dem Orakel R2 die Frage (K, y), so erhält er ein x.
Dieses Szenario geht davon aus, dass jede bereits gestellte Frage nicht mehr wiederholt
werden soll. Mit anderen Worten wird die Frage (K, x) mit einem y beantwortet, so
ist es nicht möglich, die Frage (K, y) zu stellen.
Die DC-Analyse wurde für alle 64 PGV-Konstruktionen durchgeführt. Es kam zu Beschluss, dass 20 Hashfunktionen sicher sind, welche die 12 sicheren PGV-Hashfunktionen
enthalten. Diese 20 Schemata, welche in der Tabelle 4.3 dargestellt werden, lassen sich
79
im Wesentlich in zwei verschiedenen Gruppen einteilen, welche mit G1 bzw. G2 bezeichnet werden und folgende sind:
G1 = {h1 , h2 , · · · , h12 } ,
G2 = {h13 , · · · , h20 } .
i
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
hi
ehi−1 (mi ) ⊕ wi
emi (hi−1 ) ⊕ hi−1
emi (wi ) ⊕ wi
ewi (mi ) ⊕ mi
ewi (hi−1 ) ⊕ hi−1
ewi (mi )
ewi (mi ) ⊕ wi
emi (hi−1 )
ewi (hi−1 )
emi (hi−1 ) ⊕ mi
ewi (hi−1 ) ⊕ wi
emi (wi )
emi (wi ) ⊕ mi
Tabelle 4.3: Die 20 ICM-sichere PGV-Hashfunktionen.
Die Gruppe G1 entspricht genau der 12 sicheren Konstruktionen, welche sich aus der
PGV-Analyse [57] ergaben, während G2 die 8 zusätlichen nach DC-Analyse [10] kollisionsresistente Konstruktionen darstellen.
Diese zwei Gruppen wurden auf zwei unterschiedliche Weisen von BRS [10] analysiert.
Dabei basierten die Sicherheitsbeweisen für G1 auf dem Merkle-Damgaard Paradigma (Theorem 3.1), welches besagt, dass die Kollisionsresistenz jeder Kompressionsfunktion fi , ( 1 ≤ i ≤ 12) die Kollisionsresistenz der daraus entstehenden Hashfunktion hi , ( 1 ≤ i ≤ 12) impliziert. Bei G2 konnte das Merkle-Damgaard Paradigma
überhaupt nicht angewendet werden, weil die verwendten Kompressionsfunktionen die
80
Kollisionsresistenz-Eigenschaft nicht aufweisen und deshalb wurden die Sicherheitsbeweisen graphenbasiert geführt. Mehere Details dazu finden sich in [10].
Bevor wir uns mit der DC-Analyse beschäftigen, wollen wir einige Begriffe und Defintionen der Graphentheorie einführen, die zum Verständnis dieses Abschnitt beitragen.
Definition 4.10 (Plain bzw.MD-Padding)
Sei m eine Nachricht, deren Bitlänge s beträgt mit s ≤ 2n/2 − 1. Seien p und p0 zwei
natürliche Zahlen mit folgenden Eigenschaften:
p + s + 1 = n/2 mod n,
p0 + s + 1 = 0 mod n,
wobei n die Hashwertlänge ist. Definieren wir zwei Arten von Paddingsvorgänge. Diese
werden Plain- bzw. MD-Padding genannt (bezeichnet mit Plain-Pad bzw. MD-Pad)
und sind folgende:
P lain − P ad = m||1||0(p) ,
0
M D − P ad = m||1||0(p ) ||BinL(m),
wobei 0(k) die Konkatenierung von k Nullen bezeichnet und BinL(m) für die binäre
Darstellung der Nachricht m steht.
Definition 4.11 (Digraph)
Ein Digraph (auch gerichteter Graph)(engl.directed graph) G = (VG , EG ) eine ist eine
nichtleere Menge VG von Knoten (engl. vertex ), einer eventuell leeren Menge EG von
gerichteten Kanten(engl. arc) und einer Inzidenzfunktion ψ : EG → VG × VG ,damit:
ψ(t) = (v, w) mit t ∈ EG und v, w ∈ VG (Schreibweise: t = (v, w) oder t = arc v → w ).
Definition 4.12 (Weg oder Pfad)
Sei G = (VG , EG ) ein Digraph. Eine Knotenfolge (v0 , v2 , · · · , vr ) mit (vi−1 , vi ) ∈ EG
für i = 1, · · · , r heisst Weg oder Pfad von v0 nach vr .
Definition 4.13 (Kreis)
Ein geschlossener Weg heißt auch Kreis (cycle), wenn er mindestens eine Kante enthält.
Definition 4.14 (Länge)
Die Länge des Weges P ist die Anzahl seiner Kanten.
81
Definition 4.15 (zusammenhängend (connected))
Ein Digragh G heißt zusammenhängend (connected), wenn je zwei Knoten aus G verbunden sind.
Definition 4.16 (Unterdigraph)
Digraph G0 = (VG0 , EG0 ) heisst Untergraph von G = (VG , EG ) falls
VG0 ⊂ VG und EG0 ⊂ EG .
Definition 4.17 (Merkle-Damgård-Graph)
Sei h eine MD-Hashfunktion und f die zugrunde liegende Kompressionsfunktion mit
f : {0, 1}n × {0, 1}k −→ {0, 1}n
Ein Merkle-Damgaard-Graph ist ein Digraph G = (VG , EG ) mit
VG ⊆ {0, 1}n
und
EG = {(y 0 , x, y)} ⊆ {0, 1}n × {0, 1}k × {0, 1}n ,
wobei y 0 = f (y, x).
Bei der DC-Analyse wurde eine Angriffsmethode angewendet, die auf Graphenthoerie
basiert. Diese Methode benutzt den Algorithmus 5, welcher ein Blochchiffre-Orakel
simuliert und die folgende Menge verwendet.
• D(eK ) = {x|eK (x) nicht definiert} .
• D(eK ) = {0, 1}n \ D(eK ).
• R(eK ) = {eK (x) nicht definiert} .
• R(eK ) = {0, 1}n \ R(eK ).
Die Angriffsidee besteht darin, dass der Angreifer A einen Digraph erstellt, in dem
zwei Pfade enthalten sind, die sich in zwei Knoten schneiden. Das geschieht, indem er
parallel den Algorithmus 5 ausführt und einen Digraph GH aufzeichnet, wobei H für
eine beliebige Hashfunktion aus G1 ∪G2 steht. Der Digraph GH wird aus den Nachrichtenblöcke mi und den Zwischenergebnisse hi−1 und hi erzeugt. Diese Angriffsmethode
wird in [21] als Graph-Drawing-Attack bezeichnet und sieht folgendermassen aus:
82
Algorithm 5 SimulateOracles(A, n)
1. Eingabe: Zwei Orakeln R1 und R2 sowie ein Angreifer A.
2. Initialisierung: i = 0, eK (x) = undef iniert , ∀ (K, x) ∈ {0, 1}n × {0, 1}n
3. Fall 1: Falls A eine Anfrage (K, y) an das Orakel R2 sendet:
3.1. i ← i + 1.
3.2. Ki ← K.
3.3. yi ← y.
$
3.4. yi ← R(eK )
3.5. eK (x) ← yi
3.6. Gebe yi dem A zurück
4. Fall 2: Falls A eine Anfrage (K, x) an das Orakel R1 sendet:
4.1. i ← i + 1.
4.2. Ki ← K.
4.3. xi ← x.
$
4.4. xi ← D(eK )
4.5. eK (xi ) ← y
4.6. Gebe xi dem A zurück
3. Ausgabe: Beendet A seine Anfragen, so werden alle (xj , Kj , yj ) ausgegeben.
83
Zunächst führt der Angreifer den Algorithmus 5 aus, um eine Menge von Tripeln
(x, K, y) zu bekommen. Unter Benutzung dreier Funktionen gi , i = 1, 2, 3 berechnet
er für jedes (x, K, y) drei Werte gi (x, K, y), i = 1, 2, 3, mit dem Absicht, dass diese
Werte jeweils ein Knot eines Graphes GH bildden.
Diese Funktionen sind in Tabelle 4.4 explizit definiert und erfüllen die folgende Eigenschaften:
gi : {0, 1}n × {0, 1}k −→ {0, 1}n , i = 1, 2, 3.
Mit
g1 (x, K, y) = hi−1 ,
g2 (x, K, y) = mi ,
g3 (x, K, y) = hi ,
wobei hi = fi (hi−1 , mi ), i = 1, · · · , 20. Diese Gleichung ist äquivalent zu
g3 (x, K, y) = fi (g1 (x, K, y), g2 (x, K, y)), i = 1, · · · , 20.
Ist das Ziel erreicht, so erzeugt er einen zusammenhängenden Untergraph von GH ,
welcher zwei Pfäde beinhält, die dieselbe Anfangsknot bzw. Endknot haben.
Bezeichnen wir mit GiH = (VGiH , EGiH ) einen Digrah, den der Angreifer konstruiert
hat, indem die beide Orakeln insgesamt i mal gefragt wurden. Am Anfang wird GiH
mit G0H = IV initialisiert. Das heisst, G0H besteht aus einem einzigen Knot IV . Um
einen Digrah zu erstellen, wird den folgenden Algorithmus namens GraphDrawing
ausgeführt:
Wenn der Angreifer einen zusammenhängenden Unterdigraph G0H aus GH extrahiert,
dann kann er eine Kollision für H bilden. Eine Kollision für H besteht in diesem Fall
aus zwei Pfäde P1 und P2 , welche folgendermaßen definiert sind:
m
ml
m0
m0l
P1 = h0 →1 · · · →1 hl1 ,
P2 = h00 →1 · · · →2 h0l2 .
unter Voraussetzung
h0 = h00 und hl1 = h0l2 .
84
i
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
g1
K
K
K
K
x
x⊕K
x
x⊕K
x⊕K
x
x⊕K
x
x⊕K
x⊕K
x
x
x
x
x⊕K
x⊕K
g2
x
x⊕K
x
x
K
K
K
x
x
x⊕K
x
x⊕K
x
x
K
x⊕K
K
x⊕K
K
K
g3
y⊕x
y⊕x
y⊕x
y⊕x⊕K
y⊕x
y⊕x
y⊕x⊕K
y⊕x⊕K
y⊕K
y⊕K
y⊕x⊕K
y⊕x⊕K
y
y⊕K
y
y
y⊕K
y⊕K
y
y⊕K
hi
emi (hi−1 ) ⊕ hi−1
emi (wi ) ⊕ wi
ewi (mi ) ⊕ mi
ewi (hi−1 ) ⊕ hi−1
ewi (mi )
ewi (mi ) ⊕ wi
emi (hi−1 )
ewi (hi−1 )
emi (hi−1 ) ⊕ mi
ewi (hi−1 ) ⊕ wi
emi (wi )
emi (wi ) ⊕ mi
Tabelle 4.4: Methoden zur Konstruktion von Knoten und Kanten eines Graphs.
Es ist zu beachten, dass kein MD-Padding in dieser Angriffsmethode durchgeführt
wurde. Wäre der Fall, so müssen die zwei erzeugten Pfäde die gleiche Länge haben.
Deswegen ist es wichtig zu betonen, dass das MD-Padding die Analyseergebnisse beeinflusst.
Im Folgenden beschäftigt sich die Sicherheitsanaylse zunächst mit der Kollisionsresistenz und danach mit (2nd ) Preimage-Resistenz von 20 Schemata, die in [10] als sicher
charakteresiert sind. Ausserdem werden hier nur die wichtige Theoreme gegeben, welche die Sicherheitskomplexität jeder Gruppe angeben.
Auf die theoretischen Beweise für diesen Theoreme werden wir verzichten. Wir geben
stattdessen nur Beweiskisszen. Die ausführliche Beweisen finden sich in [21].
4.3.2.2.1 Kollisionsresistenz In diesem Abschnitt werden wir uns mit der Kollisionsresistenz der 20 sicheren PGV-Schemata befassen und auf den Aufwand des Kollisionsangriffs eingehen, welcher auf der bereits vorgestellten Graph-Drawing-Methode
85
Algorithm 6 GraphDrawing(A, n)
1. Eingabe: Zwei Orakeln R1 und R2 sowie ein Angreifer A.
2. Initialisierung: i = 0, eK (x) = nicht − def iniert , ∀ (K, x) ∈ {0, 1}n × {0, 1}n ,
GH = G0H .
3. Ausführung: Führe den Algoritmus 5 aus, dessen Ausgabe eine Menge von
Tupeln (xj , Kj , yj ) ist.
4. Erstellung eines Graphs:
4.1. VGiH ← VGi−1 ∪ {g1 (xi , Ki , yi ), g3 (xi , Ki , yi )}.
H
4.2. EGiH ← EGi−1 ∪ {g1 (xi , Ki , yi ), g2 (xi , Ki , yi ), g3 (xi , Ki , yi )}.
H
5. Ausgabe: Beendet A seine Anfragen, so werden alle (xj , Kj , yj ) und
den dazugehörigen Graph ausgegeben.
basiert. Die Komplexität dieses Angriffs hängt hauptsächlich von der Paddingsmethode ab, je nach dem, ob ein MD-Padding oder ein Plain-Padding durchgeführt wurde.
Theorem 4.1 (Oberschranke der Komplexität)
Sei H eine Hashfunktion, welche einen Hashwert der Länge n mit n ≥ 1 produziert.
Wird das Plain-Padding duchrgefürt, so gelten die folgenden Ungleichungen:
Koll
AdvH
(A) ≤ q(q + 1)/2n
für jede q ≥ 1 , H ∈ G1 ∪ G2 .
Beweisskizze: Die Beweisidee basiert auf dem Algorithmus 6) und ist folgende:
Sei A ein Angreifer, der eine Kollision für eine beliebige H ∈ G1 ∪ G2 finden möchte.
Zunächst führt er den Graph-Drawing-Algorithmus aus, mit G0H = {IV }. Angenommen, dass der Angreifer insgesamt q Fragen den Orakeln stellt, mit dem Ziel, einen
zusammenhängenden Unterdigraph Ug ⊂ GH zu bilden.
Betrachten wir das folgende Ereignis E
E = Es existiert ein solcher Unterdigraph mit dem Kreis C und dem Anfangsknot
”
IV “.
Ferner definieren noch ein weiteres Ereignis Ei mit
86
Ei = Der Unterdigraph Ug lässt sich nach i-Anfrage erzeugt werden.“,
”
wobei E0 die Leermenge ist.
Also gilt
Pr [E] =
Pq
i=1
Pr Ei |Ei−1 ∧ · · · ∧ E0 .
Jedes Summenglied der rechten Seite besagt, dass der Underdigraph erst bei der i−ten
Anfrage erstellt werden kann. Das heisst, der Angriff war bis zur (i − 1) − ten Anfrage
gescheitert.
Zum Beweis des Theorems wurden zwei wichtige Behauptungen in [21] eingeführt, die
wir hier ohne Beweise annehmen.
1. Behauptung 1:
2. Behauptung 2:
AdvhKoll (A) ≤ Pr [E] .
Pr Ei |Ei−1 ∧ · · · ∧ E0 ≤
i
.
2n −i+1
Jetzt können wir den Beweis für das Theorem 4.1 vervollständigen. Es gilt also
AdvhKoll (A)
≤ Pr [E] =
q
X
Pr Ei |Ei−1 ∧ · · · ∧ E0
i=1
q
≤
X
i=1
q
≤
X
2n
i
−i+1
i = q(q + 1)/2n .
i=1
≤ q(q + 1)/2n .
Theorem 4.2 (Unterschranke der Komplexität)
Sei H eine Hashfunktion, welche einen Hashwert der Länge n mit n ≥ 1 produziert.
Wird ein Plain-Padding duchrgefürt, so gelten die folgenden Ungleichungen:
Koll
(A) ≥ q(q + 1)/2n+1
AdvH
für jede q ≥ 1 , H ∈ G1 ∪ G2 .
87
Beweisskizze: Sei A ein Angreifer auf eine beliebige Hashfunktion H ∈ G1 ∪ G2 ,
mit dem Absicht, eine Kollision für dieses Hashfunktion zu finden. Zunächst führt
er den Graph-Drawing-Algorithmus aus, mit G0H = {IV }. Angenommen, dass A nur
Anfragen der Form (x, K) auswählt, mit dem Ziel, dass dem Wert g1 (x, K, ?) in GiH
enthalten ist.
Die Fragezeichen in g1 (x, K, ?) stellt die unbekannte Antwort y dar, bevor sie dem Angreifer zurückgeschickt wird. Also ist Digraph GH zusammenhängend und IV ∈ GH .
Analog zu vorhergendem Theorem, betrachten wir die folgenden Ereignisse
F = IV ∈ GH . und GH besitzt einen Kreis C“.
”
und
Fi = Der Kreis C wird nach nach i Anfragen erstellt“,
”
wobei F0 die Leermenge bezeichnet.
Also gilt:
Pr [F ] =
Pq
i=1
Pr Fi |Fi−1 ∧ · · · ∧ F0 .
Um die obige Ungleichung zu zeigen, benötigen wir zwei weitere Ungleichungen, deren
Beweisen in [21] gegeben sind.
1.
2.
Koll
(A) ≥ Pr [F ] .
AdvH
Pr Fi |Fi−1 ∧ · · · ∧ F0 ≥
(1)
i
.
2n
(2)
Aus (1) und (2) folgt
Koll
AdvH
(A) ≥ Pr [F ]
q
X
≥
Pr Fi |Fi−1 ∧ · · · ∧ F0
i=1
q
X
i
≥
2n
i=1
= q(q + 1)/2n+1 .
88
Wenn das MD-Padding durchgeführt wird, dann erhalten wir die folgenden Ergebnisse,
die sich völlig zu vorherigen Ergebnisse unterscheiden.
Theorem 4.3 (Unterschranke bzw.Oberschranke der Kompexität)
Sei H eine Hashfunktion, welche einen Hashwert der Länge n mit n ≥ 1 erzeugt. Wird
ein MD-Padding duchrgefürt, so gelten die folgenden Ungleichungen:
Koll
q(q − 1)/2n ≤ AdvH
(A) ≤ q(q − 1)/2n+1 ,
q ≥ 1 , H ∈ G1 ∪ G2 .
4.3.2.2.2 Preimage-Resistenz Jedes Urbid kann als ein gerichteter Pfad aufgefasst
wird, welcher das Initialknot IV mit einem vorgegebenen Knot β in einem Digraph
GH vebindet. Im Gegensatz zu Kollisionsresistenz-Analyse ist der Komplexität eines Preimage-Angriffs mithilfe der Graph-Drawing-Methode artunabhängig von dem
Padding. Mit anderen Worten erhält man die gleichen Ergebnisse unabhängig davon,
ob ein Plain Padding oder MD-Pading durchgeführt wird. In Folgenden werden wir
Theoreme angeben, deren Beweise sich in [21] finden.
Theorem 4.4 (Preimage)
Seien n die Hashwertlänge und ein vorgegebenes Target β . Also es gilt:
1.
P re
(A) ≤ q/2n−1 ,
q/2n ≤ AdvH
2.
P re
q(q + 1)/2n+2 ≤ AdvH
(A) ≤ q(q + 1)/2n+1 ,
q ≥ 1 , H ∈ G1 .
q ≥ 1 , H ∈ G1 ∪ G2 .
Beweis : Siehe [21].
4.3.2.2.3 2nd -Preimage-Resistenz Hier werden die zwei Typen des Paddings
berüchsichtigt. In Abhängigkeit von diesen Arten kommen zwei verschieden Ergebnisse heraus, welche im Folgenden als zwei Theoreme ohne Beweise gegeben sind.
Theorem 4.5 (2nd -Preimage mit Plain Padding)
Seien n ≥ 1 der Hashwertlänge und H eine Hashfunktion H. Falls jede Nachricht aus
r Blöcke besteht und H(m, IV ) = β, wobei für ein vorgegebenes Target steht, Dann
gelten die folgenden Ungleichungen:
1.
sP re
(r + 1)q/2n ≤ AdvH
(A) ≤ (r + 1)q/2n−1 ,
2.
sP re
q(4r + q + 3)/2n+2 ≤ AdvH
(A) ≤ q(2r + q + 3)/2n ,
q ≥ 1 , H ∈ G1 .
q ≥ 1 , H ∈ G2 .
Theorem 4.6 (2nd -Preimage mit MD-Padding)
Seien n ≥ 1 der Hashwertlänge und H eine Hashfunktion H. Falls jede Nachricht aus
89
r Blöcke besteht und H(m, IV ) = β, wobei für ein vorgegebenes Target steht, Dann
gelten die folgenden Ungleichungen:
sP re
1.
(r + 1)q/2n ≤ AdvH
(A) ≤ (r + 1)q/2n−1 , q ≥ 1 , H ∈ G1 .
sP re
2.
q(4r + q + 3)/2n+2 ≤ AdvH
(A) ≤ q(2r + q + 3)/2n , q ≥ 1 , H ∈ G2 .
Zusammenfassung der Ergebnisse Alle Ergebnisse, die wir aus ICM-Analyse erhalten haben, sind tabellarisch nochmal vorgestellt :
Kollisionsresistenz
PGV-Gruppe Unterschranke Oberschranke
{h1 , · · · h20 } q(q + 1)/2n+1 q(q + 1)/2n
Tabelle 4.5: Die Kollisionsresistenz der 20 PGV-Konstruktionen.
Preimage-Resistenz
PGV-Gruppe Unterschranke Oberschranke
{h1 , · · · h12 }
q/2n
q/2n−1
{h13 , · · · h20 } q(q + 1)/2n+2 q(q + 1)/2n
Tabelle 4.6: Die Preimage-Resistenz der 20 PGV-Konstruktionen.
2nd -Preimage mit Plain
PGV-Gruppe
Unterschranke
{h1 , · · · h4 }
q(r + 1)/2n+2
{h5 , · · · h12 }
q(r + 1)/2n+2
{h13 , · · · h20 } q(q + 4r + 3)/2n+2
Padding
Oberschranke
q(r + 1)/2n
q(r + 1)/2n+1
q(q + 2r + 1)/2n
Tabelle 4.7: Die 2nd -Preimage-Resistenz der 20 PGV-Konstruktionen mit Plain-Pad.
2nd -Preimage mit MD-Padding
{h1 , · · · h4 }
q/2n
q/2n−1
n+2
{h5 , · · · h12 } q(r − 1)/2
q(r − 1)/2n
{h13 , · · · h20 } q(q + 2r)/2n+2 q(q + r)/2n
Tabelle 4.8: Die 2nd -Preimage-Resistenz der 20 PGV-Konstruktionen mit MD-Pad.
90
Sicherheistniveaus der 20 sicheren Konstruktionen Um die Sicherheitsniveaus
der 20 sicheren Konstruktionen approximativ zu erhlaten, werden die Unterschranke
des Vorteils jedes Angriffs mit dem Wert 1/2 gleichgesetzt, und nach der Anzahl der
Anfragen q aufgelöst, unter Verwendung der Approximation q(q + s) ≈ q 2 , wobei
s ∈ {1, r, 2r, 2r + 1, 4r + 3} ist. Daraus ergeben sich die nachstehenden Ergebnisse:
Hashfunktion
{h1 , · · · h4 }
{h5 , · · · h12 }
{h13 , · · · h20 }
Kollision
2n/2
2n/2
2n/2
Preimage
2nd -Preimage
2n−1
2n /(r + 1) (Plain)
2n−1 (MD)
2n−1
2n /(r + 1) (Plain)
2n+1 /(r − 1) (MD)
2(n+1)/2
2(n+1)/2 (Plain)
2(n+1)/2 (MD)
Tabelle 4.9: Die Sicherheistniveaus der 20 sicheren PGV-Konstruktionen.
4.4 Double-Block-Length Konstruktionen
Als alternative Konstruktionen für die bekannten Hashfunktionen wie MD5 und SHA1 ist die Verwendung von Blockchiffren als Kompressionsfunktion. Ein großer Nachteil
bei diesen Konstruktionen liegt hauptsächlich darin, dass die Ausgabelänge im Allgemein beschränkt ist. Mit anderen Worten: Bei der Benutzung von Blockchiffren, die
zum Beispiel 128 Bit Outputlänge liefern, liegt die maximale Komplexität zum Finden
einer Kollision nur bei 264 Hashberechnungen. Eine mögliche und allgemeine Lösung,
die Beschränkung dieses Sicherheitsniveaus zu überwinden, ist die Verwendung von
einer Double Block-length-Hashfunktion (bezeichnet mit DBL), deren Ausgabelänge
(Hashlänge) doppelt so lang ist wie die Ausgabelänge der zugrunde liegenden Blockchiffre. Wenn beispielsweise das DES bzw. AES als Kompressionsfunktion verwendet
wird, dann erhält man nur einen 128 bzw. 256 Bit Hashwert; der Einsatz im Bereich
der digitalen Signaturen ist also nicht zu empfehlen. Im folgenden Abschnitt gehen wir
auf einige wichtige Konstruktionen von DBL-Hashfunktionen sowie ihre Sicherheit auf.
4.4.1 MDC-2 und MDC-4
Die MDC-2 und MDC-4 zählen zu den meist bekannten DBL-Hashfunktionen. Sie wurden von B.Brachtl und Coppersmith et al. [47, 11] entwickelt. Wie in der Abbildung
4.5 dargestellt wird, besteht die MDC-2 im Wesentlichen aus den zwei Anwendungen
der Matyas-Meyer-Oseas-Kompressionsfunktion und kann wie folgt beschrieben werden:
Zunächst wird die Nachricht in t Blöcke mi der Länge n eingeteilt. Ein Block geht zwei
mal und parallel als Klartext in die Blockchiffre ein. Die Grundidee der Hasherzeugung ist, dass zwei Zwischenergebnisse hi−1 und h0i−1 als Schlüsseln verwendet werden
91
, um zwei Hashwerte hi und h0i mit je n Bits zu berechnen, deren Konkatenation dem
endgültigen Hashwert nach der letzten Runde entspricht. Unter Verwendung zweier
Initialwerte h0 und h00 sieht der genaue Ablauf der Hashberechnung formal folgendermaßen aus:
Ti = ehi−1 (mi ) ⊕ mi = LTi ||RTi
Ti0 = eh0i−1 (mi ) ⊕ mi = LTi0 ||RTi0
hi = LTi ||RTi0
h0i = LTi0 ||RTi
Nach t Iterationen erhalten wir einen 2n-Bit-Hashwert MDC2 mit
M DC2 = ht ||h0t .
Abbildung 4.5: Die MDC-2 Kompressionsfunktion.
Wie die Abbildung 4.6 verdeudlich wird bei der MDC-4 Hashfunktion die MDC-2Kompressionsfunktion zweimal ausgeführt. Bei der zweiten Anwendung der MDC-2
92
werden die benötigten Schlüsseln aus den Ergebnissen (Hashwerte) der ersten MDC-2Ausführung abgeleitet. Die Klartexte entstehen aus den Ausgaben der vorhergehenden
MD4-Kompressionsfunktion, d.h eine MDC-4 Iteration kann als Verkettung von zwei
MDC-2 Runden angesehen werden. Formal beschrieben, verläuft die MDC-4 wie folgt:
Ti = ehi−1 (mi ) ⊕ mi = LTi ||RTi
Ti0 = eh0i−1 (mi ) ⊕ mi = LTi0 ||RTi0
Ui
Ui0
Vi
Vi0
hi
h0i
=
=
=
=
=
=
LTi ||RTi0
LTi0 ||RTi
eUi (h0i−1 ) ⊕ h0i−1 = LVi ||RVi
eUi0 (hi−1 ) ⊕ hi−1 = LVi0 ||RVi0
LVi ||RTi0
LVi0 ||RVi
und der MDC-4 Hashwert ist
M DC4 = ht ||h0t .
Wie man sieht, benötigen MDC-2 und MDC-4 zwei bzw. vier Aufrufe der Blockchiffre,
um einen Nachrichtenblock zu bearbeiten. Deshalb beträgt ihre Hash-Rate 1/2 bzw.
1/4. In [37] wurde gezeigt, dass die MDC-2 Kompressionsfunktion sicherlich nicht kollisionsresistent ist. Für die MDC-4 ist allerdings möglich Kollisionen zu finden, für dessen Auffinden lediglich 23n/4 Kompressionsfunktionsaufrufe statt 22n benötigt werden.
In Bezuf auf Preimage-Resistenz besitzen MDC-2 und MDC-4 eine Sicherheitsniveau
von 23n/4 bzw. 2n .
4.4.2 Parallel Davies-Meyer (Parallel-DM)
Das Parallele Davies-Meyer wurde auf der Kryptokonferenz 93 in [70] vorgeschlagen
mit dem Ziel, eine effiziente 2n-Bit-DBL-Hashfunktion vom Hash-Rate 1 aus einer
(n, n)-Bit-Blockchiffre zu realisieren. Zur Beschreibung allgemeiner Form solcher Konstruktionen werden die Nachrichtenblöcke mi und die Zwischenergebnisse hi jeweils in
zwei n-Bit-Strings zerlegt . Sie sind wie folgt definiert:
(1)
(2)
hi = hi ||hi
(1)
(2)
mi = mi ||mi ,
(j)
wobei jedes hi
(j)
bzw.mi
für j = 1, 2. eine Bitlänge n hat.
93
Abbildung 4.6: Die MDC-4 Kompressionsfunktion.
Die allgemeine Struktur sieht dann folgendermaßen aus:
(1)
hi
= eA (B) ⊕ C
(2)
hi
= eR (S) ⊕ T
(j)
(j)
Dabei sind A, B, CR, S und T binäre Linearkombinationen von {hi , mi , j = 1, 2.}
Diese formale Struktur erzeugt eine Klasse von DBL-Hashfunktionen von Hash-Rate
1. Ein besonderer Spezielfall davon ist das Parallel-DM-Schema, welches in der Abbildung 4.7 dargestellt wird und die folgenden Parametern verwendet:
(1)
(2)
A = mi ⊕ mi
(1)
(1)
(1)
(1)
B = hi ⊕ mi
C = hi ⊕ mi
(1)
R = mi
(2)
(2)
(2)
(2)
S = hi ⊕ mi
T = hi ⊕ mi
94
Abbildung 4.7: Die Parallel Davies-Meyer-Hashfunktion.
Eine weitere Instanz, die auch zu der obigen Klasse gehört, heißt LOKI DoubleHashfunktion. Diese Hashfunktion wurde von L. Brown, J. Pieprzyck, and J. Seberry
in [12] veröffentlicht. Es ist offensichtlich, dass diese Hashfunktionen eine gute Performance aufweisen. Trotzdem wurden diesen beiden Schemata im Jahr 1995 geknackt.
In [38] wurden tatsächlich zwei Angriffe auf das Parallel-DM vorgestellt und zwar ein
Kollisions- und Preimage-Angriff. Mit einer Wahrscheinlichkeit von 63 Prozent können
Kollisionen und Urbilder mit einem Aufwand von 3 · 2n bzw. 3 · 2n/2 gefunden werden. Für das LOKI-Schema benötigt das Auffinden von Kollisionen nach Knudsen,Lai
und Preneel [36] höchstens 23n/4 Hashberechnungen. Diese Autoren haben sogar gezeigt, dass das maximale Sicherheitsniveau in Bezug auf der Kollisionsresistenz für
irgendeine Konstruktion der obigen Klasse 23n/4 beträgt.
4.4.3 Yi-Lam-Hash
Diese Hashfunktion wurde in [78] von Yi und Lam vorgeschlagen. Sie verwendet eine (2n, n)-Blockchiffre-basierte Kompressionsfunktion und erzeugt einen 2n-Bit Hashwert. Um den Hashwert einer Nachricht m zu berechnen, wird m in t Blöcke mit je
n Blöcke gespalten. Im Gegensatz zu den vorherigen Schemas wird bei dieser Hashfunktion eine modulare Addition eingesetzt, mit dem Ziel, das Zustandekommen von
Kollisionen für die Kompressionsfunktion auszuschließen. Darüber hinaus wird bei jeder Iteration das vorhergehende Zwischenergebnis als Schlüssel verwendet.
95
(1)
(2)
Bezeichnen wir mit h0 und h0 zwei Initialwerte mit je n-Bits . Wie die Abbildung 4.8
verdeutlicht, sieht der Ablauf der Hashberechnung wie folgt aus:
(1)
(2)
ki = hi−1 ||hi−1
(1)
hi
= eki (mi ) ⊕ mi
(2)
hi
= (eki (mi ) ⊕ hi−1 )[+]hi−1
(2)
(1)
mod 2n ,
wobei die Operation [+] die modulare Addition darstellt. Der erzeugte Hashwert, der
wir mit YILAM bezeichnen, ist dann durch
(1)
(2)
Y ILAM = ht ||ht
Abbildung 4.8: Die Yi-Lam-Hashfunktion.
gegeben. Trotz der Vermutung, dass diese Konstruktion in [78] sicher [78] ist, wurde
später festgestellt, dass ihr Design anfällig gegen den so genannte Solving-One-HalfAngriff ist. Die Grundidee ist es, die obigen Gleichungen unter bestimmten Bedingungen möglichst getrennt zu lösen.
(1)
(2)
(1)
Zum Beispiel findet man ein Paar (hi−1 , hi−1 ), welches zu dem Zwischenergebnis hi
führt, so lässt sich der gesamte Angriff auf 2n-Bit Hashfunktion auf eine n-Bit Hashfunktion reduzieren. Basierend auf dieser Idee wurde in [42] gezeigt, dass Kollisionen
und Urbilder für die Yi-Lam-Hashfunktion mit wenigem Aufwand in Vergleich zu
Brute-Force-Angriffe gefunden werden können. Für eine Kollision sind nur 3 · 2n/2
statt 2n Hashberechnungen erforderlich. Für ein Preimage bzw. ein zweites Preimage
benötigt man hingegen 2n+1 bzw. 3 · 2n−1 Hashberechnungen.
Weitere Angriffe wurden im Jahr 2000 von David Wagner in [69] publiziert. Er zeigte,
wie die Pseudo-Kollisionen und daher auch vollständige Kollisionen ermittelt werden
können. Seine Angriffstrategie ist, das Design der Yi-Lam so zu vereinfachen, dass ein
Pseudo-Kollisionsangriff durchführbar ist. Um dies zu verwirklichen, wurde die modulare Addition durch die bitweise XOR-Operation ersetzt. Sind Pseudo-Kollisionen
bei vereinfachter Variante erzeugt, so können auch Pseudo-Kollisionen für die Yi-Lam
Hashfunktion und danach volle Kollisionen gefunden werden. Der Gesamtaufwand zum
Finden einer Kollision wurde lediglich auf 2(0.71·n) reduziert.
96
4.4.4 Nandi-Hash
Im Jahr 2005 schlug Nandi in [48] eine Reihe von DBL-Hashfunktionen vor. Sein
Ziel war, die Sicherheit von andere DBL-Konstruktionen wie Luks-Double Schema
[40, 41] und kaskadierten Hashfunktionen aufgrund des Joux-Multikollsionsangriffs
[32] zu erhöhen. Die Grundidee des Vorschlags besteht darin, kollisionsfreie DBLKonstruktionen unter bestimmten Umständen in Black-Box-Modell anhand von Permutationen zu entwerfen. Formal ausgedrückt: Liegen Permutationen p : {0, 1}N →
{0, 1}N und eine Kompressionsfunktion f : {0, 1}N → {0, 1}n mit N ≥ n + 1 vor, so
kann eine sichere 2n-DBL-Kompressionsfunktion F konstruiert werden, deren Form
folgendermaßen aussieht:
F (X) = f (X)||f (p(X)) , X ∈ {0, 1}N .
Basierend auf der vorhergehenden Idee entwickelte Nandi eine Menge von
DBL-Kompressionsfunktionen. Zu diesem Zweck führen einige Begriffe und Definitionen ein.
Definition 4.18 (simpel Permutation)
Sei p : {0, 1}m+n → {0, 1}m+n mit m ≥ n + 1 eine Permutation. P heißt simpel , falls
für alle X ∈ {0, 1}m+n , p(X) und p− (X) leicht zu berechnen sind, wobei p− für die
Inverse von p steht.
Betrachten wir also zwei simpele Permutationen p1 ,p2 und eine Kompressionsfunktion
f mit
f : {0, 1}m+n → {0, 1}n .
Weiterhin definieren wir die folgende DBL-Kompressionsfunktionf p1 ,p2 :
f p1 ,p2 (X) = f (p1 (X))||f (p2 (X)), X ∈ f : {0, 1}m+n .
Falls p1 = id ist, erhalten wir
f id,p (X) = f (X)||f (p(X)), X ∈ {0, 1}m+n .
Zur vereinfachung setzen wir f id,p = f p . Dann wird eine Klasse von DBLKompressionsfunktionen gebildet, die wir mit C bezeichnen.
C = {f p :
p beschreibt alle mögliche simpele Permuattionen.}
Wie bei Single-Block-Length definieren wir eine verallgemeinerte Hash-Rate wie folgt:
97
Definition 4.19 (Hash-Rate)
Sei F eine Double-Length-Kompressionsfunktion, die auf der folgendenen Kompressionsfunktionen fi , i = 1, · · · k basiert mit
F : {0, 1}N → {0, 1}2n ,
fi : {0, 1}m+n → {0, 1}n , i = 1, · · · k.
wobei m für die Bitlänge eines Nachrichtenblocks steht.
−2n
. Dabei ist s die AufruWir definieren die Hash-Rate von F durch den Wert Nm·s
feanzahl aller fi mit i = 1, · · · k, welche Wir zur Berechnung von F (X), X ∈ {0, 1}N
brauchen.
Beispiele
1. Definiere die Funktion F = f1 ||f2 wie folgt:
fi : {0, 1}n+m → {0, 1}n , i = 1, 2.
F : {0, 1}2n+m → {0, 1}n .
F (x1 , x2 , x3 ) = f1 (x1 , x3 )||f2 (x2 , x3 ), wobei |x1 | = |x2 | = n und |x3 | = m. Die
= 12 .
Hash-Rate von F ist gleich 2n+m−n
m·2
2. Sei F (X) = f1 (X)||f2 (X) definiert von {0, 1}n+m nach {0, 1}n . Die Hash-Rate
n
von F ist gleich n+m−2n
= 21 − 2m
. Falls m = 2n dann ist die Hash-Rate 12 .
m·2
3. Die Hash-Rate aller obigen definierten Kompressionsfunktionen f p beträgt auch
1
n
− 2m
.
2
Definition 4.20 (Fixpunkt)
Ein X heißt ein Fixpunkt von einer Permutation p, falls p(X) = X gilt.
Bezeichnen wir im Folgenden Fp als die Menge aller Fixpunkte von p.
Definition 4.21 (gute Permutation (good Permutation))
Sei p eine Permutation auf {0, 1}n+m mit m ≥ n + 1. Definieren wir die Menge
Fp [2n] = z ∈ {0, 1}2n : ∃ m ∈ {0, 1}m−n so dass z||m ∈ Fp .
Eine Permutation p heißt eine gute Permutaion, falls |Fp [2n]| << 2n erfüllt ist.
Betrachten wir eine gute Permutation p und eine Kompressionsfunktion f mit folgenden Eigenschaften
98
f : {0, 1}n+k → {0, 1}n ,
p : {0, 1}n+k → {0, 1}n+k .
wobei k ≥ n + 1. Nehmen wir eine Nachricht m, die in t Blöcke mi mit je (k − n) Bits
zerlegt wird. Bezeichnen wir mit f p die aus p entstehende DBL-Kompressionsfunktion
f p . Die Hashberechnung der Nachricht verläuft wie folgt:
f p : {0, 1}n+k → {0, 1}2n ,
h0 = IV als Initialwert.
hi = f p (hi−1 , mi )
= f (hi−1 , mi )||f (p(hi−1 , mi )), i = 1, · · · t.
Der endgültige Hashwert lautet dann ht .
In [48] wurde gezeigt: Ist die Funktion f als Zufallsorakel modelliert und p eine gute
Permutation, so wird aus jeder Kompressionsfunktion f p eine sichere Hashfunktion
erzeugt, deren Komplexität zum Finden einer Kollision O(2n ) beträgt .
Bemerkung 4.4
1 - Die Double-Wipe-Konstruktion von Luks [40, 41] ist nur eine Instanz der Klasse C
unter Verwendung der folgenden Permutation
p(x, y, z) = y||x||z,
wobei |x| = |y| = n bzw. |z| = m. Die Parameter x und y bzw. z stellen die Zwichenergebnisse bzw. die Nachrichtenblöcke dar.
2 - Neben dem oben beschriebenen Schema stellte Nandi in [49] zwei weitere Konstruktionen vor, deren Hash-Rate 1/3 bzw. 2/3 betragen. Die beiden Schemata basieren auf
so genannte unabhängige Funktionen, welche wie folgt definiert sind:
Definition 4.22 ( Unabhängige Funktion ( Independent Function ))
Eine Familie von Funktionen f1 , f2 · · · fs : D → R heißt unabhängig, falls
∀ {x11 , · · · , xiki } ⊂ D, i = 1, · · · s die Vektoren (fi (xi1 ), · · · , (fi (xiki ))), i = 1, · · · s unabhängig verteilt sind.
99
Nun beschreiben diese zwei Konstruktionen. Die erste DBL-Konstruktion, deren HashRate gleich 1/3 ist, verwendet drei unabhängige Kompressionsfunktionen f1 , f2 , f3 :
{0, 1}2n → {0, 1}2 , um eine DBL-Kompressionsfunktion F zu konstruieren. Diese ist
durch
F (x, y, z) = (f1 (x, y) ⊕ f2 (y, z))||(f2 (y, z) ⊕ f3 (z, x)).
gegeben, mit |x| = |y| = |z| = n. Wie die Abbilddung 4.9 zeigt, kann dieses Schema
trotz ihrer Hash-Rate parallel implementiert werden.
In Bezug auf ihrer Sicherheit vermutete Nandi [49], dass die Komplexität diese Konstruktion im Zufallsorakel-Modell bezüglich der free-start-Kollisionsresistenz8 Ω(22n/3 )
beträgt. Diese Behauptung wurde später in [53] widelegt.Es wurde gezeigt, dass sich
die Komplexität auf Ø(2n/2 ) reduziert, falls die drei verwendete Kompressionsfunktionen durch Blockchiffren ersetzt werden.
Bei der zweiten Konstruktion werden auch drei unabhängige Funktion eingesetzt,die
jeweils im Vergleich zu den obigen Konstruktion drei Parameter übernehmen. Dieses
Schema, dessen Hash-Rate 3/4 beträgt, hat eine höhere Sicherheit im Ideal-Cipher Modell gegen Kollisionsangriffe. Dabei ist die Komplexität Ø(22n/3 ). Schließlich wurde in
[53] festgestellt, dass diese Komplexität nur bei Ø(2n/2 ) liegt, wenn die drei zugrunde
liegenden Kompressionsfunktionen als reale Blockchiffren betrachtet werden.
Abbildung 4.9: Die 1/3-Rate Nandi-Hashfunktion.
4.4.5 Hirose-Hash
Bei der Konstruktion von Hirose [30, 29] ging es hauptsächlich um eine Fortsetzung
der oben besprochenen Grundidee von Nandi [48]. Dabei wurde erklärt, wie man ei8
Eine Hasfunktion f ist free-start-Kollisionsresistent falls, zu gegebenen h0 und m ist es schwierig
eine andere Nachricht m0 mit m0 6= m, so dass gilt :f (h0 , m) = f (h0 , m0 ).
100
ne DBL-Hashfunktion anhand eines kleinen Bauteiles realisieren kann. Genau wie bei
dem Nandi-Schema werden Permutationen und eine n-Bit-Kompressionsfunktion eingesetzt, die bestimmte Eigenschaften erfüllen sollen. Diese Konstruktion wurde auf
zwei Arten aufgestellt, je nach dem zugrunde liegenden Sicherheitsmodell. Zunächst
im Zufallsorakel-Modell und danach im Ideal-Block-Cipher-Modell. In beiden Modellen haben die Ergebnisse der Sicherheitsanalyse gezeigt, dass die Konstruktion eine
signifikante Kollisionsresistenz besitzt. Im Folgenden werden wir zunächst das HiroseSchema in den beiden Sicherheistmodelle vorstellen und danach uns jeweils mit dem
Sicherheitsaspekt beschäftigen.
4.4.5.1 ROM-Konstruktion
In diesem Abschnitt betrachten wir die DBL-Hashfunktionen, deren zugrunde liegenden Kompressionsfunktionen wie folgt definiert sind:
F : {0, 1}2n × {0, 1}b → {0, 1}2n ,
mit F = (F1 , F2 ), wobei
Fi : {0, 1}2n × {0, 1}b → {0, 1}n ,
i = 1, 2.
Zum Hashen einer Nachricht m, wird sie zunächst in k Blöcke mi mit je b Bits gespalten
und danach durch die Kompressionsfunktion F folgendermaßen bearbeitet :
Seien gi und hi die zwei n-Bit Zwischenergebnisse, deren Konkatenation den Hashwert
in der i-ten Iteration bilden. Um die nächsten Hashwerte gi+1 und hi+1 zu erzeugen,
werden die folgende Operationen unter Verwendung einer Permutation p und eine
n-Bit Kompressionsfunktion parallel durchgeführt:
gi+1 = F1 (gi , hi , mi+1 ) = f (gi , hi , mi+1 )
hi+1 = F2 (gi , hi , mi+1 ) = f (p(gi , hi , mi+1 )),
wobei p und f die nachstehende Eigenschaften besitzen:
f : {0, 1}2n × {0, 1}b → {0, 1}n .
p : {0, 1}2n × {0, 1}b → {0, 1}n × {0, 1}b
mit
101
• Dief ist eine zufällig unabhängige Funktion.
• ∀ x ∈ {0, 1}2n+b , p(x) und p− (x) sind leicht zu berechnen.
• ∀ x ∈ {0, 1}2n+b , p(p(x)) = x. D.h, alle x sind Fixpunkte der Permutation p2 .
• ∀ x ∈ {0, 1}2n+b , p(x) 6= x. D.h, p besitzt keinen einzigen Fixpunkt.
Nach der k-ten Iteration wird der endgültige 2n-Bit Hashwert (bezeichnet mit H)
erzeugt
H = gk ||hk .
Nachdem wir den Ablauf der Hasberechnung vorgestellt haben, wollen uns mit der
Sicherheitsanalyse dieser Konstruktion befassen. Zu diesem Zweck werden zwei Annahmen aufgestellt. Erstens wird die Funktion f als Zufallsorakel betrachtet. Zweitens
werden die Anfragen x und p(x) zur selben Zeit an das Orakel gesendet, um den Wert
F (x) zu produzieren.
Eine Kollision für F sind zwei Nachrichten x, y mit x 6= y, so dass F (x) = F (y). Die
Definition von F lautet
F (x) = f (x)||f (p(x)), ∀x.
Daraus folgt
F (x) = F (y) ⇔ f (x)||f (p(x)) = f (y)||f (p(y)).
⇔ f (x) = f (y) und f (p(x)) = f (p(y))
Das impliziert, dass die Mengen {x, y} und {p(x), p(y)} Kollision für f erzeugen.
Daraus ergibt sich die folgende Fallunterscheidung:
1. Falls {x, y} = {p(x), p(y)} :
folgt daraus
Da die Permutation p keine Fixpunkte besitzt,
y = p(x) und x = p(y) mit x 6= y.
Solches Paar heißt ein zusammengehöriges Paar (matching-Paar) für F , sonst
nicht-zusammengehöriges Paar (non-matching-Paar). In diesem Fall sollen x und
P (x) eine Kollision für F bilden.
102
2. Falls {x, y} =
6 {p(x), p(y)} : In diesem Fall muss gelten
y 6= p(x) und x 6= p(y) mit x 6= y.
Sonst y = p(x) oder x = p(y). Nehmen wir an, y = p(x). Wegen p2 = id, muss
also gelten x = p(y) , und damit sind wir wieder im ersten Fall gelandet.
Aus dieser Diskussion können wir feststellen, dass sich das Zustandekommen einer
Kollision für F auf der soeben besprochenen Ereignisse reduziert.
Den Begriff des zusammengehöriges Paares brauchen wir für die Beweisskizze des folgenden Theorems, welche die Oberschranke der Komplexität angibt, um eine Kollision
für F zu finden.
Theorem 4.7 (Kollisionsresistenz)
Seien F die bereits definierte DBL-Kompressionsfunktion und H die daraus basierte
Koll
Hashfunktion. Ausserdem bezeichnen wir mit AdvH
(A) die Erfolgswahrscheinlichkeit, dass ein Angreifer A eine Kollision für H findet. Falls der Angreifer A insgesamt
q Anfragen an das Zufallsorakel F gesendet hat, dann gilt
Koll
AdvH
(A) ≤
q
q(q + 1)
+ n.
2n
2
2
Beweisidee : Betrachten wir das folgende Ereignis E
E := (F (x) = F (y) ∈ {0, 1}2n : x, y ∈ {0, 1}2n+b mitx 6= y
Da jede Kollision (x, y) für F zu einem der obigen Fälle führt, folgt daraus
E := E1 ∨ E2
wobei
E1 = {F (x) = F (y) | y 6= p(x)}
= {f (x) = f (y)} ∧ {f (p(y)) = f (p(x))}
und
E2 = {F (x) = F (y) | y = p(x)}
= {f (x) = f (y)} ∧ {f (x) = f (p(x))}
103
Das Symbol | stellt das bedingte Wahrscheinlichkeitszeichen dar. Die Menge E1 (bzw.
E2 ) beschreibt das Ereignis, bei welchem ein nicht-zusammengehöriges
(bzw.zusammengehöriges) Paar (x, y) eine Kollision erzeugt, wenn genau eine einzige
Frage dem Orakel gestellt wurde.
Da die Funktion f zufällig unabhängig ist, erhalten wir die folgende Ergebnisse
Pr(E1 ) = Pr[{f (x) = f (y)} ∧ {f (p(y)) = f (p(x))}] =
Pr(E2 ) = Pr[{f (x) = f (y)} ∧ {f (x) = f (p(x))}] =
1 1
·
2n 2n
1
2n
Jetzt verallgemeinern wir dieses Ergebnis. Wenn der Angreifer insgesamt q verschiedene Paare (x, y) an das Orakel F geschickt hat, dann ergeben sich andere Wahrscheinlichkeiten für die soeben beschriebene Ereignisse und zwar
q q
Pr(E1 ) = Pr[{f (x) = f (y)} ∧ {f (p(y)) = f (p(x))}] = n · n
2 2
q
Pr(E2 ) = Pr[{f (x) = f (y)} ∧ {f (x) = f (p(x))}] = n
2
Somit ist
Koll
AdvH
(A)
q 2
q q
q
q
≤ n · n + n = n + n.
2 2
2
2
2
Um eine bessere Oberschranke dieser Komplexität zu erlangen, wurde in [30] eine
Instanz dieser Konstruktion vorgeschlagen. Dabei wurde die Permutation p durch eine Konkatenation zweier unabhängigen Funktionen p1 und p2 ersetzt, die wie folgt
festgelegt sind:
p1 : {0, 1}2n → {0, 1}2n ,
p2 : {0, 1}b → {0, 1}b ,
mit p(x, y, z) = (p1 (x, y), p2 (z)). Ausserdem wurde vorausgesetzt, dass p1 keine Fixpunkte in der Menge {0, 1}2n hat, d.h
p1 (x, y) 6= (x, y) , ∀ (x, y) ∈ {0, 1}2n × {0, 1}2n .
104
Als Beispiele für solche Permutation p sind
• p(x, y, z) = (x⊕K, y, z), wobei K ein von Null verschiedenes Element aus {0, 1}n
ist.
• p(x, y, z) = (x ⊕ K1 , y ⊕ K2 , z ⊕ K3 ), wobei K1 , K2 ∈ {0, 1}n mit K1 6= K2 und
K3 ∈ {0, 1}b Konstanten sind.
2
In [30] wurde bewiesen, dass die gesamte Komplexität kleiner gleich 3· 2qn ist, analog
zu dem vorhergehenden Beweis. Die Beweisidee basiert auf der folgenden Mengeninklusion:
E2 = {F (x) = F (y)} ∧ {y = p(x)} ⊆ {F (w0 ) = p1 (F (w))} ∧ {w0 6= p(w)}
wobei (w, w0 ) eine nicht-zusammengehöriges Paar für F darstellt. Da p1 unabhängig
ist, ergibt sich
2
1
0
0
Pr[{F (w ) = p1 (F (w))} ∧ {w 6= p(w)}] =
2n
Dies führt zu
Pr(E2 ) ≤
1
2n
2
Werden insgesamt q Anfragenspaare dem Orakel F gestellt, so erhalten wir
q 2
Pr(E2 ) ≤
2n
und somit ist die gesamte Komplexität
q 2
q 2
q 2
Koll
AdvH (A) ≤
+2· n =3· n .
2n
2
2
Dieses Ergebnis ist im Vergleich zu der vorhergehenden Oberschranke sehr signifikant.
Beispielsweise für n = 128 und q = 280 bekommen wir für die
• Konstruktion 1 :
Koll
AdvH
(A)
q 2
q
≤
+ n ≈ 2−48
n
2
2
105
• Konstruktion 2 :
Koll
AdvH
(A) ≤ 3 ·
q 2
≈ 2−94
2n
4.4.5.2 ICM-Konstruktion
Bei dieser Konstruktion wurde die Kompressionsfunktion F durch eine konkrete (n, n+
b)-Bit-Blockchiffre ersetzt. Diese ist bei der (i + 1)-Iteration wie folgt definiert :
gi+1 = ehi ||mi+1 (hi ) ⊕ hi
hi+1 = ehi ||mi+1 (hi ⊕ K) ⊕ hi ⊕ K
wobei das Symbol || für das Konkatenierungszeichen steht. K ist eine von Null verschiedene Konstante aus {0, 1}n .
Zur Verabeitung eines Nachrichtenblocks benötigt die Kompressionsfunktion F zwei
Aufrufe der eingesetzten Blochchiffre e. Für diese zwei Aufrufe wird eine einzige Keyschelding-Phase gebraucht. Also die Hash-Rate beträgt (k − n)/2n, wobei die k die
Bitlänge des Schlüssels ist und n die Ausgabelänge von e.
Für reale Blockchiffre wie AES192 (k = 192, n = 128, b = 64) bzw. AES256 (k =
256, n = 128, b = 64) erhalten wir die Hash-Rate 1/4 bzw. 1/2. Was die Sicherheit dieses Hashalgorithmus betrifft, so wurde in [30] bewiesen, dass die Erfolgswahrscheinlich2
q
keit zum Finden einer Kollision im Ideal-Block-Cipher-Modell kleiner gleich 3 · 2n−1
ist. Formal heißt dies
q 2
Koll
AdvH
(A) ≤ = 3 · n−1 .
2
106
Abbildung 4.10: Die Double-Length Hashfunktion von Hirose.
107
Kapitel 5
Zusammenfassung
5.1 Zusammenfassung
Kryptographische Hashfunktionen werden in Zukunft immer eine bedeutendere Rolle
spielen, da sie im digitalen IT-Bereich nicht mehr wegzudenken sind. Fast alle zur Zeit
in der Praxis eingesetzten Hashfunktionen wie MD5 und SHA-1 sind nach dem MerkleDamgård Designprinzip [16, 46, 45] konstruiert, welches im Kapitel 3 vorgestellt wird.
Dieses Prinzip besteht darin, kollisionsresistente Hashfunktionen aus kollisionsresistenten Kompressionsfunktionen zu realisieren. In den letzten drei Jahren wurden bei
der Analyse dieses Designs bedeutende neue Erkenntnisse aufgedeckt. Die Ergebnisse haben gezeigt, dass dieses Design sich für die Hashfunktionen als mangelhaft und
empfindlich erwiesen hatte. Aus diesem Grund wurden eine Reihe von Varianten und
Erweiterungen der Merkle-Damgård Konstruktion vorgestellt, die einen Sicherheitsgewinn für Merkle-Damgård Hashfunktion gegen alle möglichen Angriffe bieten, unter
anderem der Joux-MultiKollisionsangriff (Abs. 3.4.2). Einige von diesen Varianten und
Vorschläge werden auch im Kapitel 3 (Abs 3.5) vorgestellt und beschrieben. Die Frage, ob diese Designideen später als Erstaz für die Merkle-Damgård Design gelten oder
ob man auf die ganze Merkle-Damgård Konstruktion verzichten sollte, ist also längst
nicht beantwortet.
Als eine alternative Konstruktion bietet sich die Kaskadierung verschiedener Hashfunktionen, um mehr Sicherheit durch das Zusammensetzen der dazugehörigen Hashwertlänge zu erreichen. Beispielsweise die SHA-1 zusammen mit SHA-224, um einen
Hashwert der Länge 416 Bit zu erzeugen. Aufgrund der möglichen Durchführung des
Joux-Multikollisionsagriffs [32] erzielt diese Konstruktion lediglich einen geringen Sicherheitsgewinn als erwartet, wenn die verwendeten Hashfunktionen nach dem MDDesign gebaut sind. Dies zeigt, dass ein längerer Hashwert nicht unbedingt mehr Sicherheit bedeutet.
Eine wichtige Anwendung des Merkle-Damgård-Prinzips im Bereich der symmetrischen Kryptographie ist die Erzeugung von Hashfunktionen aus Blockchiffren. Dabei
108
Kapitel 5 Zusammenfassung
wird die Kompressionsfunktion durch eine abstrakte Blockchiffre ersetzt. Eine besondere Familie von solchen Hashfunktionen geht auf Preneel, Govaets und Vandewalle
zurück, welche zu den Single-Length Konstruktionen gehört. Dabei ist der zu erzeugende Hashwert genauso gross wie die Blocklänge der benutzten Blockchiffre. Die
PGV-Familie umfasst insgesamt 64 Schemata. Unabhängig von der Sicherheitsmodelle wird gezeigt, dass nur 20 von denen als beweisbar sicher“ angesehen sind. Die Si”
cherheitsanalyse wird sowohl im Black-Box-Modell als auch im Block-Cipher-Modell
durchgeführt; d.h die verwendete Blockchiffre wird als eine idealisierte Blockchiffre
betrachtet. An dieser Stelle erhebt sich jedoch die Frage, ob diese Sicherheit dieser
Konstruktionen in der Praxis sichergestellt wird, wenn die gebräuchlichen Blockchiffren wie AES zum Einsatz kommen. Bisher ist die Antwort nicht klar, weil die realen
Blockchiffren häufig Schwächen aufweisen. Hat man eine bestimmte Schwachstelle entdeckt, so kann man davon ausgehen, dass weitere Schwachstellen existieren.
Da die meisten Single-Length Hashfunktionen in der Praxis Blochchiffren beschränkter
Blocklänge verwenden, also maximal 256 Bit mit AES256 , ist es wegen dem Moore
”
Gesetz“ notwendig, die Sicherheit von solchen Hashfunktionen in Zukunft gegen neuen
Angriffe [32, 77, 73] zu erhöhen, indem die zu erzeugende Hashlänge verdoppelt wird.
Eine kryptographisch robuste Methode, um dieses Ziel zu erreichen, ist der Einsatz von
Double-Length Hasfunktionen, welche in Kapitel 4 Abschnitt 4.4 behandelt werden.
Dabei verläuft die Hashberechnung parallel unter Verwendung zweier oder mehrerer
verschiedener Kompressionsfunktionen, deren Hashwerte gleich lang sind und die den
engültigen Hashwert der gesamten Hashfunktion durch die Konkatenation erzeugen.
Diese Hashfunktionen bieten im theoritischen Sinne eine höhere Sicherheit im IdealBlock-Cipher. Dennoch werden diese in der Praxis selten eingesetzt nicht aber die
kürzlich veröffentlichten Hashfunktion wie etwa die Hirose-Hashfunktion.
5.2 Ausblick
Aufgrund der erstaunlichen Ergebnisse bezüglich Unsicherheit von Hasfunktionen [32,
77, 73] muss in diesem Gebiet viel Arbeit reingesteckt werden. Die öffentliche kryptographische Gemeinschaft muss sich mehr mit dem Thema der Hashfunktionen befassen
und Wissen aneigenen, um bessere Designkriterien zu ermitteln.
Eine sachliche Diskussion über weitere Entwicklunsgstrategien von Hashfunktionen
wurde auf dem zweiten Cryptographic Hash Workshop 2006 geführt. Dabei wurden
unter anderem folgende Fragen hervorgehoben:
• Welche Eigenschaften sollten zukunftige Hashfunktionen besitzen, damit sie langfristig halten ?. Unter anderem robust und resistent gegen Kollisionsangriffe.
• Soll man Allzweck-Hasfunktionen entwickeln oder lieber meherer Hashfunktionen, die nur für einen bestimmten Zweck geeignet sind?. Man kann sich über
109
Kapitel 5 Zusammenfassung
diese Frage streiten.
• Soll man komplett neue Algorithmen entwickeln oder die bisher bekannten modifizieren ?. Die bisher bekannte Algorithmen sind fehlerhaft, aber man ist der
Auffassung, dass es keine Alternativen dazu gibt, welche mehr Sicherheit bieten.
Deshalb wird empfohlen, die bereits verwendeten Hashfunktionen zu modifizieren oder zu verstärkten Versionen wie SHA-2 Familie zu wechseln.
• Gibt es ein Kompromiss zwischen Sicherheit und Effizienz ?. Das ist ein Optimierungsproblem. Tatsache ist, dass bisher kein Algorithmus existiert, das gleichzeitig maximale Effizienz und maximale Sicherheit bietet. Ein Vorschlag wurde von
Shamir und Rivest eingereicht: Um weder die Effizienz noch die Sicherheit zu beeinträchtigen, soll die Rundeanzahl der Hashfunktionen paramatrisiert werden.
Die eingereichten Vorschläge erwecken unser Interesse, die Forschung in den nächsten
Jahren zu verfolgen.
110
Anhang A
Anhang
A.1 Grundlagen der Wahrscheinlichkeitstheorie
Der Ergebnisraum
Der Ergebnisraum ist die Menge, welche alle möglichen Ergebnisse eines Zufallsexperiments umfasst. Dieser Raum wird häufig mit dem Buchstaben Ω bezeichnet und kann
endlich (auch diskret) und unendlich sein. Im diskreten Fall besteht der Ergebnisraum
aus abzählbaren Ergebnissen, welche häufig als w1 , w2 , · · · , wn bezeichnet werden.
Der Ereignisraum
Jede Teilmenge eines Ergebnisraumes Ω werden Ereignisse genannt. Der Ereignisraum
ist die Menge aller mögliche Ergebnisse.
Jedes Ereignis bestehend aus einem einzigen Element der Form {w} heißt ein Elementarereignis.
Man sagt, dass ein Ereignis E eintritt, wenn ein Ergebnis w ∈ Ω existiert, welche in
E enthalten ist.
Die Menge A = Ω bzw. A = ∅ wird das leere Ereignis bzw. das sichere Ereignis
gennant.
Liegen E1 und E2 zwei Ereignisse vor, so können daraus andere Ereignisse durch mathematischen Verknüpfungen erzeugt werden, deren Bedeutung und Schreibeweise in
der folgenden Tabelle dargestellt wird:
Ausdruck
E1 ∩ E2 oder E1 ∧ E2
E1 ∪ E2 oder E1 ∨ E2
E1
Bedeutung
E1 und E2 tretten gleichzeitig ein.
E1 oder auch E2 eintritt
E1 tritt nicht ein.
111
Anhang A Anhang
Das Wahrscheinlichkeitsmaß
Gegeben seien ein Ergebnisraum Ω und ein Ereignisraum E. Das Wahrscheinlichkeitsmaß oder die Wahrscheinlichkeitsfunktion ist eine Funktion Pr : E ∈ E → Pr(E) ∈ R
mit folgenden Eigeschaften:
1. ∀ E ∈ E, 0 ≤ Pr(E) ≤ 1.
2. Pr(∅) = 0, Pr(Ω) = 1.
3. ∀ E1 , E2 ∈ E mit E1 ∧ E2 = ∅ ⇒ Pr(E1 ∨ E2 ) = Pr(E1 ) + Pr(E2 )
Die Ereignisse, welche die letzte Eigenschaft erfüllen, werden als disjunkte Ereignisse
bezeichnet.
Der Wahrscheinlichheitsraum
Ein Wahrscheinlichkeitsraum besteht aus einem Tripel (Ω, E, Pr) mit
• Ω ein Ergebnisraum
• E ein Ereignisraum über Ω
• Pr ein Wahrscheinlichkeitsmaß auf E
Laplace-Experimente
Sind alle Ergebnisse w ∈ Ω gleichwahrscheinlich, so wird Pr als Gleichverteilung auf Ω
und der Wahrscheinlichheitsraum (Ω, E, Pr) als laplacesch bezeichnet. In diesem Fall
gilt
Pr(E) =
|E|
,
|Ω|
∀E ∈ E,
wobei die Schreibeweise |E| für die Anzahl der Elemente von E steht.
Bedingte Wahrscheinlichkeiten
Sind E1 und E2 zwei Ereignisse mit Pr(E2 ) > 0, dann ist de bedingte Wahrscheinlichkeit von E1 unter der Bedingung E2 definiert durch
Pr(E1 |E2 ) =
112
| Pr(E1 ∧E2 )|
| Pr(E2 )|
Anhang A Anhang
Unabhängigkeit von Ereignissen
Zwei Ereignisse E1 und E2 sind (stochastich ) unabhängig, wenn
Pr(E1 |E2 ) = Pr(E1 ) bzw. Pr(E2 |E1 ) = Pr(E2 ).
In diesem Fall gilt
Pr(E1 ∧ E2 ) = Pr(E1 ) · Pr(E2 ).
Zufallsvariablen
In Zufallsexperimenten können die Ergebnisse wi des Ergebnissraumes Ω beispielsweise Buchstaben sein, mit welchen man nicht numerisch rechnen kann. Zur Bewertung
dieser Ergebnisse wird eine Abbildung benötigt, welche diesen Ergebnisse reellen Zahlen zuordnet. Diese Abbildung X : Ω ∈ w → X(w) = x ∈ R heißt eine Zufallsvariable
oder eine Zufallsgröße auf (Ω, E, Pr).
Eine Zufallsvariable heisst diskret, wenn die Teilmenge {X(w) : w ∈ Ω} eine endliche
Teilmenge von R ist.
Jede diskrete Zufallsvariable X auf (Ω, E, Pr) besitzt die sogenannte Wahrscheinlichkeitsverteilung, welche wie folgt definiert ist:
PrX : R ∈ x → PrX (x) = Pr({w ∈ Ω : X(w) = x}) ∈ [0, 1]
Der Wert PrX (x) wird häufig als Pr(X = x) geschrieben.
Sind X und Y zwei diskrete Zufallsvariablen eine diskrete, so wird die Funktion
PrX,Y : R2 ∈ (x, y) → PrX,Y (x, y) = Pr({w ∈ Ω : X(w) = x ∧ Y (w) = y}) ∈ [0, 1]
die gemeinsame Wahrscheinlichkeitsverteilung von X und Y genannt.
Zwei Zufallsvariablen X und Y heißen unabhängig, wenn für alle (x, y) ∈ R2 gilt:
PrX,Y (x, y) = Pr(X = x ∧ Y = y) = PrX (x) · PrY (y)
113
Anhang A Anhang
A.2 Geburtstagsangriff
Theorem 3.4 (Geburtstagsangriff)
hashenden Nachrichten mindestens 2n bzw. 2n/2 , um ein Urbild bzw. eine Kollision zu
finden.
Beweis:
1. Finden eines Urbildes
Die Hashwerte sind zufällig gleichtverteilt auf {0, 1}n , weil die Hashfunktion
eine ideale Hashfunktion ist. Sei H ein vorgegebener Hashwert. Wählt man eine
Nachricht zufällig, so ist ein Hashwert h(m) mit Wahrscheinlichkeit 1/2n gleich
dem gesuchten H. Also sollen mindestens 2n Nachrichten gehascht werden.
2. Finden einer Kollision
Sei h eine ideale Hashfunktion. Bezeichnen wir mit E die folgende Menge:
E = {m1 , m2 , · · · , mk , mit mi 6= mj , ∀ i 6= j ∈ {1, · · · , k}}
Wobei die Nachrichten mi zufällig aus {0, 1}n ausgewählt sind. Für i = 1, · · · , k
bezeichne Ei das Ereignis
h(mi ) ∈
/ {h(m1 ), h(m2 ), · · · , h(mi−1 )}“.
”
Dann beschreibt die E1 ∨ E2 · · · ∨ Ek das Ereignis
Es gibt keine Kollision für die Hashfunktion h“
”
Also für i = 1, · · · , k gilt
Pr[Ei |E1 ∨ E2 · · · ∨ Ei−1 ] =
2n − i + 1
.
2n
Daraus folgt die Erfolgswahrscheinlichkeit eine Kollision zu finden
114
Anhang A Anhang
n
n
2n − 1
2 −2
2 −k−1
Pr[Es gibt eine Kollision] = 1 −
·
···
.
2n
2n
2n
1
2
k−1
= 1 − 1 − n · 1 − n ··· 1 − n
.
2
2
2
Mit 1 − x ≈ e−x folgt
Pr[ Es gibt eine Kollision] ≈ 1 − e
−1
2n
−2 −(k−1) n
2
· e
· · · e 2n
.
Somit gilt
−k2
Pr[ Es gibt eine Kollision] = 1 − e 2n+1 .
Da k(k − 1) ≈ k 2 für ein grosses k ist , folgt
−k2
Pr[Es gibt eine Kollision] = e 2n+1 .
Also die Erfolgswahrscheinlichkeit ist gleich 1/2 genau dann wenn
−k2
1
= e 2n+1
2
Lösen wir diese Gleichung nach k auf, so bekommen wir
√
k ≈ 1.18 2n
Das bedeutet, dass die Anzahl der zu hashenden Nachrichten mindestens 2n/2
beträgt, um eine Kollision zu finden.
115
Anhang A Anhang
Theorem 3.5 (k-Kollision)
hashenden Nachrichten mindestens 2n(k−1)/k , um eine k-Kollision zu finden.
Um das Theorem zu beweisen, benötigen wir das folgende Lemma
Lemma: Sei f : A → {0, 1}n ein Zufallsorakel. Werden r Anfragen an das Orakel
f gesendet, so ist die Wahrscheinlichkeit ein k-Weg für f zu finden gleich r/2(k−1)n ,
wobei A für den Definitionsbereich von f steht.
Beweis des Lemmas : Seien x1 , x2 , · · · , xq zufällig gewählte Nachrichten aus A. Da f
ein Zufallsorakel ist, ergibt sich daraus, dass die Werte f (x1 ), f (x2 ), · · · , f (xq ) zufällig
und unabhängig gleichmässig verteilt auf {0, 1}n sind. Daraus folgt
Pr[f (xj1 ) = · · · f (xjk )] =
1
2n(k−1)
Seien A1 , · · · , Aj k-elemetigen Untermengen aus der Menge {x1 , x2 , · · · , xq }, wobei
j = kq .
Für jedes i bezeichnet Ei das Ereignis Ai ist eine k-Kollision“. Also die Menge ∨i Ei
”
beschreibt das Ereigns Es existiert ein k-Weg aus der Menge {x1 , x2 , · · · , xq }“.
”
Also zum Finden einer k-Kollision ist die Wahrscheinlichkeit gleich
Pr[∨i Ei ] ≤
X
Pr[Ei ]
i
q
k
2n(k−1)
=
Wegen
q
q · (q − 1) · (q − 2) · · · (q − k + 1)
=
k!
k
qk
≤
k!
erhalten wir
Pr[∨i Ei ] ≤ C ·
116
qk
2n(k−1)
,
Anhang A Anhang
wobei C eine Konstante ist. Und somit ist das Lemma bewiesen.
Beweis des Theorems 3.5: Aus dem Lemma folgt, dass die Wahrscheinlichkeit eine
qk
k-Kollision zu finden kleiner gleich 2n(k−1)
ist.
Setzen wir Pr[∨i Ei ] = 1 und lösen die folgende Ungleichung nach q auf:
qk
2n(k−1)
≥1
Es ergibt sich
qk
2n(k−1)
≥ 1 ⇔ q ≥ 2n(k−1)/k
117
[1] FIPS 197. Advanced encryption standard. National Institute of Standards and
Technology, Nov. 2001.
[2] FIPS 46-3. Data encryption standard. National Institute of Standards and Technology, Oct. 1999.
[3] Mihir Bellare, Ran Canetti, and Hugo Krawczyk. Keying Hash Functions for
Message Authentication, volume 1109 of LNCS. Springer, 1996.
[4] Mihir Bellare, Ran Canetti, and Hugo Krawczyk. Message authentication using
hash functions: the HMAC construction. CryptoBytes, 2(1):12–15, Spring 1996.
[5] Mihir Bellare and Thomas Ristenpart. Multi-property-preserving hash domain
extension and the emd transform. In Xuejia Lai and Kefei Chen, editors, ASIACRYPT, volume 4284 of LNCS, pages 299–314. Springer, 2006.
[6] Mihir Bellare and Phillip Rogaway. Random oracles are practical: A paradigm
for designing efficient protocols. In ACM Conference on Computer and Communications Security, pages 62–73, 1993.
[7] Mihir Bellare and Phillip Rogaway. Collision-resistant hashing: Towards making
uowhfs practical. In CRYPTO ’97: Proceedings of the 17th Annual International Cryptology Conference on Advances in Cryptology, LNCS, pages 470–484.
Springer-Verlag, 1997.
[8] Eli Biham, Rafi Chen, Antoine Joux, Patrick Carribault, Christophe Lemuet, and
William Jalby. Collisions of SHA-0 and Reduced SHA-1, volume 3494 of LNCS.
Springer, 2005.
[9] Eli Biham and Orr Dunkelman. A framework for iterative hash functions - haifa.
2007. http://eprint.iacr.org/.
[10] John Black, Phillip Rogaway, and Thomas Shrimpton. Black-box analysis of the
block-cipher-based hash-function constructions from pgv. In CRYPTO, volume
2442 of LNCS, pages 320–335, 2002.
118
[11] M.M. Hyden S.M. Matyaa C.H.W. Meyer J. Oseas S. Pilpel B.O. Brachtal,
D. Coppersmith and M. Shilling. ”data authentication using modification detection codes based on a public one-way encryption function”,u.s. patent no.
4,908,861. 1990.
[12] Lawrence Brown, Josef Pieprzyk, and Jennifer Seberry. LOKI—a cryptographic primitive for authentication and secrecy applications, volume 453 of LNCS.
Springer-Verlag, 1990.
[13] Johannes Buchmann. Einführung in die Kryptographie. Springer, Berlin, 2003.
[14] C. CANNIÈRE, C. D. ; RECHBERGER. Finding sha-1 characteristics: General
results and applications. In Advances in Cryptology – ASIACRYPT 2006, volume
4284 of LNCS, page 1–20, 2006.
[15] Florent Chabaud and Antoine Joux. Differential collisions in sha-0. In Advances
in Cryptology — CRYPTO ’98, volume 1462 of LNCS, pages 56–71. SpringerVerlag, 1998.
[16] Ivan Damgaard. A Design Principle for Hash Functions, volume 435 of LNCS.
Springer, 1990.
[17] D. Davies and W. L. Price. Digital signatures, an update. Proc. 5th International
Conference on Computer Communication, page 845–849, October 1984.
[18] B. den Boer. A. Bosselaers. An Attack of the last Two Rounds of MD4, volume
576 of LNCS. Springer, 1992.
[19] H. Dobbertin. Cryptanalysis of md4. Journal of Cryptology, 11(4):253–271, 1998.
[20] Hans Dobbertin, Antoon Bosselaers, and Bart Preneel. RIPEMD-160: A strengthened version of RIPEMD, volume 1039 of LNCS. Springer, 1996.
[21] Lei Duo and Chao Li. Improved collision and preimage resistance bounds on pgv
schemes. Cryptology ePrint Archive, Report 2006/462, 2006. http://eprint.
iacr.org/.
[22] Claudia Eckert. IT-Sicherheit. Oldenbourg, München, 2004.
[23] Rafi Chen Eli Biham. Near-collisions of sha-0. Cryptology ePrint Archive, Report
2004/146, 2004. http://eprint.iacr.org/.
[24] Niels Ferguson and Bruce Schneier. Practical Cryptography. Wiley, 2003.
[25] A. Fiat and A. Shamir. How to prove yourself: Practical solutions to identification
and signature problems, volume 263 of LNCS. Springer-Verlag, 1987.
119
[26] Vincent Rijmen Hirotaka Yoshida Florian Mendel, Bart Preneel and Dai Watanabe. Update on Tiger., volume 4329 of LNCS. Springer, 2006.
[27] S. Goldwasser and M. Bellare. Lecture notes on cryptography. http://www-cse.
ucsd.edu/users/mihir/papers/gb.html, August 2001.
[28] Shai Halevi and Hugo Krawczyk. Strengthening digital signatures via randomized
hashing. In Cynthia Dwork, editor, CRYPTO, volume 4117 of LNCS, pages 41–59.
Springer, 2006.
[29] S. Hirose. How to construct double-block-length hash functions. In The Second
Cryptographic Hash Workshop, Santa Barbara, Aug. 2006. http://csrc.nist.
gov/pki/HashWorkshop/2006/Papers/HIROSE_article.pdf.
[30] Shoichi Hirose. Some Plausible Constructions of Double-Block-Length Hash Functions., volume 4047 of LNCS. Springer, 2006.
[31] Yevgeniy Dodis Jean-Sébastien Coron, Cécile Malinaud, and Prashant Puniya.
Merkle-damgård revisited: How to construct a hash function. In Advances in
Cryptology – CRYPTO 2005, volume 3621 of LNCS, pages 430–448. Springer,
2005.
[32] A. Joux. Multicollisions in Iterated Hash Functions, Application to Cascaded
Constructions, volume 3152 of LNCS. Springer, 2004.
[33] John Kelsey and Tadayoshi Kohno. Herding hash functions and the nostradamus
attack. Cryptology ePrint Archive, Report 2005/281, 2005. http://eprint.
iacr.org/.
[34] John Kelsey and Stefan Lucks. Collisions and Near-Collisions for Reduced-Round
Tiger., volume 4047 of LNCS. Springer, 2006.
[35] John Kelsey and Bruce Schneier. Second Preimages on n-bit Hash Functions for
Much Less than 2n Work, volume 3494 of LNCS. Springer, 2004.
[36] Lars R. Knudsen and Bart Preneel. Hash Functions Based on Block Ciphers and
Quaternary Codes, volume 1163 of LNCS. Springer, 1996.
[37] Lars R. Knudsen and Bart Preneel. Fast and secure hashing based on codes. In
Advances in Cryptology — CRYPTO ’97, volume 1294 of LNCS, pages 485–498.
Springer, 1997.
[38] Lars Ramkilde Knudsen and Xuejia Lai. New attacks on all double block length
hash functions of hash rate 1, including the parallel-DM, volume 950 of LNCS.
Springer, 1995.
120
[39] Xuejia Lai and James L. Massey. Hash Functions Based on Block Ciphers, volume
[40] Stefan Lucks. Design principles for iterated hash functions, 2004.
//eprint.iacr.org/2004/253.pdf.
http:
[41] Stefan Lucks. A Failure-Friendly Design Principle for Hash Functions., volume
[42] K. Martin and C. Mitchell. Analysis of hash function of yi and lam. Electronics Letters, 34:2327–2328, 1998. http://www.esat.kuleuven.ac.be/cosic/
aspect/papers/kul093.ps.
[43] E. H. Mckinney. Generalized birthday problem. The American Mathematical
Monthly, 73:385–387, 1966.
[44] Alfred J. Menezes, Scott A. Vanstone, and Paul C. Van Oorschot. Handbook of
Applied Cryptography. CRC Press, Inc., 1996.
[45] Ralph C. Merkle. A certified digital signature, volume 435 of LNCS. Springer,
1989. http://dsns.csie.nctu.edu.tw/research/crypto/HTML/PDF/C89/218.
PDF.
[46] Ralph C. Merkle. One way hash functions and DES, volume 435 of LNCS. Springer, 1990. http://dsns.csie.nctu.edu.tw/research/crypto/HTML/PDF/C89/
428.PDF.
[47] C.H. Meyer and M. Schilling. Secure program load with manipulation detection
code,. Proceedings Securicom, pages 111–130, 1988.
[48] Mridul Nandi. Designs of efficient secure large hash values. Cryptology ePrint
Archive, Report 2004/296, 2004. http://eprint.iacr.org/.
[49] Mridul Nandi, Wonil Lee, Kouichi Sakurai, and Sangjin Lee. Security analysis
of a 2/3-rate double length compression function in the black-box model. In
Henri Gilbert and Helena Handschuh, editors, FSE, volume 3557 of LNCS, pages
243–254. Springer, 2005.
[50] M. Naor and M. Yung. Universal one-way hash functions and their cryptographic
applications. ACM Press, 1989.
[51] NIST. Federal information processing standards publication 180-2. Technical
report, August 2002 / February 2004. http://www.governmentsecurity.org/
articles/articles2/fips-180-2.pdf_fl/.
121
[52] E. P. Dawson P. Gauravaram, W. Millan and K. Viswanathan. Constructing Secure Hash Functions by Enhancing Merkle-Damgard Construction., volume 4058
of LNCS. Springer, 2006.
[53] Wen-Ling Wu Pin Lin and Chuan-Kun Wu. Security analysis of double length
compression function based on block cipher. International Journal of Network
Security, 4:121–127, 2007.
[54] Juanma Gonzalez Nieto Praveen Gauravaram, William Millan and Edward Dawson. 3c- a provably secure pseudorandom function and message authentication
code.a new mode of operation for cryptographic hash function. Cryptology ePrint
Archive, Report 2005/390, 2005. http://eprint.iacr.org/.
[55] Bart PRENEEL. Analysis and Design of Cryptographic Hash Functions. PhD thesis, February 2003. http://homes.esat.kuleuven.be/~preneel/phd_preneel_
feb1993.pdf.
[56] Bart Preneel. Hash functions, June 2005. http://ecrypt.eu.org/stvl/hfw/
Preneel.pdf.
[57] Bart Preneel, René Govaerts, and Joos Vandewalle. Hash Functions Based on
Block Ciphers: A Synthetic Approach, volume 773 of LNCS. Springer, 1993.
[58] Ronald L. Rivest. The md4 message digest algorithm. In Alfred Menezes and
Scott A. Vanstone, editors, CRYPTO, volume 537 of LNCS, pages 303–311. Springer, 1990.
[59] Ronald L. Rivest. The MD5 message-digest algorithm, 1992. http://theory.
lcs.mit.edu/~rivest/rfc1321.txt1321.
[60] P. Rogaway and T. Shrimpton. Cryptographic hash-function basics: Definitions,
implications and separations for preimage resistance, second-preimage resistance,
and collision resistance, volume 3017 of LNCS. Springer, 2004.
[61] M. Iwata S. Miyaguchi and K. Ohta. New 128-bit hash function.(n-hash). NTT
Review, 2(6):128–132., Nov. 1990.
[62] Bruce Schneier. Angewandte Kryptographie. Addison-Wesley, 1996.
[63] Bruce Schneier. Applied Cryptography. John Wiley & Sons, New York, 1996.
[64] Claude E. Shannon. Communication theory of secrecy systems. Bell System
Technical Journal, 28:656–715, 1949.
[65] Victor Shoup. A Composition Theorem for Universal One-Way Hash Functions,
volume 1807 of LNCS. Springer, 1999.
122
[66] Daniel R. Simon. Finding Collisions on a One-Way Street: Can Secure Hash
Functions Be Based on General Assumptions?, volume 1403 of LNCS. Springer,
1998.
[67] C.H. Meyer S.M. Matyas and J. Oseas. Generating strong one-way functions with
cryptographic algorithm. IBM Techn. Disclosure Bull, 27:5658–5659., 1985.
[68] Paul C. van Oorschot and Michael J. Wiener. Parallel collision search with cryptanalytic applications. Journal of Cryptology, 12(1):1–28, 1995.
[69] David Wagner. Cryptanalysis of the Yi-Lam Hash, volume 1976 of LNCS. Springer, 2000.
[70] Thomas Meier Walter Hohl, Xuejia Lai and Christian Waldvogel. Security of
iterated hash functions based on block ciphers, volume 773 of LNCS. Springer,
1994.
[71] Xiaoyun Wang, Dengguo Feng, Xuejia Lai, and Hongbo Yu. Collisions for hash
functions md4, md5, haval-128 and ripemd. Cryptology ePrint Archive, Report
2004/199, 2004. http://eprint.iacr.org/.
[72] Xiaoyun Wang, Yiqun Lisa Yin, and Hongbo Yu. Collision search attacks on
sha1. February 2005. http://www.infosec.sdu.edu.cn/paper/sha-attack-note.pdf.
[73] Xiaoyun Wang and Hongbo Yu. How to Break MD5 and Other Hash Functions.,
volume 3494 of LNCS. Springer, 2005.
[74] Robert S. Winternitz. Producing a One-Way Hash Function from DES. 1984.
[75] Robert S. Winternitz. A Secure One-Way Hash Function Built from DES., volume 00. IEEE Computer Society, 1984.
[76] Reinhard Wobst. Abenteuer Kryptologie : Methoden, Risiken und Nutzen der
Datenverschlüsselung. Addison-Wesley Verlag, 2001.
[77] Yiqun Lisa Yin Xiaoyun Wang and Hongbo Yu. Finding Collisions in the Full
SHA-1., volume 3621 of LNCS. Springer, 2005.
[78] Xun Yi and Kwok-Yan Lam. A New Hash Function Based on Block Cipher,
volume 1270 of LNCS. Springer-Verlag, 1997.
[79] Gideon Yuval. How to swindle Rabin. Cryptologia, 3(3):187–189, July 1979.
123
Index
k-Kollision, 28
3C -Hashfunktion
3C-X Hashfunktion, 47
Kaskadierte Hashfunktion, 32
Kelsey-Schneier-Angriff, 34
Kollision, 28
Querkollision, 44
Strikte Kollision, 44
Kollisionen, 13
Kollisionsangriff, 16
Kompressionsfunktion, 19
kryptographische Hashfunktion, 15
Blockchiffre, 66
Ideale Blockchiffre, 67
Blockchiffre-basierte Hashfunktion, 68
Blockchiffre-basierte Kompressionsfunktion, 68
Brute Force-Angriff, 16
Chosen-Target-Forced-Prefix Perimage resistence, 36
CTFP
Preimage Resistenz, 36
Length Extension, 25
Length Extension-Property, 25
Einwegfunktion, 12
expandierbare Nachricht, 34
Matyas-Meyer-Oseas Verfahren, 71
MDC-2, MDC-4, 91
Merkle-Damgård-Konstruktion, 21
Merkle-Damgård-Theorem, 22
Miyaguchi-Preenel-Verfahren, 74
Multikollision, 28
Multikollision-Angriff, 30
Multiweg-Urblid-Theorem, 33
Falltürfunktion, 13
Nandi-Hash, 97
Geburtstagsangriff, 27
Graph-Drawing-Attack, 82
Parallel-DM, 93
Partial-message-collision, 26
Preimage-Angriff, 16
Preneel-Govaets-Vandewalle-Konstruktionen,
74
Davies-Meyer-Verfahren, 72
Diamantstruktur, 37
Double-Block-Length , 91
Hash-Rate, 69
Hashfunktion, 13
Herding-Angriff, 36
Hirose-Hash, 100
Randomisiertes Hashing, 49
Shannon-Modell, 67
Sicherheitsniveau, 17
Standardmodell, 67
Ideal Cipher Model, 67
Joux-Theorem, 32
Joux-Multikollision, 30
124
Index
Target-Kollisionsresistanz, 50
Wide-Pipe
Double-Pipe, 40
Wide-Pipe-Multikollision, 41
Yi-Lam-Hash, 95
zusammengehöriges Paar, 102
125

Konstruktion von Hashfunktionen

Transcription

Documents pareils

Kommunikation mit Ihrem Kundenberater mittels

Lineares Hashing

Pressestimmen - Bildschirmschoner.de

UN/EDIFACT EDIFACT-Verzeichnisse EDIFACT

Zeitung in der Grundschule – Ideen für den Unterricht

3. Runde - Mathematik-Wettbewerb des Landes Hessen

Spread Spectrum Modulationen

Mitteilungen VSD - Volkssternwarte Darmstadt eV