Kryptologie

Kryptologie
Bernd Borchert
Univ. Tübingen, SS 2017
Vorlesung
Teil 1
- Historische Verschlüsselungsverfahren
Kryptologie – vom Umgang mit Geheimnissen
Drei Zielrichtungen
der Kryptologie:
Verschlüsseln
Nachrichten geheim halten
Speicherinhalte verschlüsseln
Vertraulichkeit
Integrität
Signieren:
Daten gegen Abänderung schützen
Nachweisbarkeit erreichen
Authentizität
Authentisieren:
Passwort
Fingerabdruck
Token
Vertraulichkeit – Basis Szenario
m
A
B
Verschlüsselungs-Szenario: Ein Sender A will einen Empfänger B in
der Zukunft eine Nachrichten zuschicken, die nicht von jemand
anders gelesen werden kann.
Zu dem Zweck dürfen sich A und B, solange sie noch am gleichen
Ort sind, ein gemeinsames Geheimnis erzeugen, sagen wir auf
Papier (oder USB Stick).
A
c(m)
K
B
K
Die Nachricht wird dann von A mithilfe des Geheimnisses K kodiert,
Nach Empfang dekodiert B die Nachricht ebenfalls mithilfe
des Geheimnisses K.
Anwendungen z.B.:
- Militär: A Befehlender, B Befehlsempfänger
- Geschäft: A Chef, B Mitarbeiter
Cäsar Chiffre
A B C D E F G H I J K L MN O P Q R S T U V WX Y Z
H I J K L MN O P Q R S T U V WX Y Z A B C D E F G
HALLOWELT wird zu OHSSVDLSA
A
OHSSVDLSA
K
B
K
Zyklus der Buchstaben. Leicht zu knacken (nur n=25 Möglichkeiten).
Besser ist eine “monoalphabetische Chiffre”, also eine Bijektion
der Buchstaben:
A B C D E F G H I J K L MN O P Q R S T U V WX Y
Z Z
I O J R L MV N S P WA T Y B Q E C Z K F H G X D
U U
HALLOWELT wird zu NIAABGLAK
Trotzdem nicht sicher: Zählung häufigster Buchstaben, Doppelbuchstaben, etc.
Cardano Chiffre
Giacomo Cardano, auch Erfinder der Kardanwelle
Nachricht
Geheimnis
(die Lochkarte)
(hier in der Steganographie Version, d.h. die Nachricht erscheint harmlos)
Vigenere Chiffre
Alphabet: A-Z plus ein paar extra Zeichen (insgesamt 30 Zeichen)
A B C D E F G H I J K L MN O P Q R S T U V WX Y Z
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
. ? !
26
27
28
29
Schlüssel: L I S A
L I S A L I S A L I S A L I S A
Zu codierende Nachricht:
H E U T
E
U M
S I E B E N !
Ciphertext:
S MI T
P D I M G G G E MMB !
Decodierte Nachricht:
H E U T
E
U M
S I E B E N !
Der Schlüssel wird einfach immer
wieder
hintereinandergeschrieben, so oft wie
die Nachricht lang ist.
Angriff: pro Position des Schlüssels
eine Häufigskeitsanalyse machen. Im
Beispiel sind das 4 Stellen. An der 2.
Stelle kommt im Beispiel-Cyphertext
2 mal M vor: Das vorläufige Setzen
auf M=c(E) mit E als häufigstem
Buchstaben stellt sich als korrekt
heraus.
Wenn unbekannt ist, wie lang der
Schlüsselstring ist (im Beispiel Länge
4) ist die Analyse schwieriger.
Kryptologie
Bernd Borchert
Univ. Tübingen, SS 2017
Vorlesung
Doppelstunde 2
- One Time Pad
- Authentisierung
Homophone Chiffre
Monoalphabetische Chiffre”: Bijektion der Buchstaben:
A B C D E F G H I J K L MN O P Q R S T U V WX Y
Z Z
I O J R L M V N S P WA T Y B Q E C Z K F H G X D
U U
Problem: Häufigkeitsanalyse: die in der Klartext-Sprache häufigsten Buchstaben werden den häufigsten
Buchstaben im Chiffretext zugeordnet, so kann man einen Chiffretext relativ schnell entschlüsseln.
Die homophone Chiffre eliminiert diesen Nachteil. Das Chiffre-Alphabet enthält dabei deutlich mehr
Buchstaben als das Klartextalphabet. Und dann werden den häufig vorkommenden Buchstaben der KlartextSprache mehrere Buchstaben des Chiffre-Alphabets zufällig zugeordnet, und zwar soviele, wie es ungefähr der
Häufigkeit in der Klartextsprache entspricht. Jeder Chiffre-Buchstabe kommt genau einmal vor.
A B C D E F G H I J K L MN O P Q R S T U V WX Y
Z Z
Q a Mq k D d i V I c C P Y u F s t T l e E J m U K
O
b
r j
A
R h
B
p
X
w
ca.8%
N
S
x
ca.15%
Z
W
G f L y
H
n g z
v
HALLO
o
c
RbZCu
Beim Verschlüsseln wird
gleichverteilter Zufall eingesetzt,
um aus der Menge der möglichen
Chiffretext-Buchstaben einen
auszuwählen.
Die Häufigkeitsanalyse wird dadurch praktisch eliminiert.
Auch für die Suche nach häufigen Buchstabennachbarn kann man sich eine
ähnliche, darauf aufsetzende Technik als Gegenmaßnahme überlegen.
Nachteil dieser Substitutions-Verschlüsselung: der Chiffretext ist länger als der
Klartext (in bits).
One-Time Pad
Das One-Time Pad ist praktisch die einzige Verschlüsselung, die nachweislich
sicher ist, und nicht nur sicher aufgrund von Annahmen ist.
Einzige Annahme (realistisch):
Gleichverteilter Zufall ist vorhanden (Münze, Würfel)
Erfinder: Vernam (USA, ca. 1918)
Beweis der 100% Sicherheit:
Mauborgne (USA, ~1920), Shannon (USA, 1948)
One-Time Pad
Alphabet: A-Z plus ein paar extra Zeichen (insgesamt 30 Zeichen)
A B C D E F G H I J K L MN O P Q R S T U V WX Y Z
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Schlüssel: Gleichverteilter Zufallsstring (aus
diesen Zeichen):
K . WR L
D H H P B J A F Z I
Zu codierende Nachricht:
A N G R I F F
MO R G E N !
Codierte Nachricht:
K K ? E S B I D T ! S P E S Y E
Decodierte Nachricht:
A N G R I F F
MO R G E N !
19
20
21
22
23
24
25
. ? !
26
27
28
29
Binäres One-Time Pad (EXOR)
One-time pad (Zufall)
1 1 0 0 1 1 0 1 0 1 1 0 1 0
Zu codierende Nachricht:
1 0 0 1 0 0 0 1 1 0 1 0 0 1
H
i
Codierte Nachricht: (EXOR)
0 1 0 1 1 1 0 0 1 1 0 0 1 1
Decodierte Nachricht:
1 0 0 1 0 0 0 1 1 0 1 0 0 1
H
i
In diesem mod 2 Spezialfall:
Codierfunktion = Decodierfunktion
Beweis Sicherheit One-Time Pad
Beweis der perfekten Sicherheit der One-Time Pads.
Behauptung: Wenn das one-time-pad K durch gleich-verteilten Zufall
entstanden ist, hat ein Angreifer bei einem abgefangenen Ciphertext C
keine Information darüber, wie die Originalnachricht m aussah.
Beweis: Eine abgefangener Ciphertext C kann aus jeder Nachricht m
entstanden sein, nämlich dann, falls als Schlüssel K = C EXOR m
gewählt wurde, und auch nur in diesem Fall. Weil alle Schlüssel K die
gleiche Wahrscheinlichkeit haben, haben also auch alle Nachrichten die
gleiche Wahrscheinlichkeit, dass aus ihnen C entstanden sein könnte.
Beispiel: Sei C = 01 der abgehörte Ciphertext.
C könnte aus der Nachricht 00 entstanden sein, wenn der Schlüssel 01 wäre.
C könnte aus der Nachricht 01 entstanden sein, wenn der Schlüssel 00 wäre.
C könnte aus der Nachricht 10 entstanden sein, wenn der Schlüssel 11 wäre.
C könnte aus der Nachricht 11 entstanden sein, wenn der Schlüssel 10 wäre.
Weil jeder der 4 möglichen Schlüssel die Wahrscheinlichkeit 25% hat, hat jede der 4 entsprechenden
Originalnachrichten (alle verschieden) die gleiche Wahrscheinlichkeit (25%). Also kann der Abhörer keine
Aussage über die Nachricht machen, nicht einmal eine probabilistische. Er hat mit C also keinerlei
Information über die Nachricht.
Affine Chiffren: Rechnen auf {0,1}
Auf der Menge {0,1} kann man rechnen:
Die Addition ist die Addition mod 2, oder anders ausgedrückt: das EXOR
0+0=0
0+1=1
1+0=1
1+1=0
Die Multiplikation auf {0,1} ist so wie als Teilmenge von Z, oder anders
ausgedrückt: das UND
0.0=0
0.1=0
1.0=0
1.1=1
So wird {0,1} zu einem sog. Körper (wie R oder C)
Die Menge der n-Tupel von Körperelementen ist ein n-dimensionaler Vektorraum.
Affine Chiffren: Matrizenrechnung
Eine n x n Matrix aus {0,1} stellt damit eine Abbildung auf den n-Tupeln dar:
(0, 1, 1)
( )
0 1 0
0 1 1
1 0 1
= (1, 1, 0)
0.0 + 1.0 + 1.1 = 0 + 0 + 1= 1
Wenn die Matrix A invertierbar ist, ist die durch A gegeben lineare Abbildung v -> vA
eine Bijektion, ebenso wie die affine Abbildung v -> vA + b, und das für jeden festen Vektor b.
Damit eignet sich eine invertierbare A zum Verschlüsseln von Bitstrings v der Länge n: v wird als Tupel
aufgefasst und auf den String c(v) =vA + b abgebildet. Das Paar (A,b) ist der Schlüssel.
Entschlüsselt wird w = vA + b durch v = (w-b)A -1
Wenn b = Nullvektor, nennt man es eine Lineare Chiffre, und allgemein eine Affine Chiffre.
Eine Bit-String der Länge kn v1...vk wird auf c(v1)...c(vk) abgebildet (erstes Beispiel einer Blockchiffre)
Statt auf {0,1} mit mod 2 kann man auch auf {0,1,...,k-1} mit mod k für eine Primzahlpotenz k rechnen. Die Matrizen
Rechnung geht genau so und die Def. der Affinen Chiffre ist darauf übertragbar.
Als Verschlüsselungsverfahren sind Affine Chiffren relativ schwach, besonders bei known-plaintext.
Authentisierung
Die drei Authentisierungs-Faktoren
Faktor Wissen: etwas, was der richtige Benutzer weiß: Passwort, PIN,
etc.
Faktor Haben: etwas, was der richtige Benutzer bei sich hat:
Zutrittskarte, Handy, Bankkarte, etc.
Faktor Sein: etwas, was der richtige Benutzer körperlich hat:
Fingerabdruck, Gesichtserkennung, etc.
Kryptologie
Bernd Borchert
Univ. Tübingen, SS 2017
Vorlesung
Doppelstunde 3
Visuelle Kryptographie
Sie sehen an den mitgebrachten Folien:
+
=
HALLO!
Man kann es aber auch so sehen: die Information wird in zwei Teile zerlegt, die
beide jeweils allein keine Information haben:
HALLO!
=
Wie funktioniert‘s?
+
Visuelle Kryptographie – wie funktioniert's?
1.Folie
(Zufall)
Original-Bild
2.Folie
(kein Zufall)
1.+ 2. Folie
=
=
Quasi wie one-time pad, nur 2-dimensional und
visuell entschlüsselt mit OR, nicht EXOR
Zusammenfassung Historische Verschlüsselungsverfahren
A
m
K
B
K
Einfache Verschlüsselungsverfahren für das einfachste Szenario
„A will B eine geheime Nachricht senden“
wobei A und B vorher schon ein Geheimnis K ausgetauscht haben.
Cäsar Chiffre
Monoalphabetische Vertauschung
Cardano Chiffre
Vigenere Chiffre
Homophone Chiffre
One-time Pad
Lineare Chiffre
Affine Chiffre
Visuelle Kryptographie
nicht sicher
nicht sicher
sicher (bei Einmalverwendung)
nicht sicher
nicht sicher
sicher (bei Einmalverwendung)
nicht sicher
nicht sicher
sicher (bei Einmalverwendung)
Angriffstypen
A
cK(m)
K
B
K
ciphertext-only, mit Angriffziel Nachricht:
cK(m) liegt vor, und es soll m gefunden werden
ciphertext-only, mit Angriffsziel Schlüssel:
cK(m1), ..., cK(mj) liegen vor, und es soll Schlüssel K gefunden werden
known-plaintext:
m1, cK(m1), ..., mj, cK(mj) liegen vor, und es soll K gefunden werden
chosen-plaintext:
m1, ..., mj dürfen vom Angreifer gewählt werden, dann werden cK(m1), ..., cK(mj) berechnet,
(ggfs. das einige Male iterativ) und dann soll aus m1, cK(m1), ..., mj, cK(mj) K gefunden werden
Alle bisher betrachteten Verschlüsselungs-Verfahren sind nicht sicher gegen known-plaintext
Angriffe, geschweige denn, sicher gegen chosen-plaintext Angriffe.
Blockchiffre
Eine Blockchiffre verschlüsselt Bitstrings der Länge n in Bitstrings der Länge n, und das für jeden
Schlüssel K.
Formal ist eine Blockchiffre ist also eine Abbildung c: {0,1}n x {0,1}k --> {0,1}n (Blockgröße
n, Schlüsselänge k), so dass für jedes feste K gilt, dass die Abbildung von {0,1}n nach {0,1}n
gegeben durch y --> c(y,K) bijektiv ist.
Typische Blockgrößen sind n = 68, 128, 1024. Der Schlüssel hat ein Größe in der Größenordnung
der Blocklänge, aber muss nicht die gleiche Länge haben. Typische Schlüssellängen sind k = 56,
128, 192, 256, 1024.
Affine Chiffren waren der erste, aber noch nicht überzeugende Versuch einer Blockchiffre, denn
eine Blockchiffre sollte gegen chosen-plaintext und known-plaintext Angriffe sicher sein.
Gegeben ist ein langer Text und eine Blockchiffre inkl. Blocklänge und Schlüssel. Wie
verschlüsselt man den Text? Es gibt verschiedene Betriebsmodi, von denen die wichtigsten 4 hier
vorgestellt werden.
Der naheliegenste Modus ist der ECB (Elektronic Code Book) Modus:
1. den Text hinten auf Blocklängenvielfaches padden,
2. und dann Block für Block verschlüsseln,
3. die entstandenen Ciphertexte in dieser Reihenfolge aneinanderketten
Betriebsmodi
ECB Modus
Electronic Code Book Modus
Plaintext
key
Ciphertext
V
key
V
key
V
Betriebsmodi
Nachteil ECB
key
ECB
“Pinguin Effekt”:
Gleiche Blöcke werden
auf den gleichen Chiffre-Blöcke
abgebildet. Das kann eine
Information für den Angrefier
bedeuten.
Bei Bildern ist das z.B. fatal,
siehe das Beispiel.
Betriebsmodi
CBC Modus
Cipher Block Chaining Modus
Plaintext:
IV
+
key
Ciphertext:
V
+
key
V
+
key
V
Betriebsmodi
Vorteil CBC
key
ECB
key
CBC
Betriebsmodi
CFB Modus
Cipher Feedback Modus
Plaintext:
key
IV
Ciphertext:
V
key
+
V
key
+
V
+
Betriebsmodi
OFB Modus
Output Feedback Modus
Plaintext:
key
IV
V
key
+
V
key
+
Ciphertext:
Vorteil: der String, mit dem ge-EXOR-ed wird, kann
schon im Voraus berechnet werden
V
+
Betriebsmodi
ECB
CBC
CFB
OFB
Zusammenfassung Betriebsmodi
--> Betriebsmodus wählen: ECB, CBC, CFB, oder OFB
Nachteile
- ECB “Pinguin” Effekt
- CBC, CFB, OFB brauchen IV – vergrößert Datengröße und den Verwaltungsaufwand
Vorteile
- bei CFB und OFB muss nicht auf Blockgröße gepaddet werden
- bei OFB kann das ganze feedback im Voraus berechnet werden.
OFB stellt somit eigentlich eine typische sog. Stromchiffre dar
Kryptologie
Bernd Borchert
Univ. Tübingen SS 2017
Vorlesung
Doppelstunde 4
Rechnen modulo n
Modulo Rechnen
a mod n ist definiert als Rest von a bei Division durch n (a aus Z, n aus N)
Rechenregeln:
(a + b) mod n = (a mod n + b mod n) mod n
(a - b) mod n = (a mod n - b mod n) mod n
(a * b) mod n = (a mod n * b mod n) mod n
Operator- und Kongruenz-Schreibweise, Teilbarkeit:
a mod n = b mod n ⇔ a ≡ b (mod n)
⇔ n | (a - b)
10
0
9
8
mod 11
1
2
Beispiele:
3
(6 + 9) mod 11 = 15 mod 11 = 4
7
4
6 – 9 ≡ -3 ≡ 8 (mod 11)
6
5
6 * 9 ≡ 54 ≡ 10 (mod 11), 11 | (54 - 10)
(60 + 9) mod 11 = (60 mod 11 + 9 mod 11) mod 11 = (5 + 9) mod 11 = 14 mod 11 = 3
Zn sei die Menge der Zahlen 0, 1, ..., n - 1. Die Operationen +, - und * auf Z n sind
eindeutig definiert durch die Operation in Z und anschließender Modulo-Rechnung;
effizient berechenbar.
Was ist mit Dividieren und Potenzieren?
Modulo Division
“a geteilt durch b mod n” bedeutet die Multiplikation von a mit dem multiplikativen
Inversen von b mod n.
Das multiplikative Inverse b-1 in Zn von b ist die Zahl c so dass b*c ≡ 1 (mod n).
Wenn b-1 in Zn existiert, dann ist es eindeutig.
Beispiel: Das mult. Inverse von 2 in Z5 ist 3, denn 2*3 ≡ 6 ≡ 1 (mod 5).
Nicht jede Zahl a hat ein mult. Inverses in Zn , z. B. hat 2 in Z4 kein Inverses
(2*0 mod 4 = 0, 2*1 mod 4 = 2, 2*2 mod 4 = 0, 2*3 mod 4 = 2).
Später sehen wir: Wenn p Primzahl ist, hat jede Zahl > 0 in Z p ein mult. Inverses, d.h. Zp
ist ein sogenannter Körper.
Aber vorerst stellen wir nur das Verfahren zur Berechnung des mult. Inversen von b in
Zn vor – das Verfahren wird uns dabei automatisch sagen, ob dieses Inverse existiert.
Euklidischer Algorithmus (für ggT)
Gesucht: größter gemeinsamer Teiler ggT(a,b) von zwei Zahlen a und b
(hier jetzt keine modulo Rechnung, sondern Rechnung in Z)
x := |a|, y := |b|
while y ≠ 0:
r := x mod y
x := y
y := r
return x
Am Ende gilt x = ggT(a,b).
Beispiel: ggT(61,36) = ?
61 = 1 * 36 + 25
36 = 1 * 25 + 11
25 = 2 * 11 + 3
11 = 3 * 3 + 2
3=1* 2+ 1
2=2* 1+ 0
ggT(61,36) = 1
Euklid, Alexandria (Ägypten),
ca. 300 v.Chr.
Beweis Euklidischer Algorithmus
Beweis (anschaulich, wie im Original von Euklid ca. 300 v.Chr.)
ggT(a,b) = ggT(b,c) wobei c der Rest ist von a : b
a
b
Ein Teiler t von a und b muss auch den Rest c teilen:
a
b a
b
t
t
t
t
t
c
b
t
t
t
Wenn c nicht durch t teilbar
ist, wäre es a auch nicht
t
t
t
Das gilt auch für den größten Teiler, also
ggT(a,b) = ggT(b,c)
Gesamtbeweis von Euklids Algorithmus:
ggT(a,b) = ggT(b,c) = ggT (c,d) = ... = ggT(an,bn)
Euklidischer Algorithmus (für ggT)
Gleiche Berechnung, aber hier nochmal in Tabellenform:
Gesucht: ggT(61,36)
ggT(61,36) = 1
a
b
q
r
61 = 1 * 36 + 25
61
36
1
25
36 = 1 * 25 + 11
36
25
1
11
25 = 2 * 11 + 3
25
11
2
3
11 = 3 * 3 + 2
11
3
3
2
3=1* 2+ 1
3
2
1
1
2=2* 1+ 0
2
1
2
0
1
0
ggT(61,36) = 1
Erweiterter Euklidischer Algorithmus
Lemma von Bézout:
Seien a, b aus Z. Dann existieren s, t aus Z mit s*a + t*b = ggT(a,b).
s und t können durch Erweiterung des Euklidischen Algorithmus berechnet werden:
nach der Berechnung des ggT werden die Restedarstellungen von unten nach oben eingesetzt.
Im Beispiel:
1 = 3 - 1*2
= 3 - 1*(11-3*3) = -11 + 4*3
= -11 + 4*(25-2*11) = 4*25 - 9*11
= 4*25 - 9*(36-25) = -9*36 + 13*25
= -9*36 + 13*(61-36) = 13*61 + (-22)*36
s a
t
b
Erweiterter Euklidischer Algorithmus
13 * 61 + (-22) * 36 = 1
(Prüfung:
793 – 792 = 1)
a
b
q
r
s
t
61
36
1
25
13
-22
= -9 – 1 * 13
36
25
1
11
-9
13
= 4 – 1 * (-9)
25
11
2
3
4
-9
= -1 – 2 * 4
25 = 2 * 11 + 3
11
3
3
2
-1
4
= 1 – 3 * (-1)
11 = 3 * 3 + 2
3
2
1
1
1
-1
=0–1*1
2
1
2
0
0
1
1
0
1
0
61 = 1 * 36 + 25
36 = 1 * 25 + 11
3=1* 2+ 1
2=2* 1+ 0
ggT(61,36) = 1
s := tu
t := su - q * tu
Erweiterter Euklidischer Algorithmus - Beweis Korrektheit
(Prüfung:
13 * 61 + (-22) * 36 = 1 793 – 792 = 1)
61 = 1 * 36 + 25
36 = 1 * 25 + 11
25 = 2 * 11 + 3
11 = 3 * 3 + 2
3=1* 2+ 1
a
b
q
r
s
t
61
36
1
25
13
-22
= -9 – 1 * 13
36
25
1
11
-9
13
= 4 – 1 * (-9)
25
11
2
3
4
-9
= -1 – 2 * 4
11
3
3
2
-1
4
= 1 – 3 * (-1)
3
2
1
1
1
-1
=0–1*1
2
1
2
0
0
1
1
0
1
0
2=2* 1+ 0
ggT(61,36) = 1
s := tu
t := su - q * tu
Korrektheitsbeweis. Zu zeigen ist die Invariante sa + tb = ggT(a,b) für jede Zeile.
Induktionsanfang: zweitunterste Zeile. Induktionsschluss:
sa + tb = tua + (su - qtu )b = tu(auq + bu) + (su - q tu )au = tuauq + tubu + suau- q tu au = tubu + suau = ggT(a,b)
Berechnung Multiplikatives Inverses modulo a
Gegeben sind a, b.
b besitzt genau dann ein multiplikatives Inverses modulo a (d.h. ein i mit b*i ≡ 1 (mod a)),
wenn ggT(a,b) = 1.
Das mult. Inverse kann mit dem EEA berechnet werden (falls es existiert, d.h. ggT(a,b) = 1):
* Der EEA liefert s,t aus Z mit s*a + t*b = ggT(a,b) = 1.
* Modulo a rechnen:
s*a + t*b ≡ 1 (mod a)
⇒
t*b ≡ 1 (mod a)
Das mult. Inverse von b in Za ist also t mod a.
Beispiel:
ggT(61, 36) = 1. EEA liefert: 13 * 61 + (-22) * 36 = 1,
also ist das mult. Inverse von 36 modulo 61: -22 mod 61 = 39.
Probe: (36 * 39) mod 61 = 1.
Potenzieren
Dividieren in Zn geht also auch. Die Berechnung ist gewöhnungsbedürftig, aber für
einen Computer kein Problem, auch nicht von der Rechenzeit her.
Was ist mit Potenzieren? 4383 mod n ist ein Zahl < n. Kann man das berechnen,
ohne 83 mal zu multiplizieren?
Beobachtung:
432 braucht 1 Multiplikation
c d
4
2 2
Potenzgesetz:
(a
) = ac*d
43 = (43 ) braucht 2 Multiplikationen,
438 = (434)2 braucht nur 3 Multiplikationen,
...
4364 = (432)2)2 )2)2)2 braucht nur 6 Multiplikationen mod n
Daraus ergibt sich der folgende Algorithmus. Um a b mod n zu berechnen, berechne a2
k
mod n, a4 mod n, a8 mod n, …, bis zum ersten a2 mod n, so dass 2k+1 größer ist als b.
Stelle b als Summe von 2-er Potenzen dar, und multipliziere dann die entsprechenden
Potenzen miteinander.
Potenzgesetz: ac+d = ac * ad
6
4
1
0
Beispiel: 83 = 2 + 2 + 2 + 2
6
4
1
0
Also ist a83 mod n = a2 * a2 * a2 * a2 mod n
Square and Multiply
Die folgende Variante des vorigen Algorithmus wird “Square-and-Multiply”-Algorithmus
(SaM) genannt.
Sei v die Binärdarstellung einer Zahl. Dann ist a (v || 0)2 = (av)2 und a(v || 1)2 = (av)2 * a.
Soll ab mod n berechnet werden, so berechne die Binärdarstellung von b und wende
die obigen beiden Regeln iterativ an (von links nach rechts; die erste 1 wird ignoriert,
danach 0 = erste Regel und 1 = zweite Regel; nach jedem Schritt wird mod n gerechnet).
Beispiel: Exponent b = 83: ab = a83 = a(1010011)2 mod n
initialize
square
x := a mod n
1010011
x := x2 mod n
1010011
x := (x2 * a) mod n
square and multiply
x := x2 mod n
x := x2 mod n
1010011
1010011
1010011
x := (x2 * a) mod n
1010011
square and multiply
x := (x2 * a) mod n
1010011
square and multiply
Es gilt dann: x ≡ a83 ≡ a(1010011)2 (mod n)
square
square
Wenn eine 1 kommt
Chinesischer Restsatz
Seien m1, ..., mn aus N paarweise teilerfremd, M = m1 * ... * mn,
a1, ..., an aus Z.
Dann existiert genau ein 0 ≤ x < M mit
x ≡ a1 (mod m1)
x ≡ a2 (mod m2)
Simultane Kongruenz
...
x ≡ an (mod mn)
}
(Sun Zi, China, ca. 300 europ. Zeitrechnung)
Berechnung von x:
Setze Mi := M : mi. Es ist ggT(Mi, mi) = 1 für alle i in { 1, ..., n }.
EEA liefert si und ti mit si * Mi + ti * mi = 1.
Setze ei := si * Mi (damit ist ei ≡ 1 (mod mi) und ei ≡ 0 (mod mj) für j ≠ i).
Die gesuchte Lösung ist x := ∑i=1n (ai * ei) mod M.
Chinesischer Restsatz
Beweis.
Für alle j in { 1, ..., n } gilt (modulo mj):
x ≡ ∑i=1n (ai * ei)
≡ ∑i=1n (ai * si * Mi)
≡ aj * sj * Mj
(da alle Mi für i ≠ j durch mj teilbar sind)
≡ aj * (1 - tj * mj)
≡ aj (mod mj)
Eindeutigkeit folgt mit M = m1 * ... * mn.
Beispiel.
Gesucht: Lösung x für x ≡ 1 (mod 3), x ≡ 4 (mod 5), x ≡ 2 (mod 8).
m1 = 3, m2 = 5, m3 = 8,
a1 = 1, a2 = 4, a3 = 2,
M = 120, M1 = 40, M2 = 24, M3 = 15.
Mit EEA: s1 = 1 (1*40-13*3 = 1), s2 = -1 (-1*24+5*5 = 1), s3 = -1 (-1*15+2*8 = 1),
e1 = 40, e2 = -24, e3 = -15,
x = (1 * 40 + 4 * (-24) + 2 * (-15)) mod 120 = -86 mod 120 = 34.
Zusammenfassung
Zusammenfassung Rechnen in Zn
Addition, Subtraktion, und Multiplikation sind in Zn genau wie in Z, es
bleibt jeweils nur die mod Operation zu berechnen.
Division in Zn ist die Multiplikation mit dem multiplikativen Inversen (falls
existent). Der Algorithmus zur Berechnung des multiplikativen Inversen ist der
Erweiterte Euklidische Algorithmus (ist schnell).
Potenzieren ab in Zn geht mit Square-and-Multiply (ist schnell).
Lösungen für simultane Kongruenzen lassen sich effizient mit dem
Chinesischen Restsatz berechnen.
Kryptologie
Bernd Borchert
Univ. Tübingen SS 2017
Vorlesung
Doppelstunde 5
Feistel Netzwerk, DES
DES (Data Encryption Standard)
Blockchiffre DES:
verschlüsselt einen 64 bit Block in einen 64 bit Block,und das mit einem Schlüssel der Länge 56 bit.
x
Plaintext x
Schlüssel K
K
DES
c(x)
Ciphertext c(x)
K
Die Ver- und die Entschlüsselungsfunktion sind rel. schnell berechenbar.
Entwickelt ca. 1976, ca. 1990 gebrochen: Schlüssel ist einfach zu kurz!
“brechen” heißt: known-plaintext Angriff ist erfolgreich:
Schlüssel wird aus abgehörten plaintext/ciphertext Paaren gefunden
DES-1
x
Vertauschung IP
32 bit
+
Feistel
Netzwerk
+
+
32 bit
32 bit
32 bit
...
+
F
Subkey 1 (48 bit)
32 bit
F
Subkey 2 (48 bit)
F
32 bit
Subkey 3 (48 bit)
...
...
32 bit
32 bit
F
Subkey 16 (48 bit)
Vertauschung IP-1
Umkehrbarkeit DES
x
y
32 bit
32 bit
+
F
Subkey i (48 bit)
swap
32 bit
+
y
32 bit
F
Subkey i (48 bit)
x
x + F(y,Subkey i) + F(y,Subkey i) = x
Fazit: Egal, wie F aussieht: DES ist umkehrbar durch Swappen und Durchlaufen
der 16 Runden in umgekehrter Reihenfolge: (nächste Seite)
Umkehrabbildung DES
IP
swap
+
+
32 bit
32 bit
...
+
F
Subkey 16 (48 bit)
F
Subkey 15 (48 bit)
...
...
32 bit
F
Subkey 1 (48 bit)
swap
IP-1
Feistelschaltung F
Subkey i (48 bit)
32 bit
Extension E
+
S1
S2
S3
S4
S5
S6
Permutation P
32 bit
S7
S8
Feistelbox S1
- Die beiden gelben bits werden binär als Zeile 0-3 interpretiert,
- die 4 blauen bits oben binär als Spalte 0-15
- und der in der Tabelle stehende Wert 0-15 wird binär zu den 4
blauen bits unten
S1
S1
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
0
1
2
3
14 4 13 1 2 15 11 8 3 10 6 12 5 9
0 15 7 4 14 2 13 1 10 6 12 11 9 5
4 1 14 8 13 6 2 11 15 12 9 7 3 10
15 12 8 2 4 9 1 7 5 11 3 14 10 0
0
3
5
6
7
8
0
13
S2 bis S8 werden analog, aber möglichst unterschiedlich definiert.
DES Subkey Erzeugung
Die 16 48-bit Subkeys für DES werden aus dem vorgegebenen
56 bit Schlüssel durch Halbieren, Weglassen, Shiften, Permutieren und
Wiederzusammensetzen erzeugt.
Details (in der Vorlesung nur oberflächlich besprochen)
Iteration
Number of
Number
Left Shifts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
1
1
2
2
2
2
2
2
1
2
2
2
2
2
2
1
Triple DES (3DES)
Triple DES verschlüsselt einen 64 bit Block in einen 64 bit Block,
mit einem Schlüssel der Länge 3 x 56 = 168 bit.
Plaintext
DES
bits 0-55 Schlüssel
DES-1
bits 56-111 Schlüssel
DES
bits 112-167 Schlüssel
Ciphertext
Ist sicher, d.h. nicht gebrochen (2017)
Dass in der Mitte die Umkehrfunktion DES-1 genutzt wird, ist unwesentlich. Es ist nur ein Kniff,
um eine 3DES Hard-/Software auch als DES nutzen zu können, denn so ist DESK = 3DESK,K,K
2-DES
2-DES ist nicht sicher, denn es kann durch einen Meet-in-the-Middle Angriff
gebrochen werden (known plaintext)
Annahme: Angreifer hat 2 plaintext/ciphertext Paare <p1,c1>
<p2,c2> abgehört. Wir nehmen an, dass eine 2DESVerschlüsselung unter allen 2DES-Veschlüsselungen durch 2
Paare <p1,c1> <p2,c2> eindeutig bestimmt ist (deshalb 2
Paare).
Gesucht sind K1, K2 mit
2DESK1,K2(p1)= c1 und 2DESK1,K2(p2)= c2
p
K1
DES
e(p)=d(c)
K2
DB
DES
c
<ek76(p1),ek76(p2),k76>
<ek2(p1), ek2(p2), k2>
<ek34(p1),ek34(p2),k34>
...
<ek17(p1),ek17(p2), k17>
Index - nicht auf k,
sondern auf e(p)
Angreifer legt eine große DB an mit den Tripeln
<ek(p1),ek(p2),k> für alle möglichen Schlüssel k für die erste
DES-Verschlüsselung, geordnet nach ek(p1), d.h.
binäre/schnelle Suche möglich (256 Datensätze ist heutzutage
machbar)
Danach berechnet er für alle Schlüssel k' der 2. DESVerschlüsselung dk'(c1) und dk'(c2) und sucht in den DB nach
einem Eintrag mit ek(p1) = dk'(c1) und ek(p2) = dk'(c2)? Wenn
die nicht ex. geht er zum nächsten Schlüssel.
Er kann sicher sein, dass er irgendwann für ein
<dk'(c1),dk'(c2),k'> in der DB ein passendes Tripel
<dk(p1),dk(p2),k> findet, denn e(p1)=d(c1) und e(p2)=d(c2).
Die Schleife mit max. 256 Iterationen ist durchlaufbar, d.h er
wird K1= k und K2 = k' finden.
Zusammenfassung DES/3DES
●
DES Blockchiffre (Blocklänge 64, Schlüssellänge 56)
●
DES ist inzwischen gebrochen, aber nur, weil der Schlüssel mit 56 bits zu kurz war
●
3DES = 3 mal DES mit 3 verschiedenen Schlüsseln hintereinander
(Blocklänge 64, Schlüssellänge 168)
●
3DES ist bislang sicher
●
2DES nicht sicher: Meet-in-the-middle Algorithmus bei known-plaintext
Kryptologie
Bernd Borchert
Univ. Tübingen SS 2017
Vorlesung
Doppelstunde 6
AES
AES
AES ist eine Blockchiffre in drei Varianten AES128, AES196 und AES256.
Wichtigste Kennzahlen:
Blocklänge bei allen drei Varianten: 128 bit (= 16 Byte)

Schlüssellänge: 128, 196, oder 256 bit

x
Plaintext x 128 bit
Schlüssel K (128, 196, 256)
K
AES
Ciphertext c(x) 128 bit
c(x)
K
AES-1
x
Grundstruktur AES
Zuerst werden aus dem 128 bit Schlüssel 11 “Rundenschlüssel” R0 bis R10 mit jeweils 128 bit erzeugt (Beschreibung
später). Dann werden die folgenden 11 Runden mit Exor (+) und der 128-bit Bijektion B (bzw. B last) durchlaufen:
Plaintext 128 bit
+
=
Rundenschlüssel R0 Runde 0
B
+
=
Rundenschlüssel R1
Runde 1
B
+
=
...
Rundenschlüssel R2
Runde 2
...
B
+
=
RundenschlüsselR13
R9 Runde 9
Rundenschlüssel
Blast
+
=
Rundenschlüssel R10 Runde 10
Chiffretext
Entschlüsselung AES
Allein durch die Grundstruktur von AES128 und der Bijektivität von B und B last ist garantiert, dass die Verschlüsselung
bijektiv ist, mit der folgenden Entschlüsselung. Es wird genutzt: (a + b) + b = a.
Plaintext
=
+
Rundenschlüssel R0 Runde 10
B-1
=
+
Rundenschlüssel R1
Runde 9
B-1
=
+
...
Rundenschlüssel R2
Runde 8
...
B
B-1
=
+
=
+
RundenschlüsselR13
R9 Runde 1
Rundenschlüssel
Blast-1
=
+
Rundenschlüssel R10 Runde 0
Chiffretext
Bijektion B
B setzt sich zusammen aus drei hintereinander ausgeführten
Bijektionen auf 128 bit Strings:
SubBytes
ShiftRows
MixColumns
Die Umkehrfunktion B-1 von B ergibt sich durch umgekehrte
Ausführung der drei jeweiligen Einzel-Umkehrfunktion.
 Bei B
fehlt die letzte Teilfunktion MixColumns.
last

B
Bijektion SubBytes
Die 128 bits werden als 16 Bytes aufgefasst und dann wird auf jedes
Byte ein monoalphabetische Substitution (Bijektion) S durchgeführt.
Definition von S siehe nächste Seite.
=
S
S
S
S
S
S
S
S
=
S
S
S
S
S
S
S
S
Substitution S (AES S-Box)
S
Die Funktion S ist eine Bijektion von Bytes auf
Bytes, also 8-bit Wörter auf 8-bit Wörter. Die
hexadezimale Tabelle sieht so aus:
Beispiel. 00101111 = 0x2f wird durch S abgebildet
auf 0x15 = 00010101.
Wichtig ist vor allem, dass S bijektiv und nicht
affin ist ist. Das erstere kann man daran
erkennen, dass jedes Byte in der Tabelle genau
einmal vorkommt. Daraus ergibt sich direkt
auch schon die Umkehrfunktion S-1 als
Tabelle:
Wie kommt S zustande? Ist S zufällig
„gewürfelt“ worden? wenn ja, dann würde der
Verdacht aufkommen, dass die Architekten von
AES eine Hintertür eingebaut haben.
| 0 1 2 3 4 5 6 7 8 9 a b c d e f
---|--|--|--|--|--|--|--|--|--|--|--|--|--|--|--|--|
00 |63 7c 77 7b f2 6b 6f c5 30 01 67 2b fe d7 ab 76
10 |ca 82 c9 7d fa 59 47 f0 ad d4 a2 af 9c a4 72 c0
20 |b7 fd 93 26 36 3f f7 cc 34 a5 e5 f1 71 d8 31 15
30 |04 c7 23 c3 18 96 05 9a 07 12 80 e2 eb 27 b2 75
40 |09 83 2c 1a 1b 6e 5a a0 52 3b d6 b3 29 e3 2f 84
50 |53 d1 00 ed 20 fc b1 5b 6a cb be 39 4a 4c 58 cf
60 |d0 ef aa fb 43 4d 33 85 45 f9 02 7f 50 3c 9f a8
70 |51 a3 40 8f 92 9d 38 f5 bc b6 da 21 10 ff f3 d2
80 |cd 0c 13 ec 5f 97 44 17 c4 a7 7e 3d 64 5d 19 73
90 |60 81 4f dc 22 2a 90 88 46 ee b8 14 de 5e 0b db
a0 |e0 32 3a 0a 49 06 24 5c c2 d3 ac 62 91 95 e4 79
b0 |e7 c8 37 6d 8d d5 4e a9 6c 56 f4 ea 65 7a ae 08
c0 |ba 78 25 2e 1c a6 b4 c6 e8 dd 74 1f 4b bd 8b 8a
d0 |70 3e b5 66 48 03 f6 0e 61 35 57 b9 86 c1 1d 9e
e0 |e1 f8 98 11 69 d9 8e 94 9b 1e 87 e9 ce 55 28 df
f0 |8c a1 89 0d bf e6 42 68 41 99 2d 0f b0 54 bb 16
-1| 0 1 2 3 4 5 6 7 8 9 a b c d e f
S---|--|--|--|--|--|--|--|--|--|--|--|--|--|--|--|--|
00
10
20
30
40
50
60
70
80
90
a0
b0
c0
d0
e0
f0
|52
|7c
|54
|08
|72
|6c
|90
|d0
|3a
|96
|47
|fc
|1f
|60
|a0
|17
09
e3
7b
2e
f8
70
d8
2c
91
ac
f1
56
dd
51
e0
2b
6a
39
94
a1
f6
48
ab
1e
11
74
1a
3e
a8
7f
3b
04
d5
82
32
66
64
50
00
8f
41
22
71
4b
33
a9
4d
7e
30
9b
a6
28
86
fd
8c
ca
4f
e7
1d
c6
88
19
ae
ba
36
2f
c2
d9
68
ed
bc
3f
67
ad
29
d2
07
b5
2a
77
a5
ff
23
24
98
b9
d3
0f
dc
35
c5
79
c7
4a
f5
d6
38
87
3d
b2
16
da
0a
02
ea
85
89
20
31
0d
b0
26
bf
34
ee
76
d4
5e
f7
c1
97
e2
6f
9a
b1
2d
c8
e1
40
8e
4c
5b
a4
15
e4
af
f2
f9
b7
db
12
e5
eb
69
a3
43
95
a2
5c
46
58
bd
cf
37
62
c0
10
7a
bb
14
9e
44
0b
49
cc
57
05
03
ce
e8
0e
fe
59
9f
3c
63
81
c4
42
6d
5d
a7
b8
01
f0
1c
aa
78
27
93
83
55
f3
de
fa
8b
65
8d
b3
13
b4
75
18
cd
80
c9
53
21
d7
e9
c3
d1
b6
9d
45
8a
e6
df
be
5a
ec
9c
99
0c
fb
cb
4e
25
92
84
06
6b
73
6e
1b
f4
5f
ef
61
7d
Basis der Permutation: Mult. Inverses in GF(28)
Sei GF(28) der Körper der Z2-Polynome mit Grad < 8 modulo dem
irred. Polynom r = x8 + x4 + x3 + x1 + x0
●
Elemente sind die 8-bit Strings a a a a a a a a
●
a steht für das Monom xi : Wenn a = 1, dann taucht es in dem Polynomausdruck auf, sonst nicht.
7
i
6
5
4
3
2
1
0
i
Beispiel: 01101001 steht für das Polynom x6 + x5 + x3 + x0
●
Addition ist EXOR
Beispiel: (x6 + x5 + x3 + x0 ) + (x5 + x4 + x3 + x0) = x6 + x4
●
Multiplikation: dazu werden die 2 Polynome in die Monome ausmultipliziert, und danach durch
das irreduzible r (ist fest, siehe oben) geteilt:
Beispiel: (x6 + x1 ) * (x5 + x4 + x0)
Zuerst die Monome: (x6 + x1 ) * (x5 + x4 + x0)
= x11 + x10 + x6 + x6 + x5 + x1
= x11 + x10 + x5 + x1
Dann das Teilen durch r:
x11 + x10 + x5 + x1 : x8 + x4 + x3 + x1 + x0 = x3 + x2
x11 + x7 + x6 + x4 + x3
x10 + x7 + x6 + x5 + x4 + x3 + x1
x10 + x6 + x5 + x3 + x2
x7 + x4 + x2 + x1
Das heißt also: (x6 + x1 ) * (x5 + x4 + x0) = x7 + x4 + x2 + x1
Basis der Permutation: Mult. Inverses in GF(28)
2. Beispiel: (x5 + x2 + x0 ) * (x6 + x3 + x2 + x0)
Zuerst das Ausmultiplizieren in Monome:
(x5 + x2 + x0 ) * (x6 + x3 + x2 + x0)
= x11 + x8 + x7 + x5
+ x8 + x 5 + x 4 + x2
+ x6 + x 3 + x 2 + x0
= x11 + x7 + x6 + x4 + x3 + x0
Dann das Teilen durch r:
x11 + x7 + x6 + x4 + x3 + x0 : x8 + x4 + x3 + x1 + x0 = x3
x11 + x7 + x6 + x4 + x3
x0
Also: (x5 + x2 + x0 ) * (x6 + x3 + x2 + x0) = x0
x0 ist das neutrale Element 1 in GF(28), denn x0 * p = p für jedes Polynom p.
Das heißt: die zwei Faktoren sind die mult. Inversen voneinander:
●
(x5 + x2 + x0) * (x6 + x3 + x2 + x0) = 1
●
00100101 * 01001101 = 1
●
0x25 * 0x4D = 1
Basis der Permutation: Mult. Inverses in GF(28)
Sei GF(28) der Körper der Z2-Polynome mit Grad < 8 modulo dem irred. Polynom r = x8 + x4 + x3 + x1 + x0
Wenn die Polynome als 8-bit Vektoren (also Bytes) aufgefasst werden, ergibt sich also die folgende Tabelle der
multiplikativen Inversen:
Beispiel von der vorhergehenden Seite:
Das mult. Inverse von 00100101 = 0x25
ist 0x4D = 01001101
Die multiplikatives-Inverse
Funktion ist hochgradig nicht-linear
(a EXOR b)-1 != a-1 EXOR b-1
Die Nicht-Linearität kann man sich
in gewisser Weise auch so klar
machen, dass nur die Polynome
mit Grad 0 und 1 affin/linear sind,
die höhergradigen aber nicht.
Die Subsitutionsbox S ist
der einzige nicht-lineare
Teil in der AES-Berechnung
Der affine Teil von S
Nachdem das mult. Inverse x-1 von x gefunden ist, wird x-1 noch mit der durch die folgende
Matrix A gegebenen, affinen Abbildung (inkl. Offset-Vektor b) umgeformt in den endgültigen Wert S(x)
A
b
Insgesamt ist also
S(x) = Ax-1 + b
Dass Ax + b eine affine Bijektion ist, erkennt man daran, dass die folgende
affine Abbildung die Umkehrabbildung davon ist:
Für S-1 wird also zuerst
diese affine Umkehrabbildung
ausgeführt, und dann
die Inversenbildung
Beispiel affiner Teil von S
Das mult. Inverse von 0x25 = 00100101 ist 0x4D = 01001101. Das wird zum Input für die affine Abbildung:
A
1
0
1
1
0
0
1
0
b
=
0+1
0+1
1+0
1+0
1+0
0+1
1+1
0+0
=
1
1
1
1
1
1
0
0
(Achtung: von oben nach unten entspricht von rechts nach links, siehe Def.)
Die affine Abb. bildet 01001101 auf 00111111 = 0x3F ab.
Also ist S(0x25) = 0x3F (stimmt mit dem Tabelleneintrag überein)
Bijektion ShiftRows
Shift Rows – so, wie durch die Farben angedeutet
Umkehrabbildung: entsprechende Rotation, nur in die andere Richtung
Bijektion MixColumns
a0
a1
a2
a3
b0
b1
b2
b3
L (lin. Abb. in GF(28))
Lineare Bijektion L
a0
a1
a2
a3
L :
b0
b1
b2
b3
●
●
●
b0 = 2a0 + 3a1 + a2 + a3
b1 = a0 + 2a1 + 3a2 + a3
b2 = a0 + a1 + 2a2 + 3a3
b3 = 3a0 + a1 + a2 + 2a3
Operationen spaltenweise (es sind 4 Spalten)
Addition + ist bit-weises EXOR
Multiplikation 2a und 3a ist byte-weise in GF(28) mit dem
bekannten irred. Polynom r = x8 + x4 + x3 + x1 + x0
(es ist 2 = x1 und 3 = x1 + 1)
Umkehrfunktion MixColumns
a0
a1
a2
a3
b0
b1
b2
b3
L :
b0 = 2a0 + 3a1 + a2 + a3
b1 = a0 + 2a1 + 3a2 + a3
b2 = a0 + a1 + 2a2 + 3a3
b3 = 3a0 + a1 + a2 + 2a3
L-1 :
a0 = Eb0 + Bb1 + Db2 + 9b3
a1 = 9b0 + Eb1 + Bb2 + Db3
a2 = Db0 + 9b1 + Eb2 + Bb3
a3 = Bb0 + Db1 + 9b2 + Eb3
L ist bijektiv, weil L-1(L(a0,a1,a2,a3)) = a0,a1,a2,a3
AES128 Rundenschlüssel Erzeugung
128 bit Schlüssel
….
R0
R1
R2
R3
R5
R4
R10
= Orig. Key
vertical
Rotation
S-Box
(SubBytes)
+
04
+
00
00
+
=
=
Columns 1,2,3:
Ci-4 EXOR Ci-1
00
Columns 0: Ci-1 → vert. Rotation → SubBytes
01 02 04 08 10 20 40 80 1B 36
→ EXOR Yk EXOR Ci-4
00 00 00 00 00 00 00 00 00 00
Video: https://www.youtube.com/watch?v=mlzxpkdXP58
00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00
Y1 Y2
Y10
Diffusion und Konfusion
Verschleierungsziele für Chiffren
Diffusion: Der Input x soll so verschleiert werden, dass er vom Output her nicht zu
rekonstruieren ist.
Konfusion: Der Schlüssel K soll so verschleiert werden, dass er vom Output her nicht
zu rekonstruieren ist.
(Eselsbrücke: Konfusion fängt mit K wie Key an, Diffusion mit D wie Daten.)
Diffusion erreicht man bei DES und AES einfach durch das EXOR mit den Subkeys.
Konfusion ist damit das wichtige Ziel bei den Blockchiffren DES, AES etc.
Die Konfusion wird nicht von ShiftRows erzeugt, sondern von allem von
MixColumns, zusammen mit dem nicht-linearen SubColumns u
Zusammenfassung AES
AES196 und AES 256 unterscheiden sich neben einer leicht modifizierten
Subschlüsselerzeugung nur darin, dass im Hauptalgorithmus 13 bzw. 15 statt
11 Runden durchlaufen werden.
Angreifbarkeit. AES konnte bislang praktisch nicht angegriffen werden
(auch nicht AES128) – alle dokumentierten Angriffe sind weit weg von
einer Aushebelung. Sie reduzieren beispielsweise die Laufzeit von O(2 128)
auf O(2125) – das ist nicht relevant.
Kryptologie
Bernd Borchert
Univ. Tübingen SS 2017
Vorlesung
Teil 7
phi(n)
Zn *
Zn ist die Menge der Zahlen 0,1,...,n-1. Die Operationen +, - und * auf Zn
sind eindeutig definiert und einfach zu berechnen.
Zn* := {x > 0 in Zn | ggT(x,n) = 1}
Beispiele:
Zp*= {1,...,p-1} für p Primzahl.
Z15*= {1,2,4,7,8,11,13,14}
Behauptung:
Zn* = {x in Zn | x hat ein multiplikatives Inverses in Zn}
Beweis:
Wenn ggT(x,n) = 1, dann findet Extended-Euklid das multiplikative Inverse y.
Wenn ggT(x,n) > 1 ist, dann ist jedes Vielfache a*x ein Vielfaches von ggT(x,n),
und zwar auch mod n, und damit ungleich 1.
q.e.d.
Euler phi(n)
Zn* ist abgeschlossen unter *. Das mult. Inverse von a*b ist b-1*a-1.
Zn* ist ein Gruppe, und zwar die sogenannte Einheitengruppe des Ringes Z n
Die Anzahl der Elemente von Zn* heißt phi(n).
phi(p) = p-1 für Primzahl p. Denn ggT(x,p) = 1 für alle 1 < x < p.
phi(p*q) = (p-1)(q-1) für Primzahlen p,q.
Beweis. Die p+q−1 Zahlen
1, p, 2p, 3p, ... (q −1)p, q, 2q, 3q, ...(p-1)q
sind die einzigen Zahlen, die nicht teilerfremd zu p*q sind,
also phi(n) = p*q − (p+q-1) = (p − 1)(q − 1).
Euler phi(n)
Allgemein gilt für teilerfemde r,s: phi(r*s) = phi(r)*phi(s)
Beweis. x < r*s ist nach CRT eindeutig beschrieben durch x = ar + bs mit a <s und b<r.
Genau dann hat x einen gemeinsamen Teiler mit r*s wenn a einen gemeinsamen
Teiler mit s hat, oder wenn b einen gemeinsamen Teiler mit r hat, oder beides.
Also hat x in phi(s)*phi(r) Fällen keinen gemeinsamen Teiler mit r*s.
phi(p2) = p(p-1)
Allgemein:
phi(pk) = pk-1(p-1).
Beweis. Ein x < pk hat genau dann einen gemeinsamen Teiler mit pk wenn x durch p
teilbar ist. Also hat ein Anteil von p-1 von p Zahlen in Z pk* keinen gemeinsamen Teiler mit pk.
Zusammen mit phi(r*s) = phi(r)*phi(r) für teilerfemde r,s kann man also phi(n) aus
der Faktorisierung von n bestimmen.
Satz von Euler, Satz von Fermat
Zn* := {x > 0 in Zn | ggT(x,n) = 1} = {x > 0 in Zn | ex. Inverses mod n}
Satz (Euler): Für alle a in Zn* gilt aphi(n) = 1
Beweis (ohne Gruppentheorie/Satz von Lagrange)
Sei Zn* = {n1,...,nphi(n)}. Die Zahlen a*n1 , … , a*nphi(n) müssen alle verschieden sein,
denn wenn a*ni = a*nj , dann ist auch a-1 * a * ni = a-1 * a *nj , also ni = nj .
Weil a in Zn* ist und Zn* unter * abgeschlossen ist, sind die Zahlen a*n1 , … , a*nphi(n)
also eine Permutation von n1 , … , nphi(n)
Also ist a*n1 * … * a*nphi(n) = n1 * … * nphi(n).
Also ist aphi(n) * n1 * … * nphi(n)= n1 * … * nphi(n) .
Sei c das Inverse von n1 * … * nphi(n) . Dann ist
aphi(n) = aphi(n) * n1 * … * nphi(n) * c = n1 * … * nphi(n) * c = 1.
q.e.d.
Korollar (Fermat): Für alle 0 < a < p gilt ap-1 = 1 mod p.
Kryptologie
Bernd Borchert
Univ. Tübingen SS 2017
Vorlesung
Teil 8
Primitivwurzeln
Primitivwurzeln in Zn*
Satz von Fermat: ax mod n zykelt modulo phi(n):
a, a2, a3, ... , aphi(n) = 1, a, a2, a3, ...
Ist dieser Zyklus maximal lang, also mit Länge phi(n), oder kürzer?
Oder äquivalent: werden in dem Zyklus alle p-1 Elemente von Zn* erreicht,
bevor es mit (1,) a, a2, ... wieder von vorn los geht?
Def. für a in Zn* : <a> = {a, a2, a3, ... , aphi(n) = 1}
Die 1 könnte aber schon eher erreicht werden als im Schritt phi(n)
a, a2, a3, ..., 1, a, a2, a3, ..., 1, a, a2, a3, ..., 1
Vor der ersten 1 gibt es keine Periode: Sei a,... y,x ... z,x ... ,1 die erste Periode, mit x als Wiederholung.
D.h. ya = za =x. Also yaa-1 = zaa-1. Also y=z. Widerspruch zur Annahme, dass x die erste Periode ist.
Wenn x=a (also x in der ersten Position), dann setze y=1, es folgt z=1, und damit ist die 1 nicht die erste 1.
|<a>| ist ein Teiler | Zn*|. Das ergibt sich aus dem Satz von Euler, denn
die erste Periode a, a2, a3, ..., 1 ist eine Unterperiode von a, a2, a3, ... , aphi(n) = 1 und muss
also genau m mal wiederholt werden, für ein m, sonst treffen sich die 1'en nicht. Also |<a>| * m = | Zn*|
Ein Element a aus Zn* mit <a> = Zn* heißt Primitivwurzel (manchmal auch Generator).
Gibt es immer Primitivwurzeln? wenn ja, kann man sie effektiv finden?
Satz von Gauß über die Existenz von Primitivwurzeln
Gauß (1799)
Zn* enthält Primitivwurzeln
↔ n = 1,2,4, pk oder 2pk für Primzahl p>2.
↔ Zn* enthält phi(phi(n)) Primitivwurzeln.
Korollar. Zp* Primzahl p>2 enthält phi(p-1) Primitivwurzeln.
Beweis: Schwierige Gruppentheorie. Wird weggelassen.
Beispiel: Z11* enthält phi(10) = phi(2*5) = 1*4 = 4 Primitivwurzeln
0
10, 1 10
1
1
9, 4, 3, 5, 1
9
2
8,9,6,4,10,3,2,5,7,1
8
3
7,5,2,3,10,4,6,9,8,1
4
7
6,3,7,9,10,5,8,4,2,1 6
5
2,4,8,5,10,9,7,3,6,1
3, 9, 5, 4, 1
4, 5, 9, 3, 1
5, 3, 4, 9, 1
Überprüfung und Finden von Primitivwurzeln
Def. Eine maximaler Teiler t von n ist ein Teiler von y, für den es keinen Teiler m von y gibt mit
t|m und t<m<y. Für Primfaktorzerlegung z = p1k1... piki sind also die i Teiler t1 = p1k1-1... piki , ... ti =
p1k1... piki-1 die maximalen Teiler von y.
Jeder echte Teiler von n ist Teiler eines maximalen Teilers von von n.
Beispiele.
●
die maximalen Teiler von 10 sind 2 und 5
●
die maximalen Teiler von 50 = 2*52 sind 10 und 25.
●
die maximalen Teiler von 300 = 22*31*52 sind
●
21*31*52 = 150
●
22*30*52 = 100
●
22*31*51 = 60
Satz. g ist Primitivwurzel von Zn* gdw. für alle maximalen Teiler t von phi(n) gilt: xt != 1
Beweis. Wenn g Primitivwurzel ist, dann ist für t < phi(n) die Periode g, g2,..., gi bei i=t noch nicht
zu Ende. Wenn g nicht Primitivwurzel ist, dann ist d = |<g>| ist ein echter Teiler von | Zn*| und
damit ein Teiler eines maximalen Teilers t. Weil g, g2,..., gd = 1, ist auch
g, g2,..., gd = 1, g,g2,..., g2d = 1, g,g2,..., gt = 1
qed.
Finden von Primitivwurzeln
Probabilistischer Algorithmus zum Finden von Primitivwurzeln in Zn* (Faktorisierung von
phi(n) muss bekannt sein):
Rate ein x in Zn* .
Prüfe für alle maximalen Teiler t von phi(n)
ob xt != 1 mod p ist;
Falls ja RETURN x ist Primitivwurzel;
Ansonsten wiederhole die Rate-Schleife.
Die Korrektheit des Tests im prob. Algorithmus: Wenn für einen echten Teiler t von phi(n) gilt x t = 1 mod
p, dann hat die von x erzeugte Menge nur t < phi(n) Elemente, denn der Zyklus geht schon hier beim t-ten
erzeugten Element in eine Schleife (denn 1x = x). Umgekehrt muss die Anzahl z der von x erzeugten
Elemente die Zahl phi(n) teilen (Satz von Euler). Wenn aber z die maximalen Teiler von phi(n) nicht teilt,
und andererseits z die Zahl phi(n) teilen muss, muss also z = phi(n) sein.
Dass es tatsächlich probabilistischer Algorithmus ist, in dem Sinne, dass man ihn nur wenige Male
(Größenordnung 20 bis 200) ausführen muss, um erfolgreich zu sein und damit zu terminieren, liegt
daran, dass es so viele – nämlich phi(phi(n)) - Primitivwurzeln gibt, siehe 3. Äquivalenz bei Gauss.
phi(p-1) ist fast nie kleiner als 1/5 p-1, und auch bei den wenigen Ausnahmen davon (die man ja nach der
Berechnung von phi(p-1) erkennt) ist es ein echter Anteil von 18, 15, 12, ... Prozent - nie eine
“Nullmenge”. Der prob. Algorithmus läuft also in so einem Ausnahmefall im Durchschnitt etwas länger.
Kryptologie
Bernd Borchert
Univ. Tübingen SS 2017
Vorlesung
Teil 9
PKI: RSA, ElGamal
PKI
Public Key Szenario
m
cKpub(m)
Alice
Bob
Kpriv
Kpub
RSA Kryptoverfahren
- 1977
- beruht auf Schwierigkeit von Faktorisierung, speziell die
von Primzahlprodukten:
Gegeben Primzahlprodukt p*q, was sind p und q?
RSA Schlüsselpaar-Erzeugung
Wähle zufällig zwei Primzahlen p und q, die ungefähr lang
sind. Sei N = pq. Berechne phi(N) = (p-1)(q-1)
Wähle eine zu phi(N) teilerfremde Zahl e < phi(N).
Berechne d, für das gilt: ed = 1 mod phi(N) (via erweiterter
Euklid)
(e,N) ist öffentlicher Schlüssel, (d,N) der private.
RSA
RSA
Public Key
(e,N)
Private Key
(d,N)
RSA Verschlüsselung
Ein m aus {2,...,N-2} wird mit dem öffentlichen Schlüssel
verschlüsselt zu
c = me mod N
RSA
RSA
Public Key
(e,N)
Private Key
(d,N)
RSA Entschlüsselung
Ein Ciphertext c aus {1,...,N-1} wird mit dem privaten
Schlüssel entschlüsselt zu
cd mod N
Verifikation: cd = (me)d = med = m1+ k*phi(N) = m1 = m mod N
Euler
RSA
RSA
Public Key
(e,N)
Private Key
(d,N)
Elgamal Kryptoverfahren
- 1985
- Erweiterung von Diffie-Hellman Schlüsselaustausch
- beruht auf Schwierigkeit von Diskreter Logarithmus (DL):
Gegeben Primzahl p, and a und m aus {0,...,p-1}.
Für welches x aus {0,...,p-1} gilt ax = m mod p ?
- Sicherheit äquivalent zum DL Problem
Elgamal Schlüsselpaar-Erzeugung
Bestimme Primzahl p und Primitivwurzel g von Zp*. Wähle
zufälliges a aus {0,...,p-2}.
p, g, und a sind fest. Nur a bleibt geheim.
Berechne A := ga mod p. Der öffentliche Schlüssel ist
(p,g,A), der private ist a.
Elgamal
Elgamal
Public Key
(p,g,A)
Private Key
a
Elgamal Verschlüsselung
Ein m aus {1,..,p-1} wird mit dem öffentlichen Schlüssel zu
einem Ciphertext (B,c) verschlüsselt:
Wähle zufälliges b aus {1,...,p-1}.
Sei B := gb mod p und c:= Abm mod p
Der Ciphertext ist das Paar (B,c).
Elgamal
Elgamal
Public Key
(p,g,A)
Private Key
a
Elgamal Entschlüsselung
Ein Ciphertext (B,c) wird mit dem privaten Schlüssel
entschlüsselt zu
Bp-1-a c = m mod p
Verifikation: Bp-1-ac = gb(p-1-a)Abm = gb(p-1-a)gab m =
gb(p-1)g-abgab m = g(p-1)bm = m mod p
Euler/Fermat
Elgamal
Elgamal
Public Key
(p,g,A)
Private Key
a
Kryptologie
Bernd Borchert
Univ. Tübingen SS 2017
Vorlesung
Teil 10
Signaturen, Diffie-Hellman
Signatur
Signatur s(m) einer Nachricht m
m, s(m)
Alice
Bob
Kpriv
Kpub
Kpub
Signatur
Signatur (Thema “Integrity”)
Gegeben eine Nachricht/Information m.
Eine Signatur s(m) von m hat folgenden Sinn:
1. Schutz gegen Manipulation von m durch Dritte
2. Nachweis, dass m durch denjenigen (und nicht jemand anders)
gesendet/produziert/bestätigt wurde, der den geheimen
Schlüssel besitzt
3. Nichtabstreitbarkeit: Nachweisbarkeit gegenüber dem Besitzer
des geheimen Schlüssels, dass m vom ihm signiert wurde.
Die 3. Eigenschaft entspricht am meisten dem Zweck einer üblichen
Unterschrift unter einen Vertrag. Die 3. Eigenschaft kann nur mit
asymmetrischen Signaturen (PKI) erreicht werden.
RSA Signatur
RSA Signaturerzeugung (mit dem privaten Schlüssel)
Ein m aus {2,...,N-2} wird mit dem privaten Schlüssel signiert als
s = md mod N
s ist die Signatur von m
signieren = verschlüsseln mit dem privaten Schlüssel
RSA
RSA
Public Key
(e,N)
Private Key
(d,N)
RSA Signatur
RSA Signaturprüfung (mit dem öffentlichen Schlüssel)
Die RSA-Signatur s einer Nachricht m wird geprüft durch
s =? me mod N
Signatur prüfen = entschlüsseln mit dem öffentlichen Schlüssel
RSA
RSA
Public Key
(e,N)
Private Key
(d,N)
Elgamal Signatur
Elgamal Signaturerzeugung (mit dem privaten Schlüssel)
Eine Nachricht m aus {1,..,p-1} soll signiert werden.
Finde durch Raten zufälliges k, so dass ggT(k,p-1) = 1, und berechne k -1 mod p-1.
Bestimme
●
r = gk mod p
●
s = (m – ar)k-1 mod p-1
Die Signatur von m ist das Paar (r,s)
Elgamal
Elgamal
Public Key
(p,g,A)
Private Key
a
Elgamal Signatur
Elgamal Signaturprüfung (mit dem öffentlichen Schlüssel)
(r,s) sei die Signatur einer Nachricht m.
Prüfe, ob gm =Arrs mod p
Wenn die Signatur vom privaten Schlüssel erzeugt wurde, dann gilt
●
s = (m – ar)k-1 mod p-1
●
<=> m = ar + ks mod p-1
●
gm = gar + ks = (ga)r (gk)s = Arrs mod p
Euler/Fermat
Auch bei Elgamal: Signieren ist ähnlich dem Verschlüsseln, jedoch mit dem privaten Schlüssel, und das
Prüfen der Signatur ist ähnlich dem Entschlüsseln, jedoch mit dem öffentlichen Schlüssel.
Elgamal
Elgamal
Public Key
(p,g,A)
Private Key
a
Symmetrische Signatur
Signaturerzeugung (mit dem Schlüssel)
Eine Nachricht m soll signiert werden:
s = eK(m) (CBC Modus)
Prüfung durch Empfänger: Gegeben m und s(m), bestimme ebenfalls s' = e K(m) (CBC
Mode) und prüfe ob s' = s.
Vorteil symmetrische Signatur: nur ein Teil von s reicht als Signatur, z.B. der letzte 16-Byte
Block, oder auch nur ein paar Bytes des letzten Blocks, oder eine deterministische
Umformung eines Teils von s(m): z.B. eine 6-stellige Nummer (TAN).
Nachteile: 1. Zertifikate etc. sind nicht möglich. 2. Nichtabstreitbarkeit ist nicht erreicht
Bijektivität der Verschlüsselung nicht notwendig --> Hash Funktion/MAC reicht (später)
AES
AES
Schlüssel
K
Schlüssel
K
Authentisierung: Challenge/Response
Challenge-Response („Zero Knowledge“) für symmetrischen Verfahren:
User kündigt dem Server die Authentisierung an und schickt ID. Daraufhin wird vom
Server ein Zufallsstring C (challenge) erzeugt und zum User geschickt. Der User
verschlüsselt mit seinem geheimen Schlüssel K die challenge C und schickt den
response R = eK(z) zurück. Der Server prüft die response R, indem er ebenfalls e K(C)
berechnet und das mit R vergleicht.
Auch hier gilt wie bei der symmetrische Signatur: Teil bzw. Abbild eines Teils des response
– sagen wir ein 6-stelliges OTP (one-time-password) - reicht.
Und es reicht hier ebenfalls eine (nicht-bijektive) Hash-Funktion (später).
Das asysmmetrische challenge/response Verfahren verläuft genau so, außer dass der Server
das Ergebnis prüft, indem er R mit dem öffentlichen Schlüssel entschlüsselt und das mit
C vergleicht.
Asymmetrisch geht challenge/response auch umgekehrt: der Zufallsstring wird vom Server
verschlüsselt: nur der User kann ihn mit seinem privaten Schlüsseln entschlüsseln.
Server
User
Schlüssel
K
geheimer Schlüssel
K
Privacy/Integrity/Authenticity
Symmetrisch
Asymmetrisch
DES
AES
RSA
Elgamal
Privacy
(Verschlüsseln/
Entschlüsseln)
ja
ja
ja
ja
Integrity
(Signatur)
ja
ja
ja
ja
- Teil der Signatur reicht
- Hash-Funktion reicht
Authentisieren
(Challenge/
Response)
ja
ja
- Teil der Signatur reicht
- Hash-Funktion reicht
nicht abstreitbar
Zertifikate möglich
ja
ja
nicht abstreitbar
Diffie-Hellman: Erinnerung Primitivwurzel
p=11, Primitivwurzel r = 7
0
1
10
2
9
3
8
4
7
6
5
Der neue Zyklus mit p-1 Elementen irrt scheinbar zufällig in dem Kreis 1,...,p-1 hin und her.
Für große Primzahlen p, z.B. p = 2*3132 + 1, ist das ein „9. Weltwunder“, dass dieser Zyklus
diese gigantische garantierte Länge hat und jedes Element erreicht.
Bewiesen von Gauss 1799 – ahead of time!
Diffie-Hellman Schlüsselvereinbarung
a, s = (gb)a
A
p, g, ga, gb
B
b, s = (ga)b
1. Einer der beiden legt eine Primzahl p und eine Primitivwurzel g fest und schickt p
und g dem anderen. Das darf jeder sehen.
2. A erzeugt sich zufällig eine Zahl a<p und B eine Zahl b<p. Diese beiden Zahlen
bleiben geheim. D.h., A wird b niemals kennen, und B a nicht.
3. A berechnet ga mod p und schickt ga mod p über den öffentlichen Kanal an B, und
B schickt gb mod p an A. Reihenfolge spielt keine Rolle
4. A berechnet s= (gb)a mod p, und B berechnet s' = (ga)b mod p. s und s' sind wegen
s = (gb)a = g(ba) = g(ab) = (ga)b = s'
identisch und s=s' ist damit das gemeinsame Geheimnis, das A und B jetzt haben,
aber niemand anders kennt.
5. Mit s als als symmetrischem Schlüssel, z.B. als AES256 Schlüssel, kann jetzt A
verschlüsselte Nachrichten über den öffentlichen Kanal an B schicken, die B dann
entschlüsseln kann, aber niemand anders, und umgekehrt.
Schwächen Diffie-Hellman
a, s = (gb)a
p, g, ga, gb
A
B
b, s = (ga)b
1. Wenn ein schneller Algorithmus für Diskreter Logarithmus gefunden wird, ist DH
gebrochen. Genau genommen reicht sogar ein schneller Algorithmus für das folgende
Berechnungsproblem: Gegeben p, g, ga mod p, gb mod p, was ist gab mod p?
2. Der Zufallsgeneratoren bei der Generierung von a und b müssen unvorhersehbar sein.
3. Größtes Problem von Diffie-Hellman ist der Man-in-the-Middle Angriff:
a, s = (gz)a
A
p, g, ga, gz
M
p, g, gz, gb
B
b, t = (gz)b
z, s = (ga)z , t = (gb)z
Der Angreifer M setzt sich beim Schlüsselaustausch zwischen A und B, generiert eine Zufallszahl
z<p und spielt dann A gegenüber B, und B gegenüber A. So tauscht M mit A einen Schlüssel s aus
und mit B einen Schlüssel t. A und B bemerken die Anwesenheit von M nicht. Wenn dann A eine
mit s verschlüsselte Nachricht an B schickt, entschlüsselt M die Nachricht mit s, verschlüsselt sie
mit t, um sie dann an B weiterzuschicken, und umgekehrt. M kann also nicht nur alle Nachrichten
abhören, sondern auch abändern.
Einziger Trost, was diesen Angriff angeht: M muss dauerhaft den Kanal besetzen, um abzuhören
bzw. zu manipulieren, denn A und B merken, dass etwas nicht stimmt, wenn M nicht mehr
dazwischen ist bzw. sie sich auf einem anderen Kanal verschlüsselte Nachrichten zuschicken.
Kryptologie
Bernd Borchert
Univ. Tübingen SS 2017
Vorlesung
Teil 11
Primzahltests: Fermat, Miller-Rabin
Primzahltests
Problem: Gegeben n. Ist n Primzahl?
Naive Methoden:
Ausprobieren: gehe der Reihe nach alle Zahlen t= 2, 3, 4, 5, … Wurzel(n) durch und teste
per Division, ob n durch t ohne Rest teilbar ist.
Verbesserung (Sieb des Eratosthenes). Gehe der Reihe nach alle Zahlen t= 2, 3, 5, 7, 11, ...
Wurzel(n) durch, aber lasse die Vielfachen von schon durchgegangen t aus.
Eratosthenes aus Cyrene, Lybien, ca. 200 v.Chr.
Die naiven Tests scheitern schon bei relativ kleinen Zahlen, z.B. 100-stellige Dezimalzahlen
(Wurzel ist halb so lang, also 50-stellig), auch bei parallelen Supercomputern.
Fermat Primzahl-Test
Problem: Gegeben n. Ist n Primzahl?
Euler: Für alle a in Zn* gilt aphi(n) = 1
Korollar (Fermat): Für alle 0 < a < p gilt a p-1 = 1 mod p.
Basierend darauf
Fermat Primzahl-Test
Für gegebenes n wähle a < n
wenn ggT(a,n) > 1 mod n, gibt aus: n ist keine Primzahl;
wenn an-1 > 1 mod n gebe aus: n ist keine Primzahl;
Ansonsten gebe aus: n ist Primzahl;
Problem ist: der Algorithmus ist nicht korrekt, er erklärt Nicht-Primzahlen zu Primzahlen:
1. Es gibt die sogenannten “Fermat-Pseudoprimzahlen n” bzgl. einer Basis a, d.h.
teilerfemde n,a mit an-1 = 1 mod n. Beispiel: 1790 = 1 mod 91. (91 = 7 x 13)
2. Schlimmer: es gibt die sog. Carmichael Zahlen n, die keine Primzahlen sind,
für die aber für alle teilerfremden a < n gilt: an-1 = 1 mod n. Kleinstes Beispiel: 341 = 3·11·17.
3. Noch schlimmer: es gibt unendlich viele Carmichael Zahlen und sie sind nach aktuellem
Stand nicht durch einen effizienten Algorithmus als solche erkennbar.
Primzahl-Tests
Bitte beachten, dass beim Fermat-Test n-1 gerade ist und somit
im Fall an-1 = 1 mod n gelten muss:
a(n-1)/2 = 1 mod n
oder a(n-1)/2 = -1 mod n
und zwar wegen der 3. binomischen Formel:
an-1 = 1 mod n
=> an-1 - 1 = 0 mod n
=> (a(n-1)/2 )2 - 12 = 0 mod n
=> (a(n-1)/2 - 1) (a(n-1)/2 + 1) = 0 mod n
=> a(n-1)/2 = 1 mod n oder a(n-1)/2 = -1 mod n
(n-1)/2
Bem. Der sog. Solovay-Strassen Primzahl-Test schaut sich an, ob einer der beiden Fälle für a
vorliegt, und
vergleicht das Ergebnis auf Gleichheit mit dem sogenannten Jacobi-Wert von n und a.
Schon der Solovay-Strassen schafft es, das Carmichael-Zahlen Problem mit einer begrenzten
einseitigen Fehlerwahrscheinlich zu lösen. Weil der Test aber gegenüber dem folgenden Miller-Rabin-Test
nur Nachteile hat (einseitige Fehlerwahrscheinlichkeit 50% statt 25% wie bei Miller-Rabin) und weil der
Jacobi-Wert und dessen Berechnung eingeführt werden müssten, wird Solovay-Strassen hier nur erwähnt.
Miller-Rabin Primzahl-Test
Die folgende Verbesserung des Fermat Primzahl-Tests guckt sich den Exponenten n-1 genauer an.
Miller-Rabin Primzahl-Test (1976)
Für ein gegebenes n sei n – 1 = m*2d mit m ungerade.
Wähle a < n zufällig.
Wenn ggT(a,n) > 1, dann ist n keine Primzahl.
Wenn folgendes Kriterium K erfüllt ist
am = 1 mod n oder am = -1 mod n,
m*2
m*2
oder a = -1 mod n, oder …, oder a
dann gebe aus: n ist Primzahl
Ansonsten gebe aus: n ist keine Primzahl;
d-1
In dieser Folge muss vor einer 1
immer eine -1 kommen, egal ob
Primzahl oder nicht, siehe Seite
vorher.
= -1 mod n,
25% Fehlerwahrscheinlichkeit
0% Fehlerwahrscheinlichkeit
Rabin (1976): Für eine Nicht-Primzahl n ist das Kriterium K nur für max. ¼ aller a < n erfüllt.
(ohne Beweis – ist schwierig)
Das ergibt den folgenden probabilistischen Algorithmus:
Wiederhole den Miller-Rabin Primzahl-Test k mal. Wenn er bis dahin nicht geantwortet
hat “n ist keine Primzahl”, dann ist n mit Wahrscheinlichkeit 1- ¼k eine Primzahl
Das reicht für praktische Belange: Wenn einem eine Fehlerwahrscheinlichkeit von
sagen wir nicht mehr als 1 aus 2200 genügt, lässt man den Algorithmus 100 mal laufen, bevor
man die Zahl n als Primzahl ansieht.
AKS Primzahl-Test
Im Jahr 2002 gab es eine mathematische Sensation durch 3 Inder (M. Agrawal, N.
Kayal, N. Saxena):
PRIMES in P.
d.h., für das Primzahlproblem gibt es eine deterministischen (d.h. nicht-randomisierten)
Algorithmus mit polynomieller Laufzeit (Inputlänge ist die Länge der Binärzahl).
Anfangs war das Laufzeit-Polynom x7,5, und wurde dann auf x6 verbessert.
Grundidee ist folgender Satz (wie beim Fermat-Test der Satz von Fermat):
Sei ggT(a,n) = 1. Dann ist n Primzahl gdw. (X + a)n = Xn + a mod n (als Polynom)
In der Praxis ist der AKS Primzahltest irrelevant, denn Miller-Rabin ist unschlagbar.
Primzahldichte
Sei für x aus N pi(x) die Anzahl der Primzahlen < x. ln(x) ist der natürliche Logarithmus zur Basis
2,71 ...
(Gauss/Legendre/Hadamard/... etc.):
Asymtotisch gilt pi(x) = x/ln(x). Abweichung nicht mehr als 5%.
Beispiel: pi(2512) ~ 2512/350.
Unter allen Zahlen mit höchstens 512 Binärstellen ist also ca. jede 350-te eine Primzahl. Wenn
man nur die Zahlen mit genau 512 Stellen nimmt, sollte die Verteilung da auch fast so hoch sein.
Unter 175 ungeraden 512-stelligen Binärzahlen ist also ca. 1 Primzahl.
Der Teil-Algorithmus bei der Schlüsselerzeugung von RSA1024 zum Finden von 512-stelligen
Primzahlen p ist also zweifach randomisiert:
Rate solange ungerade 512-stellige Zahlen n, bis der Miller-Rabin-Test mit
Fehlerwahrscheinlichkeit von sagen wir 2-200 mit dem Ergebnis “n ist Primzahl” hält.
Wegen der hohen Primzahldichte kann man davon ausgehen, dass man nach nicht viel mehr als
ln(n) (im Beispiel 350) Versuchen eine Primzahl gefunden hat.
Praktisch (Erfahrung, aber kein Beweis!) sind die Primzahl so gut verteilt, dass man n nur einmal
raten muss und dann n, n+2, n+4, ... auf Primality testet.
Kryptologie
Bernd Borchert
Univ. Tübingen SS 2017
Vorlesung
Teil 12
Elliptische Kurven
Elliptische Kurven im Reellen
Punktmengen in R2
Elliptische Kurve
y2 = x3 + ax + b
Kreis
y2 = b - x 2
Ellipse
y2 = b - ax2
Elliptische Kurven im Reellen
Punkt-Addition P+Q
Punkt-Addition P+Q
P+Q
P
P+Q
Q
P
Q
Wenn P und Q verschienen sind, gibt es in fast allen Fällen auf der Gerade durch P und Q einen 3. Punkt
(spezielle Eigenschaft der elliptischen Kurven): dessen Spiegelpunkt an der x-Achse ist das Resultat P + Q.
Elliptische Kurven im Reellen
Punkt-Verdopplung 2P
spezielle Punkt-Addition P+Q
2P
P+Q
P
Q
P
Wenn P = Q, dann liegt in fast allen Fällen auf der
Tangente durch P ein 2. Punkt. Dessen Spiegelpunkt an
der x-Achse ist das Resutat P + P = 2P. Diese Definition
kann man herleiten, indem man Q an P infinitesimal
annähert: P+Q konvergiert gegen den “Grenzwert” 2P.
Der Spezialfall, dass P auf der horizontalen
Tangente des “lokalen Maximums” Q liegt.
Das ist ebenfalls als “Grenzwert” herleitbar.
Neutrales Element N
Hier sind die verbleibenden Fälle, dass kein 3. Punkt auf der Geraden liegt (links), nämlich dann, wenn
die x-Werte von P und Q gleich sind, bzw. dass auf der Tangente kein 2. Punkt liegt (rechts). In diesen
Fällen definiert man das Ergebnis als “unendlichen” Punkt N, der formal ein Element der elliptischen
Kurve wird (N wird das neutrale Element bei der Addition sein).
P+Q=N
2P = N
P
P
Q
Skalarmultiplikation
Skalarmultiplikation kP
kP für k>0 und einen Punkt P der EC ist definiert durch
1P = P
2P = P + P
3P = P + P + P
4P = P + P + P + P
...
kP = (k-1)P + P
...
2P
6P
Man kann also k-1 mal eine Punktaddition durchführen,
um den Punkt kP zu berechnen.
Für k = 2100 wäre das z.B. aber nicht machbar.
Man kommt für k = 2100 mit nur 100
Punktverdopplungen aus, indem man 100
mal den Punkt P verdoppelt.
Die Zeichnung zeigt die Konstruktion von 6P, nicht durch
5 Punktadditionen, sondern durch 1 Punktaddition
und zwei Punktverdopplungen
P → 2P
→2P + P = 3P
→2 . 3P = 6P
3P
P
Diskrete Elliptische Kurven
Gegeben sei ein endl. Primkörper Fp.
Eine elliptische Kurve C ist die Menge von Paaren (x,y) aus Fp x Fp für die die Gleichung
y2 = x3 + ax + b
gilt, wobei a, b aus Fp vorgegeben sind mit 4a3 + 27b3 != 0 (Diskriminanten-Bedingung)
Zur Menge kommt ein “neutrales Element” N dazu.
Beispiel p=5, a=1, b=1. (Diskriminanten-Bed. erfüllt: 4a 3 + 27b2 = 31 = 1 != 0 mod 5).
Welche Paare (x,y) aus F5 x F5 erfüllen die Gleichung y2 = x3 + x + 1?
y/x
0
1
2
3
4
Hilfs-Tabellen
y y
x x
1
2
3
0
x
x
x
0
0
0
0
2
x
1
1
1
1
3
x
2
3
2
4
3
2
3
4
4
4
4
1
4
x
x
x
C = {N, (0,1), (0,4), (2,1), (2,4), (3,1), (3,4), (4,2), (4,3)}
ECC – Addition und Verdopplung
Auf C wird eine Addition P + Q definiert:
Wenn P = N oder Q = N ist, dann ist P + N = N + Q = N.
Gegeben seien zwei verschiedene Punkte P = (x1,y1) und G = (x2,y2) der Kurve C.
Wenn x1 = x2, dann P + Q := N. Ansonsten:
s :=
y2 - y1
x2 - x1
x3 := s2 - x2 - x1
y3 := s(x2 - x3) - y2
Resultat: P + Q = (x1,y1) + (x2,y2)= (x3,y3)
Wenn P = Q, dann wird die Punktverdopplung P + P = 2P = 2(x1,y1) definiert:
3x12 + a
s :=
2y1
(a ist Kurvenparameter)
x3 := s2 - 2x1
y3 := s(x1 - x3) - y1
Resultat P + P = 2P = 2(x1,y1) := (x3,y3)
(nur die Gleichung für s ist anders als oben)
ECC – Beispiel Addition
C = {N, (0,1), (0,4), (2,1), (2,4), (3,1), (3,4), (4,2), (4,3)}
y\x
0
1
2
3
x
x
4
0
1
x
2
x
3
x
4
x
x
x
Beispiel (2,1) + (3,4)
s = (4 – 1)(3 – 2)-1 = 3.1-1 = 3 mod 5
x3 = 9 – 3 – 2 = 4 mod 5
y3 = 3(3-4) – 4 = -7 = 3 mod 5
Also (2,1) + (3,4) = (4,3)
x-1 mod 5
x x-1
0
-
1
1
2
3
3
2
4
4
Double-and-Add
Mit den zwei Operation P+Q und 2P kann man für jedes ganzzahlige k und jeden Punkt P
den Punkt kP berechnen, und zwar schnell, in dem man den Square-and-Multiply
Algorithmus eins-zu-eins in einen Double-and-Add Algorithmus übersetzt: Square entspricht
Verdopplung 2P, und Multiply entspricht Addition P+Q:
Sei b die Binärdarstellung von k. Fange mit X := P an, gehe von links nach rechts
durch die Binärdarstellung von k durch: wenn eine 0 kommt, verdopple X := 2X, wenn
eine 1 kommt, verdopple und addiere: X = 2X + P.
Beispiel k = 18 = 10010.
X := P;
X := 2X;
X := 2X;
X := 2X + P;
X := 2X;
Es gilt am Schluss: X = 18P.
Generatoren
Eine Punkt G einer diskreten elliptischen Kurve C heißt Generator von C, wenn durch Skalarmultiplikation mit G
jeder Punkt der Kurve erreicht werden kann, also wenn
{kG | k > 0} = C.
Weil die Anzahl |C| der Elemente von C endlich ist, muss es also eine
Periode G, 2G, 3G, ...., N, G, 2G, ... der Länge |C| sein.
Dass das letzte Elemente der Periode das neutrale Element N ist, liegt daran, dass (wie bei Z n* ) die von G
erzeugte Menge eine zyklische Untergruppe von (C,+) ist: wenn X + G = G, dann muss X das neutrale Element sein.
Wegen der Untergruppen Eigenschaft hat man ebenso wie bei Zn* das folgende “Lagrange” Kriterium dafür, ob
ein Punkt P ein Generator der Kurve C ist:
P ist Generator von C gdw. für alle maximalen Teiler t von |C| ist tP ungleich N.
Für dieses Kriterium muss man |C| kennen und faktorisieren können.
Das erstere leistet ein effektiver Algortihmus von Schoof (1985), der in Linearzeit läuft (Speicherbedarf kubisch):
Gegegen sei das p und die Gleichung für C. Dann lässt sich |C| effektiv berechnen.
Wenn |C| eine Primzahl ist, ist nach dem Kriterium oben jeder Punkt von C außer N ein Generator. Bei Z p* war
das nicht möglich, denn phi(p) ist durch 2 teilbar, aber bei elliptischen Kurven geht es, siehe z.B. die Bitcoin Kurve.
Was Generatoren angeht, liegt also bei elliptischen Kurven praktisch die gleiche Situation vor wie bei Z p* , nur
mit dem Unterschied, dass die Zyklus-Operation mit + notiert wird, nicht mit ., das ist aber nur eine Notationsfrage.
Es gibt also wie bei Zp* die nachweislich exponentiell langen Zyklen, bei der jedes Element der Menge erreicht wird.
Es liegt also nahe, das Diskrete Logarithmus Problem analog für EC's zu formulieren.
Diskreter Logarithmus Problem bei ECC
x = gy
DLP Problem:
fest: Primzahl p, Generator g von Zp*
INPUT:
x in Zp*
OUTPUT:
y > 0 so dass x = gy mod p
Zp *
g3 g2 g
P = yG
DL-ECC Problem:
fest: diskrete elliptische Kurve C, Generator G
INPUT:
P in C
OUTPUT:
y > 0 so dass P = yG
C
3G 2G
G
BitCoin Kurve
Bitcoin Kurve (Name: secp256k1)
Primzahl p:
p = 2256 – 232 – 29 – 28 – 27 – 26 – 24 – 1
= 115792089237316195423570985008687907853269984665640564039457584007908834671663
Kurvengleichung:
y2 = x3 +7
Generator G:
x = 79BE667E F9DCBBAC 55A06295 CE870B07 029BFCDB 2DCE28D9 59F2815B 16F81798
y = 483ADA77 26A3C465 5DA4FBFC 0E1108A8 FD17B448 A6855419 9C47D08F FB10D4B8
Ordnung von G = Länge des Zyklus = Anzahl der Elemente der Kurve: (ist eine Primzahl)
115792089237316195423570985008687907852837564279074904382605163141518161494337
ECC Verschlüsselung
R,c(m)
A
kpriv
B
r
kpub
Gegeben (fest und öffentlich): elliptische Kurve C und Generator G für C
Schlüsselpaarerzeugung durch A:
Privater Schlüssel: Bestimme ein kpriv zufällig aus {2, ... ,|C|-1}
Öffentlicher Schlüssel: kpub = kpriv G
kpriv ist ein Integer,
kpub ist ein Punkt.
Verschlüsselung durch B: wähle Zufallszahl r und berechne R = rG und S = rkpub .
Fasse S als symmetr. Schlüssel auf (z.B. AES) und verschlüssele damit die Nachricht m zu c(m).
Schicke (R,c(m)) an A.
Entschlüsselung durch A: Berechne kprivR = kprivrG = rkprivG = rkpub = S. Entschlüssele mit S die Nachricht m
Kryptologie
Bernd Borchert
Univ. Tübingen SS 2017
Vorlesung
Teil 13
Zertifikate, DLP: Shanks, Pohlig-Hellman
Zertifikate
Diffie-Helman Schlüsselvereinbarung zwischen Browser B und Webseite A
www.uni-tuebingen.de
a
Browser
ga
A
B
b
gb
Fatales Problem: Man-in-the-middle
a
A
ga
gm
M
m
gb
gm
B b
Spezielle (einseitige) Situation ist das Aufrufen einer Webseite: wie kann B
sicher sein, dass er tatsächlich auf der richtigen Webseite A ist?
Erste Lösung: Signatur durch Authority
Certification Authority
Problem: A muss jedesmal
CA bitten, zu signieren
(“Standleitung”)
CA
kCA,priv
kCA,pub
s = ek CA,priv(ga,www.uni-tuebingen.de)
a
ga, s
A
B
b
gb
a
A
ga
g
m
M
m
gb
g
m
geht schief
B b
B entschlüsselt mit
kCA,pub die Signatur s
Wenn alles stimmt, setzt
er den Schlüsselaustausch fort
Zweite Lösung: Zertifikat
Certification Authority
CA
kCA,priv
kCA,pub
certA = < kA,pub, www.uni-tuebingen.de, ek CA,priv(kA,pub,www.uni-tuebingen.de) , CA>
s = ek A,priv(ga)
g , s, certA
a
a
a
kAA,priv
A
B
b
gb
ga
g
m
M
m
gb
g
m
CA) und prüft dann mit
kA,pub die Signatur s.
Wenn alles stimmt, setzt
er den Schlüsselaustausch fort
B b
Ein Zerfikat ist die Signatur eines Paares <k pub,ID> eines Teilnehmers mit ID
in einer PKI durch eine CA.
B prüft ID und CASignatur in certA (bei
CA Hierarchie
CA-top
kCA-top,priv
kCA-top,pub
certCA1 = < kCA,pub, CA, ek CA-top,priv(kCA1,pub,CA) , CA-top>
CA
kCA,priv
zusätzlich
kCA,pub
certA = < kA,pub, www.uni-tuebingen.de, ek CA,priv(kA,pub,www.uni-tuebingen.de), certCA1>
s = ek A,priv(ga)
a
certA
kAA,priv
ga, s, certA
gb
B
b
B prüft certCA1 und certA
TLS
www.uni-tuebingen.de
a
Browser
ga
A
B
b
gb
TLS (“https”) besteht - aus Browsersicht - aus 3 Schritten.
1. Prüfe Zertifikat der Webseite (z.B. via ECC).
2. Vereinbare (z.B. via Diffie Helman) einen symmetrischen Schlüssel, aber nur
wenn dabei von der Webseite die Nachrichten signiert werden.
3. Verschlüssele/Entschlüssele ab da den Rest der Kommunikation mit dem
vereinbarten symmetrischen Schlüssel (z.B. AES).
DLP Algorithmen
Es folgen zwei Algorithmen für DLP: Giant-Step-Baby-Step und Pohlig-Helman
Baby-Step-Giant-Step Algorithmus
Baby-Step-Giant-Step Algorithmus zur Berechnung des Diskr. Logarithmus DL
Fest vorgegeben: Primzahl p, Generator g.
Problem: Gegeben x in Zp*, finde y mit gy = x mod p
Sei r = kleinste ganze Zahl größer als Quadratwurzel von p,
d.h., jedes y lässt sich darstellen als y = ryGiant + yBaby mit yGiant ,yBaby < r. (Eindeutigkeit unwesentlich)
Es gilt: gy = x mod p ↔ g
ry
+y
Giant
Baby
= x mod p ↔ g
ry
Giant
g
y
Baby
= x mod p ↔
y
g Baby = xg
-ry
Giant
Algorithmus. Finde y mit gy = x mod p
Schritt 1: Lege eine 2-spaltige DB an mit den Einträgen (in,out)
= (0,g0 mod p), (1,g1 mod p), (2,g2 mod p), …. ,(r-1,gr-1 mod p).
Lege einen Index an zum schnellen Suchen in der 2. Spalte out.
Schritt 2: Durchlaufe alle Möglichkeiten yGiant = 0, 1, …, r-1:
Berechne s = xg
-ry
Giant
mod p und prüfe, ob es einen DB-Eintrag (yBaby,s) gibt.
Wenn ja, RETURN y = ryGiant + yBaby;
Ansonsten gehe zum nächsten yGiant;
y
Korrektheit: Wenn Ausgabe ryGiant + yBabyerfolgt, dann g Baby = s = xg
-ry
Giant
mod p, also gy = x mod p.
Andererseits wird der Schritt 2 auch irgendwann den DL y erwischen, nämlich beim Durchlauf von y Giant.
Komplexität: Der Algorithmus reduziert die Laufzeit eines Exhaustive Search von p auf Wurzel p (was
erheblich ist), auf Kosten eines großen Speicherbedarfs.
Bem. Das ist wieder ein Meet-in-the-middle Algorithmus, so wie der für 2-DES.
Bem. Der Algorithmus wird auch nach seinem Erfinder Shanks Algorithmus genannt.
Bem. Der Algorithmus zum Finden des multiplikativen Faktors k beim DL-ECC Problem ist identisch!
mod p
Pohlig-Hellman Algorithmus
Pohlig-Helman Algorithmus zur Berechnung des Diskr. Logarithmus DL
Fest vorgegeben: Primzahl p, Generator g.
Problem: Gegeben x in Zp*, finde y mit gy = x mod p
Teilalgorithmus A (teilerfremde Faktoren)
Sei phi(p) = r.s mit r und s teilerfremd.
Berechne g0.s , g1.s , g2.s , ... , g(r-1).s mod p, solange bis ein gi.s = xs mod p gefunden ist.
Dieses i existiert, nämlich als i = y mod r, denn für y = i + z.r gilt
Euler/Fermat
xs = (g(i + z.r))s = g(i + z.r).s = gi.s . gz.r.s = gi.s . gz.phi(p) = gi.s mod p
Bekannt ist damit also i = y mod r.
Analog finden wir durch Ausprobieren von g0.r , g1.r , g2.r , ... , g(s-1).r mod p und
jeweils den Vergleich gj.r = xr mod p ? den Wert j = y mod s.
Damit sind die Voraussetzungen für CRT perfekt gegeben:
y ergibt sich als eindeutige Lösung modulo r.s (r und s teilerfremd), für die gilt i = y mod r und j = y mod s.
Es gilt dann: gy = x mod p
Pohlig-Hellman Algorithmus
Pohlig-Helman Algorithmus zur Berechnung des Diskr. Logarithmus
Fest vorgegeben: Primzahl p, Generator g.
Problem: Gegeben x in Zp*, finde y mit gy = x mod p
Teilalgorithmus B (Primzahlpotenzen)
Sei phi(p) = qh.s mit q (Primzahl) und s (“Restfaktor”) teilerfremd.
Gesucht ist die Zahl j = y mod qh.
Dafür schreiben wir fiktiv y = a0q0 + a1q1 + ... + ahqh mit 0 <= ai < q (ist eindeutig, wie z.B. Binärzahlen).
h-1.s
Zuerst wird a0 gefunden durch Ausprobieren/Berechnen von g0.q
h-1.s
solange bis ein gi.q
xq
h-1.s
h-1s
= (gy)q
= xq
= gy.q
h-1.s
h-1.s
xq
h-2.s
h-2s
= (gy)q
h-2.s
= xq
h-1.s
= g(a0 + a1q + ... + ah.q ).q
h
= gy.q
h-2.s
h-2.s
h-1.s
h-1.s
, g2.q
h-1.s
, ... , g(q-1).q
mod p,
Euler/Fermat
mod p gefunden ist. Dieses i existiert, nämlich i=a0:
= ga0.q
h-1.s
. g(a1q + ... + ah.qh).q
Mit a0 als bekannt, finde a1 durch Ausprobieren von g(a0 + 0.q).q
das i mit g(a0 + i).q
, g1.q
h-2.s
h-1.s
h-1.s
= ga0.q
h-2.s
, g(a0 + 1.q).q
h
. g(a1 + ... + ah.qh-1).q .s
h-2.s
, g(a0 + 2.q).q
mod p. Es ist i = a1 aus dem analogen Grund wie bei a0:
2 + ... + a .qh).qh-2.s
h
= g(a0 + a1q + a2q
h-2.s
= g(a0 + a1q).q
. g(a2 +
... + ah.qh-2).qh.s
, ... , g(a0 + (q-1).q).q
Euler/Fermat
= g(a0 + a1q).q
h-2.s
mod p
Mit a0 und a1 als bekannt, finde durch Ausprobieren von
h-3.s
g(a0 + a1q + 0.q ).q
2
, g(a0 + a1q + 1.q ).q
2
h-3.s
h-3.s
, ... , g(a0 + a1q + (q-1).q ).q
2
h-3.s
ein i ( = a2) mit g(a0 + a1q+ i.q ).q
2
h-3.s
= xq
Mache das h mal, d.h., bestimme alle a0,..., ah-1. Wegen y = a0q0 + a1q1 + ... + ah-1qh-1 + ahqh
gilt für j = a0q0 + a1q1 + ... + ah-1qh-1 , dass j = y mod qh. Diese Zahl j wurde gesucht.
h-1.s
= ga0q
mod p.
mod p
h-2.s
Pohlig-Hellman Algorithmus
Pohlig-Helman Algorithmus zur Berechnung des Diskr. Logarithmus
Fest vorgegeben: Primzahl p, Generator g.
Problem: Gegeben x in Zp*, finde y mit gy = x mod p
Gesamt-Algorithmus
Sei phi(p) = q1h1 . q2h2 . ... . qnhn die Primfaktorzerlegung von phi(p).
Bestimme für jede Primzahl qi das ji , so dass y = ji mod pihi
Diese n Gleichungen haben mit CRT eine eindeutige Lösung y, für die gilt: g y = x mod p.
Wenn phi(p) also in “kleine” Primfaktoren zerfällt, dann lässt sich DLP schnell lösen.
Beispiel: p = 2.3132 + 1
Konsequenz aus Pohlig-Helman:
Sophie-Germain Primzahlen p für DLP benutzen (p = 2q+1, mit q Primzahl. Beispiel p=47).
Kryptologie
Bernd Borchert
Univ. Tübingen SS 2017
Vorlesung
Teil 14
Faktorisierungsmethoden
Faktorisierungsmethoden
Kryptologie
•
Probedivision
•
ggT
•
Pollard rho Methode
•
Fermat Methode
•
Lucas Test
Probedivision
Gegeben n.
Dividiere n systematisch durch Zahlen oder besser Primzahlen.
Beispiel: Dividiere n durch 2, durch 3, durch 5, etc. bis zur Wurzel von n.
Faktorisierungsmethode ggT
Gegeben n.
Nimm eine Zahl m, die schon viele Teiler hat und berechne ggT(n,m).
Beispiel: Mit m = 2.3.5.7.11.13 = 30030 erhält man ggT(119,m) = 7 als
Teiler von 119.
rho
PollardPollard
rho Methode
Gegeben n.
Wähle zufällig a < n.
Setze x := a und y:= a.
Sei f(x) := x2 + 1.
Iteriere
x = f(x),
y = f(f(y)),
solange bis d = ggT(|y-x|,n) > 1.
Wenn d = n, dann nochmal mit neuem a. Andernfalls ist d ein echter Teiler von m.
Verifikation ist trivial: wenn d>1 dann ist d ein Teiler von n.
Komplexität: Wegen Geburtstagsparadoxon und realistischer Annahme, dass f sich wie eine Zufallsfolge
verhält und damit die Größe des Zyklus n1/2 ist, ist die erwartete Laufzeit von der Größenordnung n1/4
Geburtstagsparadoxon:
Wenn eine Eigenschaft von Objekten a gleichverteilte Ausprägungen hat, dann reichen 1,2a 1/2 Objekte, so dass die
Wahrscheinlichkeit, dass mindestens zwei davon die gleiche Ausprägung haben, > 50% ist.
Beispiel: bei 22 Menschen ist die Wahrscheinlichkeit, dass zwei am gleichen Tag Geburtstag haben, > 50%.
Bem.: Wenn die Ausprägung nicht gleichverteilt ist, dann reichen sogar weniger.
Das bedeutet, dass ein Algorithmus, der iteriert zwei Zahlen a,b rät und auf ggT(|a-b|,n) testet, erwartet nur 1,2 p 1/2
Iterationen braucht, um den Teiler p zu finden, im Vergleich zu dem Algorithmus, der iteriert eine Zahl a rät und
auf ggT(a,n) testet: der braucht erwartet p/2 Iterationen.
Die Pollard Konstruktion mit den zwei “Zeigern” x und y in dem rho ist nur dazu da, den Zufall des Ratens der 2 Zahlen
a,b auf Pseudozufall zu reduzieren (Pseudozufall ist weniger teuer/rechenintesiv als vom Betriebssystem generierter Zufall).
Beispiel Pollard rho
n = 187
a = 10
x
y
|y-x|
ggT(|y-x|,187)
10
10
-
-
101
104
3
1
104
94
10
1
158
61
97
1
94
138
44
11
48
61
169
138
158
48
f
94
f
f
f
158
f
f
Teiler gefunden
104
61
138
f
101
f
10
f
169
Fermat Methode
Grundidee: wegen
a2 – b2 = (a+b)(a-b)
würde es für eine Faktorisierung von n genügen, n als Differenz a 2 – b2 von zwei
Quadraten darzustellen, denn dann hätte man die zwei Faktoren (a+b) und (a-b).
Gegeben n. Suche die kleinste Ganzzahl a, die größer ist als die Wurzel von n. Prüfe,
ob a2 – n eine Quadratzahl ist.
Wenn nein, setze a := a+1 und prüfe, ob a2 – n eine Quadratzahl ist. Mache das solange,
bis a2 – n eine Quadratzahl ist oder a > n. Eine Optimierung besteht darin, anstatt (a+1)2
für den nächsten Schritt a2 + 2a + 1 zu berechnen.
Der Algorithmus ist vollständig: wenn ein Ergebnis a2 – n = b2 gefunden wird, sind
(a+b) und (a-b) Faktoren von n, wegen 3. binomische Formel a2 – b2 = (a+b)(a-b). Ist
umgekehrt n = cd mit c>d, dann wird bei a = (c-d)/2 die Faktorisierung gefunden.
Wenn n zu groß ist und die Faktoren weit voneinander entfernt sind, terminiert der
Algorithmus möglicherweise nicht. D.h. der Algorithmus eignet sich eigentlich nur
dann, wenn ein Faktor nicht weit von der Wurzel entfernt ist.
Im worst case (n prim) terminert der Algorithmus erst nach n minus Wurzel-n Schritten.
Beispiel. Gegeben n = 377. Wegen 192 = 361 und 202 = 400 ist 20 die kleinste Ganzzahl
größer als die Wurzel aus 377. 202 - 377 = 23, was keine Quadratzahl ist. Also gehen
wir zur nächsten Zahl 20 + 1 = 21:
212 - 377 = 441 – 377 = 64 = 82 . Also sind (21-8) = 13 und (21+8) = 19 Teiler von n.
Lucas Primzahltest
Lucas Primzahltest
n ist Primzahl gdw.
es gibt a < n, so dass an = 1 mod n und at != 1 mod n für alle maximalen Teiler t von n-1.
Beweis wie der ähnliche Satz für Primitivwurzeln, d.h. die Umkehrung von Euler's Satz.
Es gilt ebenso wie bei den Primtivwurzeln, dass ein solches a probabilistisch gesucht werden
kann, denn ein fester Anteil von solchen a unter alle Zahlen y< p ist garantiert.
Problem mit Lucas Primzahltest: man muss die Faktorisierung von n-1 kennen.
Und Faktorisierung ist schwieriger als Primzahl-Testen.
Beweis von Primality
Wie beweist man, dass eine Zahl n keine Primzahl ist? Indem man eine Zerlegung ab = n angibt.
Aber wie beweist man, dass eine Zahl n eine Primzahl ist?
Pratt/Lucas: Man gibt die Primzahlzerlegung von n-1 an, und einen “Zeugen” a, so dass a t
für die Maximalteiler t der Primzahlzerlegung ungleich 1 mod p ist.
Man bezeichnet das als ein “Pratt Zertifikat” der Primality von n.
Beispiel 11 ist Primzahl,
denn 10 = 2 * 5,
2
und 72 = 5 != 1 mod 11, und 75 = 7 * (72) = 7 * 3 = 21 != 1 mod 11
Die Primzahlzerlegung 11-1 = 2 x 5 und der Zeuge a=7 sind ein Beweis für die
Primalität von 11.
Achtung: für jede Primzahl der Primzahlzerlegung muss rekursiv ein Beweis der
Primality angegeben werden.
Beispiel: 85 ist keine Primzahl, aber die Zerlegung 84 =6*14 mit dem Zeugen a=4 wäre ein
Beweis für Primality von 85, wenn man nicht fordern würde, auch die Primality von 6 und 14
nachzuweisen. Denn 414 = 16 != 1 mod 85, und auch 46 = 16 != 1 mod 85.
Größenordnungen
Dezimaldarstellung vs. Binärdarstellung: wg. 210 = 1024 = ca. 103 gilt für die
Länge der Darstellung einer Zahl:
Länge Binärdarstellung/Länge Dezimaldarstellung = ca. 10/3, oder ganz grob:
3/1. Beispiel. 473930481 hat binär ca. die Länge 30.
Länge der Wurzel einer Zahl: halb so lang, plusminus 1.
Länge der Produkts von zwei Zahlen: Summe der Längen der beiden Zahlen,
plusminus 1.
1080 ist eine obere Schranke für die Anzahl der Teilchen im sichtbaren Weltall
(Eddington Zahl, 1923. Aktuelle Anerkennung unklar.)
1070 ist eine obere Schranke für die Anzahl der unterscheidbaren Zeitpunkte
vom Urknall bis nochmal so lange in der Zukunft. Deshalb kann kein
klassischer (getaktet und auf 0/1 basierender) Parallelcomputer mehr als 10 150 =
ca. 2500 Möglichkeiten testen, egal wie schnell Computer in der Zukunft noch
werden und wieviele Computer parallel wie lange an der vorgegebenen Aufgabe
rechnen.
Kryptologie
Bernd Borchert
Univ. Tübingen SS 2017
Vorlesung
Teil 15
Hashfunktionen
Hashfunktionen
Eine Hashfunktion bildet beliebig lange Wörter auf Wörter einer
bestimmten Länge ab. Dabei „vermischt“ sie möglichst gut die
Eingabe, d.h. Wörter, die sich nur wenig oder nur ein bit
unterscheiden, werden auf ganz verschiedene Wörter abgebildet. Auch
soll die Hashfunktion nur schwer rückrechenbar sein, d.h.
idealerweise kann man einen Urwert u eines Hashwerts h(u) nur so
errechnen, indem man systematisch alle existierenden Wörter w
daraufhin testet, ob h(w) = h(u).
Eine Hashfunktion hatten wir schon kennengelernt: AES im CBC Modus
mit dem letzten Block als Hashwert (Schlüssel fest). Die Länge dieser
Hashwerte ist also 128.
Es wurden schon viele Hashfunktionen entwickelt, nicht nur für
kryptologische Zwecke. Kryptologische Hashfunktionen sind
beispielsweise MD5, SHA, Tiger, und viele andere.
Achtung: Hashfunktionen wie hier definiert haben eine endlichen
Wertebereich. Davon zu unterscheiden sind die “kryptografischen
Hashfunktionen” mit unendlichem Wertebereich, siehe z.B. Hauck
Script.
Kollisionsresistenz
Hashfunktion h
{0,1}*
(alle bitstrings)
{0,1}s
(bitstrings der Länge s, z.B. s=160)
Einwegfunktions-Eigenschaft: Es ist praktisch unmöglich, zu einem gegebenen Ausgabewert einen
Eingabewert zu finden, der auf diesen Ausgabewert abgebildet wird.
Schwache Kollisionsresistenz: es ist praktisch unmöglich, für einen gegebenen Eingabewert einen davon
verschiedenen zu finden, der denselben Hashwert ergibt.
Starke Kollisionsresistenz: es ist praktisch unmöglich, zwei verschiedene Eingabewerte zu finden, die
denselben Hashwert ergeben.
stark kollisionsresistent → schwach kollisionsresistent
SHA1 Hashfunktion
SHA1 bildet jeden
bitstring (bis Länge 264)
(in Blöcken von 512
bits) auf einen 160 bit
langen bitstring ab.
Rechts der Pseudocode
(Quelle Wikipedia)
Motto: „wildes
iteriertes Shiften,
XORen und Addieren“
(genau das sollte man
von einem HashAlgorithmus erwarten)
// Initialisiere die Variablen:
var int h0 := 0x67452301
var int h1 := 0xEFCDAB89
var int h2 := 0x98BADCFE
var int h3 := 0x10325476
var int h4 := 0xC3D2E1F0
// Vorbereitung der Nachricht 'message':
var int message_laenge := bit_length(message)
erweitere message um bit "1"
erweitere message um bits "0" bis Länge von message in bits ≡ 448 (mod 512)
erweitere message um message_laenge als 64-Bit big-endian Integer
// Verarbeite die Nachricht in aufeinander folgenden 512-Bit-Blöcken:
für alle 512-Bit Block von message
unterteile Block in 16 32-bit big-endian Worte w(i), 0 ≤ i ≤ 15
// Erweitere die 16 32-Bit-Worte auf 80 32-Bit-Worte:
für alle i von 16 bis 79
w(i) := (w(i-3) xor w(i-8) xor w(i-14) xor w(i-16)) leftrotate 1
// Initialisiere den Hash-Wert für diesen Block:
var int a := h0
var int b := h1
var int c := h2
var int d := h3
var int e := h4
// Hauptschleife:
für alle i von 0 bis 79
wenn 0 ≤ i ≤ 19 dann
f := (b and c) or ((not b) and d)
k := 0x5A827999
sonst wenn 20 ≤ i ≤ 39 dann
f := b xor c xor d
k := 0x6ED9EBA1
sonst wenn 40 ≤ i ≤ 59 dann
f := (b and c) or (b and d) or (c and d)
k := 0x8F1BBCDC
sonst wenn 60 ≤ i ≤ 79 dann
f := b xor c xor d
k := 0xCA62C1D6
wenn_ende
temp := (a leftrotate 5) + f + e + k + w(i)
e := d
d := c
c := b leftrotate 30
b := a
a := temp
// Addiere den Hash-Wert des Blocks zur Summe der vorherigen Hashes:
h0 := h0 + a
h1 := h1 + b
h2 := h2 + c
h3 := h3 + d
h4 := h4 + e
digest = hash = h0 append h1 append h2 append h3 append h4 //(Darstellung als big-endian)
SHA1
SHA1: block-weise Verarbeitung
Input x
512 bits
160 bits
konstante
Werte
SHA1
Block
512 bits
SHA1
Block
Auffüllung mit
bits 1000...000 64 bits Länge
von x (binär)
512 bits
SHA1
Block
SHA1
Block
Output = h(x)
160 bits
Kryptologie
Bernd Borchert
Univ. Tübingen SS 2017
Vorlesung
Teil 16
Anwendungen Hashing
Anwendung Hashing: Gehashte Passwörter
Das Benutzername/Passwort Verfahren (Faktor Wissen) ist mit weitem Abstand das
gängigste Authentisierungsverfahren, insbesondere im Internet, aber auch in lokalen
Netzen.
Passwörter können bei der Übertragung abgehört werden, insbesondere bei der Eingabe
auf dem Endgerät (Keylogger) – dort ist praktisch keine Abwehr möglich (zumindest
nicht ohne einen weiteren Faktor Haben). Bei der Übertragung durch das Netz zum
Server schützt aber die Verschlüsselung der Sitzung (TLS/https, siehe
AbschnittZertifikate).
Um sich gegen Diebstahl der Identitäten (=Benutzername+Passwort) beim Server zu
schützen, werden die Passwörter beim Server fast überall gehasht abgespeichert
(Defintion hashen ein paar Folien später). So muss der Dieb der Passwort-Datei die
Passwörter zumindest ent-hashen, was bei guten Passwörtern (zufällig gewählt und
aktuell so ab Länge 10) schwer bis unmöglich ist. Für die Überprüfung des vom
Benutzer eingegebenen Passworts reicht dem Server die Speicherung des Hashwerts,
denn das aktuell empfangene Passwort wird gehasht und dann mit dem gespeicherten
Hashwert verglichen.
Um die Verwendung von Tabellen mit hash(Passwort)-->Passwort (sog. rainbow tables)
zu vemeiden, wird oft ein “Salz” s vor dem Hashen des Passworts hinzugefügt, also
z.B. hash(s|Passwort). Das Salz kann für alle User das gleiche sein, aber auch für
jeden User verschieden, z.B. der Benutzername. Ein wirksamer Schutz gegen das
Enthashen von zu kurzen/einfachen Passwörtern ist auch das Salz nicht.
Anwendung Hashing: Challenge/Response Verfahren
c
c
Login
r
r
Der Authentisierungs-Server produziert ein nur kurzfristig geltendes Zufallswort (challenge) und es schickt über
das Netz zum Endgerät, z.B Kartenlesegerät. Der Benutzer hält seine Karte an das Lesegerät. Die challenge
wird von der Karte gelesen und mit dem gespeicherten Schlüssel verschlüsselt. Der Output, auch response
genannt, wird an das Kartenlesegerät zurückgegeben, und dieses schickt die response an den Server. Der
Server, der auch den Schlüssel gespeichert hat, vergleicht die response mit seinem Verschlüsselsergebnis und
gibt bei Übereinstimmung den Zugang frei.
Der Schlüssel wird nicht preisgegeben, der Server kann aber dennoch eindeutig (bis auf die
Ratewahrscheinlichkeit, abhängig von der response-Länge) bestimmen, ob sich der Kartenbesitzer
authentisiert hat.
Das Verfahren ist auch mit assymmetrischen Schlüsseln möglich. Wegen der Rechenressourcen-Belastung sollte
aber vorzugsweise mit einer Hash-Funktion anstatt einer Verschlüsselungsfunktion gearbeitet werden: Die
Eingabe für die Berechnung des Hashwerts (=response) ist dabei eine Konkatenation kc des Schlüssels k und
der challenge c. Verschlüsselung statt Hashen ist over-engineered: die Entschlüsselbarkeit bringt nichts,
kostet aber meistens mehr Rechenressourcen, asymmetrische Verschlüsselung am meisten. Aber Vorteil
asymmetrische Verschlüsselung: Nachweisbarkeit des Authentisierungs-Vorgangs von Seite des Servers.
Anwendung Hashing: Pseudo-Random-Folge
Wie erzeugt man mit einer Hashfunktion h aus wenigen bits Zufall beliebig viele
bits Pseudozufall?
?
r
128 bits Zufall
Die folgende Konstruktion muss in jedem bit zufällig aussehen (ansonsten hat die
Hashfunktion h ein Problem):
praktisch beliebig lang
h(r,0)
h(r,1)
h(r,2)
h(r,0)
r
0
h(r,3)
h(r,1)
r
1
h(r,4)
alternativ:
h(r) h(r,h(r)) h(r,h(r,h(r))) …
falsch:
h(r) h(h(r)) h(h(h(r))) …
Signieren via Hashfunktion
Sei h eine Hashfunktion. Gegeben sei ein Sender A und Empfänger B, die eine gemeinsames
geheimes Wort k ausgetauscht haben. k wird auch hier oft Schlüssel genannt, auch wenn mit k gar
verschlüsselt werden wird („seed“ ist besserer Name dafür).
1. Der Sender berechnet den Hashwert h = h(kN) der Konkatention von k und der Nachricht N, und
schickt <N,h> an B.
k
A
<N,h(kN)>
B prüft beim Empfang die mitgeschickten Hashwert h dahingehend, ob h = h(kN).
Die Nachricht kann von Dritten praktisch nicht gefälscht werden.
B
k
HMAC
Symmetrische Signatur (MAC Message Authentication Code)
A
m, H(K|m)
K
B
K
- wenn K mit der Blocklänge der Hashfunktion H inferiert könnte es Probleme geben
- z.B. wenn H nicht das Ende der Eingabe absichert, könnte ein Angreifer
H(K|m|y) für jedes my berechnen
Auch wenn diese Probleme für z.B. H = SHA1 nicht direkt gegeben sind, macht man trotzdem
eine Absicherung mit folgender Grundidee: Anstatt H(K|m) als MAC nimm man
H(K|H(K|m)) (“HMAC”):
HMAC(K,m) = H(K'+opad| H(K'+ipad|m))
K' := K von links mit 0'en gepadded
opad ist die konstante Blockauffüllung 0x5c5c...5c
ipad ist die konstante Blockauffüllung 0x3636...36
+ ist EXOR
Das ist eine Art Standard,
auch für MACs mit SHA1.
Nachteil: 2 mal H ausführen
Online Banking: Signieren via Hashfunktion
Beispiel: Display-TAN der Univ. Tübingen
k
k
k
k
k
A
N = <nonce~Konto~Betrag>
A
1. Berechnung TAN' = h(kN)
2. Vergleich TAN = TAN' ?
TAN = h(kN)
B
B
k
Berechnung h(kN)
k
Es wird bei Display-TAN tatsächlich ein HMAC
mit SHA1 verwendet - der 160 bit Hashwert wird dann noch
deterministisch gekürzt auf 8 Ziffern (OCRA RFC-Standard).
Kryptologie
Bernd Borchert
Univ. Tübingen SS 2017
Vorlesung
Teil 17
Quantencomputer, Postquantum Kryptographie
Shor's Algorithmus (klassischer Teil)
Shor's Algorithmus zur Faktorisierung - Teilalgorithmus (der Teil ohne Physik)
Sei n = pq gegeben (p,q Primzahl).
Jedes des phi(n) Elemente a aus Zn* hat eine Ordnung ord(a), nämlich die Größe der Menge {a, a2, ..., aord(a)
= 1}.
ord(a) muss phi(n) = (p-1)(q-1) teilen, weil es eine Untergruppe ist.
Für 3/4 der a aus Zn* ist ord(a) gerade. Das kann man beweisen (Gruppentheorie) - man kann es sich
plausibel machen dadurch, dass 2 ja schon zweimal als Teiler von phi(n) vorkommt und somit für viele
Untergruppen ein Teiler ihrer Ordnung ist.
Für max. ¼ der a aus Zn* gilt, dass a gerade Ordnung r hat und dabei ar/2 = -1 gilt.
Insgesamt haben also mind 50% der Elemente a aus Zn* die Eigenschaft, dass die Ordnung von a gerade ist
und ar/2 != -1 gilt.
Wenn man zu so einem a die gerade Ordnung r = ord(a) bekommt, dann kann man
n = pq faktorisieren (3. Binomische Formel)
ar - 1 = (ar/2 - 1)(ar/2 + 1)
ungleich 0 mod n wg. Def. von r: dann wäre
ja schon bei r/2 ein Zyklus von a da
auch ungleich 0 mod n, denn solche a hatten wir
ausgeschlossen (nur ein ¼ aller a)
n ist Teiler von ar – 1 wegen ar = 1 mod n <--> ar - 1 = 0 mod n.
Weil aber beide Faktoren oben rechts ungleich 0 mod n sind, müssen die
Teiler p und q von n sich auf die beiden Faktoren oben rechts verteilen.
Damit kann man mit ggT(n, ar/2 – 1) (oder auch ggT(n, ar/2 + 1)) einen der zwei Primfaktoren finden.
a
ai mod 21
ord
gerade
ar/2 != -1=20
1
1
1
-
2
2, 4, 8, 16, 11, 1
6
+
+
+
3
-
4
4, 16, 1
3
-
-
-
5
5, 4, 20, 16, 17, 1
6
+
-
-
6
-
7
-
8
8,1
2
+
+
+
9
-
10
10, 12, 15, 13, 4, 19, 1 7
-
11
11, 16, 8, 4, 2, 1
6
+
+
+
12
-
(113 – 1)(113 +1)
= 7 * 9 (mod 21)
13
13, 1
2
+
+
+
14
-
(13 – 1)(13 +1)
= 12 *14
15
-
16
16, 4, 1
3
-
+
-
17
17, 16, 20, 4, 5, 1
6
+
-
-
18
-
19
19, 4, 13, 16, 10, 1
6
+
+
+
20
20,1
2
+
-
-
beides
-
-
Beispiel 21 = 3*7
(23 – 1)(23 +1)
=7*9
(81 – 1)(81 +1)
= 7 *9
(193 – 1)(193 +1)
= 12 *14 (mod 21)
Orakel Teilalgorithmus
Mit einem “Orakel”, das einem zu einem Zn* und einem a die Ordnung ord(a)
gäbe, wäre also der folgende probabilistische Algorithmus zur Faktorisierung
von n erfolgreich, jedesmal mit 50%:
Gegeben n= pq.
1. Rate ein a aus Zn;
2. Prüfe ob a in Zn* via ggT(a,n). Falls ggT > 1 ist Teiler gefunden --> fertig.
3. Lass Dir vom Orakel r = ord(a) geben
4. Wenn ord(a) nicht gerade ist oder ar/2 = -1, dann gehe zu 1 zurück
5. Ansonsten wird ggT(n,ar/2 -1) > 1 einen nicht-trivialen Teiler von n liefern.
Physiker-Idee: Das Orakel könnte ein sog. Quanten-Computer sein.
a
n
Qubits,
Q Circuits,
FourierTransform
ord(a)
Quantenrechner
a
r
Qubits,
Q Circuits,
FourierTransform
ord(r)
1) Initialize the registers.
This initial state is a superposition of Q states.
2) Construct f(r) as a quantum function and apply it to the above state
This is still a superposition of Q states.
3) Apply the quantum Fourier transform to the input register.
4) Perform measurements, and output with high probablity
Post-Quantum Kryptographie
Der Fortschritt bei den Quantencomputern ist bei genauer Betrachtung
eher bescheiden (vor allem in der Extrapolation ernüchternd):
1996 stellt P. Shor den Quantencomputer-Faktorisierungsalgorithmus vor
2001 verkündet IBM, man habe die Zahl 15 mit einem Quantencomputer faktorisiert
2012 verkündet die Univ. Bristol, man habe die Zahl 21 mit einem Quantencomputer faktorisiert
Deshalb/dennoch: Post-Quantum Kryptographie:
Symmetric key
Code-based cryptography
Lattice-based cryptography
Multivariate cryptography
und viele andere mehr
Hash-based cryptography
Auch/vor allem aus dem Grund: Faktorisierung
oder Diskr. Logarithmus könnte mathematisch
gelöst werden (“indischer Doktorand” mit
einer neuen Formel für die ganzen Zahlen...)
Basierend auf Schwierigkeit von math. Problemen, also so wie RSA,
DH etc.
Teilweise sind die math. Probleme NP-hart, was verdächtig ist, denn
bislang haben sich alle auf NP-harten Problemen basierenden Verfahren
als unbrauchbar erwiesen.
Hoffnungsträger, weil nicht auf math. Annahmen basierend.
Nachteile: 1. große Schlüssel mit dynamischer Verwaltung nötig.
2. nur Signieren und Authentisieren möglich, Verschlüsseln nicht.
Forward secrecy (als Eigenschaft eine Verschlüsselungsverfahrens):
Auch wenn das Verfahren gebrochen wird, können die verschlüsselten Nachrichten der Vergangenheit nicht
entschlüsselt werden.
Weak forward secrecy: Wenn das Verfahren gebrochen wird, können die verschlüsselten
Nachrichten aus der Vergangenheit nur dann entschlüsselt werden, wenn beim Versenden der
Nachricht schon aktiv/vorbereitend abgehört wurde.
Lamport One-Time PKI
Schlüsselerzeugung. A erzeugt 2n zufällige Strings s1,0,s1,1, s2,0,s2,1, …, sn,0, sn,1 - alle von einer gewissen
Länge l. Diese geordnete Liste (s1,0,s1,1, s2,0,s2,1, …, sn,0, sn,1) ist kpriv.
Mit einer Hash-Funktion h erzeugt A die 2n Hashwerte h1,0= h(s1,0),h1,1= h(s1,1), …, hn,1= h(sn,1), die alle
Strings einer Länge m sind. Diese geordnete Liste (h1,0,h1,1, h2,0,h2,1, …, hn,0, hn,1) ist kpub.
Alice
Bob
Kpriv
Kpub
B kann jetzt B einen Text a = a1...an der Länge n (die ai sind bits) an A schicken und sich von A signieren lassen.
Das macht A, indem er den string c = c1...cn der Länge n*m erzeugt, wobei der substring ci = si,ai ist (d.h., ci ist
entweder si,0 oder si,1 , je nachdem,ob ai 0 oder 1 ist).
B kann nachprüfen, ob die Signatur korrekt ist, denn er berechnet, ob für alle i gilt h(si,ai) = ci .
Niemand anders als A kann aber die h-Ur-Werte der ci gewusst oder berechnet haben. Also hat A die Nachricht
tatsächlich signiert. Die Signatur ist nicht abstreitbar.
Nachteile: 1. Nur Signatur und Authentication, aber keine Verschlüsselung möglich. 2. Wie beim One-Time-Pad ist
der Schlüssel nur einmal verwendbar → viel Speicherplatz für kpub
Vorteil: Dieses PKI baut nicht auf der Schwierigkeit eines mathematischen Problems
auf (und wäre damit ein Kandidat für den Ersatz für RSA etc. im Ernstfall “Postquantum Kryptographie”).
Merkle-Tree Signature
Lamport One-time Signature
kpub
kpriv
H1= h(P1)
H2 = h(P2)
P2
P1
H3 = h(P3)
P3
H1,2,3,4 = h(H1,2|H3,4)
H1,2 = h(H1|H2)
P1
P4
Vorteil gegenüber Lamport:
öffentl. Schlüssel kpub ist klein.
Merkle-Tree One-time Signature
H1= h(P1)
H4 = h(P4)
= kpub
H3,4 = h(H3|H4)
H2 = h(P2)
P2
H3 = h(P3)
P3
H4 = h(P4)
P4
= kpriv
Merkle-Tree Verfikation
H1,2,3,4 = h(H1,2|H3,4)
H1,2 = h(H1|H2)
H3,4 = h(H3|H4)
von rechts
von links
H1= h(P1)
P1
H2 = h(P2)
H3 = h(P3)
P2
P3
H4 = h(P4)
P4
Das bit “1” wird mit dem ersten Blatt-Paar signiert. Weil das bit 1 ist, wird das rechte Blatt P2
genommen.
(links/rechts ist ein flag, damit der Verifizierer weiß, von
Die Signatur ist: <P2, H1 links, H3,4 rechts>
welcher Seite dieser Hash-wert konkateniert werden muss)
Der Verfizierer prüft:
1. berechne H2 = h(P2)
2. berechne H1,2 = h(H1|H2)
3. berechne H1,2,3,4 = h(H1,2|H3,4)
4. wenn H1,2,3,4 = kpub, dann ist die Signatur in Ordnung.
Warum kann niemand anderes eine gültige Signatur schicken?
- niemand kann andere Werte als H1,2 und H3,4 angeben,
so dass kpub = H1,2,3,4 = h(H1,2|H3,4)
- niemand kann andere Werte als H1 und H2 angeben,
so dass H1,2 = h(H1|H2)
- niemand anderes als der, der den privaten Schlüssel hat,
kann ein P2 angeben, so dass h(P2) = H2 ist.
könnte aber abgehört
worden sein
kann nicht abgehört
worden sein – hier zum ersten
Mal veröffentlicht
Merkle-Tree mit pseudo-random Urwerten
Verbesserung Merkle-Tree One-time Signature.
H1,2,3,4 = h(H1,2|H3,4)
H1,2 = h(H1|H2)
H1= h(P1)
= kpub
H3,4 = h(H3|H4)
H2 = h(P2)
P1
P2
h
<s|0>
h
<s|1>
H3 = h(P3)
P3
H4 = h(P4)
P4
h
h
<s,2>
<s,3>
s = kurzes
Geheimnis
(“seed”)
Vorteil: Auch der private Schlüssel reduziert sich praktisch auf ein kurzes Geheimnis s.
Zwar muss am Anfang, d.h. zur Generierung des public key, der gesamte Baum aufgebaut
und durchgerechnet werden, aber ab dann kann man durch entsprechende Baum-Verwaltung
mit einem nur logarithmisch großen Teil des Baumes den Baum effektiv traversieren (nur ab
zu und muss wieder gerechnet werden, in der Summe noch einmal der ganze Baum)
Kryptologie
Bernd Borchert
Univ. Tübingen SS 2017
Vorlesung
Teil 18
Geheimnisteilungsschemata
Motivation
Geheimnisteilungsschemata
Geheimnisteilungsschema
Geheimnis
Schliessfach 652, PIN 290172
ASCII
11 ...............................01
Aufteilen in zwei
zufällige Strings
01 ...............................10
10 ...............................11
Keiner der beiden Strings hat eine Information. Nur beide zusammen:
11 ...............................01
ASCII
Schliessfach 652, PIN 290172
Beobachtung: Es würde reichen,
zu wissen, wie man das für ein
bit macht. Für Bit-Strings
macht man es dann bitweise.
Geheimnisteilungsschemata
Ein bit i (0 oder 1) Information sei gegeben. Es soll so in zwei Teilgeheimnisse A und B aufgeteilt werden, dass keins der
beiden Teilgeheimnisse allein etwas von der Information i preisgibt, aber beide zusammen i vollständig erschließen lassen.
Lösung: A bekommt ein bit a gleichverteilt zufällig (Münzwurf), und B bekommt b = a EXOR i.
1. Warum kann man mit A und B zusammen auf i schließen? i = a EXOR b,
denn a EXOR b = a EXOR a EXOR i = 0 EXOR i = i.
2. Warum kann man mit A allein nicht auf das Geheimnis i schließen? Weil a zufällig vergeben wurde und gar nichts über i
enthält.
3. Warum kann man mit B allein nicht auf das Geheimnis i schließen?
Folgende Argumentation ist die einfachste:
Sei i=0. Dann ist die Wahrscheinlichkeit, dass b=0 ist, 50%, denn die Wahrscheinlichkeit, dass a=0 ist, ist 50%.(b = a EXOR i)
Sei i=1. Dann ist die Wahrscheinlichkeit, dass b=0 ist, ebenfalls 50%, denn die Wahrscheinlichkeit, dass a=1 ist, ist 50%.
Also ist die Wahrscheinlichkeit, dass b=0 ist, in beiden möglichen Fällen 50% (unabhängig von i). Also ist b gleichverteilt
zufällig (so wie a). Also kann man mit b nicht auf i schließen. qed.
Verbindung/Ähnlichkeit zum one-time-pad: Es ist quasi die umgekehrte Richtung: Es wird beim Geheimnisteilungsschema
nicht b mit a zu i verschlüsselt, sondern es wird i in a und b zerlegt.
Entsprechend wird ein BitString a = a1...ak aus {0,1}k durch k unabhängige Münzwürfe in zwei Teilgeheimnisse (beides
bitstrings der Länge k) aufgeteilt, die jeweils keine Information über a preisgeben, aber die zusammen a vollständig
rekonstruieren lassen.
Dies sind 2-aus-2 Geheimnisteilungsschemata, als Spezialfall von m-aus-n Geheimnisteilungsschemata für m <= n. Definition
davon: Es gibt n Teilgeheimnisse, m-1 Teilgeheimnisse geben nichts über das Geheimnis preis, aber m Teilgeheimnisse lassen
das Geheimnis vollständig rekonstruieren.
n-aus-n Geheimnisteilungsschema
Ein bit b soll auf n Teilgeheimnisse verteilt werden:
Dazu reicht ein bit bi für jedes Teilgeheimnis:
n-1 Teilgeheimnisse b1, ..., bn-1 werden zufällig bestimmt. Das letzte Teilgeheimnis bnwird
als EXOR(b1, ..., bn-1, b) bestimmt.
Also kann b als EXOR(b1, ..., bn-1, bn) bestimmt werden, aber keine Teilmenge von n-1 oder
weniger Teilgeheimnissen reicht alleine aus. Beweis: wie für n=2.
Wörtern mit m bits können also für ein Geheimnisteilungsschema n-aus-n in n
Teilgeheimnisse mit je m bits aufgeteilt werden.
2-aus-n Geheimnisteilungsschema
Ein bit i soll auf 8 Teilgeheimnisse verteilt werden, so dass ein einzelnes Teilgeheimnis
keine Information hat, aber aus 2 Teilgeheimnissen das bit i zu rekonstruieren ist.
Dazu reichen 3 bits b1b2b3 für jedes Teilgeheimnis:
Wenn das bit i = 0 ist, wird eine 3-bit Sequenz b1b2b3 geraten und jeder der 8 Teilnehmer
bekommt das als Teilgeheimnis.
Wenn das bit i = 1 ist, werden die 8 3-stelligen bit-Folgen den 8 Teilnehmern gleichverteilt
zufällig zugeordnet.
Aus einen Teilgeheimnis b1b2b3 kann also keine Information über i gewonnen werden.
Aber aus 2 verschiedenen Teilgeheimnissen b1b2b3 und c1c2c3 kann man i rekonstruieren:
wenn sie gleich sind, dann ist i = 0, und ansonsten ist i = 1.
Wörtern mit m bits können also für ein Geheimnisteilungsschema 2-aus-2j in 2j
Teilgeheimnisse mit je j.m bits aufgeteilt werden.
Wenn n keine 2er-Potenz ist: Ein m-aus-n Geheimnisteilungsschema ist natürlich immer
auch ein m-aus-k Geheimnisteilungsschema für alle k mit k>= m und k < n, indem man n-k
Teilgeheimnisse „wegwirft“.
Shamir Geheimnisteilungsschema
Ein anderes Geheimnisteilungsschema ist das von Shamir
1979: Es nutzt das Phänomen, dass ein Polynom p(X) vom
Grad n erst durch n+1 Punkte (x,p(x)) vollständig bestimmt ist.
Mit anderen Worten: wenn n Punkte bekannt sind, ist das
Polynom bzw. dessen Koeffizienten noch unbestimmt.
Das Geheimnis ist also Polynom von Grad n bzw. ein gewisser
Koeffizient davon (z.B. der erste für x0) und die n+1
Teilgeheimnisse sind n+1 verschiedene Punkte (x,p(x)). n
dieser Punkte lassen noch nicht auf das Polynom bzw. dessen
Koeffizient schließen, nur alle n+1 zusammen.
Visuelle Kryptographie (2-aus-2 Schema)
Originalbild
v
1.Folie
Teilgeheimnis 1
(Zufall)
2. Folie
Teilgeheimnis 2
Rekonstruktion:
übereinanderlegen