Ein sicheres Signaturverfahren mithilfe bilinearer Abbildungen

Ein sicheres Signaturverfahren mithilfe bilinearer
Abbildungen
Martin Lingnau
Betreuer: Sven Schäge
Horst Görtz Institut für IT-Sicherheit,
Ruhr Universität Bochum
[email protected]
Juni 2010
Zusammenfassung
In dieser Arbeit wird das Paper “A Secure Signature Scheme from Bilinear Map“ von Boneh, Mironov und Shoup1 , in dem ein Signaturschema
auf Basis bilinearer Abbildungen vorgestellt wird, betrachtet. Dabei wird
insbesondere die Herleitung des Verfahrens vertieft und näher erläutert
dargestellt.
1
Bilineare Abbildungen
Die Abbildungen, mit denen wir arbeiten werden, sind Funktionen mit einem
Paar von Eingangswerten, das auf ein Paar von Ausgangswerten abgebildet
wird. Der Definitions- und Wertebereich wird auf endliche zyklische Gruppen
mit primer Ordnung beschränkt. Die Eigenschaft der Bilinearität soll durch die
folgende formale Definition verdeutlicht werden:
Definition 1 (Bilineare Abbildungen) Eine Funktion e: G0 x G1 → G2
ist bilinear wenn für beliebige g1 , g2 ∈ G0 , H1 , H2 ∈ G1 das Folgende gilt:
e(g1 ◦g2 , H1 ) = e(g1 , H1 )◦e(g2 , H1 ) und e(g1 , H1 ◦H2 ) = e(g1 , H1 )◦e(g1 , H2 ).
Im Folgenden werden Elemente aus der Gruppe G0 mit kleinen lateinischen
Buchstaben und Elemente aus der Gruppe G1 mit großen lateinischen Buchstaben bezeichnet. Elemente der Gruppe G2 werden mit kleinen lateinischen
Buchstaben vom Ende des Alphabets bezeichnet.
1 http://crypto.stanford.edu/
mironov/papers/bmap.pdf
1
2
Sichere bilineare Abbildungen
Wir müssen uns zunächst fragen, was eine sichere bilineare Abbildung ausmacht.
Dazu wird eine mögliche Definition für eine solche Abbildung aufgestellt und
daraufhin gezeigt, dass die vorgestellte Definition einer sicheren bilinearen Abbildung genau dann, wenn auch das Diffie-Hellman-Problem (DHP) (eng.: computational Diffie-Hellman assumption) nicht gelöst werden kann, gilt.
Definition 2 (Sichere bilineare Abbildung) Eine bilineare Abbildung
e: G0 x G1 → G2 ist (t, ε)-sicher, wenn für alle Angriffe A, die Zeit t benötigen,
gilt:
R
R
− G0 ; G, H ←
− G1 < ε.
AdvBLAA = Pr e A(g, G, H), H = e(g, G) g ←
Das Ziel des Angreifers ist es also, zu den drei zufällig gewählten, bekannten
Werten g, G und H das passende h zu finden, sodass e(h, H) = e(g, G) gilt. Die
Wahrscheinlichkeit seines erfolgreichen Angriffs darf dabei ε nicht überschreiten.
Um zu zeigen, dass die Sicherheit der bilinearen Abbildung gleichbedeutend
mit der Sicherheit des DHP ist, betrachten wir zunächst die Definition des DHP:
Definition 3 (Diffie-Hellman-Problem) Das Diffie-Hellman-Problem ist
(t, ε)-hart, wenn für alle Angriffe A, die Zeit t benötigen, gilt:
R
R
R
AdvDHPA = Pr A(g, H, H α ) = g α g ←
− G0 ; H ←
− G1 ; α ←
− Z|G1 | < ε.
Der Angreifer kennt die zufällig bestimmten Werte g, H und H α und versucht
g zu bestimmen.
α
Behauptung Wir nehmen an, dass G0 , G1 , G2 zyklische Gruppen mit Primordnung p sind. Des Weiteren nehmen wir an, dass die Abbildung G0 x
G1 → G2 nicht degeneriert ist, d.h. e(h, H) 6= 1 für beliebige Generatoren
h ∈ G0 und H ∈ G1 . Wenn das gilt, ist die Abbildung e (t, ε)-sicher genau
dann, wenn das DHP (t, ε)-hart ist.
Beweis Wir beginnen mit einer bilinearen Abbildung e(g, G) = e(h, H) mit
g, h ∈ G0 und G, H ∈ G1 . g, G und H sind bekannt; h wird gesucht. Da G1 eine
zyklische endliche Gruppe mit Primordnung p ist, muss es ein a ∈ Zp geben,
sodass G = H a gilt. Nehmen wir außerdem an – da wir einen Negativbeweis
führen möchten –, dass das DHP (t, ε)-lösbar ist. Dann können wir daraus h =
g α bestimmen. Aufgrund der Bilinearität unserer Abbildung können wir des
Weiteren den Exponenten a in der Klammer umhertauschen. Mit all diesen
2
Eigenschaften gilt:
DHP
e(h, H) = e(g a , H) = e(g ◦ g ◦ ... ◦ g ◦ g , H)
|
{z
}
a-mal
bil.
= e(g, H) ◦ ... ◦ e(g, H)
|
{z
}
a-mal
bil.
= e(g, |H ◦ H ◦ {z
... ◦ H ◦ H}) = e(g, H a ) = e(g, G).
a-mal
a
h = g , die Lösung des DHP (g, H, G) = (g, H, H a ), ist also nötig, um die
Abbildung zu lösen. Da die Abbildung aber (t, ε)-sicher ist, muss DHP im
Umkehrschluss der Aussagenlogik folgerichtig (t, ε)-hart sein.
Nehmen wir nun an, dass unsere bilineare Abbildung nicht (t, ε)-sicher ist.
Somit gibt es einen Algorithmus A, der uns zuverlässig bei gegebenen (g, G, H)
ein h ∈ G0 ausgibt, sodass e(g, G) = e(h, H) gilt. Wenn (g, G, H) ein beliebiges
DHP mit H 6= 1 (also nicht trivial) ist, können wir nun wie folgt das DHP lösen.
Wir wissen, dass G = H a – für ein uns unbekanntes a ∈ Zp – ist. Mit unserem
Algorithmus A bestimmen wir ein h, sodass e(g, G) = e(h, H) gilt. Dann folgt:
A
bil.
e(h, H) = e(g, G) = e(g, H a ) = e(g a , H)
⇔
e(h, H) bil. h
= e( a , H) = 1
e(g a , H)
g
Da H 6= 1 folgt h = g a , denn sonst wäre die Abbildung degeneriert. Wir könnten
also mit einer aufgelösten sicheren bilinearen Abbildung ein beliebiges DHP bestimmen. Da das DHP aber (t, ε)-hart ist, folgt, dass unsere bilinearen Abbildungen (t, ε)-sicher sind.
Baumstrukturen und der Dwork-Naor-Trick Das [BMS02]-Verfahren benutzt eine Baumstruktur zur Authentifizierung. Es wird ein Baum mit geringer
Tiefe l und hohem Verzweigungsfaktor n erzeugt, an dessen Blätter die Nachrichten gehangen werden. Die Authentizität geht in einem baumstrukturierten Signaturverfahren von der Wurzel aus. Eine Signatur besteht aus einem Pfad von
Knoten, der bei einem der Blätter startet und bei der Wurzel endet. Die Sicherheit des Verfahrens wird dadurch gewährleistet, dass man für einen bereits bestehenden Knoten nur dann Kindknoten erzeugen kann ohne dass die Signatur
ungültig wird, wenn man ein Geheimnis des Elternknotens – resultierend aus
dem privaten Schlüssel – kennt. Die Kindknoten werden also durch ihre Eltern
authentifiziert. Wir können uns vorstellen, dass die Kante, die von einem Kind
zu seinem Elternknoten führt, den Authentizitätsnachweis des Kindes darstellt.
Für die Berechnung eines solchen Wertes müssen bei einigen Verfahren die
Nachweise sämtlicher Kindknoten mit einem Geheimnis des Elternknotens verknüpft
werden. Alle Kindknoten haben denselben Authentizitätsnachweis. Dabei entsteht das Problem, dass für die Verifikation und damit für die Signatur nicht nur
die Knoten des direkten Pfads vom Blatt bis zur Wurzel benötigt werden, sondern auch sämtliche Geschwisterknoten sämtlicher Pfad-Knoten. Als Resultat
versucht man die Anzahl der Geschwister so gering wie möglich zu halten, was
wiederum gegen einen hohen Verzweigungsfaktor spricht. Um aber trotzdem
noch eine akzeptable Anzahl von möglichen Signaturen zu gewährleisten (die
3
Anzahl der Blätter berechnet sich in einem Baum zu ln ) muss die Tiefe groß
genug gewählt werden. Die Tiefe schlägt sich aber wiederum in der Anzahl der
direkten Pfad-Knoten nieder.
Dwork und Naor stellen in einem ihrer Paper2 eine Lösung für dieses Problem vor. Durch eine komplexere Berechnung der Authentizitätswerte gelingt
es ihnen, dass diese nicht mehr von den Geschwistern abhängen. Jede Kante,
die von einem Knoten zu seinen Kindern führt, steht jetzt für einen eigenen
Wert. Dadurch werden nicht nur sämtliche Geschwisterknoten bei der Signatur
eingespart, sondern es kann ebenfalls auf die Angabe der Knoten selbst verzichten werden. Folgende zwei Informationen reichen pro Knoten aus: Die Kante
des Knotens zu seinem Elternknoten, d.h. sein Authentitätsnachweis, und die
Angabe, das wievielte Kind der Knoten für seinen Elterknoten darstellt. Dadurch
wird ein flacher und breiter Baum ermöglicht, der wiederum zu einer kürzeren
Signatur führt. Im [BMS02]-Verfahren wird dies als Dwork-Naor-Trick bezeichnet und verwendet.
Des Weiteren wird im [BMS02]-Verfahren nicht zwischen einem zustandsbehafteten oder zustandsfreien Schema unterschieden, da nach dem Paper von
Goldreich3 jedes Verfahren zustandslos gemacht werden kann, indem die Tiefe
des Baumes verdoppelt wird.
3
Das Signaturverfahren
Ein Signaturverfahren besteht aus den drei Komponenten Schlüsselerzeugung,
Signaturalgorithmus und Verifikationsalgorithmus.
R
1. Schlüsselerzeugung (KeyGen) −
→ (kpr , kpub )
2. Signaturalgorithmus (Sign) (kpr , M ) → σ
3. Verifikationsalgorithmus (Verify) (kpub , M, σ) → 0 ∨ 1
Bei der Schlüsselerzeugung wird auf Basis einiger festgelegter Konstanten
ein zufälliges Schlüsselpaar, bestehend aus einem privaten (kpr ) und einem
öffentlichen Schlüssel (kpr ), generiert. Mit dem privaten Schlüssel kann dann
für eine beliebige Nachricht M eine Signatur σ erzeugt werden. Bei der Verifikation werden die Nachricht und deren Signatur mithilfe des öffentliche Schlüssel
auf Korrektheit überprüft und der Algorithmus gibt entweder korrekt oder inkorrekt aus.
2 C. Dwork and M. Naor, “An efficient existentially unforgeable signature scheme and its
applications,” Proc. of CRYPTO’94, pp. 234–246, 1994. Full version appeared in J. of Cryptology, v. 11(2), pp. 187–208, 1998.
3 O. Goldreich, “Two remarks concerning the Goldwasser-Micali-Rivest signature scheme,”
Proc. of CRYPTO’86, pp. 104–110, 1986.
4
Definition 4 (Signaturverfahren)
wenn gilt:
Pr Verify(kpr , M, σ) = korrekt
Ein Signaturverfahren gilt als korrekt,
∀M ∈ M, ∀(kpr , kpub ) ← KeyGen,
∀σ ← Sign(kpr , M ) = 1
Setup des Verfahrens G0 und G1 sind zyklische Gruppen mit Primordnung
p. Die bilineare Abbildung e : G0 x G1 → G2 ist sicher. Hk : M → {0, 1}s ist eine
Familie von kollisionsresistenten Hashfunktionen. M ist der Nachrichtenraum
und der Schlüssel k von Hk ist ein fester Schlüssel, der bei der Schlüsselerzeugung
bestimmt und öffentlich gemacht wird. Mit diesem Signaturverfahren können ln
Nachrichten signiert werden. l und n sind beliebige positive ganze Zahlen. n ist
der Verzweigungsgrad und l die Tiefe des Baums.
Schlüsselerzeugung
R
R
1. Wähle α1 , ..., αn ← Z∗ p und H ← G1 . Wähle einen zufälligen Schlüssel k.
Berechne H1 ← H 1/α1 , ..., Hn ← H 1/αn ∈ G1 .
R
2. Wähle g ← G0 . Berechne y ← e(g, H).
R
3. Wähle β0 ← Zp . Berechne x0 ← e(g, H)β0
4. Der öffentliche Schlüssel besteht aus k, H, H1 , ..., Hn , y und x0 . Der
geheime Schlüssel besteht aus α1 , ..., αn , β0 und g.
Signaturalgorithmus Jeder Knoten des Baums wird durch seinen Elternknoten authentifiziert. Nachrichten M ∈ M, die signiert werden sollen, werden
an die Blätter des Baumes gehangen und durch diese authentifiziert. Soll die i-te
Nachricht signiert werden, wird das i-te Blatt und der Weg bis dorthin generiert.
Den Weg zum Blatt xb ∈ G1 schreiben wir als (xb , ib , xb−1 , ib−1 , ..., i1 , x0 ). xj
ist dabei das ij -te Kind von xj−1 . Die Blätter und die Knoten auf dem Pfad zu
diesem werden wie folgt berechnet:
1. Alle bisher unbesuchten Knoten und das Blatt xb werden als xj ← e(g, H)βj
R
mit einem zufälligen βj ← Zp berechnet. Das geheime βj wird solange
gespeichert, wie xj ein Vorfahre des aktuellen zum Signieren verwendeten Blattes ist. Da Blätter nur für eine einzige Nachricht Vorfahre sind,
wird βb sofort nach der Berechnung des Authentizitätswerts (siehe 2.)
der Nachricht verworfen. Wenn wir eine zustandslose Signatur erzeugen
wollen, werden die βj durch eine Pseudozufallsfunktion erzeugt und ihre
Werte müssen deswegen nicht gespeichert werden.
2. Der Authentizitätswert von xj , dem ij -ten Kind von xj−1 , berechnet sich
als fj ← g αij (βj−1 +Hk (xj )) .
3. Der Authentizitätswert von Hk (M ), dem Kind von xb berechnet sich als
f ← g βl +Hk (M ) .
4. Die Signatur von M besteht aus (f, fb , ib , ..., f1 , i1 ).
5
Verifikationsalgorithmus Um eine Signatur (fˆ, fˆb , îb , ..., fˆ1 , î1 ) einer Nachricht
M zu verifizieren, konstruieren wir den Baum in umgekehrter Richtung. Wir
starten bei x̂b und prüfen am Ende, ob unser berechnetes x̂0 mit der Wurzel x0 ,
die Teil des öffentlichen Schlüssels ist, übereinstimmt. Wenn dies der Fall ist,
können wir die Signatur als richtig anerkennen. Die folgenden Schritte werden
dazu ausgeführt:
1. Berechne x̂b ← e(fˆ, H) · y −Hk (M ) .
2. Berechne x̂j−1 ← e(fˆj , Hij ) · y −Hk (x̂j ) ; mit j = b...1.
3. Die Signatur wird akzeptiert, wenn x̂0 = x0 .
Nun soll gezeigt werden, dass eine durch den Algorithmus erzeugte Signatur
immer erfolgreich verifiziert werden kann. Betrachten wir den ersten Schritt des
Verifikationsalgorithmus. Unter der Annahme, dass der Authentizitätswert der
Nachricht korrekt ist, können wir f und y durch ihre Berechnungsvorschriften
im 3. Schritt des Signierens bzw. 2. Schritt der Schlüsselerzeugung ersetzen und
mit der Eigenschaft der Bilinearität weiter umformen:
e(f, H) · y −Hk (M ) = e(g βb +Hk (M ) , H) · e(g, H)−Hk (M )
bil.
= e(g βb +Hk (M ) , H) · e(g −Hk (M ) , H)
bil.
= e(g βb +Hk (M ) · g −Hk (M ) , H)
= e(g βb +Hk (M )−Hk (M ) , H)
bil.
= e(g βb , H) = xb
Für den zweiten Schritt der Verifikation ersetzen wir dieses Mal fj , Hij und y
mit ihren Berechnungsvorschriften. Dies gilt für jedes j = 1...l:
e(fj , Hij ) · y −Hk (xj ) = e(g αj (βj−1 +Hk (xj )) , H 1/αij ) · e(g, H)−Hk (xj )
bil.
= e(g αj (βj−1 +Hk (xj )q)·1/αij , H) · e(g −Hk (xj ) , H)
= e(g βj−1 +Hk (xj ) , H) · e(g −Hk (xj ) , H)
bil.
= e(g βj−1 +Hk (xj ) · g −Hk (xj ) , H)
= e(g βj−1 +Hk (xj ) · g −Hk (xj ) , H)
= e(g βj−1 +Hk (xj )−Hk (xj ) , H)
= e(g βj−1 , H) = xj−1
Signaturlänge Wie schon im Setup erwähnt, bestimmt der frei wählbare
Wert n den Grad der Verzweigung des Baums, also wie viele Kindknoten jeder
Knoten besitzt, und der frei wählbare Wert l die Tiefe des Baums. Dadurch
bekommen wir ln Blätter für den Baum und können dementsprechend viele Signaturen erzeugen. Idealerweise wird also ein großes n und ein vergleichsweise
kleines l gewählt. Mit n = 20 und l = 4 könnten wir zum Beispiel schon über
eine Billion Signaturen erzeugen. Der öffentliche Schlüssel besteht aus n + 3
und die Signatur aus l + 1 Elementen. Bei der Betrachtung der Signaturelemente können wir die ij wegen ihrer geringen Größe von log2 n ignorieren. Wie
bereits erwähnt, müssen wir für eine zustandslose Signatur die Tiefe des Baums
verdoppeln, sodass jede Signatur aus 2l + 1 Elementen bestünde.
6
4
Sicherheit
Um die größtmögliche Sicherheit zu gewährleisten muss der Angreifer während
der Beweisführung optimale Vorraussetzungen besitzen. Wie solche Vorraussetzungen für den Angriff auf ein Signaturverfahren aussehen ist in Abbildung 1
gezeigt.
Abbildung 1: Optimales Angriffsszenario
Der Angreifer bekommt vor seinem Angriff den öffentlichen Schlüssel mitgeteilt (2) und kann sich einzelne Nachrichten vom Challenger signieren lassen
(3). Im [BSM02]-Verfahren ist die Anzahl der Nachrichten s durch die Anzahl der
Blätter des Authentifikationsbaums begrenzt. Nach jeder Nachricht wird dem
Angreifer direkt die dazugehörige Signatur mitgeteilt und er kann die darauffolgende Nachricht an seinen bisherigen Ergebnisse anpassen. Dies wird adaptive
chosen-message attack genannt.
Der Angreifer hat die Challenge gewonnen, wenn es ihm gelingt ein beliebiges
Nachrichten-Signatur-Paar (M, σ) zu generieren (4), dass vom Verifikationsalgorithmus positiv verifiziert wird. Die Nachricht muss keinerlei Sinn ergeben.
Einzige Bedingung an das Paar: Es darf keines der Paare sein, die vom Challenger an den Angreifer geschickt wurden. Diese Art der Fälschung ist am einfachsten zu realisieren und wird existential forgery genannt.
Definition 5 (Sicheres Signaturverfahren) Ein Signaturverfahren gilt als
(t, s, )-sicher, wenn für die Wahrscheinlichkeit aller Algorithmen A, die Zeit
t benötigen, ein Nachrichten-Signatur-Paar
(M,
σ) zu finden gilt:
AdvSigA = Pr (M, σ) ← A(Mi , σi , kpub )(M, σ) 6= (Mi , σi ); ∀i = 1...s; < Die Sicherheit des vorgestellten Verfahrens wird durch einen Widerspruchsbeweis bestätigt. Im Folgenden wird gezeigt, wie aus der Annahme, dass Signaturen des Verfahrens gefälscht werden können, folgt, dass entweder die verwendete bilineare Abbildung unsicher ist, oder dass eine Kollision in der verwendeten
Hashfunktion H gefunden werden kann. Im Umkehrschluss der Aussagenlogik
bedeutet dies natürlich, dass wenn die verwendete bilineare Abbildung mathematisch sicher ist — also das Diffie-Hellman-Problem hart ist, wie Abschnitt
7
2.3 gezeigt hat — und die verwendete Hashfunktion kollisionsresistent ist, keine
gefälschte Signatur erzeugt werden kann. Das Finden von kollisionsresistenten
Funktionen bzw. der Beweis ihrer Kollisionsresistenz, soll an dieser Stelle nicht
thematisiert werden. Es folgt eine allgemeine Definition, was wir unter einer
solchen Funktion verstehen sollten:
Definition 6 (Kollisionresistente Funktion) Wir nennen eine Funktion
H : K x M → {0, 1}s eine Familie von (t, ε)-kollisionsresistenten Funktionen,
wenn für die Wahrscheinlichkeit aller Algorithmen A, die Zeit t benötigen, eine
Kollision zu finden
gilt:
R
AngKRA = Pr Hk (M1 ) = Hk (M2 ) k ← K; (M1 , M2 ) ← A(k); M1 6= M2 < ε.
Die Wahrscheinlichkeit zwei beliebige Nachrichten zu erzeugen, die denselben Hashwert haben, darf also nicht größer als ε sein.
Angriffsszenario Wir stellen uns also einen Angreifer vor, der Signaturen
des [BMS02]-Verfahrens fälschen kann. Dazu ist es dem Angreifer erlaubt, sich
Nachrichten von uns signieren zu lassen. Er kennt außerdem selbstverständlich
den öffentlichen Schlüssel des Verfahrens. Unser Ziel ist es, dem Angreifer einen
korrekten Signaturalgorithmus vorzutäuschen, obwohl wir in Wirklichkeit jedoch selbst lediglich den öffentlichen Schlüssel des Verfahrens kennen. Dieser
wird von uns so berechnet, dass wir eine für uns nicht lösbare Challenge (gegeben
g, H, G; berechnet h mit e(h, H) = e(g, G)) darin verstecken. Bekommen wir nun
eine gefälschte Signatur, die vom Verfahren positiv verifiziert wird, können wir
diese entweder mit ziemlich hoher Wahrscheinlichkeit dazu nutzen, die Challenge zu lösen oder eine Kollision der Hashfunktion ist aufgetreten. Im Folgenden wird zuerst gezeigt, wie wir mit einer ungelösten bilinearen Abbildung als
Grundlage einen Signaturalgorithmus vortäuschen können, den der Angreifer
nicht vpm echten [BMS02]-Verfahren unterscheiden kann. Für diese Konstruktion brauchen wir noch einen Algorithmus, der Kollisionen in einer bilinearen
Abbildung finden kann. Dieser ist wie folgt definiert:
Definition 7 (Kollisionsfindender Algorithmus) Wir nennen einen Algorithmus für eine bilineare Abbildung G0 × G1 → G2 kollisionsfindend, wenn
er ein Ergebnis g 0 , g 00 ∈ G0 , mit g 0 , g 00 6= 1, für die Gleichung
e(g 0 , G0 ) = e(g 00 , G00 )
für gegebene G0 , G00 ∈ G1 findet, sofern eine solche Lösung existiert.
Solche Algorithmen können sehr einfach für bilineare Abbildungen, die auf
elliptischen Kurven definiert sind, konstruiert werden.
ε
Satz 1 Das Signaturverfahren ist (t, (n+1)
, m)-sicher gegen existential forgery
eines adaptive chosen-message Angriffs, wenn die folgenden Annahmen gelten:
• e ist eine (t, ε)-sichere bilineare Abbildung
• H ist eine (t, ε)-resistente Hashfunktion
8
• es gibt einen effizienten kollisionsfindenden Algorithmus für e
Beweis Wie bereits erwähnt, wird ein Widerspruchsbeweis geführt. Die Existenz eines effizienten Fälschungsangriffs soll zeigen, dass entweder H nicht
kollisionsresistent ist oder man ein bisher unbekanntes g ∗ finden kann für das
gilt:
e(g ∗ , G1 ) = e(g2 , G3 ).
Gegeben sei G1 , G3 ∈ G1 und g2 ∈ G0 .
Unsere Challenge muss jetzt in einen Pseudosignieralgorithmus, genannt Simulator, eingebettet werden, mit dem wir die vom Angreifer geschickten Nachrichten
signieren können.
Als Erstes setzen wir y ← e(g2 , G3 ). Danach wählen wir ein zufälliges i ∈
{0, ..., n}. Wozu dieses i dient, wird später verdeutlicht. Ab hier unterscheiden
wir zwei Fälle, abhängig von unserem zufälligen i.
R
i = 0 : Setze H ← G1 ; wähle γj ← Zp für alle j ∈ {1, ..., n} und setze
Hj ← G3 1/γj . Die inneren Knoten des Authentifikationsbaums, auch x0 , werden als zufällige Potenzen von e(g2 , G3 ) berechnet. Um zu zeigen, dass die so
erzeugten Knoten korrekt verifiziert werden, betrachten wir einen beliebigen
Knoten x0 , der das j-te Kind eines Knotens x00 = e(g2 , G3 )γ ist. Der Authen0
tizitätswert von x0 berechnet sich als f 0 ← g2 γj (γ+H(x )) . Wenn wir diese Werte
in die Berechnungsvorschrift zur Verifikation des Authentizitätswerts von x00
einsetzen, erhalten wir:
0
0
0
e(f 0 , Hj ) · y −H(x ) = e(g2 γj (γ+H(x )) , G3 1/γj ) · e(g2 , G3 )−H(x )
−H(x0 )
0
bil.
= e(g2 γj (γ+H(x ))·1/γj , G3 ) · e(g2
0
−H(x )
= e(g2 γ+H(x ) , G3 ) · e(g2
0
bil.
= e(g2 γ+H(x ) ·
, G3 )
0
, G3 )
−H(x0 )
g2
, G3 )
bil.
= e(g2 γ , G3 ) = e(g2 , G3 )γ = x00
Die Blätter des Baumes werden berechnet, wenn eine neue Nachricht M sigR
niert werden soll. xb ← e(g2 , G1 γb · G3 −H(M ) ) mit einem zufälligen γb ← Zp .
Der Authentizitätswert von H(M ) berechnet sich als f ← g2 γb . Das Blatt
wird an einen beliebigen Knoten der tiefsten Ebene des Baumes gehangen und
der Authentizitätswert wie oben berechnet. Wir erhalten eine gültige Signatur
(f, fb , ib , ..., f1 , i1 ).
R
i ∈ {1, ..., n} : Setze Hi ← G1 . Wähle zufällige γ, γb , ..., γi−1 , γi+1 , ..., γn ← Zp
und setze H ← G3 1/γ sowie Hj ← G3 1/γj für alle j 6= i. Jetzt benutzen wir den
kollisionsfindenden Algorithmus, um ein d1 und ein d2 zu finden, für die gilt:
e(d1 , G1 ) = e(d2 , G3 ).
(1)
Der Authentifikationsbaum wird in diesem Fall von unten nach oben aufgebaut. Dies gelingt uns, wenn wir einen Knoten z jeweils in Abhängigkeit von
9
seinem i-ten Kindknoten zi berechnen. Das verwendete i ist selbstverständlich
das am Anfang des Algorithmus zufällig gewählte i. Der Elternknoten berechR
net sich als z ← e(d2 , G3 δz )y −H(zi ) mit einem zufälligen δz ← Zp . Für alle
j ∈ {1, ...n} =
6 i, berechnet sich der Authentizitätswerts von zj als fj ←
H(zj )−H(zi )
(g2
· dδ2z )γj . Durch Einsetzen dieser derart definierten Werte in die
Verifikationsvorschrift für den Authentizitätswert von z erhalten wir:
e(fj , Hj ) · y −H(zj ) = e((g2 H(zj )−H(zi ) · d2 δz )γj , G3 1/γj ) · e(g2 , G3 )−H(zj )
−H(zj )
bil.
= e((g2 H(zj )−H(zi ) · d2 δz )γj ·1/γj , G3 ) · e(g2
, G3 )
bil.
= e(g2 H(zj )−H(zi )−H(zj ) · d2 δz , G3 )
= e(g2 −H(zi ) · d2 δz , G3 )
bil.
= e(g2 −H(zi ) , G3 ) · e(d2 δz , G3 )
bil.
= e(d2 , Gδ3z ) · e(g2 , G3 )−H(zi )
= e(d2 , Gδ3z ) · y −H(zi ) = z.
Der i-te Kindknoten zi , dessen Wert wiederum von seinem i-ten Kind abhängt,
wird authentifiziert durch fi ← d1 δz . Dadurch ergibt sich in diesem Fall die
Verifikationsvorschrift von z als:
bil.
e(fi , Hi ) · y −H(zi ) = e(d1 δz , G1 ) · y −H(zi ) = e(d1 , G1 )δz · y −H(zi ) .
An dieser Stelle nutzen wir die bei (1) geschaffene Kollision:
e(d1 , G1 )δz · y −H(zi ) = e(d2 , G3 )δz · y −H(zi )
bil.
= e(d2 , Gδ3z ) · y −H(zi ) = z.
Jeder der inneren Knoten kann also in Abhängigkeit zu seinem i-ten Kind konstruiert werden. Auf diese Weise kann ein Pfad bis zur Wurzel x0 und schließlich
die Wurzel selbst berechnet werden. Dies geschieht, wenn die erste Nachricht signiert werden muss. Die Blätter berechnen sich als xb ← e(g2 , H δl ) mit einem
R
zufälligen δb ← Zp . Der Authentizitätswert von H(M ) selbst berechnet sich
als f ← g2 δl +γH(M ) . Die Verifikation des Authentizitätswerts von H(M ), mit
Einbezug des zu Beginn zugewiesenen H = G3 1/γ ⇔ H γ = G3 , lautet:
e(f, H) · y −H(M ) = e(g2 δl +γH(M ) , G3 1/γ ) · e(g2 , G3 )−H(M )
bil.
−H(M )
= e(g2 (δl +γH(M ))·1/γ , G3 ) · e(g2
= e(g2
(δl /γ)+H(M )
, G3 ) ·
, G3 )
−H(M )
, G3 )
e(g2
bil.
= e(g2 (δl /γ)+H(M )−H(M ) , G3 )
= e(g2 (δl /γ) , H γ )
bil.
= e(g2 , H γ(δl /γ) ) = e(g2 , H δl ) = xl
Damit ist die Konstruktion des Simulators vollständig. Da sowohl beim richtigen Verfahren, als auch beim Simulator, die Authentizitätswerte Potenzen sind,
in deren Berechnung immer mindestens eine zufällig gewählte Zahl vorkommt,
10
erscheinen die vom Simulator ausgegebenen Signaturen ebenso zufällig, wie die
Signaturen des richtigen [BMS02]-Verfahrens. Dies ist insofern wichtig, da der
Angreifer, sollte ihm auffallen, dass er es nur mit einem Simulator zu tun hat,
jederzeit aufhören könnte die Challenge zu lösen, obwohl vielleicht eine Methode
dafür vorhanden ist.
Extraktion Wir stellen uns vor, ein Angreifer hätte mithilfe der Antworten
unseres Simulators eine gültige Signatur (fˆ, fˆb , îb , ..., fˆ1 , î1 ) für eine Nachricht
M̂ gefälscht. Wir können ebenfalls davon ausgehen, dass der vollständige Authentifikationsbaum, den wir B nennen, bereits berechnet wurde. Auf Grundlage
dieser Signatur wird im Verifikationsprozess ein Pfad (x̂b , îb , x̂b−1 , îb−1 , ..., î1 , x̂0 )
berechnet. Sofern keine vollständige Übereinstimmung mit einem der Pfade aus
B besteht (vgl. existential forgery) kann der Rest des Pfades beliebig aussehen.
Einzige Bedingung, damit eine Signatur positiv verifiziert, ist eine Übereinstimmung
von x̂0 dieses Pfades und dem x0 aus B. Der Verifikationsalgorithmus des
[BMS02]-Verfahrens prüft nicht, ob der beschriebene Pfad tatsächlich auch in
B vorhanden ist, denn B ist durch seine verfahrensbedingte Konstruktion für
gewöhnlich nicht vollständig bekannt. Stattdessen wird lediglich geprüft, ob der
Pfad vorhanden sein könnte, was dem Angreifer ermöglicht, an irgendeinen der
Knoten von B einen Pfad zu hängen, der aus von ihm erdachten Knoten besteht,
sofern er in der Lage ist, die Authentizitätswerte dieser Knoten zu fälschen.
Abbildung 2: Zwei mögliche Positionen der Fälschung
In Abhängigkeit davon, ob erst der Authentizitätswert von H(M ) gefälscht
wurde (wie (1) in Abb. 2) oder die Fälschung bereits an einem der inneren
Knoten ansetzt (wie (2) in Abb. 2), unterscheiden wir die folgenden beiden
Fälle, wobei xj den am Tiefsten im Angreifer-Pfad liegenden Knoten angibt,
der noch in unserem B liegt.
11
j = b : Der Angreifer hat seine Nachricht an eines der Blätter von B gehangen
und nur den Authentizitätswert seines H(M ) gefälscht. Wir bezeichnen die
Nachricht, für deren Signatur xb ursprünglich erstellt wurde als M und dessen
Authentizitätswert H(M ) als f . Es folgt (aus der xb -Berechnungsvorschrift):
e(fˆ, H) · y −H(M̂ ) = xb
e(f, H) · y −H(M ) = xb .
Aus beiden Gleichungen erhalten wir:
e(fˆ, H) · y −H(M̂ ) = e(f, H) · y −H(M )
e(fˆ, H)
y −H(M )
⇔
= y −H(M )+H(M̂ )
=
e(f, H)
y −H(M̂ )
fˆ
bil.
⇔ e( , H) = y −H(M )+H(M̂ )
f
j < b : Der Angreifer hat einen Pfad — wobei ein solcher Pfad auch nur aus
einem Blatt und dem Hashwert der Nachricht, der am Blatt hängt, bestehen
kann — gefälscht und diesen an den Knoten xj aus B gehangen. Wir betrachten
nun die Authentizitätswerte, die sich auf xj berufen, wobei wir das ij -te Kind
von xj in B mit xj+1 und dessen Authentizitätswert mit fj bezeichnen.
e(fˆj , Hij ) · y −H(x̂j+1 ) = xj
e(fj , Hij ) · y −H(xj+1 ) = xj .
Analog zum Fall j = b erhalten wir:
e(
fˆj
, Hij ) = y −H(xj+1 )+H(x̂j+1 )
fj
Wir unterscheiden zwei weitere Fälle. Im ersten Fall ist H(M̂ ) = H(M ) falls
i = b bzw. H(x̂j+1 ) = H(xj+1 ) falls i < b und wir haben eine Kollision in der
Hashfunktion gefunden. Im zweiten Fall haben wir eine Gleichung der Form
y d = e(f˜, H̃)
mit d und f˜ bekannt und d 6= 0 gelöst. H̃ ist eines von H, H1 , ..., Hn . Durch das
zufällig gewählte i haben wir n + 1 Fälle konstruiert in denen jeweils eines der
H, H1 , ..., Hn gleich G1 gesetzt wurde. Dies ist notwendig, da wir nicht wissen
können, an welchen Knoten im Baum, der Angreifer seine Signatur anhängt. Da
wir aber für alle möglichen Positionen des Angreifer-Pfads einen Baum konstruiert haben, mit dem wir unsere gesuchte bilineare Abbildung lösen können und
einer von diesen zufällig ausgewählt wird, gilt mit einer Wahrscheinlichkeit von
1
n+1 , dass H̃ = G1 ist. Dadurch, dass y = e(g2 , G3 ) haben wir in einem solchen
Fall eine Gleichung
bil.
e(g2 , G3 )d = e(f˜, G1 ) ⇔ e(g2 , G3 ) = e(f˜, G1 )1/d ⇔ e(g2 , G3 ) = e(f˜1/d , G1 )
gefunden. f˜1/d ist dabei das gesuchte g ∗ , aus der für uns anfangs unlösbaren
bilinearen Gleichung, das wir jetzt dank des Angreifers berechnen können. Wir
12
können also mithilfe eines effizienten Algorithmus zum Fälschen von Signaturen
des [BMS02]-Verfahrens entweder eine Kollision in der Hashfunktion finden oder
zeigen, dass die verwendete bilineare Abbildung e nicht sicher ist. Damit ist im
Umkehrschluss Satz 1 bewiesen.
5
Konkretes Signaturverfahren
Für das konkrete Verfahren wird als sichere bilineare Abbildung e : G0 × G1 →
G2 eine elliptische Kurve E/Fp gewählt, für die es einen effizienten kollisionsfindenden Algorithmus gibt. Mit E/Fpr wird die Menge an Punkten von E über
Fpr bezeichnet. q soll ein Primfaktor von |E(Fp )| sein.
Wir können G0 = G1 als eine Untergruppe mit allen Punkten der Ordnung
q in E(Fp ) annehmen, wenn wir eine supersinguläre Kurve über Fp mit p > 3
wählen. Die Gruppe G2 ist die Einheitsgruppe der Ordnung q von F∗ p2 – enthält
also nur invertierbare Zahlen. Das von Boneh und Franklin4 modifizierte Weil
pairing bezeichnen wir als ê. Da wir annehmen, dass das DHP in G0 nicht
effizient lösbar ist, wissen wir, dass ê sicher nach Definition 2 ist. Durch die
Symmetrie von ê, erhalten wir auch direkt den kollisionsfindenden Algorithmus
ê(G, H) = ê(H, G) mit G, H ∈ G1 . Es sind alle Forderungen von Satz 1 erfüllt
und wir haben ein mögliches Signaturverfahren nach [BMS02].
4 D. Boneh and M. Franklin, “Identity based encryption from the Weil pairing,” Proc. of
CRYPTO’01, pp. 213-229, 2001. Also http://eprint.iacr.org/2001/090/
13