Merkles Meta-Verfahren
# Merkles Meta-Verfahren

Merkles Meta-Verfahren (auch Merkle-Damgård-Konstruktion) ist eine Methode zur Konstruktion von kryptographischen Hash-Funktionen, die auf Arbeiten von Ralph Merkle und Ivan Damgård zurückgeht.

Gegeben ist eine Kompressionsfunktion $f\colon \{0,1\}^{a+b}\rightarrow \{0,1\}^{b}$, die eine $a+b$ Bit lange Eingabe auf eine $b$ Bit lange Ausgabe abbildet. Sie ist kollisionssicher, das heißt, es ist nicht mit realistischem Aufwand möglich, zwei verschiedene Eingaben zu finden, die auf die gleiche Ausgabe abgebildet werden. Durch die Anwendung von Merkles Meta-Verfahren ergibt sich daraus eine kollisionssichere Hash-Funktion $h\colon \{0,1\}^{*}\rightarrow \{0,1\}^{b}$, die beliebig lange Nachrichten auf einen Hashwert von $b$ Bit abbildet.

## Vorgehensweise

Die Nachricht $m$ wird zunächst mit einem Padding-Verfahren zu ${\overline {m}}$ erweitert, so dass die Länge von ${\overline {m}}$ ein Vielfaches der Blockgröße $a$ ist. Dann wird ${\overline {m}}$ in $n$ Blöcke der Länge $a$ aufgeteilt:

    ${\overline {m}}=m_{1}\|m_{2}\|\ldots \|m_{n}$ mit $|m_{i}|=a$.

Die Kompressionsfunktion $f$ wird iterativ auf die $b$ Bit lange Ausgabe der vorherigen Iteration und den nächsten Block $m_{i}$ der erweiterten Nachricht angewandt, bis diese ganz verarbeitet ist. Bei der ersten Iteration besteht die Eingabe aus einem $b$ Bit langen konstanten Initialisierungsvektor $H_{0}$ und dem ersten Nachrichtenblock $m_{1}$.

    $H_{i}:=f(H_{i-1}\|m_{i});\quad 1\leq i\leq n$.

Der Hash-Wert wird dann aus der letzten Kompressionsausgabe durch eine Finalisierungsfunktion berechnet: $h=\operatorname {final} (H_{n})$. Diese ist häufig die Identität oder eine Trunkierung.

Die Kompressionsfunktion wird oft aus einer Blockverschlüsselung konstruiert, wofür es hauptsächlich zwei Möglichkeiten gibt. Eine ist die Davies-Meyer-Kompressionsfunktion: $H_{i}=E_{m_{i}}(H_{i-1})\oplus H_{i-1}$. Sie nutzt den Nachrichtenblock $m_{i}$ als Schlüssel, um damit den Verkettungswert $H_{i-1}$ zu verschlüsseln. Danach wird noch der so berechnete Schlüsseltext mit dem Klartext verknüpft, z. B. durch bitweises XOR. Dadurch wird die Eigenschaft einer Blockchiffre aufgehoben, den Klartext bijektiv auf den Schlüsseltext abzubilden, und die Abbildung von $H_{i-1}$ auf $H_{i}$ ähnelt wesentlich mehr einer Zufallsfunktion. Sonst wäre die Kompressionsfunktion auch nicht kollisionssicher, denn ein Angreifer könnte $H_{i}$ vorgeben und mit verschiedenen $m_{i}$ entschlüsseln.

Die zweite ist die Matyas–Meyer–Oseas-Kompressionsfunktion: $H_{i}=E_{k_{i}}(m_{i})\oplus m_{i}$ mit $k_{i}=g(H_{i-1})$ oder $k_{i}=H_{i-1}$. Sie verschlüsselt den Nachrichtenblock mit dem Verkettungswert als Schlüssel. Auch hier werden Klar- und Schlüsseltext anschließend verknüpft. Die Funktion $g$ erweitert oder komprimiert $H_{i-1}$ zur Anpassung an die gegebene Schlüssellänge. Als Modifikation von Matyas–Meyer–Oseas gibt es noch die Miyaguchi-Preneel-Kompressionsfunktion, die sich nur dadurch unterscheidet, dass auch $H_{i-1}$ mit dem Schlüsseltext verknüpft wird: $H_{i}=E_{k_{i}}(m_{i})\oplus m_{i}\oplus H_{i-1}$. Das ist vor allem dann von Nutzen, wenn die Funktion $g$ den Verkettungswert komprimieren muss, denn so geht dessen gesamter Informationsgehalt in $H_{i}$ ein.

## Padding

Damit die Kollisionssicherheit der Kompressionsfunktion sich beweisbar auf die Hashfunktion überträgt, muss das Paddingverfahren bestimmte Bedingungen erfüllen. Folgende Bedingungen sind dafür hinreichend:

* $m$ ist ein Anfangsstück von ${\overline {m}}$, d. h., die Nachrichten werden nicht verändert, nur mit einem Endstück erweitert.
* Zwei Nachrichten der gleichen Länge werden mit gleich langen Endstücken erweitert.
* Zwei verschieden lange Nachrichten werden unterschiedlich erweitert, so dass sie sich im letzten Block, der in die letzte Kompressionsstufe eingegeben wird, unterscheiden.

Typischerweise wird beim Padden eine Codierung der Bitlänge $\left|m\right|$ an die Nachricht angehängt, und dazwischen werden ggfs. Bits mit dem Wert 0 eingefügt, damit $|{\overline {m}}|$ ein Vielfaches der Blockgröße $a$ ist:

    ${\overline {m}}=m\,\|\,0^{k}\,\|\,|m|$

## Schwächen

Eine Schwäche ist ein möglicher Erweiterungs-Angriff (Extension-Attack): Wenn die Finalisierungsfunktion umkehrbar ist, dann kann man aus dem Hashwert $h(m)$ einer unbekannten Nachricht $m$ leicht den Hashwert $h({\overline {m}}\,\|\,y)$ einer Nachricht bestimmen, die aus der wie oben erweiterten Nachricht durch Anfügen einer Erweiterung $y$ hervorgeht. Man kann also Hashwerte zu Nachrichten bestimmen, die $m$ als Anfangsstück haben, auch wenn man $m$ nicht kennt. Da ein Zufallsorakel diese Eigenschaft nicht hat, können sich daraus Angriffe auf Verfahren ergeben, die nur im Random-Oracle-Modell einen Sicherheitsbeweis haben. Daraus folgt auch: wenn man einmal eine Kollision zweier Nachrichten mit gleicher Blockanzahl $n$ gefunden hat, kann man durch Erweiterung leicht weitere Kollisionen bestimmen.

Mehrfachkollisionen zu finden, also mehrere Nachrichten, die alle den gleichen Hashwert haben, erfordert nur wenig mehr Aufwand als das Bestimmen einer einzelnen Kollision.

Ein Herding-Angriff, also zu einem selbst gewählten Hashwert z und einem gegebenen Anfangsstück $m$ einer Nachricht ein passendes Endstück zu finden, so dass die gesamte Nachricht zu z hasht, d. h., ein $y$ mit $h(m\|y)=z$ zu finden, erfordert zwar mehr Aufwand als das Finden einer Kollision, aber wesentlich weniger, als es für ein Zufallsorakel als Hashfunktion $h$ der Fall sein sollte.

Ein Angriff zur Bestimmung eines zweiten Urbildes (second preimage attack), bei dem man zu einer gegebenen Nachricht $m$ eine zweite $m^{\prime }$ mit demselben Hashwert $h(m)=h(m^{\prime })$ sucht, ist bei einer Nachricht der Länge von $2^{k}$ Blöcken mit dem Zeitaufwand $k2^{b/2+1}+2^{b-k+1}$ möglich, und damit bei langen Nachrichten erheblich schneller als durch systematisches Probieren (brute force), was etwa $2^{b}$ Schritte erfordert.

## Verbesserungen

Zur Überwindung dieser Schwächen hat Stefan Lucks die wide-pipe-hash-Konstruktion vorgeschlagen: Um einen Hashwert von $b$ Bit Länge zu berechnen, verwendet man eine Kompressionsfunktion $f^{\prime }$, deren Ausgabe länger als $b$ ist, typischerweise doppelt so lang. $f^{\prime }$ komprimiert also $2b$ Bit aus der vorherigen Iteration und einen $a$ Bit langen Nachrichtenblock zu einer Ausgabe von $2b$ Bit. Nach der letzten Iteration wird die Ausgabe durch eine weitere Kompressionsfunktion von $2b$ auf $b$ Bit verkürzt, im einfachsten Fall durch Trunkierung. Beispiele: SHA-512/256, Grøstl.

Nandi und Paul haben gezeigt, dass diese Konstruktion etwa doppelt so schnell gemacht werden kann (fast wide pipe hash), indem man nur $b$ Bit aus den vorhergehenden Kompressionen in die nächste Kompression eingibt, zusammen mit einem $a+b$ Bit langen Nachrichtenblock $m_{i}$. Die andere Hälfte der $2b$-Kompressionsausgabe wird mit der darauf folgenden Eingabe XOR-verknüpft:

    $h_{i}=f^{\prime }\left(\,(\operatorname {Hi} (h_{i-2})\oplus \operatorname {Lo} (h_{i-1}))\;\|\;m_{i}\right);\quad 1\leq i\leq n-1$

In der letzten Stufe wird die Ausgabe der vorletzten komplett verarbeitet, und der Nachrichtenblock $m_{n}$ ist dafür nur $a$ Bit breit (falls man hier nicht eine andere Kompressionsfunktion mit größerer Eingabe verwendet):

    $h_{n}=f^{\prime }(\,(\operatorname {Hi} (h_{n-2})\oplus \operatorname {Lo} (h_{n-1}))\;\|\;\operatorname {Hi} (h_{n-1})\;\|\;m_{n})$

$\operatorname {Hi} (c)$ und $\operatorname {Lo} (c)$ bedeuten dabei die erste bzw. die zweite Hälfte der Bitkette $c$.

Neben der wide-pipe-hash-Konstruktion gilt auch die HAIFA-Konstruktion als eine Weiterentwicklung des Merkle-Damgård Verfahrens. Ein Beispiel dafür ist BLAKE.

