Kryptographische Protokolle Lerneinheit 1: Zufallszahlengeneratoren Prof. Dr. Christoph Karg

Lerneinheit 1: Zufallszahlengeneratoren

Prof. Dr. Christoph Karg

Studiengang Informatik Hochschule Aalen

Sommersemester 2021

15.3.2021

Einleitung

Zufallszahlen spielen in der Kryptographie eine wichtige Rolle. Die Sicherheit vieler Verfahren (z.B. RSA) hängt von der Qualität der eingesetzten Zufallszahlengeneratoren ab.

Folgende Themen werden behandelt:

• Anforderungen an Zufallszahlengeneratoren

• Lineare-Kongruenzen Generator

• Blum-Blum-Shub Generator

• Fortuna Generator auf Basis von AES

Die Lerneinheit basiert auf Kapitel 8 von Stinson: Cryptography Theory and Practiceund Kapitel 10 von Ferguson, Schneier:

Unterscheidung

• Echte Zufallsdaten

▷ Zur Generierung werden physikalische Ereignisse z.B.

zeitliche Abstände zwischen Tastatureingaben gemessen.

▷ Die Erzeugung ist in der Regel aufwändig.

▷ Derartige Zufallsdaten nicht immer verfügbar.

• Pseudo Zufallsdaten

▷ Die Berechnung erfolgt mit einem (deterministischen) Algorithmus.

▷ Zufallsfolge hängt ausschließlich von einem Initialwert (Seed) ab.

▷ Voraussetzung: Die Seed muss geheim gehalten werden.

(k, ℓ)-bit Generator

Definition. Seien k, ℓ positive ganze Zahlen, so dass ℓ≥k+1.

Ein(k, ℓ)-bit Generatorist eine Funktion f:{0,1}^k 7→{0,1}^ℓ, die in Polynomialzeit berechenbar ist.

Die Eingabe s0 ∈{0,1}^k nennt man einen Seed, die Ausgabe f(s0) wird als erzeugte Bitfolge bezeichnet.

(k, ℓ)-bit Generator (Forts.)

Bemerkungen:

• Die erzeugte Bitfolge ist mindestens ein Bit länger als der Seed.

• Da f deterministisch ist, hängt die erzeugte Bitfolge ausschließlich vom Seed ab.

• Ziel: Konstruktion von (k, ℓ)-bit Generatoren, deren erzeugte Bitfolge zufällig aussieht. Einen derartigen Generator nennt man dann Pseudo-Random Bit Generator (PRBG).

Linearer Kongruenzgenerator

Definition (k, ℓ)-bit Linearer Kongruenzgenerator.

Seim≥2 eine ganze Zahl und seien a,bganze Zahlen mit 1≤a,b≤m−1.

Seik=dlog₂me und sei ℓ≥k+1 eine ganze Zahl.

Der Seed ist eine ganze Zahl s₀ ∈{0,1, . . . ,m−1}. Für i=1, . . . , ℓ ist s_i definiert als:

si = (a·si−1+b)mod m

Dieerzeugte Bitfolge ist f(s ) = (z ,z , . . . ,z), wobei z =s mod2.

Algorithmus LKG(a, b, m, s

)

LKG(a, b, m, s

)

Input: k-bit Zahl m, a,b ∈{1, . . . ,m}, s₀ ∈{0, . . . ,m−1} Output: ℓ-bit Folge (z1, . . . ,z_ℓ)

1 for i←1 to ℓ do

2 si ←(a·si−1+b)modm

3 zi ←si mod2

4 return (z1, . . . ,z_ℓ)

Beispiel Linearer Kongruenzgenerator

Konstruktion eines(5,10)-bit Generators:

Wählem=31, a =3, b=5. Die Zufallsbitfolge wird unter Einsatz der Funktion s7→(3s+5)mod31 berechnet.

Die interne Zufallsfolge durchläuft 2 Zyklen:

1. 0→5→20→3→14→16→22→9→1→8→29

→30→2→11→7→26→21→6→23→12→10

→4→17→25→18→28→27→24→15→19→0 2. 13→13

Der Wert 13 ist offensichtlich nicht als Seed geeignet.

Beispiel Linearer Kongruenzgenerator (Forts.)

Zufallsbitsvon Zyklus 1:

i si−1 si mod2

1 0 1

2 5 0

3 20 1

4 3 0

5 14 0

6 16 0

7 22 1

8 9 1

9 1 0

10 8 1

i si−1 si mod2

11 29 0

12 30 0

13 2 1

14 11 1

15 7 0

16 26 1

17 21 0

18 6 1

19 23 0

20 12 0

i si−1 si mod2

21 10 0

22 4 1

23 17 1

24 25 0

25 18 0

26 28 1

27 27 0

28 24 1

29 15 1

30 19 0

Beispiel Linearer Kongruenzgenerator (Forts.)

Seeds mit den jeweiligen erzeugten Bitfolgen:

Seed Bitfolge 0 1010001101 1 0100110101 2 1101010001 3 0001101001 4 1100101101 5 0100011010 6 1000110010 7 0101000110 8 1001101010 9 1010011010 10 0110010110 11 1010100011 12 0011001011 13 1111111111 14 0011010011

Seed Bitfolge 16 0110100110 17 1001011010 18 0101101010 19 0101000110 20 1000110100 21 0100011001 22 1101001101 23 0001100101 24 1101010001 25 0010110101 26 1010001100 27 0110101000 28 1011010100 29 0011010100 30 0110101000

Beispiel Linearer Kongruenzgenerator (Forts.)

Häufigkeit der Bitfolgen:

Bitfolge Seeds 1111111111 13 1010100011 11,15 0110101000 27,30 1100101101 4 1000110100 20 0001100101 23 1010011010 9 1010001100 26 1010001101 0 0100011010 5 1011010100 28 0110100110 16 0010110101 25 0101000110 7,19

Bitfolge Seeds 0011001011 12 1001011010 17 0110010110 10 0011010100 29 1000110010 6 0100011001 21 1101010001 2,24 1101001101 22 0101101010 18 0001101001 3 0011010011 14 1001101010 8 0100110101 1

RSA Generator

Der RSA Generator ist ein (k, ℓ)-Generator, der ist folgendermaßen aufgebaut ist:

Seien p, q zwei verschiedene(k/2)-bit Primzahlen.

Sein=p·q. Seie∈{2, . . . ϕ(n) −2} eine Zahl mitgcd(e, ϕ(n)) = 1.

Der Seed ist eine Zahl s0 ∈{2, . . . ,n−2}. Definiere s_i = s^e_i−1 mod n

zi = si mod2 für i=1, . . . , ℓund f(s₀) = (z₁, . . . ,z_ℓ).

Beispiel RSA Generator

Ziel ist die Konstruktion eines (32,48)-bit RSA Generators.

Hierzu werden die 16-bit Primzahlen p=49853 und q=50023 ausgewählt.

Die Werte von n undϕ(n) sind:

n = p·q=2493796619

ϕ(n) = (p−1)·(q−1) =2493696744

Als Exponent wird e=5 gewählt

Offensichtlich gilt gcd(e, ϕ(n)) = 1, denn 2493696744 ist kein Vielfaches von 5.

Beispiel RSA Generator (Forts.)

Bitfolge für den Seed s0 =133:

i si simod2

1 1715049989 1 2 125151210 0 3 111607254 0 4 1286485940 0 5 1757925661 1 6 1231273517 1 7 629651831 1 8 2110340527 1 9 2444573424 0 10 310341634 0 11 1044210194 0 12 2351172386 0

i si simod2

13 704525673 1 14 2217923578 0 15 1246194714 0 16 2268344913 1 17 1293816839 1 18 1142308995 1 19 640358470 0 20 2201746057 1 21 2247054200 0 22 214965552 0 23 1568366061 1 24 147756434 0

Beispiel RSA Generator (Forts.)

Bitfolge für den Seed s0 =133 (Teil 2):

i si simod2

25 1263833740 0 26 1212176274 0 27 2284028447 1 28 412716439 1 29 1291977567 1 30 1423793022 0 31 1432131289 1 32 1104879508 0 33 1285559980 0 34 1462305071 1 35 1982001190 0 36 1825221129 1

i si simod2

37 1061153640 0 38 1230173667 1 39 2475540485 1 40 1339296228 0 41 2371312881 1 42 1721175376 0 43 2128133478 0 44 115842642 0 45 545991434 0 46 1094191503 1 47 971577659 1 48 296897324 0

Anforderungen

Zwei Anforderungen an PRBGs:

• Sicherheit⇝ es ist mit vertretbarem Aufwand nicht möglich, eine erzeugte Bitfolge von einer echten Zufallsfolge zu unterscheiden.

• Geschwindigkeit ⇝ die Berechnung der Bitfolgen muss effizient durchführbar sein.

Wahrscheinlichkeitsverteilungen

Definition. Eine Wahrscheinlichkeitsverteilung über der Menge {0,1}^k ist eine Funktionµ :{0,1}^k 7→[0,1] mit

X

x∈{0,1}^k

µ(x) =1. Steht die Zufallsvariable Xfür das Ereignis

„Ziehen eines Worts aus {0,1}^k“, dann ist

Prob_µ[X=x] =µ(x)

die Wahrscheinlichkeit, dass das Wort x gezogen wird.

Gleichverteilung über { 0, 1 }

DieGleichverteilung µu über der Menge {0,1}^ℓ weist jedem Wort dieselbe Wahrscheinlichkeit zu.

Es gilt für alle x∈{0,1}^ℓ:

µu(x) = 1 2^ℓ

Bemerkung:Aus kryptographischer Sicht ist die Gleichverteilung eine ideale Wahrscheinlichkeitsverteilung.

Verteilung eines (k, ℓ)-bit Generators

Gegeben: (k, ℓ)-bit Generator f

Annahme: Der Seed wird unter Gleichverteilung aus{0,1}^k gezogen.

Ansatz: Sei x∈{0,1}^ℓ beliebig gewählt. Die Menge Seed(x) enthält alle Seeds, für die f die Bitfolge x erzeugt. Formal:

Seed(x) ={s∈{0,1}^k|f(s) =x}

Die Wahrscheinlichkeit, dass f das Wort x∈{0,1}^ℓ erzeugt, ist gleich µf(x) = X

s∈Seed(x)

µu(s) = kSeed(x)k 2^k .

Intuitive Idee

Gegeben: Wahrscheinlichkeitsverteilungen µ0 undµ1 über {0,1}^ℓ Frage: Gibt es einen Algorithmus DSTmit folgenden Eigenschaften?

• DST berechnet eine Funktion von {0,1}^ℓ nach {0,1}.

• DST hat polynomiale Laufzeit.

• Auf Eingabe eines Wortesx∈{0,1}^ℓ kannDST mit einer gewissen Chance korrekt entscheiden, obx gemäß µ0 oder µ1

erzeugt wurde.

ε-Unterscheidbarkeit

Definition. Seien µ0 und µ1 Wahrscheinlichkeitsverteilungen über der Menge {0,1}^ℓ. Sei DST:{0,1}^ℓ 7→{0,1} eine Funktion und ε >0.

Definiere füri =0,1 den Wert E_DST(µi) als E_DST(µi) = X

x∈{0,1}^ℓ:DST(x)=1

µi(x)

Die FunktionDST ist ein ε-Unterscheider vonµ0 und µ1, falls

|E_DST(µ0) −E_DST(µ1)|≥ε

Falls DSTin Polynomialzeit berechenbar ist, dann nennt man DST einen Polynomialzeitε-Unterscheider.

ε-Unterscheidbarkeit (Forts.)

Definition. Seien µ0 und µ1 Wahrscheinlichkeitsverteilungen über der Menge {0,1}^ℓ.

• µ0 und µ1 sindε-unterscheidbar, falls es einen ε-Unterscheider DST für µ0 und µ1 gibt.

• µ0 und µ1 sindin Polynomialzeit ε-unterscheidbar, falls es einen Polynomialzeit ε-Unterscheider DST für µ0 und µ1 gibt.

Anwendung von ε-Unterscheidbarkeit

Gegeben: (k, ℓ)-bit Generator f

Annahme: Jeder Seed erzeugt eine andere Bitfolge.

Für die ausf abgeleitete Wahrscheinlichkeitsverteilung µf gilt:

• Es gibt 2^k Wörter in {0,1}^ℓ, die jeweils mit Wahrscheinlichkeit ₂¹k

erzeugt werden.

• Es gibt 2^ℓ−2^k Wörter in {0,1}^ℓ, die nicht erzeugt werden.

Konsequenz: µf unterscheidet sich stark von der Gleichverteilung µu

über {0,1}^ℓ.

Anforderung:f gilt als kryptographisch sicherer PRBG, falls für alle ε >0 gilt, dass µf nicht ε-unterscheidbar von µu ist.

Zur Illustration ein Beispiel

Beispiel. Gegeben ist ein (k, ℓ)-bit Generator f, der ausschließlich Bitfolgen erzeugt, in denen die Anzahl Nullen gleich der Anzahl Einsen ist.

Definiere

DST(x1. . .x_ℓ) =

1(⇝µf) falls x₁. . .x_ℓ genau ₂^ℓ Nullen enthält 0(⇝µu) sonst

Zur Illustration ein Beispiel (Forts.)

Es gilt

E_DST[µu] =

ℓ ℓ/2

2^ℓ und

EDST[µf] =1 Wegen der Eigenschaft

ℓlim→∞

ℓ ℓ/2

2^ℓ =0

sind µu und µf für jedes ε, 0< ε <1, ε-unterscheidbar, falls ℓ hinreichend groß ist

Beispiel: Linearer Kongruenzgenerator

Gegeben ist ein (5,10)-bit Linearer Kongruenzgenerator mit den Parametern a=3,b=5 undm=31

Der Unterscheidungsalgorithmus basiert auf folgender Funktion:

DST(x₁. . .x_ℓ−1x_ℓ) =

1 falls xℓ−1 6=x_ℓ, 0 sonst.

DST ordnet demnach x1. . .x_ℓ dem Generator f zu, wenn die letzten beiden Bits verschieden sind.

Beispiel: Linearer Kongruenzgenerator (Forts.)

Bitfolgen x mit DST(x) =1:

Bitfolge Häufigkeit

1100101101 1

0001100101 1

1010011010 1

1010001101 1

0100011010 1

0110100110 1

0010110101 1

0101000110 2

1001011010 1

Bitfolge Häufigkeit

0110010110 1

1000110010 1

0100011001 1

1101010001 2

1101001101 1

0101101010 1

0001101001 1

1001101010 1

0100110101 1

Gesamthäufigkeit: 18

Beispiel: Linearer Kongruenzgenerator (Forts.)

Anhand der Tabelle berechnet man:

E_DST(µf) = X

x∈{0,1}^ℓ:DST(x)=1

µf(x) = 18 31

Wird ein ℓ-bit Wort zufällig unter Gleichverteilung gezogen, dann sind mit einer Wahrscheinlichkeit von ¹₂ die letzten beiden Bits

verschieden.

EDST(µu) = X

x∈{0,1}^ℓ:DST(x)=1

µu(x) = 1 2

Beispiel: Linearer Kongruenzgenerator (Forts.)

Hieraus folgt:

|E_DST(µf) −E_DST(µu)| = 18

31−1 2

= 36

62−31 62

= 5 62

Ergebnis: DSTist ein ₆₂⁵-Unterscheider für µf und µu.

Vorhersage des nächsten Bits

Frage: Ist es ohne Kenntnis des Seeds möglich, für einen (k, ℓ)-bit Generator vorherzusagen, welchen Wert das i-te Bit hat, wenn man die Bitsx1, . . . ,xi−1 kennt?

Antwort: Falls ja, dann ist der Generator nicht als sicher einzustufen.

Ziel: Formalisierung dieses Konzepts.

Definition Next Bit Predictor

Definition. Seif ein (k, ℓ)-bit Generator. Angenommen, 1≤i≤ℓ−1.

Die FunktionNBP:{0,1}ⁱ⁻¹ →{0,1} ist ein ε-Next Bit Predictor für Bit i, falls NBP auf Eingabe von x₁. . .x_i−1 das i-te Bit x_i korrekt berechnet mit einer Wahrscheinlichkeit von ¹₂ +ε, wobei ε >0.

Anpassung der Wahrscheinlichkeitsverteilungen

Seiµ eine Wahrscheinlichkeitsverteilung über {0,1}^ℓ. Sei i∈{0, . . . , ℓ}

fest gewählt.

Betrachte ein beliebiges Wort x₁. . .x_i ∈{0,1}ⁱ. Die Menge aller Wörter in{0,1}^ℓ mit Präfix x1. . .xi ist

Prefix(x₁. . .x_i) ={x₁. . .x_iw|w∈{0,1}^ℓ−i}

Die Wahrscheinlichkeit, dass ein Wort mit Präfix x1. . .xi auftritt, ist:

µⁱ(x₁. . .x_i) = X

z∈Prefix(x1...xi)

µ(z)

Ein wichtiger Satz

Betrachte einen(k, ℓ)-bit Generatorf.

Die Zufallsvariable Xi steht für den Wert des i-ten Bits einer Zufallsfolge, die gemäß µf auftritt.

Definiere für eine Funktion NBP:{0,1}ⁱ⁻¹ 7→{0,1}

pⁱ_NBP(x1. . .xi−1) =Prob[Xi =NBP(x1. . .xi−1)|x1. . .xi−1] Satz.Eine Funktion NBPist genau dann ein ε-Next Bit Predictor für Bit i von f, wenn

X

x1...xi−1∈{0,1}ⁱ⁻¹

µⁱ⁻¹_f (x1. . .xi−1)·pⁱ_NBP(x1. . .xi−1)≥ 1 2+ε

Beispiel: Linearer Kongruenzgenerator

Beispiel. Betrachte für ein i∈{1,2, . . . ,9} einenNBP, der folgende Funktion berechnet:

NBP(x₁. . .x_i−1) =1−x_i−1

Die Vorhersage ist also, dass auf eine 0 vermutlich eine 1 folgt, und umgekehrt.

Anwendungauf den linearen Kongruenzgenerator mit den Parametern a=3,b=5,m=31

Beispiel: Linearer Kongruenzgenerator (Forts.)

Analyseder Tabelle von Folie 10 für i=5:

x b=NBP(x) Seeds #Seeds

0010 1 25 1

0011 0 12,14,29 3

0100 1 1 1

0101 0 7,19 2

0110 1 16,27,30 3

1000 1 6,20 2

1001 0 17 1

1010 1 11,15 2

1011 0 28 1

1100 1 4 1

1101 0 2,22,24 3

Beispiel: Linearer Kongruenzgenerator (Forts.)

Die Wahrscheinlichkeit, dass NBP(x) das Biti =5 korrekt vorhersagt, ist:

20 31 = 40

62 = 31+9 62 = 1

2+ 9 62

Also ist NBP(x) ein ₆₂⁹ -Next Bit Predictor für das Biti=5 Durch Analyse der Tabelle von Folie 10 stellt man fest, dass diese Funktion für alle i ein ₆₂⁹ -Next Bit Predictor ist.

Zusammenhänge

Satz.Sei f ein (k, ℓ)-bit Generator. Angenommen, es gibt einen Polynomialzeit ε-Next Bit Predictor für ein Bit i∈{1, . . . , ℓ} vonf.

Dann sind µu und µf ε-unterscheidbar.

Satz.Sei f ein (k, ℓ)-bit Generator. Angenommen, µu und µf sind ε-unterscheidbar. Dann existiert für mindestens ein i∈{1, . . . , ℓ} ein Polynomialzeit ^ε_ℓ-Next Bit Predictor für Bit i vonf.

Definition Quadratischer Rest

Definition. Seip eine ungerade Primzahl. Die Zahl a∈Zp, a6=0, ist ein quadratischer Restmodulo p, falls eine Zahl x∈Zp existiert, so dass

x² ≡a (mod p)

Ist a kein quadratischer Rest, dann nennt mana quadratischen Nicht-Rest.

Beispiel zu Quadratischen Resten

Betrachte Z11.

a 1 2 3 4 5 6 7 8 9 10

a² 1 4 9 5 3 3 5 9 4 1

Also ist die Menge der quadratischen Reste modulo 11 gleich {1,3,4,5,9}.

Die Menge der quadratischen Nicht-Reste ist {2,6,7,8,10}.

Anzahl der Quadratwurzeln

Seip eine ungerade Primzahl und sei a ein quadratischer Rest modulo p.

Frage: Wieviele Lösungen hat die Gleichung x² ≡a (mod p)?

Seiy6=0 eine der Lösungen (eine solche muss existieren, da a ein quadratischer Rest ist).

Umformen:

x² ≡ a (mod p)

⇔ x²−a ≡ 0 (mod p)

⇔ (x+y)(x−y) ≡ 0 (mod p)

Anzahl der Quadratwurzeln (Forts.)

Zu zeigen bleibt, dassx≡ ±y (mod p) die beiden einzigen Lösungen sind.

Angenommen, es gibt einen weiteren quadratischen Rest z∈Zp mit z6≡ ±y (mod p).

Da p eine Primzahl ist, folgt wegen ZTK (Satz 5.2) aus (z+y)(z−y)≡0 (mod p), dass p|(z+y)oder p|(z−y)

Anzahl der Quadratwurzeln (Forts.)

Fall 1:p|(z+y). Also istz+y ein Vielfaches von p. Wegen der Wahl von zgilt:

0<z+y<2p−1

Also muss z+y=p und somitz=p−y gelten. Widerspruch!

Fall 2:p|(z−y). Analog zu Fall 1.

Ergebnis:

• Die Gleichungx² ≡a (mod p) besitzt genau zwei Lösungen

• Die eine Lösung ist die Negation der anderen modulo p

Euler Kriterium

Satz.Sei p eine ungerade Primzahl. Die Zahl a∈Zp ist genau dann ein quadratischer Rest, wenn

a^(p−1)/2 ≡1 (mod p)

Bemerkung:Mit dem Algorithmus zur modularen Exponentiation kann man effizient überprüfen, ob a ein quadratischer Rest modulo p ist.

Euler Kriterium (Forts.)

Beweis. Angenommen, x² ≡a (mod p) für ein x∈Zp. Unter Einsatz des Satzes von Fermat folgt:

a^(p−1)/2 ≡ (x²)^(p−1)/2 (mod p)

≡ x^p−1 (mod p)

≡ 1 (mod p)

Euler Kriterium (Forts.)

Angenommen, a^(p−1)/2 ≡1 (mod p). Sei b ein erzeugendes Element von Z^∗p. Dann existiert eini mit bⁱ≡a (mod p).

Es gilt:

a^(p−1)/2 ≡ (bⁱ)^(p−1)/2 (mod p)

≡ b^i(p−1)/2 (mod p)

≡ 1 (mod p)

Da b die Ordnung p−1 hat, muss (p−1)|(i(p−1)/2) gelten.

Folglich ist i eine gerade Zahl und deshalb sind ±b^i/2 modp die beiden Quadratwurzeln von a.

Legendre Symbol

Definition. Angenommen, p ist eine ungerade Primzahl. Für eine beliebige ganze Zahla ist das Legendre Symbol

a p

definiert als

a p

=







0 fallsa ≡0 (mod p)

1 fallsa quadratischer Rest modulop ist

−1 fallsa quadratischer Nicht-Rest modulop ist Satz.Sei p eine ungerade Primzahl. Dann gilt

a p

≡a^(p−1)/2 (mod p)

Quadratwurzeln von zusammengesetzten Zahlen

Definition. Sein eine beliebige ungerade ganze Zahl. Sei a eine ganze Zahl, die teilerfremd zu n ist, d.h.,gcd(a,n) =1. Falls es eine ganze Zahl ymit

y² ≡a (mod n)

gibt, dann nennt mana einenquadratischen Rest modulo n.

Andernfalls ist a ein quadratischer Nicht-Rest modulo n.

Zu klären:

• Welchea sind quadratische Reste modulo n?

• Wieviele Quadratwurzeln hat ein quadratischer Rest modulo n?

Primzahlpotenzen

Satz.Sei p eine ungerade Primzahl und seik eine ganze Zahl mit k>0. Sei a eine zu p teilerfremde Zahl, d.h., gcd(a,p) =1.

Angenommen, es existiert eine Zahlb∈Z^∗p, so dass b² ≡a (mod p^k−1).

Dann existiert genau ein x∈Zp^k mit:

(1) x² ≡ a (mod p^k) (2) x ≡ b (mod p^k−1)

Primzahlpotenzen (Forts.)

Beweis. Seip eine ungerade Primzahl und a ∈Z^∗p. Annahme: Es gibtb∈Z^∗p, so dassb² ≡a (mod p^k−1) Existenz von x:Laut Annahme ist

b² =j·p^k−1+a für eine ganze Zahl j.

Laut (2) muss x=i·p^k−1+b für eine ganze Zahl i sein.

Einsetzen in (1) führt zu folgender Gleichung:

(i·p^k−1+b)² ≡a (mod p^k)

Primzahlpotenzen (Forts.)

Umformen:

(i·p^k−1+b)² ≡ a (mod p^k)

⇔ (i·p^k−1)² +2·b·i·p^k−1+b² ≡ a (mod p^k)

⇔ 2·b·i·p^k−1+b² ≡ a (mod p^k)

⇔ 2·b·i·p^k−1+j·p^k−1+a ≡ a (mod p^k)

⇔ 2·b·i·p^k−1 ≡ −j·p^k−1 (mod p^k)

Primzahlpotenzen (Forts.)

Wegen ZTK (Korollar 6.3) folgt:

2·b·i·p^k−1 ≡ −j·p^k−1 (mod p^k)

⇔ 2·b·i ≡ −j (mod p)

⇔ i ≡ −j·(2·b)⁻¹ (mod p)

⇔ i·p^k−1 ≡ −j·(2·b)⁻¹p^k−1 (mod p^k) Also ist x= (−j·(2·b)⁻¹)·p^k−1+b eine Quadratwurzel von a modulo p^k

Primzahlpotenzen (Forts.)

Eindeutigkeit vonx: Angenommen, es gibt zwei verschiedene x₁ und x₂. die beide die Eigenschaften des Satzes erfüllen.

Wegen (2) gilt x1 =i1 ·p^k−1+b und x2 =i2·p^k−1+b für zwei verschiedene ganze Zahlen i₁ und i₂

Wegen (1) folgt:

x²₁ ≡ x²₂ (mod p^k)

⇔ (i1·p^k−1+b)² ≡ (i2·p^k−1+b)² (mod p^k)

⇔ 2·b·p^k−1·i₁ ≡ 2·b·p^k−1 ·i₂ (mod p^k)

⇔ 2·b·i₁ ≡ 2·b·i₂ (mod p)

i1 ≡ i2 (mod p)

Primzahlpotenzen (Forts.)

Satz.Sei p eine ungerade Primzahl, k>0 eine ganze Zahl und a eine ganze Zahl mitgcd(a,p^k) =1. Die Kongruenz y² ≡a (mod p^k) hat keine Lösungen, falls

a p

= −1, und genau zwei Lösungen, falls a

p

=1.

Beweis. Induktion überk und Verwendung des vorheriges Satzes

Zusammengesetzte Zahlen

Satz.Sei n>1 eine ungerade ganze Zahl mit der Primfaktorzerlegung

n= Yℓ

i=1

p^e_iⁱ. Angenommen, gcd(a,n) =1.

Falls

a pi

=1 für alle i={1, . . . , ℓ}gilt, dann besitzt die Kongruenz x² ≡a (mod n)

genau 2^ℓ Lösungen modulo n. Andernfalls besitzt die Kongruenz keine Lösung modulo n.

Zusammengesetzte Zahlen (Forts.)

Beweis. Betrachte eine ungerade ganze Zahln mit der Primfaktorzerlegung

n= Yℓ

i=1

p^ℓ_iⁱ.

Da gcd(p^e_iⁱ,p^e_j^j) =1 für alle i6=j gilt, folgt mit dem Chinesischen Restsatz (ZTK (Satz 9.1)), dass

y² ≡a (mod n) genau dann lösbar ist, wenn

y² ≡a (mod p^e_iⁱ) für allei =1, . . . , ℓ lösbar ist

Zusammengesetzte Zahlen (Forts.)

Laut dem vorherigen Satz ist y² ≡a (mod p^e_iⁱ) genau dann lösbar, wenn

a p_i

=1. In diesem Fall gibt es genau 2 Lösungen.

Angenommen, es ist

a pi

=1 für alle i=1, . . . , ℓ.

Es gibt 2^ℓ Möglichkeiten, die Teillösungen zu einer Lösung modulo n zu kombinieren. Folglich gibt es 2^ℓ Lösungen

Das Jacobi Symbol

Seien n>0 eine ungerade ganze Zahl mit der Primfaktorzerlegung n=

Yℓ i=1

p^e_iⁱ. Seia eine ganze Zahl. DasJacobi Symbol _n^a

ist definiert als a

n

= Yℓ

i=1

a p_i

e_i

Aufbau Blum-Blum-Shub Generator

Der Blum-Blum-Shub (BBS) Generator ist ein(k, ℓ)-Generator f, der wie folgt aufgebaut ist.

Seien p,q zwei verschiedene (k/2)-bit Primzahlen mit p≡q≡3 (mod 4). Definiere n=p·q.

Seis0 ein quadratischer Rest modulo n. Definiere si = s²_i−1 mod n z_i = s_i mod2 für allei =1, . . . , ℓ undf(s0) = (z1, . . . ,z_ℓ).

Beachte:Anstatt eines quadratischen Rests s₀ wählt man in der

∈Z^{∗ 2}

Beispiel: Blum-Blum-Shub Generator

Seip=383, q=503, n=p·q=192649 und s0 =101355² modn=20749.

Die ersten erzeugten 20 Bits sind:

i s_i z_i

0 20749 −

1 143135 1 2 177671 1 3 97048 0 4 89992 0 5 174051 1 6 80649 1

i s_i z_i 7 54663 1 8 69442 0 9 186894 0 10 177046 0 11 137922 0 12 123175 1

13 8630 0

i s_i z_i 14 114386 0 15 14863 1 16 133015 1 17 160065 1 18 45870 0 19 137171 1 20 48060 0

BBS Algorithmen

Initialisierung des Generators:

BBSInit(n

, s

)

Input: Modulninit, Seed sinit 1 n←ninit

2 s←s²_init modn

Berechnung des nächsten Bits:

BBSGetBit()

Output: Pseudo-zufälliges Bit

1 s←s² mod n return smod2

BBS Algorithmen (Forts.)

Berechnung des nächsten Bytes:

BBSGetByte()

Output: Pseudo-zufälliges Byte

1 b←0

2 for i←1 to 8do

3 b←2·b+BBSGetBit()

4 return b

Beobachtung

Seien p und q zwei verschiedene ungerade Primzahlen. Sein=p·q.

Für alle ganzen Zahlena 6=0 gilt:

a n

=















0 falls gcd(a,n)>1 1 falls

a p

= a

q

=1 oder

a p

= a

q

= −1

−1 falls ein Wert von

a p

und

a q

gleich 1 und der andere gleich −1 ist

Beachte: a ist ein quadratischer Rest modulo n falls a

p

= a

q

=1

Entscheidungsproblem QR

Problem Quadratic Residues (QR) Gegeben:

• Eine ganze Zahln, die das Produkt zweier ungerader Primzahlen p undq ist

• Eine ganze Zahl a∈Z^∗n mit ^a_n

=1 Gefragt: Ist a ein quadratischer Rest modulo n?

Bemerkungen:

• Bis heute ist kein Polynomialzeit Algorithmus für QR bekannt

• Kann mann effizient faktorisieren, dann ist QR ebenfalls effizient lösbar

Monte Carlo Algorithmen

EinMonte Carlo Algorithmus Aist ein Algorithmus mit folgenden Eigenschaften:

• Aberechnet eine Funktion f:{0,1}^∗ 7→{0,1}

• Ahat Zugriff auf einen Generator, der gleichverteilte Zufallsbits liefert

• Das von A berechnete Ergebnis ist korrekt mit einer Wahrscheinlichkeit von mindestens ¹₂ +ε für ein ε >0.

Formal: Für alle x∈{0,1}^∗ gilt:

Prob[A(x) =f(x)]≥ 1 2+ε DieFehlerwahrscheinlichkeit von Aauf Eingabe x ist

1

Monte Carlo Algorithmen (Forts.)

MajorityA(x, n)

Input: Wortx∈{0,1}^∗ Output: 0 oder 1

1 y←0

2 for i←1 to n do

3 if A(x) =1then

4 y←y+1

5 if y≥n/2then

6 return 1

7 else

8 return 0

Monte Carlo Algorithmen (Forts.)

Satz.Angenommen, Aist ein Monte Carlo Algorithmus mit einer Fehlerwahrscheinlichkeit von höchstens ¹₂ −ε. Sei n=2m+1 für eine ganze Zahl m>0.

Dann ist MajorityA(·,n) ein Monte Carlo Algorithmus mit einer Fehlerwahrscheinlichkeit von höchstens

(1−4ε²)^m 2

Monte Carlo Algorithmen (Forts.)

Beweis. Seix∈{0,1}^∗.

Die Wahrscheinlichkeit, dass A(x)exakt i-mal ein korrektes Ergebnis

liefert, ist

n i

1 2 +ε

i 1 2 −ε

n−i

Die Wahrscheinlichkeit, dass MajorityA(x,n) nicht korrekt ist, ist:

Prob[Fehler] ≤ Xm

i=0

n i

1 2 +ε

i 1 2−ε

2m+1−i

= #

Monte Carlo Algorithmen (Forts.)

# = 1

2 +ε m

1 2−ε

m+1Xm i=0

n i

1 2 −ε

1 2 +ε

^m−i

| {z }

≤1

= 1

2 +ε m

1 2−ε

m+1Xm i=0

n i

= 1

2 +ε m

1 2−ε

m+1

2^2m

= #

Monte Carlo Algorithmen (Forts.)

# =

1

2+ε 1 2 −ε

m 1 2 −ε

2^2m

= 1

4−ε² m

1 2−ε

2^2m

=

1−4ε² 4

m 1 2 −ε

4^m

= 1−4ε²m 1 2−ε

≤ (1−4ε²)^m 2

Monte Carlo Algorithmen (Forts.)

Anwendungdes Satzes: Angenommen, die Fehlerwahrscheinlichkeit von Asoll auf einen Wert 0< γ < ¹₂ −ε verkleinert werden.

Dann muss m so gewählt werden, dass (1−4ε²)^m

2 ≤γ

Hieraus folgt:

m=

1+log₂γ log₂(1−4ε²)

Sicherheit des BBS-Generators

Es gilt:

ein (k, ℓ)-bit BBS Generator ist ε-unterscheidbar von µu

⇓

es gibt einen (ε/ℓ)Previous Bit Predictor für den (k, ℓ)-bit BBS Generator

⇓

es gibt einen Monte Carlo Algorithmus für QR mit einer Fehlerwahrscheinlichkeit von höchstens ¹₂ −^ε_ℓ

⇓

es gibt einen Monte Carlo Algorithmus für QR mit einer Fehlerwahrscheinlichkeit von höchstens γ für alleγ > 0

Sicherheit des BBS-Generators (Forts.)

Vermutung: Es existiert kein Monte Carlo Algorithmus für QR mit einer Fehlerwahrscheinlichkeit von höchstensγ für alle γ >0.

Konsequenz: Ein (k, ℓ)-bit BBS Generator ist nichtε-unterscheidbar von der Gleichverteilung für alle ε >0.

Sicherheitsanforderung: Die Primzahlen p und q sowie der Seed müssen geheim gehalten werden.

Bemerkung: Der BBS-Generator ist selbst dann noch sicher, wenn log₂log₂kBits in einem Schleifendurchlauf abgreift.

Fortuna Pseudo Random Number Generator

• Entwicklung von Niels Ferguson und Bruce Schneier

• Weiterentwicklung des Yarrow PRNG

• Prinzip: Block Chiffre im Counter Mode

• Interner Zustand:

▷ 256 bit Schlüssel einer Blockchiffre

▷ 128 bit Zähler

• Fortuna erzeugt beliebig lange Byte Folgen

• Einsatz von AES und SHA-256 zur Verarbeitung des internen Zustands

• Ebenfalls geeignet: Serpent und Twofish

Eigenschaften

• Um zu verhindern, dass ein Angreifer anhand des internen Zustands Informationen über bereits erzeugte Byte-Folgen erlangen kann, wird der Schlüssel nach jeder Erzeugung gewechselt.

• Um zu garantieren, dass die erzeugte Byte-Folge statistisch zufällig aussieht, wird die Anzahl Bytes, die in einem Aufruf erzeugt werden können, auf 2²⁰=1048576 beschränkt.

• Regelmässiges Reseeding verhindert, dass ein Angreifer anhand des internen Zustands zukünftige Byte-Folgen berechnen kann.

Counter Mode

Aufgabe: Erzeugen eines Bitstroms unter Einsatz einer Blockchiffre Gegeben: Block Chiffre E, Schlüssel k, Klartext x1, . . . ,x_ℓ bestehend aus ℓ Blöcken, Initialisierungswert n

Verschlüsselung: Zwei Schritte: Für i=1, . . . , ℓ:

1. Berechne Blockschlüssel k_i =E(k,n||i) 2. Berechne Geheimtextblock y_i =x_i⊕k_i Ergebnis: Geheimtexty₁, . . . ,y_ℓ

Bemerkungen zum Counter Mode

• Die Wortlänge vonn und i orientiert sich an der Blocklänge des Kryptosystems E.

• Ist die Anzahl der zu verschlüssenden Blöcke nicht bekannt, dann wird i als interner Zähler implementiert, der nach jeder Verschlüsselung inkrementiert wird.

• Die Kombination aus Schlüssel kund Initialwert Noncedarf nur einmal benutzt werden.

• Die Laufzeit des Counter Modes hängt im Wesentlichen von der eingesetzten BlockchiffreE ab.

Aufbau des Initialisierungswerts

Beispiel. Block Chiffre mit einer Blocklänge von 128 Bit Parameterwahl für den CTR Mode:

• Initialisierungswert, zusammengesetzt aus:

▷ Message ID (48 bit) ⇝Vergabe anhand der zu übertragenden Nachricht

▷ Nonce (16 bit) ⇝einmal zu verwendendes Wort

• Counter (64 bit) Ergebnis:

• Pro Schlüssel können 2⁴⁸ verschiedene Nachrichten verschlüsselt werden.

• Die Länge einer Nachricht ist beschränkt auf höchstens 2⁶⁴ Byte.

Interner Zustand von Fortuna

Fortunabesitzt einen internen Zustand bestehend aus:

• Schlüssel key(256 bit)

• Zähler cntr (128 bit)

Der Zähler cntrwird entweder als Byte Array oder als natürliche Zahl in Least Significant Byte First (LSBF) Darstellung interpretiert.

Istcntr in dem Byte-Block p0, . . . ,p15 abgespeichert, dann berechnet man die zugehörige Zahl als

cntr= X15

i=0

pi·2⁸ⁱ.

Initialisierung

InitializeGenerator()

Output: G= (key,cntr) Initialwerte für Schlüssel und Zähler

1 key←0

2 cntr←0

3 G←(key,cntr)

4 return G

Beachte: Nach der Initialisierung ist der PRNG nicht einsatzbereit.

Reseeding

Reseed( G , s)

Input: Interner ZustandG= (key,cntr), Seed s

1 key←SHA-256(key||s)

2 cntr←cntr+1

Beachte: Der interne Zustand wird während des Reseedings verändert.

Generierung von 16-Byte-Blöcken

GenerateBlocks( G , k)

Input: Interner ZustandG= (key,cntr), Anzahlk der zu generierenden Blöcke Output: r Pseudo-Zufallsfolge mit 16k Bytes

1 if cntr =0 then

2 error „PRNG wurde nicht korrekt initialisiert.“

3 r←ε

4 for i←1 to k do

5 r :=r||AES(key,cntr)

6 cntr←cntr+1

7 return r

Beachte: Der interne Zustand wird während der Generierung verändert.

Generierung von beliebigen Byte-Folgen

PseudoRandomData( G , n)

Input: Interner ZustandG= (key,cntr), Anzahln der zu generierenden Bytes Output: Pseudo-Zufallsfolge r mit n Bytes

1 if n<0or n>2²⁰ then

2 error „Inkorrekte Länge.“

3 b←GenerateBlocks(G,_n

16

)

4 r← erste nBytes von b

5 key:=GenerateBlocks(G,2)

6 return r

Bemerkungen zu PseudoRandomData()

• Die Länge der erzeugten Byte-Folge wird beschränkt, um

statistische Abweichungen zu echten Zufallsfolgen zu vermeiden.

• Der Schlüssel wird erneuert, um zu verhindern, dass man die erzeugte Zufallsfolge rekonstruieren kann.

• Um ein Datenleck zu verhindern, sollte die Implementierung

▷ keine Kopie vonr zwischenspeichern und

▷ den fürb und r benutzten Speicher überschreiben.

• Eine Folge mit mehr als 2²⁰ Bytes kann durch wiederholtes Ausführen vonPseudoRandomData() erzeugt werden.

Akkumulator

Aufgabe: Sammeln von echten Zufallsdaten, die zum Reseeding eingesetzt werden

Idee: Je mehr Quellen beim Reseeding berücksichtigt werden, desto geringer ist die Chance, dass ein Angreifer den neuen Seed berechnen kann.

Umsetzung: Der Akkumulator wird in den Generator integriert.

MöglicheZufallsquellen:

• Dauer von Tastaturklicks

• Mausbewegungen und -klicks

• Zugriffszeit einer Festplatte

Zufallsquellen und Random Pools

Eigenschafteneiner Zufallsquelle:

• Jede Quelle erhält eine eindeutige Nummer aus {0, . . . ,255}.

• Eine Quelle liefert als Event eine kleine Anzahl echt zufälliger Bytes zurück.

• Es besteht die Möglichkeit, mehrere Events zu einer längeren Byte-Folge zu konkatenieren.

Random Pools

• Es gibt 32 Pools, die mit P0,P1, . . . ,P31 bezeichnet werden.

• Jeder Pool liefert eine Byte-Folge unbeschränkter Länge.

• Diese Folge wird durch wiederholte Anwendung einer kryptographischen Hashfunktion berechnet.

Ablauf des Reseedings

• Die Daten einer Quelle werden zyklisch über alle Pools verteilt.

• Bei Zuteilung einer Quelle an den Pool Pi wird der Event an die Daten vonPi angehängt.

• Das Reseeding wird durchgeführt, wennP0 genügend Daten vorrätig hat.

• Die Reseedings werden mitr=1,2,3, . . . durchnummeriert.

• Pool Pi wird beim Reseeding rberücksichtigt, wenn 2ⁱ ein Teiler vonr ist.

• Konsequenz: P0 wird immer benutzt, P1 wird jedes zweite Mal benutzt, P₂ wird jedes vierte Mal benutzt, usw..

• Wird ein Pool P_i zum Reseeding benutzt, dann werden

Sicherheitsbetrachtung

Angriffspunkte:

• Der Angreifer hat Zugriff auf mehrere (aber nicht alle) Pools.

• Der Angreifer kann selbst gefälschte Events einschleusen.

Ansatz:

• Da der Pool Pi nur jedes 2ⁱ-te Mal benutzt wird, um so mehr Daten hält er vor.

• Falls es eine Zufallsquelle gibt, die der Angreifer nicht kennt, dann gibt es immer einen Pool, der genügend Daten sammelt, die gegen einen Angriff resistent sind.

• Das System erholt sich von einer Kompromittierung innerhalb von einer kurzen Zeit von selbst.

Initialisierung

InitializePRNG()

Output: Interner Zustand R

1 for i←0 to 31do

2 Pi ←ε

3 reseed_cntr ←0

4 G←InitializeGenerator()

5 R←(G,reseed_cntr,P₀, . . . ,P₃₁)

6 return R

Generierung von Byte-Folgen

RandomData( R , n)

Input: Interner ZustandR= (G,reseed_cntr,P0, . . . ,P31) Anzahln der zu generierenden Bytes

Output: Pseudo-Zufallsfolge mit n Bytes

1 if length(P₀)≥min_pool_sizeand last reseed>100ms then

2 reseed_cntr←reseed_cntr+1

3 s←ε

4 for i∈{0,1, . . . ,31} do

5 if 2ⁱ|reseed_cntr then

6 s←s||SHA-256(Pi)

7 Pi ←ε

8 Reseed(G,s)

9 return PseudoRandomData(G,n)

Hinzufügen eines Events

AddRandomEvent(R,s,i,e) Input: Interner ZustandR,

Nummer der Quelle s∈{0,1, . . . ,255}, Nummer des Poolsi ∈{0,1, . . . ,31},

Daten des Eventse (Folge von höchstens 32 Bytes)

1 if 1≤length(e)≤32and 0≤s≤255 and0≤i≤31 then

2 P_i ←P_i||s||length(e)||e

3 else

4 error „Fehlerhafte Parameter“

Anlegen einer Seed Datei

Problem:Nach dem Booten des Rechners ist der PRNG nicht in der Lage, gute Zufallszahlen zu erzeugen, da zu wenige Events vorliegen.

Vorschlag:

• Abwarten, bis sich der Pool gefüllt hat.

• Auslesen eines guten Seeds aus einer Datei, die beim Herunterfahren des Rechners gespeichert wurde.

Sicherheitsvorkehrungen: Der Inhalt der Seed Datei

• muss geheim gehalten werden und

• darf nur einmal benutzt werden.

Lesen und Schreiben der Seed Datei

WriteSeedFile( R , f)

Input: Interner ZustandR, Datei Handle f

1 write RandomData(G,64) to f

UpdateSeedFile( R , f)

Input: Interner ZustandR, Datei Handle f

1 read f to s

2 if length(s)<64then

3 error „Zu wenig Daten für Reseed“

4 Reseed(G,s)

write RandomData(G 64) to f

Bemerkungen zu Seed Dateien

• Die Seed Datei sollte bei Start des Systems gelesen werden.

• Beim Herunterfahren des Rechners muss ein Update der Seed Datei erfolgen.k

• Es empfiehlt sich, die Seed Datei regelmäßig zu aktualisieren.

• Vorsicht ist beim Backup eines Systems geboten, da man damit die Seed Datei wieder herstellen kann.

• Eine weitere Gefahr besteht darin, dass in der Regel die Daten nicht sofort auf die Festplatte geschrieben werden. Dies kann zu Inkonsistenzen führen.

• Bei der Installation eines Computers muss darauf geachtet werden, dass die Seed Datei beim ersten Reboot nicht benutzt wird oder dass eine geeignete Datei erstellt wird.

Hinweise zur Arbeit mit PRNGs

• Die PRNGs von Programmiersprachen und Betriebssystemen erfüllen in der Regel nicht die Anforderungen an einen kryptographisch sicheren Pseudo-Zufallszahlengenerator.

• Gute Quellen mit hoher Entropie sind oft schwer zu finden.

Daher sollten möglichst viele Quellen angezapft werden. Fortuna ist gegen schlechte Quellen immun.

• Der Einsatz von Seed Dateien ist einfach zu verstehen, aber schwierig zu implementieren. In der Regel sind Eingriffe in das Betriebssystem und sogar in die Firmware der Komponenten notwendig, um die Implementierung sicher zu gestalten.

Generierung von gleichverteilten Zahlen

Aufgabe: Generiere unter Gleichverteilung eine Zahl

x∈{0,1, . . . ,n−1}, wobei n eine natürliche Zahl und keine Zweierpotenz ist.

Ansatz 1: Generiere zufällig eine Zahl y∈{0,1, . . . ,2^⌈log2n⌉−1}und berechnex=ymodn

Ergebnis: die resultierende Verteilung ist keine Gleichverteilung und somit nicht sicher.

Ansatz 2: Generiere solange zufällig eine Zahl x∈{0,1, . . . ,2^⌈log2n⌉−1}, bis x∈{0,1, . . . ,n−1}

Ergebnis: Die resultierende Verteilung ist eine Gleichverteilung, aber es sind gelegentlich mehrere Versuche notwendig, bis eine Zufallszahl vorliegt.

Zusammenfassung

• Die Kryptographie stellt hohe Anforderungen an Pseudo-Zufallszahlengeneratoren.

• Der Blum-Blum-Shub Generator gilt als der sicherste PRNG.

• Fortuna ist ein PRNG, der auf AES im Counter Mode basiert.

• Zufallsquellen mit hoher Entropie verbessern die Qualität der Zufallszahlen von Fortuna.

• Für weitere Informationen zum Thema Zufallszahlen empfiehlt sich RFC 4086 (Randomness Requirements for Security) der Internet Engineering Task Force (IETF).